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, NULL);
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 = &mp;
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 }