The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/nfsclient/nfs_socket.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    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  * 3. All advertising materials mentioning features or use of this software
   17  *    must display the following acknowledgement:
   18  *      This product includes software developed by the University of
   19  *      California, Berkeley and its contributors.
   20  * 4. Neither the name of the University nor the names of its contributors
   21  *    may be used to endorse or promote products derived from this software
   22  *    without specific prior written permission.
   23  *
   24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   34  * SUCH DAMAGE.
   35  *
   36  *      @(#)nfs_socket.c        8.5 (Berkeley) 3/30/95
   37  */
   38 
   39 #include <sys/cdefs.h>
   40 __FBSDID("$FreeBSD: releng/5.2/sys/nfsclient/nfs_socket.c 122698 2003-11-14 20:54:10Z alfred $");
   41 
   42 /*
   43  * Socket operations for use by nfs
   44  */
   45 
   46 #include "opt_inet6.h"
   47 
   48 #include <sys/param.h>
   49 #include <sys/systm.h>
   50 #include <sys/kernel.h>
   51 #include <sys/lock.h>
   52 #include <sys/malloc.h>
   53 #include <sys/mbuf.h>
   54 #include <sys/mount.h>
   55 #include <sys/mutex.h>
   56 #include <sys/proc.h>
   57 #include <sys/protosw.h>
   58 #include <sys/signalvar.h>
   59 #include <sys/socket.h>
   60 #include <sys/socketvar.h>
   61 #include <sys/sysctl.h>
   62 #include <sys/syslog.h>
   63 #include <sys/vnode.h>
   64 
   65 #include <netinet/in.h>
   66 #include <netinet/tcp.h>
   67 
   68 #include <rpc/rpcclnt.h>
   69 
   70 #include <nfs/rpcv2.h>
   71 #include <nfs/nfsproto.h>
   72 #include <nfsclient/nfs.h>
   73 #include <nfs/xdr_subs.h>
   74 #include <nfsclient/nfsm_subs.h>
   75 #include <nfsclient/nfsmount.h>
   76 #include <nfsclient/nfsnode.h>
   77 
   78 #include <nfs4client/nfs4.h>
   79 
   80 #define TRUE    1
   81 #define FALSE   0
   82 
   83 /*
   84  * Estimate rto for an nfs rpc sent via. an unreliable datagram.
   85  * Use the mean and mean deviation of rtt for the appropriate type of rpc
   86  * for the frequent rpcs and a default for the others.
   87  * The justification for doing "other" this way is that these rpcs
   88  * happen so infrequently that timer est. would probably be stale.
   89  * Also, since many of these rpcs are
   90  * non-idempotent, a conservative timeout is desired.
   91  * getattr, lookup - A+2D
   92  * read, write     - A+4D
   93  * other           - nm_timeo
   94  */
   95 #define NFS_RTO(n, t) \
   96         ((t) == 0 ? (n)->nm_timeo : \
   97          ((t) < 3 ? \
   98           (((((n)->nm_srtt[t-1] + 3) >> 2) + (n)->nm_sdrtt[t-1] + 1) >> 1) : \
   99           ((((n)->nm_srtt[t-1] + 7) >> 3) + (n)->nm_sdrtt[t-1] + 1)))
  100 #define NFS_SRTT(r)     (r)->r_nmp->nm_srtt[proct[(r)->r_procnum] - 1]
  101 #define NFS_SDRTT(r)    (r)->r_nmp->nm_sdrtt[proct[(r)->r_procnum] - 1]
  102 
  103 /*
  104  * Defines which timer to use for the procnum.
  105  * 0 - default
  106  * 1 - getattr
  107  * 2 - lookup
  108  * 3 - read
  109  * 4 - write
  110  */
  111 static int proct[NFS_NPROCS] = {
  112         0, 1, 0, 2, 1, 3, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 0, 0, 0, 0, 0,
  113 };
  114 
  115 static int      nfs_realign_test;
  116 static int      nfs_realign_count;
  117 static int      nfs_bufpackets = 4;
  118 
  119 SYSCTL_DECL(_vfs_nfs);
  120 
  121 SYSCTL_INT(_vfs_nfs, OID_AUTO, realign_test, CTLFLAG_RW, &nfs_realign_test, 0, "");
  122 SYSCTL_INT(_vfs_nfs, OID_AUTO, realign_count, CTLFLAG_RW, &nfs_realign_count, 0, "");
  123 SYSCTL_INT(_vfs_nfs, OID_AUTO, bufpackets, CTLFLAG_RW, &nfs_bufpackets, 0, "");
  124 
  125 
  126 /*
  127  * There is a congestion window for outstanding rpcs maintained per mount
  128  * point. The cwnd size is adjusted in roughly the way that:
  129  * Van Jacobson, Congestion avoidance and Control, In "Proceedings of
  130  * SIGCOMM '88". ACM, August 1988.
  131  * describes for TCP. The cwnd size is chopped in half on a retransmit timeout
  132  * and incremented by 1/cwnd when each rpc reply is received and a full cwnd
  133  * of rpcs is in progress.
  134  * (The sent count and cwnd are scaled for integer arith.)
  135  * Variants of "slow start" were tried and were found to be too much of a
  136  * performance hit (ave. rtt 3 times larger),
  137  * I suspect due to the large rtt that nfs rpcs have.
  138  */
  139 #define NFS_CWNDSCALE   256
  140 #define NFS_MAXCWND     (NFS_CWNDSCALE * 32)
  141 #define NFS_NBACKOFF    8
  142 static int nfs_backoff[NFS_NBACKOFF] = { 2, 4, 8, 16, 32, 64, 128, 256, };
  143 struct callout_handle   nfs_timer_handle;
  144 
  145 static int      nfs_msg(struct thread *, char *, char *);
  146 static int      nfs_rcvlock(struct nfsreq *);
  147 static void     nfs_rcvunlock(struct nfsreq *);
  148 static void     nfs_realign(struct mbuf **pm, int hsiz);
  149 static int      nfs_receive(struct nfsreq *rep, struct sockaddr **aname,
  150                     struct mbuf **mp);
  151 static int      nfs_reply(struct nfsreq *);
  152 static void     nfs_softterm(struct nfsreq *rep);
  153 static int      nfs_reconnect(struct nfsreq *rep);
  154 
  155 /*
  156  * Initialize sockets and congestion for a new NFS connection.
  157  * We do not free the sockaddr if error.
  158  */
  159 int
  160 nfs_connect(struct nfsmount *nmp, struct nfsreq *rep)
  161 {
  162         struct socket *so;
  163         int s, error, rcvreserve, sndreserve;
  164         int pktscale;
  165         struct sockaddr *saddr;
  166         struct thread *td = &thread0; /* only used for socreate and sobind */
  167 
  168         GIANT_REQUIRED;         /* XXX until socket locking done */
  169 
  170         nmp->nm_so = NULL;
  171         saddr = nmp->nm_nam;
  172         error = socreate(saddr->sa_family, &nmp->nm_so, nmp->nm_sotype,
  173                 nmp->nm_soproto, nmp->nm_mountp->mnt_cred, td);
  174         if (error)
  175                 goto bad;
  176         so = nmp->nm_so;
  177         nmp->nm_soflags = so->so_proto->pr_flags;
  178 
  179         /*
  180          * Some servers require that the client port be a reserved port number.
  181          */
  182         if (nmp->nm_flag & NFSMNT_RESVPORT) {
  183                 struct sockopt sopt;
  184                 int ip, ip2, len;
  185                 struct sockaddr_in6 ssin;
  186                 struct sockaddr *sa;
  187 
  188                 bzero(&sopt, sizeof sopt);
  189                 switch(saddr->sa_family) {
  190                 case AF_INET:
  191                         sopt.sopt_level = IPPROTO_IP;
  192                         sopt.sopt_name = IP_PORTRANGE;
  193                         ip = IP_PORTRANGE_LOW;
  194                         ip2 = IP_PORTRANGE_DEFAULT;
  195                         len = sizeof (struct sockaddr_in);
  196                         break;
  197 #ifdef INET6
  198                 case AF_INET6:
  199                         sopt.sopt_level = IPPROTO_IPV6;
  200                         sopt.sopt_name = IPV6_PORTRANGE;
  201                         ip = IPV6_PORTRANGE_LOW;
  202                         ip2 = IPV6_PORTRANGE_DEFAULT;
  203                         len = sizeof (struct sockaddr_in6);
  204                         break;
  205 #endif
  206                 default:
  207                         goto noresvport;
  208                 }
  209                 sa = (struct sockaddr *)&ssin;
  210                 bzero(sa, len);
  211                 sa->sa_len = len;
  212                 sa->sa_family = saddr->sa_family;
  213                 sopt.sopt_dir = SOPT_SET;
  214                 sopt.sopt_val = (void *)&ip;
  215                 sopt.sopt_valsize = sizeof(ip);
  216                 error = sosetopt(so, &sopt);
  217                 if (error)
  218                         goto bad;
  219                 error = sobind(so, sa, td);
  220                 if (error)
  221                         goto bad;
  222                 ip = ip2;
  223                 error = sosetopt(so, &sopt);
  224                 if (error)
  225                         goto bad;
  226         noresvport: ;
  227         }
  228 
  229         /*
  230          * Protocols that do not require connections may be optionally left
  231          * unconnected for servers that reply from a port other than NFS_PORT.
  232          */
  233         if (nmp->nm_flag & NFSMNT_NOCONN) {
  234                 if (nmp->nm_soflags & PR_CONNREQUIRED) {
  235                         error = ENOTCONN;
  236                         goto bad;
  237                 }
  238         } else {
  239                 error = soconnect(so, nmp->nm_nam, td);
  240                 if (error)
  241                         goto bad;
  242 
  243                 /*
  244                  * Wait for the connection to complete. Cribbed from the
  245                  * connect system call but with the wait timing out so
  246                  * that interruptible mounts don't hang here for a long time.
  247                  */
  248                 s = splnet();
  249                 while ((so->so_state & SS_ISCONNECTING) && so->so_error == 0) {
  250                         (void) tsleep(&so->so_timeo,
  251                             PSOCK, "nfscon", 2 * hz);
  252                         if ((so->so_state & SS_ISCONNECTING) &&
  253                             so->so_error == 0 && rep &&
  254                             (error = nfs_sigintr(nmp, rep, rep->r_td)) != 0) {
  255                                 so->so_state &= ~SS_ISCONNECTING;
  256                                 splx(s);
  257                                 goto bad;
  258                         }
  259                 }
  260                 if (so->so_error) {
  261                         error = so->so_error;
  262                         so->so_error = 0;
  263                         splx(s);
  264                         goto bad;
  265                 }
  266                 splx(s);
  267         }
  268         so->so_rcv.sb_timeo = 5 * hz;
  269         so->so_snd.sb_timeo = 5 * hz;
  270 
  271         /*
  272          * Get buffer reservation size from sysctl, but impose reasonable
  273          * limits.
  274          */
  275         pktscale = nfs_bufpackets;
  276         if (pktscale < 2)
  277                 pktscale = 2;
  278         if (pktscale > 64)
  279                 pktscale = 64;
  280 
  281         if (nmp->nm_sotype == SOCK_DGRAM) {
  282                 sndreserve = (nmp->nm_wsize + NFS_MAXPKTHDR) * pktscale;
  283                 rcvreserve = (max(nmp->nm_rsize, nmp->nm_readdirsize) +
  284                     NFS_MAXPKTHDR) * pktscale;
  285         } else if (nmp->nm_sotype == SOCK_SEQPACKET) {
  286                 sndreserve = (nmp->nm_wsize + NFS_MAXPKTHDR) * pktscale;
  287                 rcvreserve = (max(nmp->nm_rsize, nmp->nm_readdirsize) +
  288                     NFS_MAXPKTHDR) * pktscale;
  289         } else {
  290                 if (nmp->nm_sotype != SOCK_STREAM)
  291                         panic("nfscon sotype");
  292                 if (so->so_proto->pr_flags & PR_CONNREQUIRED) {
  293                         struct sockopt sopt;
  294                         int val;
  295 
  296                         bzero(&sopt, sizeof sopt);
  297                         sopt.sopt_dir = SOPT_SET;
  298                         sopt.sopt_level = SOL_SOCKET;
  299                         sopt.sopt_name = SO_KEEPALIVE;
  300                         sopt.sopt_val = &val;
  301                         sopt.sopt_valsize = sizeof val;
  302                         val = 1;
  303                         sosetopt(so, &sopt);
  304                 }
  305                 if (so->so_proto->pr_protocol == IPPROTO_TCP) {
  306                         struct sockopt sopt;
  307                         int val;
  308 
  309                         bzero(&sopt, sizeof sopt);
  310                         sopt.sopt_dir = SOPT_SET;
  311                         sopt.sopt_level = IPPROTO_TCP;
  312                         sopt.sopt_name = TCP_NODELAY;
  313                         sopt.sopt_val = &val;
  314                         sopt.sopt_valsize = sizeof val;
  315                         val = 1;
  316                         sosetopt(so, &sopt);
  317                 }
  318                 sndreserve = (nmp->nm_wsize + NFS_MAXPKTHDR +
  319                     sizeof (u_int32_t)) * pktscale;
  320                 rcvreserve = (nmp->nm_rsize + NFS_MAXPKTHDR +
  321                     sizeof (u_int32_t)) * pktscale;
  322         }
  323         error = soreserve(so, sndreserve, rcvreserve);
  324         if (error)
  325                 goto bad;
  326         so->so_rcv.sb_flags |= SB_NOINTR;
  327         so->so_snd.sb_flags |= SB_NOINTR;
  328 
  329         /* Initialize other non-zero congestion variables */
  330         nmp->nm_srtt[0] = nmp->nm_srtt[1] = nmp->nm_srtt[2] =
  331                 nmp->nm_srtt[3] = (NFS_TIMEO << 3);
  332         nmp->nm_sdrtt[0] = nmp->nm_sdrtt[1] = nmp->nm_sdrtt[2] =
  333                 nmp->nm_sdrtt[3] = 0;
  334         nmp->nm_cwnd = NFS_MAXCWND / 2;     /* Initial send window */
  335         nmp->nm_sent = 0;
  336         nmp->nm_timeouts = 0;
  337         return (0);
  338 
  339 bad:
  340         nfs_disconnect(nmp);
  341         return (error);
  342 }
  343 
  344 /*
  345  * Reconnect routine:
  346  * Called when a connection is broken on a reliable protocol.
  347  * - clean up the old socket
  348  * - nfs_connect() again
  349  * - set R_MUSTRESEND for all outstanding requests on mount point
  350  * If this fails the mount point is DEAD!
  351  * nb: Must be called with the nfs_sndlock() set on the mount point.
  352  */
  353 static int
  354 nfs_reconnect(struct nfsreq *rep)
  355 {
  356         struct nfsreq *rp;
  357         struct nfsmount *nmp = rep->r_nmp;
  358         int error;
  359 
  360         nfs_disconnect(nmp);
  361         while ((error = nfs_connect(nmp, rep)) != 0) {
  362                 if (error == EINTR || error == ERESTART)
  363                         return (EINTR);
  364                 (void) tsleep(&lbolt, PSOCK, "nfscon", 0);
  365         }
  366 
  367         /*
  368          * Loop through outstanding request list and fix up all requests
  369          * on old socket.
  370          */
  371         TAILQ_FOREACH(rp, &nfs_reqq, r_chain) {
  372                 if (rp->r_nmp == nmp)
  373                         rp->r_flags |= R_MUSTRESEND;
  374         }
  375         return (0);
  376 }
  377 
  378 /*
  379  * NFS disconnect. Clean up and unlink.
  380  */
  381 void
  382 nfs_disconnect(struct nfsmount *nmp)
  383 {
  384         struct socket *so;
  385 
  386         GIANT_REQUIRED;         /* XXX until socket locking done */
  387 
  388         if (nmp->nm_so) {
  389                 so = nmp->nm_so;
  390                 nmp->nm_so = NULL;
  391                 soshutdown(so, 2);
  392                 soclose(so);
  393         }
  394 }
  395 
  396 void
  397 nfs_safedisconnect(struct nfsmount *nmp)
  398 {
  399         struct nfsreq dummyreq;
  400 
  401         bzero(&dummyreq, sizeof(dummyreq));
  402         dummyreq.r_nmp = nmp;
  403         nfs_rcvlock(&dummyreq);
  404         nfs_disconnect(nmp);
  405         nfs_rcvunlock(&dummyreq);
  406 }
  407 
  408 /*
  409  * This is the nfs send routine. For connection based socket types, it
  410  * must be called with an nfs_sndlock() on the socket.
  411  * - return EINTR if the RPC is terminated, 0 otherwise
  412  * - set R_MUSTRESEND if the send fails for any reason
  413  * - do any cleanup required by recoverable socket errors (?)
  414  */
  415 int
  416 nfs_send(struct socket *so, struct sockaddr *nam, struct mbuf *top,
  417     struct nfsreq *rep)
  418 {
  419         struct sockaddr *sendnam;
  420         int error, soflags, flags;
  421 
  422         GIANT_REQUIRED;         /* XXX until socket locking done */
  423 
  424         KASSERT(rep, ("nfs_send: called with rep == NULL"));
  425 
  426         if (rep->r_flags & R_SOFTTERM) {
  427                 m_freem(top);
  428                 return (EINTR);
  429         }
  430         if ((so = rep->r_nmp->nm_so) == NULL) {
  431                 rep->r_flags |= R_MUSTRESEND;
  432                 m_freem(top);
  433                 return (0);
  434         }
  435         rep->r_flags &= ~R_MUSTRESEND;
  436         soflags = rep->r_nmp->nm_soflags;
  437 
  438         if ((soflags & PR_CONNREQUIRED) || (so->so_state & SS_ISCONNECTED))
  439                 sendnam = NULL;
  440         else
  441                 sendnam = nam;
  442         if (so->so_type == SOCK_SEQPACKET)
  443                 flags = MSG_EOR;
  444         else
  445                 flags = 0;
  446 
  447         error = so->so_proto->pr_usrreqs->pru_sosend(so, sendnam, 0, top, 0,
  448                                                      flags, curthread /*XXX*/);
  449         if (error == ENOBUFS && so->so_type == SOCK_DGRAM) {
  450                 error = 0;
  451                 rep->r_flags |= R_MUSTRESEND;
  452         }
  453 
  454         if (error) {
  455                 log(LOG_INFO, "nfs send error %d for server %s\n", error,
  456                     rep->r_nmp->nm_mountp->mnt_stat.f_mntfromname);
  457                 /*
  458                  * Deal with errors for the client side.
  459                  */
  460                 if (rep->r_flags & R_SOFTTERM)
  461                         error = EINTR;
  462                 else
  463                         rep->r_flags |= R_MUSTRESEND;
  464 
  465                 /*
  466                  * Handle any recoverable (soft) socket errors here. (?)
  467                  */
  468                 if (error != EINTR && error != ERESTART &&
  469                         error != EWOULDBLOCK && error != EPIPE)
  470                         error = 0;
  471         }
  472         return (error);
  473 }
  474 
  475 /*
  476  * Receive a Sun RPC Request/Reply. For SOCK_DGRAM, the work is all
  477  * done by soreceive(), but for SOCK_STREAM we must deal with the Record
  478  * Mark and consolidate the data into a new mbuf list.
  479  * nb: Sometimes TCP passes the data up to soreceive() in long lists of
  480  *     small mbufs.
  481  * For SOCK_STREAM we must be very careful to read an entire record once
  482  * we have read any of it, even if the system call has been interrupted.
  483  */
  484 static int
  485 nfs_receive(struct nfsreq *rep, struct sockaddr **aname, struct mbuf **mp)
  486 {
  487         struct socket *so;
  488         struct uio auio;
  489         struct iovec aio;
  490         struct mbuf *m;
  491         struct mbuf *control;
  492         u_int32_t len;
  493         struct sockaddr **getnam;
  494         int error, sotype, rcvflg;
  495         struct thread *td = curthread;  /* XXX */
  496 
  497         GIANT_REQUIRED;         /* XXX until socket locking done */
  498 
  499         /*
  500          * Set up arguments for soreceive()
  501          */
  502         *mp = NULL;
  503         *aname = NULL;
  504         sotype = rep->r_nmp->nm_sotype;
  505 
  506         /*
  507          * For reliable protocols, lock against other senders/receivers
  508          * in case a reconnect is necessary.
  509          * For SOCK_STREAM, first get the Record Mark to find out how much
  510          * more there is to get.
  511          * We must lock the socket against other receivers
  512          * until we have an entire rpc request/reply.
  513          */
  514         if (sotype != SOCK_DGRAM) {
  515                 error = nfs_sndlock(rep);
  516                 if (error)
  517                         return (error);
  518 tryagain:
  519                 /*
  520                  * Check for fatal errors and resending request.
  521                  */
  522                 /*
  523                  * Ugh: If a reconnect attempt just happened, nm_so
  524                  * would have changed. NULL indicates a failed
  525                  * attempt that has essentially shut down this
  526                  * mount point.
  527                  */
  528                 if (rep->r_mrep || (rep->r_flags & R_SOFTTERM)) {
  529                         nfs_sndunlock(rep);
  530                         return (EINTR);
  531                 }
  532                 so = rep->r_nmp->nm_so;
  533                 if (!so) {
  534                         error = nfs_reconnect(rep);
  535                         if (error) {
  536                                 nfs_sndunlock(rep);
  537                                 return (error);
  538                         }
  539                         goto tryagain;
  540                 }
  541                 while (rep->r_flags & R_MUSTRESEND) {
  542                         m = m_copym(rep->r_mreq, 0, M_COPYALL, M_TRYWAIT);
  543                         nfsstats.rpcretries++;
  544                         error = nfs_send(so, rep->r_nmp->nm_nam, m, rep);
  545                         if (error) {
  546                                 if (error == EINTR || error == ERESTART ||
  547                                     (error = nfs_reconnect(rep)) != 0) {
  548                                         nfs_sndunlock(rep);
  549                                         return (error);
  550                                 }
  551                                 goto tryagain;
  552                         }
  553                 }
  554                 nfs_sndunlock(rep);
  555                 if (sotype == SOCK_STREAM) {
  556                         aio.iov_base = (caddr_t) &len;
  557                         aio.iov_len = sizeof(u_int32_t);
  558                         auio.uio_iov = &aio;
  559                         auio.uio_iovcnt = 1;
  560                         auio.uio_segflg = UIO_SYSSPACE;
  561                         auio.uio_rw = UIO_READ;
  562                         auio.uio_offset = 0;
  563                         auio.uio_resid = sizeof(u_int32_t);
  564                         auio.uio_td = td;
  565                         do {
  566                            rcvflg = MSG_WAITALL;
  567                            error = so->so_proto->pr_usrreqs->pru_soreceive
  568                                    (so, NULL, &auio, NULL, NULL, &rcvflg);
  569                            if (error == EWOULDBLOCK && rep) {
  570                                 if (rep->r_flags & R_SOFTTERM)
  571                                         return (EINTR);
  572                            }
  573                         } while (error == EWOULDBLOCK);
  574                         if (!error && auio.uio_resid > 0) {
  575                             /*
  576                              * Don't log a 0 byte receive; it means
  577                              * that the socket has been closed, and
  578                              * can happen during normal operation
  579                              * (forcible unmount or Solaris server).
  580                              */
  581                             if (auio.uio_resid != sizeof (u_int32_t))
  582                             log(LOG_INFO,
  583                                  "short receive (%d/%d) from nfs server %s\n",
  584                                  (int)(sizeof(u_int32_t) - auio.uio_resid),
  585                                  (int)sizeof(u_int32_t),
  586                                  rep->r_nmp->nm_mountp->mnt_stat.f_mntfromname);
  587                             error = EPIPE;
  588                         }
  589                         if (error)
  590                                 goto errout;
  591                         len = ntohl(len) & ~0x80000000;
  592                         /*
  593                          * This is SERIOUS! We are out of sync with the sender
  594                          * and forcing a disconnect/reconnect is all I can do.
  595                          */
  596                         if (len > NFS_MAXPACKET) {
  597                             log(LOG_ERR, "%s (%d) from nfs server %s\n",
  598                                 "impossible packet length",
  599                                 len,
  600                                 rep->r_nmp->nm_mountp->mnt_stat.f_mntfromname);
  601                             error = EFBIG;
  602                             goto errout;
  603                         }
  604                         auio.uio_resid = len;
  605                         do {
  606                             rcvflg = MSG_WAITALL;
  607                             error =  so->so_proto->pr_usrreqs->pru_soreceive
  608                                     (so, NULL,
  609                                      &auio, mp, NULL, &rcvflg);
  610                         } while (error == EWOULDBLOCK || error == EINTR ||
  611                                  error == ERESTART);
  612                         if (!error && auio.uio_resid > 0) {
  613                             if (len != auio.uio_resid)
  614                             log(LOG_INFO,
  615                                 "short receive (%d/%d) from nfs server %s\n",
  616                                 len - auio.uio_resid, len,
  617                                 rep->r_nmp->nm_mountp->mnt_stat.f_mntfromname);
  618                             error = EPIPE;
  619                         }
  620                 } else {
  621                         /*
  622                          * NB: Since uio_resid is big, MSG_WAITALL is ignored
  623                          * and soreceive() will return when it has either a
  624                          * control msg or a data msg.
  625                          * We have no use for control msg., but must grab them
  626                          * and then throw them away so we know what is going
  627                          * on.
  628                          */
  629                         auio.uio_resid = len = 100000000; /* Anything Big */
  630                         auio.uio_td = td;
  631                         do {
  632                             rcvflg = 0;
  633                             error =  so->so_proto->pr_usrreqs->pru_soreceive
  634                                     (so, NULL,
  635                                 &auio, mp, &control, &rcvflg);
  636                             if (control)
  637                                 m_freem(control);
  638                             if (error == EWOULDBLOCK && rep) {
  639                                 if (rep->r_flags & R_SOFTTERM)
  640                                         return (EINTR);
  641                             }
  642                         } while (error == EWOULDBLOCK ||
  643                                  (!error && *mp == NULL && control));
  644                         if ((rcvflg & MSG_EOR) == 0)
  645                                 printf("Egad!!\n");
  646                         if (!error && *mp == NULL)
  647                                 error = EPIPE;
  648                         len -= auio.uio_resid;
  649                 }
  650 errout:
  651                 if (error && error != EINTR && error != ERESTART) {
  652                         m_freem(*mp);
  653                         *mp = NULL;
  654                         if (error != EPIPE)
  655                                 log(LOG_INFO,
  656                                     "receive error %d from nfs server %s\n",
  657                                     error,
  658                                  rep->r_nmp->nm_mountp->mnt_stat.f_mntfromname);
  659                         error = nfs_sndlock(rep);
  660                         if (!error) {
  661                                 error = nfs_reconnect(rep);
  662                                 if (!error)
  663                                         goto tryagain;
  664                                 else
  665                                         nfs_sndunlock(rep);
  666                         }
  667                 }
  668         } else {
  669                 if ((so = rep->r_nmp->nm_so) == NULL)
  670                         return (EACCES);
  671                 if (so->so_state & SS_ISCONNECTED)
  672                         getnam = NULL;
  673                 else
  674                         getnam = aname;
  675                 auio.uio_resid = len = 1000000;
  676                 auio.uio_td = td;
  677                 do {
  678                         rcvflg = 0;
  679                         error =  so->so_proto->pr_usrreqs->pru_soreceive
  680                                 (so, getnam, &auio, mp,
  681                                 NULL, &rcvflg);
  682                         if (error == EWOULDBLOCK &&
  683                             (rep->r_flags & R_SOFTTERM))
  684                                 return (EINTR);
  685                 } while (error == EWOULDBLOCK);
  686                 len -= auio.uio_resid;
  687         }
  688         if (error) {
  689                 m_freem(*mp);
  690                 *mp = NULL;
  691         }
  692         /*
  693          * Search for any mbufs that are not a multiple of 4 bytes long
  694          * or with m_data not longword aligned.
  695          * These could cause pointer alignment problems, so copy them to
  696          * well aligned mbufs.
  697          */
  698         nfs_realign(mp, 5 * NFSX_UNSIGNED);
  699         return (error);
  700 }
  701 
  702 /*
  703  * Implement receipt of reply on a socket.
  704  * We must search through the list of received datagrams matching them
  705  * with outstanding requests using the xid, until ours is found.
  706  */
  707 /* ARGSUSED */
  708 static int
  709 nfs_reply(struct nfsreq *myrep)
  710 {
  711         struct nfsreq *rep;
  712         struct nfsmount *nmp = myrep->r_nmp;
  713         int32_t t1;
  714         struct mbuf *mrep, *md;
  715         struct sockaddr *nam;
  716         u_int32_t rxid, *tl;
  717         caddr_t dpos;
  718         int error;
  719 
  720         /*
  721          * Loop around until we get our own reply
  722          */
  723         for (;;) {
  724                 /*
  725                  * Lock against other receivers so that I don't get stuck in
  726                  * sbwait() after someone else has received my reply for me.
  727                  * Also necessary for connection based protocols to avoid
  728                  * race conditions during a reconnect.
  729                  * If nfs_rcvlock() returns EALREADY, that means that
  730                  * the reply has already been recieved by another
  731                  * process and we can return immediately.  In this
  732                  * case, the lock is not taken to avoid races with
  733                  * other processes.
  734                  */
  735                 error = nfs_rcvlock(myrep);
  736                 if (error == EALREADY)
  737                         return (0);
  738                 if (error)
  739                         return (error);
  740                 /*
  741                  * Get the next Rpc reply off the socket
  742                  */
  743                 error = nfs_receive(myrep, &nam, &mrep);
  744                 nfs_rcvunlock(myrep);
  745                 if (error) {
  746 
  747                         /*
  748                          * Ignore routing errors on connectionless protocols??
  749                          */
  750                         if (NFSIGNORE_SOERROR(nmp->nm_soflags, error)) {
  751                                 nmp->nm_so->so_error = 0;
  752                                 if (myrep->r_flags & R_GETONEREP)
  753                                         return (0);
  754                                 continue;
  755                         }
  756                         return (error);
  757                 }
  758                 if (nam)
  759                         FREE(nam, M_SONAME);
  760 
  761                 /*
  762                  * Get the xid and check that it is an rpc reply
  763                  */
  764                 md = mrep;
  765                 dpos = mtod(md, caddr_t);
  766                 tl = nfsm_dissect(u_int32_t *, 2 * NFSX_UNSIGNED);
  767                 rxid = *tl++;
  768                 if (*tl != rpc_reply) {
  769                         nfsstats.rpcinvalid++;
  770                         m_freem(mrep);
  771 nfsmout:
  772                         if (myrep->r_flags & R_GETONEREP)
  773                                 return (0);
  774                         continue;
  775                 }
  776 
  777                 /*
  778                  * Loop through the request list to match up the reply
  779                  * Iff no match, just drop the datagram
  780                  */
  781                 TAILQ_FOREACH(rep, &nfs_reqq, r_chain) {
  782                         if (rep->r_mrep == NULL && rxid == rep->r_xid) {
  783                                 /* Found it.. */
  784                                 rep->r_mrep = mrep;
  785                                 rep->r_md = md;
  786                                 rep->r_dpos = dpos;
  787                                 /*
  788                                  * Update congestion window.
  789                                  * Do the additive increase of
  790                                  * one rpc/rtt.
  791                                  */
  792                                 if (nmp->nm_cwnd <= nmp->nm_sent) {
  793                                         nmp->nm_cwnd +=
  794                                            (NFS_CWNDSCALE * NFS_CWNDSCALE +
  795                                            (nmp->nm_cwnd >> 1)) / nmp->nm_cwnd;
  796                                         if (nmp->nm_cwnd > NFS_MAXCWND)
  797                                                 nmp->nm_cwnd = NFS_MAXCWND;
  798                                 }
  799                                 if (rep->r_flags & R_SENT) {
  800                                         rep->r_flags &= ~R_SENT;
  801                                         nmp->nm_sent -= NFS_CWNDSCALE;
  802                                 }
  803                                 /*
  804                                  * Update rtt using a gain of 0.125 on the mean
  805                                  * and a gain of 0.25 on the deviation.
  806                                  */
  807                                 if (rep->r_flags & R_TIMING) {
  808                                         /*
  809                                          * Since the timer resolution of
  810                                          * NFS_HZ is so course, it can often
  811                                          * result in r_rtt == 0. Since
  812                                          * r_rtt == N means that the actual
  813                                          * rtt is between N+dt and N+2-dt ticks,
  814                                          * add 1.
  815                                          */
  816                                         t1 = rep->r_rtt + 1;
  817                                         t1 -= (NFS_SRTT(rep) >> 3);
  818                                         NFS_SRTT(rep) += t1;
  819                                         if (t1 < 0)
  820                                                 t1 = -t1;
  821                                         t1 -= (NFS_SDRTT(rep) >> 2);
  822                                         NFS_SDRTT(rep) += t1;
  823                                 }
  824                                 nmp->nm_timeouts = 0;
  825                                 break;
  826                         }
  827                 }
  828                 /*
  829                  * If not matched to a request, drop it.
  830                  * If it's mine, get out.
  831                  */
  832                 if (rep == 0) {
  833                         nfsstats.rpcunexpected++;
  834                         m_freem(mrep);
  835                 } else if (rep == myrep) {
  836                         if (rep->r_mrep == NULL)
  837                                 panic("nfsreply nil");
  838                         return (0);
  839                 }
  840                 if (myrep->r_flags & R_GETONEREP)
  841                         return (0);
  842         }
  843 }
  844 
  845 /*
  846  * nfs_request - goes something like this
  847  *      - fill in request struct
  848  *      - links it into list
  849  *      - calls nfs_send() for first transmit
  850  *      - calls nfs_receive() to get reply
  851  *      - break down rpc header and return with nfs reply pointed to
  852  *        by mrep or error
  853  * nb: always frees up mreq mbuf list
  854  */
  855 /* XXX overloaded before */
  856 #define NQ_TRYLATERDEL  15      /* Initial try later delay (sec) */
  857 
  858 int
  859 nfs_request(struct vnode *vp, struct mbuf *mrest, int procnum,
  860     struct thread *td, struct ucred *cred, struct mbuf **mrp,
  861     struct mbuf **mdp, caddr_t *dposp)
  862 {
  863         struct mbuf *mrep, *m2;
  864         struct nfsreq *rep;
  865         u_int32_t *tl;
  866         int i;
  867         struct nfsmount *nmp;
  868         struct mbuf *m, *md, *mheadend;
  869         time_t waituntil;
  870         caddr_t dpos;
  871         int s, error = 0, mrest_len, auth_len, auth_type;
  872         int trylater_delay = NQ_TRYLATERDEL, trylater_cnt = 0;
  873         u_int32_t xid;
  874 
  875         /* Reject requests while attempting a forced unmount. */
  876         if (vp->v_mount->mnt_kern_flag & MNTK_UNMOUNTF) {
  877                 m_freem(mrest);
  878                 return (ESTALE);
  879         }
  880         nmp = VFSTONFS(vp->v_mount);
  881         if ((nmp->nm_flag & NFSMNT_NFSV4) != 0)
  882                 return nfs4_request(vp, mrest, procnum, td, cred, mrp, mdp, dposp);
  883         MALLOC(rep, struct nfsreq *, sizeof(struct nfsreq), M_NFSREQ, M_WAITOK);
  884         rep->r_nmp = nmp;
  885         rep->r_vp = vp;
  886         rep->r_td = td;
  887         rep->r_procnum = procnum;
  888         mrest_len = m_length(mrest, NULL);
  889 
  890         /*
  891          * Get the RPC header with authorization.
  892          */
  893         auth_type = RPCAUTH_UNIX;
  894         if (cred->cr_ngroups < 1)
  895                 panic("nfsreq nogrps");
  896         auth_len = ((((cred->cr_ngroups - 1) > nmp->nm_numgrps) ?
  897                 nmp->nm_numgrps : (cred->cr_ngroups - 1)) << 2) +
  898                 5 * NFSX_UNSIGNED;
  899         m = nfsm_rpchead(cred, nmp->nm_flag, procnum, auth_type, auth_len,
  900              mrest, mrest_len, &mheadend, &xid);
  901 
  902         /*
  903          * For stream protocols, insert a Sun RPC Record Mark.
  904          */
  905         if (nmp->nm_sotype == SOCK_STREAM) {
  906                 M_PREPEND(m, NFSX_UNSIGNED, M_TRYWAIT);
  907                 *mtod(m, u_int32_t *) = htonl(0x80000000 |
  908                          (m->m_pkthdr.len - NFSX_UNSIGNED));
  909         }
  910         rep->r_mreq = m;
  911         rep->r_xid = xid;
  912 tryagain:
  913         if (nmp->nm_flag & NFSMNT_SOFT)
  914                 rep->r_retry = nmp->nm_retry;
  915         else
  916                 rep->r_retry = NFS_MAXREXMIT + 1;       /* past clip limit */
  917         rep->r_rtt = rep->r_rexmit = 0;
  918         if (proct[procnum] > 0)
  919                 rep->r_flags = R_TIMING;
  920         else
  921                 rep->r_flags = 0;
  922         rep->r_mrep = NULL;
  923 
  924         /*
  925          * Do the client side RPC.
  926          */
  927         nfsstats.rpcrequests++;
  928         /*
  929          * Chain request into list of outstanding requests. Be sure
  930          * to put it LAST so timer finds oldest requests first.
  931          */
  932         s = splsoftclock();
  933         TAILQ_INSERT_TAIL(&nfs_reqq, rep, r_chain);
  934 
  935         /*
  936          * If backing off another request or avoiding congestion, don't
  937          * send this one now but let timer do it. If not timing a request,
  938          * do it now.
  939          */
  940         if (nmp->nm_so && (nmp->nm_sotype != SOCK_DGRAM ||
  941                 (nmp->nm_flag & NFSMNT_DUMBTIMR) ||
  942                 nmp->nm_sent < nmp->nm_cwnd)) {
  943                 splx(s);
  944                 if (nmp->nm_soflags & PR_CONNREQUIRED)
  945                         error = nfs_sndlock(rep);
  946                 if (!error) {
  947                         m2 = m_copym(m, 0, M_COPYALL, M_TRYWAIT);
  948                         error = nfs_send(nmp->nm_so, nmp->nm_nam, m2, rep);
  949                         if (nmp->nm_soflags & PR_CONNREQUIRED)
  950                                 nfs_sndunlock(rep);
  951                 }
  952                 if (!error && (rep->r_flags & R_MUSTRESEND) == 0) {
  953                         nmp->nm_sent += NFS_CWNDSCALE;
  954                         rep->r_flags |= R_SENT;
  955                 }
  956         } else {
  957                 splx(s);
  958                 rep->r_rtt = -1;
  959         }
  960 
  961         /*
  962          * Wait for the reply from our send or the timer's.
  963          */
  964         if (!error || error == EPIPE)
  965                 error = nfs_reply(rep);
  966 
  967         /*
  968          * RPC done, unlink the request.
  969          */
  970         s = splsoftclock();
  971         TAILQ_REMOVE(&nfs_reqq, rep, r_chain);
  972         splx(s);
  973 
  974         /*
  975          * Decrement the outstanding request count.
  976          */
  977         if (rep->r_flags & R_SENT) {
  978                 rep->r_flags &= ~R_SENT;        /* paranoia */
  979                 nmp->nm_sent -= NFS_CWNDSCALE;
  980         }
  981 
  982         /*
  983          * If there was a successful reply and a tprintf msg.
  984          * tprintf a response.
  985          */
  986         if (!error && (rep->r_flags & R_TPRINTFMSG))
  987                 nfs_msg(rep->r_td, nmp->nm_mountp->mnt_stat.f_mntfromname,
  988                     "is alive again");
  989         mrep = rep->r_mrep;
  990         md = rep->r_md;
  991         dpos = rep->r_dpos;
  992         if (error) {
  993                 m_freem(rep->r_mreq);
  994                 free((caddr_t)rep, M_NFSREQ);
  995                 return (error);
  996         }
  997 
  998         /*
  999          * break down the rpc header and check if ok
 1000          */
 1001         tl = nfsm_dissect(u_int32_t *, 3 * NFSX_UNSIGNED);
 1002         if (*tl++ == rpc_msgdenied) {
 1003                 if (*tl == rpc_mismatch)
 1004                         error = EOPNOTSUPP;
 1005                 else
 1006                         error = EACCES;
 1007                 m_freem(mrep);
 1008                 m_freem(rep->r_mreq);
 1009                 free((caddr_t)rep, M_NFSREQ);
 1010                 return (error);
 1011         }
 1012 
 1013         /*
 1014          * Just throw away any verifyer (ie: kerberos etc).
 1015          */
 1016         i = fxdr_unsigned(int, *tl++);          /* verf type */
 1017         i = fxdr_unsigned(int32_t, *tl);        /* len */
 1018         if (i > 0)
 1019                 nfsm_adv(nfsm_rndup(i));
 1020         tl = nfsm_dissect(u_int32_t *, NFSX_UNSIGNED);
 1021         /* 0 == ok */
 1022         if (*tl == 0) {
 1023                 tl = nfsm_dissect(u_int32_t *, NFSX_UNSIGNED);
 1024                 if (*tl != 0) {
 1025                         error = fxdr_unsigned(int, *tl);
 1026                         if ((nmp->nm_flag & NFSMNT_NFSV3) &&
 1027                                 error == NFSERR_TRYLATER) {
 1028                                 m_freem(mrep);
 1029                                 error = 0;
 1030                                 waituntil = time_second + trylater_delay;
 1031                                 while (time_second < waituntil)
 1032                                         (void) tsleep(&lbolt,
 1033                                                 PSOCK, "nqnfstry", 0);
 1034                                 trylater_delay *= nfs_backoff[trylater_cnt];
 1035                                 if (trylater_cnt < NFS_NBACKOFF - 1)
 1036                                         trylater_cnt++;
 1037                                 goto tryagain;
 1038                         }
 1039 
 1040                         /*
 1041                          * If the File Handle was stale, invalidate the
 1042                          * lookup cache, just in case.
 1043                          */
 1044                         if (error == ESTALE)
 1045                                 cache_purge(vp);
 1046                         if (nmp->nm_flag & NFSMNT_NFSV3) {
 1047                                 *mrp = mrep;
 1048                                 *mdp = md;
 1049                                 *dposp = dpos;
 1050                                 error |= NFSERR_RETERR;
 1051                         } else
 1052                                 m_freem(mrep);
 1053                         m_freem(rep->r_mreq);
 1054                         free((caddr_t)rep, M_NFSREQ);
 1055                         return (error);
 1056                 }
 1057 
 1058                 *mrp = mrep;
 1059                 *mdp = md;
 1060                 *dposp = dpos;
 1061                 m_freem(rep->r_mreq);
 1062                 FREE((caddr_t)rep, M_NFSREQ);
 1063                 return (0);
 1064         }
 1065         m_freem(mrep);
 1066         error = EPROTONOSUPPORT;
 1067 nfsmout:
 1068         m_freem(rep->r_mreq);
 1069         free((caddr_t)rep, M_NFSREQ);
 1070         return (error);
 1071 }
 1072 
 1073 /*
 1074  * Nfs timer routine
 1075  * Scan the nfsreq list and retranmit any requests that have timed out
 1076  * To avoid retransmission attempts on STREAM sockets (in the future) make
 1077  * sure to set the r_retry field to 0 (implies nm_retry == 0).
 1078  */
 1079 void
 1080 nfs_timer(void *arg)
 1081 {
 1082         struct nfsreq *rep;
 1083         struct mbuf *m;
 1084         struct socket *so;
 1085         struct nfsmount *nmp;
 1086         int timeo;
 1087         int s, error;
 1088         struct thread *td;
 1089 
 1090         td = &thread0; /* XXX for credentials, may break if sleep */
 1091         s = splnet();
 1092         TAILQ_FOREACH(rep, &nfs_reqq, r_chain) {
 1093                 nmp = rep->r_nmp;
 1094                 if (rep->r_mrep || (rep->r_flags & R_SOFTTERM))
 1095                         continue;
 1096                 if (nfs_sigintr(nmp, rep, rep->r_td)) {
 1097                         nfs_softterm(rep);
 1098                         continue;
 1099                 }
 1100                 if (rep->r_rtt >= 0) {
 1101                         rep->r_rtt++;
 1102                         if (nmp->nm_flag & NFSMNT_DUMBTIMR)
 1103                                 timeo = nmp->nm_timeo;
 1104                         else
 1105                                 timeo = NFS_RTO(nmp, proct[rep->r_procnum]);
 1106                         if (nmp->nm_timeouts > 0)
 1107                                 timeo *= nfs_backoff[nmp->nm_timeouts - 1];
 1108                         if (rep->r_rtt <= timeo)
 1109                                 continue;
 1110                         if (nmp->nm_timeouts < NFS_NBACKOFF)
 1111                                 nmp->nm_timeouts++;
 1112                 }
 1113                 /*
 1114                  * Check for server not responding
 1115                  */
 1116                 if ((rep->r_flags & R_TPRINTFMSG) == 0 &&
 1117                      rep->r_rexmit > nmp->nm_deadthresh) {
 1118                         nfs_msg(rep->r_td,
 1119                             nmp->nm_mountp->mnt_stat.f_mntfromname,
 1120                             "not responding");
 1121                         rep->r_flags |= R_TPRINTFMSG;
 1122                 }
 1123                 if (rep->r_rexmit >= rep->r_retry) {    /* too many */
 1124                         nfsstats.rpctimeouts++;
 1125                         nfs_softterm(rep);
 1126                         continue;
 1127                 }
 1128                 if (nmp->nm_sotype != SOCK_DGRAM) {
 1129                         if (++rep->r_rexmit > NFS_MAXREXMIT)
 1130                                 rep->r_rexmit = NFS_MAXREXMIT;
 1131                         continue;
 1132                 }
 1133                 if ((so = nmp->nm_so) == NULL)
 1134                         continue;
 1135 
 1136                 /*
 1137                  * If there is enough space and the window allows..
 1138                  *      Resend it
 1139                  * Set r_rtt to -1 in case we fail to send it now.
 1140                  */
 1141                 rep->r_rtt = -1;
 1142                 if (sbspace(&so->so_snd) >= rep->r_mreq->m_pkthdr.len &&
 1143                    ((nmp->nm_flag & NFSMNT_DUMBTIMR) ||
 1144                     (rep->r_flags & R_SENT) ||
 1145                     nmp->nm_sent < nmp->nm_cwnd) &&
 1146                    (m = m_copym(rep->r_mreq, 0, M_COPYALL, M_DONTWAIT))){
 1147                         if ((nmp->nm_flag & NFSMNT_NOCONN) == 0)
 1148                             error = (*so->so_proto->pr_usrreqs->pru_send)
 1149                                     (so, 0, m, NULL, NULL, td);
 1150                         else
 1151                             error = (*so->so_proto->pr_usrreqs->pru_send)
 1152                                     (so, 0, m, nmp->nm_nam, NULL, td);
 1153                         if (error) {
 1154                                 if (NFSIGNORE_SOERROR(nmp->nm_soflags, error))
 1155                                         so->so_error = 0;
 1156                         } else {
 1157                                 /*
 1158                                  * Iff first send, start timing
 1159                                  * else turn timing off, backoff timer
 1160                                  * and divide congestion window by 2.
 1161                                  */
 1162                                 if (rep->r_flags & R_SENT) {
 1163                                         rep->r_flags &= ~R_TIMING;
 1164                                         if (++rep->r_rexmit > NFS_MAXREXMIT)
 1165                                                 rep->r_rexmit = NFS_MAXREXMIT;
 1166                                         nmp->nm_cwnd >>= 1;
 1167                                         if (nmp->nm_cwnd < NFS_CWNDSCALE)
 1168                                                 nmp->nm_cwnd = NFS_CWNDSCALE;
 1169                                         nfsstats.rpcretries++;
 1170                                 } else {
 1171                                         rep->r_flags |= R_SENT;
 1172                                         nmp->nm_sent += NFS_CWNDSCALE;
 1173                                 }
 1174                                 rep->r_rtt = 0;
 1175                         }
 1176                 }
 1177         }
 1178         splx(s);
 1179         nfs_timer_handle = timeout(nfs_timer, NULL, nfs_ticks);
 1180 }
 1181 
 1182 /*
 1183  * Mark all of an nfs mount's outstanding requests with R_SOFTTERM and
 1184  * wait for all requests to complete. This is used by forced unmounts
 1185  * to terminate any outstanding RPCs.
 1186  */
 1187 int
 1188 nfs_nmcancelreqs(nmp)
 1189         struct nfsmount *nmp;
 1190 {
 1191         struct nfsreq *req;
 1192         int i, s;
 1193 
 1194         s = splnet();
 1195         TAILQ_FOREACH(req, &nfs_reqq, r_chain) {
 1196                 if (nmp != req->r_nmp || req->r_mrep != NULL ||
 1197                     (req->r_flags & R_SOFTTERM))
 1198                         continue;
 1199                 nfs_softterm(req);
 1200         }
 1201         splx(s);
 1202 
 1203         for (i = 0; i < 30; i++) {
 1204                 s = splnet();
 1205                 TAILQ_FOREACH(req, &nfs_reqq, r_chain) {
 1206                         if (nmp == req->r_nmp)
 1207                                 break;
 1208                 }
 1209                 splx(s);
 1210                 if (req == NULL)
 1211                         return (0);
 1212                 tsleep(&lbolt, PSOCK, "nfscancel", 0);
 1213         }
 1214         return (EBUSY);
 1215 }
 1216 
 1217 /*
 1218  * Flag a request as being about to terminate (due to NFSMNT_INT/NFSMNT_SOFT).
 1219  * The nm_send count is decremented now to avoid deadlocks when the process in
 1220  * soreceive() hasn't yet managed to send its own request.
 1221  */
 1222 
 1223 static void
 1224 nfs_softterm(struct nfsreq *rep)
 1225 {
 1226 
 1227         rep->r_flags |= R_SOFTTERM;
 1228         if (rep->r_flags & R_SENT) {
 1229                 rep->r_nmp->nm_sent -= NFS_CWNDSCALE;
 1230                 rep->r_flags &= ~R_SENT;
 1231         }
 1232 }
 1233 
 1234 /*
 1235  * Test for a termination condition pending on the process.
 1236  * This is used for NFSMNT_INT mounts.
 1237  */
 1238 int
 1239 nfs_sigintr(struct nfsmount *nmp, struct nfsreq *rep, struct thread *td)
 1240 {
 1241         struct proc *p;
 1242         sigset_t tmpset;
 1243 
 1244         if ((nmp->nm_flag & NFSMNT_NFSV4) != 0)
 1245                 return nfs4_sigintr(nmp, rep, td);
 1246         if (rep && (rep->r_flags & R_SOFTTERM))
 1247                 return (EINTR);
 1248         /* Terminate all requests while attempting a forced unmount. */
 1249         if (nmp->nm_mountp->mnt_kern_flag & MNTK_UNMOUNTF)
 1250                 return (EINTR);
 1251         if (!(nmp->nm_flag & NFSMNT_INT))
 1252                 return (0);
 1253         if (td == NULL)
 1254                 return (0);
 1255 
 1256         p = td->td_proc;
 1257         PROC_LOCK(p);
 1258         tmpset = p->p_siglist;
 1259         SIGSETNAND(tmpset, td->td_sigmask);
 1260         mtx_lock(&p->p_sigacts->ps_mtx);
 1261         SIGSETNAND(tmpset, p->p_sigacts->ps_sigignore);
 1262         mtx_unlock(&p->p_sigacts->ps_mtx);
 1263         if (SIGNOTEMPTY(p->p_siglist) && NFSINT_SIGMASK(tmpset)) {
 1264                 PROC_UNLOCK(p);
 1265                 return (EINTR);
 1266         }
 1267         PROC_UNLOCK(p);
 1268 
 1269         return (0);
 1270 }
 1271 
 1272 /*
 1273  * Lock a socket against others.
 1274  * Necessary for STREAM sockets to ensure you get an entire rpc request/reply
 1275  * and also to avoid race conditions between the processes with nfs requests
 1276  * in progress when a reconnect is necessary.
 1277  */
 1278 int
 1279 nfs_sndlock(struct nfsreq *rep)
 1280 {
 1281         int *statep = &rep->r_nmp->nm_state;
 1282         struct thread *td;
 1283         int slpflag = 0, slptimeo = 0;
 1284 
 1285         td = rep->r_td;
 1286         if (rep->r_nmp->nm_flag & NFSMNT_INT)
 1287                 slpflag = PCATCH;
 1288         while (*statep & NFSSTA_SNDLOCK) {
 1289                 if (nfs_sigintr(rep->r_nmp, rep, td))
 1290                         return (EINTR);
 1291                 *statep |= NFSSTA_WANTSND;
 1292                 (void) tsleep(statep, slpflag | (PZERO - 1),
 1293                         "nfsndlck", slptimeo);
 1294                 if (slpflag == PCATCH) {
 1295                         slpflag = 0;
 1296                         slptimeo = 2 * hz;
 1297                 }
 1298         }
 1299         *statep |= NFSSTA_SNDLOCK;
 1300         return (0);
 1301 }
 1302 
 1303 /*
 1304  * Unlock the stream socket for others.
 1305  */
 1306 void
 1307 nfs_sndunlock(struct nfsreq *rep)
 1308 {
 1309         int *statep = &rep->r_nmp->nm_state;
 1310 
 1311         if ((*statep & NFSSTA_SNDLOCK) == 0)
 1312                 panic("nfs sndunlock");
 1313         *statep &= ~NFSSTA_SNDLOCK;
 1314         if (*statep & NFSSTA_WANTSND) {
 1315                 *statep &= ~NFSSTA_WANTSND;
 1316                 wakeup(statep);
 1317         }
 1318 }
 1319 
 1320 static int
 1321 nfs_rcvlock(struct nfsreq *rep)
 1322 {
 1323         int *statep = &rep->r_nmp->nm_state;
 1324         int slpflag, slptimeo = 0;
 1325 
 1326         if (rep->r_nmp->nm_flag & NFSMNT_INT)
 1327                 slpflag = PCATCH;
 1328         else
 1329                 slpflag = 0;
 1330         while (*statep & NFSSTA_RCVLOCK) {
 1331                 if (nfs_sigintr(rep->r_nmp, rep, rep->r_td))
 1332                         return (EINTR);
 1333                 *statep |= NFSSTA_WANTRCV;
 1334                 (void) tsleep(statep, slpflag | (PZERO - 1), "nfsrcvlk",
 1335                         slptimeo);
 1336                 /*
 1337                  * If our reply was recieved while we were sleeping,
 1338                  * then just return without taking the lock to avoid a
 1339                  * situation where a single iod could 'capture' the
 1340                  * recieve lock.
 1341                  */
 1342                 if (rep->r_mrep != NULL)
 1343                         return (EALREADY);
 1344                 if (slpflag == PCATCH) {
 1345                         slpflag = 0;
 1346                         slptimeo = 2 * hz;
 1347                 }
 1348         }
 1349         /* Always fail if our request has been cancelled. */
 1350         if (rep != NULL && (rep->r_flags & R_SOFTTERM))
 1351                 return (EINTR);
 1352         *statep |= NFSSTA_RCVLOCK;
 1353         return (0);
 1354 }
 1355 
 1356 /*
 1357  * Unlock the stream socket for others.
 1358  */
 1359 static void
 1360 nfs_rcvunlock(struct nfsreq *rep)
 1361 {
 1362         int *statep = &rep->r_nmp->nm_state;
 1363 
 1364         if ((*statep & NFSSTA_RCVLOCK) == 0)
 1365                 panic("nfs rcvunlock");
 1366         *statep &= ~NFSSTA_RCVLOCK;
 1367         if (*statep & NFSSTA_WANTRCV) {
 1368                 *statep &= ~NFSSTA_WANTRCV;
 1369                 wakeup(statep);
 1370         }
 1371 }
 1372 
 1373 /*
 1374  *      nfs_realign:
 1375  *
 1376  *      Check for badly aligned mbuf data and realign by copying the unaligned
 1377  *      portion of the data into a new mbuf chain and freeing the portions
 1378  *      of the old chain that were replaced.
 1379  *
 1380  *      We cannot simply realign the data within the existing mbuf chain
 1381  *      because the underlying buffers may contain other rpc commands and
 1382  *      we cannot afford to overwrite them.
 1383  *
 1384  *      We would prefer to avoid this situation entirely.  The situation does
 1385  *      not occur with NFS/UDP and is supposed to only occassionally occur
 1386  *      with TCP.  Use vfs.nfs.realign_count and realign_test to check this.
 1387  */
 1388 static void
 1389 nfs_realign(struct mbuf **pm, int hsiz)
 1390 {
 1391         struct mbuf *m;
 1392         struct mbuf *n = NULL;
 1393         int off = 0;
 1394 
 1395         ++nfs_realign_test;
 1396         while ((m = *pm) != NULL) {
 1397                 if ((m->m_len & 0x3) || (mtod(m, intptr_t) & 0x3)) {
 1398                         MGET(n, M_TRYWAIT, MT_DATA);
 1399                         if (m->m_len >= MINCLSIZE) {
 1400                                 MCLGET(n, M_TRYWAIT);
 1401                         }
 1402                         n->m_len = 0;
 1403                         break;
 1404                 }
 1405                 pm = &m->m_next;
 1406         }
 1407         /*
 1408          * If n is non-NULL, loop on m copying data, then replace the
 1409          * portion of the chain that had to be realigned.
 1410          */
 1411         if (n != NULL) {
 1412                 ++nfs_realign_count;
 1413                 while (m) {
 1414                         m_copyback(n, off, m->m_len, mtod(m, caddr_t));
 1415                         off += m->m_len;
 1416                         m = m->m_next;
 1417                 }
 1418                 m_freem(*pm);
 1419                 *pm = n;
 1420         }
 1421 }
 1422 
 1423 
 1424 static int
 1425 nfs_msg(struct thread *td, char *server, char *msg)
 1426 {
 1427 
 1428         tprintf(td ? td->td_proc : NULL, LOG_INFO,
 1429             "nfs server %s: %s\n", server, msg);
 1430         return (0);
 1431 }

Cache object: 2b02fedabb5721b27f363f026f809ab8


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.