sys/nfsserver/nfs_srvsock.c

   1 /*-
   2  * Copyright (c) 1989, 1991, 1993, 1995
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * This code is derived from software contributed to Berkeley by
   6  * Rick Macklem at The University of Guelph.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 4. Neither the name of the University nor the names of its contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  *
  32  *      @(#)nfs_socket.c        8.5 (Berkeley) 3/30/95
  33  */
  34
  35 #include <sys/cdefs.h>
  36 __FBSDID("$FreeBSD$");
  37
  38 /*
  39  * Socket operations for use by nfs
  40  */
  41
  42 #include "opt_mac.h"
  43
  44 #include <sys/param.h>
  45 #include <sys/systm.h>
  46 #include <sys/kernel.h>
  47 #include <sys/lock.h>
  48 #include <sys/malloc.h>
  49 #include <sys/mbuf.h>
  50 #include <sys/mount.h>
  51 #include <sys/mutex.h>
  52 #include <sys/proc.h>
  53 #include <sys/protosw.h>
  54 #include <sys/refcount.h>
  55 #include <sys/signalvar.h>
  56 #include <sys/socket.h>
  57 #include <sys/socketvar.h>
  58 #include <sys/sysctl.h>
  59 #include <sys/syslog.h>
  60 #include <sys/vnode.h>
  61
  62 #include <netinet/in.h>
  63 #include <netinet/tcp.h>
  64
  65 #include <nfs/rpcv2.h>
  66 #include <nfs/nfsproto.h>
  67 #include <nfsserver/nfs.h>
  68 #include <nfs/xdr_subs.h>
  69 #include <nfsserver/nfsm_subs.h>
  70
  71 #include <security/mac/mac_framework.h>
  72
  73 #ifdef NFS_LEGACYRPC
  74
  75 #define TRUE    1
  76 #define FALSE   0
  77
  78 static int nfs_realign_test;
  79 static int nfs_realign_count;
  80
  81 SYSCTL_DECL(_vfs_nfsrv);
  82
  83 SYSCTL_INT(_vfs_nfsrv, OID_AUTO, realign_test, CTLFLAG_RW, &nfs_realign_test, 0, "");
  84 SYSCTL_INT(_vfs_nfsrv, OID_AUTO, realign_count, CTLFLAG_RW, &nfs_realign_count, 0, "");
  85
  86
  87 /*
  88  * There is a congestion window for outstanding rpcs maintained per mount
  89  * point. The cwnd size is adjusted in roughly the way that:
  90  * Van Jacobson, Congestion avoidance and Control, In "Proceedings of
  91  * SIGCOMM '88". ACM, August 1988.
  92  * describes for TCP. The cwnd size is chopped in half on a retransmit timeout
  93  * and incremented by 1/cwnd when each rpc reply is received and a full cwnd
  94  * of rpcs is in progress.
  95  * (The sent count and cwnd are scaled for integer arith.)
  96  * Variants of "slow start" were tried and were found to be too much of a
  97  * performance hit (ave. rtt 3 times larger),
  98  * I suspect due to the large rtt that nfs rpcs have.
  99  */
 100 #define NFS_CWNDSCALE   256
 101 #define NFS_MAXCWND     (NFS_CWNDSCALE * 32)
 102 struct callout  nfsrv_callout;
 103
 104 static void     nfs_realign(struct mbuf **pm, int hsiz);        /* XXX SHARED */
 105 static int      nfsrv_getstream(struct nfssvc_sock *, int);
 106
 107 int32_t (*nfsrv3_procs[NFS_NPROCS])(struct nfsrv_descript *nd,
 108                                 struct nfssvc_sock *slp,
 109                                 struct mbuf **mreqp) = {
 110         nfsrv_null,
 111         nfsrv_getattr,
 112         nfsrv_setattr,
 113         nfsrv_lookup,
 114         nfsrv3_access,
 115         nfsrv_readlink,
 116         nfsrv_read,
 117         nfsrv_write,
 118         nfsrv_create,
 119         nfsrv_mkdir,
 120         nfsrv_symlink,
 121         nfsrv_mknod,
 122         nfsrv_remove,
 123         nfsrv_rmdir,
 124         nfsrv_rename,
 125         nfsrv_link,
 126         nfsrv_readdir,
 127         nfsrv_readdirplus,
 128         nfsrv_statfs,
 129         nfsrv_fsinfo,
 130         nfsrv_pathconf,
 131         nfsrv_commit,
 132         nfsrv_noop
 133 };
 134
 135
 136 /*
 137  * Generate the rpc reply header
 138  * siz arg. is used to decide if adding a cluster is worthwhile
 139  */
 140 struct mbuf *
 141 nfs_rephead(int siz, struct nfsrv_descript *nd, int err,
 142     struct mbuf **mbp, caddr_t *bposp)
 143 {
 144         u_int32_t *tl;
 145         struct mbuf *mreq;
 146         caddr_t bpos;
 147         struct mbuf *mb;
 148
 149         nd->nd_repstat = err;
 150         if (err && (nd->nd_flag & ND_NFSV3) == 0)       /* XXX recheck */
 151                 siz = 0;
 152         MGETHDR(mreq, M_WAIT, MT_DATA);
 153         mb = mreq;
 154         /*
 155          * If this is a big reply, use a cluster else
 156          * try and leave leading space for the lower level headers.
 157          */
 158         mreq->m_len = 6 * NFSX_UNSIGNED;
 159         siz += RPC_REPLYSIZ;
 160         if ((max_hdr + siz) >= MINCLSIZE) {
 161                 MCLGET(mreq, M_WAIT);
 162         } else
 163                 mreq->m_data += min(max_hdr, M_TRAILINGSPACE(mreq));
 164         tl = mtod(mreq, u_int32_t *);
 165         bpos = ((caddr_t)tl) + mreq->m_len;
 166         *tl++ = txdr_unsigned(nd->nd_retxid);
 167         *tl++ = nfsrv_rpc_reply;
 168         if (err == ERPCMISMATCH || (err & NFSERR_AUTHERR)) {
 169                 *tl++ = nfsrv_rpc_msgdenied;
 170                 if (err & NFSERR_AUTHERR) {
 171                         *tl++ = nfsrv_rpc_autherr;
 172                         *tl = txdr_unsigned(err & ~NFSERR_AUTHERR);
 173                         mreq->m_len -= NFSX_UNSIGNED;
 174                         bpos -= NFSX_UNSIGNED;
 175                 } else {
 176                         *tl++ = nfsrv_rpc_mismatch;
 177                         *tl++ = txdr_unsigned(RPC_VER2);
 178                         *tl = txdr_unsigned(RPC_VER2);
 179                 }
 180         } else {
 181                 *tl++ = nfsrv_rpc_msgaccepted;
 182                 /*
 183                  * Send a RPCAUTH_NULL verifier - no Kerberos.
 184                  */
 185                 *tl++ = 0;
 186                 *tl++ = 0;
 187                 switch (err) {
 188                 case EPROGUNAVAIL:
 189                         *tl = txdr_unsigned(RPC_PROGUNAVAIL);
 190                         break;
 191                 case EPROGMISMATCH:
 192                         *tl = txdr_unsigned(RPC_PROGMISMATCH);
 193                         tl = nfsm_build(u_int32_t *, 2 * NFSX_UNSIGNED);
 194                         *tl++ = txdr_unsigned(2);
 195                         *tl = txdr_unsigned(3);
 196                         break;
 197                 case EPROCUNAVAIL:
 198                         *tl = txdr_unsigned(RPC_PROCUNAVAIL);
 199                         break;
 200                 case EBADRPC:
 201                         *tl = txdr_unsigned(RPC_GARBAGE);
 202                         break;
 203                 default:
 204                         *tl = 0;
 205                         if (err != NFSERR_RETVOID) {
 206                                 tl = nfsm_build(u_int32_t *, NFSX_UNSIGNED);
 207                                 if (err)
 208                                     *tl = txdr_unsigned(nfsrv_errmap(nd, err));
 209                                 else
 210                                     *tl = 0;
 211                         }
 212                         break;
 213                 }
 214         }
 215         *mbp = mb;
 216         *bposp = bpos;
 217         if (err != 0 && err != NFSERR_RETVOID)
 218                 nfsrvstats.srvrpc_errs++;
 219         return mreq;
 220 }
 221
 222
 223 /*
 224  *      nfs_realign:
 225  *
 226  *      Check for badly aligned mbuf data and realign by copying the unaligned
 227  *      portion of the data into a new mbuf chain and freeing the portions
 228  *      of the old chain that were replaced.
 229  *
 230  *      We cannot simply realign the data within the existing mbuf chain
 231  *      because the underlying buffers may contain other rpc commands and
 232  *      we cannot afford to overwrite them.
 233  *
 234  *      We would prefer to avoid this situation entirely.  The situation does
 235  *      not occur with NFS/UDP and is supposed to only occassionally occur
 236  *      with TCP.  Use vfs.nfs.realign_count and realign_test to check this.
 237  */
 238 static void
 239 nfs_realign(struct mbuf **pm, int hsiz) /* XXX COMMON */
 240 {
 241         struct mbuf *m;
 242         struct mbuf *n = NULL;
 243         int off = 0;
 244
 245         ++nfs_realign_test;
 246         while ((m = *pm) != NULL) {
 247                 if ((m->m_len & 0x3) || (mtod(m, intptr_t) & 0x3)) {
 248                         MGET(n, M_WAIT, MT_DATA);
 249                         if (m->m_len >= MINCLSIZE) {
 250                                 MCLGET(n, M_WAIT);
 251                         }
 252                         n->m_len = 0;
 253                         break;
 254                 }
 255                 pm = &m->m_next;
 256         }
 257
 258         /*
 259          * If n is non-NULL, loop on m copying data, then replace the
 260          * portion of the chain that had to be realigned.
 261          */
 262         if (n != NULL) {
 263                 ++nfs_realign_count;
 264                 while (m) {
 265                         m_copyback(n, off, m->m_len, mtod(m, caddr_t));
 266                         off += m->m_len;
 267                         m = m->m_next;
 268                 }
 269                 m_freem(*pm);
 270                 *pm = n;
 271         }
 272 }
 273
 274
 275 /*
 276  * Parse an RPC request
 277  * - verify it
 278  * - fill in the cred struct.
 279  */
 280 int
 281 nfs_getreq(struct nfsrv_descript *nd, struct nfsd *nfsd, int has_header)
 282 {
 283         int len, i;
 284         u_int32_t *tl;
 285         caddr_t dpos;
 286         u_int32_t nfsvers, auth_type;
 287         int error = 0;
 288         struct mbuf *mrep, *md;
 289
 290         NFSD_LOCK_ASSERT();
 291
 292         mrep = nd->nd_mrep;
 293         md = nd->nd_md;
 294         dpos = nd->nd_dpos;
 295         if (has_header) {
 296                 tl = nfsm_dissect_nonblock(u_int32_t *, 10 * NFSX_UNSIGNED);
 297                 nd->nd_retxid = fxdr_unsigned(u_int32_t, *tl++);
 298                 if (*tl++ != nfsrv_rpc_call) {
 299                         m_freem(mrep);
 300                         return (EBADRPC);
 301                 }
 302         } else
 303                 tl = nfsm_dissect_nonblock(u_int32_t *, 8 * NFSX_UNSIGNED);
 304         nd->nd_repstat = 0;
 305         nd->nd_flag = 0;
 306         if (*tl++ != nfsrv_rpc_vers) {
 307                 nd->nd_repstat = ERPCMISMATCH;
 308                 nd->nd_procnum = NFSPROC_NOOP;
 309                 return (0);
 310         }
 311         if (*tl != nfsrv_nfs_prog) {
 312                 nd->nd_repstat = EPROGUNAVAIL;
 313                 nd->nd_procnum = NFSPROC_NOOP;
 314                 return (0);
 315         }
 316         tl++;
 317         nfsvers = fxdr_unsigned(u_int32_t, *tl++);
 318         if (nfsvers < NFS_VER2 || nfsvers > NFS_VER3) {
 319                 nd->nd_repstat = EPROGMISMATCH;
 320                 nd->nd_procnum = NFSPROC_NOOP;
 321                 return (0);
 322         }
 323         nd->nd_procnum = fxdr_unsigned(u_int32_t, *tl++);
 324         if (nd->nd_procnum == NFSPROC_NULL)
 325                 return (0);
 326         if (nfsvers == NFS_VER3) {
 327                 nd->nd_flag = ND_NFSV3;
 328                 if (nd->nd_procnum >= NFS_NPROCS) {
 329                         nd->nd_repstat = EPROCUNAVAIL;
 330                         nd->nd_procnum = NFSPROC_NOOP;
 331                         return (0);
 332                 }
 333         } else {
 334                 if (nd->nd_procnum > NFSV2PROC_STATFS) {
 335                         nd->nd_repstat = EPROCUNAVAIL;
 336                         nd->nd_procnum = NFSPROC_NOOP;
 337                         return (0);
 338                 }
 339                 /* Map the v2 procedure numbers into v3 ones */
 340                 nd->nd_procnum = nfsrv_nfsv3_procid[nd->nd_procnum];
 341         }
 342         auth_type = *tl++;
 343         len = fxdr_unsigned(int, *tl++);
 344         if (len < 0 || len > RPCAUTH_MAXSIZ) {
 345                 m_freem(mrep);
 346                 return (EBADRPC);
 347         }
 348
 349         /*
 350          * Handle auth_unix;
 351          */
 352         if (auth_type == nfsrv_rpc_auth_unix) {
 353                 len = fxdr_unsigned(int, *++tl);
 354                 if (len < 0 || len > NFS_MAXNAMLEN) {
 355                         m_freem(mrep);
 356                         return (EBADRPC);
 357                 }
 358                 nfsm_adv(nfsm_rndup(len));
 359                 tl = nfsm_dissect_nonblock(u_int32_t *, 3 * NFSX_UNSIGNED);
 360                 nd->nd_cr->cr_uid = nd->nd_cr->cr_ruid =
 361                     nd->nd_cr->cr_svuid = fxdr_unsigned(uid_t, *tl++);
 362                 nd->nd_cr->cr_groups[0] = nd->nd_cr->cr_rgid =
 363                     nd->nd_cr->cr_svgid = fxdr_unsigned(gid_t, *tl++);
 364 #ifdef MAC
 365                 mac_cred_associate_nfsd(nd->nd_cr);
 366 #endif
 367                 len = fxdr_unsigned(int, *tl);
 368                 if (len < 0 || len > RPCAUTH_UNIXGIDS) {
 369                         m_freem(mrep);
 370                         return (EBADRPC);
 371                 }
 372                 tl = nfsm_dissect_nonblock(u_int32_t *, (len + 2) * NFSX_UNSIGNED);
 373                 for (i = 1; i <= len; i++)
 374                     if (i < NGROUPS)
 375                         nd->nd_cr->cr_groups[i] = fxdr_unsigned(gid_t, *tl++);
 376                     else
 377                         tl++;
 378                 nd->nd_cr->cr_ngroups = (len >= NGROUPS) ? NGROUPS : (len + 1);
 379                 if (nd->nd_cr->cr_ngroups > 1)
 380                     nfsrvw_sort(nd->nd_cr->cr_groups, nd->nd_cr->cr_ngroups);
 381                 len = fxdr_unsigned(int, *++tl);
 382                 if (len < 0 || len > RPCAUTH_MAXSIZ) {
 383                         m_freem(mrep);
 384                         return (EBADRPC);
 385                 }
 386                 if (len > 0)
 387                         nfsm_adv(nfsm_rndup(len));
 388                 nd->nd_credflavor = RPCAUTH_UNIX;
 389         } else {
 390                 nd->nd_repstat = (NFSERR_AUTHERR | AUTH_REJECTCRED);
 391                 nd->nd_procnum = NFSPROC_NOOP;
 392                 return (0);
 393         }
 394
 395         nd->nd_md = md;
 396         nd->nd_dpos = dpos;
 397         return (0);
 398 nfsmout:
 399         return (error);
 400 }
 401
 402 /*
 403  * Socket upcall routine for the nfsd sockets.
 404  * The caddr_t arg is a pointer to the "struct nfssvc_sock".
 405  * Essentially do as much as possible non-blocking, else punt and it will
 406  * be called with M_WAIT from an nfsd.
 407  */
 408 void
 409 nfsrv_rcv(struct socket *so, void *arg, int waitflag)
 410 {
 411         struct nfssvc_sock *slp = (struct nfssvc_sock *)arg;
 412         struct mbuf *m;
 413         struct mbuf *mp;
 414         struct sockaddr *nam;
 415         struct uio auio;
 416         int flags, error;
 417
 418         NFSD_UNLOCK_ASSERT();
 419
 420         /* XXXRW: Unlocked read. */
 421         if ((slp->ns_flag & SLP_VALID) == 0)
 422                 return;
 423
 424         /*
 425          * We can't do this in the context of a socket callback
 426          * because we're called with locks held.
 427          * XXX: SMP
 428          */
 429         if (waitflag == M_DONTWAIT) {
 430                 NFSD_LOCK();
 431                 slp->ns_flag |= SLP_NEEDQ;
 432                 goto dorecs;
 433         }
 434
 435
 436         NFSD_LOCK();
 437         auio.uio_td = NULL;
 438         if (so->so_type == SOCK_STREAM) {
 439                 /*
 440                  * If there are already records on the queue, defer soreceive()
 441                  * to an nfsd so that there is feedback to the TCP layer that
 442                  * the nfs servers are heavily loaded.
 443                  */
 444                 if (STAILQ_FIRST(&slp->ns_rec) != NULL &&
 445                     waitflag == M_DONTWAIT) {
 446                         slp->ns_flag |= SLP_NEEDQ;
 447                         goto dorecs;
 448                 }
 449
 450                 /*
 451                  * Do soreceive().
 452                  */
 453                 auio.uio_resid = 1000000000;
 454                 flags = MSG_DONTWAIT;
 455                 NFSD_UNLOCK();
 456                 error = soreceive(so, &nam, &auio, &mp, NULL, &flags);
 457                 NFSD_LOCK();
 458                 if (error || mp == NULL) {
 459                         if (error == EWOULDBLOCK)
 460                                 slp->ns_flag |= SLP_NEEDQ;
 461                         else
 462                                 slp->ns_flag |= SLP_DISCONN;
 463                         goto dorecs;
 464                 }
 465                 m = mp;
 466                 if (slp->ns_rawend) {
 467                         slp->ns_rawend->m_next = m;
 468                         slp->ns_cc += 1000000000 - auio.uio_resid;
 469                 } else {
 470                         slp->ns_raw = m;
 471                         slp->ns_cc = 1000000000 - auio.uio_resid;
 472                 }
 473                 while (m->m_next)
 474                         m = m->m_next;
 475                 slp->ns_rawend = m;
 476
 477                 /*
 478                  * Now try and parse record(s) out of the raw stream data.
 479                  */
 480                 error = nfsrv_getstream(slp, waitflag);
 481                 if (error) {
 482                         if (error == EPERM)
 483                                 slp->ns_flag |= SLP_DISCONN;
 484                         else
 485                                 slp->ns_flag |= SLP_NEEDQ;
 486                 }
 487         } else {
 488                 do {
 489                         auio.uio_resid = 1000000000;
 490                         flags = MSG_DONTWAIT;
 491                         NFSD_UNLOCK();
 492                         error = soreceive(so, &nam, &auio, &mp, NULL, &flags);
 493                         if (mp) {
 494                                 struct nfsrv_rec *rec;
 495                                 rec = malloc(sizeof(struct nfsrv_rec),
 496                                     M_NFSRVDESC,
 497                                     waitflag == M_DONTWAIT ? M_NOWAIT : M_WAITOK);
 498                                 if (!rec) {
 499                                         if (nam)
 500                                                 free(nam, M_SONAME);
 501                                         m_freem(mp);
 502                                         NFSD_LOCK();
 503                                         continue;
 504                                 }
 505                                 nfs_realign(&mp, 10 * NFSX_UNSIGNED);
 506                                 NFSD_LOCK();
 507                                 rec->nr_address = nam;
 508                                 rec->nr_packet = mp;
 509                                 STAILQ_INSERT_TAIL(&slp->ns_rec, rec, nr_link);
 510                         } else
 511                                 NFSD_LOCK();
 512                         if (error) {
 513                                 if ((so->so_proto->pr_flags & PR_CONNREQUIRED)
 514                                         && error != EWOULDBLOCK) {
 515                                         slp->ns_flag |= SLP_DISCONN;
 516                                         goto dorecs;
 517                                 }
 518                         }
 519                 } while (mp);
 520         }
 521
 522         /*
 523          * Now try and process the request records, non-blocking.
 524          */
 525 dorecs:
 526         if (waitflag == M_DONTWAIT &&
 527                 (STAILQ_FIRST(&slp->ns_rec) != NULL ||
 528                  (slp->ns_flag & (SLP_NEEDQ | SLP_DISCONN))))
 529                 nfsrv_wakenfsd(slp);
 530         NFSD_UNLOCK();
 531 }
 532
 533 /*
 534  * Try and extract an RPC request from the mbuf data list received on a
 535  * stream socket. The "waitflag" argument indicates whether or not it
 536  * can sleep.
 537  */
 538 static int
 539 nfsrv_getstream(struct nfssvc_sock *slp, int waitflag)
 540 {
 541         struct mbuf *m, **mpp;
 542         char *cp1, *cp2;
 543         int len;
 544         struct mbuf *om, *m2, *recm;
 545         u_int32_t recmark;
 546
 547         NFSD_LOCK_ASSERT();
 548
 549         if (slp->ns_flag & SLP_GETSTREAM)
 550                 panic("nfs getstream");
 551         slp->ns_flag |= SLP_GETSTREAM;
 552         for (;;) {
 553             if (slp->ns_reclen == 0) {
 554                 if (slp->ns_cc < NFSX_UNSIGNED) {
 555                         slp->ns_flag &= ~SLP_GETSTREAM;
 556                         return (0);
 557                 }
 558                 m = slp->ns_raw;
 559                 if (m->m_len >= NFSX_UNSIGNED) {
 560                         bcopy(mtod(m, caddr_t), (caddr_t)&recmark, NFSX_UNSIGNED);
 561                         m->m_data += NFSX_UNSIGNED;
 562                         m->m_len -= NFSX_UNSIGNED;
 563                 } else {
 564                         cp1 = (caddr_t)&recmark;
 565                         cp2 = mtod(m, caddr_t);
 566                         while (cp1 < ((caddr_t)&recmark) + NFSX_UNSIGNED) {
 567                                 while (m->m_len == 0) {
 568                                         m = m->m_next;
 569                                         cp2 = mtod(m, caddr_t);
 570                                 }
 571                                 *cp1++ = *cp2++;
 572                                 m->m_data++;
 573                                 m->m_len--;
 574                         }
 575                 }
 576                 slp->ns_cc -= NFSX_UNSIGNED;
 577                 recmark = ntohl(recmark);
 578                 slp->ns_reclen = recmark & ~0x80000000;
 579                 if (recmark & 0x80000000)
 580                         slp->ns_flag |= SLP_LASTFRAG;
 581                 else
 582                         slp->ns_flag &= ~SLP_LASTFRAG;
 583                 if (slp->ns_reclen > NFS_MAXPACKET || slp->ns_reclen <= 0) {
 584                         slp->ns_flag &= ~SLP_GETSTREAM;
 585                         return (EPERM);
 586                 }
 587             }
 588
 589             /*
 590              * Now get the record part.
 591              *
 592              * Note that slp->ns_reclen may be 0.  Linux sometimes
 593              * generates 0-length RPCs.
 594              */
 595             recm = NULL;
 596             if (slp->ns_cc == slp->ns_reclen) {
 597                 recm = slp->ns_raw;
 598                 slp->ns_raw = slp->ns_rawend = NULL;
 599                 slp->ns_cc = slp->ns_reclen = 0;
 600             } else if (slp->ns_cc > slp->ns_reclen) {
 601                 len = 0;
 602                 m = slp->ns_raw;
 603                 om = NULL;
 604
 605                 while (len < slp->ns_reclen) {
 606                         if ((len + m->m_len) > slp->ns_reclen) {
 607                                 NFSD_UNLOCK();
 608                                 m2 = m_copym(m, 0, slp->ns_reclen - len,
 609                                         waitflag);
 610                                 NFSD_LOCK();
 611                                 if (m2) {
 612                                         if (om) {
 613                                                 om->m_next = m2;
 614                                                 recm = slp->ns_raw;
 615                                         } else
 616                                                 recm = m2;
 617                                         m->m_data += slp->ns_reclen - len;
 618                                         m->m_len -= slp->ns_reclen - len;
 619                                         len = slp->ns_reclen;
 620                                 } else {
 621                                         slp->ns_flag &= ~SLP_GETSTREAM;
 622                                         return (EWOULDBLOCK);
 623                                 }
 624                         } else if ((len + m->m_len) == slp->ns_reclen) {
 625                                 om = m;
 626                                 len += m->m_len;
 627                                 m = m->m_next;
 628                                 recm = slp->ns_raw;
 629                                 om->m_next = NULL;
 630                         } else {
 631                                 om = m;
 632                                 len += m->m_len;
 633                                 m = m->m_next;
 634                         }
 635                 }
 636                 slp->ns_raw = m;
 637                 slp->ns_cc -= len;
 638                 slp->ns_reclen = 0;
 639             } else {
 640                 slp->ns_flag &= ~SLP_GETSTREAM;
 641                 return (0);
 642             }
 643
 644             /*
 645              * Accumulate the fragments into a record.
 646              */
 647             mpp = &slp->ns_frag;
 648             while (*mpp)
 649                 mpp = &((*mpp)->m_next);
 650             *mpp = recm;
 651             if (slp->ns_flag & SLP_LASTFRAG) {
 652                 struct nfsrv_rec *rec;
 653                 NFSD_UNLOCK();
 654                 rec = malloc(sizeof(struct nfsrv_rec), M_NFSRVDESC,
 655                     waitflag == M_DONTWAIT ? M_NOWAIT : M_WAITOK);
 656                 if (rec) {
 657                     nfs_realign(&slp->ns_frag, 10 * NFSX_UNSIGNED);
 658                     rec->nr_address = NULL;
 659                     rec->nr_packet = slp->ns_frag;
 660                     NFSD_LOCK();
 661                     STAILQ_INSERT_TAIL(&slp->ns_rec, rec, nr_link);
 662                 } else {
 663                     NFSD_LOCK();
 664                 }
 665                 if (!rec) {
 666                     m_freem(slp->ns_frag);
 667                 }
 668                 slp->ns_frag = NULL;
 669             }
 670         }
 671 }
 672
 673 /*
 674  * Parse an RPC header.
 675  */
 676 int
 677 nfsrv_dorec(struct nfssvc_sock *slp, struct nfsd *nfsd,
 678     struct nfsrv_descript **ndp)
 679 {
 680         struct nfsrv_rec *rec;
 681         struct mbuf *m;
 682         struct sockaddr *nam;
 683         struct nfsrv_descript *nd;
 684         int error;
 685
 686         NFSD_LOCK_ASSERT();
 687
 688         *ndp = NULL;
 689         if ((slp->ns_flag & SLP_VALID) == 0 ||
 690             STAILQ_FIRST(&slp->ns_rec) == NULL)
 691                 return (ENOBUFS);
 692         rec = STAILQ_FIRST(&slp->ns_rec);
 693         KASSERT(rec->nr_packet != NULL, ("nfsrv_dorec: missing mbuf"));
 694         STAILQ_REMOVE_HEAD(&slp->ns_rec, nr_link);
 695         nam = rec->nr_address;
 696         m = rec->nr_packet;
 697         free(rec, M_NFSRVDESC);
 698         NFSD_UNLOCK();
 699         nd = malloc(sizeof (struct nfsrv_descript),
 700                 M_NFSRVDESC, M_WAITOK);
 701         nd->nd_cr = crget();
 702         NFSD_LOCK();
 703         nd->nd_md = nd->nd_mrep = m;
 704         nd->nd_nam2 = nam;
 705         nd->nd_dpos = mtod(m, caddr_t);
 706         error = nfs_getreq(nd, nfsd, TRUE);
 707         if (error) {
 708                 if (nam) {
 709                         free(nam, M_SONAME);
 710                 }
 711                 if (nd->nd_cr != NULL)
 712                         crfree(nd->nd_cr);
 713                 free((caddr_t)nd, M_NFSRVDESC);
 714                 return (error);
 715         }
 716         *ndp = nd;
 717         nfsd->nfsd_nd = nd;
 718         return (0);
 719 }
 720
 721 /*
 722  * Search for a sleeping nfsd and wake it up.
 723  * SIDE EFFECT: If none found, set NFSD_CHECKSLP flag, so that one of the
 724  * running nfsds will go look for the work in the nfssvc_sock list.
 725  */
 726 void
 727 nfsrv_wakenfsd(struct nfssvc_sock *slp)
 728 {
 729         struct nfsd *nd;
 730
 731         NFSD_LOCK_ASSERT();
 732
 733         if ((slp->ns_flag & SLP_VALID) == 0)
 734                 return;
 735         TAILQ_FOREACH(nd, &nfsd_head, nfsd_chain) {
 736                 if (nd->nfsd_flag & NFSD_WAITING) {
 737                         nd->nfsd_flag &= ~NFSD_WAITING;
 738                         if (nd->nfsd_slp)
 739                                 panic("nfsd wakeup");
 740                         slp->ns_sref++;
 741                         nd->nfsd_slp = slp;
 742                         wakeup(nd);
 743                         return;
 744                 }
 745         }
 746         slp->ns_flag |= SLP_DOREC;
 747         nfsd_head_flag |= NFSD_CHECKSLP;
 748 }
 749
 750 /*
 751  * This is the nfs send routine.
 752  * For the server side:
 753  * - return EINTR or ERESTART if interrupted by a signal
 754  * - return EPIPE if a connection is lost for connection based sockets (TCP...)
 755  * - do any cleanup required by recoverable socket errors (?)
 756  */
 757 int
 758 nfsrv_send(struct socket *so, struct sockaddr *nam, struct mbuf *top)
 759 {
 760         struct sockaddr *sendnam;
 761         int error, soflags, flags;
 762
 763         NFSD_UNLOCK_ASSERT();
 764
 765         soflags = so->so_proto->pr_flags;
 766         if ((soflags & PR_CONNREQUIRED) || (so->so_state & SS_ISCONNECTED))
 767                 sendnam = NULL;
 768         else
 769                 sendnam = nam;
 770         if (so->so_type == SOCK_SEQPACKET)
 771                 flags = MSG_EOR;
 772         else
 773                 flags = 0;
 774
 775         error = sosend(so, sendnam, 0, top, 0, flags, curthread/*XXX*/);
 776         if (error == ENOBUFS && so->so_type == SOCK_DGRAM)
 777                 error = 0;
 778
 779         if (error) {
 780                 log(LOG_INFO, "nfsd send error %d\n", error);
 781
 782                 /*
 783                  * Handle any recoverable (soft) socket errors here. (?)
 784                  */
 785                 if (error != EINTR && error != ERESTART &&
 786                     error != EWOULDBLOCK && error != EPIPE)
 787                         error = 0;
 788         }
 789         return (error);
 790 }
 791
 792 /*
 793  * NFS server timer routine.
 794  */
 795 void
 796 nfsrv_timer(void *arg)
 797 {
 798         struct nfssvc_sock *slp;
 799         u_quad_t cur_usec;
 800
 801         NFSD_LOCK();
 802         /*
 803          * Scan the write gathering queues for writes that need to be
 804          * completed now.
 805          */
 806         cur_usec = nfs_curusec();
 807         TAILQ_FOREACH(slp, &nfssvc_sockhead, ns_chain) {
 808                 if (LIST_FIRST(&slp->ns_tq) &&
 809                     LIST_FIRST(&slp->ns_tq)->nd_time <= cur_usec)
 810                         nfsrv_wakenfsd(slp);
 811         }
 812         NFSD_UNLOCK();
 813         callout_reset(&nfsrv_callout, nfsrv_ticks, nfsrv_timer, NULL);
 814 }
 815
 816 #endif /* NFS_LEGACYRPC */