nfs_socket.c revision 1.167.6.3
1 /* $NetBSD: nfs_socket.c,v 1.167.6.3 2008/09/28 10:41:00 mjf Exp $ */ 2 3 /* 4 * Copyright (c) 1989, 1991, 1993, 1995 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. Neither the name of the University nor the names of its contributors 19 * may be used to endorse or promote products derived from this software 20 * without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 25 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 * 34 * @(#)nfs_socket.c 8.5 (Berkeley) 3/30/95 35 */ 36 37 /* 38 * Socket operations for use by nfs 39 */ 40 41 #include <sys/cdefs.h> 42 __KERNEL_RCSID(0, "$NetBSD: nfs_socket.c,v 1.167.6.3 2008/09/28 10:41:00 mjf Exp $"); 43 44 #include "fs_nfs.h" 45 #include "opt_nfs.h" 46 #include "opt_nfsserver.h" 47 #include "opt_mbuftrace.h" 48 #include "opt_inet.h" 49 50 #include <sys/param.h> 51 #include <sys/systm.h> 52 #include <sys/evcnt.h> 53 #include <sys/callout.h> 54 #include <sys/proc.h> 55 #include <sys/mount.h> 56 #include <sys/kernel.h> 57 #include <sys/kmem.h> 58 #include <sys/mbuf.h> 59 #include <sys/vnode.h> 60 #include <sys/domain.h> 61 #include <sys/protosw.h> 62 #include <sys/socket.h> 63 #include <sys/socketvar.h> 64 #include <sys/syslog.h> 65 #include <sys/tprintf.h> 66 #include <sys/namei.h> 67 #include <sys/signal.h> 68 #include <sys/signalvar.h> 69 #include <sys/kauth.h> 70 71 #include <netinet/in.h> 72 #include <netinet/tcp.h> 73 74 #include <nfs/rpcv2.h> 75 #include <nfs/nfsproto.h> 76 #include <nfs/nfs.h> 77 #include <nfs/xdr_subs.h> 78 #include <nfs/nfsm_subs.h> 79 #include <nfs/nfsmount.h> 80 #include <nfs/nfsnode.h> 81 #include <nfs/nfsrtt.h> 82 #include <nfs/nfs_var.h> 83 84 #ifdef MBUFTRACE 85 struct mowner nfs_mowner = MOWNER_INIT("nfs",""); 86 #endif 87 88 /* 89 * Estimate rto for an nfs rpc sent via. an unreliable datagram. 90 * Use the mean and mean deviation of rtt for the appropriate type of rpc 91 * for the frequent rpcs and a default for the others. 92 * The justification for doing "other" this way is that these rpcs 93 * happen so infrequently that timer est. would probably be stale. 94 * Also, since many of these rpcs are 95 * non-idempotent, a conservative timeout is desired. 96 * getattr, lookup - A+2D 97 * read, write - A+4D 98 * other - nm_timeo 99 */ 100 #define NFS_RTO(n, t) \ 101 ((t) == 0 ? (n)->nm_timeo : \ 102 ((t) < 3 ? \ 103 (((((n)->nm_srtt[t-1] + 3) >> 2) + (n)->nm_sdrtt[t-1] + 1) >> 1) : \ 104 ((((n)->nm_srtt[t-1] + 7) >> 3) + (n)->nm_sdrtt[t-1] + 1))) 105 #define NFS_SRTT(r) (r)->r_nmp->nm_srtt[proct[(r)->r_procnum] - 1] 106 #define NFS_SDRTT(r) (r)->r_nmp->nm_sdrtt[proct[(r)->r_procnum] - 1] 107 /* 108 * External data, mostly RPC constants in XDR form 109 */ 110 extern u_int32_t rpc_reply, rpc_msgdenied, rpc_mismatch, rpc_vers, 111 rpc_auth_unix, rpc_msgaccepted, rpc_call, rpc_autherr, 112 rpc_auth_kerb; 113 extern u_int32_t nfs_prog; 114 extern const int nfsv3_procid[NFS_NPROCS]; 115 extern int nfs_ticks; 116 117 /* 118 * Defines which timer to use for the procnum. 119 * 0 - default 120 * 1 - getattr 121 * 2 - lookup 122 * 3 - read 123 * 4 - write 124 */ 125 static const int proct[NFS_NPROCS] = { 126 [NFSPROC_NULL] = 0, 127 [NFSPROC_GETATTR] = 1, 128 [NFSPROC_SETATTR] = 0, 129 [NFSPROC_LOOKUP] = 2, 130 [NFSPROC_ACCESS] = 1, 131 [NFSPROC_READLINK] = 3, 132 [NFSPROC_READ] = 3, 133 [NFSPROC_WRITE] = 4, 134 [NFSPROC_CREATE] = 0, 135 [NFSPROC_MKDIR] = 0, 136 [NFSPROC_SYMLINK] = 0, 137 [NFSPROC_MKNOD] = 0, 138 [NFSPROC_REMOVE] = 0, 139 [NFSPROC_RMDIR] = 0, 140 [NFSPROC_RENAME] = 0, 141 [NFSPROC_LINK] = 0, 142 [NFSPROC_READDIR] = 3, 143 [NFSPROC_READDIRPLUS] = 3, 144 [NFSPROC_FSSTAT] = 0, 145 [NFSPROC_FSINFO] = 0, 146 [NFSPROC_PATHCONF] = 0, 147 [NFSPROC_COMMIT] = 0, 148 [NFSPROC_NOOP] = 0, 149 }; 150 151 /* 152 * There is a congestion window for outstanding rpcs maintained per mount 153 * point. The cwnd size is adjusted in roughly the way that: 154 * Van Jacobson, Congestion avoidance and Control, In "Proceedings of 155 * SIGCOMM '88". ACM, August 1988. 156 * describes for TCP. The cwnd size is chopped in half on a retransmit timeout 157 * and incremented by 1/cwnd when each rpc reply is received and a full cwnd 158 * of rpcs is in progress. 159 * (The sent count and cwnd are scaled for integer arith.) 160 * Variants of "slow start" were tried and were found to be too much of a 161 * performance hit (ave. rtt 3 times larger), 162 * I suspect due to the large rtt that nfs rpcs have. 163 */ 164 #define NFS_CWNDSCALE 256 165 #define NFS_MAXCWND (NFS_CWNDSCALE * 32) 166 static const int nfs_backoff[8] = { 2, 4, 8, 16, 32, 64, 128, 256, }; 167 int nfsrtton = 0; 168 struct nfsrtt nfsrtt; 169 struct nfsreqhead nfs_reqq; 170 static callout_t nfs_timer_ch; 171 static struct evcnt nfs_timer_ev; 172 static struct evcnt nfs_timer_start_ev; 173 static struct evcnt nfs_timer_stop_ev; 174 175 static int nfs_sndlock(struct nfsmount *, struct nfsreq *); 176 static void nfs_sndunlock(struct nfsmount *); 177 static int nfs_rcvlock(struct nfsmount *, struct nfsreq *); 178 static void nfs_rcvunlock(struct nfsmount *); 179 180 #if defined(NFSSERVER) 181 static void nfsrv_wakenfsd_locked(struct nfssvc_sock *); 182 #endif /* defined(NFSSERVER) */ 183 184 /* 185 * Initialize sockets and congestion for a new NFS connection. 186 * We do not free the sockaddr if error. 187 */ 188 int 189 nfs_connect(nmp, rep, l) 190 struct nfsmount *nmp; 191 struct nfsreq *rep; 192 struct lwp *l; 193 { 194 struct socket *so; 195 int error, rcvreserve, sndreserve; 196 struct sockaddr *saddr; 197 struct sockaddr_in *sin; 198 #ifdef INET6 199 struct sockaddr_in6 *sin6; 200 #endif 201 struct mbuf *m; 202 int val; 203 204 nmp->nm_so = (struct socket *)0; 205 saddr = mtod(nmp->nm_nam, struct sockaddr *); 206 error = socreate(saddr->sa_family, &nmp->nm_so, 207 nmp->nm_sotype, nmp->nm_soproto, l, NULL); 208 if (error) 209 goto bad; 210 so = nmp->nm_so; 211 #ifdef MBUFTRACE 212 so->so_mowner = &nfs_mowner; 213 so->so_rcv.sb_mowner = &nfs_mowner; 214 so->so_snd.sb_mowner = &nfs_mowner; 215 #endif 216 nmp->nm_soflags = so->so_proto->pr_flags; 217 218 /* 219 * Some servers require that the client port be a reserved port number. 220 */ 221 if (saddr->sa_family == AF_INET && (nmp->nm_flag & NFSMNT_RESVPORT)) { 222 val = IP_PORTRANGE_LOW; 223 224 if ((error = so_setsockopt(NULL, so, IPPROTO_IP, IP_PORTRANGE, 225 &val, sizeof(val)))) 226 goto bad; 227 m = m_get(M_WAIT, MT_SONAME); 228 MCLAIM(m, so->so_mowner); 229 sin = mtod(m, struct sockaddr_in *); 230 sin->sin_len = m->m_len = sizeof (struct sockaddr_in); 231 sin->sin_family = AF_INET; 232 sin->sin_addr.s_addr = INADDR_ANY; 233 sin->sin_port = 0; 234 error = sobind(so, m, &lwp0); 235 m_freem(m); 236 if (error) 237 goto bad; 238 } 239 #ifdef INET6 240 if (saddr->sa_family == AF_INET6 && (nmp->nm_flag & NFSMNT_RESVPORT)) { 241 val = IPV6_PORTRANGE_LOW; 242 243 if ((error = so_setsockopt(NULL, so, IPPROTO_IPV6, 244 IPV6_PORTRANGE, &val, sizeof(val)))) 245 goto bad; 246 m = m_get(M_WAIT, MT_SONAME); 247 MCLAIM(m, so->so_mowner); 248 sin6 = mtod(m, struct sockaddr_in6 *); 249 sin6->sin6_len = m->m_len = sizeof (struct sockaddr_in6); 250 sin6->sin6_family = AF_INET6; 251 sin6->sin6_addr = in6addr_any; 252 sin6->sin6_port = 0; 253 error = sobind(so, m, &lwp0); 254 m_freem(m); 255 if (error) 256 goto bad; 257 } 258 #endif 259 260 /* 261 * Protocols that do not require connections may be optionally left 262 * unconnected for servers that reply from a port other than NFS_PORT. 263 */ 264 solock(so); 265 if (nmp->nm_flag & NFSMNT_NOCONN) { 266 if (nmp->nm_soflags & PR_CONNREQUIRED) { 267 sounlock(so); 268 error = ENOTCONN; 269 goto bad; 270 } 271 } else { 272 error = soconnect(so, nmp->nm_nam, l); 273 if (error) { 274 sounlock(so); 275 goto bad; 276 } 277 278 /* 279 * Wait for the connection to complete. Cribbed from the 280 * connect system call but with the wait timing out so 281 * that interruptible mounts don't hang here for a long time. 282 */ 283 while ((so->so_state & SS_ISCONNECTING) && so->so_error == 0) { 284 (void)sowait(so, 2 * hz); 285 if ((so->so_state & SS_ISCONNECTING) && 286 so->so_error == 0 && rep && 287 (error = nfs_sigintr(nmp, rep, rep->r_lwp)) != 0){ 288 so->so_state &= ~SS_ISCONNECTING; 289 sounlock(so); 290 goto bad; 291 } 292 } 293 if (so->so_error) { 294 error = so->so_error; 295 so->so_error = 0; 296 sounlock(so); 297 goto bad; 298 } 299 } 300 if (nmp->nm_flag & (NFSMNT_SOFT | NFSMNT_INT)) { 301 so->so_rcv.sb_timeo = (5 * hz); 302 so->so_snd.sb_timeo = (5 * hz); 303 } else { 304 /* 305 * enable receive timeout to detect server crash and reconnect. 306 * otherwise, we can be stuck in soreceive forever. 307 */ 308 so->so_rcv.sb_timeo = (5 * hz); 309 so->so_snd.sb_timeo = 0; 310 } 311 if (nmp->nm_sotype == SOCK_DGRAM) { 312 sndreserve = (nmp->nm_wsize + NFS_MAXPKTHDR) * 2; 313 rcvreserve = (max(nmp->nm_rsize, nmp->nm_readdirsize) + 314 NFS_MAXPKTHDR) * 2; 315 } else if (nmp->nm_sotype == SOCK_SEQPACKET) { 316 sndreserve = (nmp->nm_wsize + NFS_MAXPKTHDR) * 2; 317 rcvreserve = (max(nmp->nm_rsize, nmp->nm_readdirsize) + 318 NFS_MAXPKTHDR) * 2; 319 } else { 320 sounlock(so); 321 if (nmp->nm_sotype != SOCK_STREAM) 322 panic("nfscon sotype"); 323 if (so->so_proto->pr_flags & PR_CONNREQUIRED) { 324 val = 1; 325 so_setsockopt(NULL, so, SOL_SOCKET, SO_KEEPALIVE, &val, 326 sizeof(val)); 327 } 328 if (so->so_proto->pr_protocol == IPPROTO_TCP) { 329 val = 1; 330 so_setsockopt(NULL, so, IPPROTO_TCP, TCP_NODELAY, &val, 331 sizeof(val)); 332 } 333 sndreserve = (nmp->nm_wsize + NFS_MAXPKTHDR + 334 sizeof (u_int32_t)) * 2; 335 rcvreserve = (nmp->nm_rsize + NFS_MAXPKTHDR + 336 sizeof (u_int32_t)) * 2; 337 solock(so); 338 } 339 error = soreserve(so, sndreserve, rcvreserve); 340 if (error) { 341 sounlock(so); 342 goto bad; 343 } 344 so->so_rcv.sb_flags |= SB_NOINTR; 345 so->so_snd.sb_flags |= SB_NOINTR; 346 sounlock(so); 347 348 /* Initialize other non-zero congestion variables */ 349 nmp->nm_srtt[0] = nmp->nm_srtt[1] = nmp->nm_srtt[2] = nmp->nm_srtt[3] = 350 NFS_TIMEO << 3; 351 nmp->nm_sdrtt[0] = nmp->nm_sdrtt[1] = nmp->nm_sdrtt[2] = 352 nmp->nm_sdrtt[3] = 0; 353 nmp->nm_cwnd = NFS_MAXCWND / 2; /* Initial send window */ 354 nmp->nm_sent = 0; 355 nmp->nm_timeouts = 0; 356 return (0); 357 358 bad: 359 nfs_disconnect(nmp); 360 return (error); 361 } 362 363 /* 364 * Reconnect routine: 365 * Called when a connection is broken on a reliable protocol. 366 * - clean up the old socket 367 * - nfs_connect() again 368 * - set R_MUSTRESEND for all outstanding requests on mount point 369 * If this fails the mount point is DEAD! 370 * nb: Must be called with the nfs_sndlock() set on the mount point. 371 */ 372 int 373 nfs_reconnect(struct nfsreq *rep) 374 { 375 struct nfsreq *rp; 376 struct nfsmount *nmp = rep->r_nmp; 377 int error; 378 379 nfs_disconnect(nmp); 380 while ((error = nfs_connect(nmp, rep, &lwp0)) != 0) { 381 if (error == EINTR || error == ERESTART) 382 return (EINTR); 383 kpause("nfscn2", false, hz, NULL); 384 } 385 386 /* 387 * Loop through outstanding request list and fix up all requests 388 * on old socket. 389 */ 390 TAILQ_FOREACH(rp, &nfs_reqq, r_chain) { 391 if (rp->r_nmp == nmp) { 392 if ((rp->r_flags & R_MUSTRESEND) == 0) 393 rp->r_flags |= R_MUSTRESEND | R_REXMITTED; 394 rp->r_rexmit = 0; 395 } 396 } 397 return (0); 398 } 399 400 /* 401 * NFS disconnect. Clean up and unlink. 402 */ 403 void 404 nfs_disconnect(nmp) 405 struct nfsmount *nmp; 406 { 407 struct socket *so; 408 int drain = 0; 409 410 if (nmp->nm_so) { 411 so = nmp->nm_so; 412 nmp->nm_so = (struct socket *)0; 413 solock(so); 414 soshutdown(so, SHUT_RDWR); 415 sounlock(so); 416 drain = (nmp->nm_iflag & NFSMNT_DISMNT) != 0; 417 if (drain) { 418 /* 419 * soshutdown() above should wake up the current 420 * listener. 421 * Now wake up those waiting for the receive lock, and 422 * wait for them to go away unhappy, to prevent *nmp 423 * from evaporating while they're sleeping. 424 */ 425 mutex_enter(&nmp->nm_lock); 426 while (nmp->nm_waiters > 0) { 427 cv_broadcast(&nmp->nm_rcvcv); 428 cv_broadcast(&nmp->nm_sndcv); 429 cv_wait(&nmp->nm_disconcv, &nmp->nm_lock); 430 } 431 mutex_exit(&nmp->nm_lock); 432 } 433 soclose(so); 434 } 435 #ifdef DIAGNOSTIC 436 if (drain && (nmp->nm_waiters > 0)) 437 panic("nfs_disconnect: waiters left after drain?"); 438 #endif 439 } 440 441 void 442 nfs_safedisconnect(nmp) 443 struct nfsmount *nmp; 444 { 445 struct nfsreq dummyreq; 446 447 memset(&dummyreq, 0, sizeof(dummyreq)); 448 dummyreq.r_nmp = nmp; 449 nfs_rcvlock(nmp, &dummyreq); /* XXX ignored error return */ 450 nfs_disconnect(nmp); 451 nfs_rcvunlock(nmp); 452 } 453 454 /* 455 * This is the nfs send routine. For connection based socket types, it 456 * must be called with an nfs_sndlock() on the socket. 457 * "rep == NULL" indicates that it has been called from a server. 458 * For the client side: 459 * - return EINTR if the RPC is terminated, 0 otherwise 460 * - set R_MUSTRESEND if the send fails for any reason 461 * - do any cleanup required by recoverable socket errors (? ? ?) 462 * For the server side: 463 * - return EINTR or ERESTART if interrupted by a signal 464 * - return EPIPE if a connection is lost for connection based sockets (TCP...) 465 * - do any cleanup required by recoverable socket errors (? ? ?) 466 */ 467 int 468 nfs_send(so, nam, top, rep, l) 469 struct socket *so; 470 struct mbuf *nam; 471 struct mbuf *top; 472 struct nfsreq *rep; 473 struct lwp *l; 474 { 475 struct mbuf *sendnam; 476 int error, soflags, flags; 477 478 /* XXX nfs_doio()/nfs_request() calls with rep->r_lwp == NULL */ 479 if (l == NULL && rep->r_lwp == NULL) 480 l = curlwp; 481 482 if (rep) { 483 if (rep->r_flags & R_SOFTTERM) { 484 m_freem(top); 485 return (EINTR); 486 } 487 if ((so = rep->r_nmp->nm_so) == NULL) { 488 rep->r_flags |= R_MUSTRESEND; 489 m_freem(top); 490 return (0); 491 } 492 rep->r_flags &= ~R_MUSTRESEND; 493 soflags = rep->r_nmp->nm_soflags; 494 } else 495 soflags = so->so_proto->pr_flags; 496 if ((soflags & PR_CONNREQUIRED) || (so->so_state & SS_ISCONNECTED)) 497 sendnam = (struct mbuf *)0; 498 else 499 sendnam = nam; 500 if (so->so_type == SOCK_SEQPACKET) 501 flags = MSG_EOR; 502 else 503 flags = 0; 504 505 error = (*so->so_send)(so, sendnam, NULL, top, NULL, flags, l); 506 if (error) { 507 if (rep) { 508 if (error == ENOBUFS && so->so_type == SOCK_DGRAM) { 509 /* 510 * We're too fast for the network/driver, 511 * and UDP isn't flowcontrolled. 512 * We need to resend. This is not fatal, 513 * just try again. 514 * 515 * Could be smarter here by doing some sort 516 * of a backoff, but this is rare. 517 */ 518 rep->r_flags |= R_MUSTRESEND; 519 } else { 520 if (error != EPIPE) 521 log(LOG_INFO, 522 "nfs send error %d for %s\n", 523 error, 524 rep->r_nmp->nm_mountp-> 525 mnt_stat.f_mntfromname); 526 /* 527 * Deal with errors for the client side. 528 */ 529 if (rep->r_flags & R_SOFTTERM) 530 error = EINTR; 531 else 532 rep->r_flags |= R_MUSTRESEND; 533 } 534 } else { 535 /* 536 * See above. This error can happen under normal 537 * circumstances and the log is too noisy. 538 * The error will still show up in nfsstat. 539 */ 540 if (error != ENOBUFS || so->so_type != SOCK_DGRAM) 541 log(LOG_INFO, "nfsd send error %d\n", error); 542 } 543 544 /* 545 * Handle any recoverable (soft) socket errors here. (? ? ?) 546 */ 547 if (error != EINTR && error != ERESTART && 548 error != EWOULDBLOCK && error != EPIPE) 549 error = 0; 550 } 551 return (error); 552 } 553 554 #ifdef NFS 555 /* 556 * Receive a Sun RPC Request/Reply. For SOCK_DGRAM, the work is all 557 * done by soreceive(), but for SOCK_STREAM we must deal with the Record 558 * Mark and consolidate the data into a new mbuf list. 559 * nb: Sometimes TCP passes the data up to soreceive() in long lists of 560 * small mbufs. 561 * For SOCK_STREAM we must be very careful to read an entire record once 562 * we have read any of it, even if the system call has been interrupted. 563 */ 564 static int 565 nfs_receive(struct nfsreq *rep, struct mbuf **aname, struct mbuf **mp, 566 struct lwp *l) 567 { 568 struct socket *so; 569 struct uio auio; 570 struct iovec aio; 571 struct mbuf *m; 572 struct mbuf *control; 573 u_int32_t len; 574 struct mbuf **getnam; 575 int error, sotype, rcvflg; 576 577 /* 578 * Set up arguments for soreceive() 579 */ 580 *mp = (struct mbuf *)0; 581 *aname = (struct mbuf *)0; 582 sotype = rep->r_nmp->nm_sotype; 583 584 /* 585 * For reliable protocols, lock against other senders/receivers 586 * in case a reconnect is necessary. 587 * For SOCK_STREAM, first get the Record Mark to find out how much 588 * more there is to get. 589 * We must lock the socket against other receivers 590 * until we have an entire rpc request/reply. 591 */ 592 if (sotype != SOCK_DGRAM) { 593 error = nfs_sndlock(rep->r_nmp, rep); 594 if (error) 595 return (error); 596 tryagain: 597 /* 598 * Check for fatal errors and resending request. 599 */ 600 /* 601 * Ugh: If a reconnect attempt just happened, nm_so 602 * would have changed. NULL indicates a failed 603 * attempt that has essentially shut down this 604 * mount point. 605 */ 606 if (rep->r_mrep || (rep->r_flags & R_SOFTTERM)) { 607 nfs_sndunlock(rep->r_nmp); 608 return (EINTR); 609 } 610 so = rep->r_nmp->nm_so; 611 if (!so) { 612 error = nfs_reconnect(rep); 613 if (error) { 614 nfs_sndunlock(rep->r_nmp); 615 return (error); 616 } 617 goto tryagain; 618 } 619 while (rep->r_flags & R_MUSTRESEND) { 620 m = m_copym(rep->r_mreq, 0, M_COPYALL, M_WAIT); 621 nfsstats.rpcretries++; 622 rep->r_rtt = 0; 623 rep->r_flags &= ~R_TIMING; 624 error = nfs_send(so, rep->r_nmp->nm_nam, m, rep, l); 625 if (error) { 626 if (error == EINTR || error == ERESTART || 627 (error = nfs_reconnect(rep)) != 0) { 628 nfs_sndunlock(rep->r_nmp); 629 return (error); 630 } 631 goto tryagain; 632 } 633 } 634 nfs_sndunlock(rep->r_nmp); 635 if (sotype == SOCK_STREAM) { 636 aio.iov_base = (void *) &len; 637 aio.iov_len = sizeof(u_int32_t); 638 auio.uio_iov = &aio; 639 auio.uio_iovcnt = 1; 640 auio.uio_rw = UIO_READ; 641 auio.uio_offset = 0; 642 auio.uio_resid = sizeof(u_int32_t); 643 UIO_SETUP_SYSSPACE(&auio); 644 do { 645 rcvflg = MSG_WAITALL; 646 error = (*so->so_receive)(so, (struct mbuf **)0, &auio, 647 (struct mbuf **)0, (struct mbuf **)0, &rcvflg); 648 if (error == EWOULDBLOCK && rep) { 649 if (rep->r_flags & R_SOFTTERM) 650 return (EINTR); 651 /* 652 * if it seems that the server died after it 653 * received our request, set EPIPE so that 654 * we'll reconnect and retransmit requests. 655 */ 656 if (rep->r_rexmit >= rep->r_nmp->nm_retry) { 657 nfsstats.rpctimeouts++; 658 error = EPIPE; 659 } 660 } 661 } while (error == EWOULDBLOCK); 662 if (!error && auio.uio_resid > 0) { 663 /* 664 * Don't log a 0 byte receive; it means 665 * that the socket has been closed, and 666 * can happen during normal operation 667 * (forcible unmount or Solaris server). 668 */ 669 if (auio.uio_resid != sizeof (u_int32_t)) 670 log(LOG_INFO, 671 "short receive (%lu/%lu) from nfs server %s\n", 672 (u_long)sizeof(u_int32_t) - auio.uio_resid, 673 (u_long)sizeof(u_int32_t), 674 rep->r_nmp->nm_mountp->mnt_stat.f_mntfromname); 675 error = EPIPE; 676 } 677 if (error) 678 goto errout; 679 len = ntohl(len) & ~0x80000000; 680 /* 681 * This is SERIOUS! We are out of sync with the sender 682 * and forcing a disconnect/reconnect is all I can do. 683 */ 684 if (len > NFS_MAXPACKET) { 685 log(LOG_ERR, "%s (%d) from nfs server %s\n", 686 "impossible packet length", 687 len, 688 rep->r_nmp->nm_mountp->mnt_stat.f_mntfromname); 689 error = EFBIG; 690 goto errout; 691 } 692 auio.uio_resid = len; 693 do { 694 rcvflg = MSG_WAITALL; 695 error = (*so->so_receive)(so, (struct mbuf **)0, 696 &auio, mp, (struct mbuf **)0, &rcvflg); 697 } while (error == EWOULDBLOCK || error == EINTR || 698 error == ERESTART); 699 if (!error && auio.uio_resid > 0) { 700 if (len != auio.uio_resid) 701 log(LOG_INFO, 702 "short receive (%lu/%d) from nfs server %s\n", 703 (u_long)len - auio.uio_resid, len, 704 rep->r_nmp->nm_mountp->mnt_stat.f_mntfromname); 705 error = EPIPE; 706 } 707 } else { 708 /* 709 * NB: Since uio_resid is big, MSG_WAITALL is ignored 710 * and soreceive() will return when it has either a 711 * control msg or a data msg. 712 * We have no use for control msg., but must grab them 713 * and then throw them away so we know what is going 714 * on. 715 */ 716 auio.uio_resid = len = 100000000; /* Anything Big */ 717 /* not need to setup uio_vmspace */ 718 do { 719 rcvflg = 0; 720 error = (*so->so_receive)(so, (struct mbuf **)0, 721 &auio, mp, &control, &rcvflg); 722 if (control) 723 m_freem(control); 724 if (error == EWOULDBLOCK && rep) { 725 if (rep->r_flags & R_SOFTTERM) 726 return (EINTR); 727 } 728 } while (error == EWOULDBLOCK || 729 (!error && *mp == NULL && control)); 730 if ((rcvflg & MSG_EOR) == 0) 731 printf("Egad!!\n"); 732 if (!error && *mp == NULL) 733 error = EPIPE; 734 len -= auio.uio_resid; 735 } 736 errout: 737 if (error && error != EINTR && error != ERESTART) { 738 m_freem(*mp); 739 *mp = (struct mbuf *)0; 740 if (error != EPIPE) 741 log(LOG_INFO, 742 "receive error %d from nfs server %s\n", 743 error, 744 rep->r_nmp->nm_mountp->mnt_stat.f_mntfromname); 745 error = nfs_sndlock(rep->r_nmp, rep); 746 if (!error) 747 error = nfs_reconnect(rep); 748 if (!error) 749 goto tryagain; 750 else 751 nfs_sndunlock(rep->r_nmp); 752 } 753 } else { 754 if ((so = rep->r_nmp->nm_so) == NULL) 755 return (EACCES); 756 if (so->so_state & SS_ISCONNECTED) 757 getnam = (struct mbuf **)0; 758 else 759 getnam = aname; 760 auio.uio_resid = len = 1000000; 761 /* not need to setup uio_vmspace */ 762 do { 763 rcvflg = 0; 764 error = (*so->so_receive)(so, getnam, &auio, mp, 765 (struct mbuf **)0, &rcvflg); 766 if (error == EWOULDBLOCK && 767 (rep->r_flags & R_SOFTTERM)) 768 return (EINTR); 769 } while (error == EWOULDBLOCK); 770 len -= auio.uio_resid; 771 if (!error && *mp == NULL) 772 error = EPIPE; 773 } 774 if (error) { 775 m_freem(*mp); 776 *mp = (struct mbuf *)0; 777 } 778 return (error); 779 } 780 781 /* 782 * Implement receipt of reply on a socket. 783 * We must search through the list of received datagrams matching them 784 * with outstanding requests using the xid, until ours is found. 785 */ 786 /* ARGSUSED */ 787 static int 788 nfs_reply(struct nfsreq *myrep, struct lwp *lwp) 789 { 790 struct nfsreq *rep; 791 struct nfsmount *nmp = myrep->r_nmp; 792 int32_t t1; 793 struct mbuf *mrep, *nam, *md; 794 u_int32_t rxid, *tl; 795 char *dpos, *cp2; 796 int error; 797 798 /* 799 * Loop around until we get our own reply 800 */ 801 for (;;) { 802 /* 803 * Lock against other receivers so that I don't get stuck in 804 * sbwait() after someone else has received my reply for me. 805 * Also necessary for connection based protocols to avoid 806 * race conditions during a reconnect. 807 */ 808 error = nfs_rcvlock(nmp, myrep); 809 if (error == EALREADY) 810 return (0); 811 if (error) 812 return (error); 813 /* 814 * Get the next Rpc reply off the socket 815 */ 816 817 mutex_enter(&nmp->nm_lock); 818 nmp->nm_waiters++; 819 mutex_exit(&nmp->nm_lock); 820 821 error = nfs_receive(myrep, &nam, &mrep, lwp); 822 823 mutex_enter(&nmp->nm_lock); 824 nmp->nm_waiters--; 825 cv_signal(&nmp->nm_disconcv); 826 mutex_exit(&nmp->nm_lock); 827 828 if (error) { 829 nfs_rcvunlock(nmp); 830 831 if (nmp->nm_iflag & NFSMNT_DISMNT) { 832 /* 833 * Oops, we're going away now.. 834 */ 835 return error; 836 } 837 /* 838 * Ignore routing errors on connectionless protocols? ? 839 */ 840 if (NFSIGNORE_SOERROR(nmp->nm_soflags, error)) { 841 nmp->nm_so->so_error = 0; 842 #ifdef DEBUG 843 printf("nfs_reply: ignoring error %d\n", error); 844 #endif 845 continue; 846 } 847 return (error); 848 } 849 if (nam) 850 m_freem(nam); 851 852 /* 853 * Get the xid and check that it is an rpc reply 854 */ 855 md = mrep; 856 dpos = mtod(md, void *); 857 nfsm_dissect(tl, u_int32_t *, 2*NFSX_UNSIGNED); 858 rxid = *tl++; 859 if (*tl != rpc_reply) { 860 nfsstats.rpcinvalid++; 861 m_freem(mrep); 862 nfsmout: 863 nfs_rcvunlock(nmp); 864 continue; 865 } 866 867 /* 868 * Loop through the request list to match up the reply 869 * Iff no match, just drop the datagram 870 */ 871 TAILQ_FOREACH(rep, &nfs_reqq, r_chain) { 872 if (rep->r_mrep == NULL && rxid == rep->r_xid) { 873 /* Found it.. */ 874 rep->r_mrep = mrep; 875 rep->r_md = md; 876 rep->r_dpos = dpos; 877 if (nfsrtton) { 878 struct rttl *rt; 879 880 rt = &nfsrtt.rttl[nfsrtt.pos]; 881 rt->proc = rep->r_procnum; 882 rt->rto = NFS_RTO(nmp, proct[rep->r_procnum]); 883 rt->sent = nmp->nm_sent; 884 rt->cwnd = nmp->nm_cwnd; 885 rt->srtt = nmp->nm_srtt[proct[rep->r_procnum] - 1]; 886 rt->sdrtt = nmp->nm_sdrtt[proct[rep->r_procnum] - 1]; 887 rt->fsid = nmp->nm_mountp->mnt_stat.f_fsidx; 888 getmicrotime(&rt->tstamp); 889 if (rep->r_flags & R_TIMING) 890 rt->rtt = rep->r_rtt; 891 else 892 rt->rtt = 1000000; 893 nfsrtt.pos = (nfsrtt.pos + 1) % NFSRTTLOGSIZ; 894 } 895 /* 896 * Update congestion window. 897 * Do the additive increase of 898 * one rpc/rtt. 899 */ 900 if (nmp->nm_cwnd <= nmp->nm_sent) { 901 nmp->nm_cwnd += 902 (NFS_CWNDSCALE * NFS_CWNDSCALE + 903 (nmp->nm_cwnd >> 1)) / nmp->nm_cwnd; 904 if (nmp->nm_cwnd > NFS_MAXCWND) 905 nmp->nm_cwnd = NFS_MAXCWND; 906 } 907 rep->r_flags &= ~R_SENT; 908 nmp->nm_sent -= NFS_CWNDSCALE; 909 /* 910 * Update rtt using a gain of 0.125 on the mean 911 * and a gain of 0.25 on the deviation. 912 */ 913 if (rep->r_flags & R_TIMING) { 914 /* 915 * Since the timer resolution of 916 * NFS_HZ is so course, it can often 917 * result in r_rtt == 0. Since 918 * r_rtt == N means that the actual 919 * rtt is between N+dt and N+2-dt ticks, 920 * add 1. 921 */ 922 t1 = rep->r_rtt + 1; 923 t1 -= (NFS_SRTT(rep) >> 3); 924 NFS_SRTT(rep) += t1; 925 if (t1 < 0) 926 t1 = -t1; 927 t1 -= (NFS_SDRTT(rep) >> 2); 928 NFS_SDRTT(rep) += t1; 929 } 930 nmp->nm_timeouts = 0; 931 break; 932 } 933 } 934 nfs_rcvunlock(nmp); 935 /* 936 * If not matched to a request, drop it. 937 * If it's mine, get out. 938 */ 939 if (rep == 0) { 940 nfsstats.rpcunexpected++; 941 m_freem(mrep); 942 } else if (rep == myrep) { 943 if (rep->r_mrep == NULL) 944 panic("nfsreply nil"); 945 return (0); 946 } 947 } 948 } 949 950 /* 951 * nfs_request - goes something like this 952 * - fill in request struct 953 * - links it into list 954 * - calls nfs_send() for first transmit 955 * - calls nfs_receive() to get reply 956 * - break down rpc header and return with nfs reply pointed to 957 * by mrep or error 958 * nb: always frees up mreq mbuf list 959 */ 960 int 961 nfs_request(np, mrest, procnum, lwp, cred, mrp, mdp, dposp, rexmitp) 962 struct nfsnode *np; 963 struct mbuf *mrest; 964 int procnum; 965 struct lwp *lwp; 966 kauth_cred_t cred; 967 struct mbuf **mrp; 968 struct mbuf **mdp; 969 char **dposp; 970 int *rexmitp; 971 { 972 struct mbuf *m, *mrep; 973 struct nfsreq *rep; 974 u_int32_t *tl; 975 int i; 976 struct nfsmount *nmp = VFSTONFS(np->n_vnode->v_mount); 977 struct mbuf *md, *mheadend; 978 char nickv[RPCX_NICKVERF]; 979 time_t waituntil; 980 char *dpos, *cp2; 981 int t1, s, error = 0, mrest_len, auth_len, auth_type; 982 int trylater_delay = NFS_TRYLATERDEL, failed_auth = 0; 983 int verf_len, verf_type; 984 u_int32_t xid; 985 char *auth_str, *verf_str; 986 NFSKERBKEY_T key; /* save session key */ 987 kauth_cred_t acred; 988 struct mbuf *mrest_backup = NULL; 989 kauth_cred_t origcred = NULL; /* XXX: gcc */ 990 bool retry_cred = true; 991 bool use_opencred = (np->n_flag & NUSEOPENCRED) != 0; 992 993 if (rexmitp != NULL) 994 *rexmitp = 0; 995 996 acred = kauth_cred_alloc(); 997 998 tryagain_cred: 999 KASSERT(cred != NULL); 1000 rep = kmem_alloc(sizeof(*rep), KM_SLEEP); 1001 rep->r_nmp = nmp; 1002 KASSERT(lwp == NULL || lwp == curlwp); 1003 rep->r_lwp = lwp; 1004 rep->r_procnum = procnum; 1005 i = 0; 1006 m = mrest; 1007 while (m) { 1008 i += m->m_len; 1009 m = m->m_next; 1010 } 1011 mrest_len = i; 1012 1013 /* 1014 * Get the RPC header with authorization. 1015 */ 1016 kerbauth: 1017 verf_str = auth_str = (char *)0; 1018 if (nmp->nm_flag & NFSMNT_KERB) { 1019 verf_str = nickv; 1020 verf_len = sizeof (nickv); 1021 auth_type = RPCAUTH_KERB4; 1022 memset((void *)key, 0, sizeof (key)); 1023 if (failed_auth || nfs_getnickauth(nmp, cred, &auth_str, 1024 &auth_len, verf_str, verf_len)) { 1025 error = nfs_getauth(nmp, rep, cred, &auth_str, 1026 &auth_len, verf_str, &verf_len, key); 1027 if (error) { 1028 kmem_free(rep, sizeof(*rep)); 1029 m_freem(mrest); 1030 KASSERT(kauth_cred_getrefcnt(acred) == 1); 1031 kauth_cred_free(acred); 1032 return (error); 1033 } 1034 } 1035 retry_cred = false; 1036 } else { 1037 /* AUTH_UNIX */ 1038 uid_t uid; 1039 gid_t gid; 1040 1041 /* 1042 * on the most unix filesystems, permission checks are 1043 * done when the file is open(2)'ed. 1044 * ie. once a file is successfully open'ed, 1045 * following i/o operations never fail with EACCES. 1046 * we try to follow the semantics as far as possible. 1047 * 1048 * note that we expect that the nfs server always grant 1049 * accesses by the file's owner. 1050 */ 1051 origcred = cred; 1052 switch (procnum) { 1053 case NFSPROC_READ: 1054 case NFSPROC_WRITE: 1055 case NFSPROC_COMMIT: 1056 uid = np->n_vattr->va_uid; 1057 gid = np->n_vattr->va_gid; 1058 if (kauth_cred_geteuid(cred) == uid && 1059 kauth_cred_getegid(cred) == gid) { 1060 retry_cred = false; 1061 break; 1062 } 1063 if (use_opencred) 1064 break; 1065 kauth_cred_setuid(acred, uid); 1066 kauth_cred_seteuid(acred, uid); 1067 kauth_cred_setsvuid(acred, uid); 1068 kauth_cred_setgid(acred, gid); 1069 kauth_cred_setegid(acred, gid); 1070 kauth_cred_setsvgid(acred, gid); 1071 cred = acred; 1072 break; 1073 default: 1074 retry_cred = false; 1075 break; 1076 } 1077 /* 1078 * backup mbuf chain if we can need it later to retry. 1079 * 1080 * XXX maybe we can keep a direct reference to 1081 * mrest without doing m_copym, but it's ...ugly. 1082 */ 1083 if (retry_cred) 1084 mrest_backup = m_copym(mrest, 0, M_COPYALL, M_WAIT); 1085 auth_type = RPCAUTH_UNIX; 1086 /* XXX elad - ngroups */ 1087 auth_len = (((kauth_cred_ngroups(cred) > nmp->nm_numgrps) ? 1088 nmp->nm_numgrps : kauth_cred_ngroups(cred)) << 2) + 1089 5 * NFSX_UNSIGNED; 1090 } 1091 m = nfsm_rpchead(cred, nmp->nm_flag, procnum, auth_type, auth_len, 1092 auth_str, verf_len, verf_str, mrest, mrest_len, &mheadend, &xid); 1093 if (auth_str) 1094 free(auth_str, M_TEMP); 1095 1096 /* 1097 * For stream protocols, insert a Sun RPC Record Mark. 1098 */ 1099 if (nmp->nm_sotype == SOCK_STREAM) { 1100 M_PREPEND(m, NFSX_UNSIGNED, M_WAIT); 1101 *mtod(m, u_int32_t *) = htonl(0x80000000 | 1102 (m->m_pkthdr.len - NFSX_UNSIGNED)); 1103 } 1104 rep->r_mreq = m; 1105 rep->r_xid = xid; 1106 tryagain: 1107 if (nmp->nm_flag & NFSMNT_SOFT) 1108 rep->r_retry = nmp->nm_retry; 1109 else 1110 rep->r_retry = NFS_MAXREXMIT + 1; /* past clip limit */ 1111 rep->r_rtt = rep->r_rexmit = 0; 1112 if (proct[procnum] > 0) 1113 rep->r_flags = R_TIMING; 1114 else 1115 rep->r_flags = 0; 1116 rep->r_mrep = NULL; 1117 1118 /* 1119 * Do the client side RPC. 1120 */ 1121 nfsstats.rpcrequests++; 1122 /* 1123 * Chain request into list of outstanding requests. Be sure 1124 * to put it LAST so timer finds oldest requests first. 1125 */ 1126 s = splsoftnet(); 1127 TAILQ_INSERT_TAIL(&nfs_reqq, rep, r_chain); 1128 nfs_timer_start(); 1129 1130 /* 1131 * If backing off another request or avoiding congestion, don't 1132 * send this one now but let timer do it. If not timing a request, 1133 * do it now. 1134 */ 1135 if (nmp->nm_so && (nmp->nm_sotype != SOCK_DGRAM || 1136 (nmp->nm_flag & NFSMNT_DUMBTIMR) || nmp->nm_sent < nmp->nm_cwnd)) { 1137 splx(s); 1138 if (nmp->nm_soflags & PR_CONNREQUIRED) 1139 error = nfs_sndlock(nmp, rep); 1140 if (!error) { 1141 m = m_copym(rep->r_mreq, 0, M_COPYALL, M_WAIT); 1142 error = nfs_send(nmp->nm_so, nmp->nm_nam, m, rep, lwp); 1143 if (nmp->nm_soflags & PR_CONNREQUIRED) 1144 nfs_sndunlock(nmp); 1145 } 1146 if (!error && (rep->r_flags & R_MUSTRESEND) == 0) { 1147 nmp->nm_sent += NFS_CWNDSCALE; 1148 rep->r_flags |= R_SENT; 1149 } 1150 } else { 1151 splx(s); 1152 rep->r_rtt = -1; 1153 } 1154 1155 /* 1156 * Wait for the reply from our send or the timer's. 1157 */ 1158 if (!error || error == EPIPE) 1159 error = nfs_reply(rep, lwp); 1160 1161 /* 1162 * RPC done, unlink the request. 1163 */ 1164 s = splsoftnet(); 1165 TAILQ_REMOVE(&nfs_reqq, rep, r_chain); 1166 splx(s); 1167 1168 /* 1169 * Decrement the outstanding request count. 1170 */ 1171 if (rep->r_flags & R_SENT) { 1172 rep->r_flags &= ~R_SENT; /* paranoia */ 1173 nmp->nm_sent -= NFS_CWNDSCALE; 1174 } 1175 1176 if (rexmitp != NULL) { 1177 int rexmit; 1178 1179 if (nmp->nm_sotype != SOCK_DGRAM) 1180 rexmit = (rep->r_flags & R_REXMITTED) != 0; 1181 else 1182 rexmit = rep->r_rexmit; 1183 *rexmitp = rexmit; 1184 } 1185 1186 /* 1187 * If there was a successful reply and a tprintf msg. 1188 * tprintf a response. 1189 */ 1190 if (!error && (rep->r_flags & R_TPRINTFMSG)) 1191 nfs_msg(rep->r_lwp, nmp->nm_mountp->mnt_stat.f_mntfromname, 1192 "is alive again"); 1193 mrep = rep->r_mrep; 1194 md = rep->r_md; 1195 dpos = rep->r_dpos; 1196 if (error) 1197 goto nfsmout; 1198 1199 /* 1200 * break down the rpc header and check if ok 1201 */ 1202 nfsm_dissect(tl, u_int32_t *, 3 * NFSX_UNSIGNED); 1203 if (*tl++ == rpc_msgdenied) { 1204 if (*tl == rpc_mismatch) 1205 error = EOPNOTSUPP; 1206 else if ((nmp->nm_flag & NFSMNT_KERB) && *tl++ == rpc_autherr) { 1207 if (!failed_auth) { 1208 failed_auth++; 1209 mheadend->m_next = (struct mbuf *)0; 1210 m_freem(mrep); 1211 m_freem(rep->r_mreq); 1212 goto kerbauth; 1213 } else 1214 error = EAUTH; 1215 } else 1216 error = EACCES; 1217 m_freem(mrep); 1218 goto nfsmout; 1219 } 1220 1221 /* 1222 * Grab any Kerberos verifier, otherwise just throw it away. 1223 */ 1224 verf_type = fxdr_unsigned(int, *tl++); 1225 i = fxdr_unsigned(int32_t, *tl); 1226 if ((nmp->nm_flag & NFSMNT_KERB) && verf_type == RPCAUTH_KERB4) { 1227 error = nfs_savenickauth(nmp, cred, i, key, &md, &dpos, mrep); 1228 if (error) 1229 goto nfsmout; 1230 } else if (i > 0) 1231 nfsm_adv(nfsm_rndup(i)); 1232 nfsm_dissect(tl, u_int32_t *, NFSX_UNSIGNED); 1233 /* 0 == ok */ 1234 if (*tl == 0) { 1235 nfsm_dissect(tl, u_int32_t *, NFSX_UNSIGNED); 1236 if (*tl != 0) { 1237 error = fxdr_unsigned(int, *tl); 1238 switch (error) { 1239 case NFSERR_PERM: 1240 error = EPERM; 1241 break; 1242 1243 case NFSERR_NOENT: 1244 error = ENOENT; 1245 break; 1246 1247 case NFSERR_IO: 1248 error = EIO; 1249 break; 1250 1251 case NFSERR_NXIO: 1252 error = ENXIO; 1253 break; 1254 1255 case NFSERR_ACCES: 1256 error = EACCES; 1257 if (!retry_cred) 1258 break; 1259 m_freem(mrep); 1260 m_freem(rep->r_mreq); 1261 kmem_free(rep, sizeof(*rep)); 1262 use_opencred = !use_opencred; 1263 if (mrest_backup == NULL) { 1264 /* m_copym failure */ 1265 KASSERT( 1266 kauth_cred_getrefcnt(acred) == 1); 1267 kauth_cred_free(acred); 1268 return ENOMEM; 1269 } 1270 mrest = mrest_backup; 1271 mrest_backup = NULL; 1272 cred = origcred; 1273 error = 0; 1274 retry_cred = false; 1275 goto tryagain_cred; 1276 1277 case NFSERR_EXIST: 1278 error = EEXIST; 1279 break; 1280 1281 case NFSERR_XDEV: 1282 error = EXDEV; 1283 break; 1284 1285 case NFSERR_NODEV: 1286 error = ENODEV; 1287 break; 1288 1289 case NFSERR_NOTDIR: 1290 error = ENOTDIR; 1291 break; 1292 1293 case NFSERR_ISDIR: 1294 error = EISDIR; 1295 break; 1296 1297 case NFSERR_INVAL: 1298 error = EINVAL; 1299 break; 1300 1301 case NFSERR_FBIG: 1302 error = EFBIG; 1303 break; 1304 1305 case NFSERR_NOSPC: 1306 error = ENOSPC; 1307 break; 1308 1309 case NFSERR_ROFS: 1310 error = EROFS; 1311 break; 1312 1313 case NFSERR_MLINK: 1314 error = EMLINK; 1315 break; 1316 1317 case NFSERR_TIMEDOUT: 1318 error = ETIMEDOUT; 1319 break; 1320 1321 case NFSERR_NAMETOL: 1322 error = ENAMETOOLONG; 1323 break; 1324 1325 case NFSERR_NOTEMPTY: 1326 error = ENOTEMPTY; 1327 break; 1328 1329 case NFSERR_DQUOT: 1330 error = EDQUOT; 1331 break; 1332 1333 case NFSERR_STALE: 1334 /* 1335 * If the File Handle was stale, invalidate the 1336 * lookup cache, just in case. 1337 */ 1338 error = ESTALE; 1339 cache_purge(NFSTOV(np)); 1340 break; 1341 1342 case NFSERR_REMOTE: 1343 error = EREMOTE; 1344 break; 1345 1346 case NFSERR_WFLUSH: 1347 case NFSERR_BADHANDLE: 1348 case NFSERR_NOT_SYNC: 1349 case NFSERR_BAD_COOKIE: 1350 error = EINVAL; 1351 break; 1352 1353 case NFSERR_NOTSUPP: 1354 error = ENOTSUP; 1355 break; 1356 1357 case NFSERR_TOOSMALL: 1358 case NFSERR_SERVERFAULT: 1359 case NFSERR_BADTYPE: 1360 error = EINVAL; 1361 break; 1362 1363 case NFSERR_TRYLATER: 1364 if ((nmp->nm_flag & NFSMNT_NFSV3) == 0) 1365 break; 1366 m_freem(mrep); 1367 error = 0; 1368 waituntil = time_second + trylater_delay; 1369 while (time_second < waituntil) { 1370 kpause("nfstrylater", false, hz, NULL); 1371 } 1372 trylater_delay *= NFS_TRYLATERDELMUL; 1373 if (trylater_delay > NFS_TRYLATERDELMAX) 1374 trylater_delay = NFS_TRYLATERDELMAX; 1375 /* 1376 * RFC1813: 1377 * The client should wait and then try 1378 * the request with a new RPC transaction ID. 1379 */ 1380 nfs_renewxid(rep); 1381 goto tryagain; 1382 1383 default: 1384 #ifdef DIAGNOSTIC 1385 printf("Invalid rpc error code %d\n", error); 1386 #endif 1387 error = EINVAL; 1388 break; 1389 } 1390 1391 if (nmp->nm_flag & NFSMNT_NFSV3) { 1392 *mrp = mrep; 1393 *mdp = md; 1394 *dposp = dpos; 1395 error |= NFSERR_RETERR; 1396 } else 1397 m_freem(mrep); 1398 goto nfsmout; 1399 } 1400 1401 /* 1402 * note which credential worked to minimize number of retries. 1403 */ 1404 if (use_opencred) 1405 np->n_flag |= NUSEOPENCRED; 1406 else 1407 np->n_flag &= ~NUSEOPENCRED; 1408 1409 *mrp = mrep; 1410 *mdp = md; 1411 *dposp = dpos; 1412 1413 KASSERT(error == 0); 1414 goto nfsmout; 1415 } 1416 m_freem(mrep); 1417 error = EPROTONOSUPPORT; 1418 nfsmout: 1419 KASSERT(kauth_cred_getrefcnt(acred) == 1); 1420 kauth_cred_free(acred); 1421 m_freem(rep->r_mreq); 1422 kmem_free(rep, sizeof(*rep)); 1423 m_freem(mrest_backup); 1424 return (error); 1425 } 1426 #endif /* NFS */ 1427 1428 /* 1429 * Generate the rpc reply header 1430 * siz arg. is used to decide if adding a cluster is worthwhile 1431 */ 1432 int 1433 nfs_rephead(siz, nd, slp, err, cache, frev, mrq, mbp, bposp) 1434 int siz; 1435 struct nfsrv_descript *nd; 1436 struct nfssvc_sock *slp; 1437 int err; 1438 int cache; 1439 u_quad_t *frev; 1440 struct mbuf **mrq; 1441 struct mbuf **mbp; 1442 char **bposp; 1443 { 1444 u_int32_t *tl; 1445 struct mbuf *mreq; 1446 char *bpos; 1447 struct mbuf *mb; 1448 1449 mreq = m_gethdr(M_WAIT, MT_DATA); 1450 MCLAIM(mreq, &nfs_mowner); 1451 mb = mreq; 1452 /* 1453 * If this is a big reply, use a cluster else 1454 * try and leave leading space for the lower level headers. 1455 */ 1456 siz += RPC_REPLYSIZ; 1457 if (siz >= max_datalen) { 1458 m_clget(mreq, M_WAIT); 1459 } else 1460 mreq->m_data += max_hdr; 1461 tl = mtod(mreq, u_int32_t *); 1462 mreq->m_len = 6 * NFSX_UNSIGNED; 1463 bpos = ((char *)tl) + mreq->m_len; 1464 *tl++ = txdr_unsigned(nd->nd_retxid); 1465 *tl++ = rpc_reply; 1466 if (err == ERPCMISMATCH || (err & NFSERR_AUTHERR)) { 1467 *tl++ = rpc_msgdenied; 1468 if (err & NFSERR_AUTHERR) { 1469 *tl++ = rpc_autherr; 1470 *tl = txdr_unsigned(err & ~NFSERR_AUTHERR); 1471 mreq->m_len -= NFSX_UNSIGNED; 1472 bpos -= NFSX_UNSIGNED; 1473 } else { 1474 *tl++ = rpc_mismatch; 1475 *tl++ = txdr_unsigned(RPC_VER2); 1476 *tl = txdr_unsigned(RPC_VER2); 1477 } 1478 } else { 1479 *tl++ = rpc_msgaccepted; 1480 1481 /* 1482 * For Kerberos authentication, we must send the nickname 1483 * verifier back, otherwise just RPCAUTH_NULL. 1484 */ 1485 if (nd->nd_flag & ND_KERBFULL) { 1486 struct nfsuid *nuidp; 1487 struct timeval ktvin, ktvout; 1488 1489 memset(&ktvout, 0, sizeof ktvout); /* XXX gcc */ 1490 1491 LIST_FOREACH(nuidp, 1492 NUIDHASH(slp, kauth_cred_geteuid(nd->nd_cr)), 1493 nu_hash) { 1494 if (kauth_cred_geteuid(nuidp->nu_cr) == 1495 kauth_cred_geteuid(nd->nd_cr) && 1496 (!nd->nd_nam2 || netaddr_match( 1497 NU_NETFAM(nuidp), &nuidp->nu_haddr, 1498 nd->nd_nam2))) 1499 break; 1500 } 1501 if (nuidp) { 1502 ktvin.tv_sec = 1503 txdr_unsigned(nuidp->nu_timestamp.tv_sec 1504 - 1); 1505 ktvin.tv_usec = 1506 txdr_unsigned(nuidp->nu_timestamp.tv_usec); 1507 1508 /* 1509 * Encrypt the timestamp in ecb mode using the 1510 * session key. 1511 */ 1512 #ifdef NFSKERB 1513 XXX 1514 #endif 1515 1516 *tl++ = rpc_auth_kerb; 1517 *tl++ = txdr_unsigned(3 * NFSX_UNSIGNED); 1518 *tl = ktvout.tv_sec; 1519 nfsm_build(tl, u_int32_t *, 3 * NFSX_UNSIGNED); 1520 *tl++ = ktvout.tv_usec; 1521 *tl++ = txdr_unsigned( 1522 kauth_cred_geteuid(nuidp->nu_cr)); 1523 } else { 1524 *tl++ = 0; 1525 *tl++ = 0; 1526 } 1527 } else { 1528 *tl++ = 0; 1529 *tl++ = 0; 1530 } 1531 switch (err) { 1532 case EPROGUNAVAIL: 1533 *tl = txdr_unsigned(RPC_PROGUNAVAIL); 1534 break; 1535 case EPROGMISMATCH: 1536 *tl = txdr_unsigned(RPC_PROGMISMATCH); 1537 nfsm_build(tl, u_int32_t *, 2 * NFSX_UNSIGNED); 1538 *tl++ = txdr_unsigned(2); 1539 *tl = txdr_unsigned(3); 1540 break; 1541 case EPROCUNAVAIL: 1542 *tl = txdr_unsigned(RPC_PROCUNAVAIL); 1543 break; 1544 case EBADRPC: 1545 *tl = txdr_unsigned(RPC_GARBAGE); 1546 break; 1547 default: 1548 *tl = 0; 1549 if (err != NFSERR_RETVOID) { 1550 nfsm_build(tl, u_int32_t *, NFSX_UNSIGNED); 1551 if (err) 1552 *tl = txdr_unsigned(nfsrv_errmap(nd, err)); 1553 else 1554 *tl = 0; 1555 } 1556 break; 1557 }; 1558 } 1559 1560 if (mrq != NULL) 1561 *mrq = mreq; 1562 *mbp = mb; 1563 *bposp = bpos; 1564 if (err != 0 && err != NFSERR_RETVOID) 1565 nfsstats.srvrpc_errs++; 1566 return (0); 1567 } 1568 1569 static void 1570 nfs_timer_schedule(void) 1571 { 1572 1573 callout_schedule(&nfs_timer_ch, nfs_ticks); 1574 } 1575 1576 void 1577 nfs_timer_start(void) 1578 { 1579 1580 if (callout_pending(&nfs_timer_ch)) 1581 return; 1582 1583 nfs_timer_start_ev.ev_count++; 1584 nfs_timer_schedule(); 1585 } 1586 1587 void 1588 nfs_timer_init(void) 1589 { 1590 1591 callout_init(&nfs_timer_ch, 0); 1592 callout_setfunc(&nfs_timer_ch, nfs_timer, NULL); 1593 evcnt_attach_dynamic(&nfs_timer_ev, EVCNT_TYPE_MISC, NULL, 1594 "nfs", "timer"); 1595 evcnt_attach_dynamic(&nfs_timer_start_ev, EVCNT_TYPE_MISC, NULL, 1596 "nfs", "timer start"); 1597 evcnt_attach_dynamic(&nfs_timer_stop_ev, EVCNT_TYPE_MISC, NULL, 1598 "nfs", "timer stop"); 1599 } 1600 1601 /* 1602 * Nfs timer routine 1603 * Scan the nfsreq list and retranmit any requests that have timed out 1604 * To avoid retransmission attempts on STREAM sockets (in the future) make 1605 * sure to set the r_retry field to 0 (implies nm_retry == 0). 1606 * A non-NULL argument means 'initialize'. 1607 */ 1608 void 1609 nfs_timer(void *arg) 1610 { 1611 struct nfsreq *rep; 1612 struct mbuf *m; 1613 struct socket *so; 1614 struct nfsmount *nmp; 1615 int timeo; 1616 int s, error; 1617 bool more = false; 1618 #ifdef NFSSERVER 1619 struct timeval tv; 1620 struct nfssvc_sock *slp; 1621 u_quad_t cur_usec; 1622 #endif 1623 1624 nfs_timer_ev.ev_count++; 1625 1626 s = splsoftnet(); 1627 TAILQ_FOREACH(rep, &nfs_reqq, r_chain) { 1628 more = true; 1629 nmp = rep->r_nmp; 1630 if (rep->r_mrep || (rep->r_flags & R_SOFTTERM)) 1631 continue; 1632 if (nfs_sigintr(nmp, rep, rep->r_lwp)) { 1633 rep->r_flags |= R_SOFTTERM; 1634 continue; 1635 } 1636 if (rep->r_rtt >= 0) { 1637 rep->r_rtt++; 1638 if (nmp->nm_flag & NFSMNT_DUMBTIMR) 1639 timeo = nmp->nm_timeo; 1640 else 1641 timeo = NFS_RTO(nmp, proct[rep->r_procnum]); 1642 if (nmp->nm_timeouts > 0) 1643 timeo *= nfs_backoff[nmp->nm_timeouts - 1]; 1644 if (rep->r_rtt <= timeo) 1645 continue; 1646 if (nmp->nm_timeouts < 1647 (sizeof(nfs_backoff) / sizeof(nfs_backoff[0]))) 1648 nmp->nm_timeouts++; 1649 } 1650 /* 1651 * Check for server not responding 1652 */ 1653 if ((rep->r_flags & R_TPRINTFMSG) == 0 && 1654 rep->r_rexmit > nmp->nm_deadthresh) { 1655 nfs_msg(rep->r_lwp, 1656 nmp->nm_mountp->mnt_stat.f_mntfromname, 1657 "not responding"); 1658 rep->r_flags |= R_TPRINTFMSG; 1659 } 1660 if (rep->r_rexmit >= rep->r_retry) { /* too many */ 1661 nfsstats.rpctimeouts++; 1662 rep->r_flags |= R_SOFTTERM; 1663 continue; 1664 } 1665 if (nmp->nm_sotype != SOCK_DGRAM) { 1666 if (++rep->r_rexmit > NFS_MAXREXMIT) 1667 rep->r_rexmit = NFS_MAXREXMIT; 1668 continue; 1669 } 1670 if ((so = nmp->nm_so) == NULL) 1671 continue; 1672 1673 /* 1674 * If there is enough space and the window allows.. 1675 * Resend it 1676 * Set r_rtt to -1 in case we fail to send it now. 1677 */ 1678 solock(so); 1679 rep->r_rtt = -1; 1680 if (sbspace(&so->so_snd) >= rep->r_mreq->m_pkthdr.len && 1681 ((nmp->nm_flag & NFSMNT_DUMBTIMR) || 1682 (rep->r_flags & R_SENT) || 1683 nmp->nm_sent < nmp->nm_cwnd) && 1684 (m = m_copym(rep->r_mreq, 0, M_COPYALL, M_DONTWAIT))){ 1685 if (so->so_state & SS_ISCONNECTED) 1686 error = (*so->so_proto->pr_usrreq)(so, PRU_SEND, m, 1687 (struct mbuf *)0, (struct mbuf *)0, (struct lwp *)0); 1688 else 1689 error = (*so->so_proto->pr_usrreq)(so, PRU_SEND, m, 1690 nmp->nm_nam, (struct mbuf *)0, (struct lwp *)0); 1691 if (error) { 1692 if (NFSIGNORE_SOERROR(nmp->nm_soflags, error)) { 1693 #ifdef DEBUG 1694 printf("nfs_timer: ignoring error %d\n", 1695 error); 1696 #endif 1697 so->so_error = 0; 1698 } 1699 } else { 1700 /* 1701 * Iff first send, start timing 1702 * else turn timing off, backoff timer 1703 * and divide congestion window by 2. 1704 */ 1705 if (rep->r_flags & R_SENT) { 1706 rep->r_flags &= ~R_TIMING; 1707 if (++rep->r_rexmit > NFS_MAXREXMIT) 1708 rep->r_rexmit = NFS_MAXREXMIT; 1709 nmp->nm_cwnd >>= 1; 1710 if (nmp->nm_cwnd < NFS_CWNDSCALE) 1711 nmp->nm_cwnd = NFS_CWNDSCALE; 1712 nfsstats.rpcretries++; 1713 } else { 1714 rep->r_flags |= R_SENT; 1715 nmp->nm_sent += NFS_CWNDSCALE; 1716 } 1717 rep->r_rtt = 0; 1718 } 1719 } 1720 sounlock(so); 1721 } 1722 splx(s); 1723 1724 #ifdef NFSSERVER 1725 /* 1726 * Scan the write gathering queues for writes that need to be 1727 * completed now. 1728 */ 1729 getmicrotime(&tv); 1730 cur_usec = (u_quad_t)tv.tv_sec * 1000000 + (u_quad_t)tv.tv_usec; 1731 mutex_enter(&nfsd_lock); 1732 TAILQ_FOREACH(slp, &nfssvc_sockhead, ns_chain) { 1733 struct nfsrv_descript *nd; 1734 1735 nd = LIST_FIRST(&slp->ns_tq); 1736 if (nd != NULL) { 1737 if (nd->nd_time <= cur_usec) { 1738 nfsrv_wakenfsd_locked(slp); 1739 } 1740 more = true; 1741 } 1742 } 1743 mutex_exit(&nfsd_lock); 1744 #endif /* NFSSERVER */ 1745 if (more) { 1746 nfs_timer_schedule(); 1747 } else { 1748 nfs_timer_stop_ev.ev_count++; 1749 } 1750 } 1751 1752 /* 1753 * Test for a termination condition pending on the process. 1754 * This is used for NFSMNT_INT mounts. 1755 */ 1756 int 1757 nfs_sigintr(nmp, rep, l) 1758 struct nfsmount *nmp; 1759 struct nfsreq *rep; 1760 struct lwp *l; 1761 { 1762 sigset_t ss; 1763 1764 if (rep && (rep->r_flags & R_SOFTTERM)) 1765 return (EINTR); 1766 if (!(nmp->nm_flag & NFSMNT_INT)) 1767 return (0); 1768 if (l) { 1769 sigpending1(l, &ss); 1770 #if 0 1771 sigminusset(&l->l_proc->p_sigctx.ps_sigignore, &ss); 1772 #endif 1773 if (sigismember(&ss, SIGINT) || sigismember(&ss, SIGTERM) || 1774 sigismember(&ss, SIGKILL) || sigismember(&ss, SIGHUP) || 1775 sigismember(&ss, SIGQUIT)) 1776 return (EINTR); 1777 } 1778 return (0); 1779 } 1780 1781 /* 1782 * Lock a socket against others. 1783 * Necessary for STREAM sockets to ensure you get an entire rpc request/reply 1784 * and also to avoid race conditions between the processes with nfs requests 1785 * in progress when a reconnect is necessary. 1786 */ 1787 static int 1788 nfs_sndlock(struct nfsmount *nmp, struct nfsreq *rep) 1789 { 1790 struct lwp *l; 1791 int timeo = 0; 1792 bool catch = false; 1793 int error = 0; 1794 1795 if (rep) { 1796 l = rep->r_lwp; 1797 if (rep->r_nmp->nm_flag & NFSMNT_INT) 1798 catch = true; 1799 } else 1800 l = NULL; 1801 mutex_enter(&nmp->nm_lock); 1802 while ((nmp->nm_iflag & NFSMNT_SNDLOCK) != 0) { 1803 if (rep && nfs_sigintr(rep->r_nmp, rep, l)) { 1804 error = EINTR; 1805 goto quit; 1806 } 1807 if (catch) { 1808 cv_timedwait_sig(&nmp->nm_sndcv, &nmp->nm_lock, timeo); 1809 } else { 1810 cv_timedwait(&nmp->nm_sndcv, &nmp->nm_lock, timeo); 1811 } 1812 if (catch) { 1813 catch = false; 1814 timeo = 2 * hz; 1815 } 1816 } 1817 nmp->nm_iflag |= NFSMNT_SNDLOCK; 1818 quit: 1819 mutex_exit(&nmp->nm_lock); 1820 return error; 1821 } 1822 1823 /* 1824 * Unlock the stream socket for others. 1825 */ 1826 static void 1827 nfs_sndunlock(struct nfsmount *nmp) 1828 { 1829 1830 mutex_enter(&nmp->nm_lock); 1831 if ((nmp->nm_iflag & NFSMNT_SNDLOCK) == 0) 1832 panic("nfs sndunlock"); 1833 nmp->nm_iflag &= ~NFSMNT_SNDLOCK; 1834 cv_signal(&nmp->nm_sndcv); 1835 mutex_exit(&nmp->nm_lock); 1836 } 1837 1838 static int 1839 nfs_rcvlock(struct nfsmount *nmp, struct nfsreq *rep) 1840 { 1841 int *flagp = &nmp->nm_iflag; 1842 int slptimeo = 0; 1843 bool catch; 1844 int error = 0; 1845 1846 KASSERT(nmp == rep->r_nmp); 1847 1848 catch = (nmp->nm_flag & NFSMNT_INT) != 0; 1849 mutex_enter(&nmp->nm_lock); 1850 while (/* CONSTCOND */ true) { 1851 if (*flagp & NFSMNT_DISMNT) { 1852 cv_signal(&nmp->nm_disconcv); 1853 error = EIO; 1854 break; 1855 } 1856 /* If our reply was received while we were sleeping, 1857 * then just return without taking the lock to avoid a 1858 * situation where a single iod could 'capture' the 1859 * receive lock. 1860 */ 1861 if (rep->r_mrep != NULL) { 1862 error = EALREADY; 1863 break; 1864 } 1865 if (nfs_sigintr(rep->r_nmp, rep, rep->r_lwp)) { 1866 error = EINTR; 1867 break; 1868 } 1869 if ((*flagp & NFSMNT_RCVLOCK) == 0) { 1870 *flagp |= NFSMNT_RCVLOCK; 1871 break; 1872 } 1873 if (catch) { 1874 cv_timedwait_sig(&nmp->nm_rcvcv, &nmp->nm_lock, 1875 slptimeo); 1876 } else { 1877 cv_timedwait(&nmp->nm_rcvcv, &nmp->nm_lock, 1878 slptimeo); 1879 } 1880 if (catch) { 1881 catch = false; 1882 slptimeo = 2 * hz; 1883 } 1884 } 1885 mutex_exit(&nmp->nm_lock); 1886 return error; 1887 } 1888 1889 /* 1890 * Unlock the stream socket for others. 1891 */ 1892 static void 1893 nfs_rcvunlock(struct nfsmount *nmp) 1894 { 1895 1896 mutex_enter(&nmp->nm_lock); 1897 if ((nmp->nm_iflag & NFSMNT_RCVLOCK) == 0) 1898 panic("nfs rcvunlock"); 1899 nmp->nm_iflag &= ~NFSMNT_RCVLOCK; 1900 cv_broadcast(&nmp->nm_rcvcv); 1901 mutex_exit(&nmp->nm_lock); 1902 } 1903 1904 /* 1905 * Parse an RPC request 1906 * - verify it 1907 * - allocate and fill in the cred. 1908 */ 1909 int 1910 nfs_getreq(nd, nfsd, has_header) 1911 struct nfsrv_descript *nd; 1912 struct nfsd *nfsd; 1913 int has_header; 1914 { 1915 int len, i; 1916 u_int32_t *tl; 1917 int32_t t1; 1918 struct uio uio; 1919 struct iovec iov; 1920 char *dpos, *cp2, *cp; 1921 u_int32_t nfsvers, auth_type; 1922 uid_t nickuid; 1923 int error = 0, ticklen; 1924 struct mbuf *mrep, *md; 1925 struct nfsuid *nuidp; 1926 struct timeval tvin, tvout; 1927 1928 memset(&tvout, 0, sizeof tvout); /* XXX gcc */ 1929 1930 KASSERT(nd->nd_cr == NULL); 1931 mrep = nd->nd_mrep; 1932 md = nd->nd_md; 1933 dpos = nd->nd_dpos; 1934 if (has_header) { 1935 nfsm_dissect(tl, u_int32_t *, 10 * NFSX_UNSIGNED); 1936 nd->nd_retxid = fxdr_unsigned(u_int32_t, *tl++); 1937 if (*tl++ != rpc_call) { 1938 m_freem(mrep); 1939 return (EBADRPC); 1940 } 1941 } else 1942 nfsm_dissect(tl, u_int32_t *, 8 * NFSX_UNSIGNED); 1943 nd->nd_repstat = 0; 1944 nd->nd_flag = 0; 1945 if (*tl++ != rpc_vers) { 1946 nd->nd_repstat = ERPCMISMATCH; 1947 nd->nd_procnum = NFSPROC_NOOP; 1948 return (0); 1949 } 1950 if (*tl != nfs_prog) { 1951 nd->nd_repstat = EPROGUNAVAIL; 1952 nd->nd_procnum = NFSPROC_NOOP; 1953 return (0); 1954 } 1955 tl++; 1956 nfsvers = fxdr_unsigned(u_int32_t, *tl++); 1957 if (nfsvers < NFS_VER2 || nfsvers > NFS_VER3) { 1958 nd->nd_repstat = EPROGMISMATCH; 1959 nd->nd_procnum = NFSPROC_NOOP; 1960 return (0); 1961 } 1962 if (nfsvers == NFS_VER3) 1963 nd->nd_flag = ND_NFSV3; 1964 nd->nd_procnum = fxdr_unsigned(u_int32_t, *tl++); 1965 if (nd->nd_procnum == NFSPROC_NULL) 1966 return (0); 1967 if (nd->nd_procnum > NFSPROC_COMMIT || 1968 (!nd->nd_flag && nd->nd_procnum > NFSV2PROC_STATFS)) { 1969 nd->nd_repstat = EPROCUNAVAIL; 1970 nd->nd_procnum = NFSPROC_NOOP; 1971 return (0); 1972 } 1973 if ((nd->nd_flag & ND_NFSV3) == 0) 1974 nd->nd_procnum = nfsv3_procid[nd->nd_procnum]; 1975 auth_type = *tl++; 1976 len = fxdr_unsigned(int, *tl++); 1977 if (len < 0 || len > RPCAUTH_MAXSIZ) { 1978 m_freem(mrep); 1979 return (EBADRPC); 1980 } 1981 1982 nd->nd_flag &= ~ND_KERBAUTH; 1983 /* 1984 * Handle auth_unix or auth_kerb. 1985 */ 1986 if (auth_type == rpc_auth_unix) { 1987 uid_t uid; 1988 gid_t gid; 1989 1990 nd->nd_cr = kauth_cred_alloc(); 1991 len = fxdr_unsigned(int, *++tl); 1992 if (len < 0 || len > NFS_MAXNAMLEN) { 1993 m_freem(mrep); 1994 error = EBADRPC; 1995 goto errout; 1996 } 1997 nfsm_adv(nfsm_rndup(len)); 1998 nfsm_dissect(tl, u_int32_t *, 3 * NFSX_UNSIGNED); 1999 2000 uid = fxdr_unsigned(uid_t, *tl++); 2001 gid = fxdr_unsigned(gid_t, *tl++); 2002 kauth_cred_setuid(nd->nd_cr, uid); 2003 kauth_cred_seteuid(nd->nd_cr, uid); 2004 kauth_cred_setsvuid(nd->nd_cr, uid); 2005 kauth_cred_setgid(nd->nd_cr, gid); 2006 kauth_cred_setegid(nd->nd_cr, gid); 2007 kauth_cred_setsvgid(nd->nd_cr, gid); 2008 2009 len = fxdr_unsigned(int, *tl); 2010 if (len < 0 || len > RPCAUTH_UNIXGIDS) { 2011 m_freem(mrep); 2012 error = EBADRPC; 2013 goto errout; 2014 } 2015 nfsm_dissect(tl, u_int32_t *, (len + 2) * NFSX_UNSIGNED); 2016 2017 if (len > 0) { 2018 size_t grbuf_size = min(len, NGROUPS) * sizeof(gid_t); 2019 gid_t *grbuf = kmem_alloc(grbuf_size, KM_SLEEP); 2020 2021 for (i = 0; i < len; i++) { 2022 if (i < NGROUPS) /* XXX elad */ 2023 grbuf[i] = fxdr_unsigned(gid_t, *tl++); 2024 else 2025 tl++; 2026 } 2027 kauth_cred_setgroups(nd->nd_cr, grbuf, 2028 min(len, NGROUPS), -1, UIO_SYSSPACE); 2029 kmem_free(grbuf, grbuf_size); 2030 } 2031 2032 len = fxdr_unsigned(int, *++tl); 2033 if (len < 0 || len > RPCAUTH_MAXSIZ) { 2034 m_freem(mrep); 2035 error = EBADRPC; 2036 goto errout; 2037 } 2038 if (len > 0) 2039 nfsm_adv(nfsm_rndup(len)); 2040 } else if (auth_type == rpc_auth_kerb) { 2041 switch (fxdr_unsigned(int, *tl++)) { 2042 case RPCAKN_FULLNAME: 2043 ticklen = fxdr_unsigned(int, *tl); 2044 *((u_int32_t *)nfsd->nfsd_authstr) = *tl; 2045 uio.uio_resid = nfsm_rndup(ticklen) + NFSX_UNSIGNED; 2046 nfsd->nfsd_authlen = uio.uio_resid + NFSX_UNSIGNED; 2047 if (uio.uio_resid > (len - 2 * NFSX_UNSIGNED)) { 2048 m_freem(mrep); 2049 error = EBADRPC; 2050 goto errout; 2051 } 2052 uio.uio_offset = 0; 2053 uio.uio_iov = &iov; 2054 uio.uio_iovcnt = 1; 2055 UIO_SETUP_SYSSPACE(&uio); 2056 iov.iov_base = (void *)&nfsd->nfsd_authstr[4]; 2057 iov.iov_len = RPCAUTH_MAXSIZ - 4; 2058 nfsm_mtouio(&uio, uio.uio_resid); 2059 nfsm_dissect(tl, u_int32_t *, 2 * NFSX_UNSIGNED); 2060 if (*tl++ != rpc_auth_kerb || 2061 fxdr_unsigned(int, *tl) != 4 * NFSX_UNSIGNED) { 2062 printf("Bad kerb verifier\n"); 2063 nd->nd_repstat = (NFSERR_AUTHERR|AUTH_BADVERF); 2064 nd->nd_procnum = NFSPROC_NOOP; 2065 return (0); 2066 } 2067 nfsm_dissect(cp, void *, 4 * NFSX_UNSIGNED); 2068 tl = (u_int32_t *)cp; 2069 if (fxdr_unsigned(int, *tl) != RPCAKN_FULLNAME) { 2070 printf("Not fullname kerb verifier\n"); 2071 nd->nd_repstat = (NFSERR_AUTHERR|AUTH_BADVERF); 2072 nd->nd_procnum = NFSPROC_NOOP; 2073 return (0); 2074 } 2075 cp += NFSX_UNSIGNED; 2076 memcpy(nfsd->nfsd_verfstr, cp, 3 * NFSX_UNSIGNED); 2077 nfsd->nfsd_verflen = 3 * NFSX_UNSIGNED; 2078 nd->nd_flag |= ND_KERBFULL; 2079 nfsd->nfsd_flag |= NFSD_NEEDAUTH; 2080 break; 2081 case RPCAKN_NICKNAME: 2082 if (len != 2 * NFSX_UNSIGNED) { 2083 printf("Kerb nickname short\n"); 2084 nd->nd_repstat = (NFSERR_AUTHERR|AUTH_BADCRED); 2085 nd->nd_procnum = NFSPROC_NOOP; 2086 return (0); 2087 } 2088 nickuid = fxdr_unsigned(uid_t, *tl); 2089 nfsm_dissect(tl, u_int32_t *, 2 * NFSX_UNSIGNED); 2090 if (*tl++ != rpc_auth_kerb || 2091 fxdr_unsigned(int, *tl) != 3 * NFSX_UNSIGNED) { 2092 printf("Kerb nick verifier bad\n"); 2093 nd->nd_repstat = (NFSERR_AUTHERR|AUTH_BADVERF); 2094 nd->nd_procnum = NFSPROC_NOOP; 2095 return (0); 2096 } 2097 nfsm_dissect(tl, u_int32_t *, 3 * NFSX_UNSIGNED); 2098 tvin.tv_sec = *tl++; 2099 tvin.tv_usec = *tl; 2100 2101 LIST_FOREACH(nuidp, NUIDHASH(nfsd->nfsd_slp, nickuid), 2102 nu_hash) { 2103 if (kauth_cred_geteuid(nuidp->nu_cr) == nickuid && 2104 (!nd->nd_nam2 || 2105 netaddr_match(NU_NETFAM(nuidp), 2106 &nuidp->nu_haddr, nd->nd_nam2))) 2107 break; 2108 } 2109 if (!nuidp) { 2110 nd->nd_repstat = 2111 (NFSERR_AUTHERR|AUTH_REJECTCRED); 2112 nd->nd_procnum = NFSPROC_NOOP; 2113 return (0); 2114 } 2115 2116 /* 2117 * Now, decrypt the timestamp using the session key 2118 * and validate it. 2119 */ 2120 #ifdef NFSKERB 2121 XXX 2122 #endif 2123 2124 tvout.tv_sec = fxdr_unsigned(long, tvout.tv_sec); 2125 tvout.tv_usec = fxdr_unsigned(long, tvout.tv_usec); 2126 if (nuidp->nu_expire < time_second || 2127 nuidp->nu_timestamp.tv_sec > tvout.tv_sec || 2128 (nuidp->nu_timestamp.tv_sec == tvout.tv_sec && 2129 nuidp->nu_timestamp.tv_usec > tvout.tv_usec)) { 2130 nuidp->nu_expire = 0; 2131 nd->nd_repstat = 2132 (NFSERR_AUTHERR|AUTH_REJECTVERF); 2133 nd->nd_procnum = NFSPROC_NOOP; 2134 return (0); 2135 } 2136 kauth_cred_hold(nuidp->nu_cr); 2137 nd->nd_cr = nuidp->nu_cr; 2138 nd->nd_flag |= ND_KERBNICK; 2139 } 2140 } else { 2141 nd->nd_repstat = (NFSERR_AUTHERR | AUTH_REJECTCRED); 2142 nd->nd_procnum = NFSPROC_NOOP; 2143 return (0); 2144 } 2145 2146 nd->nd_md = md; 2147 nd->nd_dpos = dpos; 2148 KASSERT((nd->nd_cr == NULL && (nfsd->nfsd_flag & NFSD_NEEDAUTH) != 0) 2149 || (nd->nd_cr != NULL && (nfsd->nfsd_flag & NFSD_NEEDAUTH) == 0)); 2150 return (0); 2151 nfsmout: 2152 errout: 2153 KASSERT(error != 0); 2154 if (nd->nd_cr != NULL) { 2155 kauth_cred_free(nd->nd_cr); 2156 nd->nd_cr = NULL; 2157 } 2158 return (error); 2159 } 2160 2161 int 2162 nfs_msg(l, server, msg) 2163 struct lwp *l; 2164 const char *server, *msg; 2165 { 2166 tpr_t tpr; 2167 2168 if (l) 2169 tpr = tprintf_open(l->l_proc); 2170 else 2171 tpr = NULL; 2172 tprintf(tpr, "nfs server %s: %s\n", server, msg); 2173 tprintf_close(tpr); 2174 return (0); 2175 } 2176 2177 #ifdef NFSSERVER 2178 int (*nfsrv3_procs[NFS_NPROCS]) __P((struct nfsrv_descript *, 2179 struct nfssvc_sock *, struct lwp *, 2180 struct mbuf **)) = { 2181 nfsrv_null, 2182 nfsrv_getattr, 2183 nfsrv_setattr, 2184 nfsrv_lookup, 2185 nfsrv3_access, 2186 nfsrv_readlink, 2187 nfsrv_read, 2188 nfsrv_write, 2189 nfsrv_create, 2190 nfsrv_mkdir, 2191 nfsrv_symlink, 2192 nfsrv_mknod, 2193 nfsrv_remove, 2194 nfsrv_rmdir, 2195 nfsrv_rename, 2196 nfsrv_link, 2197 nfsrv_readdir, 2198 nfsrv_readdirplus, 2199 nfsrv_statfs, 2200 nfsrv_fsinfo, 2201 nfsrv_pathconf, 2202 nfsrv_commit, 2203 nfsrv_noop 2204 }; 2205 2206 /* 2207 * Socket upcall routine for the nfsd sockets. 2208 * The void *arg is a pointer to the "struct nfssvc_sock". 2209 */ 2210 void 2211 nfsrv_soupcall(struct socket *so, void *arg, int waitflag) 2212 { 2213 struct nfssvc_sock *slp = (struct nfssvc_sock *)arg; 2214 2215 nfsdsock_setbits(slp, SLP_A_NEEDQ); 2216 nfsrv_wakenfsd(slp); 2217 } 2218 2219 void 2220 nfsrv_rcv(struct nfssvc_sock *slp) 2221 { 2222 struct socket *so; 2223 struct mbuf *m; 2224 struct mbuf *mp, *nam; 2225 struct uio auio; 2226 int flags; 2227 int error; 2228 int setflags = 0; 2229 2230 error = nfsdsock_lock(slp, true); 2231 if (error) { 2232 setflags |= SLP_A_NEEDQ; 2233 goto dorecs_unlocked; 2234 } 2235 2236 nfsdsock_clearbits(slp, SLP_A_NEEDQ); 2237 2238 so = slp->ns_so; 2239 if (so->so_type == SOCK_STREAM) { 2240 /* 2241 * Do soreceive(). 2242 */ 2243 auio.uio_resid = 1000000000; 2244 /* not need to setup uio_vmspace */ 2245 flags = MSG_DONTWAIT; 2246 error = (*so->so_receive)(so, &nam, &auio, &mp, NULL, &flags); 2247 if (error || mp == NULL) { 2248 if (error == EWOULDBLOCK) 2249 setflags |= SLP_A_NEEDQ; 2250 else 2251 setflags |= SLP_A_DISCONN; 2252 goto dorecs; 2253 } 2254 m = mp; 2255 m_claimm(m, &nfs_mowner); 2256 if (slp->ns_rawend) { 2257 slp->ns_rawend->m_next = m; 2258 slp->ns_cc += 1000000000 - auio.uio_resid; 2259 } else { 2260 slp->ns_raw = m; 2261 slp->ns_cc = 1000000000 - auio.uio_resid; 2262 } 2263 while (m->m_next) 2264 m = m->m_next; 2265 slp->ns_rawend = m; 2266 2267 /* 2268 * Now try and parse record(s) out of the raw stream data. 2269 */ 2270 error = nfsrv_getstream(slp, M_WAIT); 2271 if (error) { 2272 if (error == EPERM) 2273 setflags |= SLP_A_DISCONN; 2274 else 2275 setflags |= SLP_A_NEEDQ; 2276 } 2277 } else { 2278 do { 2279 auio.uio_resid = 1000000000; 2280 /* not need to setup uio_vmspace */ 2281 flags = MSG_DONTWAIT; 2282 error = (*so->so_receive)(so, &nam, &auio, &mp, NULL, 2283 &flags); 2284 if (mp) { 2285 if (nam) { 2286 m = nam; 2287 m->m_next = mp; 2288 } else 2289 m = mp; 2290 m_claimm(m, &nfs_mowner); 2291 if (slp->ns_recend) 2292 slp->ns_recend->m_nextpkt = m; 2293 else 2294 slp->ns_rec = m; 2295 slp->ns_recend = m; 2296 m->m_nextpkt = (struct mbuf *)0; 2297 } 2298 if (error) { 2299 if ((so->so_proto->pr_flags & PR_CONNREQUIRED) 2300 && error != EWOULDBLOCK) { 2301 setflags |= SLP_A_DISCONN; 2302 goto dorecs; 2303 } 2304 } 2305 } while (mp); 2306 } 2307 dorecs: 2308 nfsdsock_unlock(slp); 2309 2310 dorecs_unlocked: 2311 if (setflags) { 2312 nfsdsock_setbits(slp, setflags); 2313 } 2314 } 2315 2316 int 2317 nfsdsock_lock(struct nfssvc_sock *slp, bool waitok) 2318 { 2319 2320 mutex_enter(&slp->ns_lock); 2321 while ((~slp->ns_flags & (SLP_BUSY|SLP_VALID)) == 0) { 2322 if (!waitok) { 2323 mutex_exit(&slp->ns_lock); 2324 return EWOULDBLOCK; 2325 } 2326 cv_wait(&slp->ns_cv, &slp->ns_lock); 2327 } 2328 if ((slp->ns_flags & SLP_VALID) == 0) { 2329 mutex_exit(&slp->ns_lock); 2330 return EINVAL; 2331 } 2332 KASSERT((slp->ns_flags & SLP_BUSY) == 0); 2333 slp->ns_flags |= SLP_BUSY; 2334 mutex_exit(&slp->ns_lock); 2335 2336 return 0; 2337 } 2338 2339 void 2340 nfsdsock_unlock(struct nfssvc_sock *slp) 2341 { 2342 2343 mutex_enter(&slp->ns_lock); 2344 KASSERT((slp->ns_flags & SLP_BUSY) != 0); 2345 cv_broadcast(&slp->ns_cv); 2346 slp->ns_flags &= ~SLP_BUSY; 2347 mutex_exit(&slp->ns_lock); 2348 } 2349 2350 int 2351 nfsdsock_drain(struct nfssvc_sock *slp) 2352 { 2353 int error = 0; 2354 2355 mutex_enter(&slp->ns_lock); 2356 if ((slp->ns_flags & SLP_VALID) == 0) { 2357 error = EINVAL; 2358 goto done; 2359 } 2360 slp->ns_flags &= ~SLP_VALID; 2361 while ((slp->ns_flags & SLP_BUSY) != 0) { 2362 cv_wait(&slp->ns_cv, &slp->ns_lock); 2363 } 2364 done: 2365 mutex_exit(&slp->ns_lock); 2366 2367 return error; 2368 } 2369 2370 /* 2371 * Try and extract an RPC request from the mbuf data list received on a 2372 * stream socket. The "waitflag" argument indicates whether or not it 2373 * can sleep. 2374 */ 2375 int 2376 nfsrv_getstream(slp, waitflag) 2377 struct nfssvc_sock *slp; 2378 int waitflag; 2379 { 2380 struct mbuf *m, **mpp; 2381 struct mbuf *recm; 2382 u_int32_t recmark; 2383 int error = 0; 2384 2385 KASSERT((slp->ns_flags & SLP_BUSY) != 0); 2386 for (;;) { 2387 if (slp->ns_reclen == 0) { 2388 if (slp->ns_cc < NFSX_UNSIGNED) { 2389 break; 2390 } 2391 m = slp->ns_raw; 2392 m_copydata(m, 0, NFSX_UNSIGNED, (void *)&recmark); 2393 m_adj(m, NFSX_UNSIGNED); 2394 slp->ns_cc -= NFSX_UNSIGNED; 2395 recmark = ntohl(recmark); 2396 slp->ns_reclen = recmark & ~0x80000000; 2397 if (recmark & 0x80000000) 2398 slp->ns_sflags |= SLP_S_LASTFRAG; 2399 else 2400 slp->ns_sflags &= ~SLP_S_LASTFRAG; 2401 if (slp->ns_reclen > NFS_MAXPACKET) { 2402 error = EPERM; 2403 break; 2404 } 2405 } 2406 2407 /* 2408 * Now get the record part. 2409 * 2410 * Note that slp->ns_reclen may be 0. Linux sometimes 2411 * generates 0-length records. 2412 */ 2413 if (slp->ns_cc == slp->ns_reclen) { 2414 recm = slp->ns_raw; 2415 slp->ns_raw = slp->ns_rawend = (struct mbuf *)0; 2416 slp->ns_cc = slp->ns_reclen = 0; 2417 } else if (slp->ns_cc > slp->ns_reclen) { 2418 recm = slp->ns_raw; 2419 m = m_split(recm, slp->ns_reclen, waitflag); 2420 if (m == NULL) { 2421 error = EWOULDBLOCK; 2422 break; 2423 } 2424 m_claimm(recm, &nfs_mowner); 2425 slp->ns_raw = m; 2426 if (m->m_next == NULL) 2427 slp->ns_rawend = m; 2428 slp->ns_cc -= slp->ns_reclen; 2429 slp->ns_reclen = 0; 2430 } else { 2431 break; 2432 } 2433 2434 /* 2435 * Accumulate the fragments into a record. 2436 */ 2437 mpp = &slp->ns_frag; 2438 while (*mpp) 2439 mpp = &((*mpp)->m_next); 2440 *mpp = recm; 2441 if (slp->ns_sflags & SLP_S_LASTFRAG) { 2442 if (slp->ns_recend) 2443 slp->ns_recend->m_nextpkt = slp->ns_frag; 2444 else 2445 slp->ns_rec = slp->ns_frag; 2446 slp->ns_recend = slp->ns_frag; 2447 slp->ns_frag = NULL; 2448 } 2449 } 2450 2451 return error; 2452 } 2453 2454 /* 2455 * Parse an RPC header. 2456 */ 2457 int 2458 nfsrv_dorec(struct nfssvc_sock *slp, struct nfsd *nfsd, 2459 struct nfsrv_descript **ndp, bool *more) 2460 { 2461 struct mbuf *m, *nam; 2462 struct nfsrv_descript *nd; 2463 int error; 2464 2465 *ndp = NULL; 2466 *more = false; 2467 2468 if (nfsdsock_lock(slp, true)) { 2469 return ENOBUFS; 2470 } 2471 m = slp->ns_rec; 2472 if (m == NULL) { 2473 nfsdsock_unlock(slp); 2474 return ENOBUFS; 2475 } 2476 slp->ns_rec = m->m_nextpkt; 2477 if (slp->ns_rec) { 2478 m->m_nextpkt = NULL; 2479 *more = true; 2480 } else { 2481 slp->ns_recend = NULL; 2482 } 2483 nfsdsock_unlock(slp); 2484 2485 if (m->m_type == MT_SONAME) { 2486 nam = m; 2487 m = m->m_next; 2488 nam->m_next = NULL; 2489 } else 2490 nam = NULL; 2491 nd = nfsdreq_alloc(); 2492 nd->nd_md = nd->nd_mrep = m; 2493 nd->nd_nam2 = nam; 2494 nd->nd_dpos = mtod(m, void *); 2495 error = nfs_getreq(nd, nfsd, true); 2496 if (error) { 2497 m_freem(nam); 2498 nfsdreq_free(nd); 2499 return (error); 2500 } 2501 *ndp = nd; 2502 nfsd->nfsd_nd = nd; 2503 return (0); 2504 } 2505 2506 /* 2507 * Search for a sleeping nfsd and wake it up. 2508 * SIDE EFFECT: If none found, set NFSD_CHECKSLP flag, so that one of the 2509 * running nfsds will go look for the work in the nfssvc_sock list. 2510 */ 2511 static void 2512 nfsrv_wakenfsd_locked(struct nfssvc_sock *slp) 2513 { 2514 struct nfsd *nd; 2515 2516 KASSERT(mutex_owned(&nfsd_lock)); 2517 2518 if ((slp->ns_flags & SLP_VALID) == 0) 2519 return; 2520 if (slp->ns_gflags & SLP_G_DOREC) 2521 return; 2522 nd = SLIST_FIRST(&nfsd_idle_head); 2523 if (nd) { 2524 SLIST_REMOVE_HEAD(&nfsd_idle_head, nfsd_idle); 2525 if (nd->nfsd_slp) 2526 panic("nfsd wakeup"); 2527 slp->ns_sref++; 2528 KASSERT(slp->ns_sref > 0); 2529 nd->nfsd_slp = slp; 2530 cv_signal(&nd->nfsd_cv); 2531 } else { 2532 slp->ns_gflags |= SLP_G_DOREC; 2533 nfsd_head_flag |= NFSD_CHECKSLP; 2534 TAILQ_INSERT_TAIL(&nfssvc_sockpending, slp, ns_pending); 2535 } 2536 } 2537 2538 void 2539 nfsrv_wakenfsd(struct nfssvc_sock *slp) 2540 { 2541 2542 mutex_enter(&nfsd_lock); 2543 nfsrv_wakenfsd_locked(slp); 2544 mutex_exit(&nfsd_lock); 2545 } 2546 2547 int 2548 nfsdsock_sendreply(struct nfssvc_sock *slp, struct nfsrv_descript *nd) 2549 { 2550 int error; 2551 2552 if (nd->nd_mrep != NULL) { 2553 m_freem(nd->nd_mrep); 2554 nd->nd_mrep = NULL; 2555 } 2556 2557 mutex_enter(&slp->ns_lock); 2558 if ((slp->ns_flags & SLP_SENDING) != 0) { 2559 SIMPLEQ_INSERT_TAIL(&slp->ns_sendq, nd, nd_sendq); 2560 mutex_exit(&slp->ns_lock); 2561 return 0; 2562 } 2563 KASSERT(SIMPLEQ_EMPTY(&slp->ns_sendq)); 2564 slp->ns_flags |= SLP_SENDING; 2565 mutex_exit(&slp->ns_lock); 2566 2567 again: 2568 error = nfs_send(slp->ns_so, nd->nd_nam2, nd->nd_mreq, NULL, curlwp); 2569 if (nd->nd_nam2) { 2570 m_free(nd->nd_nam2); 2571 } 2572 nfsdreq_free(nd); 2573 2574 mutex_enter(&slp->ns_lock); 2575 KASSERT((slp->ns_flags & SLP_SENDING) != 0); 2576 nd = SIMPLEQ_FIRST(&slp->ns_sendq); 2577 if (nd != NULL) { 2578 SIMPLEQ_REMOVE_HEAD(&slp->ns_sendq, nd_sendq); 2579 mutex_exit(&slp->ns_lock); 2580 goto again; 2581 } 2582 slp->ns_flags &= ~SLP_SENDING; 2583 mutex_exit(&slp->ns_lock); 2584 2585 return error; 2586 } 2587 2588 void 2589 nfsdsock_setbits(struct nfssvc_sock *slp, int bits) 2590 { 2591 2592 mutex_enter(&slp->ns_alock); 2593 slp->ns_aflags |= bits; 2594 mutex_exit(&slp->ns_alock); 2595 } 2596 2597 void 2598 nfsdsock_clearbits(struct nfssvc_sock *slp, int bits) 2599 { 2600 2601 mutex_enter(&slp->ns_alock); 2602 slp->ns_aflags &= ~bits; 2603 mutex_exit(&slp->ns_alock); 2604 } 2605 2606 bool 2607 nfsdsock_testbits(struct nfssvc_sock *slp, int bits) 2608 { 2609 2610 return (slp->ns_aflags & bits); 2611 } 2612 #endif /* NFSSERVER */ 2613 2614 #if defined(NFSSERVER) || (defined(NFS) && !defined(NFS_V2_ONLY)) 2615 static struct pool nfs_srvdesc_pool; 2616 2617 void 2618 nfsdreq_init(void) 2619 { 2620 2621 pool_init(&nfs_srvdesc_pool, sizeof(struct nfsrv_descript), 2622 0, 0, 0, "nfsrvdescpl", &pool_allocator_nointr, IPL_NONE); 2623 } 2624 2625 struct nfsrv_descript * 2626 nfsdreq_alloc(void) 2627 { 2628 struct nfsrv_descript *nd; 2629 2630 nd = pool_get(&nfs_srvdesc_pool, PR_WAITOK); 2631 nd->nd_cr = NULL; 2632 return nd; 2633 } 2634 2635 void 2636 nfsdreq_free(struct nfsrv_descript *nd) 2637 { 2638 kauth_cred_t cr; 2639 2640 cr = nd->nd_cr; 2641 if (cr != NULL) { 2642 kauth_cred_free(cr); 2643 } 2644 pool_put(&nfs_srvdesc_pool, nd); 2645 } 2646 #endif /* defined(NFSSERVER) || (defined(NFS) && !defined(NFS_V2_ONLY)) */ 2647
Indexes created Tue Sep 30 11:09:46 GMT 2025