![[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 [Net/2] / Net2 / nfs|
Return to nfs_socket.c CVS log | Up to [Net/2] / Net2 / nfs |
1.1 root 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: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following conditions
10: * are met:
11: * 1. Redistributions of source code must retain the above copyright
12: * notice, this list of conditions and the following disclaimer.
13: * 2. Redistributions in binary form must reproduce the above copyright
14: * notice, this list of conditions and the following disclaimer in the
15: * documentation and/or other materials provided with the distribution.
16: * 3. All advertising materials mentioning features or use of this software
17: * must display the following acknowledgement:
18: * This product includes software developed by the University of
19: * California, Berkeley and its contributors.
20: * 4. Neither the name of the University nor the names of its contributors
21: * may be used to endorse or promote products derived from this software
22: * without specific prior written permission.
23: *
24: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34: * SUCH DAMAGE.
35: *
36: * @(#)nfs_socket.c 7.23 (Berkeley) 4/20/91
37: */
38:
39: /*
40: * Socket operations for use by nfs
41: */
42:
43: #include "param.h"
44: #include "proc.h"
45: #include "mount.h"
46: #include "kernel.h"
47: #include "malloc.h"
48: #include "mbuf.h"
49: #include "namei.h"
50: #include "vnode.h"
51: #include "domain.h"
52: #include "protosw.h"
53: #include "socket.h"
54: #include "socketvar.h"
55: #include "syslog.h"
56: #include "tprintf.h"
57: #include "../netinet/in.h"
58: #include "../netinet/tcp.h"
59:
60: #include "rpcv2.h"
61: #include "nfsv2.h"
62: #include "nfs.h"
63: #include "xdr_subs.h"
64: #include "nfsm_subs.h"
65: #include "nfsmount.h"
66:
67: #define TRUE 1
68: #define FALSE 0
69:
70: /*
71: * External data, mostly RPC constants in XDR form
72: */
73: extern u_long rpc_reply, rpc_msgdenied, rpc_mismatch, rpc_vers, rpc_auth_unix,
74: rpc_msgaccepted, rpc_call;
75: extern u_long nfs_prog, nfs_vers;
76: /* Maybe these should be bits in a u_long ?? */
77: extern int nonidempotent[NFS_NPROCS];
78: static int compressrequest[NFS_NPROCS] = {
79: FALSE,
80: TRUE,
81: TRUE,
82: FALSE,
83: TRUE,
84: TRUE,
85: TRUE,
86: FALSE,
87: FALSE,
88: TRUE,
89: TRUE,
90: TRUE,
91: TRUE,
92: TRUE,
93: TRUE,
94: TRUE,
95: TRUE,
96: TRUE,
97: };
98: int nfs_sbwait();
99: void nfs_disconnect();
100: struct mbuf *nfs_compress(), *nfs_uncompress();
101:
102: int nfsrv_null(),
103: nfsrv_getattr(),
104: nfsrv_setattr(),
105: nfsrv_lookup(),
106: nfsrv_readlink(),
107: nfsrv_read(),
108: nfsrv_write(),
109: nfsrv_create(),
110: nfsrv_remove(),
111: nfsrv_rename(),
112: nfsrv_link(),
113: nfsrv_symlink(),
114: nfsrv_mkdir(),
115: nfsrv_rmdir(),
116: nfsrv_readdir(),
117: nfsrv_statfs(),
118: nfsrv_noop();
119:
120: int (*nfsrv_procs[NFS_NPROCS])() = {
121: nfsrv_null,
122: nfsrv_getattr,
123: nfsrv_setattr,
124: nfsrv_noop,
125: nfsrv_lookup,
126: nfsrv_readlink,
127: nfsrv_read,
128: nfsrv_noop,
129: nfsrv_write,
130: nfsrv_create,
131: nfsrv_remove,
132: nfsrv_rename,
133: nfsrv_link,
134: nfsrv_symlink,
135: nfsrv_mkdir,
136: nfsrv_rmdir,
137: nfsrv_readdir,
138: nfsrv_statfs,
139: };
140:
141: struct nfsreq nfsreqh;
142: int nfsrexmtthresh = NFS_FISHY;
143: int nfs_tcpnodelay = 1;
144:
145: /*
146: * Initialize sockets and congestion for a new NFS connection.
147: * We do not free the sockaddr if error.
148: */
149: nfs_connect(nmp)
150: register struct nfsmount *nmp;
151: {
152: register struct socket *so;
153: int s, error, bufsize;
154: struct mbuf *m;
155:
156: nmp->nm_so = (struct socket *)0;
157: if (error = socreate(mtod(nmp->nm_nam, struct sockaddr *)->sa_family,
158: &nmp->nm_so, nmp->nm_sotype, nmp->nm_soproto))
159: goto bad;
160: so = nmp->nm_so;
161: nmp->nm_soflags = so->so_proto->pr_flags;
162:
163: if (nmp->nm_sotype == SOCK_DGRAM)
164: bufsize = min(4 * (nmp->nm_wsize + NFS_MAXPKTHDR),
165: NFS_MAXPACKET);
166: else
167: bufsize = min(4 * (nmp->nm_wsize + NFS_MAXPKTHDR + sizeof(u_long)),
168: NFS_MAXPACKET + sizeof(u_long));
169: if (error = soreserve(so, bufsize, bufsize))
170: goto bad;
171:
172: /*
173: * Protocols that do not require connections may be optionally left
174: * unconnected for servers that reply from a port other than NFS_PORT.
175: */
176: if (nmp->nm_flag & NFSMNT_NOCONN) {
177: if (nmp->nm_soflags & PR_CONNREQUIRED) {
178: error = ENOTCONN;
179: goto bad;
180: }
181: } else {
182: if (error = soconnect(so, nmp->nm_nam))
183: goto bad;
184:
185: /*
186: * Wait for the connection to complete. Cribbed from the
187: * connect system call but with the wait at negative prio.
188: */
189: s = splnet();
190: while ((so->so_state & SS_ISCONNECTING) && so->so_error == 0)
191: (void) tsleep((caddr_t)&so->so_timeo, PSOCK, "nfscon", 0);
192: splx(s);
193: if (so->so_error) {
194: error = so->so_error;
195: goto bad;
196: }
197: }
198: if (nmp->nm_sotype == SOCK_DGRAM) {
199: if (nmp->nm_flag & (NFSMNT_SOFT | NFSMNT_SPONGY | NFSMNT_INT)) {
200: so->so_rcv.sb_timeo = (5 * hz);
201: so->so_snd.sb_timeo = (5 * hz);
202: } else {
203: so->so_rcv.sb_timeo = 0;
204: so->so_snd.sb_timeo = 0;
205: }
206: nmp->nm_rto = NFS_TIMEO;
207: } else {
208: if (nmp->nm_flag & (NFSMNT_SOFT | NFSMNT_SPONGY | NFSMNT_INT)) {
209: so->so_rcv.sb_timeo = (5 * hz);
210: so->so_snd.sb_timeo = (5 * hz);
211: } else {
212: so->so_rcv.sb_timeo = 0;
213: so->so_snd.sb_timeo = 0;
214: }
215: if (so->so_proto->pr_flags & PR_CONNREQUIRED) {
216: MGET(m, M_WAIT, MT_SOOPTS);
217: *mtod(m, int *) = 1;
218: m->m_len = sizeof(int);
219: sosetopt(so, SOL_SOCKET, SO_KEEPALIVE, m);
220: }
221: if (so->so_proto->pr_domain->dom_family == AF_INET &&
222: so->so_proto->pr_protocol == IPPROTO_TCP &&
223: nfs_tcpnodelay) {
224: MGET(m, M_WAIT, MT_SOOPTS);
225: *mtod(m, int *) = 1;
226: m->m_len = sizeof(int);
227: sosetopt(so, IPPROTO_TCP, TCP_NODELAY, m);
228: }
229: nmp->nm_rto = 10 * NFS_TIMEO; /* XXX */
230: }
231: so->so_rcv.sb_flags |= SB_NOINTR;
232: so->so_snd.sb_flags |= SB_NOINTR;
233:
234: /* Initialize other non-zero congestion variables */
235: nmp->nm_window = 2; /* Initial send window */
236: nmp->nm_ssthresh = NFS_MAXWINDOW; /* Slowstart threshold */
237: nmp->nm_rttvar = nmp->nm_rto << 1;
238: nmp->nm_sent = 0;
239: nmp->nm_currexmit = 0;
240: return (0);
241:
242: bad:
243: nfs_disconnect(nmp);
244: return (error);
245: }
246:
247: /*
248: * Reconnect routine:
249: * Called when a connection is broken on a reliable protocol.
250: * - clean up the old socket
251: * - nfs_connect() again
252: * - set R_MUSTRESEND for all outstanding requests on mount point
253: * If this fails the mount point is DEAD!
254: * nb: Must be called with the nfs_solock() set on the mount point.
255: */
256: nfs_reconnect(rep, nmp)
257: register struct nfsreq *rep;
258: register struct nfsmount *nmp;
259: {
260: register struct nfsreq *rp;
261: int error;
262:
263: nfs_msg(rep->r_procp, nmp->nm_mountp->mnt_stat.f_mntfromname,
264: "trying reconnect");
265: while (error = nfs_connect(nmp)) {
266: #ifdef lint
267: error = error;
268: #endif /* lint */
269: if ((nmp->nm_flag & NFSMNT_INT) && nfs_sigintr(rep->r_procp))
270: return (EINTR);
271: (void) tsleep((caddr_t)&lbolt, PSOCK, "nfscon", 0);
272: }
273: nfs_msg(rep->r_procp, nmp->nm_mountp->mnt_stat.f_mntfromname,
274: "reconnected");
275:
276: /*
277: * Loop through outstanding request list and fix up all requests
278: * on old socket.
279: */
280: rp = nfsreqh.r_next;
281: while (rp != &nfsreqh) {
282: if (rp->r_nmp == nmp)
283: rp->r_flags |= R_MUSTRESEND;
284: rp = rp->r_next;
285: }
286: return (0);
287: }
288:
289: /*
290: * NFS disconnect. Clean up and unlink.
291: */
292: void
293: nfs_disconnect(nmp)
294: register struct nfsmount *nmp;
295: {
296: register struct socket *so;
297:
298: if (nmp->nm_so) {
299: so = nmp->nm_so;
300: nmp->nm_so = (struct socket *)0;
301: soshutdown(so, 2);
302: soclose(so);
303: }
304: }
305:
306: /*
307: * This is the nfs send routine. For connection based socket types, it
308: * must be called with an nfs_solock() on the socket.
309: * "rep == NULL" indicates that it has been called from a server.
310: */
311: nfs_send(so, nam, top, rep)
312: register struct socket *so;
313: struct mbuf *nam;
314: register struct mbuf *top;
315: struct nfsreq *rep;
316: {
317: struct mbuf *sendnam;
318: int error, soflags;
319:
320: if (rep) {
321: if (rep->r_flags & R_SOFTTERM) {
322: m_freem(top);
323: return (EINTR);
324: }
325: if (rep->r_nmp->nm_so == NULL &&
326: (error = nfs_reconnect(rep, rep->r_nmp)))
327: return (error);
328: rep->r_flags &= ~R_MUSTRESEND;
329: so = rep->r_nmp->nm_so;
330: soflags = rep->r_nmp->nm_soflags;
331: } else
332: soflags = so->so_proto->pr_flags;
333: if ((soflags & PR_CONNREQUIRED) || (so->so_state & SS_ISCONNECTED))
334: sendnam = (struct mbuf *)0;
335: else
336: sendnam = nam;
337:
338: error = sosend(so, sendnam, (struct uio *)0, top,
339: (struct mbuf *)0, 0);
340: if (error == EWOULDBLOCK && rep) {
341: if (rep->r_flags & R_SOFTTERM)
342: error = EINTR;
343: else {
344: rep->r_flags |= R_MUSTRESEND;
345: error = 0;
346: }
347: }
348: /*
349: * Ignore socket errors??
350: */
351: if (error && error != EINTR && error != ERESTART)
352: error = 0;
353: return (error);
354: }
355:
356: /*
357: * Receive a Sun RPC Request/Reply. For SOCK_DGRAM, the work is all
358: * done by soreceive(), but for SOCK_STREAM we must deal with the Record
359: * Mark and consolidate the data into a new mbuf list.
360: * nb: Sometimes TCP passes the data up to soreceive() in long lists of
361: * small mbufs.
362: * For SOCK_STREAM we must be very careful to read an entire record once
363: * we have read any of it, even if the system call has been interrupted.
364: */
365: nfs_receive(so, aname, mp, rep)
366: register struct socket *so;
367: struct mbuf **aname;
368: struct mbuf **mp;
369: register struct nfsreq *rep;
370: {
371: struct uio auio;
372: struct iovec aio;
373: register struct mbuf *m;
374: struct mbuf *m2, *mnew, **mbp;
375: caddr_t fcp, tcp;
376: u_long len;
377: struct mbuf **getnam;
378: int error, siz, mlen, soflags, rcvflg;
379:
380: /*
381: * Set up arguments for soreceive()
382: */
383: *mp = (struct mbuf *)0;
384: *aname = (struct mbuf *)0;
385: if (rep)
386: soflags = rep->r_nmp->nm_soflags;
387: else
388: soflags = so->so_proto->pr_flags;
389:
390: /*
391: * For reliable protocols, lock against other senders/receivers
392: * in case a reconnect is necessary.
393: * For SOCK_STREAM, first get the Record Mark to find out how much
394: * more there is to get.
395: * We must lock the socket against other receivers
396: * until we have an entire rpc request/reply.
397: */
398: if (soflags & PR_CONNREQUIRED) {
399: tryagain:
400: /*
401: * Check for fatal errors and resending request.
402: */
403: if (rep) {
404: /*
405: * Ugh: If a reconnect attempt just happened, nm_so
406: * would have changed. NULL indicates a failed
407: * attempt that has essentially shut down this
408: * mount point.
409: */
410: if (rep->r_mrep || (so = rep->r_nmp->nm_so) == NULL ||
411: (rep->r_flags & R_SOFTTERM))
412: return (EINTR);
413: while (rep->r_flags & R_MUSTRESEND) {
414: m = m_copym(rep->r_mreq, 0, M_COPYALL, M_WAIT);
415: nfsstats.rpcretries++;
416: if (error = nfs_send(so, rep->r_nmp->nm_nam, m,
417: rep))
418: goto errout;
419: }
420: }
421: if ((soflags & PR_ATOMIC) == 0) {
422: aio.iov_base = (caddr_t) &len;
423: aio.iov_len = sizeof(u_long);
424: auio.uio_iov = &aio;
425: auio.uio_iovcnt = 1;
426: auio.uio_segflg = UIO_SYSSPACE;
427: auio.uio_rw = UIO_READ;
428: auio.uio_procp = (struct proc *)0;
429: auio.uio_offset = 0;
430: auio.uio_resid = sizeof(u_long);
431: do {
432: rcvflg = MSG_WAITALL;
433: error = soreceive(so, (struct mbuf **)0, &auio,
434: (struct mbuf **)0, (struct mbuf **)0, &rcvflg);
435: if (error == EWOULDBLOCK && rep) {
436: if (rep->r_flags & R_SOFTTERM)
437: return (EINTR);
438: if (rep->r_flags & R_MUSTRESEND)
439: goto tryagain;
440: }
441: } while (error == EWOULDBLOCK);
442: if (!error && auio.uio_resid > 0) {
443: if (rep)
444: log(LOG_INFO,
445: "short receive (%d/%d) from nfs server %s\n",
446: sizeof(u_long) - auio.uio_resid,
447: sizeof(u_long),
448: rep->r_nmp->nm_mountp->mnt_stat.f_mntfromname);
449: error = EPIPE;
450: }
451: if (error)
452: goto errout;
453: len = ntohl(len) & ~0x80000000;
454: /*
455: * This is SERIOUS! We are out of sync with the sender
456: * and forcing a disconnect/reconnect is all I can do.
457: */
458: if (len > NFS_MAXPACKET) {
459: if (rep)
460: log(LOG_ERR, "%s (%d) from nfs server %s\n",
461: "impossible packet length",
462: len,
463: rep->r_nmp->nm_mountp->mnt_stat.f_mntfromname);
464: error = EFBIG;
465: goto errout;
466: }
467: auio.uio_resid = len;
468: do {
469: rcvflg = MSG_WAITALL;
470: error = soreceive(so, (struct mbuf **)0,
471: &auio, mp, (struct mbuf **)0, &rcvflg);
472: } while (error == EWOULDBLOCK || error == EINTR ||
473: error == ERESTART);
474: if (!error && auio.uio_resid > 0) {
475: if (rep)
476: log(LOG_INFO,
477: "short receive (%d/%d) from nfs server %s\n",
478: len - auio.uio_resid, len,
479: rep->r_nmp->nm_mountp->mnt_stat.f_mntfromname);
480: error = EPIPE;
481: }
482: } else {
483: auio.uio_resid = len = 1000000; /* Anything Big */
484: do {
485: rcvflg = 0;
486: error = soreceive(so, (struct mbuf **)0,
487: &auio, mp, (struct mbuf **)0, &rcvflg);
488: if (error == EWOULDBLOCK && rep) {
489: if (rep->r_flags & R_SOFTTERM)
490: return (EINTR);
491: if (rep->r_flags & R_MUSTRESEND)
492: goto tryagain;
493: }
494: } while (error == EWOULDBLOCK);
495: if (!error && *mp == NULL)
496: error = EPIPE;
497: len -= auio.uio_resid;
498: }
499: errout:
500: if (error && rep && error != EINTR && error != ERESTART) {
501: m_freem(*mp);
502: *mp = (struct mbuf *)0;
503: if (error != EPIPE && rep)
504: log(LOG_INFO,
505: "receive error %d from nfs server %s\n",
506: error,
507: rep->r_nmp->nm_mountp->mnt_stat.f_mntfromname);
508: nfs_disconnect(rep->r_nmp);
509: error = nfs_reconnect(rep, rep->r_nmp);
510: if (!error)
511: goto tryagain;
512: }
513: } else {
514: if (so->so_state & SS_ISCONNECTED)
515: getnam = (struct mbuf **)0;
516: else
517: getnam = aname;
518: auio.uio_resid = len = 1000000;
519: do {
520: rcvflg = 0;
521: error = soreceive(so, getnam, &auio, mp,
522: (struct mbuf **)0, &rcvflg);
523: if (error == EWOULDBLOCK && rep &&
524: (rep->r_flags & R_SOFTTERM))
525: return (EINTR);
526: } while (error == EWOULDBLOCK);
527: len -= auio.uio_resid;
528: }
529: if (error) {
530: m_freem(*mp);
531: *mp = (struct mbuf *)0;
532: }
533: /*
534: * Search for any mbufs that are not a multiple of 4 bytes long.
535: * These could cause pointer alignment problems, so copy them to
536: * well aligned mbufs.
537: */
538: m = *mp;
539: mbp = mp;
540: while (m) {
541: /*
542: * All this for something that may never happen.
543: */
544: if (m->m_next && (m->m_len & 0x3)) {
545: printf("nfs_rcv odd length!\n");
546: mlen = 0;
547: while (m) {
548: fcp = mtod(m, caddr_t);
549: while (m->m_len > 0) {
550: if (mlen == 0) {
551: MGET(m2, M_WAIT, MT_DATA);
552: if (len >= MINCLSIZE)
553: MCLGET(m2, M_WAIT);
554: m2->m_len = 0;
555: mlen = M_TRAILINGSPACE(m2);
556: tcp = mtod(m2, caddr_t);
557: *mbp = m2;
558: mbp = &m2->m_next;
559: }
560: siz = MIN(mlen, m->m_len);
561: bcopy(fcp, tcp, siz);
562: m2->m_len += siz;
563: mlen -= siz;
564: len -= siz;
565: tcp += siz;
566: m->m_len -= siz;
567: fcp += siz;
568: }
569: MFREE(m, mnew);
570: m = mnew;
571: }
572: break;
573: }
574: len -= m->m_len;
575: mbp = &m->m_next;
576: m = m->m_next;
577: }
578: return (error);
579: }
580:
581: /*
582: * Implement receipt of reply on a socket.
583: * We must search through the list of received datagrams matching them
584: * with outstanding requests using the xid, until ours is found.
585: */
586: /* ARGSUSED */
587: nfs_reply(nmp, myrep)
588: struct nfsmount *nmp;
589: struct nfsreq *myrep;
590: {
591: register struct mbuf *m;
592: register struct nfsreq *rep;
593: register int error = 0;
594: u_long rxid;
595: struct mbuf *mp, *nam;
596: char *cp;
597: int cnt, xfer;
598:
599: /*
600: * Loop around until we get our own reply
601: */
602: for (;;) {
603: /*
604: * Lock against other receivers so that I don't get stuck in
605: * sbwait() after someone else has received my reply for me.
606: * Also necessary for connection based protocols to avoid
607: * race conditions during a reconnect.
608: */
609: nfs_solock(&nmp->nm_flag);
610: /* Already received, bye bye */
611: if (myrep->r_mrep != NULL) {
612: nfs_sounlock(&nmp->nm_flag);
613: return (0);
614: }
615: /*
616: * Get the next Rpc reply off the socket
617: */
618: if (error = nfs_receive(nmp->nm_so, &nam, &mp, myrep)) {
619: nfs_sounlock(&nmp->nm_flag);
620:
621: /*
622: * Ignore routing errors on connectionless protocols??
623: */
624: if (NFSIGNORE_SOERROR(nmp->nm_soflags, error)) {
625: nmp->nm_so->so_error = 0;
626: continue;
627: }
628:
629: /*
630: * Otherwise cleanup and return a fatal error.
631: */
632: if (myrep->r_flags & R_TIMING) {
633: myrep->r_flags &= ~R_TIMING;
634: nmp->nm_rtt = -1;
635: }
636: if (myrep->r_flags & R_SENT) {
637: myrep->r_flags &= ~R_SENT;
638: nmp->nm_sent--;
639: }
640: return (error);
641: }
642:
643: /*
644: * Get the xid and check that it is an rpc reply
645: */
646: m = mp;
647: while (m && m->m_len == 0)
648: m = m->m_next;
649: if (m == NULL) {
650: nfsstats.rpcinvalid++;
651: m_freem(mp);
652: nfs_sounlock(&nmp->nm_flag);
653: continue;
654: }
655: bcopy(mtod(m, caddr_t), (caddr_t)&rxid, NFSX_UNSIGNED);
656: /*
657: * Loop through the request list to match up the reply
658: * Iff no match, just drop the datagram
659: */
660: m = mp;
661: rep = nfsreqh.r_next;
662: while (rep != &nfsreqh) {
663: if (rep->r_mrep == NULL && rxid == rep->r_xid) {
664: /* Found it.. */
665: rep->r_mrep = m;
666: /*
667: * Update timing
668: */
669: if (rep->r_flags & R_TIMING) {
670: nfs_updatetimer(rep->r_nmp);
671: rep->r_flags &= ~R_TIMING;
672: rep->r_nmp->nm_rtt = -1;
673: }
674: if (rep->r_flags & R_SENT) {
675: rep->r_flags &= ~R_SENT;
676: rep->r_nmp->nm_sent--;
677: }
678: break;
679: }
680: rep = rep->r_next;
681: }
682: nfs_sounlock(&nmp->nm_flag);
683: if (nam)
684: m_freem(nam);
685: /*
686: * If not matched to a request, drop it.
687: * If it's mine, get out.
688: */
689: if (rep == &nfsreqh) {
690: nfsstats.rpcunexpected++;
691: m_freem(m);
692: } else if (rep == myrep)
693: return (0);
694: }
695: }
696:
697: /*
698: * nfs_request - goes something like this
699: * - fill in request struct
700: * - links it into list
701: * - calls nfs_send() for first transmit
702: * - calls nfs_receive() to get reply
703: * - break down rpc header and return with nfs reply pointed to
704: * by mrep or error
705: * nb: always frees up mreq mbuf list
706: */
707: nfs_request(vp, mreq, xid, procnum, procp, tryhard, mp, mrp, mdp, dposp)
708: struct vnode *vp;
709: struct mbuf *mreq;
710: u_long xid;
711: int procnum;
712: struct proc *procp;
713: int tryhard;
714: struct mount *mp;
715: struct mbuf **mrp;
716: struct mbuf **mdp;
717: caddr_t *dposp;
718: {
719: register struct mbuf *m, *mrep;
720: register struct nfsreq *rep;
721: register u_long *tl;
722: register int len;
723: struct nfsmount *nmp;
724: struct mbuf *md;
725: struct nfsreq *reph;
726: caddr_t dpos;
727: char *cp2;
728: int t1;
729: int s, compressed;
730: int error = 0;
731:
732: nmp = VFSTONFS(mp);
733: m = mreq;
734: MALLOC(rep, struct nfsreq *, sizeof(struct nfsreq), M_NFSREQ, M_WAITOK);
735: rep->r_xid = xid;
736: rep->r_nmp = nmp;
737: rep->r_vp = vp;
738: rep->r_procp = procp;
739: if ((nmp->nm_flag & NFSMNT_SOFT) ||
740: ((nmp->nm_flag & NFSMNT_SPONGY) && !tryhard))
741: rep->r_retry = nmp->nm_retry;
742: else
743: rep->r_retry = NFS_MAXREXMIT + 1; /* past clip limit */
744: rep->r_flags = rep->r_rexmit = 0;
745: /*
746: * Three cases:
747: * - non-idempotent requests on SOCK_DGRAM use NFS_MINIDEMTIMEO
748: * - idempotent requests on SOCK_DGRAM use 0
749: * - Reliable transports, NFS_RELIABLETIMEO
750: * Timeouts are still done on reliable transports to ensure detection
751: * of excessive connection delay.
752: */
753: if (nmp->nm_sotype != SOCK_DGRAM)
754: rep->r_timerinit = -NFS_RELIABLETIMEO;
755: else if (nonidempotent[procnum])
756: rep->r_timerinit = -NFS_MINIDEMTIMEO;
757: else
758: rep->r_timerinit = 0;
759: rep->r_timer = rep->r_timerinit;
760: rep->r_mrep = NULL;
761: len = 0;
762: while (m) {
763: len += m->m_len;
764: m = m->m_next;
765: }
766: mreq->m_pkthdr.len = len;
767: mreq->m_pkthdr.rcvif = (struct ifnet *)0;
768: compressed = 0;
769: m = mreq;
770: if ((nmp->nm_flag & NFSMNT_COMPRESS) && compressrequest[procnum]) {
771: mreq = nfs_compress(mreq);
772: if (mreq != m) {
773: len = mreq->m_pkthdr.len;
774: compressed++;
775: }
776: }
777: /*
778: * For non-atomic protocols, insert a Sun RPC Record Mark.
779: */
780: if ((nmp->nm_soflags & PR_ATOMIC) == 0) {
781: M_PREPEND(mreq, sizeof(u_long), M_WAIT);
782: *mtod(mreq, u_long *) = htonl(0x80000000 | len);
783: }
784: rep->r_mreq = mreq;
785:
786: /*
787: * Do the client side RPC.
788: */
789: nfsstats.rpcrequests++;
790: /*
791: * Chain request into list of outstanding requests. Be sure
792: * to put it LAST so timer finds oldest requests first.
793: */
794: s = splnet();
795: reph = &nfsreqh;
796: reph->r_prev->r_next = rep;
797: rep->r_prev = reph->r_prev;
798: reph->r_prev = rep;
799: rep->r_next = reph;
800: /*
801: * If backing off another request or avoiding congestion, don't
802: * send this one now but let timer do it. If not timing a request,
803: * do it now.
804: */
805: if (nmp->nm_sent <= 0 || nmp->nm_sotype != SOCK_DGRAM ||
806: (nmp->nm_currexmit == 0 && nmp->nm_sent < nmp->nm_window)) {
807: nmp->nm_sent++;
808: rep->r_flags |= R_SENT;
809: if (nmp->nm_rtt == -1) {
810: nmp->nm_rtt = 0;
811: rep->r_flags |= R_TIMING;
812: }
813: splx(s);
814: m = m_copym(mreq, 0, M_COPYALL, M_WAIT);
815: if (nmp->nm_soflags & PR_CONNREQUIRED)
816: nfs_solock(&nmp->nm_flag);
817: error = nfs_send(nmp->nm_so, nmp->nm_nam, m, rep);
818: if (nmp->nm_soflags & PR_CONNREQUIRED)
819: nfs_sounlock(&nmp->nm_flag);
820: if (error && NFSIGNORE_SOERROR(nmp->nm_soflags, error))
821: nmp->nm_so->so_error = error = 0;
822: } else
823: splx(s);
824:
825: /*
826: * Wait for the reply from our send or the timer's.
827: */
828: if (!error)
829: error = nfs_reply(nmp, rep);
830:
831: /*
832: * RPC done, unlink the request.
833: */
834: s = splnet();
835: rep->r_prev->r_next = rep->r_next;
836: rep->r_next->r_prev = rep->r_prev;
837: splx(s);
838:
839: /*
840: * If there was a successful reply and a tprintf msg.
841: * tprintf a response.
842: */
843: if (!error && (rep->r_flags & R_TPRINTFMSG))
844: nfs_msg(rep->r_procp, nmp->nm_mountp->mnt_stat.f_mntfromname,
845: "is alive again");
846: m_freem(rep->r_mreq);
847: mrep = rep->r_mrep;
848: FREE((caddr_t)rep, M_NFSREQ);
849: if (error)
850: return (error);
851:
852: if (compressed)
853: mrep = nfs_uncompress(mrep);
854: md = mrep;
855: /*
856: * break down the rpc header and check if ok
857: */
858: dpos = mtod(md, caddr_t);
859: nfsm_disect(tl, u_long *, 5*NFSX_UNSIGNED);
860: tl += 2;
861: if (*tl++ == rpc_msgdenied) {
862: if (*tl == rpc_mismatch)
863: error = EOPNOTSUPP;
864: else
865: error = EACCES;
866: m_freem(mrep);
867: return (error);
868: }
869: /*
870: * skip over the auth_verf, someday we may want to cache auth_short's
871: * for nfs_reqhead(), but for now just dump it
872: */
873: if (*++tl != 0) {
874: len = nfsm_rndup(fxdr_unsigned(long, *tl));
875: nfsm_adv(len);
876: }
877: nfsm_disect(tl, u_long *, NFSX_UNSIGNED);
878: /* 0 == ok */
879: if (*tl == 0) {
880: nfsm_disect(tl, u_long *, NFSX_UNSIGNED);
881: if (*tl != 0) {
882: error = fxdr_unsigned(int, *tl);
883: m_freem(mrep);
884: return (error);
885: }
886: *mrp = mrep;
887: *mdp = md;
888: *dposp = dpos;
889: return (0);
890: }
891: m_freem(mrep);
892: return (EPROTONOSUPPORT);
893: nfsmout:
894: return (error);
895: }
896:
897: /*
898: * Get a request for the server main loop
899: * - receive a request via. nfs_soreceive()
900: * - verify it
901: * - fill in the cred struct.
902: */
903: nfs_getreq(so, prog, vers, maxproc, nam, mrp, mdp, dposp, retxid, procnum, cr,
904: msk, mtch, wascomp)
905: struct socket *so;
906: u_long prog;
907: u_long vers;
908: int maxproc;
909: struct mbuf **nam;
910: struct mbuf **mrp;
911: struct mbuf **mdp;
912: caddr_t *dposp;
913: u_long *retxid;
914: u_long *procnum;
915: register struct ucred *cr;
916: struct mbuf *msk, *mtch;
917: int *wascomp;
918: {
919: register int i;
920: register u_long *tl;
921: register long t1;
922: caddr_t dpos, cp2;
923: int error = 0;
924: struct mbuf *mrep, *md;
925: int len;
926:
927: if (so->so_proto->pr_flags & PR_CONNREQUIRED) {
928: error = nfs_receive(so, nam, &mrep, (struct nfsreq *)0);
929: } else {
930: mrep = (struct mbuf *)0;
931: do {
932: if (mrep) {
933: m_freem(*nam);
934: m_freem(mrep);
935: }
936: error = nfs_receive(so, nam, &mrep, (struct nfsreq *)0);
937: } while (!error && nfs_badnam(*nam, msk, mtch));
938: }
939: if (error)
940: return (error);
941: md = mrep;
942: mrep = nfs_uncompress(mrep);
943: if (mrep != md) {
944: *wascomp = 1;
945: md = mrep;
946: } else
947: *wascomp = 0;
948: dpos = mtod(mrep, caddr_t);
949: nfsm_disect(tl, u_long *, 10*NFSX_UNSIGNED);
950: *retxid = *tl++;
951: if (*tl++ != rpc_call) {
952: m_freem(mrep);
953: return (ERPCMISMATCH);
954: }
955: if (*tl++ != rpc_vers) {
956: m_freem(mrep);
957: return (ERPCMISMATCH);
958: }
959: if (*tl++ != prog) {
960: m_freem(mrep);
961: return (EPROGUNAVAIL);
962: }
963: if (*tl++ != vers) {
964: m_freem(mrep);
965: return (EPROGMISMATCH);
966: }
967: *procnum = fxdr_unsigned(u_long, *tl++);
968: if (*procnum == NFSPROC_NULL) {
969: *mrp = mrep;
970: return (0);
971: }
972: if (*procnum > maxproc || *tl++ != rpc_auth_unix) {
973: m_freem(mrep);
974: return (EPROCUNAVAIL);
975: }
976: len = fxdr_unsigned(int, *tl++);
977: if (len < 0 || len > RPCAUTH_MAXSIZ) {
978: m_freem(mrep);
979: return (EBADRPC);
980: }
981: len = fxdr_unsigned(int, *++tl);
982: if (len < 0 || len > NFS_MAXNAMLEN) {
983: m_freem(mrep);
984: return (EBADRPC);
985: }
986: nfsm_adv(nfsm_rndup(len));
987: nfsm_disect(tl, u_long *, 3*NFSX_UNSIGNED);
988: cr->cr_uid = fxdr_unsigned(uid_t, *tl++);
989: cr->cr_gid = fxdr_unsigned(gid_t, *tl++);
990: len = fxdr_unsigned(int, *tl);
991: if (len < 0 || len > RPCAUTH_UNIXGIDS) {
992: m_freem(mrep);
993: return (EBADRPC);
994: }
995: nfsm_disect(tl, u_long *, (len + 2)*NFSX_UNSIGNED);
996: for (i = 1; i <= len; i++)
997: if (i < NGROUPS)
998: cr->cr_groups[i] = fxdr_unsigned(gid_t, *tl++);
999: else
1000: tl++;
1001: cr->cr_ngroups = (len >= NGROUPS) ? NGROUPS : (len + 1);
1002: /*
1003: * Do we have any use for the verifier.
1004: * According to the "Remote Procedure Call Protocol Spec." it
1005: * should be AUTH_NULL, but some clients make it AUTH_UNIX?
1006: * For now, just skip over it
1007: */
1008: len = fxdr_unsigned(int, *++tl);
1009: if (len < 0 || len > RPCAUTH_MAXSIZ) {
1010: m_freem(mrep);
1011: return (EBADRPC);
1012: }
1013: if (len > 0)
1014: nfsm_adv(nfsm_rndup(len));
1015: *mrp = mrep;
1016: *mdp = md;
1017: *dposp = dpos;
1018: return (0);
1019: nfsmout:
1020: return (error);
1021: }
1022:
1023: /*
1024: * Generate the rpc reply header
1025: * siz arg. is used to decide if adding a cluster is worthwhile
1026: */
1027: nfs_rephead(siz, retxid, err, mrq, mbp, bposp)
1028: int siz;
1029: u_long retxid;
1030: int err;
1031: struct mbuf **mrq;
1032: struct mbuf **mbp;
1033: caddr_t *bposp;
1034: {
1035: register u_long *tl;
1036: register long t1;
1037: caddr_t bpos;
1038: struct mbuf *mreq, *mb, *mb2;
1039:
1040: NFSMGETHDR(mreq);
1041: mb = mreq;
1042: if ((siz+RPC_REPLYSIZ) > MHLEN)
1043: MCLGET(mreq, M_WAIT);
1044: tl = mtod(mreq, u_long *);
1045: mreq->m_len = 6*NFSX_UNSIGNED;
1046: bpos = ((caddr_t)tl)+mreq->m_len;
1047: *tl++ = retxid;
1048: *tl++ = rpc_reply;
1049: if (err == ERPCMISMATCH) {
1050: *tl++ = rpc_msgdenied;
1051: *tl++ = rpc_mismatch;
1052: *tl++ = txdr_unsigned(2);
1053: *tl = txdr_unsigned(2);
1054: } else {
1055: *tl++ = rpc_msgaccepted;
1056: *tl++ = 0;
1057: *tl++ = 0;
1058: switch (err) {
1059: case EPROGUNAVAIL:
1060: *tl = txdr_unsigned(RPC_PROGUNAVAIL);
1061: break;
1062: case EPROGMISMATCH:
1063: *tl = txdr_unsigned(RPC_PROGMISMATCH);
1064: nfsm_build(tl, u_long *, 2*NFSX_UNSIGNED);
1065: *tl++ = txdr_unsigned(2);
1066: *tl = txdr_unsigned(2); /* someday 3 */
1067: break;
1068: case EPROCUNAVAIL:
1069: *tl = txdr_unsigned(RPC_PROCUNAVAIL);
1070: break;
1071: default:
1072: *tl = 0;
1073: if (err != VNOVAL) {
1074: nfsm_build(tl, u_long *, NFSX_UNSIGNED);
1075: *tl = txdr_unsigned(err);
1076: }
1077: break;
1078: };
1079: }
1080: *mrq = mreq;
1081: *mbp = mb;
1082: *bposp = bpos;
1083: if (err != 0 && err != VNOVAL)
1084: nfsstats.srvrpc_errs++;
1085: return (0);
1086: }
1087:
1088: /*
1089: * Nfs timer routine
1090: * Scan the nfsreq list and retranmit any requests that have timed out
1091: * To avoid retransmission attempts on STREAM sockets (in the future) make
1092: * sure to set the r_retry field to 0 (implies nm_retry == 0).
1093: */
1094: nfs_timer()
1095: {
1096: register struct nfsreq *rep;
1097: register struct mbuf *m;
1098: register struct socket *so;
1099: register struct nfsmount *nmp;
1100: int s, error;
1101:
1102: s = splnet();
1103: for (rep = nfsreqh.r_next; rep != &nfsreqh; rep = rep->r_next) {
1104: nmp = rep->r_nmp;
1105: if (rep->r_mrep || (rep->r_flags & R_SOFTTERM) ||
1106: (so = nmp->nm_so) == NULL)
1107: continue;
1108: if ((nmp->nm_flag & NFSMNT_INT) && nfs_sigintr(rep->r_procp)) {
1109: rep->r_flags |= R_SOFTTERM;
1110: continue;
1111: }
1112: if (rep->r_flags & R_TIMING) /* update rtt in mount */
1113: nmp->nm_rtt++;
1114: /* If not timed out */
1115: if (++rep->r_timer < nmp->nm_rto)
1116: continue;
1117: /* Do backoff and save new timeout in mount */
1118: if (rep->r_flags & R_TIMING) {
1119: nfs_backofftimer(nmp);
1120: rep->r_flags &= ~R_TIMING;
1121: nmp->nm_rtt = -1;
1122: }
1123: if (rep->r_flags & R_SENT) {
1124: rep->r_flags &= ~R_SENT;
1125: nmp->nm_sent--;
1126: }
1127:
1128: /*
1129: * Check for too many retries on soft mount.
1130: * nb: For hard mounts, r_retry == NFS_MAXREXMIT+1
1131: */
1132: if (++rep->r_rexmit > NFS_MAXREXMIT)
1133: rep->r_rexmit = NFS_MAXREXMIT;
1134:
1135: /*
1136: * Check for server not responding
1137: */
1138: if ((rep->r_flags & R_TPRINTFMSG) == 0 &&
1139: rep->r_rexmit > NFS_FISHY) {
1140: nfs_msg(rep->r_procp,
1141: nmp->nm_mountp->mnt_stat.f_mntfromname,
1142: "not responding");
1143: rep->r_flags |= R_TPRINTFMSG;
1144: }
1145: if (rep->r_rexmit >= rep->r_retry) { /* too many */
1146: nfsstats.rpctimeouts++;
1147: rep->r_flags |= R_SOFTTERM;
1148: continue;
1149: }
1150: if (nmp->nm_sotype != SOCK_DGRAM)
1151: continue;
1152:
1153: /*
1154: * If there is enough space and the window allows..
1155: * Resend it
1156: */
1157: if (sbspace(&so->so_snd) >= rep->r_mreq->m_pkthdr.len &&
1158: nmp->nm_sent < nmp->nm_window &&
1159: (m = m_copym(rep->r_mreq, 0, M_COPYALL, M_DONTWAIT))){
1160: nfsstats.rpcretries++;
1161: if ((nmp->nm_flag & NFSMNT_NOCONN) == 0)
1162: error = (*so->so_proto->pr_usrreq)(so, PRU_SEND, m,
1163: (caddr_t)0, (struct mbuf *)0, (struct mbuf *)0);
1164: else
1165: error = (*so->so_proto->pr_usrreq)(so, PRU_SEND, m,
1166: nmp->nm_nam, (struct mbuf *)0, (struct mbuf *)0);
1167: if (error) {
1168: if (NFSIGNORE_SOERROR(nmp->nm_soflags, error))
1169: so->so_error = 0;
1170: } else {
1171: /*
1172: * We need to time the request even though we
1173: * are retransmitting.
1174: */
1175: nmp->nm_rtt = 0;
1176: nmp->nm_sent++;
1177: rep->r_flags |= (R_SENT|R_TIMING);
1178: rep->r_timer = rep->r_timerinit;
1179: }
1180: }
1181: }
1182: splx(s);
1183: timeout(nfs_timer, (caddr_t)0, hz/NFS_HZ);
1184: }
1185:
1186: /*
1187: * NFS timer update and backoff. The "Jacobson/Karels/Karn" scheme is
1188: * used here. The timer state is held in the nfsmount structure and
1189: * a single request is used to clock the response. When successful
1190: * the rtt smoothing in nfs_updatetimer is used, when failed the backoff
1191: * is done by nfs_backofftimer. We also log failure messages in these
1192: * routines.
1193: *
1194: * Congestion variables are held in the nfshost structure which
1195: * is referenced by nfsmounts and shared per-server. This separation
1196: * makes it possible to do per-mount timing which allows varying disk
1197: * access times to be dealt with, while preserving a network oriented
1198: * congestion control scheme.
1199: *
1200: * The windowing implements the Jacobson/Karels slowstart algorithm
1201: * with adjusted scaling factors. We start with one request, then send
1202: * 4 more after each success until the ssthresh limit is reached, then
1203: * we increment at a rate proportional to the window. On failure, we
1204: * remember 3/4 the current window and clamp the send limit to 1. Note
1205: * ICMP source quench is not reflected in so->so_error so we ignore that
1206: * for now.
1207: *
1208: * NFS behaves much more like a transport protocol with these changes,
1209: * shedding the teenage pedal-to-the-metal tendencies of "other"
1210: * implementations.
1211: *
1212: * Timers and congestion avoidance by Tom Talpey, Open Software Foundation.
1213: */
1214:
1215: /*
1216: * The TCP algorithm was not forgiving enough. Because the NFS server
1217: * responds only after performing lookups/diskio/etc, we have to be
1218: * more prepared to accept a spiky variance. The TCP algorithm is:
1219: * TCP_RTO(nmp) ((((nmp)->nm_srtt >> 2) + (nmp)->nm_rttvar) >> 1)
1220: */
1221: #define NFS_RTO(nmp) (((nmp)->nm_srtt >> 3) + (nmp)->nm_rttvar)
1222:
1223: nfs_updatetimer(nmp)
1224: register struct nfsmount *nmp;
1225: {
1226:
1227: /* If retransmitted, clear and return */
1228: if (nmp->nm_rexmit || nmp->nm_currexmit) {
1229: nmp->nm_rexmit = nmp->nm_currexmit = 0;
1230: return;
1231: }
1232: /* If have a measurement, do smoothing */
1233: if (nmp->nm_srtt) {
1234: register short delta;
1235: delta = nmp->nm_rtt - (nmp->nm_srtt >> 3);
1236: if ((nmp->nm_srtt += delta) <= 0)
1237: nmp->nm_srtt = 1;
1238: if (delta < 0)
1239: delta = -delta;
1240: delta -= (nmp->nm_rttvar >> 2);
1241: if ((nmp->nm_rttvar += delta) <= 0)
1242: nmp->nm_rttvar = 1;
1243: /* Else initialize */
1244: } else {
1245: nmp->nm_rttvar = nmp->nm_rtt << 1;
1246: if (nmp->nm_rttvar == 0) nmp->nm_rttvar = 2;
1247: nmp->nm_srtt = nmp->nm_rttvar << 2;
1248: }
1249: /* Compute new Retransmission TimeOut and clip */
1250: nmp->nm_rto = NFS_RTO(nmp);
1251: if (nmp->nm_rto < NFS_MINTIMEO)
1252: nmp->nm_rto = NFS_MINTIMEO;
1253: else if (nmp->nm_rto > NFS_MAXTIMEO)
1254: nmp->nm_rto = NFS_MAXTIMEO;
1255:
1256: /* Update window estimate */
1257: if (nmp->nm_window < nmp->nm_ssthresh) /* quickly */
1258: nmp->nm_window += 4;
1259: else { /* slowly */
1260: register long incr = ++nmp->nm_winext;
1261: incr = (incr * incr) / nmp->nm_window;
1262: if (incr > 0) {
1263: nmp->nm_winext = 0;
1264: ++nmp->nm_window;
1265: }
1266: }
1267: if (nmp->nm_window > NFS_MAXWINDOW)
1268: nmp->nm_window = NFS_MAXWINDOW;
1269: }
1270:
1271: nfs_backofftimer(nmp)
1272: register struct nfsmount *nmp;
1273: {
1274: register unsigned long newrto;
1275:
1276: /* Clip shift count */
1277: if (++nmp->nm_rexmit > 8 * sizeof nmp->nm_rto)
1278: nmp->nm_rexmit = 8 * sizeof nmp->nm_rto;
1279: /* Back off RTO exponentially */
1280: newrto = NFS_RTO(nmp);
1281: newrto <<= (nmp->nm_rexmit - 1);
1282: if (newrto == 0 || newrto > NFS_MAXTIMEO)
1283: newrto = NFS_MAXTIMEO;
1284: nmp->nm_rto = newrto;
1285:
1286: /* If too many retries, message, assume a bogus RTT and re-measure */
1287: if (nmp->nm_currexmit < nmp->nm_rexmit) {
1288: nmp->nm_currexmit = nmp->nm_rexmit;
1289: if (nmp->nm_currexmit >= nfsrexmtthresh) {
1290: if (nmp->nm_currexmit == nfsrexmtthresh) {
1291: nmp->nm_rttvar += (nmp->nm_srtt >> 2);
1292: nmp->nm_srtt = 0;
1293: }
1294: }
1295: }
1296: /* Close down window but remember this point (3/4 current) for later */
1297: nmp->nm_ssthresh = ((nmp->nm_window << 1) + nmp->nm_window) >> 2;
1298: nmp->nm_window = 1;
1299: nmp->nm_winext = 0;
1300: }
1301:
1302: /*
1303: * Test for a termination signal pending on procp.
1304: * This is used for NFSMNT_INT mounts.
1305: */
1306: nfs_sigintr(p)
1307: register struct proc *p;
1308: {
1309: if (p && p->p_sig && (((p->p_sig &~ p->p_sigmask) &~ p->p_sigignore) &
1310: NFSINT_SIGMASK))
1311: return (1);
1312: else
1313: return (0);
1314: }
1315:
1316: nfs_msg(p, server, msg)
1317: struct proc *p;
1318: char *server, *msg;
1319: {
1320: tpr_t tpr;
1321:
1322: if (p)
1323: tpr = tprintf_open(p);
1324: else
1325: tpr = NULL;
1326: tprintf(tpr, "nfs server %s: %s\n", server, msg);
1327: tprintf_close(tpr);
1328: }
1329:
1330: /*
1331: * Lock a socket against others.
1332: * Necessary for STREAM sockets to ensure you get an entire rpc request/reply
1333: * and also to avoid race conditions between the processes with nfs requests
1334: * in progress when a reconnect is necessary.
1335: */
1336: nfs_solock(flagp)
1337: register int *flagp;
1338: {
1339:
1340: while (*flagp & NFSMNT_SCKLOCK) {
1341: *flagp |= NFSMNT_WANTSCK;
1342: (void) tsleep((caddr_t)flagp, PZERO-1, "nfsolck", 0);
1343: }
1344: *flagp |= NFSMNT_SCKLOCK;
1345: }
1346:
1347: /*
1348: * Unlock the stream socket for others.
1349: */
1350: nfs_sounlock(flagp)
1351: register int *flagp;
1352: {
1353:
1354: if ((*flagp & NFSMNT_SCKLOCK) == 0)
1355: panic("nfs sounlock");
1356: *flagp &= ~NFSMNT_SCKLOCK;
1357: if (*flagp & NFSMNT_WANTSCK) {
1358: *flagp &= ~NFSMNT_WANTSCK;
1359: wakeup((caddr_t)flagp);
1360: }
1361: }
1362:
1363: /*
1364: * This function compares two net addresses by family and returns TRUE
1365: * if they are the same.
1366: * If there is any doubt, return FALSE.
1367: */
1368: nfs_netaddr_match(nam1, nam2)
1369: struct mbuf *nam1, *nam2;
1370: {
1371: register struct sockaddr *saddr1, *saddr2;
1372:
1373: saddr1 = mtod(nam1, struct sockaddr *);
1374: saddr2 = mtod(nam2, struct sockaddr *);
1375: if (saddr1->sa_family != saddr2->sa_family)
1376: return (0);
1377:
1378: /*
1379: * Must do each address family separately since unused fields
1380: * are undefined values and not always zeroed.
1381: */
1382: switch (saddr1->sa_family) {
1383: case AF_INET:
1384: if (((struct sockaddr_in *)saddr1)->sin_addr.s_addr ==
1385: ((struct sockaddr_in *)saddr2)->sin_addr.s_addr)
1386: return (1);
1387: break;
1388: default:
1389: break;
1390: };
1391: return (0);
1392: }
1393:
1394: /*
1395: * Check the hostname fields for nfsd's mask and match fields.
1396: * By address family:
1397: * - Bitwise AND the mask with the host address field
1398: * - Compare for == with match
1399: * return TRUE if not equal
1400: */
1401: nfs_badnam(nam, msk, mtch)
1402: register struct mbuf *nam, *msk, *mtch;
1403: {
1404: switch (mtod(nam, struct sockaddr *)->sa_family) {
1405: case AF_INET:
1406: return ((mtod(nam, struct sockaddr_in *)->sin_addr.s_addr &
1407: mtod(msk, struct sockaddr_in *)->sin_addr.s_addr) !=
1408: mtod(mtch, struct sockaddr_in *)->sin_addr.s_addr);
1409: default:
1410: printf("nfs_badmatch, unknown sa_family\n");
1411: return (0);
1412: };
1413: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.