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