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