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