![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to nfs_socket.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / nfs|
Return to nfs_socket.c CVS log | Up to [Apple XNU] / XNU / bsd / nfs |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
23: /*
24: * Copyright (c) 1989, 1991, 1993, 1995
25: * The Regents of the University of California. All rights reserved.
26: *
27: * This code is derived from software contributed to Berkeley by
28: * Rick Macklem at The University of Guelph.
29: *
30: * Redistribution and use in source and binary forms, with or without
31: * modification, are permitted provided that the following conditions
32: * are met:
33: * 1. Redistributions of source code must retain the above copyright
34: * notice, this list of conditions and the following disclaimer.
35: * 2. Redistributions in binary form must reproduce the above copyright
36: * notice, this list of conditions and the following disclaimer in the
37: * documentation and/or other materials provided with the distribution.
38: * 3. All advertising materials mentioning features or use of this software
39: * must display the following acknowledgement:
40: * This product includes software developed by the University of
41: * California, Berkeley and its contributors.
42: * 4. Neither the name of the University nor the names of its contributors
43: * may be used to endorse or promote products derived from this software
44: * without specific prior written permission.
45: *
46: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
47: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
48: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
49: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
50: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
51: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
52: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
53: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
54: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
55: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
56: * SUCH DAMAGE.
57: *
58: * @(#)nfs_socket.c 8.5 (Berkeley) 3/30/95
59: * FreeBSD-Id: nfs_socket.c,v 1.30 1997/10/28 15:59:07 bde Exp $
60: */
61:
62: /*
63: * Socket operations for use by nfs
64: */
65:
66: #include <sys/param.h>
67: #include <sys/systm.h>
68: #include <sys/proc.h>
69: #include <sys/mount.h>
70: #include <sys/kernel.h>
71: #include <sys/mbuf.h>
72: #include <sys/malloc.h>
73: #include <sys/vnode.h>
74: #include <sys/domain.h>
75: #include <sys/protosw.h>
76: #include <sys/socket.h>
77: #include <sys/socketvar.h>
78: #include <sys/syslog.h>
79: #include <sys/tprintf.h>
80: #include <machine/spl.h>
81:
82: #include <netinet/in.h>
83: #include <netinet/tcp.h>
84:
85: #include <nfs/rpcv2.h>
86: #include <nfs/nfsproto.h>
87: #include <nfs/nfs.h>
88: #include <nfs/xdr_subs.h>
89: #include <nfs/nfsm_subs.h>
90: #include <nfs/nfsmount.h>
91: #include <nfs/nfsnode.h>
92: #include <nfs/nfsrtt.h>
93: #include <nfs/nqnfs.h>
94:
95: #define TRUE 1
96: #define FALSE 0
97:
98: /*
99: * Estimate rto for an nfs rpc sent via. an unreliable datagram.
100: * Use the mean and mean deviation of rtt for the appropriate type of rpc
101: * for the frequent rpcs and a default for the others.
102: * The justification for doing "other" this way is that these rpcs
103: * happen so infrequently that timer est. would probably be stale.
104: * Also, since many of these rpcs are
105: * non-idempotent, a conservative timeout is desired.
106: * getattr, lookup - A+2D
107: * read, write - A+4D
108: * other - nm_timeo
109: */
110: #define NFS_RTO(n, t) \
111: ((t) == 0 ? (n)->nm_timeo : \
112: ((t) < 3 ? \
113: (((((n)->nm_srtt[t-1] + 3) >> 2) + (n)->nm_sdrtt[t-1] + 1) >> 1) : \
114: ((((n)->nm_srtt[t-1] + 7) >> 3) + (n)->nm_sdrtt[t-1] + 1)))
115: #define NFS_SRTT(r) (r)->r_nmp->nm_srtt[proct[(r)->r_procnum] - 1]
116: #define NFS_SDRTT(r) (r)->r_nmp->nm_sdrtt[proct[(r)->r_procnum] - 1]
117: /*
118: * External data, mostly RPC constants in XDR form
119: */
120: extern u_long rpc_reply, rpc_msgdenied, rpc_mismatch, rpc_vers, rpc_auth_unix,
121: rpc_msgaccepted, rpc_call, rpc_autherr,
122: rpc_auth_kerb;
123: extern u_long nfs_prog, nqnfs_prog;
124: extern time_t nqnfsstarttime;
125: extern struct nfsstats nfsstats;
126: extern int nfsv3_procid[NFS_NPROCS];
127: extern int nfs_ticks;
128:
129: /*
130: * Defines which timer to use for the procnum.
131: * 0 - default
132: * 1 - getattr
133: * 2 - lookup
134: * 3 - read
135: * 4 - write
136: */
137: static int proct[NFS_NPROCS] = {
138: 0, 1, 0, 2, 1, 3, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 0, 0, 0, 0, 0,
139: 0, 0, 0,
140: };
141:
142: /*
143: * There is a congestion window for outstanding rpcs maintained per mount
144: * point. The cwnd size is adjusted in roughly the way that:
145: * Van Jacobson, Congestion avoidance and Control, In "Proceedings of
146: * SIGCOMM '88". ACM, August 1988.
147: * describes for TCP. The cwnd size is chopped in half on a retransmit timeout
148: * and incremented by 1/cwnd when each rpc reply is received and a full cwnd
149: * of rpcs is in progress.
150: * (The sent count and cwnd are scaled for integer arith.)
151: * Variants of "slow start" were tried and were found to be too much of a
152: * performance hit (ave. rtt 3 times larger),
153: * I suspect due to the large rtt that nfs rpcs have.
154: */
155: #define NFS_CWNDSCALE 256
156: #define NFS_MAXCWND (NFS_CWNDSCALE * 32)
157: static int nfs_backoff[8] = { 2, 4, 8, 16, 32, 64, 128, 256, };
158: int nfsrtton = 0;
159: struct nfsrtt nfsrtt;
160:
161: static int nfs_msg __P((struct proc *,char *,char *));
162: static int nfs_rcvlock __P((struct nfsreq *));
163: static void nfs_rcvunlock __P((int *flagp));
164: static int nfs_receive __P((struct nfsreq *rep, struct mbuf **aname,
165: struct mbuf **mp));
166: static int nfs_reconnect __P((struct nfsreq *rep));
167: #ifndef NFS_NOSERVER
168: static int nfsrv_getstream __P((struct nfssvc_sock *,int));
169:
170: int (*nfsrv3_procs[NFS_NPROCS]) __P((struct nfsrv_descript *nd,
171: struct nfssvc_sock *slp,
172: struct proc *procp,
173: struct mbuf **mreqp)) = {
174: nfsrv_null,
175: nfsrv_getattr,
176: nfsrv_setattr,
177: nfsrv_lookup,
178: nfsrv3_access,
179: nfsrv_readlink,
180: nfsrv_read,
181: nfsrv_write,
182: nfsrv_create,
183: nfsrv_mkdir,
184: nfsrv_symlink,
185: nfsrv_mknod,
186: nfsrv_remove,
187: nfsrv_rmdir,
188: nfsrv_rename,
189: nfsrv_link,
190: nfsrv_readdir,
191: nfsrv_readdirplus,
192: nfsrv_statfs,
193: nfsrv_fsinfo,
194: nfsrv_pathconf,
195: nfsrv_commit,
196: nqnfsrv_getlease,
197: nqnfsrv_vacated,
198: nfsrv_noop,
199: nfsrv_noop
200: };
201: #endif /* NFS_NOSERVER */
202:
203: #if DIAGNOSTIC
204: uint nfstraceindx = 0;
205: struct nfstracerec nfstracebuf[NFSTBUFSIZ] = {{0,0,0,0}};
206: uint nfstracemask = 0; /* enables trace points 0 to 31 (right to left) */
207:
208: int nfsprnttimo = 1;
209:
210: int nfsodata[1024];
211: int nfsoprocnum, nfsolen;
212: int nfsbt[32], nfsbtlen;
213:
214:
215: #if defined(__ppc__)
216: int
217: backtrace(int *where, int size)
218: {
219: int register sp, *fp, numsaved;
220:
221: __asm__ volatile("mr %0,r1" : "=r" (sp));
222:
223: fp = (int *)*((int *)sp);
224: size /= sizeof(int);
225: for (numsaved = 0; numsaved < size; numsaved++) {
226: *where++ = fp[2];
227: if ((int)fp <= 0)
228: break;
229: fp = (int *)*fp;
230: }
231: return (numsaved);
232: }
233: #elif defined(__i386__)
234: int
235: backtrace()
236: {
237: return(0); /* Till someone implements a real routine */
238: }
239: #else
240: #error architecture not implemented.
241: #endif
242:
243: void
244: nfsdup(struct nfsreq *rep)
245: {
246: int *ip, i, first = 1, end;
247: char *s, b[240];
248: struct mbuf *mb;
249:
250: if ((nfs_debug & NFS_DEBUG_DUP) == 0)
251: return;
252: /* last mbuf in chain will be nfs content */
253: for (mb = rep->r_mreq; mb->m_next; mb = mb->m_next)
254: ;
255: if (rep->r_procnum == nfsoprocnum && mb->m_len == nfsolen &&
256: !bcmp((caddr_t)nfsodata, mb->m_data, nfsolen)) {
257: s = b + sprintf(b, "nfsdup x=%x p=%d h=", rep->r_xid,
258: rep->r_procnum);
259: end = (int)(VTONFS(rep->r_vp)->n_fhp);
260: ip = (int *)(end & ~3);
261: end += VTONFS(rep->r_vp)->n_fhsize;
262: while ((int)ip < end) {
263: i = *ip++;
264: if (first) { /* avoid leading zeroes */
265: if (i == 0)
266: continue;
267: first = 0;
268: s += sprintf(s, "%x", i);
269: } else
270: s += sprintf(s, "%08x", i);
271: }
272: if (first)
273: sprintf(s, "%x", 0);
274: else /* eliminate trailing zeroes */
275: while (*--s == '0')
276: *s = 0;
277: /*
278: * set a breakpoint here and you can view the
279: * current backtrace and the one saved in nfsbt
280: */
281: kprintf("%s\n", b);
282: }
283: nfsoprocnum = rep->r_procnum;
284: nfsolen = mb->m_len;
285: bcopy(mb->m_data, (caddr_t)nfsodata, mb->m_len);
286: nfsbtlen = backtrace(&nfsbt, sizeof(nfsbt));
287: }
288: #endif
289:
290: /*
291: * Initialize sockets and congestion for a new NFS connection.
292: * We do not free the sockaddr if error.
293: */
294: int
295: nfs_connect(nmp, rep)
296: register struct nfsmount *nmp;
297: struct nfsreq *rep;
298: {
299: register struct socket *so;
300: int s, error, rcvreserve, sndreserve;
301: struct sockaddr *saddr;
302: struct sockaddr_in sin;
303: u_short tport;
304:
305: nmp->nm_so = (struct socket *)0;
306: saddr = mtod(nmp->nm_nam, struct sockaddr *);
307: error = socreate(saddr->sa_family, &nmp->nm_so, nmp->nm_sotype,
308: nmp->nm_soproto);
309: if (error)
310: goto bad;
311: so = nmp->nm_so;
312: nmp->nm_soflags = so->so_proto->pr_flags;
313:
314: /*
315: * Some servers require that the client port be a reserved port number.
316: */
317: if (saddr->sa_family == AF_INET && (nmp->nm_flag & NFSMNT_RESVPORT)) {
318: sin.sin_len = sizeof (struct sockaddr_in);
319: sin.sin_family = AF_INET;
320: sin.sin_addr.s_addr = INADDR_ANY;
321: tport = IPPORT_RESERVED - 1;
322: sin.sin_port = htons(tport);
323: while ((error = sobind(so, (struct sockaddr *) &sin) == EADDRINUSE) &&
324: (--tport > IPPORT_RESERVED / 2))
325: sin.sin_port = htons(tport);
326:
327: if (error)
328: goto bad;
329: }
330:
331: /*
332: * Protocols that do not require connections may be optionally left
333: * unconnected for servers that reply from a port other than NFS_PORT.
334: */
335: if (nmp->nm_flag & NFSMNT_NOCONN) {
336: if (nmp->nm_soflags & PR_CONNREQUIRED) {
337: error = ENOTCONN;
338: goto bad;
339: }
340: } else {
341: error = soconnect(so, mtod(nmp->nm_nam, struct sockaddr *));
342: if (error)
343: goto bad;
344:
345: /*
346: * Wait for the connection to complete. Cribbed from the
347: * connect system call but with the wait timing out so
348: * that interruptible mounts don't hang here for a long time.
349: */
350: s = splnet();
351: while ((so->so_state & SS_ISCONNECTING) && so->so_error == 0) {
352: (void) tsleep((caddr_t)&so->so_timeo, PSOCK,
353: "nfscon", 2 * hz);
354: if ((so->so_state & SS_ISCONNECTING) &&
355: so->so_error == 0 && rep &&
356: (error = nfs_sigintr(nmp, rep, rep->r_procp))) {
357: so->so_state &= ~SS_ISCONNECTING;
358: splx(s);
359: goto bad;
360: }
361: }
362: if (so->so_error) {
363: error = so->so_error;
364: so->so_error = 0;
365: splx(s);
366: goto bad;
367: }
368: splx(s);
369: }
370: if (nmp->nm_flag & (NFSMNT_SOFT | NFSMNT_INT)) {
371: so->so_rcv.sb_timeo = (5 * hz);
372: so->so_snd.sb_timeo = (5 * hz);
373: } else {
374: so->so_rcv.sb_timeo = 0;
375: so->so_snd.sb_timeo = 0;
376: }
377: if (nmp->nm_sotype == SOCK_DGRAM) {
378: sndreserve = (nmp->nm_wsize + NFS_MAXPKTHDR) * 2;
379: rcvreserve = (nmp->nm_rsize + NFS_MAXPKTHDR) * 2;
380: } else if (nmp->nm_sotype == SOCK_SEQPACKET) {
381: sndreserve = (nmp->nm_wsize + NFS_MAXPKTHDR) * 2;
382: rcvreserve = (nmp->nm_rsize + NFS_MAXPKTHDR) * 2;
383: } else {
384: if (nmp->nm_sotype != SOCK_STREAM)
385: panic("nfscon sotype");
386:
387: if (so->so_proto->pr_flags & PR_CONNREQUIRED) {
388: struct sockopt sopt;
389: int val;
390:
391: bzero(&sopt, sizeof sopt);
392: sopt.sopt_level = SOL_SOCKET;
393: sopt.sopt_name = SO_KEEPALIVE;
394: sopt.sopt_val = &val;
395: sopt.sopt_valsize = sizeof val;
396: val = 1;
397: sosetopt(so, &sopt);
398: }
399: if (so->so_proto->pr_protocol == IPPROTO_TCP) {
400: struct sockopt sopt;
401: int val;
402:
403: bzero(&sopt, sizeof sopt);
404: sopt.sopt_level = IPPROTO_TCP;
405: sopt.sopt_name = TCP_NODELAY;
406: sopt.sopt_val = &val;
407: sopt.sopt_valsize = sizeof val;
408: val = 1;
409: sosetopt(so, &sopt);
410: }
411:
412: sndreserve = (nmp->nm_wsize + NFS_MAXPKTHDR + sizeof (u_long))
413: * 2;
414: rcvreserve = (nmp->nm_rsize + NFS_MAXPKTHDR + sizeof (u_long))
415: * 2;
416: }
417: error = soreserve(so, sndreserve, rcvreserve);
418: if (error)
419: goto bad;
420: so->so_rcv.sb_flags |= SB_NOINTR;
421: so->so_snd.sb_flags |= SB_NOINTR;
422:
423: /* Initialize other non-zero congestion variables */
424: nmp->nm_srtt[0] = nmp->nm_srtt[1] = nmp->nm_srtt[2] =
425: nmp->nm_srtt[3] = (NFS_TIMEO << 3);
426: nmp->nm_sdrtt[0] = nmp->nm_sdrtt[1] = nmp->nm_sdrtt[2] =
427: nmp->nm_sdrtt[3] = 0;
428: nmp->nm_cwnd = NFS_MAXCWND / 2; /* Initial send window */
429: nmp->nm_sent = 0;
430: nmp->nm_timeouts = 0;
431: return (0);
432:
433: bad:
434: nfs_disconnect(nmp);
435: return (error);
436: }
437:
438: /*
439: * Reconnect routine:
440: * Called when a connection is broken on a reliable protocol.
441: * - clean up the old socket
442: * - nfs_connect() again
443: * - set R_MUSTRESEND for all outstanding requests on mount point
444: * If this fails the mount point is DEAD!
445: * nb: Must be called with the nfs_sndlock() set on the mount point.
446: */
447: static int
448: nfs_reconnect(rep)
449: register struct nfsreq *rep;
450: {
451: register struct nfsreq *rp;
452: register struct nfsmount *nmp = rep->r_nmp;
453: int error;
454:
455: nfs_disconnect(nmp);
456: while ((error = nfs_connect(nmp, rep))) {
457: if (error == EINTR || error == ERESTART)
458: return (EINTR);
459: (void) tsleep((caddr_t)&lbolt, PSOCK, "nfscon", 0);
460: }
461:
462: NFS_DPF(DUP, ("nfs_reconnect RESEND\n"));
463: /*
464: * Loop through outstanding request list and fix up all requests
465: * on old socket.
466: */
467: for (rp = nfs_reqq.tqh_first; rp != 0; rp = rp->r_chain.tqe_next) {
468: if (rp->r_nmp == nmp)
469: rp->r_flags |= R_MUSTRESEND;
470: }
471: return (0);
472: }
473:
474: /*
475: * NFS disconnect. Clean up and unlink.
476: */
477: void
478: nfs_disconnect(nmp)
479: register struct nfsmount *nmp;
480: {
481: register struct socket *so;
482:
483: if (nmp->nm_so) {
484: so = nmp->nm_so;
485: nmp->nm_so = (struct socket *)0;
486: soshutdown(so, 2);
487: soclose(so);
488: }
489: }
490:
491: /*
492: * This is the nfs send routine. For connection based socket types, it
493: * must be called with an nfs_sndlock() on the socket.
494: * "rep == NULL" indicates that it has been called from a server.
495: * For the client side:
496: * - return EINTR if the RPC is terminated, 0 otherwise
497: * - set R_MUSTRESEND if the send fails for any reason
498: * - do any cleanup required by recoverable socket errors (???)
499: * For the server side:
500: * - return EINTR or ERESTART if interrupted by a signal
501: * - return EPIPE if a connection is lost for connection based sockets (TCP...)
502: * - do any cleanup required by recoverable socket errors (???)
503: */
504: int
505: nfs_send(so, nam, top, rep)
506: register struct socket *so;
507: struct mbuf *nam;
508: register struct mbuf *top;
509: struct nfsreq *rep;
510: {
511: struct sockaddr *sendnam;
512: int error, soflags, flags;
513:
514: if (rep) {
515: if (rep->r_flags & R_SOFTTERM) {
516: m_freem(top);
517: return (EINTR);
518: }
519: if ((so = rep->r_nmp->nm_so) == NULL) {
520: rep->r_flags |= R_MUSTRESEND;
521: m_freem(top);
522: return (0);
523: }
524: rep->r_flags &= ~R_MUSTRESEND;
525: soflags = rep->r_nmp->nm_soflags;
526: } else
527: soflags = so->so_proto->pr_flags;
528: if ((soflags & PR_CONNREQUIRED) || (so->so_state & SS_ISCONNECTED) ||
529: (nam == 0))
530: sendnam = (struct sockaddr *)0;
531: else
532: sendnam = mtod(nam, struct sockaddr *);
533:
534: if (so->so_type == SOCK_SEQPACKET)
535: flags = MSG_EOR;
536: else
537: flags = 0;
538:
539: #if DIAGNOSTIC
540: if (rep)
541: nfsdup(rep);
542: #endif
543: error = sosend(so, sendnam, (struct uio *)0, top,
544: (struct mbuf *)0, flags);
545: if (error) {
546: if (rep) {
547: log(LOG_INFO, "nfs send error %d for server %s\n",
548: error,
549: rep->r_nmp->nm_mountp->mnt_stat.f_mntfromname);
550: /*
551: * Deal with errors for the client side.
552: */
553: if (rep->r_flags & R_SOFTTERM)
554: error = EINTR;
555: else {
556: rep->r_flags |= R_MUSTRESEND;
557: NFS_DPF(DUP,
558: ("nfs_send RESEND error=%d\n",
559: error));
560: }
561: } else
562: log(LOG_INFO, "nfsd send error %d\n", error);
563:
564: /*
565: * Handle any recoverable (soft) socket errors here. (???)
566: */
567: if (error != EINTR && error != ERESTART &&
568: error != EWOULDBLOCK && error != EPIPE)
569: error = 0;
570: }
571: return (error);
572: }
573:
574: /*
575: * Receive a Sun RPC Request/Reply. For SOCK_DGRAM, the work is all
576: * done by soreceive(), but for SOCK_STREAM we must deal with the Record
577: * Mark and consolidate the data into a new mbuf list.
578: * nb: Sometimes TCP passes the data up to soreceive() in long lists of
579: * small mbufs.
580: * For SOCK_STREAM we must be very careful to read an entire record once
581: * we have read any of it, even if the system call has been interrupted.
582: */
583: static int
584: nfs_receive(rep, aname, mp)
585: register struct nfsreq *rep;
586: struct mbuf **aname;
587: struct mbuf **mp;
588: {
589: register struct socket *so;
590: struct uio auio;
591: struct iovec aio;
592: register struct mbuf *m;
593: struct mbuf *control;
594: u_long len;
595: struct sockaddr **getnam;
596: struct sockaddr *tmp_nam;
597: struct mbuf *mhck;
598: struct sockaddr_in *sin;
599: int error, sotype, rcvflg;
600: struct proc *p = current_proc(); /* XXX */
601:
602: /*
603: * Set up arguments for soreceive()
604: */
605: *mp = (struct mbuf *)0;
606: *aname = (struct mbuf *)0;
607: sotype = rep->r_nmp->nm_sotype;
608:
609: /*
610: * For reliable protocols, lock against other senders/receivers
611: * in case a reconnect is necessary.
612: * For SOCK_STREAM, first get the Record Mark to find out how much
613: * more there is to get.
614: * We must lock the socket against other receivers
615: * until we have an entire rpc request/reply.
616: */
617: if (sotype != SOCK_DGRAM) {
618: error = nfs_sndlock(&rep->r_nmp->nm_flag, rep);
619: if (error)
620: return (error);
621: tryagain:
622: /*
623: * Check for fatal errors and resending request.
624: */
625: /*
626: * Ugh: If a reconnect attempt just happened, nm_so
627: * would have changed. NULL indicates a failed
628: * attempt that has essentially shut down this
629: * mount point.
630: */
631: if (rep->r_mrep || (rep->r_flags & R_SOFTTERM)) {
632: nfs_sndunlock(&rep->r_nmp->nm_flag);
633: return (EINTR);
634: }
635: so = rep->r_nmp->nm_so;
636: if (!so) {
637: error = nfs_reconnect(rep);
638: if (error) {
639: nfs_sndunlock(&rep->r_nmp->nm_flag);
640: return (error);
641: }
642: goto tryagain;
643: }
644: while (rep->r_flags & R_MUSTRESEND) {
645: m = m_copym(rep->r_mreq, 0, M_COPYALL, M_WAIT);
646: nfsstats.rpcretries++;
647: NFS_DPF(DUP,
648: ("nfs_receive RESEND %s\n",
649: rep->r_nmp->nm_mountp->mnt_stat.f_mntfromname));
650: error = nfs_send(so, rep->r_nmp->nm_nam, m, rep);
651: if (error) {
652: if (error == EINTR || error == ERESTART ||
653: (error = nfs_reconnect(rep))) {
654: nfs_sndunlock(&rep->r_nmp->nm_flag);
655: return (error);
656: }
657: goto tryagain;
658: }
659: }
660: nfs_sndunlock(&rep->r_nmp->nm_flag);
661: if (sotype == SOCK_STREAM) {
662: aio.iov_base = (caddr_t) &len;
663: aio.iov_len = sizeof(u_long);
664: auio.uio_iov = &aio;
665: auio.uio_iovcnt = 1;
666: auio.uio_segflg = UIO_SYSSPACE;
667: auio.uio_rw = UIO_READ;
668: auio.uio_offset = 0;
669: auio.uio_resid = sizeof(u_long);
670: auio.uio_procp = p;
671: do {
672: rcvflg = MSG_WAITALL;
673: error = soreceive(so, (struct sockaddr **)0, &auio,
674: (struct mbuf **)0, (struct mbuf **)0, &rcvflg);
675: if (!rep->r_nmp) /* if unmounted then bailout */
676: goto shutout;
677: if (error == EWOULDBLOCK && rep) {
678: if (rep->r_flags & R_SOFTTERM)
679: return (EINTR);
680: }
681: } while (error == EWOULDBLOCK);
682: if (!error && auio.uio_resid > 0) {
683: log(LOG_INFO,
684: "short receive (%d/%d) from nfs server %s\n",
685: sizeof(u_long) - auio.uio_resid,
686: sizeof(u_long),
687: rep->r_nmp->nm_mountp->mnt_stat.f_mntfromname);
688: error = EPIPE;
689: }
690: if (error)
691: goto errout;
692: len = ntohl(len) & ~0x80000000;
693: /*
694: * This is SERIOUS! We are out of sync with the sender
695: * and forcing a disconnect/reconnect is all I can do.
696: */
697: if (len > NFS_MAXPACKET) {
698: log(LOG_ERR, "%s (%d) from nfs server %s\n",
699: "impossible packet length",
700: len,
701: rep->r_nmp->nm_mountp->mnt_stat.f_mntfromname);
702: error = EFBIG;
703: goto errout;
704: }
705: auio.uio_resid = len;
706: do {
707: rcvflg = MSG_WAITALL;
708: error = soreceive(so, (struct sockaddr **)0,
709: &auio, mp, (struct mbuf **)0, &rcvflg);
710: if (!rep->r_nmp) /* if unmounted then bailout */
711: goto shutout;
712: } while (error == EWOULDBLOCK || error == EINTR ||
713: error == ERESTART);
714: if (!error && auio.uio_resid > 0) {
715: log(LOG_INFO,
716: "short receive (%d/%d) from nfs server %s\n",
717: len - auio.uio_resid, len,
718: rep->r_nmp->nm_mountp->mnt_stat.f_mntfromname);
719: error = EPIPE;
720: }
721: } else {
722: /*
723: * NB: Since uio_resid is big, MSG_WAITALL is ignored
724: * and soreceive() will return when it has either a
725: * control msg or a data msg.
726: * We have no use for control msg., but must grab them
727: * and then throw them away so we know what is going
728: * on.
729: */
730: auio.uio_resid = len = 100000000; /* Anything Big */
731: auio.uio_procp = p;
732: do {
733: rcvflg = 0;
734: error = soreceive(so, (struct sockaddr **)0,
735: &auio, mp, &control, &rcvflg);
736: if (!rep->r_nmp) /* if unmounted then bailout */
737: goto shutout;
738: if (control)
739: m_freem(control);
740: if (error == EWOULDBLOCK && rep) {
741: if (rep->r_flags & R_SOFTTERM)
742: return (EINTR);
743: }
744: } while (error == EWOULDBLOCK ||
745: (!error && *mp == NULL && control));
746: if ((rcvflg & MSG_EOR) == 0)
747: printf("Egad!!\n");
748: if (!error && *mp == NULL)
749: error = EPIPE;
750: len -= auio.uio_resid;
751: }
752: errout:
753: if (error && error != EINTR && error != ERESTART) {
754: m_freem(*mp);
755: *mp = (struct mbuf *)0;
756: if (error != EPIPE)
757: log(LOG_INFO,
758: "receive error %d from nfs server %s\n",
759: error,
760: rep->r_nmp->nm_mountp->mnt_stat.f_mntfromname);
761: error = nfs_sndlock(&rep->r_nmp->nm_flag, rep);
762: if (!error)
763: error = nfs_reconnect(rep);
764: if (!error)
765: goto tryagain;
766: }
767: } else {
768: if ((so = rep->r_nmp->nm_so) == NULL)
769: return (EACCES);
770: if (so->so_state & SS_ISCONNECTED)
771: getnam = (struct sockaddr **)0;
772: else
773: getnam = &tmp_nam;;
774: auio.uio_resid = len = 1000000;
775: auio.uio_procp = p;
776: do {
777: rcvflg = 0;
778: error = soreceive(so, getnam, &auio, mp,
779: (struct mbuf **)0, &rcvflg);
780:
781: if ((getnam) && (*getnam)) {
782: MGET(mhck, M_WAIT, MT_SONAME);
783: mhck->m_len = (*getnam)->sa_len;
784: sin = mtod(mhck, struct sockaddr_in *);
785: bcopy(*getnam, sin, sizeof(struct sockaddr_in));
786: mhck->m_hdr.mh_len = sizeof(struct sockaddr_in);
787: FREE(*getnam, M_SONAME);
788: *aname = mhck;
789: }
790: if (!rep->r_nmp) /* if unmounted then bailout */
791: goto shutout;
792:
793: if (error == EWOULDBLOCK &&
794: (rep->r_flags & R_SOFTTERM))
795: return (EINTR);
796: } while (error == EWOULDBLOCK);
797: len -= auio.uio_resid;
798: }
799: shutout:
800: if (error) {
801: m_freem(*mp);
802: *mp = (struct mbuf *)0;
803: }
804: return (error);
805: }
806:
807: /*
808: * Implement receipt of reply on a socket.
809: * We must search through the list of received datagrams matching them
810: * with outstanding requests using the xid, until ours is found.
811: */
812: /* ARGSUSED */
813: int
814: nfs_reply(myrep)
815: struct nfsreq *myrep;
816: {
817: register struct nfsreq *rep;
818: register struct nfsmount *nmp = myrep->r_nmp;
819: register long t1;
820: struct mbuf *mrep, *md;
821: struct mbuf *nam;
822: u_long rxid, *tl;
823: caddr_t dpos, cp2;
824: int error;
825:
826: /*
827: * Loop around until we get our own reply
828: */
829: for (;;) {
830: /*
831: * Lock against other receivers so that I don't get stuck in
832: * sbwait() after someone else has received my reply for me.
833: * Also necessary for connection based protocols to avoid
834: * race conditions during a reconnect.
835: * If nfs_rcvlock() returns EALREADY, that means that
836: * the reply has already been recieved by another
837: * process and we can return immediately. In this
838: * case, the lock is not taken to avoid races with
839: * other processes.
840: */
841: error = nfs_rcvlock(myrep);
842: if (error == EALREADY)
843: return (0);
844: if (error)
845: return (error);
846: /*
847: * Get the next Rpc reply off the socket
848: */
849: error = nfs_receive(myrep, &nam, &mrep);
850: /*
851: * Bailout asap if nfsmount struct gone (unmounted)
852: */
853: if (!myrep->r_nmp)
854: return(ECONNABORTED);
855: nfs_rcvunlock(&nmp->nm_flag);
856: if (error) {
857:
858: /*
859: * Ignore routing errors on connectionless protocols??
860: */
861: if (NFSIGNORE_SOERROR(nmp->nm_soflags, error)) {
862: nmp->nm_so->so_error = 0;
863: if (myrep->r_flags & R_GETONEREP)
864: return (0);
865: continue;
866: }
867: return (error);
868: }
869: if (nam)
870: m_freem(nam);
871:
872: /*
873: * Get the xid and check that it is an rpc reply
874: */
875: md = mrep;
876: dpos = mtod(md, caddr_t);
877: nfsm_dissect(tl, u_long *, 2*NFSX_UNSIGNED);
878: rxid = *tl++;
879: if (*tl != rpc_reply) {
880: #ifndef NFS_NOSERVER
881: if (nmp->nm_flag & NFSMNT_NQNFS) {
882: if (nqnfs_callback(nmp, mrep, md, dpos))
883: nfsstats.rpcinvalid++;
884: } else {
885: nfsstats.rpcinvalid++;
886: m_freem(mrep);
887: }
888: #else
889: nfsstats.rpcinvalid++;
890: m_freem(mrep);
891: #endif
892: nfsmout:
893: if (myrep->r_flags & R_GETONEREP)
894: return (0);
895: continue;
896: }
897:
898: /*
899: * Loop through the request list to match up the reply
900: * Iff no match, just drop the datagram
901: */
902: for (rep = nfs_reqq.tqh_first; rep != 0;
903: rep = rep->r_chain.tqe_next) {
904: if (rep->r_mrep == NULL && rxid == rep->r_xid) {
905: /* Found it.. */
906: rep->r_mrep = mrep;
907: rep->r_md = md;
908: rep->r_dpos = dpos;
909: if (nfsrtton) {
910: struct rttl *rt;
911:
912: rt = &nfsrtt.rttl[nfsrtt.pos];
913: rt->proc = rep->r_procnum;
914: rt->rto = NFS_RTO(nmp, proct[rep->r_procnum]);
915: rt->sent = nmp->nm_sent;
916: rt->cwnd = nmp->nm_cwnd;
917: if (proct[rep->r_procnum] == 0)
918: panic("nfs_reply: proct[%d] is zero", rep->r_procnum);
919: rt->srtt = nmp->nm_srtt[proct[rep->r_procnum] - 1];
920: rt->sdrtt = nmp->nm_sdrtt[proct[rep->r_procnum] - 1];
921: rt->fsid = nmp->nm_mountp->mnt_stat.f_fsid;
922: rt->tstamp = time;
923: if (rep->r_flags & R_TIMING)
924: rt->rtt = rep->r_rtt;
925: else
926: rt->rtt = 1000000;
927: nfsrtt.pos = (nfsrtt.pos + 1) % NFSRTTLOGSIZ;
928: }
929: /*
930: * Update congestion window.
931: * Do the additive increase of
932: * one rpc/rtt.
933: */
934: if (nmp->nm_cwnd <= nmp->nm_sent) {
935: nmp->nm_cwnd +=
936: (NFS_CWNDSCALE * NFS_CWNDSCALE +
937: (nmp->nm_cwnd >> 1)) / nmp->nm_cwnd;
938: if (nmp->nm_cwnd > NFS_MAXCWND)
939: nmp->nm_cwnd = NFS_MAXCWND;
940: }
941: rep->r_flags &= ~R_SENT;
942: nmp->nm_sent -= NFS_CWNDSCALE;
943: /*
944: * Update rtt using a gain of 0.125 on the mean
945: * and a gain of 0.25 on the deviation.
946: */
947: if (rep->r_flags & R_TIMING) {
948: /*
949: * Since the timer resolution of
950: * NFS_HZ is so course, it can often
951: * result in r_rtt == 0. Since
952: * r_rtt == N means that the actual
953: * rtt is between N+dt and N+2-dt ticks,
954: * add 1.
955: */
956: if (proct[rep->r_procnum] == 0)
957: panic("nfs_reply: proct[%d] is zero", rep->r_procnum);
958: t1 = rep->r_rtt + 1;
959: t1 -= (NFS_SRTT(rep) >> 3);
960: NFS_SRTT(rep) += t1;
961: if (t1 < 0)
962: t1 = -t1;
963: t1 -= (NFS_SDRTT(rep) >> 2);
964: NFS_SDRTT(rep) += t1;
965: }
966: nmp->nm_timeouts = 0;
967: break;
968: }
969: }
970: /*
971: * If not matched to a request, drop it.
972: * If it's mine, get out.
973: */
974: if (rep == 0) {
975: nfsstats.rpcunexpected++;
976: m_freem(mrep);
977: } else if (rep == myrep) {
978: if (rep->r_mrep == NULL)
979: panic("nfsreply nil");
980: return (0);
981: }
982: if (myrep->r_flags & R_GETONEREP)
983: return (0);
984: }
985: }
986:
987: /*
988: * nfs_request - goes something like this
989: * - fill in request struct
990: * - links it into list
991: * - calls nfs_send() for first transmit
992: * - calls nfs_receive() to get reply
993: * - break down rpc header and return with nfs reply pointed to
994: * by mrep or error
995: * nb: always frees up mreq mbuf list
996: */
997: int
998: nfs_request(vp, mrest, procnum, procp, cred, mrp, mdp, dposp)
999: struct vnode *vp;
1000: struct mbuf *mrest;
1001: int procnum;
1002: struct proc *procp;
1003: struct ucred *cred;
1004: struct mbuf **mrp;
1005: struct mbuf **mdp;
1006: caddr_t *dposp;
1007: {
1008: register struct mbuf *m, *mrep;
1009: register struct nfsreq *rep;
1010: register u_long *tl;
1011: register int i;
1012: struct nfsmount *nmp;
1013: struct mbuf *md, *mheadend;
1014: struct nfsnode *np;
1015: char nickv[RPCX_NICKVERF];
1016: time_t reqtime, waituntil;
1017: caddr_t dpos, cp2;
1018: int t1, nqlflag, cachable, s, error = 0, mrest_len, auth_len, auth_type;
1019: int trylater_delay = NQ_TRYLATERDEL, trylater_cnt = 0, failed_auth = 0;
1020: int verf_len, verf_type;
1021: u_long xid;
1022: u_quad_t frev;
1023: char *auth_str, *verf_str;
1024: NFSKERBKEY_T key; /* save session key */
1025:
1026: NFSTRACE4(NFSTRC_REQ, vp, procnum, 0, 0);
1027: nmp = VFSTONFS(vp->v_mount);
1028:
1029: MALLOC_ZONE(rep, struct nfsreq *,
1030: sizeof(struct nfsreq), M_NFSREQ, M_WAITOK);
1031: rep->r_nmp = nmp;
1032: rep->r_vp = vp;
1033: rep->r_procp = procp;
1034: rep->r_procnum = procnum;
1035: i = 0;
1036: m = mrest;
1037: while (m) {
1038: i += m->m_len;
1039: m = m->m_next;
1040: }
1041: mrest_len = i;
1042:
1043: /*
1044: * Get the RPC header with authorization.
1045: */
1046: kerbauth:
1047: verf_str = auth_str = (char *)0;
1048: if (nmp->nm_flag & NFSMNT_KERB) {
1049: verf_str = nickv;
1050: verf_len = sizeof (nickv);
1051: auth_type = RPCAUTH_KERB4;
1052: bzero((caddr_t)key, sizeof (key));
1053: if (failed_auth || nfs_getnickauth(nmp, cred, &auth_str,
1054: &auth_len, verf_str, verf_len)) {
1055: error = nfs_getauth(nmp, rep, cred, &auth_str,
1056: &auth_len, verf_str, &verf_len, key);
1057: if (error) {
1058: _FREE_ZONE((caddr_t)rep,
1059: sizeof (struct nfsreq), M_NFSREQ);
1060: m_freem(mrest);
1061: return (error);
1062: }
1063: }
1064: } else {
1065: auth_type = RPCAUTH_UNIX;
1066: if (cred->cr_ngroups < 1)
1067: panic("nfsreq nogrps");
1068: auth_len = ((((cred->cr_ngroups - 1) > nmp->nm_numgrps) ?
1069: nmp->nm_numgrps : (cred->cr_ngroups - 1)) << 2) +
1070: 5 * NFSX_UNSIGNED;
1071: }
1072: m = nfsm_rpchead(cred, nmp->nm_flag, procnum, auth_type, auth_len,
1073: auth_str, verf_len, verf_str, mrest, mrest_len, &mheadend, &xid);
1074: if (auth_str)
1075: _FREE(auth_str, M_TEMP);
1076:
1077: /*
1078: * For stream protocols, insert a Sun RPC Record Mark.
1079: */
1080: if (nmp->nm_sotype == SOCK_STREAM) {
1081: M_PREPEND(m, NFSX_UNSIGNED, M_WAIT);
1082: *mtod(m, u_long *) = htonl(0x80000000 |
1083: (m->m_pkthdr.len - NFSX_UNSIGNED));
1084: }
1085: rep->r_mreq = m;
1086: rep->r_xid = xid;
1087: tryagain:
1088: if (nmp->nm_flag & NFSMNT_SOFT)
1089: rep->r_retry = nmp->nm_retry;
1090: else
1091: rep->r_retry = NFS_MAXREXMIT + 1; /* past clip limit */
1092: rep->r_rtt = rep->r_rexmit = 0;
1093: if (proct[procnum] > 0)
1094: rep->r_flags = R_TIMING;
1095: else
1096: rep->r_flags = 0;
1097: rep->r_mrep = NULL;
1098:
1099: /*
1100: * Do the client side RPC.
1101: */
1102: nfsstats.rpcrequests++;
1103: /*
1104: * Chain request into list of outstanding requests. Be sure
1105: * to put it LAST so timer finds oldest requests first.
1106: */
1107: s = splsoftclock();
1108: TAILQ_INSERT_TAIL(&nfs_reqq, rep, r_chain);
1109:
1110: /* Get send time for nqnfs */
1111: reqtime = time.tv_sec;
1112:
1113: /*
1114: * If backing off another request or avoiding congestion, don't
1115: * send this one now but let timer do it. If not timing a request,
1116: * do it now.
1117: */
1118: if (nmp->nm_so && (nmp->nm_sotype != SOCK_DGRAM ||
1119: (nmp->nm_flag & NFSMNT_DUMBTIMR) ||
1120: nmp->nm_sent < nmp->nm_cwnd)) {
1121: splx(s);
1122: if (nmp->nm_soflags & PR_CONNREQUIRED)
1123: error = nfs_sndlock(&nmp->nm_flag, rep);
1124: if (!error) {
1125: m = m_copym(m, 0, M_COPYALL, M_WAIT);
1126: error = nfs_send(nmp->nm_so, nmp->nm_nam, m, rep);
1127: if (nmp->nm_soflags & PR_CONNREQUIRED)
1128: nfs_sndunlock(&nmp->nm_flag);
1129: }
1130: if (!error && (rep->r_flags & R_MUSTRESEND) == 0) {
1131: nmp->nm_sent += NFS_CWNDSCALE;
1132: rep->r_flags |= R_SENT;
1133: }
1134: } else {
1135: splx(s);
1136: rep->r_rtt = -1;
1137: }
1138:
1139: /*
1140: * Wait for the reply from our send or the timer's.
1141: */
1142: if (!error || error == EPIPE)
1143: error = nfs_reply(rep);
1144:
1145: /*
1146: * RPC done, unlink the request.
1147: */
1148: s = splsoftclock();
1149: TAILQ_REMOVE(&nfs_reqq, rep, r_chain);
1150: splx(s);
1151:
1152: /*
1153: * Decrement the outstanding request count.
1154: */
1155: if (rep->r_flags & R_SENT) {
1156: rep->r_flags &= ~R_SENT; /* paranoia */
1157: nmp->nm_sent -= NFS_CWNDSCALE;
1158: }
1159:
1160: /*
1161: * If there was a successful reply and a tprintf msg.
1162: * tprintf a response.
1163: */
1164: if (!error && (rep->r_flags & R_TPRINTFMSG))
1165: nfs_msg(rep->r_procp, nmp->nm_mountp->mnt_stat.f_mntfromname,
1166: "is alive again");
1167: mrep = rep->r_mrep;
1168: md = rep->r_md;
1169: dpos = rep->r_dpos;
1170: if (error) {
1171: m_freem(rep->r_mreq);
1172: _FREE_ZONE((caddr_t)rep, sizeof (struct nfsreq), M_NFSREQ);
1173: return (error);
1174: }
1175:
1176: /*
1177: * break down the rpc header and check if ok
1178: */
1179: nfsm_dissect(tl, u_long *, 3 * NFSX_UNSIGNED);
1180: if (*tl++ == rpc_msgdenied) {
1181: if (*tl == rpc_mismatch)
1182: error = EOPNOTSUPP;
1183: else if ((nmp->nm_flag & NFSMNT_KERB) && *tl++ == rpc_autherr) {
1184: if (!failed_auth) {
1185: failed_auth++;
1186: mheadend->m_next = (struct mbuf *)0;
1187: m_freem(mrep);
1188: m_freem(rep->r_mreq);
1189: goto kerbauth;
1190: } else
1191: error = EAUTH;
1192: } else
1193: error = EACCES;
1194: m_freem(mrep);
1195: m_freem(rep->r_mreq);
1196: _FREE_ZONE((caddr_t)rep, sizeof (struct nfsreq), M_NFSREQ);
1197: return (error);
1198: }
1199:
1200: /*
1201: * Grab any Kerberos verifier, otherwise just throw it away.
1202: */
1203: verf_type = fxdr_unsigned(int, *tl++);
1204: i = fxdr_unsigned(int, *tl);
1205: if ((nmp->nm_flag & NFSMNT_KERB) && verf_type == RPCAUTH_KERB4) {
1206: error = nfs_savenickauth(nmp, cred, i, key, &md, &dpos, mrep);
1207: if (error)
1208: goto nfsmout;
1209: } else if (i > 0)
1210: nfsm_adv(nfsm_rndup(i));
1211: nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
1212: /* 0 == ok */
1213: if (*tl == 0) {
1214: nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
1215: if (*tl != 0) {
1216: error = fxdr_unsigned(int, *tl);
1217: if ((nmp->nm_flag & NFSMNT_NFSV3) &&
1218: error == NFSERR_TRYLATER) {
1219: m_freem(mrep);
1220: error = 0;
1221: waituntil = time.tv_sec + trylater_delay;
1222: NFS_DPF(DUP,
1223: ("nfs_request %s flag=%x trylater_cnt=%x waituntil=%lx trylater_delay=%x\n",
1224: nmp->nm_mountp->mnt_stat.f_mntfromname,
1225: nmp->nm_flag, trylater_cnt, waituntil,
1226: trylater_delay));
1227: while (time.tv_sec < waituntil)
1228: (void) tsleep((caddr_t)&lbolt,
1229: PSOCK, "nqnfstry", 0);
1230: trylater_delay *= nfs_backoff[trylater_cnt];
1231: if (trylater_cnt < 7)
1232: trylater_cnt++;
1233: goto tryagain;
1234: }
1235:
1236: /*
1237: * If the File Handle was stale, invalidate the
1238: * lookup cache, just in case.
1239: */
1240: if (error == ESTALE)
1241: cache_purge(vp);
1242: if (nmp->nm_flag & NFSMNT_NFSV3) {
1243: *mrp = mrep;
1244: *mdp = md;
1245: *dposp = dpos;
1246: error |= NFSERR_RETERR;
1247: } else
1248: m_freem(mrep);
1249: m_freem(rep->r_mreq);
1250: _FREE_ZONE((caddr_t)rep,
1251: sizeof (struct nfsreq), M_NFSREQ);
1252: return (error);
1253: }
1254:
1255: /*
1256: * For nqnfs, get any lease in reply
1257: */
1258: if (nmp->nm_flag & NFSMNT_NQNFS) {
1259: nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
1260: if (*tl) {
1261: np = VTONFS(vp);
1262: nqlflag = fxdr_unsigned(int, *tl);
1263: nfsm_dissect(tl, u_long *, 4*NFSX_UNSIGNED);
1264: cachable = fxdr_unsigned(int, *tl++);
1265: reqtime += fxdr_unsigned(int, *tl++);
1266: if (reqtime > time.tv_sec) {
1267: fxdr_hyper(tl, &frev);
1268: nqnfs_clientlease(nmp, np, nqlflag,
1269: cachable, reqtime, frev);
1270: }
1271: }
1272: }
1273: *mrp = mrep;
1274: *mdp = md;
1275: *dposp = dpos;
1276: m_freem(rep->r_mreq);
1277: FREE_ZONE((caddr_t)rep, sizeof (struct nfsreq), M_NFSREQ);
1278: return (0);
1279: }
1280: m_freem(mrep);
1281: error = EPROTONOSUPPORT;
1282: nfsmout:
1283: m_freem(rep->r_mreq);
1284: _FREE_ZONE((caddr_t)rep, sizeof (struct nfsreq), M_NFSREQ);
1285: return (error);
1286: }
1287:
1288: #ifndef NFS_NOSERVER
1289: /*
1290: * Generate the rpc reply header
1291: * siz arg. is used to decide if adding a cluster is worthwhile
1292: */
1293: int
1294: nfs_rephead(siz, nd, slp, err, cache, frev, mrq, mbp, bposp)
1295: int siz;
1296: struct nfsrv_descript *nd;
1297: struct nfssvc_sock *slp;
1298: int err;
1299: int cache;
1300: u_quad_t *frev;
1301: struct mbuf **mrq;
1302: struct mbuf **mbp;
1303: caddr_t *bposp;
1304: {
1305: register u_long *tl;
1306: register struct mbuf *mreq;
1307: caddr_t bpos;
1308: struct mbuf *mb, *mb2;
1309:
1310: MGETHDR(mreq, M_WAIT, MT_DATA);
1311: mb = mreq;
1312: /*
1313: * If this is a big reply, use a cluster else
1314: * try and leave leading space for the lower level headers.
1315: */
1316: siz += RPC_REPLYSIZ;
1317: if (siz >= MINCLSIZE) {
1318: MCLGET(mreq, M_WAIT);
1319: } else
1320: mreq->m_data += max_hdr;
1321: tl = mtod(mreq, u_long *);
1322: mreq->m_len = 6 * NFSX_UNSIGNED;
1323: bpos = ((caddr_t)tl) + mreq->m_len;
1324: *tl++ = txdr_unsigned(nd->nd_retxid);
1325: *tl++ = rpc_reply;
1326: if (err == ERPCMISMATCH || (err & NFSERR_AUTHERR)) {
1327: *tl++ = rpc_msgdenied;
1328: if (err & NFSERR_AUTHERR) {
1329: *tl++ = rpc_autherr;
1330: *tl = txdr_unsigned(err & ~NFSERR_AUTHERR);
1331: mreq->m_len -= NFSX_UNSIGNED;
1332: bpos -= NFSX_UNSIGNED;
1333: } else {
1334: *tl++ = rpc_mismatch;
1335: *tl++ = txdr_unsigned(RPC_VER2);
1336: *tl = txdr_unsigned(RPC_VER2);
1337: }
1338: } else {
1339: *tl++ = rpc_msgaccepted;
1340:
1341: /*
1342: * For Kerberos authentication, we must send the nickname
1343: * verifier back, otherwise just RPCAUTH_NULL.
1344: */
1345: if (nd->nd_flag & ND_KERBFULL) {
1346: register struct nfsuid *nuidp;
1347: struct timeval ktvin, ktvout;
1348:
1349: for (nuidp = NUIDHASH(slp, nd->nd_cr.cr_uid)->lh_first;
1350: nuidp != 0; nuidp = nuidp->nu_hash.le_next) {
1351: if (nuidp->nu_cr.cr_uid == nd->nd_cr.cr_uid &&
1352: (!nd->nd_nam2 || netaddr_match(NU_NETFAM(nuidp),
1353: &nuidp->nu_haddr, nd->nd_nam2)))
1354: break;
1355: }
1356: if (nuidp) {
1357: ktvin.tv_sec =
1358: txdr_unsigned(nuidp->nu_timestamp.tv_sec - 1);
1359: ktvin.tv_usec =
1360: txdr_unsigned(nuidp->nu_timestamp.tv_usec);
1361:
1362: /*
1363: * Encrypt the timestamp in ecb mode using the
1364: * session key.
1365: */
1366: #if NFSKERB
1367: XXX
1368: #endif
1369:
1370: *tl++ = rpc_auth_kerb;
1371: *tl++ = txdr_unsigned(3 * NFSX_UNSIGNED);
1372: *tl = ktvout.tv_sec;
1373: nfsm_build(tl, u_long *, 3 * NFSX_UNSIGNED);
1374: *tl++ = ktvout.tv_usec;
1375: *tl++ = txdr_unsigned(nuidp->nu_cr.cr_uid);
1376: } else {
1377: *tl++ = 0;
1378: *tl++ = 0;
1379: }
1380: } else {
1381: *tl++ = 0;
1382: *tl++ = 0;
1383: }
1384: switch (err) {
1385: case EPROGUNAVAIL:
1386: *tl = txdr_unsigned(RPC_PROGUNAVAIL);
1387: break;
1388: case EPROGMISMATCH:
1389: *tl = txdr_unsigned(RPC_PROGMISMATCH);
1390: nfsm_build(tl, u_long *, 2 * NFSX_UNSIGNED);
1391: if (nd->nd_flag & ND_NQNFS) {
1392: *tl++ = txdr_unsigned(3);
1393: *tl = txdr_unsigned(3);
1394: } else {
1395: *tl++ = txdr_unsigned(2);
1396: *tl = txdr_unsigned(3);
1397: }
1398: break;
1399: case EPROCUNAVAIL:
1400: *tl = txdr_unsigned(RPC_PROCUNAVAIL);
1401: break;
1402: case EBADRPC:
1403: *tl = txdr_unsigned(RPC_GARBAGE);
1404: break;
1405: default:
1406: *tl = 0;
1407: if (err != NFSERR_RETVOID) {
1408: nfsm_build(tl, u_long *, NFSX_UNSIGNED);
1409: if (err)
1410: *tl = txdr_unsigned(nfsrv_errmap(nd, err));
1411: else
1412: *tl = 0;
1413: }
1414: break;
1415: };
1416: }
1417:
1418: /*
1419: * For nqnfs, piggyback lease as requested.
1420: */
1421: if ((nd->nd_flag & ND_NQNFS) && err == 0) {
1422: if (nd->nd_flag & ND_LEASE) {
1423: nfsm_build(tl, u_long *, 5 * NFSX_UNSIGNED);
1424: *tl++ = txdr_unsigned(nd->nd_flag & ND_LEASE);
1425: *tl++ = txdr_unsigned(cache);
1426: *tl++ = txdr_unsigned(nd->nd_duration);
1427: txdr_hyper(frev, tl);
1428: } else {
1429: nfsm_build(tl, u_long *, NFSX_UNSIGNED);
1430: *tl = 0;
1431: }
1432: }
1433: if (mrq != NULL)
1434: *mrq = mreq;
1435: *mbp = mb;
1436: *bposp = bpos;
1437: if (err != 0 && err != NFSERR_RETVOID)
1438: nfsstats.srvrpc_errs++;
1439: return (0);
1440: }
1441:
1442:
1443: #endif /* NFS_NOSERVER */
1444:
1445: /*
1446: * Nfs timer routine
1447: * Scan the nfsreq list and retranmit any requests that have timed out
1448: * To avoid retransmission attempts on STREAM sockets (in the future) make
1449: * sure to set the r_retry field to 0 (implies nm_retry == 0).
1450: */
1451: void
1452: nfs_timer(arg)
1453: void *arg; /* never used */
1454: {
1455: register struct nfsreq *rep;
1456: register struct mbuf *m;
1457: register struct socket *so;
1458: register struct nfsmount *nmp;
1459: register int timeo;
1460: int s, error;
1461: #ifndef NFS_NOSERVER
1462: static long lasttime = 0;
1463: register struct nfssvc_sock *slp;
1464: u_quad_t cur_usec;
1465: #endif /* NFS_NOSERVER */
1466: #if DIAGNOSTIC
1467: int rttdiag;
1468: #endif
1469:
1470: s = splnet();
1471: for (rep = nfs_reqq.tqh_first; rep != 0; rep = rep->r_chain.tqe_next) {
1472: nmp = rep->r_nmp;
1473: if (!nmp) /* unmounted */
1474: continue;
1475: if (rep->r_mrep || (rep->r_flags & R_SOFTTERM))
1476: continue;
1477: if (nfs_sigintr(nmp, rep, rep->r_procp)) {
1478: rep->r_flags |= R_SOFTTERM;
1479: continue;
1480: }
1481: if (rep->r_rtt >= 0) {
1482: rep->r_rtt++;
1483: if (nmp->nm_flag & NFSMNT_DUMBTIMR)
1484: timeo = nmp->nm_timeo;
1485: else
1486: timeo = NFS_RTO(nmp, proct[rep->r_procnum]);
1487: /* ensure 62.5 ms floor */
1488: while (16 * timeo < hz)
1489: timeo *= 2;
1490: if (nmp->nm_timeouts > 0)
1491: timeo *= nfs_backoff[nmp->nm_timeouts - 1];
1492: if (rep->r_rtt <= timeo)
1493: continue;
1494: if (nmp->nm_timeouts < 8)
1495: nmp->nm_timeouts++;
1496: }
1497: /*
1498: * Check for server not responding
1499: */
1500: if ((rep->r_flags & R_TPRINTFMSG) == 0 &&
1501: rep->r_rexmit > nmp->nm_deadthresh) {
1502: nfs_msg(rep->r_procp,
1503: nmp->nm_mountp->mnt_stat.f_mntfromname,
1504: "not responding");
1505: rep->r_flags |= R_TPRINTFMSG;
1506: }
1507: if (rep->r_rexmit >= rep->r_retry) { /* too many */
1508: nfsstats.rpctimeouts++;
1509: rep->r_flags |= R_SOFTTERM;
1510: continue;
1511: }
1512: if (nmp->nm_sotype != SOCK_DGRAM) {
1513: if (++rep->r_rexmit > NFS_MAXREXMIT)
1514: rep->r_rexmit = NFS_MAXREXMIT;
1515: continue;
1516: }
1517: if ((so = nmp->nm_so) == NULL)
1518: continue;
1519:
1520: /*
1521: * If there is enough space and the window allows..
1522: * Resend it
1523: * Set r_rtt to -1 in case we fail to send it now.
1524: */
1525: #if DIAGNOSTIC
1526: rttdiag = rep->r_rtt;
1527: #endif
1528: rep->r_rtt = -1;
1529: if (sbspace(&so->so_snd) >= rep->r_mreq->m_pkthdr.len &&
1530: ((nmp->nm_flag & NFSMNT_DUMBTIMR) ||
1531: (rep->r_flags & R_SENT) ||
1532: nmp->nm_sent < nmp->nm_cwnd) &&
1533: (m = m_copym(rep->r_mreq, 0, M_COPYALL, M_DONTWAIT))){
1534:
1535: struct proc *p = current_proc();
1536:
1537: #if DIAGNOSTIC
1538: if (rep->r_flags & R_SENT && nfsprnttimo &&
1539: nmp->nm_timeouts >= nfsprnttimo) {
1540: int t = proct[rep->r_procnum];
1541: if (t)
1542: NFS_DPF(DUP, ("nfs_timer %s nmtm=%d tms=%d rtt=%d tm=%d p=%d A=%d D=%d\n", nmp->nm_mountp->mnt_stat.f_mntfromname, nmp->nm_timeo, nmp->nm_timeouts, rttdiag, timeo, rep->r_procnum, nmp->nm_srtt[t-1], nmp->nm_sdrtt[t-1]));
1543: else
1544: NFS_DPF(DUP, ("nfs_timer %s nmtm=%d tms=%d rtt=%d tm=%d p=%d\n", nmp->nm_mountp->mnt_stat.f_mntfromname, nmp->nm_timeo, nmp->nm_timeouts, rttdiag, timeo, rep->r_procnum));
1545: }
1546: nfsdup(rep);
1547: #endif
1548: if ((nmp->nm_flag & NFSMNT_NOCONN) == 0)
1549: error = (*so->so_proto->pr_usrreqs->pru_send)
1550: (so, 0, m, 0, 0, p);
1551: else
1552: error = (*so->so_proto->pr_usrreqs->pru_send)
1553: (so, 0, m, mtod(nmp->nm_nam, struct sockaddr *), 0, p);
1554:
1555: if (error) {
1556: if (NFSIGNORE_SOERROR(nmp->nm_soflags, error))
1557: so->so_error = 0;
1558: } else {
1559: /*
1560: * Iff first send, start timing
1561: * else turn timing off, backoff timer
1562: * and divide congestion window by 2.
1563: */
1564: if (rep->r_flags & R_SENT) {
1565: rep->r_flags &= ~R_TIMING;
1566: if (++rep->r_rexmit > NFS_MAXREXMIT)
1567: rep->r_rexmit = NFS_MAXREXMIT;
1568: nmp->nm_cwnd >>= 1;
1569: if (nmp->nm_cwnd < NFS_CWNDSCALE)
1570: nmp->nm_cwnd = NFS_CWNDSCALE;
1571: nfsstats.rpcretries++;
1572: } else {
1573: rep->r_flags |= R_SENT;
1574: nmp->nm_sent += NFS_CWNDSCALE;
1575: }
1576: rep->r_rtt = 0;
1577: }
1578: }
1579: }
1580: #ifndef NFS_NOSERVER
1581: /*
1582: * Call the nqnfs server timer once a second to handle leases.
1583: */
1584: if (lasttime != time.tv_sec) {
1585: lasttime = time.tv_sec;
1586: nqnfs_serverd();
1587: }
1588:
1589: /*
1590: * Scan the write gathering queues for writes that need to be
1591: * completed now.
1592: */
1593: cur_usec = (u_quad_t)time.tv_sec * 1000000 + (u_quad_t)time.tv_usec;
1594: for (slp = nfssvc_sockhead.tqh_first; slp != 0;
1595: slp = slp->ns_chain.tqe_next) {
1596: if (slp->ns_tq.lh_first && slp->ns_tq.lh_first->nd_time<=cur_usec)
1597: nfsrv_wakenfsd(slp);
1598: }
1599: #endif /* NFS_NOSERVER */
1600: splx(s);
1601: timeout(nfs_timer, (void *)0, nfs_ticks);
1602: }
1603:
1604:
1605: /*
1606: * Test for a termination condition pending on the process.
1607: * This is used for NFSMNT_INT mounts.
1608: */
1609: int
1610: nfs_sigintr(nmp, rep, p)
1611: struct nfsmount *nmp;
1612: struct nfsreq *rep;
1613: register struct proc *p;
1614: {
1615:
1616: if (rep && (rep->r_flags & R_SOFTTERM))
1617: return (EINTR);
1618: if (!(nmp->nm_flag & NFSMNT_INT))
1619: return (0);
1620: if (p && p->p_siglist &&
1621: (((p->p_siglist & ~p->p_sigmask) & ~p->p_sigignore) &
1622: NFSINT_SIGMASK))
1623: return (EINTR);
1624: return (0);
1625: }
1626:
1627: /*
1628: * Lock a socket against others.
1629: * Necessary for STREAM sockets to ensure you get an entire rpc request/reply
1630: * and also to avoid race conditions between the processes with nfs requests
1631: * in progress when a reconnect is necessary.
1632: */
1633: int
1634: nfs_sndlock(flagp, rep)
1635: register int *flagp;
1636: struct nfsreq *rep;
1637: {
1638: struct proc *p;
1639: int slpflag = 0, slptimeo = 0;
1640:
1641: if (rep) {
1642: p = rep->r_procp;
1643: if (rep->r_nmp->nm_flag & NFSMNT_INT)
1644: slpflag = PCATCH;
1645: } else
1646: p = (struct proc *)0;
1647: while (*flagp & NFSMNT_SNDLOCK) {
1648: if (nfs_sigintr(rep->r_nmp, rep, p))
1649: return (EINTR);
1650: *flagp |= NFSMNT_WANTSND;
1651: (void) tsleep((caddr_t)flagp, slpflag | (PZERO - 1), "nfsndlck",
1652: slptimeo);
1653: if (slpflag == PCATCH) {
1654: slpflag = 0;
1655: slptimeo = 2 * hz;
1656: }
1657: }
1658: *flagp |= NFSMNT_SNDLOCK;
1659: return (0);
1660: }
1661:
1662: /*
1663: * Unlock the stream socket for others.
1664: */
1665: void
1666: nfs_sndunlock(flagp)
1667: register int *flagp;
1668: {
1669:
1670: if ((*flagp & NFSMNT_SNDLOCK) == 0)
1671: panic("nfs sndunlock");
1672: *flagp &= ~NFSMNT_SNDLOCK;
1673: if (*flagp & NFSMNT_WANTSND) {
1674: *flagp &= ~NFSMNT_WANTSND;
1675: wakeup((caddr_t)flagp);
1676: }
1677: }
1678:
1679: static int
1680: nfs_rcvlock(rep)
1681: register struct nfsreq *rep;
1682: {
1683: register int *flagp = &rep->r_nmp->nm_flag;
1684: int slpflag, slptimeo = 0;
1685:
1686: if (*flagp & NFSMNT_INT)
1687: slpflag = PCATCH;
1688: else
1689: slpflag = 0;
1690: while (*flagp & NFSMNT_RCVLOCK) {
1691: NFSTRACE(NFSTRC_RCVLCKW, flagp);
1692: if (nfs_sigintr(rep->r_nmp, rep, rep->r_procp))
1693: return (EINTR);
1694: *flagp |= NFSMNT_WANTRCV;
1695: (void) tsleep((caddr_t)flagp, slpflag | (PZERO - 1), "nfsrcvlk",
1696: slptimeo);
1697: /*
1698: * If our reply was recieved while we were sleeping,
1699: * then just return without taking the lock to avoid a
1700: * situation where a single iod could 'capture' the
1701: * recieve lock.
1702: */
1703: if (rep->r_mrep != NULL)
1704: return (EALREADY);
1705: if (slpflag == PCATCH) {
1706: slpflag = 0;
1707: slptimeo = 2 * hz;
1708: }
1709: }
1710: NFSTRACE(NFSTRC_RCVLCK, flagp);
1711: *flagp |= NFSMNT_RCVLOCK;
1712: return (0);
1713: }
1714:
1715: /*
1716: * Unlock the stream socket for others.
1717: */
1718: static void
1719: nfs_rcvunlock(flagp)
1720: register int *flagp;
1721: {
1722:
1723: if ((*flagp & NFSMNT_RCVLOCK) == 0)
1724: panic("nfs rcvunlock");
1725: *flagp &= ~NFSMNT_RCVLOCK;
1726: if (*flagp & NFSMNT_WANTRCV) {
1727: NFSTRACE(NFSTRC_RCVUNLW, flagp);
1728: *flagp &= ~NFSMNT_WANTRCV;
1729: wakeup((caddr_t)flagp);
1730: } else {
1731: NFSTRACE(NFSTRC_RCVUNL, flagp);
1732: }
1733: }
1734:
1735:
1736: #ifndef NFS_NOSERVER
1737: /*
1738: * Socket upcall routine for the nfsd sockets.
1739: * The caddr_t arg is a pointer to the "struct nfssvc_sock".
1740: * Essentially do as much as possible non-blocking, else punt and it will
1741: * be called with M_WAIT from an nfsd.
1742: */
1743: void
1744: nfsrv_rcv(so, arg, waitflag)
1745: struct socket *so;
1746: caddr_t arg;
1747: int waitflag;
1748: {
1749: register struct nfssvc_sock *slp = (struct nfssvc_sock *)arg;
1750: register struct mbuf *m;
1751: struct mbuf *mp, *mhck;
1752: struct sockaddr *nam=0;
1753: struct uio auio;
1754: int flags, error;
1755: struct sockaddr_in *sin;
1756:
1757: if ((slp->ns_flag & SLP_VALID) == 0)
1758: return;
1759: #ifdef notdef
1760: /*
1761: * Define this to test for nfsds handling this under heavy load.
1762: */
1763: if (waitflag == M_DONTWAIT) {
1764: slp->ns_flag |= SLP_NEEDQ; goto dorecs;
1765: }
1766: #endif
1767: auio.uio_procp = NULL;
1768: if (so->so_type == SOCK_STREAM) {
1769: /*
1770: * If there are already records on the queue, defer soreceive()
1771: * to an nfsd so that there is feedback to the TCP layer that
1772: * the nfs servers are heavily loaded.
1773: */
1774: if (slp->ns_rec && waitflag == M_DONTWAIT) {
1775: slp->ns_flag |= SLP_NEEDQ;
1776: goto dorecs;
1777: }
1778:
1779: /*
1780: * Do soreceive().
1781: */
1782: auio.uio_resid = 1000000000;
1783: flags = MSG_DONTWAIT;
1784: error = soreceive(so, (struct sockaddr **) 0, &auio, &mp, (struct mbuf **)0, &flags);
1785: if (error || mp == (struct mbuf *)0) {
1786: if (error == EWOULDBLOCK)
1787: slp->ns_flag |= SLP_NEEDQ;
1788: else
1789: slp->ns_flag |= SLP_DISCONN;
1790: goto dorecs;
1791: }
1792: m = mp;
1793: if (slp->ns_rawend) {
1794: slp->ns_rawend->m_next = m;
1795: slp->ns_cc += 1000000000 - auio.uio_resid;
1796: } else {
1797: slp->ns_raw = m;
1798: slp->ns_cc = 1000000000 - auio.uio_resid;
1799: }
1800: while (m->m_next)
1801: m = m->m_next;
1802: slp->ns_rawend = m;
1803:
1804: /*
1805: * Now try and parse record(s) out of the raw stream data.
1806: */
1807: error = nfsrv_getstream(slp, waitflag);
1808: if (error) {
1809: if (error == EPERM)
1810: slp->ns_flag |= SLP_DISCONN;
1811: else
1812: slp->ns_flag |= SLP_NEEDQ;
1813: }
1814: } else {
1815: do {
1816: auio.uio_resid = 1000000000;
1817: flags = MSG_DONTWAIT;
1818: nam = 0;
1819: error = soreceive(so, &nam, &auio, &mp,
1820: (struct mbuf **)0, &flags);
1821: if (mp) {
1822: if (nam) {
1823: MGET(mhck, M_WAIT, MT_SONAME);
1824: mhck->m_len = nam->sa_len;
1825: sin = mtod(mhck, struct sockaddr_in *);
1826: bcopy(nam, sin, sizeof(struct sockaddr_in));
1827: mhck->m_hdr.mh_len = sizeof(struct sockaddr_in);
1828: FREE(nam, M_SONAME);
1829:
1830: m = mhck;
1831: m->m_next = mp;
1832: } else
1833: m = mp;
1834: if (slp->ns_recend)
1835: slp->ns_recend->m_nextpkt = m;
1836: else
1837: slp->ns_rec = m;
1838: slp->ns_recend = m;
1839: m->m_nextpkt = (struct mbuf *)0;
1840: }
1841: if (error) {
1842: if ((so->so_proto->pr_flags & PR_CONNREQUIRED)
1843: && error != EWOULDBLOCK) {
1844: slp->ns_flag |= SLP_DISCONN;
1845: goto dorecs;
1846: }
1847: }
1848: } while (mp);
1849: }
1850:
1851: /*
1852: * Now try and process the request records, non-blocking.
1853: */
1854: dorecs:
1855: if (waitflag == M_DONTWAIT &&
1856: (slp->ns_rec || (slp->ns_flag & (SLP_NEEDQ | SLP_DISCONN))))
1857: nfsrv_wakenfsd(slp);
1858: }
1859:
1860: /*
1861: * Try and extract an RPC request from the mbuf data list received on a
1862: * stream socket. The "waitflag" argument indicates whether or not it
1863: * can sleep.
1864: */
1865: static int
1866: nfsrv_getstream(slp, waitflag)
1867: register struct nfssvc_sock *slp;
1868: int waitflag;
1869: {
1870: register struct mbuf *m, **mpp;
1871: register char *cp1, *cp2;
1872: register int len;
1873: struct mbuf *om, *m2, *recm = 0;
1874: u_long recmark;
1875:
1876: if (slp->ns_flag & SLP_GETSTREAM)
1877: panic("nfs getstream");
1878: slp->ns_flag |= SLP_GETSTREAM;
1879: for (;;) {
1880: if (slp->ns_reclen == 0) {
1881: if (slp->ns_cc < NFSX_UNSIGNED) {
1882: slp->ns_flag &= ~SLP_GETSTREAM;
1883: return (0);
1884: }
1885: m = slp->ns_raw;
1886: if (m->m_len >= NFSX_UNSIGNED) {
1887: bcopy(mtod(m, caddr_t), (caddr_t)&recmark, NFSX_UNSIGNED);
1888: m->m_data += NFSX_UNSIGNED;
1889: m->m_len -= NFSX_UNSIGNED;
1890: } else {
1891: cp1 = (caddr_t)&recmark;
1892: cp2 = mtod(m, caddr_t);
1893: while (cp1 < ((caddr_t)&recmark) + NFSX_UNSIGNED) {
1894: while (m->m_len == 0) {
1895: m = m->m_next;
1896: cp2 = mtod(m, caddr_t);
1897: }
1898: *cp1++ = *cp2++;
1899: m->m_data++;
1900: m->m_len--;
1901: }
1902: }
1903: slp->ns_cc -= NFSX_UNSIGNED;
1904: recmark = ntohl(recmark);
1905: slp->ns_reclen = recmark & ~0x80000000;
1906: if (recmark & 0x80000000)
1907: slp->ns_flag |= SLP_LASTFRAG;
1908: else
1909: slp->ns_flag &= ~SLP_LASTFRAG;
1910: if (slp->ns_reclen < NFS_MINPACKET || slp->ns_reclen > NFS_MAXPACKET) {
1911: slp->ns_flag &= ~SLP_GETSTREAM;
1912: return (EPERM);
1913: }
1914: }
1915:
1916: /*
1917: * Now get the record part.
1918: */
1919: if (slp->ns_cc == slp->ns_reclen) {
1920: recm = slp->ns_raw;
1921: slp->ns_raw = slp->ns_rawend = (struct mbuf *)0;
1922: slp->ns_cc = slp->ns_reclen = 0;
1923: } else if (slp->ns_cc > slp->ns_reclen) {
1924: len = 0;
1925: m = slp->ns_raw;
1926: om = (struct mbuf *)0;
1927: while (len < slp->ns_reclen) {
1928: if ((len + m->m_len) > slp->ns_reclen) {
1929: m2 = m_copym(m, 0, slp->ns_reclen - len,
1930: waitflag);
1931: if (m2) {
1932: if (om) {
1933: om->m_next = m2;
1934: recm = slp->ns_raw;
1935: } else
1936: recm = m2;
1937: m->m_data += slp->ns_reclen - len;
1938: m->m_len -= slp->ns_reclen - len;
1939: len = slp->ns_reclen;
1940: } else {
1941: slp->ns_flag &= ~SLP_GETSTREAM;
1942: return (EWOULDBLOCK);
1943: }
1944: } else if ((len + m->m_len) == slp->ns_reclen) {
1945: om = m;
1946: len += m->m_len;
1947: m = m->m_next;
1948: recm = slp->ns_raw;
1949: om->m_next = (struct mbuf *)0;
1950: } else {
1951: om = m;
1952: len += m->m_len;
1953: m = m->m_next;
1954: }
1955: }
1956: slp->ns_raw = m;
1957: slp->ns_cc -= len;
1958: slp->ns_reclen = 0;
1959: } else {
1960: slp->ns_flag &= ~SLP_GETSTREAM;
1961: return (0);
1962: }
1963:
1964: /*
1965: * Accumulate the fragments into a record.
1966: */
1967: mpp = &slp->ns_frag;
1968: while (*mpp)
1969: mpp = &((*mpp)->m_next);
1970: *mpp = recm;
1971: if (slp->ns_flag & SLP_LASTFRAG) {
1972: if (slp->ns_recend)
1973: slp->ns_recend->m_nextpkt = slp->ns_frag;
1974: else
1975: slp->ns_rec = slp->ns_frag;
1976: slp->ns_recend = slp->ns_frag;
1977: slp->ns_frag = (struct mbuf *)0;
1978: }
1979: }
1980: }
1981:
1982: /*
1983: * Parse an RPC header.
1984: */
1985: int
1986: nfsrv_dorec(slp, nfsd, ndp)
1987: register struct nfssvc_sock *slp;
1988: struct nfsd *nfsd;
1989: struct nfsrv_descript **ndp;
1990: {
1991: register struct mbuf *m;
1992: register struct mbuf *nam;
1993: register struct nfsrv_descript *nd;
1994: int error;
1995:
1996: *ndp = NULL;
1997: if ((slp->ns_flag & SLP_VALID) == 0 ||
1998: (m = slp->ns_rec) == (struct mbuf *)0)
1999: return (ENOBUFS);
2000: slp->ns_rec = m->m_nextpkt;
2001: if (slp->ns_rec)
2002: m->m_nextpkt = (struct mbuf *)0;
2003: else
2004: slp->ns_recend = (struct mbuf *)0;
2005: if (m->m_type == MT_SONAME) {
2006: nam = m;
2007: m = m->m_next;
2008: nam->m_next = NULL;
2009: } else
2010: nam = NULL;
2011: MALLOC_ZONE(nd, struct nfsrv_descript *,
2012: sizeof (struct nfsrv_descript), M_NFSRVDESC, M_WAITOK);
2013: nd->nd_md = nd->nd_mrep = m;
2014: nd->nd_nam2 = nam;
2015: nd->nd_dpos = mtod(m, caddr_t);
2016: error = nfs_getreq(nd, nfsd, TRUE);
2017: if (error) {
2018: m_freem(nam);
2019: _FREE_ZONE((caddr_t)nd, sizeof *nd, M_NFSRVDESC);
2020: return (error);
2021: }
2022: *ndp = nd;
2023: nfsd->nfsd_nd = nd;
2024: return (0);
2025: }
2026:
2027: /*
2028: * Parse an RPC request
2029: * - verify it
2030: * - fill in the cred struct.
2031: */
2032: int
2033: nfs_getreq(nd, nfsd, has_header)
2034: register struct nfsrv_descript *nd;
2035: struct nfsd *nfsd;
2036: int has_header;
2037: {
2038: register int len, i;
2039: register u_long *tl;
2040: register long t1;
2041: struct uio uio;
2042: struct iovec iov;
2043: caddr_t dpos, cp2, cp;
2044: u_long nfsvers, auth_type;
2045: uid_t nickuid;
2046: int error = 0, nqnfs = 0, ticklen;
2047: struct mbuf *mrep, *md;
2048: register struct nfsuid *nuidp;
2049: struct timeval tvin, tvout;
2050: #if 0 /* until encrypted keys are implemented */
2051: NFSKERBKEYSCHED_T keys; /* stores key schedule */
2052: #endif
2053:
2054: mrep = nd->nd_mrep;
2055: md = nd->nd_md;
2056: dpos = nd->nd_dpos;
2057: if (has_header) {
2058: nfsm_dissect(tl, u_long *, 10 * NFSX_UNSIGNED);
2059: nd->nd_retxid = fxdr_unsigned(u_long, *tl++);
2060: if (*tl++ != rpc_call) {
2061: m_freem(mrep);
2062: return (EBADRPC);
2063: }
2064: } else
2065: nfsm_dissect(tl, u_long *, 8 * NFSX_UNSIGNED);
2066: nd->nd_repstat = 0;
2067: nd->nd_flag = 0;
2068: if (*tl++ != rpc_vers) {
2069: nd->nd_repstat = ERPCMISMATCH;
2070: nd->nd_procnum = NFSPROC_NOOP;
2071: return (0);
2072: }
2073: if (*tl != nfs_prog) {
2074: if (*tl == nqnfs_prog)
2075: nqnfs++;
2076: else {
2077: nd->nd_repstat = EPROGUNAVAIL;
2078: nd->nd_procnum = NFSPROC_NOOP;
2079: return (0);
2080: }
2081: }
2082: tl++;
2083: nfsvers = fxdr_unsigned(u_long, *tl++);
2084: if (((nfsvers < NFS_VER2 || nfsvers > NFS_VER3) && !nqnfs) ||
2085: (nfsvers != NQNFS_VER3 && nqnfs)) {
2086: nd->nd_repstat = EPROGMISMATCH;
2087: nd->nd_procnum = NFSPROC_NOOP;
2088: return (0);
2089: }
2090: if (nqnfs)
2091: nd->nd_flag = (ND_NFSV3 | ND_NQNFS);
2092: else if (nfsvers == NFS_VER3)
2093: nd->nd_flag = ND_NFSV3;
2094: nd->nd_procnum = fxdr_unsigned(u_long, *tl++);
2095: if (nd->nd_procnum == NFSPROC_NULL)
2096: return (0);
2097: if (nd->nd_procnum >= NFS_NPROCS ||
2098: (!nqnfs && nd->nd_procnum >= NQNFSPROC_GETLEASE) ||
2099: (!nd->nd_flag && nd->nd_procnum > NFSV2PROC_STATFS)) {
2100: nd->nd_repstat = EPROCUNAVAIL;
2101: nd->nd_procnum = NFSPROC_NOOP;
2102: return (0);
2103: }
2104: if ((nd->nd_flag & ND_NFSV3) == 0)
2105: nd->nd_procnum = nfsv3_procid[nd->nd_procnum];
2106: auth_type = *tl++;
2107: len = fxdr_unsigned(int, *tl++);
2108: if (len < 0 || len > RPCAUTH_MAXSIZ) {
2109: m_freem(mrep);
2110: return (EBADRPC);
2111: }
2112:
2113: nd->nd_flag &= ~ND_KERBAUTH;
2114: /*
2115: * Handle auth_unix or auth_kerb.
2116: */
2117: if (auth_type == rpc_auth_unix) {
2118: len = fxdr_unsigned(int, *++tl);
2119: if (len < 0 || len > NFS_MAXNAMLEN) {
2120: m_freem(mrep);
2121: return (EBADRPC);
2122: }
2123: nfsm_adv(nfsm_rndup(len));
2124: nfsm_dissect(tl, u_long *, 3 * NFSX_UNSIGNED);
2125: bzero((caddr_t)&nd->nd_cr, sizeof (struct ucred));
2126: nd->nd_cr.cr_ref = 1;
2127: nd->nd_cr.cr_uid = fxdr_unsigned(uid_t, *tl++);
2128: nd->nd_cr.cr_gid = fxdr_unsigned(gid_t, *tl++);
2129: len = fxdr_unsigned(int, *tl);
2130: if (len < 0 || len > RPCAUTH_UNIXGIDS) {
2131: m_freem(mrep);
2132: return (EBADRPC);
2133: }
2134: nfsm_dissect(tl, u_long *, (len + 2) * NFSX_UNSIGNED);
2135: for (i = 1; i <= len; i++)
2136: if (i < NGROUPS)
2137: nd->nd_cr.cr_groups[i] = fxdr_unsigned(gid_t, *tl++);
2138: else
2139: tl++;
2140: nd->nd_cr.cr_ngroups = (len >= NGROUPS) ? NGROUPS : (len + 1);
2141: if (nd->nd_cr.cr_ngroups > 1)
2142: nfsrvw_sort(nd->nd_cr.cr_groups, nd->nd_cr.cr_ngroups);
2143: len = fxdr_unsigned(int, *++tl);
2144: if (len < 0 || len > RPCAUTH_MAXSIZ) {
2145: m_freem(mrep);
2146: return (EBADRPC);
2147: }
2148: if (len > 0)
2149: nfsm_adv(nfsm_rndup(len));
2150: } else if (auth_type == rpc_auth_kerb) {
2151: switch (fxdr_unsigned(int, *tl++)) {
2152: case RPCAKN_FULLNAME:
2153: ticklen = fxdr_unsigned(int, *tl);
2154: *((u_long *)nfsd->nfsd_authstr) = *tl;
2155: uio.uio_resid = nfsm_rndup(ticklen) + NFSX_UNSIGNED;
2156: nfsd->nfsd_authlen = uio.uio_resid + NFSX_UNSIGNED;
2157: if (uio.uio_resid > (len - 2 * NFSX_UNSIGNED)) {
2158: m_freem(mrep);
2159: return (EBADRPC);
2160: }
2161: uio.uio_offset = 0;
2162: uio.uio_iov = &iov;
2163: uio.uio_iovcnt = 1;
2164: uio.uio_segflg = UIO_SYSSPACE;
2165: iov.iov_base = (caddr_t)&nfsd->nfsd_authstr[4];
2166: iov.iov_len = RPCAUTH_MAXSIZ - 4;
2167: nfsm_mtouio(&uio, uio.uio_resid);
2168: nfsm_dissect(tl, u_long *, 2 * NFSX_UNSIGNED);
2169: if (*tl++ != rpc_auth_kerb ||
2170: fxdr_unsigned(int, *tl) != 4 * NFSX_UNSIGNED) {
2171: printf("Bad kerb verifier\n");
2172: nd->nd_repstat = (NFSERR_AUTHERR|AUTH_BADVERF);
2173: nd->nd_procnum = NFSPROC_NOOP;
2174: return (0);
2175: }
2176: nfsm_dissect(cp, caddr_t, 4 * NFSX_UNSIGNED);
2177: tl = (u_long *)cp;
2178: if (fxdr_unsigned(int, *tl) != RPCAKN_FULLNAME) {
2179: printf("Not fullname kerb verifier\n");
2180: nd->nd_repstat = (NFSERR_AUTHERR|AUTH_BADVERF);
2181: nd->nd_procnum = NFSPROC_NOOP;
2182: return (0);
2183: }
2184: cp += NFSX_UNSIGNED;
2185: bcopy(cp, nfsd->nfsd_verfstr, 3 * NFSX_UNSIGNED);
2186: nfsd->nfsd_verflen = 3 * NFSX_UNSIGNED;
2187: nd->nd_flag |= ND_KERBFULL;
2188: nfsd->nfsd_flag |= NFSD_NEEDAUTH;
2189: break;
2190: case RPCAKN_NICKNAME:
2191: if (len != 2 * NFSX_UNSIGNED) {
2192: printf("Kerb nickname short\n");
2193: nd->nd_repstat = (NFSERR_AUTHERR|AUTH_BADCRED);
2194: nd->nd_procnum = NFSPROC_NOOP;
2195: return (0);
2196: }
2197: nickuid = fxdr_unsigned(uid_t, *tl);
2198: nfsm_dissect(tl, u_long *, 2 * NFSX_UNSIGNED);
2199: if (*tl++ != rpc_auth_kerb ||
2200: fxdr_unsigned(int, *tl) != 3 * NFSX_UNSIGNED) {
2201: printf("Kerb nick verifier bad\n");
2202: nd->nd_repstat = (NFSERR_AUTHERR|AUTH_BADVERF);
2203: nd->nd_procnum = NFSPROC_NOOP;
2204: return (0);
2205: }
2206: nfsm_dissect(tl, u_long *, 3 * NFSX_UNSIGNED);
2207: tvin.tv_sec = *tl++;
2208: tvin.tv_usec = *tl;
2209:
2210: for (nuidp = NUIDHASH(nfsd->nfsd_slp,nickuid)->lh_first;
2211: nuidp != 0; nuidp = nuidp->nu_hash.le_next) {
2212: if (nuidp->nu_cr.cr_uid == nickuid &&
2213: (!nd->nd_nam2 ||
2214: netaddr_match(NU_NETFAM(nuidp),
2215: &nuidp->nu_haddr, nd->nd_nam2)))
2216: break;
2217: }
2218: if (!nuidp) {
2219: nd->nd_repstat =
2220: (NFSERR_AUTHERR|AUTH_REJECTCRED);
2221: nd->nd_procnum = NFSPROC_NOOP;
2222: return (0);
2223: }
2224:
2225: /*
2226: * Now, decrypt the timestamp using the session key
2227: * and validate it.
2228: */
2229: #if NFSKERB
2230: XXX
2231: #endif
2232:
2233: tvout.tv_sec = fxdr_unsigned(long, tvout.tv_sec);
2234: tvout.tv_usec = fxdr_unsigned(long, tvout.tv_usec);
2235: if (nuidp->nu_expire < time.tv_sec ||
2236: nuidp->nu_timestamp.tv_sec > tvout.tv_sec ||
2237: (nuidp->nu_timestamp.tv_sec == tvout.tv_sec &&
2238: nuidp->nu_timestamp.tv_usec > tvout.tv_usec)) {
2239: nuidp->nu_expire = 0;
2240: nd->nd_repstat =
2241: (NFSERR_AUTHERR|AUTH_REJECTVERF);
2242: nd->nd_procnum = NFSPROC_NOOP;
2243: return (0);
2244: }
2245: nfsrv_setcred(&nuidp->nu_cr, &nd->nd_cr);
2246: nd->nd_flag |= ND_KERBNICK;
2247: };
2248: } else {
2249: nd->nd_repstat = (NFSERR_AUTHERR | AUTH_REJECTCRED);
2250: nd->nd_procnum = NFSPROC_NOOP;
2251: return (0);
2252: }
2253:
2254: /*
2255: * For nqnfs, get piggybacked lease request.
2256: */
2257: if (nqnfs && nd->nd_procnum != NQNFSPROC_EVICTED) {
2258: nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
2259: nd->nd_flag |= fxdr_unsigned(int, *tl);
2260: if (nd->nd_flag & ND_LEASE) {
2261: nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
2262: nd->nd_duration = fxdr_unsigned(int, *tl);
2263: } else
2264: nd->nd_duration = NQ_MINLEASE;
2265: } else
2266: nd->nd_duration = NQ_MINLEASE;
2267: nd->nd_md = md;
2268: nd->nd_dpos = dpos;
2269: return (0);
2270: nfsmout:
2271: return (error);
2272: }
2273:
2274: /*
2275: * Search for a sleeping nfsd and wake it up.
2276: * SIDE EFFECT: If none found, set NFSD_CHECKSLP flag, so that one of the
2277: * running nfsds will go look for the work in the nfssvc_sock list.
2278: */
2279: void
2280: nfsrv_wakenfsd(slp)
2281: struct nfssvc_sock *slp;
2282: {
2283: register struct nfsd *nd;
2284:
2285: if ((slp->ns_flag & SLP_VALID) == 0)
2286: return;
2287: for (nd = nfsd_head.tqh_first; nd != 0; nd = nd->nfsd_chain.tqe_next) {
2288: if (nd->nfsd_flag & NFSD_WAITING) {
2289: nd->nfsd_flag &= ~NFSD_WAITING;
2290: if (nd->nfsd_slp)
2291: panic("nfsd wakeup");
2292: slp->ns_sref++;
2293: nd->nfsd_slp = slp;
2294: wakeup((caddr_t)nd);
2295: return;
2296: }
2297: }
2298: slp->ns_flag |= SLP_DOREC;
2299: nfsd_head_flag |= NFSD_CHECKSLP;
2300: }
2301: #endif /* NFS_NOSERVER */
2302:
2303: static int
2304: nfs_msg(p, server, msg)
2305: struct proc *p;
2306: char *server, *msg;
2307: {
2308: tpr_t tpr;
2309:
2310: if (p)
2311: tpr = tprintf_open(p);
2312: else
2313: tpr = NULL;
2314: tprintf(tpr, "nfs server %s: %s\n", server, msg);
2315: tprintf_close(tpr);
2316: return (0);
2317: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.