1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright (c) 1990, 2010, Oracle and/or its affiliates. All rights reserved. 23 * Copyright (c) 2011 Bayard G. Bell. All rights reserved. 24 * Copyright (c) 2013 by Delphix. All rights reserved. 25 * Copyright 2014 Nexenta Systems, Inc. All rights reserved. 26 */ 27 28 /* 29 * Copyright (c) 1983,1984,1985,1986,1987,1988,1989 AT&T. 30 * All rights reserved. 31 * Use is subject to license terms. 32 */ 33 34 #include <sys/param.h> 35 #include <sys/types.h> 36 #include <sys/systm.h> 37 #include <sys/cred.h> 38 #include <sys/proc.h> 39 #include <sys/user.h> 40 #include <sys/buf.h> 41 #include <sys/vfs.h> 42 #include <sys/vnode.h> 43 #include <sys/pathname.h> 44 #include <sys/uio.h> 45 #include <sys/file.h> 46 #include <sys/stat.h> 47 #include <sys/errno.h> 48 #include <sys/socket.h> 49 #include <sys/sysmacros.h> 50 #include <sys/siginfo.h> 51 #include <sys/tiuser.h> 52 #include <sys/statvfs.h> 53 #include <sys/stream.h> 54 #include <sys/strsun.h> 55 #include <sys/strsubr.h> 56 #include <sys/stropts.h> 57 #include <sys/timod.h> 58 #include <sys/t_kuser.h> 59 #include <sys/kmem.h> 60 #include <sys/kstat.h> 61 #include <sys/dirent.h> 62 #include <sys/cmn_err.h> 63 #include <sys/debug.h> 64 #include <sys/unistd.h> 65 #include <sys/vtrace.h> 66 #include <sys/mode.h> 67 #include <sys/acl.h> 68 #include <sys/sdt.h> 69 70 #include <rpc/types.h> 71 #include <rpc/auth.h> 72 #include <rpc/auth_unix.h> 73 #include <rpc/auth_des.h> 74 #include <rpc/svc.h> 75 #include <rpc/xdr.h> 76 #include <rpc/rpc_rdma.h> 77 78 #include <nfs/nfs.h> 79 #include <nfs/export.h> 80 #include <nfs/nfssys.h> 81 #include <nfs/nfs_clnt.h> 82 #include <nfs/nfs_acl.h> 83 #include <nfs/nfs_log.h> 84 #include <nfs/nfs_cmd.h> 85 #include <nfs/lm.h> 86 #include <nfs/nfs_dispatch.h> 87 #include <nfs/nfs4_drc.h> 88 89 #include <sys/modctl.h> 90 #include <sys/cladm.h> 91 #include <sys/clconf.h> 92 93 #include <sys/tsol/label.h> 94 95 #define MAXHOST 32 96 const char *kinet_ntop6(uchar_t *, char *, size_t); 97 98 /* 99 * Module linkage information. 100 */ 101 102 static struct modlmisc modlmisc = { 103 &mod_miscops, "NFS server module" 104 }; 105 106 static struct modlinkage modlinkage = { 107 MODREV_1, (void *)&modlmisc, NULL 108 }; 109 110 kmem_cache_t *nfs_xuio_cache; 111 int nfs_loaned_buffers = 0; 112 113 int 114 _init(void) 115 { 116 int status; 117 118 if ((status = nfs_srvinit()) != 0) { 119 cmn_err(CE_WARN, "_init: nfs_srvinit failed"); 120 return (status); 121 } 122 123 status = mod_install((struct modlinkage *)&modlinkage); 124 if (status != 0) { 125 /* 126 * Could not load module, cleanup previous 127 * initialization work. 128 */ 129 nfs_srvfini(); 130 131 return (status); 132 } 133 134 /* 135 * Initialise some placeholders for nfssys() calls. These have 136 * to be declared by the nfs module, since that handles nfssys() 137 * calls - also used by NFS clients - but are provided by this 138 * nfssrv module. These also then serve as confirmation to the 139 * relevant code in nfs that nfssrv has been loaded, as they're 140 * initially NULL. 141 */ 142 nfs_srv_quiesce_func = nfs_srv_quiesce_all; 143 nfs_srv_dss_func = rfs4_dss_setpaths; 144 145 /* setup DSS paths here; must be done before initial server startup */ 146 rfs4_dss_paths = rfs4_dss_oldpaths = NULL; 147 148 /* initialize the copy reduction caches */ 149 150 nfs_xuio_cache = kmem_cache_create("nfs_xuio_cache", 151 sizeof (nfs_xuio_t), 0, NULL, NULL, NULL, NULL, NULL, 0); 152 153 return (status); 154 } 155 156 int 157 _fini() 158 { 159 return (EBUSY); 160 } 161 162 int 163 _info(struct modinfo *modinfop) 164 { 165 return (mod_info(&modlinkage, modinfop)); 166 } 167 168 /* 169 * PUBLICFH_CHECK() checks if the dispatch routine supports 170 * RPC_PUBLICFH_OK, if the filesystem is exported public, and if the 171 * incoming request is using the public filehandle. The check duplicates 172 * the exportmatch() call done in checkexport(), and we should consider 173 * modifying those routines to avoid the duplication. For now, we optimize 174 * by calling exportmatch() only after checking that the dispatch routine 175 * supports RPC_PUBLICFH_OK, and if the filesystem is explicitly exported 176 * public (i.e., not the placeholder). 177 */ 178 #define PUBLICFH_CHECK(disp, exi, fsid, xfid) \ 179 ((disp->dis_flags & RPC_PUBLICFH_OK) && \ 180 ((exi->exi_export.ex_flags & EX_PUBLIC) || \ 181 (exi == exi_public && exportmatch(exi_root, \ 182 fsid, xfid)))) 183 184 static void nfs_srv_shutdown_all(int); 185 static void rfs4_server_start(int); 186 static void nullfree(void); 187 static void rfs_dispatch(struct svc_req *, SVCXPRT *); 188 static void acl_dispatch(struct svc_req *, SVCXPRT *); 189 static void common_dispatch(struct svc_req *, SVCXPRT *, 190 rpcvers_t, rpcvers_t, char *, 191 struct rpc_disptable *); 192 static void hanfsv4_failover(void); 193 static int checkauth(struct exportinfo *, struct svc_req *, cred_t *, int, 194 bool_t, bool_t *); 195 static char *client_name(struct svc_req *req); 196 static char *client_addr(struct svc_req *req, char *buf); 197 extern int sec_svc_getcred(struct svc_req *, cred_t *cr, char **, int *); 198 extern bool_t sec_svc_inrootlist(int, caddr_t, int, caddr_t *); 199 200 #define NFSLOG_COPY_NETBUF(exi, xprt, nb) { \ 201 (nb)->maxlen = (xprt)->xp_rtaddr.maxlen; \ 202 (nb)->len = (xprt)->xp_rtaddr.len; \ 203 (nb)->buf = kmem_alloc((nb)->len, KM_SLEEP); \ 204 bcopy((xprt)->xp_rtaddr.buf, (nb)->buf, (nb)->len); \ 205 } 206 207 /* 208 * Public Filehandle common nfs routines 209 */ 210 static int MCLpath(char **); 211 static void URLparse(char *); 212 213 /* 214 * NFS callout table. 215 * This table is used by svc_getreq() to dispatch a request with 216 * a given prog/vers pair to an appropriate service provider 217 * dispatch routine. 218 * 219 * NOTE: ordering is relied upon below when resetting the version min/max 220 * for NFS_PROGRAM. Careful, if this is ever changed. 221 */ 222 static SVC_CALLOUT __nfs_sc_clts[] = { 223 { NFS_PROGRAM, NFS_VERSMIN, NFS_VERSMAX, rfs_dispatch }, 224 { NFS_ACL_PROGRAM, NFS_ACL_VERSMIN, NFS_ACL_VERSMAX, acl_dispatch } 225 }; 226 227 static SVC_CALLOUT_TABLE nfs_sct_clts = { 228 sizeof (__nfs_sc_clts) / sizeof (__nfs_sc_clts[0]), FALSE, 229 __nfs_sc_clts 230 }; 231 232 static SVC_CALLOUT __nfs_sc_cots[] = { 233 { NFS_PROGRAM, NFS_VERSMIN, NFS_VERSMAX, rfs_dispatch }, 234 { NFS_ACL_PROGRAM, NFS_ACL_VERSMIN, NFS_ACL_VERSMAX, acl_dispatch } 235 }; 236 237 static SVC_CALLOUT_TABLE nfs_sct_cots = { 238 sizeof (__nfs_sc_cots) / sizeof (__nfs_sc_cots[0]), FALSE, __nfs_sc_cots 239 }; 240 241 static SVC_CALLOUT __nfs_sc_rdma[] = { 242 { NFS_PROGRAM, NFS_VERSMIN, NFS_VERSMAX, rfs_dispatch }, 243 { NFS_ACL_PROGRAM, NFS_ACL_VERSMIN, NFS_ACL_VERSMAX, acl_dispatch } 244 }; 245 246 static SVC_CALLOUT_TABLE nfs_sct_rdma = { 247 sizeof (__nfs_sc_rdma) / sizeof (__nfs_sc_rdma[0]), FALSE, __nfs_sc_rdma 248 }; 249 rpcvers_t nfs_versmin = NFS_VERSMIN_DEFAULT; 250 rpcvers_t nfs_versmax = NFS_VERSMAX_DEFAULT; 251 252 /* 253 * Used to track the state of the server so that initialization 254 * can be done properly. 255 */ 256 typedef enum { 257 NFS_SERVER_STOPPED, /* server state destroyed */ 258 NFS_SERVER_STOPPING, /* server state being destroyed */ 259 NFS_SERVER_RUNNING, 260 NFS_SERVER_QUIESCED, /* server state preserved */ 261 NFS_SERVER_OFFLINE /* server pool offline */ 262 } nfs_server_running_t; 263 264 static nfs_server_running_t nfs_server_upordown; 265 static kmutex_t nfs_server_upordown_lock; 266 static kcondvar_t nfs_server_upordown_cv; 267 268 /* 269 * DSS: distributed stable storage 270 * lists of all DSS paths: current, and before last warmstart 271 */ 272 nvlist_t *rfs4_dss_paths, *rfs4_dss_oldpaths; 273 274 int rfs4_dispatch(struct rpcdisp *, struct svc_req *, SVCXPRT *, char *); 275 bool_t rfs4_minorvers_mismatch(struct svc_req *, SVCXPRT *, void *); 276 277 /* 278 * RDMA wait variables. 279 */ 280 static kcondvar_t rdma_wait_cv; 281 static kmutex_t rdma_wait_mutex; 282 283 /* 284 * Will be called at the point the server pool is being unregistered 285 * from the pool list. From that point onwards, the pool is waiting 286 * to be drained and as such the server state is stale and pertains 287 * to the old instantiation of the NFS server pool. 288 */ 289 void 290 nfs_srv_offline(void) 291 { 292 mutex_enter(&nfs_server_upordown_lock); 293 if (nfs_server_upordown == NFS_SERVER_RUNNING) { 294 nfs_server_upordown = NFS_SERVER_OFFLINE; 295 } 296 mutex_exit(&nfs_server_upordown_lock); 297 } 298 299 /* 300 * Will be called at the point the server pool is being destroyed so 301 * all transports have been closed and no service threads are in 302 * existence. 303 * 304 * If we quiesce the server, we're shutting it down without destroying the 305 * server state. This allows it to warm start subsequently. 306 */ 307 void 308 nfs_srv_stop_all(void) 309 { 310 int quiesce = 0; 311 nfs_srv_shutdown_all(quiesce); 312 } 313 314 /* 315 * This alternative shutdown routine can be requested via nfssys() 316 */ 317 void 318 nfs_srv_quiesce_all(void) 319 { 320 int quiesce = 1; 321 nfs_srv_shutdown_all(quiesce); 322 } 323 324 static void 325 nfs_srv_shutdown_all(int quiesce) { 326 mutex_enter(&nfs_server_upordown_lock); 327 if (quiesce) { 328 if (nfs_server_upordown == NFS_SERVER_RUNNING || 329 nfs_server_upordown == NFS_SERVER_OFFLINE) { 330 nfs_server_upordown = NFS_SERVER_QUIESCED; 331 cv_signal(&nfs_server_upordown_cv); 332 333 /* reset DSS state, for subsequent warm restart */ 334 rfs4_dss_numnewpaths = 0; 335 rfs4_dss_newpaths = NULL; 336 337 cmn_err(CE_NOTE, "nfs_server: server is now quiesced; " 338 "NFSv4 state has been preserved"); 339 } 340 } else { 341 if (nfs_server_upordown == NFS_SERVER_OFFLINE) { 342 nfs_server_upordown = NFS_SERVER_STOPPING; 343 mutex_exit(&nfs_server_upordown_lock); 344 rfs4_state_fini(); 345 rfs4_fini_drc(nfs4_drc); 346 mutex_enter(&nfs_server_upordown_lock); 347 nfs_server_upordown = NFS_SERVER_STOPPED; 348 cv_signal(&nfs_server_upordown_cv); 349 } 350 } 351 mutex_exit(&nfs_server_upordown_lock); 352 } 353 354 static int 355 nfs_srv_set_sc_versions(struct file *fp, SVC_CALLOUT_TABLE **sctpp, 356 rpcvers_t versmin, rpcvers_t versmax) 357 { 358 struct strioctl strioc; 359 struct T_info_ack tinfo; 360 int error, retval; 361 362 /* 363 * Find out what type of transport this is. 364 */ 365 strioc.ic_cmd = TI_GETINFO; 366 strioc.ic_timout = -1; 367 strioc.ic_len = sizeof (tinfo); 368 strioc.ic_dp = (char *)&tinfo; 369 tinfo.PRIM_type = T_INFO_REQ; 370 371 error = strioctl(fp->f_vnode, I_STR, (intptr_t)&strioc, 0, K_TO_K, 372 CRED(), &retval); 373 if (error || retval) 374 return (error); 375 376 /* 377 * Based on our query of the transport type... 378 * 379 * Reset the min/max versions based on the caller's request 380 * NOTE: This assumes that NFS_PROGRAM is first in the array!! 381 * And the second entry is the NFS_ACL_PROGRAM. 382 */ 383 switch (tinfo.SERV_type) { 384 case T_CLTS: 385 if (versmax == NFS_V4) 386 return (EINVAL); 387 __nfs_sc_clts[0].sc_versmin = versmin; 388 __nfs_sc_clts[0].sc_versmax = versmax; 389 __nfs_sc_clts[1].sc_versmin = versmin; 390 __nfs_sc_clts[1].sc_versmax = versmax; 391 *sctpp = &nfs_sct_clts; 392 break; 393 case T_COTS: 394 case T_COTS_ORD: 395 __nfs_sc_cots[0].sc_versmin = versmin; 396 __nfs_sc_cots[0].sc_versmax = versmax; 397 /* For the NFS_ACL program, check the max version */ 398 if (versmax > NFS_ACL_VERSMAX) 399 versmax = NFS_ACL_VERSMAX; 400 __nfs_sc_cots[1].sc_versmin = versmin; 401 __nfs_sc_cots[1].sc_versmax = versmax; 402 *sctpp = &nfs_sct_cots; 403 break; 404 default: 405 error = EINVAL; 406 } 407 408 return (error); 409 } 410 411 /* 412 * NFS Server system call. 413 * Does all of the work of running a NFS server. 414 * uap->fd is the fd of an open transport provider 415 */ 416 int 417 nfs_svc(struct nfs_svc_args *arg, model_t model) 418 { 419 file_t *fp; 420 SVCMASTERXPRT *xprt; 421 int error; 422 int readsize; 423 char buf[KNC_STRSIZE]; 424 size_t len; 425 STRUCT_HANDLE(nfs_svc_args, uap); 426 struct netbuf addrmask; 427 SVC_CALLOUT_TABLE *sctp = NULL; 428 429 #ifdef lint 430 model = model; /* STRUCT macros don't always refer to it */ 431 #endif 432 433 STRUCT_SET_HANDLE(uap, model, arg); 434 435 /* Check privileges in nfssys() */ 436 437 if ((fp = getf(STRUCT_FGET(uap, fd))) == NULL) 438 return (EBADF); 439 440 /* 441 * Set read buffer size to rsize 442 * and add room for RPC headers. 443 */ 444 readsize = nfs3tsize() + (RPC_MAXDATASIZE - NFS_MAXDATA); 445 if (readsize < RPC_MAXDATASIZE) 446 readsize = RPC_MAXDATASIZE; 447 448 error = copyinstr((const char *)STRUCT_FGETP(uap, netid), buf, 449 KNC_STRSIZE, &len); 450 if (error) { 451 releasef(STRUCT_FGET(uap, fd)); 452 return (error); 453 } 454 455 addrmask.len = STRUCT_FGET(uap, addrmask.len); 456 addrmask.maxlen = STRUCT_FGET(uap, addrmask.maxlen); 457 addrmask.buf = kmem_alloc(addrmask.maxlen, KM_SLEEP); 458 error = copyin(STRUCT_FGETP(uap, addrmask.buf), addrmask.buf, 459 addrmask.len); 460 if (error) { 461 releasef(STRUCT_FGET(uap, fd)); 462 kmem_free(addrmask.buf, addrmask.maxlen); 463 return (error); 464 } 465 466 nfs_versmin = STRUCT_FGET(uap, versmin); 467 nfs_versmax = STRUCT_FGET(uap, versmax); 468 469 /* Double check the vers min/max ranges */ 470 if ((nfs_versmin > nfs_versmax) || 471 (nfs_versmin < NFS_VERSMIN) || 472 (nfs_versmax > NFS_VERSMAX)) { 473 nfs_versmin = NFS_VERSMIN_DEFAULT; 474 nfs_versmax = NFS_VERSMAX_DEFAULT; 475 } 476 477 if (error = 478 nfs_srv_set_sc_versions(fp, &sctp, nfs_versmin, nfs_versmax)) { 479 releasef(STRUCT_FGET(uap, fd)); 480 kmem_free(addrmask.buf, addrmask.maxlen); 481 return (error); 482 } 483 484 /* Initialize nfsv4 server */ 485 if (nfs_versmax == (rpcvers_t)NFS_V4) 486 rfs4_server_start(STRUCT_FGET(uap, delegation)); 487 488 /* Create a transport handle. */ 489 error = svc_tli_kcreate(fp, readsize, buf, &addrmask, &xprt, 490 sctp, NULL, NFS_SVCPOOL_ID, TRUE); 491 492 if (error) 493 kmem_free(addrmask.buf, addrmask.maxlen); 494 495 releasef(STRUCT_FGET(uap, fd)); 496 497 /* HA-NFSv4: save the cluster nodeid */ 498 if (cluster_bootflags & CLUSTER_BOOTED) 499 lm_global_nlmid = clconf_get_nodeid(); 500 501 return (error); 502 } 503 504 static void 505 rfs4_server_start(int nfs4_srv_delegation) 506 { 507 /* 508 * Determine if the server has previously been "started" and 509 * if not, do the per instance initialization 510 */ 511 mutex_enter(&nfs_server_upordown_lock); 512 513 if (nfs_server_upordown != NFS_SERVER_RUNNING) { 514 /* Do we need to stop and wait on the previous server? */ 515 while (nfs_server_upordown == NFS_SERVER_STOPPING || 516 nfs_server_upordown == NFS_SERVER_OFFLINE) 517 cv_wait(&nfs_server_upordown_cv, 518 &nfs_server_upordown_lock); 519 520 if (nfs_server_upordown != NFS_SERVER_RUNNING) { 521 (void) svc_pool_control(NFS_SVCPOOL_ID, 522 SVCPSET_UNREGISTER_PROC, (void *)&nfs_srv_offline); 523 (void) svc_pool_control(NFS_SVCPOOL_ID, 524 SVCPSET_SHUTDOWN_PROC, (void *)&nfs_srv_stop_all); 525 526 /* is this an nfsd warm start? */ 527 if (nfs_server_upordown == NFS_SERVER_QUIESCED) { 528 cmn_err(CE_NOTE, "nfs_server: " 529 "server was previously quiesced; " 530 "existing NFSv4 state will be re-used"); 531 532 /* 533 * HA-NFSv4: this is also the signal 534 * that a Resource Group failover has 535 * occurred. 536 */ 537 if (cluster_bootflags & CLUSTER_BOOTED) 538 hanfsv4_failover(); 539 } else { 540 /* cold start */ 541 rfs4_state_init(); 542 nfs4_drc = rfs4_init_drc(nfs4_drc_max, 543 nfs4_drc_hash); 544 } 545 546 /* 547 * Check to see if delegation is to be 548 * enabled at the server 549 */ 550 if (nfs4_srv_delegation != FALSE) 551 rfs4_set_deleg_policy(SRV_NORMAL_DELEGATE); 552 553 nfs_server_upordown = NFS_SERVER_RUNNING; 554 } 555 cv_signal(&nfs_server_upordown_cv); 556 } 557 mutex_exit(&nfs_server_upordown_lock); 558 } 559 560 /* 561 * If RDMA device available, 562 * start RDMA listener. 563 */ 564 int 565 rdma_start(struct rdma_svc_args *rsa) 566 { 567 int error; 568 rdma_xprt_group_t started_rdma_xprts; 569 rdma_stat stat; 570 int svc_state = 0; 571 572 /* Double check the vers min/max ranges */ 573 if ((rsa->nfs_versmin > rsa->nfs_versmax) || 574 (rsa->nfs_versmin < NFS_VERSMIN) || 575 (rsa->nfs_versmax > NFS_VERSMAX)) { 576 rsa->nfs_versmin = NFS_VERSMIN_DEFAULT; 577 rsa->nfs_versmax = NFS_VERSMAX_DEFAULT; 578 } 579 nfs_versmin = rsa->nfs_versmin; 580 nfs_versmax = rsa->nfs_versmax; 581 582 /* Set the versions in the callout table */ 583 __nfs_sc_rdma[0].sc_versmin = rsa->nfs_versmin; 584 __nfs_sc_rdma[0].sc_versmax = rsa->nfs_versmax; 585 /* For the NFS_ACL program, check the max version */ 586 __nfs_sc_rdma[1].sc_versmin = rsa->nfs_versmin; 587 if (rsa->nfs_versmax > NFS_ACL_VERSMAX) 588 __nfs_sc_rdma[1].sc_versmax = NFS_ACL_VERSMAX; 589 else 590 __nfs_sc_rdma[1].sc_versmax = rsa->nfs_versmax; 591 592 /* Initialize nfsv4 server */ 593 if (rsa->nfs_versmax == (rpcvers_t)NFS_V4) 594 rfs4_server_start(rsa->delegation); 595 596 started_rdma_xprts.rtg_count = 0; 597 started_rdma_xprts.rtg_listhead = NULL; 598 started_rdma_xprts.rtg_poolid = rsa->poolid; 599 600 restart: 601 error = svc_rdma_kcreate(rsa->netid, &nfs_sct_rdma, rsa->poolid, 602 &started_rdma_xprts); 603 604 svc_state = !error; 605 606 while (!error) { 607 608 /* 609 * wait till either interrupted by a signal on 610 * nfs service stop/restart or signalled by a 611 * rdma plugin attach/detatch. 612 */ 613 614 stat = rdma_kwait(); 615 616 /* 617 * stop services if running -- either on a HCA detach event 618 * or if the nfs service is stopped/restarted. 619 */ 620 621 if ((stat == RDMA_HCA_DETACH || stat == RDMA_INTR) && 622 svc_state) { 623 rdma_stop(&started_rdma_xprts); 624 svc_state = 0; 625 } 626 627 /* 628 * nfs service stop/restart, break out of the 629 * wait loop and return; 630 */ 631 if (stat == RDMA_INTR) 632 return (0); 633 634 /* 635 * restart stopped services on a HCA attach event 636 * (if not already running) 637 */ 638 639 if ((stat == RDMA_HCA_ATTACH) && (svc_state == 0)) 640 goto restart; 641 642 /* 643 * loop until a nfs service stop/restart 644 */ 645 } 646 647 return (error); 648 } 649 650 /* ARGSUSED */ 651 void 652 rpc_null(caddr_t *argp, caddr_t *resp, struct exportinfo *exi, 653 struct svc_req *req, cred_t *cr, bool_t ro) 654 { 655 } 656 657 /* ARGSUSED */ 658 void 659 rpc_null_v3(caddr_t *argp, caddr_t *resp, struct exportinfo *exi, 660 struct svc_req *req, cred_t *cr, bool_t ro) 661 { 662 DTRACE_NFSV3_3(op__null__start, struct svc_req *, req, 663 cred_t *, cr, vnode_t *, NULL); 664 DTRACE_NFSV3_3(op__null__done, struct svc_req *, req, 665 cred_t *, cr, vnode_t *, NULL); 666 } 667 668 /* ARGSUSED */ 669 static void 670 rfs_error(caddr_t *argp, caddr_t *resp, struct exportinfo *exi, 671 struct svc_req *req, cred_t *cr, bool_t ro) 672 { 673 /* return (EOPNOTSUPP); */ 674 } 675 676 static void 677 nullfree(void) 678 { 679 } 680 681 static char *rfscallnames_v2[] = { 682 "RFS2_NULL", 683 "RFS2_GETATTR", 684 "RFS2_SETATTR", 685 "RFS2_ROOT", 686 "RFS2_LOOKUP", 687 "RFS2_READLINK", 688 "RFS2_READ", 689 "RFS2_WRITECACHE", 690 "RFS2_WRITE", 691 "RFS2_CREATE", 692 "RFS2_REMOVE", 693 "RFS2_RENAME", 694 "RFS2_LINK", 695 "RFS2_SYMLINK", 696 "RFS2_MKDIR", 697 "RFS2_RMDIR", 698 "RFS2_READDIR", 699 "RFS2_STATFS" 700 }; 701 702 static struct rpcdisp rfsdisptab_v2[] = { 703 /* 704 * NFS VERSION 2 705 */ 706 707 /* RFS_NULL = 0 */ 708 {rpc_null, 709 xdr_void, NULL_xdrproc_t, 0, 710 xdr_void, NULL_xdrproc_t, 0, 711 nullfree, RPC_IDEMPOTENT, 712 0}, 713 714 /* RFS_GETATTR = 1 */ 715 {rfs_getattr, 716 xdr_fhandle, xdr_fastfhandle, sizeof (fhandle_t), 717 xdr_attrstat, xdr_fastattrstat, sizeof (struct nfsattrstat), 718 nullfree, RPC_IDEMPOTENT|RPC_ALLOWANON|RPC_MAPRESP, 719 rfs_getattr_getfh}, 720 721 /* RFS_SETATTR = 2 */ 722 {rfs_setattr, 723 xdr_saargs, NULL_xdrproc_t, sizeof (struct nfssaargs), 724 xdr_attrstat, xdr_fastattrstat, sizeof (struct nfsattrstat), 725 nullfree, RPC_MAPRESP, 726 rfs_setattr_getfh}, 727 728 /* RFS_ROOT = 3 *** NO LONGER SUPPORTED *** */ 729 {rfs_error, 730 xdr_void, NULL_xdrproc_t, 0, 731 xdr_void, NULL_xdrproc_t, 0, 732 nullfree, RPC_IDEMPOTENT, 733 0}, 734 735 /* RFS_LOOKUP = 4 */ 736 {rfs_lookup, 737 xdr_diropargs, NULL_xdrproc_t, sizeof (struct nfsdiropargs), 738 xdr_diropres, xdr_fastdiropres, sizeof (struct nfsdiropres), 739 nullfree, RPC_IDEMPOTENT|RPC_MAPRESP|RPC_PUBLICFH_OK, 740 rfs_lookup_getfh}, 741 742 /* RFS_READLINK = 5 */ 743 {rfs_readlink, 744 xdr_fhandle, xdr_fastfhandle, sizeof (fhandle_t), 745 xdr_rdlnres, NULL_xdrproc_t, sizeof (struct nfsrdlnres), 746 rfs_rlfree, RPC_IDEMPOTENT, 747 rfs_readlink_getfh}, 748 749 /* RFS_READ = 6 */ 750 {rfs_read, 751 xdr_readargs, NULL_xdrproc_t, sizeof (struct nfsreadargs), 752 xdr_rdresult, NULL_xdrproc_t, sizeof (struct nfsrdresult), 753 rfs_rdfree, RPC_IDEMPOTENT, 754 rfs_read_getfh}, 755 756 /* RFS_WRITECACHE = 7 *** NO LONGER SUPPORTED *** */ 757 {rfs_error, 758 xdr_void, NULL_xdrproc_t, 0, 759 xdr_void, NULL_xdrproc_t, 0, 760 nullfree, RPC_IDEMPOTENT, 761 0}, 762 763 /* RFS_WRITE = 8 */ 764 {rfs_write, 765 xdr_writeargs, NULL_xdrproc_t, sizeof (struct nfswriteargs), 766 xdr_attrstat, xdr_fastattrstat, sizeof (struct nfsattrstat), 767 nullfree, RPC_MAPRESP, 768 rfs_write_getfh}, 769 770 /* RFS_CREATE = 9 */ 771 {rfs_create, 772 xdr_creatargs, NULL_xdrproc_t, sizeof (struct nfscreatargs), 773 xdr_diropres, xdr_fastdiropres, sizeof (struct nfsdiropres), 774 nullfree, RPC_MAPRESP, 775 rfs_create_getfh}, 776 777 /* RFS_REMOVE = 10 */ 778 {rfs_remove, 779 xdr_diropargs, NULL_xdrproc_t, sizeof (struct nfsdiropargs), 780 #ifdef _LITTLE_ENDIAN 781 xdr_enum, xdr_fastenum, sizeof (enum nfsstat), 782 #else 783 xdr_enum, NULL_xdrproc_t, sizeof (enum nfsstat), 784 #endif 785 nullfree, RPC_MAPRESP, 786 rfs_remove_getfh}, 787 788 /* RFS_RENAME = 11 */ 789 {rfs_rename, 790 xdr_rnmargs, NULL_xdrproc_t, sizeof (struct nfsrnmargs), 791 #ifdef _LITTLE_ENDIAN 792 xdr_enum, xdr_fastenum, sizeof (enum nfsstat), 793 #else 794 xdr_enum, NULL_xdrproc_t, sizeof (enum nfsstat), 795 #endif 796 nullfree, RPC_MAPRESP, 797 rfs_rename_getfh}, 798 799 /* RFS_LINK = 12 */ 800 {rfs_link, 801 xdr_linkargs, NULL_xdrproc_t, sizeof (struct nfslinkargs), 802 #ifdef _LITTLE_ENDIAN 803 xdr_enum, xdr_fastenum, sizeof (enum nfsstat), 804 #else 805 xdr_enum, NULL_xdrproc_t, sizeof (enum nfsstat), 806 #endif 807 nullfree, RPC_MAPRESP, 808 rfs_link_getfh}, 809 810 /* RFS_SYMLINK = 13 */ 811 {rfs_symlink, 812 xdr_slargs, NULL_xdrproc_t, sizeof (struct nfsslargs), 813 #ifdef _LITTLE_ENDIAN 814 xdr_enum, xdr_fastenum, sizeof (enum nfsstat), 815 #else 816 xdr_enum, NULL_xdrproc_t, sizeof (enum nfsstat), 817 #endif 818 nullfree, RPC_MAPRESP, 819 rfs_symlink_getfh}, 820 821 /* RFS_MKDIR = 14 */ 822 {rfs_mkdir, 823 xdr_creatargs, NULL_xdrproc_t, sizeof (struct nfscreatargs), 824 xdr_diropres, xdr_fastdiropres, sizeof (struct nfsdiropres), 825 nullfree, RPC_MAPRESP, 826 rfs_mkdir_getfh}, 827 828 /* RFS_RMDIR = 15 */ 829 {rfs_rmdir, 830 xdr_diropargs, NULL_xdrproc_t, sizeof (struct nfsdiropargs), 831 #ifdef _LITTLE_ENDIAN 832 xdr_enum, xdr_fastenum, sizeof (enum nfsstat), 833 #else 834 xdr_enum, NULL_xdrproc_t, sizeof (enum nfsstat), 835 #endif 836 nullfree, RPC_MAPRESP, 837 rfs_rmdir_getfh}, 838 839 /* RFS_READDIR = 16 */ 840 {rfs_readdir, 841 xdr_rddirargs, NULL_xdrproc_t, sizeof (struct nfsrddirargs), 842 xdr_putrddirres, NULL_xdrproc_t, sizeof (struct nfsrddirres), 843 rfs_rddirfree, RPC_IDEMPOTENT, 844 rfs_readdir_getfh}, 845 846 /* RFS_STATFS = 17 */ 847 {rfs_statfs, 848 xdr_fhandle, xdr_fastfhandle, sizeof (fhandle_t), 849 xdr_statfs, xdr_faststatfs, sizeof (struct nfsstatfs), 850 nullfree, RPC_IDEMPOTENT|RPC_ALLOWANON|RPC_MAPRESP, 851 rfs_statfs_getfh}, 852 }; 853 854 static char *rfscallnames_v3[] = { 855 "RFS3_NULL", 856 "RFS3_GETATTR", 857 "RFS3_SETATTR", 858 "RFS3_LOOKUP", 859 "RFS3_ACCESS", 860 "RFS3_READLINK", 861 "RFS3_READ", 862 "RFS3_WRITE", 863 "RFS3_CREATE", 864 "RFS3_MKDIR", 865 "RFS3_SYMLINK", 866 "RFS3_MKNOD", 867 "RFS3_REMOVE", 868 "RFS3_RMDIR", 869 "RFS3_RENAME", 870 "RFS3_LINK", 871 "RFS3_READDIR", 872 "RFS3_READDIRPLUS", 873 "RFS3_FSSTAT", 874 "RFS3_FSINFO", 875 "RFS3_PATHCONF", 876 "RFS3_COMMIT" 877 }; 878 879 static struct rpcdisp rfsdisptab_v3[] = { 880 /* 881 * NFS VERSION 3 882 */ 883 884 /* RFS_NULL = 0 */ 885 {rpc_null_v3, 886 xdr_void, NULL_xdrproc_t, 0, 887 xdr_void, NULL_xdrproc_t, 0, 888 nullfree, RPC_IDEMPOTENT, 889 0}, 890 891 /* RFS3_GETATTR = 1 */ 892 {rfs3_getattr, 893 xdr_nfs_fh3_server, NULL_xdrproc_t, sizeof (GETATTR3args), 894 xdr_GETATTR3res, NULL_xdrproc_t, sizeof (GETATTR3res), 895 nullfree, (RPC_IDEMPOTENT | RPC_ALLOWANON), 896 rfs3_getattr_getfh}, 897 898 /* RFS3_SETATTR = 2 */ 899 {rfs3_setattr, 900 xdr_SETATTR3args, NULL_xdrproc_t, sizeof (SETATTR3args), 901 xdr_SETATTR3res, NULL_xdrproc_t, sizeof (SETATTR3res), 902 nullfree, 0, 903 rfs3_setattr_getfh}, 904 905 /* RFS3_LOOKUP = 3 */ 906 {rfs3_lookup, 907 xdr_diropargs3, NULL_xdrproc_t, sizeof (LOOKUP3args), 908 xdr_LOOKUP3res, NULL_xdrproc_t, sizeof (LOOKUP3res), 909 nullfree, (RPC_IDEMPOTENT | RPC_PUBLICFH_OK), 910 rfs3_lookup_getfh}, 911 912 /* RFS3_ACCESS = 4 */ 913 {rfs3_access, 914 xdr_ACCESS3args, NULL_xdrproc_t, sizeof (ACCESS3args), 915 xdr_ACCESS3res, NULL_xdrproc_t, sizeof (ACCESS3res), 916 nullfree, RPC_IDEMPOTENT, 917 rfs3_access_getfh}, 918 919 /* RFS3_READLINK = 5 */ 920 {rfs3_readlink, 921 xdr_nfs_fh3_server, NULL_xdrproc_t, sizeof (READLINK3args), 922 xdr_READLINK3res, NULL_xdrproc_t, sizeof (READLINK3res), 923 rfs3_readlink_free, RPC_IDEMPOTENT, 924 rfs3_readlink_getfh}, 925 926 /* RFS3_READ = 6 */ 927 {rfs3_read, 928 xdr_READ3args, NULL_xdrproc_t, sizeof (READ3args), 929 xdr_READ3res, NULL_xdrproc_t, sizeof (READ3res), 930 rfs3_read_free, RPC_IDEMPOTENT, 931 rfs3_read_getfh}, 932 933 /* RFS3_WRITE = 7 */ 934 {rfs3_write, 935 xdr_WRITE3args, NULL_xdrproc_t, sizeof (WRITE3args), 936 xdr_WRITE3res, NULL_xdrproc_t, sizeof (WRITE3res), 937 nullfree, 0, 938 rfs3_write_getfh}, 939 940 /* RFS3_CREATE = 8 */ 941 {rfs3_create, 942 xdr_CREATE3args, NULL_xdrproc_t, sizeof (CREATE3args), 943 xdr_CREATE3res, NULL_xdrproc_t, sizeof (CREATE3res), 944 nullfree, 0, 945 rfs3_create_getfh}, 946 947 /* RFS3_MKDIR = 9 */ 948 {rfs3_mkdir, 949 xdr_MKDIR3args, NULL_xdrproc_t, sizeof (MKDIR3args), 950 xdr_MKDIR3res, NULL_xdrproc_t, sizeof (MKDIR3res), 951 nullfree, 0, 952 rfs3_mkdir_getfh}, 953 954 /* RFS3_SYMLINK = 10 */ 955 {rfs3_symlink, 956 xdr_SYMLINK3args, NULL_xdrproc_t, sizeof (SYMLINK3args), 957 xdr_SYMLINK3res, NULL_xdrproc_t, sizeof (SYMLINK3res), 958 nullfree, 0, 959 rfs3_symlink_getfh}, 960 961 /* RFS3_MKNOD = 11 */ 962 {rfs3_mknod, 963 xdr_MKNOD3args, NULL_xdrproc_t, sizeof (MKNOD3args), 964 xdr_MKNOD3res, NULL_xdrproc_t, sizeof (MKNOD3res), 965 nullfree, 0, 966 rfs3_mknod_getfh}, 967 968 /* RFS3_REMOVE = 12 */ 969 {rfs3_remove, 970 xdr_diropargs3, NULL_xdrproc_t, sizeof (REMOVE3args), 971 xdr_REMOVE3res, NULL_xdrproc_t, sizeof (REMOVE3res), 972 nullfree, 0, 973 rfs3_remove_getfh}, 974 975 /* RFS3_RMDIR = 13 */ 976 {rfs3_rmdir, 977 xdr_diropargs3, NULL_xdrproc_t, sizeof (RMDIR3args), 978 xdr_RMDIR3res, NULL_xdrproc_t, sizeof (RMDIR3res), 979 nullfree, 0, 980 rfs3_rmdir_getfh}, 981 982 /* RFS3_RENAME = 14 */ 983 {rfs3_rename, 984 xdr_RENAME3args, NULL_xdrproc_t, sizeof (RENAME3args), 985 xdr_RENAME3res, NULL_xdrproc_t, sizeof (RENAME3res), 986 nullfree, 0, 987 rfs3_rename_getfh}, 988 989 /* RFS3_LINK = 15 */ 990 {rfs3_link, 991 xdr_LINK3args, NULL_xdrproc_t, sizeof (LINK3args), 992 xdr_LINK3res, NULL_xdrproc_t, sizeof (LINK3res), 993 nullfree, 0, 994 rfs3_link_getfh}, 995 996 /* RFS3_READDIR = 16 */ 997 {rfs3_readdir, 998 xdr_READDIR3args, NULL_xdrproc_t, sizeof (READDIR3args), 999 xdr_READDIR3res, NULL_xdrproc_t, sizeof (READDIR3res), 1000 rfs3_readdir_free, RPC_IDEMPOTENT, 1001 rfs3_readdir_getfh}, 1002 1003 /* RFS3_READDIRPLUS = 17 */ 1004 {rfs3_readdirplus, 1005 xdr_READDIRPLUS3args, NULL_xdrproc_t, sizeof (READDIRPLUS3args), 1006 xdr_READDIRPLUS3res, NULL_xdrproc_t, sizeof (READDIRPLUS3res), 1007 rfs3_readdirplus_free, RPC_AVOIDWORK, 1008 rfs3_readdirplus_getfh}, 1009 1010 /* RFS3_FSSTAT = 18 */ 1011 {rfs3_fsstat, 1012 xdr_nfs_fh3_server, NULL_xdrproc_t, sizeof (FSSTAT3args), 1013 xdr_FSSTAT3res, NULL_xdrproc_t, sizeof (FSSTAT3res), 1014 nullfree, RPC_IDEMPOTENT, 1015 rfs3_fsstat_getfh}, 1016 1017 /* RFS3_FSINFO = 19 */ 1018 {rfs3_fsinfo, 1019 xdr_nfs_fh3_server, NULL_xdrproc_t, sizeof (FSINFO3args), 1020 xdr_FSINFO3res, NULL_xdrproc_t, sizeof (FSINFO3res), 1021 nullfree, RPC_IDEMPOTENT|RPC_ALLOWANON, 1022 rfs3_fsinfo_getfh}, 1023 1024 /* RFS3_PATHCONF = 20 */ 1025 {rfs3_pathconf, 1026 xdr_nfs_fh3_server, NULL_xdrproc_t, sizeof (PATHCONF3args), 1027 xdr_PATHCONF3res, NULL_xdrproc_t, sizeof (PATHCONF3res), 1028 nullfree, RPC_IDEMPOTENT, 1029 rfs3_pathconf_getfh}, 1030 1031 /* RFS3_COMMIT = 21 */ 1032 {rfs3_commit, 1033 xdr_COMMIT3args, NULL_xdrproc_t, sizeof (COMMIT3args), 1034 xdr_COMMIT3res, NULL_xdrproc_t, sizeof (COMMIT3res), 1035 nullfree, RPC_IDEMPOTENT, 1036 rfs3_commit_getfh}, 1037 }; 1038 1039 static char *rfscallnames_v4[] = { 1040 "RFS4_NULL", 1041 "RFS4_COMPOUND", 1042 "RFS4_NULL", 1043 "RFS4_NULL", 1044 "RFS4_NULL", 1045 "RFS4_NULL", 1046 "RFS4_NULL", 1047 "RFS4_NULL", 1048 "RFS4_CREATE" 1049 }; 1050 1051 static struct rpcdisp rfsdisptab_v4[] = { 1052 /* 1053 * NFS VERSION 4 1054 */ 1055 1056 /* RFS_NULL = 0 */ 1057 {rpc_null, 1058 xdr_void, NULL_xdrproc_t, 0, 1059 xdr_void, NULL_xdrproc_t, 0, 1060 nullfree, RPC_IDEMPOTENT, 0}, 1061 1062 /* RFS4_compound = 1 */ 1063 {rfs4_compound, 1064 xdr_COMPOUND4args_srv, NULL_xdrproc_t, sizeof (COMPOUND4args), 1065 xdr_COMPOUND4res_srv, NULL_xdrproc_t, sizeof (COMPOUND4res), 1066 rfs4_compound_free, 0, 0}, 1067 }; 1068 1069 union rfs_args { 1070 /* 1071 * NFS VERSION 2 1072 */ 1073 1074 /* RFS_NULL = 0 */ 1075 1076 /* RFS_GETATTR = 1 */ 1077 fhandle_t nfs2_getattr_args; 1078 1079 /* RFS_SETATTR = 2 */ 1080 struct nfssaargs nfs2_setattr_args; 1081 1082 /* RFS_ROOT = 3 *** NO LONGER SUPPORTED *** */ 1083 1084 /* RFS_LOOKUP = 4 */ 1085 struct nfsdiropargs nfs2_lookup_args; 1086 1087 /* RFS_READLINK = 5 */ 1088 fhandle_t nfs2_readlink_args; 1089 1090 /* RFS_READ = 6 */ 1091 struct nfsreadargs nfs2_read_args; 1092 1093 /* RFS_WRITECACHE = 7 *** NO LONGER SUPPORTED *** */ 1094 1095 /* RFS_WRITE = 8 */ 1096 struct nfswriteargs nfs2_write_args; 1097 1098 /* RFS_CREATE = 9 */ 1099 struct nfscreatargs nfs2_create_args; 1100 1101 /* RFS_REMOVE = 10 */ 1102 struct nfsdiropargs nfs2_remove_args; 1103 1104 /* RFS_RENAME = 11 */ 1105 struct nfsrnmargs nfs2_rename_args; 1106 1107 /* RFS_LINK = 12 */ 1108 struct nfslinkargs nfs2_link_args; 1109 1110 /* RFS_SYMLINK = 13 */ 1111 struct nfsslargs nfs2_symlink_args; 1112 1113 /* RFS_MKDIR = 14 */ 1114 struct nfscreatargs nfs2_mkdir_args; 1115 1116 /* RFS_RMDIR = 15 */ 1117 struct nfsdiropargs nfs2_rmdir_args; 1118 1119 /* RFS_READDIR = 16 */ 1120 struct nfsrddirargs nfs2_readdir_args; 1121 1122 /* RFS_STATFS = 17 */ 1123 fhandle_t nfs2_statfs_args; 1124 1125 /* 1126 * NFS VERSION 3 1127 */ 1128 1129 /* RFS_NULL = 0 */ 1130 1131 /* RFS3_GETATTR = 1 */ 1132 GETATTR3args nfs3_getattr_args; 1133 1134 /* RFS3_SETATTR = 2 */ 1135 SETATTR3args nfs3_setattr_args; 1136 1137 /* RFS3_LOOKUP = 3 */ 1138 LOOKUP3args nfs3_lookup_args; 1139 1140 /* RFS3_ACCESS = 4 */ 1141 ACCESS3args nfs3_access_args; 1142 1143 /* RFS3_READLINK = 5 */ 1144 READLINK3args nfs3_readlink_args; 1145 1146 /* RFS3_READ = 6 */ 1147 READ3args nfs3_read_args; 1148 1149 /* RFS3_WRITE = 7 */ 1150 WRITE3args nfs3_write_args; 1151 1152 /* RFS3_CREATE = 8 */ 1153 CREATE3args nfs3_create_args; 1154 1155 /* RFS3_MKDIR = 9 */ 1156 MKDIR3args nfs3_mkdir_args; 1157 1158 /* RFS3_SYMLINK = 10 */ 1159 SYMLINK3args nfs3_symlink_args; 1160 1161 /* RFS3_MKNOD = 11 */ 1162 MKNOD3args nfs3_mknod_args; 1163 1164 /* RFS3_REMOVE = 12 */ 1165 REMOVE3args nfs3_remove_args; 1166 1167 /* RFS3_RMDIR = 13 */ 1168 RMDIR3args nfs3_rmdir_args; 1169 1170 /* RFS3_RENAME = 14 */ 1171 RENAME3args nfs3_rename_args; 1172 1173 /* RFS3_LINK = 15 */ 1174 LINK3args nfs3_link_args; 1175 1176 /* RFS3_READDIR = 16 */ 1177 READDIR3args nfs3_readdir_args; 1178 1179 /* RFS3_READDIRPLUS = 17 */ 1180 READDIRPLUS3args nfs3_readdirplus_args; 1181 1182 /* RFS3_FSSTAT = 18 */ 1183 FSSTAT3args nfs3_fsstat_args; 1184 1185 /* RFS3_FSINFO = 19 */ 1186 FSINFO3args nfs3_fsinfo_args; 1187 1188 /* RFS3_PATHCONF = 20 */ 1189 PATHCONF3args nfs3_pathconf_args; 1190 1191 /* RFS3_COMMIT = 21 */ 1192 COMMIT3args nfs3_commit_args; 1193 1194 /* 1195 * NFS VERSION 4 1196 */ 1197 1198 /* RFS_NULL = 0 */ 1199 1200 /* COMPUND = 1 */ 1201 COMPOUND4args nfs4_compound_args; 1202 }; 1203 1204 union rfs_res { 1205 /* 1206 * NFS VERSION 2 1207 */ 1208 1209 /* RFS_NULL = 0 */ 1210 1211 /* RFS_GETATTR = 1 */ 1212 struct nfsattrstat nfs2_getattr_res; 1213 1214 /* RFS_SETATTR = 2 */ 1215 struct nfsattrstat nfs2_setattr_res; 1216 1217 /* RFS_ROOT = 3 *** NO LONGER SUPPORTED *** */ 1218 1219 /* RFS_LOOKUP = 4 */ 1220 struct nfsdiropres nfs2_lookup_res; 1221 1222 /* RFS_READLINK = 5 */ 1223 struct nfsrdlnres nfs2_readlink_res; 1224 1225 /* RFS_READ = 6 */ 1226 struct nfsrdresult nfs2_read_res; 1227 1228 /* RFS_WRITECACHE = 7 *** NO LONGER SUPPORTED *** */ 1229 1230 /* RFS_WRITE = 8 */ 1231 struct nfsattrstat nfs2_write_res; 1232 1233 /* RFS_CREATE = 9 */ 1234 struct nfsdiropres nfs2_create_res; 1235 1236 /* RFS_REMOVE = 10 */ 1237 enum nfsstat nfs2_remove_res; 1238 1239 /* RFS_RENAME = 11 */ 1240 enum nfsstat nfs2_rename_res; 1241 1242 /* RFS_LINK = 12 */ 1243 enum nfsstat nfs2_link_res; 1244 1245 /* RFS_SYMLINK = 13 */ 1246 enum nfsstat nfs2_symlink_res; 1247 1248 /* RFS_MKDIR = 14 */ 1249 struct nfsdiropres nfs2_mkdir_res; 1250 1251 /* RFS_RMDIR = 15 */ 1252 enum nfsstat nfs2_rmdir_res; 1253 1254 /* RFS_READDIR = 16 */ 1255 struct nfsrddirres nfs2_readdir_res; 1256 1257 /* RFS_STATFS = 17 */ 1258 struct nfsstatfs nfs2_statfs_res; 1259 1260 /* 1261 * NFS VERSION 3 1262 */ 1263 1264 /* RFS_NULL = 0 */ 1265 1266 /* RFS3_GETATTR = 1 */ 1267 GETATTR3res nfs3_getattr_res; 1268 1269 /* RFS3_SETATTR = 2 */ 1270 SETATTR3res nfs3_setattr_res; 1271 1272 /* RFS3_LOOKUP = 3 */ 1273 LOOKUP3res nfs3_lookup_res; 1274 1275 /* RFS3_ACCESS = 4 */ 1276 ACCESS3res nfs3_access_res; 1277 1278 /* RFS3_READLINK = 5 */ 1279 READLINK3res nfs3_readlink_res; 1280 1281 /* RFS3_READ = 6 */ 1282 READ3res nfs3_read_res; 1283 1284 /* RFS3_WRITE = 7 */ 1285 WRITE3res nfs3_write_res; 1286 1287 /* RFS3_CREATE = 8 */ 1288 CREATE3res nfs3_create_res; 1289 1290 /* RFS3_MKDIR = 9 */ 1291 MKDIR3res nfs3_mkdir_res; 1292 1293 /* RFS3_SYMLINK = 10 */ 1294 SYMLINK3res nfs3_symlink_res; 1295 1296 /* RFS3_MKNOD = 11 */ 1297 MKNOD3res nfs3_mknod_res; 1298 1299 /* RFS3_REMOVE = 12 */ 1300 REMOVE3res nfs3_remove_res; 1301 1302 /* RFS3_RMDIR = 13 */ 1303 RMDIR3res nfs3_rmdir_res; 1304 1305 /* RFS3_RENAME = 14 */ 1306 RENAME3res nfs3_rename_res; 1307 1308 /* RFS3_LINK = 15 */ 1309 LINK3res nfs3_link_res; 1310 1311 /* RFS3_READDIR = 16 */ 1312 READDIR3res nfs3_readdir_res; 1313 1314 /* RFS3_READDIRPLUS = 17 */ 1315 READDIRPLUS3res nfs3_readdirplus_res; 1316 1317 /* RFS3_FSSTAT = 18 */ 1318 FSSTAT3res nfs3_fsstat_res; 1319 1320 /* RFS3_FSINFO = 19 */ 1321 FSINFO3res nfs3_fsinfo_res; 1322 1323 /* RFS3_PATHCONF = 20 */ 1324 PATHCONF3res nfs3_pathconf_res; 1325 1326 /* RFS3_COMMIT = 21 */ 1327 COMMIT3res nfs3_commit_res; 1328 1329 /* 1330 * NFS VERSION 4 1331 */ 1332 1333 /* RFS_NULL = 0 */ 1334 1335 /* RFS4_COMPOUND = 1 */ 1336 COMPOUND4res nfs4_compound_res; 1337 1338 }; 1339 1340 static struct rpc_disptable rfs_disptable[] = { 1341 {sizeof (rfsdisptab_v2) / sizeof (rfsdisptab_v2[0]), 1342 rfscallnames_v2, 1343 &rfsproccnt_v2_ptr, rfsdisptab_v2}, 1344 {sizeof (rfsdisptab_v3) / sizeof (rfsdisptab_v3[0]), 1345 rfscallnames_v3, 1346 &rfsproccnt_v3_ptr, rfsdisptab_v3}, 1347 {sizeof (rfsdisptab_v4) / sizeof (rfsdisptab_v4[0]), 1348 rfscallnames_v4, 1349 &rfsproccnt_v4_ptr, rfsdisptab_v4}, 1350 }; 1351 1352 /* 1353 * If nfs_portmon is set, then clients are required to use privileged 1354 * ports (ports < IPPORT_RESERVED) in order to get NFS services. 1355 * 1356 * N.B.: this attempt to carry forward the already ill-conceived notion 1357 * of privileged ports for TCP/UDP is really quite ineffectual. Not only 1358 * is it transport-dependent, it's laughably easy to spoof. If you're 1359 * really interested in security, you must start with secure RPC instead. 1360 */ 1361 static int nfs_portmon = 0; 1362 1363 #ifdef DEBUG 1364 static int cred_hits = 0; 1365 static int cred_misses = 0; 1366 #endif 1367 1368 1369 #ifdef DEBUG 1370 /* 1371 * Debug code to allow disabling of rfs_dispatch() use of 1372 * fastxdrargs() and fastxdrres() calls for testing purposes. 1373 */ 1374 static int rfs_no_fast_xdrargs = 0; 1375 static int rfs_no_fast_xdrres = 0; 1376 #endif 1377 1378 union acl_args { 1379 /* 1380 * ACL VERSION 2 1381 */ 1382 1383 /* ACL2_NULL = 0 */ 1384 1385 /* ACL2_GETACL = 1 */ 1386 GETACL2args acl2_getacl_args; 1387 1388 /* ACL2_SETACL = 2 */ 1389 SETACL2args acl2_setacl_args; 1390 1391 /* ACL2_GETATTR = 3 */ 1392 GETATTR2args acl2_getattr_args; 1393 1394 /* ACL2_ACCESS = 4 */ 1395 ACCESS2args acl2_access_args; 1396 1397 /* ACL2_GETXATTRDIR = 5 */ 1398 GETXATTRDIR2args acl2_getxattrdir_args; 1399 1400 /* 1401 * ACL VERSION 3 1402 */ 1403 1404 /* ACL3_NULL = 0 */ 1405 1406 /* ACL3_GETACL = 1 */ 1407 GETACL3args acl3_getacl_args; 1408 1409 /* ACL3_SETACL = 2 */ 1410 SETACL3args acl3_setacl; 1411 1412 /* ACL3_GETXATTRDIR = 3 */ 1413 GETXATTRDIR3args acl3_getxattrdir_args; 1414 1415 }; 1416 1417 union acl_res { 1418 /* 1419 * ACL VERSION 2 1420 */ 1421 1422 /* ACL2_NULL = 0 */ 1423 1424 /* ACL2_GETACL = 1 */ 1425 GETACL2res acl2_getacl_res; 1426 1427 /* ACL2_SETACL = 2 */ 1428 SETACL2res acl2_setacl_res; 1429 1430 /* ACL2_GETATTR = 3 */ 1431 GETATTR2res acl2_getattr_res; 1432 1433 /* ACL2_ACCESS = 4 */ 1434 ACCESS2res acl2_access_res; 1435 1436 /* ACL2_GETXATTRDIR = 5 */ 1437 GETXATTRDIR2args acl2_getxattrdir_res; 1438 1439 /* 1440 * ACL VERSION 3 1441 */ 1442 1443 /* ACL3_NULL = 0 */ 1444 1445 /* ACL3_GETACL = 1 */ 1446 GETACL3res acl3_getacl_res; 1447 1448 /* ACL3_SETACL = 2 */ 1449 SETACL3res acl3_setacl_res; 1450 1451 /* ACL3_GETXATTRDIR = 3 */ 1452 GETXATTRDIR3res acl3_getxattrdir_res; 1453 1454 }; 1455 1456 static bool_t 1457 auth_tooweak(struct svc_req *req, char *res) 1458 { 1459 1460 if (req->rq_vers == NFS_VERSION && req->rq_proc == RFS_LOOKUP) { 1461 struct nfsdiropres *dr = (struct nfsdiropres *)res; 1462 if ((enum wnfsstat)dr->dr_status == WNFSERR_CLNT_FLAVOR) 1463 return (TRUE); 1464 } else if (req->rq_vers == NFS_V3 && req->rq_proc == NFSPROC3_LOOKUP) { 1465 LOOKUP3res *resp = (LOOKUP3res *)res; 1466 if ((enum wnfsstat)resp->status == WNFSERR_CLNT_FLAVOR) 1467 return (TRUE); 1468 } 1469 return (FALSE); 1470 } 1471 1472 1473 static void 1474 common_dispatch(struct svc_req *req, SVCXPRT *xprt, rpcvers_t min_vers, 1475 rpcvers_t max_vers, char *pgmname, 1476 struct rpc_disptable *disptable) 1477 { 1478 int which; 1479 rpcvers_t vers; 1480 char *args; 1481 union { 1482 union rfs_args ra; 1483 union acl_args aa; 1484 } args_buf; 1485 char *res; 1486 union { 1487 union rfs_res rr; 1488 union acl_res ar; 1489 } res_buf; 1490 struct rpcdisp *disp = NULL; 1491 int dis_flags = 0; 1492 cred_t *cr; 1493 int error = 0; 1494 int anon_ok; 1495 struct exportinfo *exi = NULL; 1496 unsigned int nfslog_rec_id; 1497 int dupstat; 1498 struct dupreq *dr; 1499 int authres; 1500 bool_t publicfh_ok = FALSE; 1501 enum_t auth_flavor; 1502 bool_t dupcached = FALSE; 1503 struct netbuf nb; 1504 bool_t logging_enabled = FALSE; 1505 struct exportinfo *nfslog_exi = NULL; 1506 char **procnames; 1507 char cbuf[INET6_ADDRSTRLEN]; /* to hold both IPv4 and IPv6 addr */ 1508 bool_t ro = FALSE; 1509 1510 vers = req->rq_vers; 1511 1512 if (vers < min_vers || vers > max_vers) { 1513 svcerr_progvers(req->rq_xprt, min_vers, max_vers); 1514 error++; 1515 cmn_err(CE_NOTE, "%s: bad version number %u", pgmname, vers); 1516 goto done; 1517 } 1518 vers -= min_vers; 1519 1520 which = req->rq_proc; 1521 if (which < 0 || which >= disptable[(int)vers].dis_nprocs) { 1522 svcerr_noproc(req->rq_xprt); 1523 error++; 1524 goto done; 1525 } 1526 1527 (*(disptable[(int)vers].dis_proccntp))[which].value.ui64++; 1528 1529 disp = &disptable[(int)vers].dis_table[which]; 1530 procnames = disptable[(int)vers].dis_procnames; 1531 1532 auth_flavor = req->rq_cred.oa_flavor; 1533 1534 /* 1535 * Deserialize into the args struct. 1536 */ 1537 args = (char *)&args_buf; 1538 1539 #ifdef DEBUG 1540 if (rfs_no_fast_xdrargs || (auth_flavor == RPCSEC_GSS) || 1541 disp->dis_fastxdrargs == NULL_xdrproc_t || 1542 !SVC_GETARGS(xprt, disp->dis_fastxdrargs, (char *)&args)) 1543 #else 1544 if ((auth_flavor == RPCSEC_GSS) || 1545 disp->dis_fastxdrargs == NULL_xdrproc_t || 1546 !SVC_GETARGS(xprt, disp->dis_fastxdrargs, (char *)&args)) 1547 #endif 1548 { 1549 bzero(args, disp->dis_argsz); 1550 if (!SVC_GETARGS(xprt, disp->dis_xdrargs, args)) { 1551 error++; 1552 /* 1553 * Check if we are outside our capabilities. 1554 */ 1555 if (rfs4_minorvers_mismatch(req, xprt, (void *)args)) 1556 goto done; 1557 1558 svcerr_decode(xprt); 1559 cmn_err(CE_NOTE, 1560 "Failed to decode arguments for %s version %u " 1561 "procedure %s client %s%s", 1562 pgmname, vers + min_vers, procnames[which], 1563 client_name(req), client_addr(req, cbuf)); 1564 goto done; 1565 } 1566 } 1567 1568 /* 1569 * If Version 4 use that specific dispatch function. 1570 */ 1571 if (req->rq_vers == 4) { 1572 error += rfs4_dispatch(disp, req, xprt, args); 1573 goto done; 1574 } 1575 1576 dis_flags = disp->dis_flags; 1577 1578 /* 1579 * Find export information and check authentication, 1580 * setting the credential if everything is ok. 1581 */ 1582 if (disp->dis_getfh != NULL) { 1583 void *fh; 1584 fsid_t *fsid; 1585 fid_t *fid, *xfid; 1586 fhandle_t *fh2; 1587 nfs_fh3 *fh3; 1588 1589 fh = (*disp->dis_getfh)(args); 1590 switch (req->rq_vers) { 1591 case NFS_VERSION: 1592 fh2 = (fhandle_t *)fh; 1593 fsid = &fh2->fh_fsid; 1594 fid = (fid_t *)&fh2->fh_len; 1595 xfid = (fid_t *)&fh2->fh_xlen; 1596 break; 1597 case NFS_V3: 1598 fh3 = (nfs_fh3 *)fh; 1599 fsid = &fh3->fh3_fsid; 1600 fid = FH3TOFIDP(fh3); 1601 xfid = FH3TOXFIDP(fh3); 1602 break; 1603 } 1604 1605 /* 1606 * Fix for bug 1038302 - corbin 1607 * There is a problem here if anonymous access is 1608 * disallowed. If the current request is part of the 1609 * client's mount process for the requested filesystem, 1610 * then it will carry root (uid 0) credentials on it, and 1611 * will be denied by checkauth if that client does not 1612 * have explicit root=0 permission. This will cause the 1613 * client's mount operation to fail. As a work-around, 1614 * we check here to see if the request is a getattr or 1615 * statfs operation on the exported vnode itself, and 1616 * pass a flag to checkauth with the result of this test. 1617 * 1618 * The filehandle refers to the mountpoint itself if 1619 * the fh_data and fh_xdata portions of the filehandle 1620 * are equal. 1621 * 1622 * Added anon_ok argument to checkauth(). 1623 */ 1624 1625 if ((dis_flags & RPC_ALLOWANON) && EQFID(fid, xfid)) 1626 anon_ok = 1; 1627 else 1628 anon_ok = 0; 1629 1630 cr = xprt->xp_cred; 1631 ASSERT(cr != NULL); 1632 #ifdef DEBUG 1633 if (crgetref(cr) != 1) { 1634 crfree(cr); 1635 cr = crget(); 1636 xprt->xp_cred = cr; 1637 cred_misses++; 1638 } else 1639 cred_hits++; 1640 #else 1641 if (crgetref(cr) != 1) { 1642 crfree(cr); 1643 cr = crget(); 1644 xprt->xp_cred = cr; 1645 } 1646 #endif 1647 1648 exi = checkexport(fsid, xfid); 1649 1650 if (exi != NULL) { 1651 publicfh_ok = PUBLICFH_CHECK(disp, exi, fsid, xfid); 1652 1653 /* 1654 * Don't allow non-V4 clients access 1655 * to pseudo exports 1656 */ 1657 if (PSEUDO(exi)) { 1658 svcerr_weakauth(xprt); 1659 error++; 1660 goto done; 1661 } 1662 1663 authres = checkauth(exi, req, cr, anon_ok, publicfh_ok, 1664 &ro); 1665 /* 1666 * authres > 0: authentication OK - proceed 1667 * authres == 0: authentication weak - return error 1668 * authres < 0: authentication timeout - drop 1669 */ 1670 if (authres <= 0) { 1671 if (authres == 0) { 1672 svcerr_weakauth(xprt); 1673 error++; 1674 } 1675 goto done; 1676 } 1677 } 1678 } else 1679 cr = NULL; 1680 1681 if ((dis_flags & RPC_MAPRESP) && (auth_flavor != RPCSEC_GSS)) { 1682 res = (char *)SVC_GETRES(xprt, disp->dis_ressz); 1683 if (res == NULL) 1684 res = (char *)&res_buf; 1685 } else 1686 res = (char *)&res_buf; 1687 1688 if (!(dis_flags & RPC_IDEMPOTENT)) { 1689 dupstat = SVC_DUP_EXT(xprt, req, res, disp->dis_ressz, &dr, 1690 &dupcached); 1691 1692 switch (dupstat) { 1693 case DUP_ERROR: 1694 svcerr_systemerr(xprt); 1695 error++; 1696 goto done; 1697 /* NOTREACHED */ 1698 case DUP_INPROGRESS: 1699 if (res != (char *)&res_buf) 1700 SVC_FREERES(xprt); 1701 error++; 1702 goto done; 1703 /* NOTREACHED */ 1704 case DUP_NEW: 1705 case DUP_DROP: 1706 curthread->t_flag |= T_DONTPEND; 1707 1708 (*disp->dis_proc)(args, res, exi, req, cr, ro); 1709 1710 curthread->t_flag &= ~T_DONTPEND; 1711 if (curthread->t_flag & T_WOULDBLOCK) { 1712 curthread->t_flag &= ~T_WOULDBLOCK; 1713 SVC_DUPDONE_EXT(xprt, dr, res, NULL, 1714 disp->dis_ressz, DUP_DROP); 1715 if (res != (char *)&res_buf) 1716 SVC_FREERES(xprt); 1717 error++; 1718 goto done; 1719 } 1720 if (dis_flags & RPC_AVOIDWORK) { 1721 SVC_DUPDONE_EXT(xprt, dr, res, NULL, 1722 disp->dis_ressz, DUP_DROP); 1723 } else { 1724 SVC_DUPDONE_EXT(xprt, dr, res, 1725 disp->dis_resfree == nullfree ? NULL : 1726 disp->dis_resfree, 1727 disp->dis_ressz, DUP_DONE); 1728 dupcached = TRUE; 1729 } 1730 break; 1731 case DUP_DONE: 1732 break; 1733 } 1734 1735 } else { 1736 curthread->t_flag |= T_DONTPEND; 1737 1738 (*disp->dis_proc)(args, res, exi, req, cr, ro); 1739 1740 curthread->t_flag &= ~T_DONTPEND; 1741 if (curthread->t_flag & T_WOULDBLOCK) { 1742 curthread->t_flag &= ~T_WOULDBLOCK; 1743 if (res != (char *)&res_buf) 1744 SVC_FREERES(xprt); 1745 error++; 1746 goto done; 1747 } 1748 } 1749 1750 if (auth_tooweak(req, res)) { 1751 svcerr_weakauth(xprt); 1752 error++; 1753 goto done; 1754 } 1755 1756 /* 1757 * Check to see if logging has been enabled on the server. 1758 * If so, then obtain the export info struct to be used for 1759 * the later writing of the log record. This is done for 1760 * the case that a lookup is done across a non-logged public 1761 * file system. 1762 */ 1763 if (nfslog_buffer_list != NULL) { 1764 nfslog_exi = nfslog_get_exi(exi, req, res, &nfslog_rec_id); 1765 /* 1766 * Is logging enabled? 1767 */ 1768 logging_enabled = (nfslog_exi != NULL); 1769 1770 /* 1771 * Copy the netbuf for logging purposes, before it is 1772 * freed by svc_sendreply(). 1773 */ 1774 if (logging_enabled) { 1775 NFSLOG_COPY_NETBUF(nfslog_exi, xprt, &nb); 1776 /* 1777 * If RPC_MAPRESP flag set (i.e. in V2 ops) the 1778 * res gets copied directly into the mbuf and 1779 * may be freed soon after the sendreply. So we 1780 * must copy it here to a safe place... 1781 */ 1782 if (res != (char *)&res_buf) { 1783 bcopy(res, (char *)&res_buf, disp->dis_ressz); 1784 } 1785 } 1786 } 1787 1788 /* 1789 * Serialize and send results struct 1790 */ 1791 #ifdef DEBUG 1792 if (rfs_no_fast_xdrres == 0 && res != (char *)&res_buf) 1793 #else 1794 if (res != (char *)&res_buf) 1795 #endif 1796 { 1797 if (!svc_sendreply(xprt, disp->dis_fastxdrres, res)) { 1798 cmn_err(CE_NOTE, "%s: bad sendreply", pgmname); 1799 svcerr_systemerr(xprt); 1800 error++; 1801 } 1802 } else { 1803 if (!svc_sendreply(xprt, disp->dis_xdrres, res)) { 1804 cmn_err(CE_NOTE, "%s: bad sendreply", pgmname); 1805 svcerr_systemerr(xprt); 1806 error++; 1807 } 1808 } 1809 1810 /* 1811 * Log if needed 1812 */ 1813 if (logging_enabled) { 1814 nfslog_write_record(nfslog_exi, req, args, (char *)&res_buf, 1815 cr, &nb, nfslog_rec_id, NFSLOG_ONE_BUFFER); 1816 exi_rele(nfslog_exi); 1817 kmem_free((&nb)->buf, (&nb)->len); 1818 } 1819 1820 /* 1821 * Free results struct. With the addition of NFS V4 we can 1822 * have non-idempotent procedures with functions. 1823 */ 1824 if (disp->dis_resfree != nullfree && dupcached == FALSE) { 1825 (*disp->dis_resfree)(res); 1826 } 1827 1828 done: 1829 /* 1830 * Free arguments struct 1831 */ 1832 if (disp) { 1833 if (!SVC_FREEARGS(xprt, disp->dis_xdrargs, args)) { 1834 cmn_err(CE_NOTE, "%s: bad freeargs", pgmname); 1835 error++; 1836 } 1837 } else { 1838 if (!SVC_FREEARGS(xprt, (xdrproc_t)0, (caddr_t)0)) { 1839 cmn_err(CE_NOTE, "%s: bad freeargs", pgmname); 1840 error++; 1841 } 1842 } 1843 1844 if (exi != NULL) 1845 exi_rele(exi); 1846 1847 global_svstat_ptr[req->rq_vers][NFS_BADCALLS].value.ui64 += error; 1848 1849 global_svstat_ptr[req->rq_vers][NFS_CALLS].value.ui64++; 1850 } 1851 1852 static void 1853 rfs_dispatch(struct svc_req *req, SVCXPRT *xprt) 1854 { 1855 common_dispatch(req, xprt, NFS_VERSMIN, NFS_VERSMAX, 1856 "NFS", rfs_disptable); 1857 } 1858 1859 static char *aclcallnames_v2[] = { 1860 "ACL2_NULL", 1861 "ACL2_GETACL", 1862 "ACL2_SETACL", 1863 "ACL2_GETATTR", 1864 "ACL2_ACCESS", 1865 "ACL2_GETXATTRDIR" 1866 }; 1867 1868 static struct rpcdisp acldisptab_v2[] = { 1869 /* 1870 * ACL VERSION 2 1871 */ 1872 1873 /* ACL2_NULL = 0 */ 1874 {rpc_null, 1875 xdr_void, NULL_xdrproc_t, 0, 1876 xdr_void, NULL_xdrproc_t, 0, 1877 nullfree, RPC_IDEMPOTENT, 1878 0}, 1879 1880 /* ACL2_GETACL = 1 */ 1881 {acl2_getacl, 1882 xdr_GETACL2args, xdr_fastGETACL2args, sizeof (GETACL2args), 1883 xdr_GETACL2res, NULL_xdrproc_t, sizeof (GETACL2res), 1884 acl2_getacl_free, RPC_IDEMPOTENT, 1885 acl2_getacl_getfh}, 1886 1887 /* ACL2_SETACL = 2 */ 1888 {acl2_setacl, 1889 xdr_SETACL2args, NULL_xdrproc_t, sizeof (SETACL2args), 1890 #ifdef _LITTLE_ENDIAN 1891 xdr_SETACL2res, xdr_fastSETACL2res, sizeof (SETACL2res), 1892 #else 1893 xdr_SETACL2res, NULL_xdrproc_t, sizeof (SETACL2res), 1894 #endif 1895 nullfree, RPC_MAPRESP, 1896 acl2_setacl_getfh}, 1897 1898 /* ACL2_GETATTR = 3 */ 1899 {acl2_getattr, 1900 xdr_GETATTR2args, xdr_fastGETATTR2args, sizeof (GETATTR2args), 1901 #ifdef _LITTLE_ENDIAN 1902 xdr_GETATTR2res, xdr_fastGETATTR2res, sizeof (GETATTR2res), 1903 #else 1904 xdr_GETATTR2res, NULL_xdrproc_t, sizeof (GETATTR2res), 1905 #endif 1906 nullfree, RPC_IDEMPOTENT|RPC_ALLOWANON|RPC_MAPRESP, 1907 acl2_getattr_getfh}, 1908 1909 /* ACL2_ACCESS = 4 */ 1910 {acl2_access, 1911 xdr_ACCESS2args, xdr_fastACCESS2args, sizeof (ACCESS2args), 1912 #ifdef _LITTLE_ENDIAN 1913 xdr_ACCESS2res, xdr_fastACCESS2res, sizeof (ACCESS2res), 1914 #else 1915 xdr_ACCESS2res, NULL_xdrproc_t, sizeof (ACCESS2res), 1916 #endif 1917 nullfree, RPC_IDEMPOTENT|RPC_MAPRESP, 1918 acl2_access_getfh}, 1919 1920 /* ACL2_GETXATTRDIR = 5 */ 1921 {acl2_getxattrdir, 1922 xdr_GETXATTRDIR2args, NULL_xdrproc_t, sizeof (GETXATTRDIR2args), 1923 xdr_GETXATTRDIR2res, NULL_xdrproc_t, sizeof (GETXATTRDIR2res), 1924 nullfree, RPC_IDEMPOTENT, 1925 acl2_getxattrdir_getfh}, 1926 }; 1927 1928 static char *aclcallnames_v3[] = { 1929 "ACL3_NULL", 1930 "ACL3_GETACL", 1931 "ACL3_SETACL", 1932 "ACL3_GETXATTRDIR" 1933 }; 1934 1935 static struct rpcdisp acldisptab_v3[] = { 1936 /* 1937 * ACL VERSION 3 1938 */ 1939 1940 /* ACL3_NULL = 0 */ 1941 {rpc_null, 1942 xdr_void, NULL_xdrproc_t, 0, 1943 xdr_void, NULL_xdrproc_t, 0, 1944 nullfree, RPC_IDEMPOTENT, 1945 0}, 1946 1947 /* ACL3_GETACL = 1 */ 1948 {acl3_getacl, 1949 xdr_GETACL3args, NULL_xdrproc_t, sizeof (GETACL3args), 1950 xdr_GETACL3res, NULL_xdrproc_t, sizeof (GETACL3res), 1951 acl3_getacl_free, RPC_IDEMPOTENT, 1952 acl3_getacl_getfh}, 1953 1954 /* ACL3_SETACL = 2 */ 1955 {acl3_setacl, 1956 xdr_SETACL3args, NULL_xdrproc_t, sizeof (SETACL3args), 1957 xdr_SETACL3res, NULL_xdrproc_t, sizeof (SETACL3res), 1958 nullfree, 0, 1959 acl3_setacl_getfh}, 1960 1961 /* ACL3_GETXATTRDIR = 3 */ 1962 {acl3_getxattrdir, 1963 xdr_GETXATTRDIR3args, NULL_xdrproc_t, sizeof (GETXATTRDIR3args), 1964 xdr_GETXATTRDIR3res, NULL_xdrproc_t, sizeof (GETXATTRDIR3res), 1965 nullfree, RPC_IDEMPOTENT, 1966 acl3_getxattrdir_getfh}, 1967 }; 1968 1969 static struct rpc_disptable acl_disptable[] = { 1970 {sizeof (acldisptab_v2) / sizeof (acldisptab_v2[0]), 1971 aclcallnames_v2, 1972 &aclproccnt_v2_ptr, acldisptab_v2}, 1973 {sizeof (acldisptab_v3) / sizeof (acldisptab_v3[0]), 1974 aclcallnames_v3, 1975 &aclproccnt_v3_ptr, acldisptab_v3}, 1976 }; 1977 1978 static void 1979 acl_dispatch(struct svc_req *req, SVCXPRT *xprt) 1980 { 1981 common_dispatch(req, xprt, NFS_ACL_VERSMIN, NFS_ACL_VERSMAX, 1982 "ACL", acl_disptable); 1983 } 1984 1985 int 1986 checkwin(int flavor, int window, struct svc_req *req) 1987 { 1988 struct authdes_cred *adc; 1989 1990 switch (flavor) { 1991 case AUTH_DES: 1992 adc = (struct authdes_cred *)req->rq_clntcred; 1993 if (adc->adc_fullname.window > window) 1994 return (0); 1995 break; 1996 1997 default: 1998 break; 1999 } 2000 return (1); 2001 } 2002 2003 2004 /* 2005 * checkauth() will check the access permission against the export 2006 * information. Then map root uid/gid to appropriate uid/gid. 2007 * 2008 * This routine is used by NFS V3 and V2 code. 2009 */ 2010 static int 2011 checkauth(struct exportinfo *exi, struct svc_req *req, cred_t *cr, int anon_ok, 2012 bool_t publicfh_ok, bool_t *ro) 2013 { 2014 int i, nfsflavor, rpcflavor, stat, access; 2015 struct secinfo *secp; 2016 caddr_t principal; 2017 char buf[INET6_ADDRSTRLEN]; /* to hold both IPv4 and IPv6 addr */ 2018 int anon_res = 0; 2019 2020 uid_t uid; 2021 gid_t gid; 2022 uint_t ngids; 2023 gid_t *gids; 2024 2025 /* 2026 * Check for privileged port number 2027 * N.B.: this assumes that we know the format of a netbuf. 2028 */ 2029 if (nfs_portmon) { 2030 struct sockaddr *ca; 2031 ca = (struct sockaddr *)svc_getrpccaller(req->rq_xprt)->buf; 2032 2033 if (ca == NULL) 2034 return (0); 2035 2036 if ((ca->sa_family == AF_INET && 2037 ntohs(((struct sockaddr_in *)ca)->sin_port) >= 2038 IPPORT_RESERVED) || 2039 (ca->sa_family == AF_INET6 && 2040 ntohs(((struct sockaddr_in6 *)ca)->sin6_port) >= 2041 IPPORT_RESERVED)) { 2042 cmn_err(CE_NOTE, 2043 "nfs_server: client %s%ssent NFS request from " 2044 "unprivileged port", 2045 client_name(req), client_addr(req, buf)); 2046 return (0); 2047 } 2048 } 2049 2050 /* 2051 * return 1 on success or 0 on failure 2052 */ 2053 stat = sec_svc_getcred(req, cr, &principal, &nfsflavor); 2054 2055 /* 2056 * A failed AUTH_UNIX sec_svc_getcred() implies we couldn't set 2057 * the credentials; below we map that to anonymous. 2058 */ 2059 if (!stat && nfsflavor != AUTH_UNIX) { 2060 cmn_err(CE_NOTE, 2061 "nfs_server: couldn't get unix cred for %s", 2062 client_name(req)); 2063 return (0); 2064 } 2065 2066 /* 2067 * Short circuit checkauth() on operations that support the 2068 * public filehandle, and if the request for that operation 2069 * is using the public filehandle. Note that we must call 2070 * sec_svc_getcred() first so that xp_cookie is set to the 2071 * right value. Normally xp_cookie is just the RPC flavor 2072 * of the the request, but in the case of RPCSEC_GSS it 2073 * could be a pseudo flavor. 2074 */ 2075 if (publicfh_ok) 2076 return (1); 2077 2078 rpcflavor = req->rq_cred.oa_flavor; 2079 /* 2080 * Check if the auth flavor is valid for this export 2081 */ 2082 access = nfsauth_access(exi, req, cr, &uid, &gid, &ngids, &gids); 2083 if (access & NFSAUTH_DROP) 2084 return (-1); /* drop the request */ 2085 2086 if (access & NFSAUTH_RO) 2087 *ro = TRUE; 2088 2089 if (access & NFSAUTH_DENIED) { 2090 /* 2091 * If anon_ok == 1 and we got NFSAUTH_DENIED, it was 2092 * probably due to the flavor not matching during 2093 * the mount attempt. So map the flavor to AUTH_NONE 2094 * so that the credentials get mapped to the anonymous 2095 * user. 2096 */ 2097 if (anon_ok == 1) 2098 rpcflavor = AUTH_NONE; 2099 else 2100 return (0); /* deny access */ 2101 2102 } else if (access & NFSAUTH_MAPNONE) { 2103 /* 2104 * Access was granted even though the flavor mismatched 2105 * because AUTH_NONE was one of the exported flavors. 2106 */ 2107 rpcflavor = AUTH_NONE; 2108 2109 } else if (access & NFSAUTH_WRONGSEC) { 2110 /* 2111 * NFSAUTH_WRONGSEC is used for NFSv4. If we get here, 2112 * it means a client ignored the list of allowed flavors 2113 * returned via the MOUNT protocol. So we just disallow it! 2114 */ 2115 return (0); 2116 } 2117 2118 if (rpcflavor != AUTH_SYS) 2119 kmem_free(gids, ngids * sizeof (gid_t)); 2120 2121 switch (rpcflavor) { 2122 case AUTH_NONE: 2123 anon_res = crsetugid(cr, exi->exi_export.ex_anon, 2124 exi->exi_export.ex_anon); 2125 (void) crsetgroups(cr, 0, NULL); 2126 break; 2127 2128 case AUTH_UNIX: 2129 if (!stat || crgetuid(cr) == 0 && !(access & NFSAUTH_UIDMAP)) { 2130 anon_res = crsetugid(cr, exi->exi_export.ex_anon, 2131 exi->exi_export.ex_anon); 2132 (void) crsetgroups(cr, 0, NULL); 2133 } else if (crgetuid(cr) == 0 && access & NFSAUTH_ROOT) { 2134 /* 2135 * It is root, so apply rootid to get real UID 2136 * Find the secinfo structure. We should be able 2137 * to find it by the time we reach here. 2138 * nfsauth_access() has done the checking. 2139 */ 2140 secp = NULL; 2141 for (i = 0; i < exi->exi_export.ex_seccnt; i++) { 2142 struct secinfo *sptr; 2143 sptr = &exi->exi_export.ex_secinfo[i]; 2144 if (sptr->s_secinfo.sc_nfsnum == nfsflavor) { 2145 secp = sptr; 2146 break; 2147 } 2148 } 2149 if (secp != NULL) { 2150 (void) crsetugid(cr, secp->s_rootid, 2151 secp->s_rootid); 2152 (void) crsetgroups(cr, 0, NULL); 2153 } 2154 } else if (crgetuid(cr) != uid || crgetgid(cr) != gid) { 2155 if (crsetugid(cr, uid, gid) != 0) 2156 anon_res = crsetugid(cr, 2157 exi->exi_export.ex_anon, 2158 exi->exi_export.ex_anon); 2159 (void) crsetgroups(cr, 0, NULL); 2160 } else if (access & NFSAUTH_GROUPS) { 2161 (void) crsetgroups(cr, ngids, gids); 2162 } 2163 2164 kmem_free(gids, ngids * sizeof (gid_t)); 2165 2166 break; 2167 2168 case AUTH_DES: 2169 case RPCSEC_GSS: 2170 /* 2171 * Find the secinfo structure. We should be able 2172 * to find it by the time we reach here. 2173 * nfsauth_access() has done the checking. 2174 */ 2175 secp = NULL; 2176 for (i = 0; i < exi->exi_export.ex_seccnt; i++) { 2177 if (exi->exi_export.ex_secinfo[i].s_secinfo.sc_nfsnum == 2178 nfsflavor) { 2179 secp = &exi->exi_export.ex_secinfo[i]; 2180 break; 2181 } 2182 } 2183 2184 if (!secp) { 2185 cmn_err(CE_NOTE, "nfs_server: client %s%shad " 2186 "no secinfo data for flavor %d", 2187 client_name(req), client_addr(req, buf), 2188 nfsflavor); 2189 return (0); 2190 } 2191 2192 if (!checkwin(rpcflavor, secp->s_window, req)) { 2193 cmn_err(CE_NOTE, 2194 "nfs_server: client %s%sused invalid " 2195 "auth window value", 2196 client_name(req), client_addr(req, buf)); 2197 return (0); 2198 } 2199 2200 /* 2201 * Map root principals listed in the share's root= list to root, 2202 * and map any others principals that were mapped to root by RPC 2203 * to anon. 2204 */ 2205 if (principal && sec_svc_inrootlist(rpcflavor, principal, 2206 secp->s_rootcnt, secp->s_rootnames)) { 2207 if (crgetuid(cr) == 0 && secp->s_rootid == 0) 2208 return (1); 2209 2210 2211 (void) crsetugid(cr, secp->s_rootid, secp->s_rootid); 2212 2213 /* 2214 * NOTE: If and when kernel-land privilege tracing is 2215 * added this may have to be replaced with code that 2216 * retrieves root's supplementary groups (e.g., using 2217 * kgss_get_group_info(). In the meantime principals 2218 * mapped to uid 0 get all privileges, so setting cr's 2219 * supplementary groups for them does nothing. 2220 */ 2221 (void) crsetgroups(cr, 0, NULL); 2222 2223 return (1); 2224 } 2225 2226 /* 2227 * Not a root princ, or not in root list, map UID 0/nobody to 2228 * the anon ID for the share. (RPC sets cr's UIDs and GIDs to 2229 * UID_NOBODY and GID_NOBODY, respectively.) 2230 */ 2231 if (crgetuid(cr) != 0 && 2232 (crgetuid(cr) != UID_NOBODY || crgetgid(cr) != GID_NOBODY)) 2233 return (1); 2234 2235 anon_res = crsetugid(cr, exi->exi_export.ex_anon, 2236 exi->exi_export.ex_anon); 2237 (void) crsetgroups(cr, 0, NULL); 2238 break; 2239 default: 2240 return (0); 2241 } /* switch on rpcflavor */ 2242 2243 /* 2244 * Even if anon access is disallowed via ex_anon == -1, we allow 2245 * this access if anon_ok is set. So set creds to the default 2246 * "nobody" id. 2247 */ 2248 if (anon_res != 0) { 2249 if (anon_ok == 0) { 2250 cmn_err(CE_NOTE, 2251 "nfs_server: client %s%ssent wrong " 2252 "authentication for %s", 2253 client_name(req), client_addr(req, buf), 2254 exi->exi_export.ex_path ? 2255 exi->exi_export.ex_path : "?"); 2256 return (0); 2257 } 2258 2259 if (crsetugid(cr, UID_NOBODY, GID_NOBODY) != 0) 2260 return (0); 2261 } 2262 2263 return (1); 2264 } 2265 2266 /* 2267 * returns 0 on failure, -1 on a drop, -2 on wrong security flavor, 2268 * and 1 on success 2269 */ 2270 int 2271 checkauth4(struct compound_state *cs, struct svc_req *req) 2272 { 2273 int i, rpcflavor, access; 2274 struct secinfo *secp; 2275 char buf[MAXHOST + 1]; 2276 int anon_res = 0, nfsflavor; 2277 struct exportinfo *exi; 2278 cred_t *cr; 2279 caddr_t principal; 2280 2281 uid_t uid; 2282 gid_t gid; 2283 uint_t ngids; 2284 gid_t *gids; 2285 2286 exi = cs->exi; 2287 cr = cs->cr; 2288 principal = cs->principal; 2289 nfsflavor = cs->nfsflavor; 2290 2291 ASSERT(cr != NULL); 2292 2293 rpcflavor = req->rq_cred.oa_flavor; 2294 cs->access &= ~CS_ACCESS_LIMITED; 2295 2296 /* 2297 * Check for privileged port number 2298 * N.B.: this assumes that we know the format of a netbuf. 2299 */ 2300 if (nfs_portmon) { 2301 struct sockaddr *ca; 2302 ca = (struct sockaddr *)svc_getrpccaller(req->rq_xprt)->buf; 2303 2304 if (ca == NULL) 2305 return (0); 2306 2307 if ((ca->sa_family == AF_INET && 2308 ntohs(((struct sockaddr_in *)ca)->sin_port) >= 2309 IPPORT_RESERVED) || 2310 (ca->sa_family == AF_INET6 && 2311 ntohs(((struct sockaddr_in6 *)ca)->sin6_port) >= 2312 IPPORT_RESERVED)) { 2313 cmn_err(CE_NOTE, 2314 "nfs_server: client %s%ssent NFSv4 request from " 2315 "unprivileged port", 2316 client_name(req), client_addr(req, buf)); 2317 return (0); 2318 } 2319 } 2320 2321 /* 2322 * Check the access right per auth flavor on the vnode of 2323 * this export for the given request. 2324 */ 2325 access = nfsauth4_access(cs->exi, cs->vp, req, cr, &uid, &gid, &ngids, 2326 &gids); 2327 2328 if (access & NFSAUTH_WRONGSEC) 2329 return (-2); /* no access for this security flavor */ 2330 2331 if (access & NFSAUTH_DROP) 2332 return (-1); /* drop the request */ 2333 2334 if (access & NFSAUTH_DENIED) { 2335 2336 if (exi->exi_export.ex_seccnt > 0) 2337 return (0); /* deny access */ 2338 2339 } else if (access & NFSAUTH_LIMITED) { 2340 2341 cs->access |= CS_ACCESS_LIMITED; 2342 2343 } else if (access & NFSAUTH_MAPNONE) { 2344 /* 2345 * Access was granted even though the flavor mismatched 2346 * because AUTH_NONE was one of the exported flavors. 2347 */ 2348 rpcflavor = AUTH_NONE; 2349 } 2350 2351 /* 2352 * XXX probably need to redo some of it for nfsv4? 2353 * return 1 on success or 0 on failure 2354 */ 2355 2356 if (rpcflavor != AUTH_SYS) 2357 kmem_free(gids, ngids * sizeof (gid_t)); 2358 2359 switch (rpcflavor) { 2360 case AUTH_NONE: 2361 anon_res = crsetugid(cr, exi->exi_export.ex_anon, 2362 exi->exi_export.ex_anon); 2363 (void) crsetgroups(cr, 0, NULL); 2364 break; 2365 2366 case AUTH_UNIX: 2367 if (crgetuid(cr) == 0 && !(access & NFSAUTH_UIDMAP)) { 2368 anon_res = crsetugid(cr, exi->exi_export.ex_anon, 2369 exi->exi_export.ex_anon); 2370 (void) crsetgroups(cr, 0, NULL); 2371 } else if (crgetuid(cr) == 0 && access & NFSAUTH_ROOT) { 2372 /* 2373 * It is root, so apply rootid to get real UID 2374 * Find the secinfo structure. We should be able 2375 * to find it by the time we reach here. 2376 * nfsauth_access() has done the checking. 2377 */ 2378 secp = NULL; 2379 for (i = 0; i < exi->exi_export.ex_seccnt; i++) { 2380 struct secinfo *sptr; 2381 sptr = &exi->exi_export.ex_secinfo[i]; 2382 if (sptr->s_secinfo.sc_nfsnum == nfsflavor) { 2383 secp = &exi->exi_export.ex_secinfo[i]; 2384 break; 2385 } 2386 } 2387 if (secp != NULL) { 2388 (void) crsetugid(cr, secp->s_rootid, 2389 secp->s_rootid); 2390 (void) crsetgroups(cr, 0, NULL); 2391 } 2392 } else if (crgetuid(cr) != uid || crgetgid(cr) != gid) { 2393 if (crsetugid(cr, uid, gid) != 0) 2394 anon_res = crsetugid(cr, 2395 exi->exi_export.ex_anon, 2396 exi->exi_export.ex_anon); 2397 (void) crsetgroups(cr, 0, NULL); 2398 } if (access & NFSAUTH_GROUPS) { 2399 (void) crsetgroups(cr, ngids, gids); 2400 } 2401 2402 kmem_free(gids, ngids * sizeof (gid_t)); 2403 2404 break; 2405 2406 default: 2407 /* 2408 * Find the secinfo structure. We should be able 2409 * to find it by the time we reach here. 2410 * nfsauth_access() has done the checking. 2411 */ 2412 secp = NULL; 2413 for (i = 0; i < exi->exi_export.ex_seccnt; i++) { 2414 if (exi->exi_export.ex_secinfo[i].s_secinfo.sc_nfsnum == 2415 nfsflavor) { 2416 secp = &exi->exi_export.ex_secinfo[i]; 2417 break; 2418 } 2419 } 2420 2421 if (!secp) { 2422 cmn_err(CE_NOTE, "nfs_server: client %s%shad " 2423 "no secinfo data for flavor %d", 2424 client_name(req), client_addr(req, buf), 2425 nfsflavor); 2426 return (0); 2427 } 2428 2429 if (!checkwin(rpcflavor, secp->s_window, req)) { 2430 cmn_err(CE_NOTE, 2431 "nfs_server: client %s%sused invalid " 2432 "auth window value", 2433 client_name(req), client_addr(req, buf)); 2434 return (0); 2435 } 2436 2437 /* 2438 * Map root principals listed in the share's root= list to root, 2439 * and map any others principals that were mapped to root by RPC 2440 * to anon. If not going to anon, set to rootid (root_mapping). 2441 */ 2442 if (principal && sec_svc_inrootlist(rpcflavor, principal, 2443 secp->s_rootcnt, secp->s_rootnames)) { 2444 if (crgetuid(cr) == 0 && secp->s_rootid == 0) 2445 return (1); 2446 2447 (void) crsetugid(cr, secp->s_rootid, secp->s_rootid); 2448 2449 /* 2450 * NOTE: If and when kernel-land privilege tracing is 2451 * added this may have to be replaced with code that 2452 * retrieves root's supplementary groups (e.g., using 2453 * kgss_get_group_info(). In the meantime principals 2454 * mapped to uid 0 get all privileges, so setting cr's 2455 * supplementary groups for them does nothing. 2456 */ 2457 (void) crsetgroups(cr, 0, NULL); 2458 2459 return (1); 2460 } 2461 2462 /* 2463 * Not a root princ, or not in root list, map UID 0/nobody to 2464 * the anon ID for the share. (RPC sets cr's UIDs and GIDs to 2465 * UID_NOBODY and GID_NOBODY, respectively.) 2466 */ 2467 if (crgetuid(cr) != 0 && 2468 (crgetuid(cr) != UID_NOBODY || crgetgid(cr) != GID_NOBODY)) 2469 return (1); 2470 2471 anon_res = crsetugid(cr, exi->exi_export.ex_anon, 2472 exi->exi_export.ex_anon); 2473 (void) crsetgroups(cr, 0, NULL); 2474 break; 2475 } /* switch on rpcflavor */ 2476 2477 /* 2478 * Even if anon access is disallowed via ex_anon == -1, we allow 2479 * this access if anon_ok is set. So set creds to the default 2480 * "nobody" id. 2481 */ 2482 2483 if (anon_res != 0) { 2484 cmn_err(CE_NOTE, 2485 "nfs_server: client %s%ssent wrong " 2486 "authentication for %s", 2487 client_name(req), client_addr(req, buf), 2488 exi->exi_export.ex_path ? 2489 exi->exi_export.ex_path : "?"); 2490 return (0); 2491 } 2492 2493 return (1); 2494 } 2495 2496 2497 static char * 2498 client_name(struct svc_req *req) 2499 { 2500 char *hostname = NULL; 2501 2502 /* 2503 * If it's a Unix cred then use the 2504 * hostname from the credential. 2505 */ 2506 if (req->rq_cred.oa_flavor == AUTH_UNIX) { 2507 hostname = ((struct authunix_parms *) 2508 req->rq_clntcred)->aup_machname; 2509 } 2510 if (hostname == NULL) 2511 hostname = ""; 2512 2513 return (hostname); 2514 } 2515 2516 static char * 2517 client_addr(struct svc_req *req, char *buf) 2518 { 2519 struct sockaddr *ca; 2520 uchar_t *b; 2521 char *frontspace = ""; 2522 2523 /* 2524 * We assume we are called in tandem with client_name and the 2525 * format string looks like "...client %s%sblah blah..." 2526 * 2527 * If it's a Unix cred then client_name returned 2528 * a host name, so we need insert a space between host name 2529 * and IP address. 2530 */ 2531 if (req->rq_cred.oa_flavor == AUTH_UNIX) 2532 frontspace = " "; 2533 2534 /* 2535 * Convert the caller's IP address to a dotted string 2536 */ 2537 ca = (struct sockaddr *)svc_getrpccaller(req->rq_xprt)->buf; 2538 2539 if (ca->sa_family == AF_INET) { 2540 b = (uchar_t *)&((struct sockaddr_in *)ca)->sin_addr; 2541 (void) sprintf(buf, "%s(%d.%d.%d.%d) ", frontspace, 2542 b[0] & 0xFF, b[1] & 0xFF, b[2] & 0xFF, b[3] & 0xFF); 2543 } else if (ca->sa_family == AF_INET6) { 2544 struct sockaddr_in6 *sin6; 2545 sin6 = (struct sockaddr_in6 *)ca; 2546 (void) kinet_ntop6((uchar_t *)&sin6->sin6_addr, 2547 buf, INET6_ADDRSTRLEN); 2548 2549 } else { 2550 2551 /* 2552 * No IP address to print. If there was a host name 2553 * printed, then we print a space. 2554 */ 2555 (void) sprintf(buf, frontspace); 2556 } 2557 2558 return (buf); 2559 } 2560 2561 /* 2562 * NFS Server initialization routine. This routine should only be called 2563 * once. It performs the following tasks: 2564 * - Call sub-initialization routines (localize access to variables) 2565 * - Initialize all locks 2566 * - initialize the version 3 write verifier 2567 */ 2568 int 2569 nfs_srvinit(void) 2570 { 2571 int error; 2572 2573 error = nfs_exportinit(); 2574 if (error != 0) 2575 return (error); 2576 error = rfs4_srvrinit(); 2577 if (error != 0) { 2578 nfs_exportfini(); 2579 return (error); 2580 } 2581 rfs_srvrinit(); 2582 rfs3_srvrinit(); 2583 nfsauth_init(); 2584 2585 /* Init the stuff to control start/stop */ 2586 nfs_server_upordown = NFS_SERVER_STOPPED; 2587 mutex_init(&nfs_server_upordown_lock, NULL, MUTEX_DEFAULT, NULL); 2588 cv_init(&nfs_server_upordown_cv, NULL, CV_DEFAULT, NULL); 2589 mutex_init(&rdma_wait_mutex, NULL, MUTEX_DEFAULT, NULL); 2590 cv_init(&rdma_wait_cv, NULL, CV_DEFAULT, NULL); 2591 2592 return (0); 2593 } 2594 2595 /* 2596 * NFS Server finalization routine. This routine is called to cleanup the 2597 * initialization work previously performed if the NFS server module could 2598 * not be loaded correctly. 2599 */ 2600 void 2601 nfs_srvfini(void) 2602 { 2603 nfsauth_fini(); 2604 rfs3_srvrfini(); 2605 rfs_srvrfini(); 2606 nfs_exportfini(); 2607 2608 mutex_destroy(&nfs_server_upordown_lock); 2609 cv_destroy(&nfs_server_upordown_cv); 2610 mutex_destroy(&rdma_wait_mutex); 2611 cv_destroy(&rdma_wait_cv); 2612 } 2613 2614 /* 2615 * Set up an iovec array of up to cnt pointers. 2616 */ 2617 2618 void 2619 mblk_to_iov(mblk_t *m, int cnt, struct iovec *iovp) 2620 { 2621 while (m != NULL && cnt-- > 0) { 2622 iovp->iov_base = (caddr_t)m->b_rptr; 2623 iovp->iov_len = (m->b_wptr - m->b_rptr); 2624 iovp++; 2625 m = m->b_cont; 2626 } 2627 } 2628 2629 /* 2630 * Common code between NFS Version 2 and NFS Version 3 for the public 2631 * filehandle multicomponent lookups. 2632 */ 2633 2634 /* 2635 * Public filehandle evaluation of a multi-component lookup, following 2636 * symbolic links, if necessary. This may result in a vnode in another 2637 * filesystem, which is OK as long as the other filesystem is exported. 2638 * 2639 * Note that the exi will be set either to NULL or a new reference to the 2640 * exportinfo struct that corresponds to the vnode of the multi-component path. 2641 * It is the callers responsibility to release this reference. 2642 */ 2643 int 2644 rfs_publicfh_mclookup(char *p, vnode_t *dvp, cred_t *cr, vnode_t **vpp, 2645 struct exportinfo **exi, struct sec_ol *sec) 2646 { 2647 int pathflag; 2648 vnode_t *mc_dvp = NULL; 2649 vnode_t *realvp; 2650 int error; 2651 2652 *exi = NULL; 2653 2654 /* 2655 * check if the given path is a url or native path. Since p is 2656 * modified by MCLpath(), it may be empty after returning from 2657 * there, and should be checked. 2658 */ 2659 if ((pathflag = MCLpath(&p)) == -1) 2660 return (EIO); 2661 2662 /* 2663 * If pathflag is SECURITY_QUERY, turn the SEC_QUERY bit 2664 * on in sec->sec_flags. This bit will later serve as an 2665 * indication in makefh_ol() or makefh3_ol() to overload the 2666 * filehandle to contain the sec modes used by the server for 2667 * the path. 2668 */ 2669 if (pathflag == SECURITY_QUERY) { 2670 if ((sec->sec_index = (uint_t)(*p)) > 0) { 2671 sec->sec_flags |= SEC_QUERY; 2672 p++; 2673 if ((pathflag = MCLpath(&p)) == -1) 2674 return (EIO); 2675 } else { 2676 cmn_err(CE_NOTE, 2677 "nfs_server: invalid security index %d, " 2678 "violating WebNFS SNEGO protocol.", sec->sec_index); 2679 return (EIO); 2680 } 2681 } 2682 2683 if (p[0] == '\0') { 2684 error = ENOENT; 2685 goto publicfh_done; 2686 } 2687 2688 error = rfs_pathname(p, &mc_dvp, vpp, dvp, cr, pathflag); 2689 2690 /* 2691 * If name resolves to "/" we get EINVAL since we asked for 2692 * the vnode of the directory that the file is in. Try again 2693 * with NULL directory vnode. 2694 */ 2695 if (error == EINVAL) { 2696 error = rfs_pathname(p, NULL, vpp, dvp, cr, pathflag); 2697 if (!error) { 2698 ASSERT(*vpp != NULL); 2699 if ((*vpp)->v_type == VDIR) { 2700 VN_HOLD(*vpp); 2701 mc_dvp = *vpp; 2702 } else { 2703 /* 2704 * This should not happen, the filesystem is 2705 * in an inconsistent state. Fail the lookup 2706 * at this point. 2707 */ 2708 VN_RELE(*vpp); 2709 error = EINVAL; 2710 } 2711 } 2712 } 2713 2714 if (error) 2715 goto publicfh_done; 2716 2717 if (*vpp == NULL) { 2718 error = ENOENT; 2719 goto publicfh_done; 2720 } 2721 2722 ASSERT(mc_dvp != NULL); 2723 ASSERT(*vpp != NULL); 2724 2725 if ((*vpp)->v_type == VDIR) { 2726 do { 2727 /* 2728 * *vpp may be an AutoFS node, so we perform 2729 * a VOP_ACCESS() to trigger the mount of the intended 2730 * filesystem, so we can perform the lookup in the 2731 * intended filesystem. 2732 */ 2733 (void) VOP_ACCESS(*vpp, 0, 0, cr, NULL); 2734 2735 /* 2736 * If vnode is covered, get the 2737 * the topmost vnode. 2738 */ 2739 if (vn_mountedvfs(*vpp) != NULL) { 2740 error = traverse(vpp); 2741 if (error) { 2742 VN_RELE(*vpp); 2743 goto publicfh_done; 2744 } 2745 } 2746 2747 if (VOP_REALVP(*vpp, &realvp, NULL) == 0 && 2748 realvp != *vpp) { 2749 /* 2750 * If realvp is different from *vpp 2751 * then release our reference on *vpp, so that 2752 * the export access check be performed on the 2753 * real filesystem instead. 2754 */ 2755 VN_HOLD(realvp); 2756 VN_RELE(*vpp); 2757 *vpp = realvp; 2758 } else { 2759 break; 2760 } 2761 /* LINTED */ 2762 } while (TRUE); 2763 2764 /* 2765 * Let nfs_vptexi() figure what the real parent is. 2766 */ 2767 VN_RELE(mc_dvp); 2768 mc_dvp = NULL; 2769 2770 } else { 2771 /* 2772 * If vnode is covered, get the 2773 * the topmost vnode. 2774 */ 2775 if (vn_mountedvfs(mc_dvp) != NULL) { 2776 error = traverse(&mc_dvp); 2777 if (error) { 2778 VN_RELE(*vpp); 2779 goto publicfh_done; 2780 } 2781 } 2782 2783 if (VOP_REALVP(mc_dvp, &realvp, NULL) == 0 && 2784 realvp != mc_dvp) { 2785 /* 2786 * *vpp is a file, obtain realvp of the parent 2787 * directory vnode. 2788 */ 2789 VN_HOLD(realvp); 2790 VN_RELE(mc_dvp); 2791 mc_dvp = realvp; 2792 } 2793 } 2794 2795 /* 2796 * The pathname may take us from the public filesystem to another. 2797 * If that's the case then just set the exportinfo to the new export 2798 * and build filehandle for it. Thanks to per-access checking there's 2799 * no security issues with doing this. If the client is not allowed 2800 * access to this new export then it will get an access error when it 2801 * tries to use the filehandle 2802 */ 2803 if (error = nfs_check_vpexi(mc_dvp, *vpp, kcred, exi)) { 2804 VN_RELE(*vpp); 2805 goto publicfh_done; 2806 } 2807 2808 /* 2809 * Not allowed access to pseudo exports. 2810 */ 2811 if (PSEUDO(*exi)) { 2812 error = ENOENT; 2813 VN_RELE(*vpp); 2814 goto publicfh_done; 2815 } 2816 2817 /* 2818 * Do a lookup for the index file. We know the index option doesn't 2819 * allow paths through handling in the share command, so mc_dvp will 2820 * be the parent for the index file vnode, if its present. Use 2821 * temporary pointers to preserve and reuse the vnode pointers of the 2822 * original directory in case there's no index file. Note that the 2823 * index file is a native path, and should not be interpreted by 2824 * the URL parser in rfs_pathname() 2825 */ 2826 if (((*exi)->exi_export.ex_flags & EX_INDEX) && 2827 ((*vpp)->v_type == VDIR) && (pathflag == URLPATH)) { 2828 vnode_t *tvp, *tmc_dvp; /* temporary vnode pointers */ 2829 2830 tmc_dvp = mc_dvp; 2831 mc_dvp = tvp = *vpp; 2832 2833 error = rfs_pathname((*exi)->exi_export.ex_index, NULL, vpp, 2834 mc_dvp, cr, NATIVEPATH); 2835 2836 if (error == ENOENT) { 2837 *vpp = tvp; 2838 mc_dvp = tmc_dvp; 2839 error = 0; 2840 } else { /* ok or error other than ENOENT */ 2841 if (tmc_dvp) 2842 VN_RELE(tmc_dvp); 2843 if (error) 2844 goto publicfh_done; 2845 2846 /* 2847 * Found a valid vp for index "filename". Sanity check 2848 * for odd case where a directory is provided as index 2849 * option argument and leads us to another filesystem 2850 */ 2851 2852 /* Release the reference on the old exi value */ 2853 ASSERT(*exi != NULL); 2854 exi_rele(*exi); 2855 2856 if (error = nfs_check_vpexi(mc_dvp, *vpp, kcred, exi)) { 2857 VN_RELE(*vpp); 2858 goto publicfh_done; 2859 } 2860 } 2861 } 2862 2863 publicfh_done: 2864 if (mc_dvp) 2865 VN_RELE(mc_dvp); 2866 2867 return (error); 2868 } 2869 2870 /* 2871 * Evaluate a multi-component path 2872 */ 2873 int 2874 rfs_pathname( 2875 char *path, /* pathname to evaluate */ 2876 vnode_t **dirvpp, /* ret for ptr to parent dir vnode */ 2877 vnode_t **compvpp, /* ret for ptr to component vnode */ 2878 vnode_t *startdvp, /* starting vnode */ 2879 cred_t *cr, /* user's credential */ 2880 int pathflag) /* flag to identify path, e.g. URL */ 2881 { 2882 char namebuf[TYPICALMAXPATHLEN]; 2883 struct pathname pn; 2884 int error; 2885 2886 /* 2887 * If pathname starts with '/', then set startdvp to root. 2888 */ 2889 if (*path == '/') { 2890 while (*path == '/') 2891 path++; 2892 2893 startdvp = rootdir; 2894 } 2895 2896 error = pn_get_buf(path, UIO_SYSSPACE, &pn, namebuf, sizeof (namebuf)); 2897 if (error == 0) { 2898 /* 2899 * Call the URL parser for URL paths to modify the original 2900 * string to handle any '%' encoded characters that exist. 2901 * Done here to avoid an extra bcopy in the lookup. 2902 * We need to be careful about pathlen's. We know that 2903 * rfs_pathname() is called with a non-empty path. However, 2904 * it could be emptied due to the path simply being all /'s, 2905 * which is valid to proceed with the lookup, or due to the 2906 * URL parser finding an encoded null character at the 2907 * beginning of path which should not proceed with the lookup. 2908 */ 2909 if (pn.pn_pathlen != 0 && pathflag == URLPATH) { 2910 URLparse(pn.pn_path); 2911 if ((pn.pn_pathlen = strlen(pn.pn_path)) == 0) 2912 return (ENOENT); 2913 } 2914 VN_HOLD(startdvp); 2915 error = lookuppnvp(&pn, NULL, NO_FOLLOW, dirvpp, compvpp, 2916 rootdir, startdvp, cr); 2917 } 2918 if (error == ENAMETOOLONG) { 2919 /* 2920 * This thread used a pathname > TYPICALMAXPATHLEN bytes long. 2921 */ 2922 if (error = pn_get(path, UIO_SYSSPACE, &pn)) 2923 return (error); 2924 if (pn.pn_pathlen != 0 && pathflag == URLPATH) { 2925 URLparse(pn.pn_path); 2926 if ((pn.pn_pathlen = strlen(pn.pn_path)) == 0) { 2927 pn_free(&pn); 2928 return (ENOENT); 2929 } 2930 } 2931 VN_HOLD(startdvp); 2932 error = lookuppnvp(&pn, NULL, NO_FOLLOW, dirvpp, compvpp, 2933 rootdir, startdvp, cr); 2934 pn_free(&pn); 2935 } 2936 2937 return (error); 2938 } 2939 2940 /* 2941 * Adapt the multicomponent lookup path depending on the pathtype 2942 */ 2943 static int 2944 MCLpath(char **path) 2945 { 2946 unsigned char c = (unsigned char)**path; 2947 2948 /* 2949 * If the MCL path is between 0x20 and 0x7E (graphic printable 2950 * character of the US-ASCII coded character set), its a URL path, 2951 * per RFC 1738. 2952 */ 2953 if (c >= 0x20 && c <= 0x7E) 2954 return (URLPATH); 2955 2956 /* 2957 * If the first octet of the MCL path is not an ASCII character 2958 * then it must be interpreted as a tag value that describes the 2959 * format of the remaining octets of the MCL path. 2960 * 2961 * If the first octet of the MCL path is 0x81 it is a query 2962 * for the security info. 2963 */ 2964 switch (c) { 2965 case 0x80: /* native path, i.e. MCL via mount protocol */ 2966 (*path)++; 2967 return (NATIVEPATH); 2968 case 0x81: /* security query */ 2969 (*path)++; 2970 return (SECURITY_QUERY); 2971 default: 2972 return (-1); 2973 } 2974 } 2975 2976 #define fromhex(c) ((c >= '0' && c <= '9') ? (c - '0') : \ 2977 ((c >= 'A' && c <= 'F') ? (c - 'A' + 10) :\ 2978 ((c >= 'a' && c <= 'f') ? (c - 'a' + 10) : 0))) 2979 2980 /* 2981 * The implementation of URLparse guarantees that the final string will 2982 * fit in the original one. Replaces '%' occurrences followed by 2 characters 2983 * with its corresponding hexadecimal character. 2984 */ 2985 static void 2986 URLparse(char *str) 2987 { 2988 char *p, *q; 2989 2990 p = q = str; 2991 while (*p) { 2992 *q = *p; 2993 if (*p++ == '%') { 2994 if (*p) { 2995 *q = fromhex(*p) * 16; 2996 p++; 2997 if (*p) { 2998 *q += fromhex(*p); 2999 p++; 3000 } 3001 } 3002 } 3003 q++; 3004 } 3005 *q = '\0'; 3006 } 3007 3008 3009 /* 3010 * Get the export information for the lookup vnode, and verify its 3011 * useable. 3012 */ 3013 int 3014 nfs_check_vpexi(vnode_t *mc_dvp, vnode_t *vp, cred_t *cr, 3015 struct exportinfo **exi) 3016 { 3017 int walk; 3018 int error = 0; 3019 3020 *exi = nfs_vptoexi(mc_dvp, vp, cr, &walk, NULL, FALSE); 3021 if (*exi == NULL) 3022 error = EACCES; 3023 else { 3024 /* 3025 * If nosub is set for this export then 3026 * a lookup relative to the public fh 3027 * must not terminate below the 3028 * exported directory. 3029 */ 3030 if ((*exi)->exi_export.ex_flags & EX_NOSUB && walk > 0) 3031 error = EACCES; 3032 } 3033 3034 return (error); 3035 } 3036 3037 /* 3038 * Do the main work of handling HA-NFSv4 Resource Group failover on 3039 * Sun Cluster. 3040 * We need to detect whether any RG admin paths have been added or removed, 3041 * and adjust resources accordingly. 3042 * Currently we're using a very inefficient algorithm, ~ 2 * O(n**2). In 3043 * order to scale, the list and array of paths need to be held in more 3044 * suitable data structures. 3045 */ 3046 static void 3047 hanfsv4_failover(void) 3048 { 3049 int i, start_grace, numadded_paths = 0; 3050 char **added_paths = NULL; 3051 rfs4_dss_path_t *dss_path; 3052 3053 /* 3054 * Note: currently, rfs4_dss_pathlist cannot be NULL, since 3055 * it will always include an entry for NFS4_DSS_VAR_DIR. If we 3056 * make the latter dynamically specified too, the following will 3057 * need to be adjusted. 3058 */ 3059 3060 /* 3061 * First, look for removed paths: RGs that have been failed-over 3062 * away from this node. 3063 * Walk the "currently-serving" rfs4_dss_pathlist and, for each 3064 * path, check if it is on the "passed-in" rfs4_dss_newpaths array 3065 * from nfsd. If not, that RG path has been removed. 3066 * 3067 * Note that nfsd has sorted rfs4_dss_newpaths for us, and removed 3068 * any duplicates. 3069 */ 3070 dss_path = rfs4_dss_pathlist; 3071 do { 3072 int found = 0; 3073 char *path = dss_path->path; 3074 3075 /* used only for non-HA so may not be removed */ 3076 if (strcmp(path, NFS4_DSS_VAR_DIR) == 0) { 3077 dss_path = dss_path->next; 3078 continue; 3079 } 3080 3081 for (i = 0; i < rfs4_dss_numnewpaths; i++) { 3082 int cmpret; 3083 char *newpath = rfs4_dss_newpaths[i]; 3084 3085 /* 3086 * Since nfsd has sorted rfs4_dss_newpaths for us, 3087 * once the return from strcmp is negative we know 3088 * we've passed the point where "path" should be, 3089 * and can stop searching: "path" has been removed. 3090 */ 3091 cmpret = strcmp(path, newpath); 3092 if (cmpret < 0) 3093 break; 3094 if (cmpret == 0) { 3095 found = 1; 3096 break; 3097 } 3098 } 3099 3100 if (found == 0) { 3101 unsigned index = dss_path->index; 3102 rfs4_servinst_t *sip = dss_path->sip; 3103 rfs4_dss_path_t *path_next = dss_path->next; 3104 3105 /* 3106 * This path has been removed. 3107 * We must clear out the servinst reference to 3108 * it, since it's now owned by another 3109 * node: we should not attempt to touch it. 3110 */ 3111 ASSERT(dss_path == sip->dss_paths[index]); 3112 sip->dss_paths[index] = NULL; 3113 3114 /* remove from "currently-serving" list, and destroy */ 3115 remque(dss_path); 3116 /* allow for NUL */ 3117 kmem_free(dss_path->path, strlen(dss_path->path) + 1); 3118 kmem_free(dss_path, sizeof (rfs4_dss_path_t)); 3119 3120 dss_path = path_next; 3121 } else { 3122 /* path was found; not removed */ 3123 dss_path = dss_path->next; 3124 } 3125 } while (dss_path != rfs4_dss_pathlist); 3126 3127 /* 3128 * Now, look for added paths: RGs that have been failed-over 3129 * to this node. 3130 * Walk the "passed-in" rfs4_dss_newpaths array from nfsd and, 3131 * for each path, check if it is on the "currently-serving" 3132 * rfs4_dss_pathlist. If not, that RG path has been added. 3133 * 3134 * Note: we don't do duplicate detection here; nfsd does that for us. 3135 * 3136 * Note: numadded_paths <= rfs4_dss_numnewpaths, which gives us 3137 * an upper bound for the size needed for added_paths[numadded_paths]. 3138 */ 3139 3140 /* probably more space than we need, but guaranteed to be enough */ 3141 if (rfs4_dss_numnewpaths > 0) { 3142 size_t sz = rfs4_dss_numnewpaths * sizeof (char *); 3143 added_paths = kmem_zalloc(sz, KM_SLEEP); 3144 } 3145 3146 /* walk the "passed-in" rfs4_dss_newpaths array from nfsd */ 3147 for (i = 0; i < rfs4_dss_numnewpaths; i++) { 3148 int found = 0; 3149 char *newpath = rfs4_dss_newpaths[i]; 3150 3151 dss_path = rfs4_dss_pathlist; 3152 do { 3153 char *path = dss_path->path; 3154 3155 /* used only for non-HA */ 3156 if (strcmp(path, NFS4_DSS_VAR_DIR) == 0) { 3157 dss_path = dss_path->next; 3158 continue; 3159 } 3160 3161 if (strncmp(path, newpath, strlen(path)) == 0) { 3162 found = 1; 3163 break; 3164 } 3165 3166 dss_path = dss_path->next; 3167 } while (dss_path != rfs4_dss_pathlist); 3168 3169 if (found == 0) { 3170 added_paths[numadded_paths] = newpath; 3171 numadded_paths++; 3172 } 3173 } 3174 3175 /* did we find any added paths? */ 3176 if (numadded_paths > 0) { 3177 /* create a new server instance, and start its grace period */ 3178 start_grace = 1; 3179 rfs4_servinst_create(start_grace, numadded_paths, added_paths); 3180 3181 /* read in the stable storage state from these paths */ 3182 rfs4_dss_readstate(numadded_paths, added_paths); 3183 3184 /* 3185 * Multiple failovers during a grace period will cause 3186 * clients of the same resource group to be partitioned 3187 * into different server instances, with different 3188 * grace periods. Since clients of the same resource 3189 * group must be subject to the same grace period, 3190 * we need to reset all currently active grace periods. 3191 */ 3192 rfs4_grace_reset_all(); 3193 } 3194 3195 if (rfs4_dss_numnewpaths > 0) 3196 kmem_free(added_paths, rfs4_dss_numnewpaths * sizeof (char *)); 3197 } 3198 3199 /* 3200 * Used by NFSv3 and NFSv4 server to query label of 3201 * a pathname component during lookup/access ops. 3202 */ 3203 ts_label_t * 3204 nfs_getflabel(vnode_t *vp, struct exportinfo *exi) 3205 { 3206 zone_t *zone; 3207 ts_label_t *zone_label; 3208 char *path; 3209 3210 mutex_enter(&vp->v_lock); 3211 if (vp->v_path != NULL) { 3212 zone = zone_find_by_any_path(vp->v_path, B_FALSE); 3213 mutex_exit(&vp->v_lock); 3214 } else { 3215 /* 3216 * v_path not cached. Fall back on pathname of exported 3217 * file system as we rely on pathname from which we can 3218 * derive a label. The exported file system portion of 3219 * path is sufficient to obtain a label. 3220 */ 3221 path = exi->exi_export.ex_path; 3222 if (path == NULL) { 3223 mutex_exit(&vp->v_lock); 3224 return (NULL); 3225 } 3226 zone = zone_find_by_any_path(path, B_FALSE); 3227 mutex_exit(&vp->v_lock); 3228 } 3229 /* 3230 * Caller has verified that the file is either 3231 * exported or visible. So if the path falls in 3232 * global zone, admin_low is returned; otherwise 3233 * the zone's label is returned. 3234 */ 3235 zone_label = zone->zone_slabel; 3236 label_hold(zone_label); 3237 zone_rele(zone); 3238 return (zone_label); 3239 } 3240 3241 /* 3242 * TX NFS routine used by NFSv3 and NFSv4 to do label check 3243 * on client label and server's file object lable. 3244 */ 3245 boolean_t 3246 do_rfs_label_check(bslabel_t *clabel, vnode_t *vp, int flag, 3247 struct exportinfo *exi) 3248 { 3249 bslabel_t *slabel; 3250 ts_label_t *tslabel; 3251 boolean_t result; 3252 3253 if ((tslabel = nfs_getflabel(vp, exi)) == NULL) { 3254 return (B_FALSE); 3255 } 3256 slabel = label2bslabel(tslabel); 3257 DTRACE_PROBE4(tx__rfs__log__info__labelcheck, char *, 3258 "comparing server's file label(1) with client label(2) (vp(3))", 3259 bslabel_t *, slabel, bslabel_t *, clabel, vnode_t *, vp); 3260 3261 if (flag == EQUALITY_CHECK) 3262 result = blequal(clabel, slabel); 3263 else 3264 result = bldominates(clabel, slabel); 3265 label_rele(tslabel); 3266 return (result); 3267 } 3268 3269 /* 3270 * Callback function to return the loaned buffers. 3271 * Calls VOP_RETZCBUF() only after all uio_iov[] 3272 * buffers are returned. nu_ref maintains the count. 3273 */ 3274 void 3275 rfs_free_xuio(void *free_arg) 3276 { 3277 uint_t ref; 3278 nfs_xuio_t *nfsuiop = (nfs_xuio_t *)free_arg; 3279 3280 ref = atomic_dec_uint_nv(&nfsuiop->nu_ref); 3281 3282 /* 3283 * Call VOP_RETZCBUF() only when all the iov buffers 3284 * are sent OTW. 3285 */ 3286 if (ref != 0) 3287 return; 3288 3289 if (((uio_t *)nfsuiop)->uio_extflg & UIO_XUIO) { 3290 (void) VOP_RETZCBUF(nfsuiop->nu_vp, (xuio_t *)free_arg, NULL, 3291 NULL); 3292 VN_RELE(nfsuiop->nu_vp); 3293 } 3294 3295 kmem_cache_free(nfs_xuio_cache, free_arg); 3296 } 3297 3298 xuio_t * 3299 rfs_setup_xuio(vnode_t *vp) 3300 { 3301 nfs_xuio_t *nfsuiop; 3302 3303 nfsuiop = kmem_cache_alloc(nfs_xuio_cache, KM_SLEEP); 3304 3305 bzero(nfsuiop, sizeof (nfs_xuio_t)); 3306 nfsuiop->nu_vp = vp; 3307 3308 /* 3309 * ref count set to 1. more may be added 3310 * if multiple mblks refer to multiple iov's. 3311 * This is done in uio_to_mblk(). 3312 */ 3313 3314 nfsuiop->nu_ref = 1; 3315 3316 nfsuiop->nu_frtn.free_func = rfs_free_xuio; 3317 nfsuiop->nu_frtn.free_arg = (char *)nfsuiop; 3318 3319 nfsuiop->nu_uio.xu_type = UIOTYPE_ZEROCOPY; 3320 3321 return (&nfsuiop->nu_uio); 3322 } 3323 3324 mblk_t * 3325 uio_to_mblk(uio_t *uiop) 3326 { 3327 struct iovec *iovp; 3328 int i; 3329 mblk_t *mp, *mp1; 3330 nfs_xuio_t *nfsuiop = (nfs_xuio_t *)uiop; 3331 3332 if (uiop->uio_iovcnt == 0) 3333 return (NULL); 3334 3335 iovp = uiop->uio_iov; 3336 mp = mp1 = esballoca((uchar_t *)iovp->iov_base, iovp->iov_len, 3337 BPRI_MED, &nfsuiop->nu_frtn); 3338 ASSERT(mp != NULL); 3339 3340 mp->b_wptr += iovp->iov_len; 3341 mp->b_datap->db_type = M_DATA; 3342 3343 for (i = 1; i < uiop->uio_iovcnt; i++) { 3344 iovp = (uiop->uio_iov + i); 3345 3346 mp1->b_cont = esballoca( 3347 (uchar_t *)iovp->iov_base, iovp->iov_len, BPRI_MED, 3348 &nfsuiop->nu_frtn); 3349 3350 mp1 = mp1->b_cont; 3351 ASSERT(mp1 != NULL); 3352 mp1->b_wptr += iovp->iov_len; 3353 mp1->b_datap->db_type = M_DATA; 3354 } 3355 3356 nfsuiop->nu_ref = uiop->uio_iovcnt; 3357 3358 return (mp); 3359 } 3360 3361 /* 3362 * Allocate memory to hold data for a read request of len bytes. 3363 * 3364 * We don't allocate buffers greater than kmem_max_cached in size to avoid 3365 * allocating memory from the kmem_oversized arena. If we allocate oversized 3366 * buffers, we incur heavy cross-call activity when freeing these large buffers 3367 * in the TCP receive path. Note that we can't set b_wptr here since the 3368 * length of the data returned may differ from the length requested when 3369 * reading the end of a file; we set b_wptr in rfs_rndup_mblks() once the 3370 * length of the read is known. 3371 */ 3372 mblk_t * 3373 rfs_read_alloc(uint_t len, struct iovec **iov, int *iovcnt) 3374 { 3375 struct iovec *iovarr; 3376 mblk_t *mp, **mpp = ∓ 3377 size_t mpsize; 3378 uint_t remain = len; 3379 int i, err = 0; 3380 3381 *iovcnt = howmany(len, kmem_max_cached); 3382 3383 iovarr = kmem_alloc(*iovcnt * sizeof (struct iovec), KM_SLEEP); 3384 *iov = iovarr; 3385 3386 for (i = 0; i < *iovcnt; remain -= mpsize, i++) { 3387 ASSERT(remain <= len); 3388 /* 3389 * We roundup the size we allocate to a multiple of 3390 * BYTES_PER_XDR_UNIT (4 bytes) so that the call to 3391 * xdrmblk_putmblk() never fails. 3392 */ 3393 ASSERT(kmem_max_cached % BYTES_PER_XDR_UNIT == 0); 3394 mpsize = MIN(kmem_max_cached, remain); 3395 *mpp = allocb_wait(RNDUP(mpsize), BPRI_MED, STR_NOSIG, &err); 3396 ASSERT(*mpp != NULL); 3397 ASSERT(err == 0); 3398 3399 iovarr[i].iov_base = (caddr_t)(*mpp)->b_rptr; 3400 iovarr[i].iov_len = mpsize; 3401 mpp = &(*mpp)->b_cont; 3402 } 3403 return (mp); 3404 } 3405 3406 void 3407 rfs_rndup_mblks(mblk_t *mp, uint_t len, int buf_loaned) 3408 { 3409 int i; 3410 int alloc_err = 0; 3411 mblk_t *rmp; 3412 uint_t mpsize, remainder; 3413 3414 remainder = P2NPHASE(len, BYTES_PER_XDR_UNIT); 3415 3416 /* 3417 * Non copy-reduction case. This function assumes that blocks were 3418 * allocated in multiples of BYTES_PER_XDR_UNIT bytes, which makes this 3419 * padding safe without bounds checking. 3420 */ 3421 if (!buf_loaned) { 3422 /* 3423 * Set the size of each mblk in the chain until we've consumed 3424 * the specified length for all but the last one. 3425 */ 3426 while ((mpsize = MBLKSIZE(mp)) < len) { 3427 ASSERT(mpsize % BYTES_PER_XDR_UNIT == 0); 3428 mp->b_wptr += mpsize; 3429 len -= mpsize; 3430 mp = mp->b_cont; 3431 ASSERT(mp != NULL); 3432 } 3433 3434 ASSERT(len + remainder <= mpsize); 3435 mp->b_wptr += len; 3436 for (i = 0; i < remainder; i++) 3437 *mp->b_wptr++ = '\0'; 3438 return; 3439 } 3440 3441 /* 3442 * No remainder mblk required. 3443 */ 3444 if (remainder == 0) 3445 return; 3446 3447 /* 3448 * Get to the last mblk in the chain. 3449 */ 3450 while (mp->b_cont != NULL) 3451 mp = mp->b_cont; 3452 3453 /* 3454 * In case of copy-reduction mblks, the size of the mblks are fixed 3455 * and are of the size of the loaned buffers. Allocate a remainder 3456 * mblk and chain it to the data buffers. This is sub-optimal, but not 3457 * expected to happen commonly. 3458 */ 3459 rmp = allocb_wait(remainder, BPRI_MED, STR_NOSIG, &alloc_err); 3460 ASSERT(rmp != NULL); 3461 ASSERT(alloc_err == 0); 3462 3463 for (i = 0; i < remainder; i++) 3464 *rmp->b_wptr++ = '\0'; 3465 3466 rmp->b_datap->db_type = M_DATA; 3467 mp->b_cont = rmp; 3468 } 3469