xref: /csrg-svn/sys/nfs/nfs_socket.c (revision 56535)
1 /*
2  * Copyright (c) 1989, 1991 The Regents of the University of California.
3  * 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  * %sccs.include.redist.c%
9  *
10  *	@(#)nfs_socket.c	7.39 (Berkeley) 10/11/92
11  */
12 
13 /*
14  * Socket operations for use by nfs
15  */
16 
17 #include <sys/param.h>
18 #include <sys/systm.h>
19 #include <sys/proc.h>
20 #include <sys/mount.h>
21 #include <sys/kernel.h>
22 #include <sys/mbuf.h>
23 #include <sys/vnode.h>
24 #include <sys/domain.h>
25 #include <sys/protosw.h>
26 #include <sys/socket.h>
27 #include <sys/socketvar.h>
28 #include <sys/syslog.h>
29 #include <sys/tprintf.h>
30 
31 #include <netinet/in.h>
32 #include <netinet/tcp.h>
33 #include <nfs/rpcv2.h>
34 #include <nfs/nfsv2.h>
35 #include <nfs/nfs.h>
36 #include <nfs/xdr_subs.h>
37 #include <nfs/nfsm_subs.h>
38 #include <nfs/nfsmount.h>
39 #include <nfs/nfsnode.h>
40 #include <nfs/nfsrtt.h>
41 #include <nfs/nqnfs.h>
42 
43 #define	TRUE	1
44 #define	FALSE	0
45 
46 /*
47  * Estimate rto for an nfs rpc sent via. an unreliable datagram.
48  * Use the mean and mean deviation of rtt for the appropriate type of rpc
49  * for the frequent rpcs and a default for the others.
50  * The justification for doing "other" this way is that these rpcs
51  * happen so infrequently that timer est. would probably be stale.
52  * Also, since many of these rpcs are
53  * non-idempotent, a conservative timeout is desired.
54  * getattr, lookup - A+2D
55  * read, write     - A+4D
56  * other           - nm_timeo
57  */
58 #define	NFS_RTO(n, t) \
59 	((t) == 0 ? (n)->nm_timeo : \
60 	 ((t) < 3 ? \
61 	  (((((n)->nm_srtt[t-1] + 3) >> 2) + (n)->nm_sdrtt[t-1] + 1) >> 1) : \
62 	  ((((n)->nm_srtt[t-1] + 7) >> 3) + (n)->nm_sdrtt[t-1] + 1)))
63 #define	NFS_SRTT(r)	(r)->r_nmp->nm_srtt[proct[(r)->r_procnum] - 1]
64 #define	NFS_SDRTT(r)	(r)->r_nmp->nm_sdrtt[proct[(r)->r_procnum] - 1]
65 /*
66  * External data, mostly RPC constants in XDR form
67  */
68 extern u_long rpc_reply, rpc_msgdenied, rpc_mismatch, rpc_vers, rpc_auth_unix,
69 	rpc_msgaccepted, rpc_call, rpc_autherr, rpc_rejectedcred,
70 	rpc_auth_kerb;
71 extern u_long nfs_prog, nfs_vers, nqnfs_prog, nqnfs_vers;
72 extern time_t nqnfsstarttime;
73 extern int nonidempotent[NFS_NPROCS];
74 
75 /*
76  * Maps errno values to nfs error numbers.
77  * Use NFSERR_IO as the catch all for ones not specifically defined in
78  * RFC 1094.
79  */
80 static int nfsrv_errmap[ELAST] = {
81   NFSERR_PERM,	NFSERR_NOENT,	NFSERR_IO,	NFSERR_IO,	NFSERR_IO,
82   NFSERR_NXIO,	NFSERR_IO,	NFSERR_IO,	NFSERR_IO,	NFSERR_IO,
83   NFSERR_IO,	NFSERR_IO,	NFSERR_ACCES,	NFSERR_IO,	NFSERR_IO,
84   NFSERR_IO,	NFSERR_EXIST,	NFSERR_IO,	NFSERR_NODEV,	NFSERR_NOTDIR,
85   NFSERR_ISDIR,	NFSERR_IO,	NFSERR_IO,	NFSERR_IO,	NFSERR_IO,
86   NFSERR_IO,	NFSERR_FBIG,	NFSERR_NOSPC,	NFSERR_IO,	NFSERR_ROFS,
87   NFSERR_IO,	NFSERR_IO,	NFSERR_IO,	NFSERR_IO,	NFSERR_IO,
88   NFSERR_IO,	NFSERR_IO,	NFSERR_IO,	NFSERR_IO,	NFSERR_IO,
89   NFSERR_IO,	NFSERR_IO,	NFSERR_IO,	NFSERR_IO,	NFSERR_IO,
90   NFSERR_IO,	NFSERR_IO,	NFSERR_IO,	NFSERR_IO,	NFSERR_IO,
91   NFSERR_IO,	NFSERR_IO,	NFSERR_IO,	NFSERR_IO,	NFSERR_IO,
92   NFSERR_IO,	NFSERR_IO,	NFSERR_IO,	NFSERR_IO,	NFSERR_IO,
93   NFSERR_IO,	NFSERR_IO,	NFSERR_NAMETOL,	NFSERR_IO,	NFSERR_IO,
94   NFSERR_NOTEMPTY, NFSERR_IO,	NFSERR_IO,	NFSERR_DQUOT,	NFSERR_STALE,
95   NFSERR_IO,	NFSERR_IO,	NFSERR_IO,	NFSERR_IO,	NFSERR_IO,
96   NFSERR_IO,	NFSERR_IO,	NFSERR_IO,	NFSERR_IO,	NFSERR_IO,
97   NFSERR_IO,
98 };
99 
100 /*
101  * Defines which timer to use for the procnum.
102  * 0 - default
103  * 1 - getattr
104  * 2 - lookup
105  * 3 - read
106  * 4 - write
107  */
108 static int proct[NFS_NPROCS] = {
109 	0, 1, 0, 0, 2, 3, 3, 0, 4, 0, 0, 0, 0, 0, 0, 0, 3, 0, 3, 0, 0, 0, 0,
110 };
111 
112 /*
113  * There is a congestion window for outstanding rpcs maintained per mount
114  * point. The cwnd size is adjusted in roughly the way that:
115  * Van Jacobson, Congestion avoidance and Control, In "Proceedings of
116  * SIGCOMM '88". ACM, August 1988.
117  * describes for TCP. The cwnd size is chopped in half on a retransmit timeout
118  * and incremented by 1/cwnd when each rpc reply is received and a full cwnd
119  * of rpcs is in progress.
120  * (The sent count and cwnd are scaled for integer arith.)
121  * Variants of "slow start" were tried and were found to be too much of a
122  * performance hit (ave. rtt 3 times larger),
123  * I suspect due to the large rtt that nfs rpcs have.
124  */
125 #define	NFS_CWNDSCALE	256
126 #define	NFS_MAXCWND	(NFS_CWNDSCALE * 32)
127 static int nfs_backoff[8] = { 2, 4, 8, 16, 32, 64, 128, 256, };
128 int	nfs_sbwait();
129 void	nfs_disconnect(), nfs_realign(), nfsrv_wakenfsd(), nfs_sndunlock();
130 void	nfs_rcvunlock(), nqnfs_serverd(), nqnfs_clientlease();
131 struct mbuf *nfsm_rpchead();
132 int nfsrtton = 0;
133 struct nfsrtt nfsrtt;
134 struct nfsd nfsd_head;
135 
136 int	nfsrv_null(),
137 	nfsrv_getattr(),
138 	nfsrv_setattr(),
139 	nfsrv_lookup(),
140 	nfsrv_readlink(),
141 	nfsrv_read(),
142 	nfsrv_write(),
143 	nfsrv_create(),
144 	nfsrv_remove(),
145 	nfsrv_rename(),
146 	nfsrv_link(),
147 	nfsrv_symlink(),
148 	nfsrv_mkdir(),
149 	nfsrv_rmdir(),
150 	nfsrv_readdir(),
151 	nfsrv_statfs(),
152 	nfsrv_noop(),
153 	nqnfsrv_readdirlook(),
154 	nqnfsrv_getlease(),
155 	nqnfsrv_vacated(),
156 	nqnfsrv_access();
157 
158 int (*nfsrv_procs[NFS_NPROCS])() = {
159 	nfsrv_null,
160 	nfsrv_getattr,
161 	nfsrv_setattr,
162 	nfsrv_noop,
163 	nfsrv_lookup,
164 	nfsrv_readlink,
165 	nfsrv_read,
166 	nfsrv_noop,
167 	nfsrv_write,
168 	nfsrv_create,
169 	nfsrv_remove,
170 	nfsrv_rename,
171 	nfsrv_link,
172 	nfsrv_symlink,
173 	nfsrv_mkdir,
174 	nfsrv_rmdir,
175 	nfsrv_readdir,
176 	nfsrv_statfs,
177 	nqnfsrv_readdirlook,
178 	nqnfsrv_getlease,
179 	nqnfsrv_vacated,
180 	nfsrv_noop,
181 	nqnfsrv_access,
182 };
183 
184 struct nfsreq nfsreqh;
185 
186 /*
187  * Initialize sockets and congestion for a new NFS connection.
188  * We do not free the sockaddr if error.
189  */
190 nfs_connect(nmp, rep)
191 	register struct nfsmount *nmp;
192 	struct nfsreq *rep;
193 {
194 	register struct socket *so;
195 	int s, error, rcvreserve, sndreserve;
196 	struct sockaddr *saddr;
197 	struct sockaddr_in *sin;
198 	struct mbuf *m;
199 	u_short tport;
200 
201 	nmp->nm_so = (struct socket *)0;
202 	saddr = mtod(nmp->nm_nam, struct sockaddr *);
203 	if (error = socreate(saddr->sa_family,
204 		&nmp->nm_so, nmp->nm_sotype, nmp->nm_soproto))
205 		goto bad;
206 	so = nmp->nm_so;
207 	nmp->nm_soflags = so->so_proto->pr_flags;
208 
209 	/*
210 	 * Some servers require that the client port be a reserved port number.
211 	 */
212 	if (saddr->sa_family == AF_INET && (nmp->nm_flag & NFSMNT_RESVPORT)) {
213 		MGET(m, M_WAIT, MT_SONAME);
214 		sin = mtod(m, struct sockaddr_in *);
215 		sin->sin_len = m->m_len = sizeof (struct sockaddr_in);
216 		sin->sin_family = AF_INET;
217 		sin->sin_addr.s_addr = INADDR_ANY;
218 		tport = IPPORT_RESERVED - 1;
219 		sin->sin_port = htons(tport);
220 		while ((error = sobind(so, m)) == EADDRINUSE &&
221 		       --tport > IPPORT_RESERVED / 2)
222 			sin->sin_port = htons(tport);
223 		m_freem(m);
224 		if (error)
225 			goto bad;
226 	}
227 
228 	/*
229 	 * Protocols that do not require connections may be optionally left
230 	 * unconnected for servers that reply from a port other than NFS_PORT.
231 	 */
232 	if (nmp->nm_flag & NFSMNT_NOCONN) {
233 		if (nmp->nm_soflags & PR_CONNREQUIRED) {
234 			error = ENOTCONN;
235 			goto bad;
236 		}
237 	} else {
238 		if (error = soconnect(so, nmp->nm_nam))
239 			goto bad;
240 
241 		/*
242 		 * Wait for the connection to complete. Cribbed from the
243 		 * connect system call but with the wait timing out so
244 		 * that interruptible mounts don't hang here for a long time.
245 		 */
246 		s = splnet();
247 		while ((so->so_state & SS_ISCONNECTING) && so->so_error == 0) {
248 			(void) tsleep((caddr_t)&so->so_timeo, PSOCK,
249 				"nfscon", 2 * hz);
250 			if ((so->so_state & SS_ISCONNECTING) &&
251 			    so->so_error == 0 && rep &&
252 			    (error = nfs_sigintr(nmp, rep, rep->r_procp))) {
253 				so->so_state &= ~SS_ISCONNECTING;
254 				splx(s);
255 				goto bad;
256 			}
257 		}
258 		if (so->so_error) {
259 			error = so->so_error;
260 			so->so_error = 0;
261 			splx(s);
262 			goto bad;
263 		}
264 		splx(s);
265 	}
266 	if (nmp->nm_flag & (NFSMNT_SOFT | NFSMNT_INT)) {
267 		so->so_rcv.sb_timeo = (5 * hz);
268 		so->so_snd.sb_timeo = (5 * hz);
269 	} else {
270 		so->so_rcv.sb_timeo = 0;
271 		so->so_snd.sb_timeo = 0;
272 	}
273 	if (nmp->nm_sotype == SOCK_DGRAM) {
274 		sndreserve = nmp->nm_wsize + NFS_MAXPKTHDR;
275 		rcvreserve = nmp->nm_rsize + NFS_MAXPKTHDR;
276 	} else if (nmp->nm_sotype == SOCK_SEQPACKET) {
277 		sndreserve = (nmp->nm_wsize + NFS_MAXPKTHDR) * 2;
278 		rcvreserve = (nmp->nm_rsize + NFS_MAXPKTHDR) * 2;
279 	} else {
280 		if (nmp->nm_sotype != SOCK_STREAM)
281 			panic("nfscon sotype");
282 		if (so->so_proto->pr_flags & PR_CONNREQUIRED) {
283 			MGET(m, M_WAIT, MT_SOOPTS);
284 			*mtod(m, int *) = 1;
285 			m->m_len = sizeof(int);
286 			sosetopt(so, SOL_SOCKET, SO_KEEPALIVE, m);
287 		}
288 		if (so->so_proto->pr_protocol == IPPROTO_TCP) {
289 			MGET(m, M_WAIT, MT_SOOPTS);
290 			*mtod(m, int *) = 1;
291 			m->m_len = sizeof(int);
292 			sosetopt(so, IPPROTO_TCP, TCP_NODELAY, m);
293 		}
294 		sndreserve = (nmp->nm_wsize + NFS_MAXPKTHDR + sizeof (u_long))
295 				* 2;
296 		rcvreserve = (nmp->nm_rsize + NFS_MAXPKTHDR + sizeof (u_long))
297 				* 2;
298 	}
299 	if (error = soreserve(so, sndreserve, rcvreserve))
300 		goto bad;
301 	so->so_rcv.sb_flags |= SB_NOINTR;
302 	so->so_snd.sb_flags |= SB_NOINTR;
303 
304 	/* Initialize other non-zero congestion variables */
305 	nmp->nm_srtt[0] = nmp->nm_srtt[1] = nmp->nm_srtt[2] = nmp->nm_srtt[3] =
306 		nmp->nm_srtt[4] = (NFS_TIMEO << 3);
307 	nmp->nm_sdrtt[0] = nmp->nm_sdrtt[1] = nmp->nm_sdrtt[2] =
308 		nmp->nm_sdrtt[3] = nmp->nm_sdrtt[4] = 0;
309 	nmp->nm_cwnd = NFS_MAXCWND / 2;	    /* Initial send window */
310 	nmp->nm_sent = 0;
311 	nmp->nm_timeouts = 0;
312 	return (0);
313 
314 bad:
315 	nfs_disconnect(nmp);
316 	return (error);
317 }
318 
319 /*
320  * Reconnect routine:
321  * Called when a connection is broken on a reliable protocol.
322  * - clean up the old socket
323  * - nfs_connect() again
324  * - set R_MUSTRESEND for all outstanding requests on mount point
325  * If this fails the mount point is DEAD!
326  * nb: Must be called with the nfs_sndlock() set on the mount point.
327  */
328 nfs_reconnect(rep)
329 	register struct nfsreq *rep;
330 {
331 	register struct nfsreq *rp;
332 	register struct nfsmount *nmp = rep->r_nmp;
333 	int error;
334 
335 	nfs_disconnect(nmp);
336 	while (error = nfs_connect(nmp, rep)) {
337 		if (error == EINTR || error == ERESTART)
338 			return (EINTR);
339 		(void) tsleep((caddr_t)&lbolt, PSOCK, "nfscon", 0);
340 	}
341 
342 	/*
343 	 * Loop through outstanding request list and fix up all requests
344 	 * on old socket.
345 	 */
346 	rp = nfsreqh.r_next;
347 	while (rp != &nfsreqh) {
348 		if (rp->r_nmp == nmp)
349 			rp->r_flags |= R_MUSTRESEND;
350 		rp = rp->r_next;
351 	}
352 	return (0);
353 }
354 
355 /*
356  * NFS disconnect. Clean up and unlink.
357  */
358 void
359 nfs_disconnect(nmp)
360 	register struct nfsmount *nmp;
361 {
362 	register struct socket *so;
363 
364 	if (nmp->nm_so) {
365 		so = nmp->nm_so;
366 		nmp->nm_so = (struct socket *)0;
367 		soshutdown(so, 2);
368 		soclose(so);
369 	}
370 }
371 
372 /*
373  * This is the nfs send routine. For connection based socket types, it
374  * must be called with an nfs_sndlock() on the socket.
375  * "rep == NULL" indicates that it has been called from a server.
376  * For the client side:
377  * - return EINTR if the RPC is terminated, 0 otherwise
378  * - set R_MUSTRESEND if the send fails for any reason
379  * - do any cleanup required by recoverable socket errors (???)
380  * For the server side:
381  * - return EINTR or ERESTART if interrupted by a signal
382  * - return EPIPE if a connection is lost for connection based sockets (TCP...)
383  * - do any cleanup required by recoverable socket errors (???)
384  */
385 nfs_send(so, nam, top, rep)
386 	register struct socket *so;
387 	struct mbuf *nam;
388 	register struct mbuf *top;
389 	struct nfsreq *rep;
390 {
391 	struct mbuf *sendnam;
392 	int error, soflags, flags;
393 
394 	if (rep) {
395 		if (rep->r_flags & R_SOFTTERM) {
396 			m_freem(top);
397 			return (EINTR);
398 		}
399 		if ((so = rep->r_nmp->nm_so) == NULL) {
400 			rep->r_flags |= R_MUSTRESEND;
401 			m_freem(top);
402 			return (0);
403 		}
404 		rep->r_flags &= ~R_MUSTRESEND;
405 		soflags = rep->r_nmp->nm_soflags;
406 	} else
407 		soflags = so->so_proto->pr_flags;
408 	if ((soflags & PR_CONNREQUIRED) || (so->so_state & SS_ISCONNECTED))
409 		sendnam = (struct mbuf *)0;
410 	else
411 		sendnam = nam;
412 	if (so->so_type == SOCK_SEQPACKET)
413 		flags = MSG_EOR;
414 	else
415 		flags = 0;
416 
417 	error = sosend(so, sendnam, (struct uio *)0, top,
418 		(struct mbuf *)0, flags);
419 	if (error) {
420 		if (rep) {
421 			log(LOG_INFO, "nfs send error %d for server %s\n",error,
422 			    rep->r_nmp->nm_mountp->mnt_stat.f_mntfromname);
423 			/*
424 			 * Deal with errors for the client side.
425 			 */
426 			if (rep->r_flags & R_SOFTTERM)
427 				error = EINTR;
428 			else
429 				rep->r_flags |= R_MUSTRESEND;
430 		} else
431 			log(LOG_INFO, "nfsd send error %d\n", error);
432 
433 		/*
434 		 * Handle any recoverable (soft) socket errors here. (???)
435 		 */
436 		if (error != EINTR && error != ERESTART &&
437 			error != EWOULDBLOCK && error != EPIPE)
438 			error = 0;
439 	}
440 	return (error);
441 }
442 
443 /*
444  * Receive a Sun RPC Request/Reply. For SOCK_DGRAM, the work is all
445  * done by soreceive(), but for SOCK_STREAM we must deal with the Record
446  * Mark and consolidate the data into a new mbuf list.
447  * nb: Sometimes TCP passes the data up to soreceive() in long lists of
448  *     small mbufs.
449  * For SOCK_STREAM we must be very careful to read an entire record once
450  * we have read any of it, even if the system call has been interrupted.
451  */
452 nfs_receive(rep, aname, mp)
453 	register struct nfsreq *rep;
454 	struct mbuf **aname;
455 	struct mbuf **mp;
456 {
457 	register struct socket *so;
458 	struct uio auio;
459 	struct iovec aio;
460 	register struct mbuf *m;
461 	struct mbuf *control;
462 	u_long len;
463 	struct mbuf **getnam;
464 	int error, sotype, rcvflg;
465 	struct proc *p = curproc;	/* XXX */
466 
467 	/*
468 	 * Set up arguments for soreceive()
469 	 */
470 	*mp = (struct mbuf *)0;
471 	*aname = (struct mbuf *)0;
472 	sotype = rep->r_nmp->nm_sotype;
473 
474 	/*
475 	 * For reliable protocols, lock against other senders/receivers
476 	 * in case a reconnect is necessary.
477 	 * For SOCK_STREAM, first get the Record Mark to find out how much
478 	 * more there is to get.
479 	 * We must lock the socket against other receivers
480 	 * until we have an entire rpc request/reply.
481 	 */
482 	if (sotype != SOCK_DGRAM) {
483 		if (error = nfs_sndlock(&rep->r_nmp->nm_flag, rep))
484 			return (error);
485 tryagain:
486 		/*
487 		 * Check for fatal errors and resending request.
488 		 */
489 		/*
490 		 * Ugh: If a reconnect attempt just happened, nm_so
491 		 * would have changed. NULL indicates a failed
492 		 * attempt that has essentially shut down this
493 		 * mount point.
494 		 */
495 		if (rep->r_mrep || (rep->r_flags & R_SOFTTERM)) {
496 			nfs_sndunlock(&rep->r_nmp->nm_flag);
497 			return (EINTR);
498 		}
499 		if ((so = rep->r_nmp->nm_so) == NULL) {
500 			if (error = nfs_reconnect(rep)) {
501 				nfs_sndunlock(&rep->r_nmp->nm_flag);
502 				return (error);
503 			}
504 			goto tryagain;
505 		}
506 		while (rep->r_flags & R_MUSTRESEND) {
507 			m = m_copym(rep->r_mreq, 0, M_COPYALL, M_WAIT);
508 			nfsstats.rpcretries++;
509 			if (error = nfs_send(so, rep->r_nmp->nm_nam, m, rep)) {
510 				if (error == EINTR || error == ERESTART ||
511 				    (error = nfs_reconnect(rep))) {
512 					nfs_sndunlock(&rep->r_nmp->nm_flag);
513 					return (error);
514 				}
515 				goto tryagain;
516 			}
517 		}
518 		nfs_sndunlock(&rep->r_nmp->nm_flag);
519 		if (sotype == SOCK_STREAM) {
520 			aio.iov_base = (caddr_t) &len;
521 			aio.iov_len = sizeof(u_long);
522 			auio.uio_iov = &aio;
523 			auio.uio_iovcnt = 1;
524 			auio.uio_segflg = UIO_SYSSPACE;
525 			auio.uio_rw = UIO_READ;
526 			auio.uio_offset = 0;
527 			auio.uio_resid = sizeof(u_long);
528 			auio.uio_procp = p;
529 			do {
530 			   rcvflg = MSG_WAITALL;
531 			   error = soreceive(so, (struct mbuf **)0, &auio,
532 				(struct mbuf **)0, (struct mbuf **)0, &rcvflg);
533 			   if (error == EWOULDBLOCK && rep) {
534 				if (rep->r_flags & R_SOFTTERM)
535 					return (EINTR);
536 			   }
537 			} while (error == EWOULDBLOCK);
538 			if (!error && auio.uio_resid > 0) {
539 			    log(LOG_INFO,
540 				 "short receive (%d/%d) from nfs server %s\n",
541 				 sizeof(u_long) - auio.uio_resid,
542 				 sizeof(u_long),
543 				 rep->r_nmp->nm_mountp->mnt_stat.f_mntfromname);
544 			    error = EPIPE;
545 			}
546 			if (error)
547 				goto errout;
548 			len = ntohl(len) & ~0x80000000;
549 			/*
550 			 * This is SERIOUS! We are out of sync with the sender
551 			 * and forcing a disconnect/reconnect is all I can do.
552 			 */
553 			if (len > NFS_MAXPACKET) {
554 			    log(LOG_ERR, "%s (%d) from nfs server %s\n",
555 				"impossible packet length",
556 				len,
557 				rep->r_nmp->nm_mountp->mnt_stat.f_mntfromname);
558 			    error = EFBIG;
559 			    goto errout;
560 			}
561 			auio.uio_resid = len;
562 			do {
563 			    rcvflg = MSG_WAITALL;
564 			    error =  soreceive(so, (struct mbuf **)0,
565 				&auio, mp, (struct mbuf **)0, &rcvflg);
566 			} while (error == EWOULDBLOCK || error == EINTR ||
567 				 error == ERESTART);
568 			if (!error && auio.uio_resid > 0) {
569 			    log(LOG_INFO,
570 				"short receive (%d/%d) from nfs server %s\n",
571 				len - auio.uio_resid, len,
572 				rep->r_nmp->nm_mountp->mnt_stat.f_mntfromname);
573 			    error = EPIPE;
574 			}
575 		} else {
576 			/*
577 			 * NB: Since uio_resid is big, MSG_WAITALL is ignored
578 			 * and soreceive() will return when it has either a
579 			 * control msg or a data msg.
580 			 * We have no use for control msg., but must grab them
581 			 * and then throw them away so we know what is going
582 			 * on.
583 			 */
584 			auio.uio_resid = len = 100000000; /* Anything Big */
585 			auio.uio_procp = p;
586 			do {
587 			    rcvflg = 0;
588 			    error =  soreceive(so, (struct mbuf **)0,
589 				&auio, mp, &control, &rcvflg);
590 			    if (control)
591 				m_freem(control);
592 			    if (error == EWOULDBLOCK && rep) {
593 				if (rep->r_flags & R_SOFTTERM)
594 					return (EINTR);
595 			    }
596 			} while (error == EWOULDBLOCK ||
597 				 (!error && *mp == NULL && control));
598 			if ((rcvflg & MSG_EOR) == 0)
599 				printf("Egad!!\n");
600 			if (!error && *mp == NULL)
601 				error = EPIPE;
602 			len -= auio.uio_resid;
603 		}
604 errout:
605 		if (error && error != EINTR && error != ERESTART) {
606 			m_freem(*mp);
607 			*mp = (struct mbuf *)0;
608 			if (error != EPIPE)
609 				log(LOG_INFO,
610 				    "receive error %d from nfs server %s\n",
611 				    error,
612 				 rep->r_nmp->nm_mountp->mnt_stat.f_mntfromname);
613 			error = nfs_sndlock(&rep->r_nmp->nm_flag, rep);
614 			if (!error)
615 				error = nfs_reconnect(rep);
616 			if (!error)
617 				goto tryagain;
618 		}
619 	} else {
620 		if ((so = rep->r_nmp->nm_so) == NULL)
621 			return (EACCES);
622 		if (so->so_state & SS_ISCONNECTED)
623 			getnam = (struct mbuf **)0;
624 		else
625 			getnam = aname;
626 		auio.uio_resid = len = 1000000;
627 		auio.uio_procp = p;
628 		do {
629 			rcvflg = 0;
630 			error =  soreceive(so, getnam, &auio, mp,
631 				(struct mbuf **)0, &rcvflg);
632 			if (error == EWOULDBLOCK &&
633 			    (rep->r_flags & R_SOFTTERM))
634 				return (EINTR);
635 		} while (error == EWOULDBLOCK);
636 		len -= auio.uio_resid;
637 	}
638 	if (error) {
639 		m_freem(*mp);
640 		*mp = (struct mbuf *)0;
641 	}
642 	/*
643 	 * Search for any mbufs that are not a multiple of 4 bytes long
644 	 * or with m_data not longword aligned.
645 	 * These could cause pointer alignment problems, so copy them to
646 	 * well aligned mbufs.
647 	 */
648 	nfs_realign(*mp, 5 * NFSX_UNSIGNED);
649 	return (error);
650 }
651 
652 /*
653  * Implement receipt of reply on a socket.
654  * We must search through the list of received datagrams matching them
655  * with outstanding requests using the xid, until ours is found.
656  */
657 /* ARGSUSED */
658 nfs_reply(myrep)
659 	struct nfsreq *myrep;
660 {
661 	register struct nfsreq *rep;
662 	register struct nfsmount *nmp = myrep->r_nmp;
663 	register long t1;
664 	struct mbuf *mrep, *nam, *md;
665 	u_long rxid, *tl;
666 	caddr_t dpos, cp2;
667 	int error;
668 
669 	/*
670 	 * Loop around until we get our own reply
671 	 */
672 	for (;;) {
673 		/*
674 		 * Lock against other receivers so that I don't get stuck in
675 		 * sbwait() after someone else has received my reply for me.
676 		 * Also necessary for connection based protocols to avoid
677 		 * race conditions during a reconnect.
678 		 */
679 		if (error = nfs_rcvlock(myrep))
680 			return (error);
681 		/* Already received, bye bye */
682 		if (myrep->r_mrep != NULL) {
683 			nfs_rcvunlock(&nmp->nm_flag);
684 			return (0);
685 		}
686 		/*
687 		 * Get the next Rpc reply off the socket
688 		 */
689 		error = nfs_receive(myrep, &nam, &mrep);
690 		nfs_rcvunlock(&nmp->nm_flag);
691 if (error) printf("rcv err=%d\n",error);
692 		if (error) {
693 
694 			/*
695 			 * Ignore routing errors on connectionless protocols??
696 			 */
697 			if (NFSIGNORE_SOERROR(nmp->nm_soflags, error)) {
698 				nmp->nm_so->so_error = 0;
699 				continue;
700 			}
701 			return (error);
702 		}
703 		if (nam)
704 			m_freem(nam);
705 
706 		/*
707 		 * Get the xid and check that it is an rpc reply
708 		 */
709 		md = mrep;
710 		dpos = mtod(md, caddr_t);
711 		nfsm_dissect(tl, u_long *, 2*NFSX_UNSIGNED);
712 		rxid = *tl++;
713 		if (*tl != rpc_reply) {
714 			if (nmp->nm_flag & NFSMNT_NQNFS) {
715 				if (nqnfs_callback(nmp, mrep, md, dpos))
716 					nfsstats.rpcinvalid++;
717 			} else {
718 				nfsstats.rpcinvalid++;
719 				m_freem(mrep);
720 			}
721 nfsmout:
722 			continue;
723 		}
724 
725 		/*
726 		 * Loop through the request list to match up the reply
727 		 * Iff no match, just drop the datagram
728 		 */
729 		rep = nfsreqh.r_next;
730 		while (rep != &nfsreqh) {
731 			if (rep->r_mrep == NULL && rxid == rep->r_xid) {
732 				/* Found it.. */
733 				rep->r_mrep = mrep;
734 				rep->r_md = md;
735 				rep->r_dpos = dpos;
736 				if (nfsrtton) {
737 					struct rttl *rt;
738 
739 					rt = &nfsrtt.rttl[nfsrtt.pos];
740 					rt->proc = rep->r_procnum;
741 					rt->rto = NFS_RTO(nmp, proct[rep->r_procnum]);
742 					rt->sent = nmp->nm_sent;
743 					rt->cwnd = nmp->nm_cwnd;
744 					rt->srtt = nmp->nm_srtt[proct[rep->r_procnum] - 1];
745 					rt->sdrtt = nmp->nm_sdrtt[proct[rep->r_procnum] - 1];
746 					rt->fsid = nmp->nm_mountp->mnt_stat.f_fsid;
747 					rt->tstamp = time;
748 					if (rep->r_flags & R_TIMING)
749 						rt->rtt = rep->r_rtt;
750 					else
751 						rt->rtt = 1000000;
752 					nfsrtt.pos = (nfsrtt.pos + 1) % NFSRTTLOGSIZ;
753 				}
754 				/*
755 				 * Update congestion window.
756 				 * Do the additive increase of
757 				 * one rpc/rtt.
758 				 */
759 				if (nmp->nm_cwnd <= nmp->nm_sent) {
760 					nmp->nm_cwnd +=
761 					   (NFS_CWNDSCALE * NFS_CWNDSCALE +
762 					   (nmp->nm_cwnd >> 1)) / nmp->nm_cwnd;
763 					if (nmp->nm_cwnd > NFS_MAXCWND)
764 						nmp->nm_cwnd = NFS_MAXCWND;
765 				}
766 				nmp->nm_sent -= NFS_CWNDSCALE;
767 				/*
768 				 * Update rtt using a gain of 0.125 on the mean
769 				 * and a gain of 0.25 on the deviation.
770 				 */
771 				if (rep->r_flags & R_TIMING) {
772 					/*
773 					 * Since the timer resolution of
774 					 * NFS_HZ is so course, it can often
775 					 * result in r_rtt == 0. Since
776 					 * r_rtt == N means that the actual
777 					 * rtt is between N+dt and N+2-dt ticks,
778 					 * add 1.
779 					 */
780 					t1 = rep->r_rtt + 1;
781 					t1 -= (NFS_SRTT(rep) >> 3);
782 					NFS_SRTT(rep) += t1;
783 					if (t1 < 0)
784 						t1 = -t1;
785 					t1 -= (NFS_SDRTT(rep) >> 2);
786 					NFS_SDRTT(rep) += t1;
787 				}
788 				nmp->nm_timeouts = 0;
789 				break;
790 			}
791 			rep = rep->r_next;
792 		}
793 		/*
794 		 * If not matched to a request, drop it.
795 		 * If it's mine, get out.
796 		 */
797 		if (rep == &nfsreqh) {
798 			nfsstats.rpcunexpected++;
799 			m_freem(mrep);
800 		} else if (rep == myrep) {
801 			if (rep->r_mrep == NULL)
802 				panic("nfsreply nil");
803 			return (0);
804 		}
805 	}
806 }
807 
808 /*
809  * nfs_request - goes something like this
810  *	- fill in request struct
811  *	- links it into list
812  *	- calls nfs_send() for first transmit
813  *	- calls nfs_receive() to get reply
814  *	- break down rpc header and return with nfs reply pointed to
815  *	  by mrep or error
816  * nb: always frees up mreq mbuf list
817  */
818 nfs_request(vp, mrest, procnum, procp, cred, mrp, mdp, dposp)
819 	struct vnode *vp;
820 	struct mbuf *mrest;
821 	int procnum;
822 	struct proc *procp;
823 	struct ucred *cred;
824 	struct mbuf **mrp;
825 	struct mbuf **mdp;
826 	caddr_t *dposp;
827 {
828 	register struct mbuf *m, *mrep;
829 	register struct nfsreq *rep;
830 	register u_long *tl;
831 	register int i;
832 	struct nfsmount *nmp;
833 	struct mbuf *md, *mheadend;
834 	struct nfsreq *reph;
835 	struct nfsnode *tp, *np;
836 	time_t reqtime, waituntil;
837 	caddr_t dpos, cp2;
838 	int t1, nqlflag, cachable, s, error = 0, mrest_len, auth_len, auth_type;
839 	int trylater_delay = NQ_TRYLATERDEL, trylater_cnt = 0, failed_auth = 0;
840 	u_long xid;
841 	u_quad_t frev;
842 	char *auth_str;
843 
844 	nmp = VFSTONFS(vp->v_mount);
845 	MALLOC(rep, struct nfsreq *, sizeof(struct nfsreq), M_NFSREQ, M_WAITOK);
846 	rep->r_nmp = nmp;
847 	rep->r_vp = vp;
848 	rep->r_procp = procp;
849 	rep->r_procnum = procnum;
850 	i = 0;
851 	m = mrest;
852 	while (m) {
853 		i += m->m_len;
854 		m = m->m_next;
855 	}
856 	mrest_len = i;
857 
858 	/*
859 	 * Get the RPC header with authorization.
860 	 */
861 kerbauth:
862 	auth_str = (char *)0;
863 	if (nmp->nm_flag & NFSMNT_KERB) {
864 		if (failed_auth) {
865 			error = nfs_getauth(nmp, rep, cred, &auth_type,
866 				&auth_str, &auth_len);
867 			if (error) {
868 				free((caddr_t)rep, M_NFSREQ);
869 				m_freem(mrest);
870 				return (error);
871 			}
872 		} else {
873 			auth_type = RPCAUTH_UNIX;
874 			auth_len = 5 * NFSX_UNSIGNED;
875 		}
876 	} else {
877 		auth_type = RPCAUTH_UNIX;
878 		if (cred->cr_ngroups < 1)
879 			panic("nfsreq nogrps");
880 		auth_len = ((((cred->cr_ngroups - 1) > nmp->nm_numgrps) ?
881 			nmp->nm_numgrps : (cred->cr_ngroups - 1)) << 2) +
882 			5 * NFSX_UNSIGNED;
883 	}
884 	m = nfsm_rpchead(cred, (nmp->nm_flag & NFSMNT_NQNFS), procnum,
885 	     auth_type, auth_len, auth_str, mrest, mrest_len, &mheadend, &xid);
886 	if (auth_str)
887 		free(auth_str, M_TEMP);
888 
889 	/*
890 	 * For stream protocols, insert a Sun RPC Record Mark.
891 	 */
892 	if (nmp->nm_sotype == SOCK_STREAM) {
893 		M_PREPEND(m, NFSX_UNSIGNED, M_WAIT);
894 		*mtod(m, u_long *) = htonl(0x80000000 |
895 			 (m->m_pkthdr.len - NFSX_UNSIGNED));
896 	}
897 	rep->r_mreq = m;
898 	rep->r_xid = xid;
899 tryagain:
900 	if (nmp->nm_flag & NFSMNT_SOFT)
901 		rep->r_retry = nmp->nm_retry;
902 	else
903 		rep->r_retry = NFS_MAXREXMIT + 1;	/* past clip limit */
904 	rep->r_rtt = rep->r_rexmit = 0;
905 	if (proct[procnum] > 0)
906 		rep->r_flags = R_TIMING;
907 	else
908 		rep->r_flags = 0;
909 	rep->r_mrep = NULL;
910 
911 	/*
912 	 * Do the client side RPC.
913 	 */
914 	nfsstats.rpcrequests++;
915 	/*
916 	 * Chain request into list of outstanding requests. Be sure
917 	 * to put it LAST so timer finds oldest requests first.
918 	 */
919 	s = splsoftclock();
920 	reph = &nfsreqh;
921 	reph->r_prev->r_next = rep;
922 	rep->r_prev = reph->r_prev;
923 	reph->r_prev = rep;
924 	rep->r_next = reph;
925 
926 	/* Get send time for nqnfs */
927 	reqtime = time.tv_sec;
928 
929 	/*
930 	 * If backing off another request or avoiding congestion, don't
931 	 * send this one now but let timer do it. If not timing a request,
932 	 * do it now.
933 	 */
934 	if (nmp->nm_so && (nmp->nm_sotype != SOCK_DGRAM ||
935 		(nmp->nm_flag & NFSMNT_DUMBTIMR) ||
936 		nmp->nm_sent < nmp->nm_cwnd)) {
937 		splx(s);
938 		if (nmp->nm_soflags & PR_CONNREQUIRED)
939 			error = nfs_sndlock(&nmp->nm_flag, rep);
940 		if (!error) {
941 			m = m_copym(m, 0, M_COPYALL, M_WAIT);
942 			error = nfs_send(nmp->nm_so, nmp->nm_nam, m, rep);
943 			if (nmp->nm_soflags & PR_CONNREQUIRED)
944 				nfs_sndunlock(&nmp->nm_flag);
945 		}
946 		if (!error && (rep->r_flags & R_MUSTRESEND) == 0) {
947 			nmp->nm_sent += NFS_CWNDSCALE;
948 			rep->r_flags |= R_SENT;
949 		}
950 	} else {
951 		splx(s);
952 		rep->r_rtt = -1;
953 	}
954 
955 	/*
956 	 * Wait for the reply from our send or the timer's.
957 	 */
958 	if (!error || error == EPIPE)
959 		error = nfs_reply(rep);
960 
961 	/*
962 	 * RPC done, unlink the request.
963 	 */
964 	s = splsoftclock();
965 	rep->r_prev->r_next = rep->r_next;
966 	rep->r_next->r_prev = rep->r_prev;
967 	splx(s);
968 
969 	/*
970 	 * If there was a successful reply and a tprintf msg.
971 	 * tprintf a response.
972 	 */
973 	if (!error && (rep->r_flags & R_TPRINTFMSG))
974 		nfs_msg(rep->r_procp, nmp->nm_mountp->mnt_stat.f_mntfromname,
975 		    "is alive again");
976 	mrep = rep->r_mrep;
977 	md = rep->r_md;
978 	dpos = rep->r_dpos;
979 	if (error) {
980 		m_freem(rep->r_mreq);
981 		free((caddr_t)rep, M_NFSREQ);
982 		return (error);
983 	}
984 
985 	/*
986 	 * break down the rpc header and check if ok
987 	 */
988 	nfsm_dissect(tl, u_long *, 3*NFSX_UNSIGNED);
989 	if (*tl++ == rpc_msgdenied) {
990 		if (*tl == rpc_mismatch)
991 			error = EOPNOTSUPP;
992 		else if ((nmp->nm_flag & NFSMNT_KERB) && *tl++ == rpc_autherr) {
993 			if (*tl == rpc_rejectedcred && failed_auth == 0) {
994 				failed_auth++;
995 				mheadend->m_next = (struct mbuf *)0;
996 				m_freem(mrep);
997 				m_freem(rep->r_mreq);
998 				goto kerbauth;
999 			} else
1000 				error = EAUTH;
1001 		} else
1002 			error = EACCES;
1003 		m_freem(mrep);
1004 		m_freem(rep->r_mreq);
1005 		free((caddr_t)rep, M_NFSREQ);
1006 		return (error);
1007 	}
1008 
1009 	/*
1010 	 * skip over the auth_verf, someday we may want to cache auth_short's
1011 	 * for nfs_reqhead(), but for now just dump it
1012 	 */
1013 	if (*++tl != 0) {
1014 		i = nfsm_rndup(fxdr_unsigned(long, *tl));
1015 		nfsm_adv(i);
1016 	}
1017 	nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
1018 	/* 0 == ok */
1019 	if (*tl == 0) {
1020 		nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
1021 		if (*tl != 0) {
1022 			error = fxdr_unsigned(int, *tl);
1023 			m_freem(mrep);
1024 			if ((nmp->nm_flag & NFSMNT_NQNFS) &&
1025 			    error == NQNFS_TRYLATER) {
1026 				error = 0;
1027 				waituntil = time.tv_sec + trylater_delay;
1028 				while (time.tv_sec < waituntil)
1029 					(void) tsleep((caddr_t)&lbolt,
1030 						PSOCK, "nqnfstry", 0);
1031 				trylater_delay *= nfs_backoff[trylater_cnt];
1032 				if (trylater_cnt < 7)
1033 					trylater_cnt++;
1034 				goto tryagain;
1035 			}
1036 
1037 			/*
1038 			 * If the File Handle was stale, invalidate the
1039 			 * lookup cache, just in case.
1040 			 */
1041 			if (error == ESTALE)
1042 				cache_purge(vp);
1043 			m_freem(rep->r_mreq);
1044 			free((caddr_t)rep, M_NFSREQ);
1045 			return (error);
1046 		}
1047 
1048 		/*
1049 		 * For nqnfs, get any lease in reply
1050 		 */
1051 		if (nmp->nm_flag & NFSMNT_NQNFS) {
1052 			nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
1053 			if (*tl) {
1054 				np = VTONFS(vp);
1055 				nqlflag = fxdr_unsigned(int, *tl);
1056 				nfsm_dissect(tl, u_long *, 4*NFSX_UNSIGNED);
1057 				cachable = fxdr_unsigned(int, *tl++);
1058 				reqtime += fxdr_unsigned(int, *tl++);
1059 				if (reqtime > time.tv_sec) {
1060 				    fxdr_hyper(tl, &frev);
1061 				    nqnfs_clientlease(nmp, np, nqlflag,
1062 					cachable, reqtime, frev);
1063 				}
1064 			}
1065 		}
1066 		*mrp = mrep;
1067 		*mdp = md;
1068 		*dposp = dpos;
1069 		m_freem(rep->r_mreq);
1070 		FREE((caddr_t)rep, M_NFSREQ);
1071 		return (0);
1072 	}
1073 	m_freem(mrep);
1074 	m_freem(rep->r_mreq);
1075 	free((caddr_t)rep, M_NFSREQ);
1076 	error = EPROTONOSUPPORT;
1077 nfsmout:
1078 	return (error);
1079 }
1080 
1081 /*
1082  * Generate the rpc reply header
1083  * siz arg. is used to decide if adding a cluster is worthwhile
1084  */
1085 nfs_rephead(siz, nd, err, cache, frev, mrq, mbp, bposp)
1086 	int siz;
1087 	struct nfsd *nd;
1088 	int err;
1089 	int cache;
1090 	u_quad_t *frev;
1091 	struct mbuf **mrq;
1092 	struct mbuf **mbp;
1093 	caddr_t *bposp;
1094 {
1095 	register u_long *tl;
1096 	register struct mbuf *mreq;
1097 	caddr_t bpos;
1098 	struct mbuf *mb, *mb2;
1099 
1100 	MGETHDR(mreq, M_WAIT, MT_DATA);
1101 	mb = mreq;
1102 	/*
1103 	 * If this is a big reply, use a cluster else
1104 	 * try and leave leading space for the lower level headers.
1105 	 */
1106 	siz += RPC_REPLYSIZ;
1107 	if (siz >= MINCLSIZE) {
1108 		MCLGET(mreq, M_WAIT);
1109 	} else
1110 		mreq->m_data += max_hdr;
1111 	tl = mtod(mreq, u_long *);
1112 	mreq->m_len = 6*NFSX_UNSIGNED;
1113 	bpos = ((caddr_t)tl)+mreq->m_len;
1114 	*tl++ = nd->nd_retxid;
1115 	*tl++ = rpc_reply;
1116 	if (err == ERPCMISMATCH || err == NQNFS_AUTHERR) {
1117 		*tl++ = rpc_msgdenied;
1118 		if (err == NQNFS_AUTHERR) {
1119 			*tl++ = rpc_autherr;
1120 			*tl = rpc_rejectedcred;
1121 			mreq->m_len -= NFSX_UNSIGNED;
1122 			bpos -= NFSX_UNSIGNED;
1123 		} else {
1124 			*tl++ = rpc_mismatch;
1125 			*tl++ = txdr_unsigned(2);
1126 			*tl = txdr_unsigned(2);
1127 		}
1128 	} else {
1129 		*tl++ = rpc_msgaccepted;
1130 		*tl++ = 0;
1131 		*tl++ = 0;
1132 		switch (err) {
1133 		case EPROGUNAVAIL:
1134 			*tl = txdr_unsigned(RPC_PROGUNAVAIL);
1135 			break;
1136 		case EPROGMISMATCH:
1137 			*tl = txdr_unsigned(RPC_PROGMISMATCH);
1138 			nfsm_build(tl, u_long *, 2*NFSX_UNSIGNED);
1139 			*tl++ = txdr_unsigned(2);
1140 			*tl = txdr_unsigned(2);	/* someday 3 */
1141 			break;
1142 		case EPROCUNAVAIL:
1143 			*tl = txdr_unsigned(RPC_PROCUNAVAIL);
1144 			break;
1145 		default:
1146 			*tl = 0;
1147 			if (err != VNOVAL) {
1148 				nfsm_build(tl, u_long *, NFSX_UNSIGNED);
1149 				if (err)
1150 					*tl = txdr_unsigned(nfsrv_errmap[err - 1]);
1151 				else
1152 					*tl = 0;
1153 			}
1154 			break;
1155 		};
1156 	}
1157 
1158 	/*
1159 	 * For nqnfs, piggyback lease as requested.
1160 	 */
1161 	if (nd->nd_nqlflag != NQL_NOVAL && err == 0) {
1162 		if (nd->nd_nqlflag) {
1163 			nfsm_build(tl, u_long *, 5*NFSX_UNSIGNED);
1164 			*tl++ = txdr_unsigned(nd->nd_nqlflag);
1165 			*tl++ = txdr_unsigned(cache);
1166 			*tl++ = txdr_unsigned(nd->nd_duration);
1167 			txdr_hyper(frev, tl);
1168 		} else {
1169 			if (nd->nd_nqlflag != 0)
1170 				panic("nqreph");
1171 			nfsm_build(tl, u_long *, NFSX_UNSIGNED);
1172 			*tl = 0;
1173 		}
1174 	}
1175 	*mrq = mreq;
1176 	*mbp = mb;
1177 	*bposp = bpos;
1178 	if (err != 0 && err != VNOVAL)
1179 		nfsstats.srvrpc_errs++;
1180 	return (0);
1181 }
1182 
1183 /*
1184  * Nfs timer routine
1185  * Scan the nfsreq list and retranmit any requests that have timed out
1186  * To avoid retransmission attempts on STREAM sockets (in the future) make
1187  * sure to set the r_retry field to 0 (implies nm_retry == 0).
1188  */
1189 void
1190 nfs_timer(arg)
1191 	void *arg;
1192 {
1193 	register struct nfsreq *rep;
1194 	register struct mbuf *m;
1195 	register struct socket *so;
1196 	register struct nfsmount *nmp;
1197 	register int timeo;
1198 	static long lasttime = 0;
1199 	int s, error;
1200 
1201 	s = splnet();
1202 	for (rep = nfsreqh.r_next; rep != &nfsreqh; rep = rep->r_next) {
1203 		nmp = rep->r_nmp;
1204 		if (rep->r_mrep || (rep->r_flags & R_SOFTTERM))
1205 			continue;
1206 		if (nfs_sigintr(nmp, rep, rep->r_procp)) {
1207 			rep->r_flags |= R_SOFTTERM;
1208 			continue;
1209 		}
1210 		if (rep->r_rtt >= 0) {
1211 			rep->r_rtt++;
1212 			if (nmp->nm_flag & NFSMNT_DUMBTIMR)
1213 				timeo = nmp->nm_timeo;
1214 			else
1215 				timeo = NFS_RTO(nmp, proct[rep->r_procnum]);
1216 			if (nmp->nm_timeouts > 0)
1217 				timeo *= nfs_backoff[nmp->nm_timeouts - 1];
1218 			if (rep->r_rtt <= timeo)
1219 				continue;
1220 			if (nmp->nm_timeouts < 8)
1221 				nmp->nm_timeouts++;
1222 		}
1223 		/*
1224 		 * Check for server not responding
1225 		 */
1226 		if ((rep->r_flags & R_TPRINTFMSG) == 0 &&
1227 		     rep->r_rexmit > nmp->nm_deadthresh) {
1228 			nfs_msg(rep->r_procp,
1229 			    nmp->nm_mountp->mnt_stat.f_mntfromname,
1230 			    "not responding");
1231 			rep->r_flags |= R_TPRINTFMSG;
1232 		}
1233 		if (rep->r_rexmit >= rep->r_retry) {	/* too many */
1234 			nfsstats.rpctimeouts++;
1235 			rep->r_flags |= R_SOFTTERM;
1236 			continue;
1237 		}
1238 		if (nmp->nm_sotype != SOCK_DGRAM) {
1239 			if (++rep->r_rexmit > NFS_MAXREXMIT)
1240 				rep->r_rexmit = NFS_MAXREXMIT;
1241 			continue;
1242 		}
1243 		if ((so = nmp->nm_so) == NULL)
1244 			continue;
1245 
1246 		/*
1247 		 * If there is enough space and the window allows..
1248 		 *	Resend it
1249 		 * Set r_rtt to -1 in case we fail to send it now.
1250 		 */
1251 		rep->r_rtt = -1;
1252 		if (sbspace(&so->so_snd) >= rep->r_mreq->m_pkthdr.len &&
1253 		   ((nmp->nm_flag & NFSMNT_DUMBTIMR) ||
1254 		    (rep->r_flags & R_SENT) ||
1255 		    nmp->nm_sent < nmp->nm_cwnd) &&
1256 		   (m = m_copym(rep->r_mreq, 0, M_COPYALL, M_DONTWAIT))){
1257 			if ((nmp->nm_flag & NFSMNT_NOCONN) == 0)
1258 			    error = (*so->so_proto->pr_usrreq)(so, PRU_SEND, m,
1259 			    (struct mbuf *)0, (struct mbuf *)0);
1260 			else
1261 			    error = (*so->so_proto->pr_usrreq)(so, PRU_SEND, m,
1262 			    nmp->nm_nam, (struct mbuf *)0);
1263 			if (error) {
1264 				if (NFSIGNORE_SOERROR(nmp->nm_soflags, error))
1265 					so->so_error = 0;
1266 			} else {
1267 				/*
1268 				 * Iff first send, start timing
1269 				 * else turn timing off, backoff timer
1270 				 * and divide congestion window by 2.
1271 				 */
1272 				if (rep->r_flags & R_SENT) {
1273 					rep->r_flags &= ~R_TIMING;
1274 					if (++rep->r_rexmit > NFS_MAXREXMIT)
1275 						rep->r_rexmit = NFS_MAXREXMIT;
1276 					nmp->nm_cwnd >>= 1;
1277 					if (nmp->nm_cwnd < NFS_CWNDSCALE)
1278 						nmp->nm_cwnd = NFS_CWNDSCALE;
1279 					nfsstats.rpcretries++;
1280 				} else {
1281 					rep->r_flags |= R_SENT;
1282 					nmp->nm_sent += NFS_CWNDSCALE;
1283 				}
1284 				rep->r_rtt = 0;
1285 			}
1286 		}
1287 	}
1288 
1289 	/*
1290 	 * Call the nqnfs server timer once a second to handle leases.
1291 	 */
1292 	if (lasttime != time.tv_sec) {
1293 		lasttime = time.tv_sec;
1294 		nqnfs_serverd();
1295 	}
1296 	splx(s);
1297 	timeout(nfs_timer, (caddr_t)0, hz/NFS_HZ);
1298 }
1299 
1300 /*
1301  * Test for a termination condition pending on the process.
1302  * This is used for NFSMNT_INT mounts.
1303  */
1304 nfs_sigintr(nmp, rep, p)
1305 	struct nfsmount *nmp;
1306 	struct nfsreq *rep;
1307 	register struct proc *p;
1308 {
1309 
1310 	if (rep && (rep->r_flags & R_SOFTTERM))
1311 		return (EINTR);
1312 	if (!(nmp->nm_flag & NFSMNT_INT))
1313 		return (0);
1314 	if (p && p->p_sig && (((p->p_sig &~ p->p_sigmask) &~ p->p_sigignore) &
1315 	    NFSINT_SIGMASK))
1316 		return (EINTR);
1317 	return (0);
1318 }
1319 
1320 /*
1321  * Lock a socket against others.
1322  * Necessary for STREAM sockets to ensure you get an entire rpc request/reply
1323  * and also to avoid race conditions between the processes with nfs requests
1324  * in progress when a reconnect is necessary.
1325  */
1326 nfs_sndlock(flagp, rep)
1327 	register int *flagp;
1328 	struct nfsreq *rep;
1329 {
1330 	struct proc *p;
1331 
1332 	if (rep)
1333 		p = rep->r_procp;
1334 	else
1335 		p = (struct proc *)0;
1336 	while (*flagp & NFSMNT_SNDLOCK) {
1337 		if (nfs_sigintr(rep->r_nmp, rep, p))
1338 			return (EINTR);
1339 		*flagp |= NFSMNT_WANTSND;
1340 		(void) tsleep((caddr_t)flagp, PZERO-1, "nfsndlck", 0);
1341 	}
1342 	*flagp |= NFSMNT_SNDLOCK;
1343 	return (0);
1344 }
1345 
1346 /*
1347  * Unlock the stream socket for others.
1348  */
1349 void
1350 nfs_sndunlock(flagp)
1351 	register int *flagp;
1352 {
1353 
1354 	if ((*flagp & NFSMNT_SNDLOCK) == 0)
1355 		panic("nfs sndunlock");
1356 	*flagp &= ~NFSMNT_SNDLOCK;
1357 	if (*flagp & NFSMNT_WANTSND) {
1358 		*flagp &= ~NFSMNT_WANTSND;
1359 		wakeup((caddr_t)flagp);
1360 	}
1361 }
1362 
1363 nfs_rcvlock(rep)
1364 	register struct nfsreq *rep;
1365 {
1366 	register int *flagp = &rep->r_nmp->nm_flag;
1367 
1368 	while (*flagp & NFSMNT_RCVLOCK) {
1369 		if (nfs_sigintr(rep->r_nmp, rep, rep->r_procp))
1370 			return (EINTR);
1371 		*flagp |= NFSMNT_WANTRCV;
1372 		(void) tsleep((caddr_t)flagp, PZERO-1, "nfsrcvlck", 0);
1373 	}
1374 	*flagp |= NFSMNT_RCVLOCK;
1375 	return (0);
1376 }
1377 
1378 /*
1379  * Unlock the stream socket for others.
1380  */
1381 void
1382 nfs_rcvunlock(flagp)
1383 	register int *flagp;
1384 {
1385 
1386 	if ((*flagp & NFSMNT_RCVLOCK) == 0)
1387 		panic("nfs rcvunlock");
1388 	*flagp &= ~NFSMNT_RCVLOCK;
1389 	if (*flagp & NFSMNT_WANTRCV) {
1390 		*flagp &= ~NFSMNT_WANTRCV;
1391 		wakeup((caddr_t)flagp);
1392 	}
1393 }
1394 
1395 /*
1396  * Check for badly aligned mbuf data areas and
1397  * realign data in an mbuf list by copying the data areas up, as required.
1398  */
1399 void
1400 nfs_realign(m, hsiz)
1401 	register struct mbuf *m;
1402 	int hsiz;
1403 {
1404 	register struct mbuf *m2;
1405 	register int siz, mlen, olen;
1406 	register caddr_t tcp, fcp;
1407 	struct mbuf *mnew;
1408 
1409 	while (m) {
1410 	    /*
1411 	     * This never happens for UDP, rarely happens for TCP
1412 	     * but frequently happens for iso transport.
1413 	     */
1414 	    if ((m->m_len & 0x3) || (mtod(m, int) & 0x3)) {
1415 		olen = m->m_len;
1416 		fcp = mtod(m, caddr_t);
1417 		m->m_flags &= ~M_PKTHDR;
1418 		if (m->m_flags & M_EXT)
1419 			m->m_data = m->m_ext.ext_buf;
1420 		else
1421 			m->m_data = m->m_dat;
1422 		m->m_len = 0;
1423 		tcp = mtod(m, caddr_t);
1424 		mnew = m;
1425 		m2 = m->m_next;
1426 
1427 		/*
1428 		 * If possible, only put the first invariant part
1429 		 * of the RPC header in the first mbuf.
1430 		 */
1431 		if (olen <= hsiz)
1432 			mlen = hsiz;
1433 		else
1434 			mlen = M_TRAILINGSPACE(m);
1435 
1436 		/*
1437 		 * Loop through the mbuf list consolidating data.
1438 		 */
1439 		while (m) {
1440 			while (olen > 0) {
1441 				if (mlen == 0) {
1442 					m2->m_flags &= ~M_PKTHDR;
1443 					if (m2->m_flags & M_EXT)
1444 						m2->m_data = m2->m_ext.ext_buf;
1445 					else
1446 						m2->m_data = m2->m_dat;
1447 					m2->m_len = 0;
1448 					mlen = M_TRAILINGSPACE(m2);
1449 					tcp = mtod(m2, caddr_t);
1450 					mnew = m2;
1451 					m2 = m2->m_next;
1452 				}
1453 				siz = min(mlen, olen);
1454 				if (tcp != fcp)
1455 					bcopy(fcp, tcp, siz);
1456 				mnew->m_len += siz;
1457 				mlen -= siz;
1458 				olen -= siz;
1459 				tcp += siz;
1460 				fcp += siz;
1461 			}
1462 			m = m->m_next;
1463 			if (m) {
1464 				olen = m->m_len;
1465 				fcp = mtod(m, caddr_t);
1466 			}
1467 		}
1468 
1469 		/*
1470 		 * Finally, set m_len == 0 for any trailing mbufs that have
1471 		 * been copied out of.
1472 		 */
1473 		while (m2) {
1474 			m2->m_len = 0;
1475 			m2 = m2->m_next;
1476 		}
1477 		return;
1478 	    }
1479 	    m = m->m_next;
1480 	}
1481 }
1482 
1483 /*
1484  * Socket upcall routine for the nfsd sockets.
1485  * The caddr_t arg is a pointer to the "struct nfssvc_sock".
1486  * Essentially do as much as possible non-blocking, else punt and it will
1487  * be called with M_WAIT from an nfsd.
1488  */
1489 void
1490 nfsrv_rcv(so, arg, waitflag)
1491 	struct socket *so;
1492 	caddr_t arg;
1493 	int waitflag;
1494 {
1495 	register struct nfssvc_sock *slp = (struct nfssvc_sock *)arg;
1496 	register struct mbuf *m;
1497 	struct mbuf *mp, *nam;
1498 	struct uio auio;
1499 	int flags, error;
1500 
1501 	if ((slp->ns_flag & SLP_VALID) == 0)
1502 		return;
1503 #ifdef notdef
1504 	/*
1505 	 * Define this to test for nfsds handling this under heavy load.
1506 	 */
1507 	if (waitflag == M_DONTWAIT) {
1508 		slp->ns_flag |= SLP_NEEDQ; goto dorecs;
1509 	}
1510 #endif
1511 	auio.uio_procp = NULL;
1512 	if (so->so_type == SOCK_STREAM) {
1513 		/*
1514 		 * If there are already records on the queue, defer soreceive()
1515 		 * to an nfsd so that there is feedback to the TCP layer that
1516 		 * the nfs servers are heavily loaded.
1517 		 */
1518 		if (slp->ns_rec && waitflag == M_DONTWAIT) {
1519 			slp->ns_flag |= SLP_NEEDQ;
1520 			goto dorecs;
1521 		}
1522 
1523 		/*
1524 		 * Do soreceive().
1525 		 */
1526 		auio.uio_resid = 1000000000;
1527 		flags = MSG_DONTWAIT;
1528 		error = soreceive(so, &nam, &auio, &mp, (struct mbuf **)0, &flags);
1529 		if (error || mp == (struct mbuf *)0) {
1530 			if (error == EWOULDBLOCK)
1531 				slp->ns_flag |= SLP_NEEDQ;
1532 			else
1533 				slp->ns_flag |= SLP_DISCONN;
1534 			goto dorecs;
1535 		}
1536 		m = mp;
1537 		if (slp->ns_rawend) {
1538 			slp->ns_rawend->m_next = m;
1539 			slp->ns_cc += 1000000000 - auio.uio_resid;
1540 		} else {
1541 			slp->ns_raw = m;
1542 			slp->ns_cc = 1000000000 - auio.uio_resid;
1543 		}
1544 		while (m->m_next)
1545 			m = m->m_next;
1546 		slp->ns_rawend = m;
1547 
1548 		/*
1549 		 * Now try and parse record(s) out of the raw stream data.
1550 		 */
1551 		if (error = nfsrv_getstream(slp, waitflag)) {
1552 			if (error == EPERM)
1553 				slp->ns_flag |= SLP_DISCONN;
1554 			else
1555 				slp->ns_flag |= SLP_NEEDQ;
1556 		}
1557 	} else {
1558 		do {
1559 			auio.uio_resid = 1000000000;
1560 			flags = MSG_DONTWAIT;
1561 			error = soreceive(so, &nam, &auio, &mp,
1562 						(struct mbuf **)0, &flags);
1563 			if (mp) {
1564 				nfs_realign(mp, 10 * NFSX_UNSIGNED);
1565 				if (nam) {
1566 					m = nam;
1567 					m->m_next = mp;
1568 				} else
1569 					m = mp;
1570 				if (slp->ns_recend)
1571 					slp->ns_recend->m_nextpkt = m;
1572 				else
1573 					slp->ns_rec = m;
1574 				slp->ns_recend = m;
1575 				m->m_nextpkt = (struct mbuf *)0;
1576 			}
1577 			if (error) {
1578 				if ((so->so_proto->pr_flags & PR_CONNREQUIRED)
1579 					&& error != EWOULDBLOCK) {
1580 					slp->ns_flag |= SLP_DISCONN;
1581 					goto dorecs;
1582 				}
1583 			}
1584 		} while (mp);
1585 	}
1586 
1587 	/*
1588 	 * Now try and process the request records, non-blocking.
1589 	 */
1590 dorecs:
1591 	if (waitflag == M_DONTWAIT &&
1592 		(slp->ns_rec || (slp->ns_flag & (SLP_NEEDQ | SLP_DISCONN))))
1593 		nfsrv_wakenfsd(slp);
1594 }
1595 
1596 /*
1597  * Try and extract an RPC request from the mbuf data list received on a
1598  * stream socket. The "waitflag" argument indicates whether or not it
1599  * can sleep.
1600  */
1601 nfsrv_getstream(slp, waitflag)
1602 	register struct nfssvc_sock *slp;
1603 	int waitflag;
1604 {
1605 	register struct mbuf *m;
1606 	register char *cp1, *cp2;
1607 	register int len;
1608 	struct mbuf *om, *m2, *recm;
1609 	u_long recmark;
1610 
1611 	if (slp->ns_flag & SLP_GETSTREAM)
1612 		panic("nfs getstream");
1613 	slp->ns_flag |= SLP_GETSTREAM;
1614 	for (;;) {
1615 	    if (slp->ns_reclen == 0) {
1616 		if (slp->ns_cc < NFSX_UNSIGNED) {
1617 			slp->ns_flag &= ~SLP_GETSTREAM;
1618 			return (0);
1619 		}
1620 		m = slp->ns_raw;
1621 		if (m->m_len >= NFSX_UNSIGNED) {
1622 			bcopy(mtod(m, caddr_t), (caddr_t)&recmark, NFSX_UNSIGNED);
1623 			m->m_data += NFSX_UNSIGNED;
1624 			m->m_len -= NFSX_UNSIGNED;
1625 		} else {
1626 			cp1 = (caddr_t)&recmark;
1627 			cp2 = mtod(m, caddr_t);
1628 			while (cp1 < ((caddr_t)&recmark) + NFSX_UNSIGNED) {
1629 				while (m->m_len == 0) {
1630 					m = m->m_next;
1631 					cp2 = mtod(m, caddr_t);
1632 				}
1633 				*cp1++ = *cp2++;
1634 				m->m_data++;
1635 				m->m_len--;
1636 			}
1637 		}
1638 		slp->ns_cc -= NFSX_UNSIGNED;
1639 		slp->ns_reclen = ntohl(recmark) & ~0x80000000;
1640 		if (slp->ns_reclen < NFS_MINPACKET || slp->ns_reclen > NFS_MAXPACKET) {
1641 			slp->ns_flag &= ~SLP_GETSTREAM;
1642 			return (EPERM);
1643 		}
1644 	    }
1645 
1646 	    /*
1647 	     * Now get the record part.
1648 	     */
1649 	    if (slp->ns_cc == slp->ns_reclen) {
1650 		recm = slp->ns_raw;
1651 		slp->ns_raw = slp->ns_rawend = (struct mbuf *)0;
1652 		slp->ns_cc = slp->ns_reclen = 0;
1653 	    } else if (slp->ns_cc > slp->ns_reclen) {
1654 		len = 0;
1655 		m = slp->ns_raw;
1656 		om = (struct mbuf *)0;
1657 		while (len < slp->ns_reclen) {
1658 			if ((len + m->m_len) > slp->ns_reclen) {
1659 				m2 = m_copym(m, 0, slp->ns_reclen - len,
1660 					waitflag);
1661 				if (m2) {
1662 					if (om) {
1663 						om->m_next = m2;
1664 						recm = slp->ns_raw;
1665 					} else
1666 						recm = m2;
1667 					m->m_data += slp->ns_reclen - len;
1668 					m->m_len -= slp->ns_reclen - len;
1669 					len = slp->ns_reclen;
1670 				} else {
1671 					slp->ns_flag &= ~SLP_GETSTREAM;
1672 					return (EWOULDBLOCK);
1673 				}
1674 			} else if ((len + m->m_len) == slp->ns_reclen) {
1675 				om = m;
1676 				len += m->m_len;
1677 				m = m->m_next;
1678 				recm = slp->ns_raw;
1679 				om->m_next = (struct mbuf *)0;
1680 			} else {
1681 				om = m;
1682 				len += m->m_len;
1683 				m = m->m_next;
1684 			}
1685 		}
1686 		slp->ns_raw = m;
1687 		slp->ns_cc -= len;
1688 		slp->ns_reclen = 0;
1689 	    } else {
1690 		slp->ns_flag &= ~SLP_GETSTREAM;
1691 		return (0);
1692 	    }
1693 	    nfs_realign(recm, 10 * NFSX_UNSIGNED);
1694 	    if (slp->ns_recend)
1695 		slp->ns_recend->m_nextpkt = recm;
1696 	    else
1697 		slp->ns_rec = recm;
1698 	    slp->ns_recend = recm;
1699 	}
1700 }
1701 
1702 /*
1703  * Parse an RPC header.
1704  */
1705 nfsrv_dorec(slp, nd)
1706 	register struct nfssvc_sock *slp;
1707 	register struct nfsd *nd;
1708 {
1709 	register struct mbuf *m;
1710 	int error;
1711 
1712 	if ((slp->ns_flag & SLP_VALID) == 0 ||
1713 	    (m = slp->ns_rec) == (struct mbuf *)0)
1714 		return (ENOBUFS);
1715 	if (slp->ns_rec = m->m_nextpkt)
1716 		m->m_nextpkt = (struct mbuf *)0;
1717 	else
1718 		slp->ns_recend = (struct mbuf *)0;
1719 	if (m->m_type == MT_SONAME) {
1720 		nd->nd_nam = m;
1721 		nd->nd_md = nd->nd_mrep = m->m_next;
1722 		m->m_next = (struct mbuf *)0;
1723 	} else {
1724 		nd->nd_nam = (struct mbuf *)0;
1725 		nd->nd_md = nd->nd_mrep = m;
1726 	}
1727 	nd->nd_dpos = mtod(nd->nd_md, caddr_t);
1728 	if (error = nfs_getreq(nd, TRUE)) {
1729 		m_freem(nd->nd_nam);
1730 		return (error);
1731 	}
1732 	return (0);
1733 }
1734 
1735 /*
1736  * Parse an RPC request
1737  * - verify it
1738  * - fill in the cred struct.
1739  */
1740 nfs_getreq(nd, has_header)
1741 	register struct nfsd *nd;
1742 	int has_header;
1743 {
1744 	register int len, i;
1745 	register u_long *tl;
1746 	register long t1;
1747 	struct uio uio;
1748 	struct iovec iov;
1749 	caddr_t dpos, cp2;
1750 	u_long nfsvers, auth_type;
1751 	int error = 0, nqnfs = 0;
1752 	struct mbuf *mrep, *md;
1753 
1754 	mrep = nd->nd_mrep;
1755 	md = nd->nd_md;
1756 	dpos = nd->nd_dpos;
1757 	if (has_header) {
1758 		nfsm_dissect(tl, u_long *, 10*NFSX_UNSIGNED);
1759 		nd->nd_retxid = *tl++;
1760 		if (*tl++ != rpc_call) {
1761 			m_freem(mrep);
1762 			return (EBADRPC);
1763 		}
1764 	} else {
1765 		nfsm_dissect(tl, u_long *, 8*NFSX_UNSIGNED);
1766 	}
1767 	nd->nd_repstat = 0;
1768 	if (*tl++ != rpc_vers) {
1769 		nd->nd_repstat = ERPCMISMATCH;
1770 		nd->nd_procnum = NFSPROC_NOOP;
1771 		return (0);
1772 	}
1773 	nfsvers = nfs_vers;
1774 	if (*tl != nfs_prog) {
1775 		if (*tl == nqnfs_prog) {
1776 			nqnfs++;
1777 			nfsvers = nqnfs_vers;
1778 		} else {
1779 			nd->nd_repstat = EPROGUNAVAIL;
1780 			nd->nd_procnum = NFSPROC_NOOP;
1781 			return (0);
1782 		}
1783 	}
1784 	tl++;
1785 	if (*tl++ != nfsvers) {
1786 		nd->nd_repstat = EPROGMISMATCH;
1787 		nd->nd_procnum = NFSPROC_NOOP;
1788 		return (0);
1789 	}
1790 	nd->nd_procnum = fxdr_unsigned(u_long, *tl++);
1791 	if (nd->nd_procnum == NFSPROC_NULL)
1792 		return (0);
1793 	if (nd->nd_procnum >= NFS_NPROCS ||
1794 		(!nqnfs && nd->nd_procnum > NFSPROC_STATFS) ||
1795 		(*tl != rpc_auth_unix && *tl != rpc_auth_kerb)) {
1796 		nd->nd_repstat = EPROCUNAVAIL;
1797 		nd->nd_procnum = NFSPROC_NOOP;
1798 		return (0);
1799 	}
1800 	auth_type = *tl++;
1801 	len = fxdr_unsigned(int, *tl++);
1802 	if (len < 0 || len > RPCAUTH_MAXSIZ) {
1803 		m_freem(mrep);
1804 		return (EBADRPC);
1805 	}
1806 
1807 	/*
1808 	 * Handle auth_unix or auth_kerb.
1809 	 */
1810 	if (auth_type == rpc_auth_unix) {
1811 		len = fxdr_unsigned(int, *++tl);
1812 		if (len < 0 || len > NFS_MAXNAMLEN) {
1813 			m_freem(mrep);
1814 			return (EBADRPC);
1815 		}
1816 		nfsm_adv(nfsm_rndup(len));
1817 		nfsm_dissect(tl, u_long *, 3*NFSX_UNSIGNED);
1818 		nd->nd_cr.cr_uid = fxdr_unsigned(uid_t, *tl++);
1819 		nd->nd_cr.cr_gid = fxdr_unsigned(gid_t, *tl++);
1820 		len = fxdr_unsigned(int, *tl);
1821 		if (len < 0 || len > RPCAUTH_UNIXGIDS) {
1822 			m_freem(mrep);
1823 			return (EBADRPC);
1824 		}
1825 		nfsm_dissect(tl, u_long *, (len + 2)*NFSX_UNSIGNED);
1826 		for (i = 1; i <= len; i++)
1827 			if (i < NGROUPS)
1828 				nd->nd_cr.cr_groups[i] = fxdr_unsigned(gid_t, *tl++);
1829 			else
1830 				tl++;
1831 		nd->nd_cr.cr_ngroups = (len >= NGROUPS) ? NGROUPS : (len + 1);
1832 	} else if (auth_type == rpc_auth_kerb) {
1833 		nd->nd_cr.cr_uid = fxdr_unsigned(uid_t, *tl++);
1834 		nd->nd_authlen = fxdr_unsigned(int, *tl);
1835 		iov.iov_len = uio.uio_resid = nfsm_rndup(nd->nd_authlen);
1836 		if (uio.uio_resid > (len - 2*NFSX_UNSIGNED)) {
1837 			m_freem(mrep);
1838 			return (EBADRPC);
1839 		}
1840 		uio.uio_offset = 0;
1841 		uio.uio_iov = &iov;
1842 		uio.uio_iovcnt = 1;
1843 		uio.uio_segflg = UIO_SYSSPACE;
1844 		iov.iov_base = (caddr_t)nd->nd_authstr;
1845 		nfsm_mtouio(&uio, uio.uio_resid);
1846 		nfsm_dissect(tl, u_long *, 2*NFSX_UNSIGNED);
1847 		nd->nd_flag |= NFSD_NEEDAUTH;
1848 	}
1849 
1850 	/*
1851 	 * Do we have any use for the verifier.
1852 	 * According to the "Remote Procedure Call Protocol Spec." it
1853 	 * should be AUTH_NULL, but some clients make it AUTH_UNIX?
1854 	 * For now, just skip over it
1855 	 */
1856 	len = fxdr_unsigned(int, *++tl);
1857 	if (len < 0 || len > RPCAUTH_MAXSIZ) {
1858 		m_freem(mrep);
1859 		return (EBADRPC);
1860 	}
1861 	if (len > 0) {
1862 		nfsm_adv(nfsm_rndup(len));
1863 	}
1864 
1865 	/*
1866 	 * For nqnfs, get piggybacked lease request.
1867 	 */
1868 	if (nqnfs && nd->nd_procnum != NQNFSPROC_EVICTED) {
1869 		nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
1870 		nd->nd_nqlflag = fxdr_unsigned(int, *tl);
1871 		if (nd->nd_nqlflag) {
1872 			nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
1873 			nd->nd_duration = fxdr_unsigned(int, *tl);
1874 		} else
1875 			nd->nd_duration = NQ_MINLEASE;
1876 	} else {
1877 		nd->nd_nqlflag = NQL_NOVAL;
1878 		nd->nd_duration = NQ_MINLEASE;
1879 	}
1880 	nd->nd_md = md;
1881 	nd->nd_dpos = dpos;
1882 	return (0);
1883 nfsmout:
1884 	return (error);
1885 }
1886 
1887 /*
1888  * Search for a sleeping nfsd and wake it up.
1889  * SIDE EFFECT: If none found, set NFSD_CHECKSLP flag, so that one of the
1890  * running nfsds will go look for the work in the nfssvc_sock list.
1891  */
1892 void
1893 nfsrv_wakenfsd(slp)
1894 	struct nfssvc_sock *slp;
1895 {
1896 	register struct nfsd *nd = nfsd_head.nd_next;
1897 
1898 	if ((slp->ns_flag & SLP_VALID) == 0)
1899 		return;
1900 	while (nd != (struct nfsd *)&nfsd_head) {
1901 		if (nd->nd_flag & NFSD_WAITING) {
1902 			nd->nd_flag &= ~NFSD_WAITING;
1903 			if (nd->nd_slp)
1904 				panic("nfsd wakeup");
1905 			slp->ns_sref++;
1906 			nd->nd_slp = slp;
1907 			wakeup((caddr_t)nd);
1908 			return;
1909 		}
1910 		nd = nd->nd_next;
1911 	}
1912 	slp->ns_flag |= SLP_DOREC;
1913 	nfsd_head.nd_flag |= NFSD_CHECKSLP;
1914 }
1915 
1916 nfs_msg(p, server, msg)
1917 	struct proc *p;
1918 	char *server, *msg;
1919 {
1920 	tpr_t tpr;
1921 
1922 	if (p)
1923 		tpr = tprintf_open(p);
1924 	else
1925 		tpr = NULL;
1926 	tprintf(tpr, "nfs server %s: %s\n", server, msg);
1927 	tprintf_close(tpr);
1928 }
1929