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 /*
  23  * Copyright 2015 Nexenta Systems, Inc.  All rights reserved.
  24  * Copyright (c) 1994, 2010, Oracle and/or its affiliates. All rights reserved.
  25  * Copyright (c) 2013 by Delphix. All rights reserved.
  26  */
  27 
  28 /* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
  29 /* All Rights Reserved */
  30 
  31 #include <sys/param.h>
  32 #include <sys/types.h>
  33 #include <sys/systm.h>
  34 #include <sys/cred.h>
  35 #include <sys/buf.h>
  36 #include <sys/vfs.h>
  37 #include <sys/vnode.h>
  38 #include <sys/uio.h>
  39 #include <sys/errno.h>
  40 #include <sys/sysmacros.h>
  41 #include <sys/statvfs.h>
  42 #include <sys/kmem.h>
  43 #include <sys/dirent.h>
  44 #include <sys/cmn_err.h>
  45 #include <sys/debug.h>
  46 #include <sys/systeminfo.h>
  47 #include <sys/flock.h>
  48 #include <sys/nbmlock.h>
  49 #include <sys/policy.h>
  50 #include <sys/sdt.h>
  51 
  52 #include <rpc/types.h>
  53 #include <rpc/auth.h>
  54 #include <rpc/svc.h>
  55 #include <rpc/rpc_rdma.h>
  56 
  57 #include <nfs/nfs.h>
  58 #include <nfs/export.h>
  59 #include <nfs/nfs_cmd.h>
  60 
  61 #include <sys/strsubr.h>
  62 #include <sys/tsol/label.h>
  63 #include <sys/tsol/tndb.h>
  64 
  65 #include <sys/zone.h>
  66 
  67 #include <inet/ip.h>
  68 #include <inet/ip6.h>
  69 
  70 /*
  71  * These are the interface routines for the server side of the
  72  * Network File System.  See the NFS version 3 protocol specification
  73  * for a description of this interface.
  74  */
  75 
  76 static writeverf3 write3verf;
  77 
  78 static int      sattr3_to_vattr(sattr3 *, struct vattr *);
  79 static int      vattr_to_fattr3(struct vattr *, fattr3 *);
  80 static int      vattr_to_wcc_attr(struct vattr *, wcc_attr *);
  81 static void     vattr_to_pre_op_attr(struct vattr *, pre_op_attr *);
  82 static void     vattr_to_wcc_data(struct vattr *, struct vattr *, wcc_data *);
  83 static int      rdma_setup_read_data3(READ3args *, READ3resok *);
  84 
  85 extern int nfs_loaned_buffers;
  86 
  87 u_longlong_t nfs3_srv_caller_id;
  88 
  89 /* ARGSUSED */
  90 void
  91 rfs3_getattr(GETATTR3args *args, GETATTR3res *resp, struct exportinfo *exi,
  92     struct svc_req *req, cred_t *cr, bool_t ro)
  93 {
  94         int error;
  95         vnode_t *vp;
  96         struct vattr va;
  97 
  98         vp = nfs3_fhtovp(&args->object, exi);
  99 
 100         DTRACE_NFSV3_4(op__getattr__start, struct svc_req *, req,
 101             cred_t *, cr, vnode_t *, vp, GETATTR3args *, args);
 102 
 103         if (vp == NULL) {
 104                 error = ESTALE;
 105                 goto out;
 106         }
 107 
 108         va.va_mask = AT_ALL;
 109         error = rfs4_delegated_getattr(vp, &va, 0, cr);
 110 
 111         if (!error) {
 112                 /* Lie about the object type for a referral */
 113                 if (vn_is_nfs_reparse(vp, cr))
 114                         va.va_type = VLNK;
 115 
 116                 /* overflow error if time or size is out of range */
 117                 error = vattr_to_fattr3(&va, &resp->resok.obj_attributes);
 118                 if (error)
 119                         goto out;
 120                 resp->status = NFS3_OK;
 121 
 122                 DTRACE_NFSV3_4(op__getattr__done, struct svc_req *, req,
 123                     cred_t *, cr, vnode_t *, vp, GETATTR3res *, resp);
 124 
 125                 VN_RELE(vp);
 126 
 127                 return;
 128         }
 129 
 130 out:
 131         if (curthread->t_flag & T_WOULDBLOCK) {
 132                 curthread->t_flag &= ~T_WOULDBLOCK;
 133                 resp->status = NFS3ERR_JUKEBOX;
 134         } else
 135                 resp->status = puterrno3(error);
 136 
 137         DTRACE_NFSV3_4(op__getattr__done, struct svc_req *, req,
 138             cred_t *, cr, vnode_t *, vp, GETATTR3res *, resp);
 139 
 140         if (vp != NULL)
 141                 VN_RELE(vp);
 142 }
 143 
 144 void *
 145 rfs3_getattr_getfh(GETATTR3args *args)
 146 {
 147 
 148         return (&args->object);
 149 }
 150 
 151 void
 152 rfs3_setattr(SETATTR3args *args, SETATTR3res *resp, struct exportinfo *exi,
 153     struct svc_req *req, cred_t *cr, bool_t ro)
 154 {
 155         int error;
 156         vnode_t *vp;
 157         struct vattr *bvap;
 158         struct vattr bva;
 159         struct vattr *avap;
 160         struct vattr ava;
 161         int flag;
 162         int in_crit = 0;
 163         struct flock64 bf;
 164         caller_context_t ct;
 165 
 166         bvap = NULL;
 167         avap = NULL;
 168 
 169         vp = nfs3_fhtovp(&args->object, exi);
 170 
 171         DTRACE_NFSV3_4(op__setattr__start, struct svc_req *, req,
 172             cred_t *, cr, vnode_t *, vp, SETATTR3args *, args);
 173 
 174         if (vp == NULL) {
 175                 error = ESTALE;
 176                 goto out;
 177         }
 178 
 179         error = sattr3_to_vattr(&args->new_attributes, &ava);
 180         if (error)
 181                 goto out;
 182 
 183         if (is_system_labeled()) {
 184                 bslabel_t *clabel = req->rq_label;
 185 
 186                 ASSERT(clabel != NULL);
 187                 DTRACE_PROBE2(tx__rfs3__log__info__opsetattr__clabel, char *,
 188                     "got client label from request(1)", struct svc_req *, req);
 189 
 190                 if (!blequal(&l_admin_low->tsl_label, clabel)) {
 191                         if (!do_rfs_label_check(clabel, vp, EQUALITY_CHECK,
 192                             exi)) {
 193                                 resp->status = NFS3ERR_ACCES;
 194                                 goto out1;
 195                         }
 196                 }
 197         }
 198 
 199         /*
 200          * We need to specially handle size changes because of
 201          * possible conflicting NBMAND locks. Get into critical
 202          * region before VOP_GETATTR, so the size attribute is
 203          * valid when checking conflicts.
 204          *
 205          * Also, check to see if the v4 side of the server has
 206          * delegated this file.  If so, then we return JUKEBOX to
 207          * allow the client to retrasmit its request.
 208          */
 209         if (vp->v_type == VREG && (ava.va_mask & AT_SIZE)) {
 210                 if (nbl_need_check(vp)) {
 211                         nbl_start_crit(vp, RW_READER);
 212                         in_crit = 1;
 213                 }
 214         }
 215 
 216         bva.va_mask = AT_ALL;
 217         error = rfs4_delegated_getattr(vp, &bva, 0, cr);
 218 
 219         /*
 220          * If we can't get the attributes, then we can't do the
 221          * right access checking.  So, we'll fail the request.
 222          */
 223         if (error)
 224                 goto out;
 225 
 226         bvap = &bva;
 227 
 228         if (rdonly(ro, vp)) {
 229                 resp->status = NFS3ERR_ROFS;
 230                 goto out1;
 231         }
 232 
 233         if (args->guard.check &&
 234             (args->guard.obj_ctime.seconds != bva.va_ctime.tv_sec ||
 235             args->guard.obj_ctime.nseconds != bva.va_ctime.tv_nsec)) {
 236                 resp->status = NFS3ERR_NOT_SYNC;
 237                 goto out1;
 238         }
 239 
 240         if (args->new_attributes.mtime.set_it == SET_TO_CLIENT_TIME)
 241                 flag = ATTR_UTIME;
 242         else
 243                 flag = 0;
 244 
 245         /*
 246          * If the filesystem is exported with nosuid, then mask off
 247          * the setuid and setgid bits.
 248          */
 249         if ((ava.va_mask & AT_MODE) && vp->v_type == VREG &&
 250             (exi->exi_export.ex_flags & EX_NOSUID))
 251                 ava.va_mode &= ~(VSUID | VSGID);
 252 
 253         ct.cc_sysid = 0;
 254         ct.cc_pid = 0;
 255         ct.cc_caller_id = nfs3_srv_caller_id;
 256         ct.cc_flags = CC_DONTBLOCK;
 257 
 258         /*
 259          * We need to specially handle size changes because it is
 260          * possible for the client to create a file with modes
 261          * which indicate read-only, but with the file opened for
 262          * writing.  If the client then tries to set the size of
 263          * the file, then the normal access checking done in
 264          * VOP_SETATTR would prevent the client from doing so,
 265          * although it should be legal for it to do so.  To get
 266          * around this, we do the access checking for ourselves
 267          * and then use VOP_SPACE which doesn't do the access
 268          * checking which VOP_SETATTR does. VOP_SPACE can only
 269          * operate on VREG files, let VOP_SETATTR handle the other
 270          * extremely rare cases.
 271          * Also the client should not be allowed to change the
 272          * size of the file if there is a conflicting non-blocking
 273          * mandatory lock in the region the change.
 274          */
 275         if (vp->v_type == VREG && (ava.va_mask & AT_SIZE)) {
 276                 if (in_crit) {
 277                         u_offset_t offset;
 278                         ssize_t length;
 279 
 280                         if (ava.va_size < bva.va_size) {
 281                                 offset = ava.va_size;
 282                                 length = bva.va_size - ava.va_size;
 283                         } else {
 284                                 offset = bva.va_size;
 285                                 length = ava.va_size - bva.va_size;
 286                         }
 287                         if (nbl_conflict(vp, NBL_WRITE, offset, length, 0,
 288                             NULL)) {
 289                                 error = EACCES;
 290                                 goto out;
 291                         }
 292                 }
 293 
 294                 if (crgetuid(cr) == bva.va_uid && ava.va_size != bva.va_size) {
 295                         ava.va_mask &= ~AT_SIZE;
 296                         bf.l_type = F_WRLCK;
 297                         bf.l_whence = 0;
 298                         bf.l_start = (off64_t)ava.va_size;
 299                         bf.l_len = 0;
 300                         bf.l_sysid = 0;
 301                         bf.l_pid = 0;
 302                         error = VOP_SPACE(vp, F_FREESP, &bf, FWRITE,
 303                             (offset_t)ava.va_size, cr, &ct);
 304                 }
 305         }
 306 
 307         if (!error && ava.va_mask)
 308                 error = VOP_SETATTR(vp, &ava, flag, cr, &ct);
 309 
 310         /* check if a monitor detected a delegation conflict */
 311         if (error == EAGAIN && (ct.cc_flags & CC_WOULDBLOCK)) {
 312                 resp->status = NFS3ERR_JUKEBOX;
 313                 goto out1;
 314         }
 315 
 316         ava.va_mask = AT_ALL;
 317         avap = rfs4_delegated_getattr(vp, &ava, 0, cr) ? NULL : &ava;
 318 
 319         /*
 320          * Force modified metadata out to stable storage.
 321          */
 322         (void) VOP_FSYNC(vp, FNODSYNC, cr, &ct);
 323 
 324         if (error)
 325                 goto out;
 326 
 327         if (in_crit)
 328                 nbl_end_crit(vp);
 329 
 330         resp->status = NFS3_OK;
 331         vattr_to_wcc_data(bvap, avap, &resp->resok.obj_wcc);
 332 
 333         DTRACE_NFSV3_4(op__setattr__done, struct svc_req *, req,
 334             cred_t *, cr, vnode_t *, vp, SETATTR3res *, resp);
 335 
 336         VN_RELE(vp);
 337 
 338         return;
 339 
 340 out:
 341         if (curthread->t_flag & T_WOULDBLOCK) {
 342                 curthread->t_flag &= ~T_WOULDBLOCK;
 343                 resp->status = NFS3ERR_JUKEBOX;
 344         } else
 345                 resp->status = puterrno3(error);
 346 out1:
 347         DTRACE_NFSV3_4(op__setattr__done, struct svc_req *, req,
 348             cred_t *, cr, vnode_t *, vp, SETATTR3res *, resp);
 349 
 350         if (vp != NULL) {
 351                 if (in_crit)
 352                         nbl_end_crit(vp);
 353                 VN_RELE(vp);
 354         }
 355         vattr_to_wcc_data(bvap, avap, &resp->resfail.obj_wcc);
 356 }
 357 
 358 void *
 359 rfs3_setattr_getfh(SETATTR3args *args)
 360 {
 361 
 362         return (&args->object);
 363 }
 364 
 365 /* ARGSUSED */
 366 void
 367 rfs3_lookup(LOOKUP3args *args, LOOKUP3res *resp, struct exportinfo *exi,
 368     struct svc_req *req, cred_t *cr, bool_t ro)
 369 {
 370         int error;
 371         vnode_t *vp;
 372         vnode_t *dvp;
 373         struct vattr *vap;
 374         struct vattr va;
 375         struct vattr *dvap;
 376         struct vattr dva;
 377         nfs_fh3 *fhp;
 378         struct sec_ol sec = {0, 0};
 379         bool_t publicfh_flag = FALSE, auth_weak = FALSE;
 380         struct sockaddr *ca;
 381         char *name = NULL;
 382 
 383         dvap = NULL;
 384 
 385         /*
 386          * Allow lookups from the root - the default
 387          * location of the public filehandle.
 388          */
 389         if (exi != NULL && (exi->exi_export.ex_flags & EX_PUBLIC)) {
 390                 dvp = rootdir;
 391                 VN_HOLD(dvp);
 392 
 393                 DTRACE_NFSV3_4(op__lookup__start, struct svc_req *, req,
 394                     cred_t *, cr, vnode_t *, dvp, LOOKUP3args *, args);
 395         } else {
 396                 dvp = nfs3_fhtovp(&args->what.dir, exi);
 397 
 398                 DTRACE_NFSV3_4(op__lookup__start, struct svc_req *, req,
 399                     cred_t *, cr, vnode_t *, dvp, LOOKUP3args *, args);
 400 
 401                 if (dvp == NULL) {
 402                         error = ESTALE;
 403                         goto out;
 404                 }
 405         }
 406 
 407         dva.va_mask = AT_ALL;
 408         dvap = VOP_GETATTR(dvp, &dva, 0, cr, NULL) ? NULL : &dva;
 409 
 410         if (args->what.name == nfs3nametoolong) {
 411                 resp->status = NFS3ERR_NAMETOOLONG;
 412                 goto out1;
 413         }
 414 
 415         if (args->what.name == NULL || *(args->what.name) == '\0') {
 416                 resp->status = NFS3ERR_ACCES;
 417                 goto out1;
 418         }
 419 
 420         fhp = &args->what.dir;
 421         if (strcmp(args->what.name, "..") == 0 &&
 422             EQFID(&exi->exi_fid, FH3TOFIDP(fhp))) {
 423                 resp->status = NFS3ERR_NOENT;
 424                 goto out1;
 425         }
 426 
 427         ca = (struct sockaddr *)svc_getrpccaller(req->rq_xprt)->buf;
 428         name = nfscmd_convname(ca, exi, args->what.name,
 429             NFSCMD_CONV_INBOUND, MAXPATHLEN + 1);
 430 
 431         if (name == NULL) {
 432                 resp->status = NFS3ERR_ACCES;
 433                 goto out1;
 434         }
 435 
 436         /*
 437          * If the public filehandle is used then allow
 438          * a multi-component lookup
 439          */
 440         if (PUBLIC_FH3(&args->what.dir)) {
 441                 publicfh_flag = TRUE;
 442                 error = rfs_publicfh_mclookup(name, dvp, cr, &vp,
 443                     &exi, &sec);
 444                 if (error && exi != NULL)
 445                         exi_rele(exi); /* See comment below Re: publicfh_flag */
 446                 /*
 447                  * Since WebNFS may bypass MOUNT, we need to ensure this
 448                  * request didn't come from an unlabeled admin_low client.
 449                  */
 450                 if (is_system_labeled() && error == 0) {
 451                         int             addr_type;
 452                         void            *ipaddr;
 453                         tsol_tpc_t      *tp;
 454 
 455                         if (ca->sa_family == AF_INET) {
 456                                 addr_type = IPV4_VERSION;
 457                                 ipaddr = &((struct sockaddr_in *)ca)->sin_addr;
 458                         } else if (ca->sa_family == AF_INET6) {
 459                                 addr_type = IPV6_VERSION;
 460                                 ipaddr = &((struct sockaddr_in6 *)
 461                                     ca)->sin6_addr;
 462                         }
 463                         tp = find_tpc(ipaddr, addr_type, B_FALSE);
 464                         if (tp == NULL || tp->tpc_tp.tp_doi !=
 465                             l_admin_low->tsl_doi || tp->tpc_tp.host_type !=
 466                             SUN_CIPSO) {
 467                                 if (exi != NULL)
 468                                         exi_rele(exi);
 469                                 VN_RELE(vp);
 470                                 error = EACCES;
 471                         }
 472                         if (tp != NULL)
 473                                 TPC_RELE(tp);
 474                 }
 475         } else {
 476                 error = VOP_LOOKUP(dvp, name, &vp,
 477                     NULL, 0, NULL, cr, NULL, NULL, NULL);
 478         }
 479 
 480         if (name != args->what.name)
 481                 kmem_free(name, MAXPATHLEN + 1);
 482 
 483         if (is_system_labeled() && error == 0) {
 484                 bslabel_t *clabel = req->rq_label;
 485 
 486                 ASSERT(clabel != NULL);
 487                 DTRACE_PROBE2(tx__rfs3__log__info__oplookup__clabel, char *,
 488                     "got client label from request(1)", struct svc_req *, req);
 489 
 490                 if (!blequal(&l_admin_low->tsl_label, clabel)) {
 491                         if (!do_rfs_label_check(clabel, dvp,
 492                             DOMINANCE_CHECK, exi)) {
 493                                 if (publicfh_flag && exi != NULL)
 494                                         exi_rele(exi);
 495                                 VN_RELE(vp);
 496                                 error = EACCES;
 497                         }
 498                 }
 499         }
 500 
 501         dva.va_mask = AT_ALL;
 502         dvap = VOP_GETATTR(dvp, &dva, 0, cr, NULL) ? NULL : &dva;
 503 
 504         if (error)
 505                 goto out;
 506 
 507         if (sec.sec_flags & SEC_QUERY) {
 508                 error = makefh3_ol(&resp->resok.object, exi, sec.sec_index);
 509         } else {
 510                 error = makefh3(&resp->resok.object, vp, exi);
 511                 if (!error && publicfh_flag && !chk_clnt_sec(exi, req))
 512                         auth_weak = TRUE;
 513         }
 514 
 515         /*
 516          * If publicfh_flag is true then we have called rfs_publicfh_mclookup
 517          * and have obtained a new exportinfo in exi which needs to be
 518          * released. Note that the original exportinfo pointed to by exi
 519          * will be released by the caller, common_dispatch.
 520          */
 521         if (publicfh_flag)
 522                 exi_rele(exi);
 523 
 524         if (error) {
 525                 VN_RELE(vp);
 526                 goto out;
 527         }
 528 
 529         va.va_mask = AT_ALL;
 530         vap = rfs4_delegated_getattr(vp, &va, 0, cr) ? NULL : &va;
 531 
 532         VN_RELE(vp);
 533 
 534         resp->status = NFS3_OK;
 535         vattr_to_post_op_attr(vap, &resp->resok.obj_attributes);
 536         vattr_to_post_op_attr(dvap, &resp->resok.dir_attributes);
 537 
 538         /*
 539          * If it's public fh, no 0x81, and client's flavor is
 540          * invalid, set WebNFS status to WNFSERR_CLNT_FLAVOR now.
 541          * Then set RPC status to AUTH_TOOWEAK in common_dispatch.
 542          */
 543         if (auth_weak)
 544                 resp->status = (enum nfsstat3)WNFSERR_CLNT_FLAVOR;
 545 
 546         DTRACE_NFSV3_4(op__lookup__done, struct svc_req *, req,
 547             cred_t *, cr, vnode_t *, dvp, LOOKUP3res *, resp);
 548         VN_RELE(dvp);
 549 
 550         return;
 551 
 552 out:
 553         if (curthread->t_flag & T_WOULDBLOCK) {
 554                 curthread->t_flag &= ~T_WOULDBLOCK;
 555                 resp->status = NFS3ERR_JUKEBOX;
 556         } else
 557                 resp->status = puterrno3(error);
 558 out1:
 559         DTRACE_NFSV3_4(op__lookup__done, struct svc_req *, req,
 560             cred_t *, cr, vnode_t *, dvp, LOOKUP3res *, resp);
 561 
 562         if (dvp != NULL)
 563                 VN_RELE(dvp);
 564         vattr_to_post_op_attr(dvap, &resp->resfail.dir_attributes);
 565 
 566 }
 567 
 568 void *
 569 rfs3_lookup_getfh(LOOKUP3args *args)
 570 {
 571 
 572         return (&args->what.dir);
 573 }
 574 
 575 /* ARGSUSED */
 576 void
 577 rfs3_access(ACCESS3args *args, ACCESS3res *resp, struct exportinfo *exi,
 578     struct svc_req *req, cred_t *cr, bool_t ro)
 579 {
 580         int error;
 581         vnode_t *vp;
 582         struct vattr *vap;
 583         struct vattr va;
 584         int checkwriteperm;
 585         boolean_t dominant_label = B_FALSE;
 586         boolean_t equal_label = B_FALSE;
 587         boolean_t admin_low_client;
 588 
 589         vap = NULL;
 590 
 591         vp = nfs3_fhtovp(&args->object, exi);
 592 
 593         DTRACE_NFSV3_4(op__access__start, struct svc_req *, req,
 594             cred_t *, cr, vnode_t *, vp, ACCESS3args *, args);
 595 
 596         if (vp == NULL) {
 597                 error = ESTALE;
 598                 goto out;
 599         }
 600 
 601         /*
 602          * If the file system is exported read only, it is not appropriate
 603          * to check write permissions for regular files and directories.
 604          * Special files are interpreted by the client, so the underlying
 605          * permissions are sent back to the client for interpretation.
 606          */
 607         if (rdonly(ro, vp) && (vp->v_type == VREG || vp->v_type == VDIR))
 608                 checkwriteperm = 0;
 609         else
 610                 checkwriteperm = 1;
 611 
 612         /*
 613          * We need the mode so that we can correctly determine access
 614          * permissions relative to a mandatory lock file.  Access to
 615          * mandatory lock files is denied on the server, so it might
 616          * as well be reflected to the server during the open.
 617          */
 618         va.va_mask = AT_MODE;
 619         error = VOP_GETATTR(vp, &va, 0, cr, NULL);
 620         if (error)
 621                 goto out;
 622 
 623         vap = &va;
 624 
 625         resp->resok.access = 0;
 626 
 627         if (is_system_labeled()) {
 628                 bslabel_t *clabel = req->rq_label;
 629 
 630                 ASSERT(clabel != NULL);
 631                 DTRACE_PROBE2(tx__rfs3__log__info__opaccess__clabel, char *,
 632                     "got client label from request(1)", struct svc_req *, req);
 633 
 634                 if (!blequal(&l_admin_low->tsl_label, clabel)) {
 635                         if ((equal_label = do_rfs_label_check(clabel, vp,
 636                             EQUALITY_CHECK, exi)) == B_FALSE) {
 637                                 dominant_label = do_rfs_label_check(clabel,
 638                                     vp, DOMINANCE_CHECK, exi);
 639                         } else
 640                                 dominant_label = B_TRUE;
 641                         admin_low_client = B_FALSE;
 642                 } else
 643                         admin_low_client = B_TRUE;
 644         }
 645 
 646         if (args->access & ACCESS3_READ) {
 647                 error = VOP_ACCESS(vp, VREAD, 0, cr, NULL);
 648                 if (error) {
 649                         if (curthread->t_flag & T_WOULDBLOCK)
 650                                 goto out;
 651                 } else if (!MANDLOCK(vp, va.va_mode) &&
 652                     (!is_system_labeled() || admin_low_client ||
 653                     dominant_label))
 654                         resp->resok.access |= ACCESS3_READ;
 655         }
 656         if ((args->access & ACCESS3_LOOKUP) && vp->v_type == VDIR) {
 657                 error = VOP_ACCESS(vp, VEXEC, 0, cr, NULL);
 658                 if (error) {
 659                         if (curthread->t_flag & T_WOULDBLOCK)
 660                                 goto out;
 661                 } else if (!is_system_labeled() || admin_low_client ||
 662                     dominant_label)
 663                         resp->resok.access |= ACCESS3_LOOKUP;
 664         }
 665         if (checkwriteperm &&
 666             (args->access & (ACCESS3_MODIFY|ACCESS3_EXTEND))) {
 667                 error = VOP_ACCESS(vp, VWRITE, 0, cr, NULL);
 668                 if (error) {
 669                         if (curthread->t_flag & T_WOULDBLOCK)
 670                                 goto out;
 671                 } else if (!MANDLOCK(vp, va.va_mode) &&
 672                     (!is_system_labeled() || admin_low_client || equal_label)) {
 673                         resp->resok.access |=
 674                             (args->access & (ACCESS3_MODIFY|ACCESS3_EXTEND));
 675                 }
 676         }
 677         if (checkwriteperm &&
 678             (args->access & ACCESS3_DELETE) && vp->v_type == VDIR) {
 679                 error = VOP_ACCESS(vp, VWRITE, 0, cr, NULL);
 680                 if (error) {
 681                         if (curthread->t_flag & T_WOULDBLOCK)
 682                                 goto out;
 683                 } else if (!is_system_labeled() || admin_low_client ||
 684                     equal_label)
 685                         resp->resok.access |= ACCESS3_DELETE;
 686         }
 687         if (args->access & ACCESS3_EXECUTE) {
 688                 error = VOP_ACCESS(vp, VEXEC, 0, cr, NULL);
 689                 if (error) {
 690                         if (curthread->t_flag & T_WOULDBLOCK)
 691                                 goto out;
 692                 } else if (!MANDLOCK(vp, va.va_mode) &&
 693                     (!is_system_labeled() || admin_low_client ||
 694                     dominant_label))
 695                         resp->resok.access |= ACCESS3_EXECUTE;
 696         }
 697 
 698         va.va_mask = AT_ALL;
 699         vap = rfs4_delegated_getattr(vp, &va, 0, cr) ? NULL : &va;
 700 
 701         resp->status = NFS3_OK;
 702         vattr_to_post_op_attr(vap, &resp->resok.obj_attributes);
 703 
 704         DTRACE_NFSV3_4(op__access__done, struct svc_req *, req,
 705             cred_t *, cr, vnode_t *, vp, ACCESS3res *, resp);
 706 
 707         VN_RELE(vp);
 708 
 709         return;
 710 
 711 out:
 712         if (curthread->t_flag & T_WOULDBLOCK) {
 713                 curthread->t_flag &= ~T_WOULDBLOCK;
 714                 resp->status = NFS3ERR_JUKEBOX;
 715         } else
 716                 resp->status = puterrno3(error);
 717         DTRACE_NFSV3_4(op__access__done, struct svc_req *, req,
 718             cred_t *, cr, vnode_t *, vp, ACCESS3res *, resp);
 719         if (vp != NULL)
 720                 VN_RELE(vp);
 721         vattr_to_post_op_attr(vap, &resp->resfail.obj_attributes);
 722 }
 723 
 724 void *
 725 rfs3_access_getfh(ACCESS3args *args)
 726 {
 727 
 728         return (&args->object);
 729 }
 730 
 731 /* ARGSUSED */
 732 void
 733 rfs3_readlink(READLINK3args *args, READLINK3res *resp, struct exportinfo *exi,
 734     struct svc_req *req, cred_t *cr, bool_t ro)
 735 {
 736         int error;
 737         vnode_t *vp;
 738         struct vattr *vap;
 739         struct vattr va;
 740         struct iovec iov;
 741         struct uio uio;
 742         char *data;
 743         struct sockaddr *ca;
 744         char *name = NULL;
 745         int is_referral = 0;
 746 
 747         vap = NULL;
 748 
 749         vp = nfs3_fhtovp(&args->symlink, exi);
 750 
 751         DTRACE_NFSV3_4(op__readlink__start, struct svc_req *, req,
 752             cred_t *, cr, vnode_t *, vp, READLINK3args *, args);
 753 
 754         if (vp == NULL) {
 755                 error = ESTALE;
 756                 goto out;
 757         }
 758 
 759         va.va_mask = AT_ALL;
 760         error = VOP_GETATTR(vp, &va, 0, cr, NULL);
 761         if (error)
 762                 goto out;
 763 
 764         vap = &va;
 765 
 766         /* We lied about the object type for a referral */
 767         if (vn_is_nfs_reparse(vp, cr))
 768                 is_referral = 1;
 769 
 770         if (vp->v_type != VLNK && !is_referral) {
 771                 resp->status = NFS3ERR_INVAL;
 772                 goto out1;
 773         }
 774 
 775         if (MANDLOCK(vp, va.va_mode)) {
 776                 resp->status = NFS3ERR_ACCES;
 777                 goto out1;
 778         }
 779 
 780         if (is_system_labeled()) {
 781                 bslabel_t *clabel = req->rq_label;
 782 
 783                 ASSERT(clabel != NULL);
 784                 DTRACE_PROBE2(tx__rfs3__log__info__opreadlink__clabel, char *,
 785                     "got client label from request(1)", struct svc_req *, req);
 786 
 787                 if (!blequal(&l_admin_low->tsl_label, clabel)) {
 788                         if (!do_rfs_label_check(clabel, vp, DOMINANCE_CHECK,
 789                             exi)) {
 790                                 resp->status = NFS3ERR_ACCES;
 791                                 goto out1;
 792                         }
 793                 }
 794         }
 795 
 796         data = kmem_alloc(MAXPATHLEN + 1, KM_SLEEP);
 797 
 798         if (is_referral) {
 799                 char *s;
 800                 size_t strsz;
 801 
 802                 /* Get an artificial symlink based on a referral */
 803                 s = build_symlink(vp, cr, &strsz);
 804                 global_svstat_ptr[3][NFS_REFERLINKS].value.ui64++;
 805                 DTRACE_PROBE2(nfs3serv__func__referral__reflink,
 806                     vnode_t *, vp, char *, s);
 807                 if (s == NULL)
 808                         error = EINVAL;
 809                 else {
 810                         error = 0;
 811                         (void) strlcpy(data, s, MAXPATHLEN + 1);
 812                         kmem_free(s, strsz);
 813                 }
 814 
 815         } else {
 816 
 817                 iov.iov_base = data;
 818                 iov.iov_len = MAXPATHLEN;
 819                 uio.uio_iov = &iov;
 820                 uio.uio_iovcnt = 1;
 821                 uio.uio_segflg = UIO_SYSSPACE;
 822                 uio.uio_extflg = UIO_COPY_CACHED;
 823                 uio.uio_loffset = 0;
 824                 uio.uio_resid = MAXPATHLEN;
 825 
 826                 error = VOP_READLINK(vp, &uio, cr, NULL);
 827 
 828                 if (!error)
 829                         *(data + MAXPATHLEN - uio.uio_resid) = '\0';
 830         }
 831 
 832         va.va_mask = AT_ALL;
 833         vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
 834 
 835         /* Lie about object type again just to be consistent */
 836         if (is_referral && vap != NULL)
 837                 vap->va_type = VLNK;
 838 
 839 #if 0 /* notyet */
 840         /*
 841          * Don't do this.  It causes local disk writes when just
 842          * reading the file and the overhead is deemed larger
 843          * than the benefit.
 844          */
 845         /*
 846          * Force modified metadata out to stable storage.
 847          */
 848         (void) VOP_FSYNC(vp, FNODSYNC, cr, NULL);
 849 #endif
 850 
 851         if (error) {
 852                 kmem_free(data, MAXPATHLEN + 1);
 853                 goto out;
 854         }
 855 
 856         ca = (struct sockaddr *)svc_getrpccaller(req->rq_xprt)->buf;
 857         name = nfscmd_convname(ca, exi, data, NFSCMD_CONV_OUTBOUND,
 858             MAXPATHLEN + 1);
 859 
 860         if (name == NULL) {
 861                 /*
 862                  * Even though the conversion failed, we return
 863                  * something. We just don't translate it.
 864                  */
 865                 name = data;
 866         }
 867 
 868         resp->status = NFS3_OK;
 869         vattr_to_post_op_attr(vap, &resp->resok.symlink_attributes);
 870         resp->resok.data = name;
 871 
 872         DTRACE_NFSV3_4(op__readlink__done, struct svc_req *, req,
 873             cred_t *, cr, vnode_t *, vp, READLINK3res *, resp);
 874         VN_RELE(vp);
 875 
 876         if (name != data)
 877                 kmem_free(data, MAXPATHLEN + 1);
 878 
 879         return;
 880 
 881 out:
 882         if (curthread->t_flag & T_WOULDBLOCK) {
 883                 curthread->t_flag &= ~T_WOULDBLOCK;
 884                 resp->status = NFS3ERR_JUKEBOX;
 885         } else
 886                 resp->status = puterrno3(error);
 887 out1:
 888         DTRACE_NFSV3_4(op__readlink__done, struct svc_req *, req,
 889             cred_t *, cr, vnode_t *, vp, READLINK3res *, resp);
 890         if (vp != NULL)
 891                 VN_RELE(vp);
 892         vattr_to_post_op_attr(vap, &resp->resfail.symlink_attributes);
 893 }
 894 
 895 void *
 896 rfs3_readlink_getfh(READLINK3args *args)
 897 {
 898 
 899         return (&args->symlink);
 900 }
 901 
 902 void
 903 rfs3_readlink_free(READLINK3res *resp)
 904 {
 905 
 906         if (resp->status == NFS3_OK)
 907                 kmem_free(resp->resok.data, MAXPATHLEN + 1);
 908 }
 909 
 910 /*
 911  * Server routine to handle read
 912  * May handle RDMA data as well as mblks
 913  */
 914 /* ARGSUSED */
 915 void
 916 rfs3_read(READ3args *args, READ3res *resp, struct exportinfo *exi,
 917     struct svc_req *req, cred_t *cr, bool_t ro)
 918 {
 919         int error;
 920         vnode_t *vp;
 921         struct vattr *vap;
 922         struct vattr va;
 923         struct iovec iov, *iovp = NULL;
 924         int iovcnt;
 925         struct uio uio;
 926         u_offset_t offset;
 927         mblk_t *mp = NULL;
 928         int in_crit = 0;
 929         int need_rwunlock = 0;
 930         caller_context_t ct;
 931         int rdma_used = 0;
 932         int loaned_buffers;
 933         struct uio *uiop;
 934 
 935         vap = NULL;
 936 
 937         vp = nfs3_fhtovp(&args->file, exi);
 938 
 939         DTRACE_NFSV3_4(op__read__start, struct svc_req *, req,
 940             cred_t *, cr, vnode_t *, vp, READ3args *, args);
 941 
 942         if (vp == NULL) {
 943                 error = ESTALE;
 944                 goto out;
 945         }
 946 
 947         if (args->wlist) {
 948                 if (args->count > clist_len(args->wlist)) {
 949                         error = EINVAL;
 950                         goto out;
 951                 }
 952                 rdma_used = 1;
 953         }
 954 
 955         /* use loaned buffers for TCP */
 956         loaned_buffers = (nfs_loaned_buffers && !rdma_used) ? 1 : 0;
 957 
 958         if (is_system_labeled()) {
 959                 bslabel_t *clabel = req->rq_label;
 960 
 961                 ASSERT(clabel != NULL);
 962                 DTRACE_PROBE2(tx__rfs3__log__info__opread__clabel, char *,
 963                     "got client label from request(1)", struct svc_req *, req);
 964 
 965                 if (!blequal(&l_admin_low->tsl_label, clabel)) {
 966                         if (!do_rfs_label_check(clabel, vp, DOMINANCE_CHECK,
 967                             exi)) {
 968                                 resp->status = NFS3ERR_ACCES;
 969                                 goto out1;
 970                         }
 971                 }
 972         }
 973 
 974         ct.cc_sysid = 0;
 975         ct.cc_pid = 0;
 976         ct.cc_caller_id = nfs3_srv_caller_id;
 977         ct.cc_flags = CC_DONTBLOCK;
 978 
 979         /*
 980          * Enter the critical region before calling VOP_RWLOCK
 981          * to avoid a deadlock with write requests.
 982          */
 983         if (nbl_need_check(vp)) {
 984                 nbl_start_crit(vp, RW_READER);
 985                 in_crit = 1;
 986                 if (nbl_conflict(vp, NBL_READ, args->offset, args->count, 0,
 987                     NULL)) {
 988                         error = EACCES;
 989                         goto out;
 990                 }
 991         }
 992 
 993         error = VOP_RWLOCK(vp, V_WRITELOCK_FALSE, &ct);
 994 
 995         /* check if a monitor detected a delegation conflict */
 996         if (error == EAGAIN && (ct.cc_flags & CC_WOULDBLOCK)) {
 997                 resp->status = NFS3ERR_JUKEBOX;
 998                 goto out1;
 999         }
1000 
1001         need_rwunlock = 1;
1002 
1003         va.va_mask = AT_ALL;
1004         error = VOP_GETATTR(vp, &va, 0, cr, &ct);
1005 
1006         /*
1007          * If we can't get the attributes, then we can't do the
1008          * right access checking.  So, we'll fail the request.
1009          */
1010         if (error)
1011                 goto out;
1012 
1013         vap = &va;
1014 
1015         if (vp->v_type != VREG) {
1016                 resp->status = NFS3ERR_INVAL;
1017                 goto out1;
1018         }
1019 
1020         if (crgetuid(cr) != va.va_uid) {
1021                 error = VOP_ACCESS(vp, VREAD, 0, cr, &ct);
1022                 if (error) {
1023                         if (curthread->t_flag & T_WOULDBLOCK)
1024                                 goto out;
1025                         error = VOP_ACCESS(vp, VEXEC, 0, cr, &ct);
1026                         if (error)
1027                                 goto out;
1028                 }
1029         }
1030 
1031         if (MANDLOCK(vp, va.va_mode)) {
1032                 resp->status = NFS3ERR_ACCES;
1033                 goto out1;
1034         }
1035 
1036         offset = args->offset;
1037         if (offset >= va.va_size) {
1038                 VOP_RWUNLOCK(vp, V_WRITELOCK_FALSE, &ct);
1039                 if (in_crit)
1040                         nbl_end_crit(vp);
1041                 resp->status = NFS3_OK;
1042                 vattr_to_post_op_attr(vap, &resp->resok.file_attributes);
1043                 resp->resok.count = 0;
1044                 resp->resok.eof = TRUE;
1045                 resp->resok.data.data_len = 0;
1046                 resp->resok.data.data_val = NULL;
1047                 resp->resok.data.mp = NULL;
1048                 /* RDMA */
1049                 resp->resok.wlist = args->wlist;
1050                 resp->resok.wlist_len = resp->resok.count;
1051                 if (resp->resok.wlist)
1052                         clist_zero_len(resp->resok.wlist);
1053                 goto done;
1054         }
1055 
1056         if (args->count == 0) {
1057                 VOP_RWUNLOCK(vp, V_WRITELOCK_FALSE, &ct);
1058                 if (in_crit)
1059                         nbl_end_crit(vp);
1060                 resp->status = NFS3_OK;
1061                 vattr_to_post_op_attr(vap, &resp->resok.file_attributes);
1062                 resp->resok.count = 0;
1063                 resp->resok.eof = FALSE;
1064                 resp->resok.data.data_len = 0;
1065                 resp->resok.data.data_val = NULL;
1066                 resp->resok.data.mp = NULL;
1067                 /* RDMA */
1068                 resp->resok.wlist = args->wlist;
1069                 resp->resok.wlist_len = resp->resok.count;
1070                 if (resp->resok.wlist)
1071                         clist_zero_len(resp->resok.wlist);
1072                 goto done;
1073         }
1074 
1075         /*
1076          * do not allocate memory more the max. allowed
1077          * transfer size
1078          */
1079         if (args->count > rfs3_tsize(req))
1080                 args->count = rfs3_tsize(req);
1081 
1082         if (loaned_buffers) {
1083                 uiop = (uio_t *)rfs_setup_xuio(vp);
1084                 ASSERT(uiop != NULL);
1085                 uiop->uio_segflg = UIO_SYSSPACE;
1086                 uiop->uio_loffset = args->offset;
1087                 uiop->uio_resid = args->count;
1088 
1089                 /* Jump to do the read if successful */
1090                 if (VOP_REQZCBUF(vp, UIO_READ, (xuio_t *)uiop, cr, &ct) == 0) {
1091                         /*
1092                          * Need to hold the vnode until after VOP_RETZCBUF()
1093                          * is called.
1094                          */
1095                         VN_HOLD(vp);
1096                         goto doio_read;
1097                 }
1098 
1099                 DTRACE_PROBE2(nfss__i__reqzcbuf_failed, int,
1100                     uiop->uio_loffset, int, uiop->uio_resid);
1101 
1102                 uiop->uio_extflg = 0;
1103                 /* failure to setup for zero copy */
1104                 rfs_free_xuio((void *)uiop);
1105                 loaned_buffers = 0;
1106         }
1107 
1108         /*
1109          * If returning data via RDMA Write, then grab the chunk list.
1110          * If we aren't returning READ data w/RDMA_WRITE, then grab
1111          * a mblk.
1112          */
1113         if (rdma_used) {
1114                 (void) rdma_get_wchunk(req, &iov, args->wlist);
1115                 uio.uio_iov = &iov;
1116                 uio.uio_iovcnt = 1;
1117         } else {
1118                 /*
1119                  * mp will contain the data to be sent out in the read reply.
1120                  * For UDP, this will be freed after the reply has been sent
1121                  * out by the driver.  For TCP, it will be freed after the last
1122                  * segment associated with the reply has been ACKed by the
1123                  * client.
1124                  */
1125                 mp = rfs_read_alloc(args->count, &iovp, &iovcnt);
1126                 uio.uio_iov = iovp;
1127                 uio.uio_iovcnt = iovcnt;
1128         }
1129 
1130         uio.uio_segflg = UIO_SYSSPACE;
1131         uio.uio_extflg = UIO_COPY_CACHED;
1132         uio.uio_loffset = args->offset;
1133         uio.uio_resid = args->count;
1134         uiop = &uio;
1135 
1136 doio_read:
1137         error = VOP_READ(vp, uiop, 0, cr, &ct);
1138 
1139         if (error) {
1140                 if (mp)
1141                         freemsg(mp);
1142                 /* check if a monitor detected a delegation conflict */
1143                 if (error == EAGAIN && (ct.cc_flags & CC_WOULDBLOCK)) {
1144                         resp->status = NFS3ERR_JUKEBOX;
1145                         goto out1;
1146                 }
1147                 goto out;
1148         }
1149 
1150         /* make mblk using zc buffers */
1151         if (loaned_buffers) {
1152                 mp = uio_to_mblk(uiop);
1153                 ASSERT(mp != NULL);
1154         }
1155 
1156         va.va_mask = AT_ALL;
1157         error = VOP_GETATTR(vp, &va, 0, cr, &ct);
1158 
1159         if (error)
1160                 vap = NULL;
1161         else
1162                 vap = &va;
1163 
1164         VOP_RWUNLOCK(vp, V_WRITELOCK_FALSE, &ct);
1165 
1166         if (in_crit)
1167                 nbl_end_crit(vp);
1168 
1169         resp->status = NFS3_OK;
1170         vattr_to_post_op_attr(vap, &resp->resok.file_attributes);
1171         resp->resok.count = args->count - uiop->uio_resid;
1172         if (!error && offset + resp->resok.count == va.va_size)
1173                 resp->resok.eof = TRUE;
1174         else
1175                 resp->resok.eof = FALSE;
1176         resp->resok.data.data_len = resp->resok.count;
1177 
1178         if (mp)
1179                 rfs_rndup_mblks(mp, resp->resok.count, loaned_buffers);
1180 
1181         resp->resok.data.mp = mp;
1182         resp->resok.size = (uint_t)args->count;
1183 
1184         if (rdma_used) {
1185                 resp->resok.data.data_val = (caddr_t)iov.iov_base;
1186                 if (!rdma_setup_read_data3(args, &(resp->resok))) {
1187                         resp->status = NFS3ERR_INVAL;
1188                 }
1189         } else {
1190                 resp->resok.data.data_val = (caddr_t)mp->b_datap->db_base;
1191                 (resp->resok).wlist = NULL;
1192         }
1193 
1194 done:
1195         DTRACE_NFSV3_4(op__read__done, struct svc_req *, req,
1196             cred_t *, cr, vnode_t *, vp, READ3res *, resp);
1197 
1198         VN_RELE(vp);
1199 
1200         if (iovp != NULL)
1201                 kmem_free(iovp, iovcnt * sizeof (struct iovec));
1202 
1203         return;
1204 
1205 out:
1206         if (curthread->t_flag & T_WOULDBLOCK) {
1207                 curthread->t_flag &= ~T_WOULDBLOCK;
1208                 resp->status = NFS3ERR_JUKEBOX;
1209         } else
1210                 resp->status = puterrno3(error);
1211 out1:
1212         DTRACE_NFSV3_4(op__read__done, struct svc_req *, req,
1213             cred_t *, cr, vnode_t *, vp, READ3res *, resp);
1214 
1215         if (vp != NULL) {
1216                 if (need_rwunlock)
1217                         VOP_RWUNLOCK(vp, V_WRITELOCK_FALSE, &ct);
1218                 if (in_crit)
1219                         nbl_end_crit(vp);
1220                 VN_RELE(vp);
1221         }
1222         vattr_to_post_op_attr(vap, &resp->resfail.file_attributes);
1223 
1224         if (iovp != NULL)
1225                 kmem_free(iovp, iovcnt * sizeof (struct iovec));
1226 }
1227 
1228 void
1229 rfs3_read_free(READ3res *resp)
1230 {
1231         mblk_t *mp;
1232 
1233         if (resp->status == NFS3_OK) {
1234                 mp = resp->resok.data.mp;
1235                 if (mp != NULL)
1236                         freemsg(mp);
1237         }
1238 }
1239 
1240 void *
1241 rfs3_read_getfh(READ3args *args)
1242 {
1243 
1244         return (&args->file);
1245 }
1246 
1247 #define MAX_IOVECS      12
1248 
1249 #ifdef DEBUG
1250 static int rfs3_write_hits = 0;
1251 static int rfs3_write_misses = 0;
1252 #endif
1253 
1254 void
1255 rfs3_write(WRITE3args *args, WRITE3res *resp, struct exportinfo *exi,
1256     struct svc_req *req, cred_t *cr, bool_t ro)
1257 {
1258         int error;
1259         vnode_t *vp;
1260         struct vattr *bvap = NULL;
1261         struct vattr bva;
1262         struct vattr *avap = NULL;
1263         struct vattr ava;
1264         u_offset_t rlimit;
1265         struct uio uio;
1266         struct iovec iov[MAX_IOVECS];
1267         mblk_t *m;
1268         struct iovec *iovp;
1269         int iovcnt;
1270         int ioflag;
1271         cred_t *savecred;
1272         int in_crit = 0;
1273         int rwlock_ret = -1;
1274         caller_context_t ct;
1275 
1276         vp = nfs3_fhtovp(&args->file, exi);
1277 
1278         DTRACE_NFSV3_4(op__write__start, struct svc_req *, req,
1279             cred_t *, cr, vnode_t *, vp, WRITE3args *, args);
1280 
1281         if (vp == NULL) {
1282                 error = ESTALE;
1283                 goto err;
1284         }
1285 
1286         if (is_system_labeled()) {
1287                 bslabel_t *clabel = req->rq_label;
1288 
1289                 ASSERT(clabel != NULL);
1290                 DTRACE_PROBE2(tx__rfs3__log__info__opwrite__clabel, char *,
1291                     "got client label from request(1)", struct svc_req *, req);
1292 
1293                 if (!blequal(&l_admin_low->tsl_label, clabel)) {
1294                         if (!do_rfs_label_check(clabel, vp, EQUALITY_CHECK,
1295                             exi)) {
1296                                 resp->status = NFS3ERR_ACCES;
1297                                 goto err1;
1298                         }
1299                 }
1300         }
1301 
1302         ct.cc_sysid = 0;
1303         ct.cc_pid = 0;
1304         ct.cc_caller_id = nfs3_srv_caller_id;
1305         ct.cc_flags = CC_DONTBLOCK;
1306 
1307         /*
1308          * We have to enter the critical region before calling VOP_RWLOCK
1309          * to avoid a deadlock with ufs.
1310          */
1311         if (nbl_need_check(vp)) {
1312                 nbl_start_crit(vp, RW_READER);
1313                 in_crit = 1;
1314                 if (nbl_conflict(vp, NBL_WRITE, args->offset, args->count, 0,
1315                     NULL)) {
1316                         error = EACCES;
1317                         goto err;
1318                 }
1319         }
1320 
1321         rwlock_ret = VOP_RWLOCK(vp, V_WRITELOCK_TRUE, &ct);
1322 
1323         /* check if a monitor detected a delegation conflict */
1324         if (rwlock_ret == EAGAIN && (ct.cc_flags & CC_WOULDBLOCK)) {
1325                 resp->status = NFS3ERR_JUKEBOX;
1326                 rwlock_ret = -1;
1327                 goto err1;
1328         }
1329 
1330 
1331         bva.va_mask = AT_ALL;
1332         error = VOP_GETATTR(vp, &bva, 0, cr, &ct);
1333 
1334         /*
1335          * If we can't get the attributes, then we can't do the
1336          * right access checking.  So, we'll fail the request.
1337          */
1338         if (error)
1339                 goto err;
1340 
1341         bvap = &bva;
1342         avap = bvap;
1343 
1344         if (args->count != args->data.data_len) {
1345                 resp->status = NFS3ERR_INVAL;
1346                 goto err1;
1347         }
1348 
1349         if (rdonly(ro, vp)) {
1350                 resp->status = NFS3ERR_ROFS;
1351                 goto err1;
1352         }
1353 
1354         if (vp->v_type != VREG) {
1355                 resp->status = NFS3ERR_INVAL;
1356                 goto err1;
1357         }
1358 
1359         if (crgetuid(cr) != bva.va_uid &&
1360             (error = VOP_ACCESS(vp, VWRITE, 0, cr, &ct)))
1361                 goto err;
1362 
1363         if (MANDLOCK(vp, bva.va_mode)) {
1364                 resp->status = NFS3ERR_ACCES;
1365                 goto err1;
1366         }
1367 
1368         if (args->count == 0) {
1369                 resp->status = NFS3_OK;
1370                 vattr_to_wcc_data(bvap, avap, &resp->resok.file_wcc);
1371                 resp->resok.count = 0;
1372                 resp->resok.committed = args->stable;
1373                 resp->resok.verf = write3verf;
1374                 goto out;
1375         }
1376 
1377         if (args->mblk != NULL) {
1378                 iovcnt = 0;
1379                 for (m = args->mblk; m != NULL; m = m->b_cont)
1380                         iovcnt++;
1381                 if (iovcnt <= MAX_IOVECS) {
1382 #ifdef DEBUG
1383                         rfs3_write_hits++;
1384 #endif
1385                         iovp = iov;
1386                 } else {
1387 #ifdef DEBUG
1388                         rfs3_write_misses++;
1389 #endif
1390                         iovp = kmem_alloc(sizeof (*iovp) * iovcnt, KM_SLEEP);
1391                 }
1392                 mblk_to_iov(args->mblk, iovcnt, iovp);
1393 
1394         } else if (args->rlist != NULL) {
1395                 iovcnt = 1;
1396                 iovp = iov;
1397                 iovp->iov_base = (char *)((args->rlist)->u.c_daddr3);
1398                 iovp->iov_len = args->count;
1399         } else {
1400                 iovcnt = 1;
1401                 iovp = iov;
1402                 iovp->iov_base = args->data.data_val;
1403                 iovp->iov_len = args->count;
1404         }
1405 
1406         uio.uio_iov = iovp;
1407         uio.uio_iovcnt = iovcnt;
1408 
1409         uio.uio_segflg = UIO_SYSSPACE;
1410         uio.uio_extflg = UIO_COPY_DEFAULT;
1411         uio.uio_loffset = args->offset;
1412         uio.uio_resid = args->count;
1413         uio.uio_llimit = curproc->p_fsz_ctl;
1414         rlimit = uio.uio_llimit - args->offset;
1415         if (rlimit < (u_offset_t)uio.uio_resid)
1416                 uio.uio_resid = (int)rlimit;
1417 
1418         if (args->stable == UNSTABLE)
1419                 ioflag = 0;
1420         else if (args->stable == FILE_SYNC)
1421                 ioflag = FSYNC;
1422         else if (args->stable == DATA_SYNC)
1423                 ioflag = FDSYNC;
1424         else {
1425                 if (iovp != iov)
1426                         kmem_free(iovp, sizeof (*iovp) * iovcnt);
1427                 resp->status = NFS3ERR_INVAL;
1428                 goto err1;
1429         }
1430 
1431         /*
1432          * We're changing creds because VM may fault and we need
1433          * the cred of the current thread to be used if quota
1434          * checking is enabled.
1435          */
1436         savecred = curthread->t_cred;
1437         curthread->t_cred = cr;
1438         error = VOP_WRITE(vp, &uio, ioflag, cr, &ct);
1439         curthread->t_cred = savecred;
1440 
1441         if (iovp != iov)
1442                 kmem_free(iovp, sizeof (*iovp) * iovcnt);
1443 
1444         /* check if a monitor detected a delegation conflict */
1445         if (error == EAGAIN && (ct.cc_flags & CC_WOULDBLOCK)) {
1446                 resp->status = NFS3ERR_JUKEBOX;
1447                 goto err1;
1448         }
1449 
1450         ava.va_mask = AT_ALL;
1451         avap = VOP_GETATTR(vp, &ava, 0, cr, &ct) ? NULL : &ava;
1452 
1453         if (error)
1454                 goto err;
1455 
1456         /*
1457          * If we were unable to get the V_WRITELOCK_TRUE, then we
1458          * may not have accurate after attrs, so check if
1459          * we have both attributes, they have a non-zero va_seq, and
1460          * va_seq has changed by exactly one,
1461          * if not, turn off the before attr.
1462          */
1463         if (rwlock_ret != V_WRITELOCK_TRUE) {
1464                 if (bvap == NULL || avap == NULL ||
1465                     bvap->va_seq == 0 || avap->va_seq == 0 ||
1466                     avap->va_seq != (bvap->va_seq + 1)) {
1467                         bvap = NULL;
1468                 }
1469         }
1470 
1471         resp->status = NFS3_OK;
1472         vattr_to_wcc_data(bvap, avap, &resp->resok.file_wcc);
1473         resp->resok.count = args->count - uio.uio_resid;
1474         resp->resok.committed = args->stable;
1475         resp->resok.verf = write3verf;
1476         goto out;
1477 
1478 err:
1479         if (curthread->t_flag & T_WOULDBLOCK) {
1480                 curthread->t_flag &= ~T_WOULDBLOCK;
1481                 resp->status = NFS3ERR_JUKEBOX;
1482         } else
1483                 resp->status = puterrno3(error);
1484 err1:
1485         vattr_to_wcc_data(bvap, avap, &resp->resfail.file_wcc);
1486 out:
1487         DTRACE_NFSV3_4(op__write__done, struct svc_req *, req,
1488             cred_t *, cr, vnode_t *, vp, WRITE3res *, resp);
1489 
1490         if (vp != NULL) {
1491                 if (rwlock_ret != -1)
1492                         VOP_RWUNLOCK(vp, V_WRITELOCK_TRUE, &ct);
1493                 if (in_crit)
1494                         nbl_end_crit(vp);
1495                 VN_RELE(vp);
1496         }
1497 }
1498 
1499 void *
1500 rfs3_write_getfh(WRITE3args *args)
1501 {
1502 
1503         return (&args->file);
1504 }
1505 
1506 void
1507 rfs3_create(CREATE3args *args, CREATE3res *resp, struct exportinfo *exi,
1508     struct svc_req *req, cred_t *cr, bool_t ro)
1509 {
1510         int error;
1511         int in_crit = 0;
1512         vnode_t *vp;
1513         vnode_t *tvp = NULL;
1514         vnode_t *dvp;
1515         struct vattr *vap;
1516         struct vattr va;
1517         struct vattr *dbvap;
1518         struct vattr dbva;
1519         struct vattr *davap;
1520         struct vattr dava;
1521         enum vcexcl excl;
1522         nfstime3 *mtime;
1523         len_t reqsize;
1524         bool_t trunc;
1525         struct sockaddr *ca;
1526         char *name = NULL;
1527 
1528         dbvap = NULL;
1529         davap = NULL;
1530 
1531         dvp = nfs3_fhtovp(&args->where.dir, exi);
1532 
1533         DTRACE_NFSV3_4(op__create__start, struct svc_req *, req,
1534             cred_t *, cr, vnode_t *, dvp, CREATE3args *, args);
1535 
1536         if (dvp == NULL) {
1537                 error = ESTALE;
1538                 goto out;
1539         }
1540 
1541         dbva.va_mask = AT_ALL;
1542         dbvap = VOP_GETATTR(dvp, &dbva, 0, cr, NULL) ? NULL : &dbva;
1543         davap = dbvap;
1544 
1545         if (args->where.name == nfs3nametoolong) {
1546                 resp->status = NFS3ERR_NAMETOOLONG;
1547                 goto out1;
1548         }
1549 
1550         if (args->where.name == NULL || *(args->where.name) == '\0') {
1551                 resp->status = NFS3ERR_ACCES;
1552                 goto out1;
1553         }
1554 
1555         if (rdonly(ro, dvp)) {
1556                 resp->status = NFS3ERR_ROFS;
1557                 goto out1;
1558         }
1559 
1560         if (is_system_labeled()) {
1561                 bslabel_t *clabel = req->rq_label;
1562 
1563                 ASSERT(clabel != NULL);
1564                 DTRACE_PROBE2(tx__rfs3__log__info__opcreate__clabel, char *,
1565                     "got client label from request(1)", struct svc_req *, req);
1566 
1567                 if (!blequal(&l_admin_low->tsl_label, clabel)) {
1568                         if (!do_rfs_label_check(clabel, dvp, EQUALITY_CHECK,
1569                             exi)) {
1570                                 resp->status = NFS3ERR_ACCES;
1571                                 goto out1;
1572                         }
1573                 }
1574         }
1575 
1576         ca = (struct sockaddr *)svc_getrpccaller(req->rq_xprt)->buf;
1577         name = nfscmd_convname(ca, exi, args->where.name,
1578             NFSCMD_CONV_INBOUND, MAXPATHLEN + 1);
1579 
1580         if (name == NULL) {
1581                 /* This is really a Solaris EILSEQ */
1582                 resp->status = NFS3ERR_INVAL;
1583                 goto out1;
1584         }
1585 
1586         if (args->how.mode == EXCLUSIVE) {
1587                 va.va_mask = AT_TYPE | AT_MODE | AT_MTIME;
1588                 va.va_type = VREG;
1589                 va.va_mode = (mode_t)0;
1590                 /*
1591                  * Ensure no time overflows and that types match
1592                  */
1593                 mtime = (nfstime3 *)&args->how.createhow3_u.verf;
1594                 va.va_mtime.tv_sec = mtime->seconds % INT32_MAX;
1595                 va.va_mtime.tv_nsec = mtime->nseconds;
1596                 excl = EXCL;
1597         } else {
1598                 error = sattr3_to_vattr(&args->how.createhow3_u.obj_attributes,
1599                     &va);
1600                 if (error)
1601                         goto out;
1602                 va.va_mask |= AT_TYPE;
1603                 va.va_type = VREG;
1604                 if (args->how.mode == GUARDED)
1605                         excl = EXCL;
1606                 else {
1607                         excl = NONEXCL;
1608 
1609                         /*
1610                          * During creation of file in non-exclusive mode
1611                          * if size of file is being set then make sure
1612                          * that if the file already exists that no conflicting
1613                          * non-blocking mandatory locks exists in the region
1614                          * being modified. If there are conflicting locks fail
1615                          * the operation with EACCES.
1616                          */
1617                         if (va.va_mask & AT_SIZE) {
1618                                 struct vattr tva;
1619 
1620                                 /*
1621                                  * Does file already exist?
1622                                  */
1623                                 error = VOP_LOOKUP(dvp, name, &tvp,
1624                                     NULL, 0, NULL, cr, NULL, NULL, NULL);
1625 
1626                                 /*
1627                                  * Check to see if the file has been delegated
1628                                  * to a v4 client.  If so, then begin recall of
1629                                  * the delegation and return JUKEBOX to allow
1630                                  * the client to retrasmit its request.
1631                                  */
1632 
1633                                 trunc = va.va_size == 0;
1634                                 if (!error &&
1635                                     rfs4_check_delegated(FWRITE, tvp, trunc)) {
1636                                         resp->status = NFS3ERR_JUKEBOX;
1637                                         goto out1;
1638                                 }
1639 
1640                                 /*
1641                                  * Check for NBMAND lock conflicts
1642                                  */
1643                                 if (!error && nbl_need_check(tvp)) {
1644                                         u_offset_t offset;
1645                                         ssize_t len;
1646 
1647                                         nbl_start_crit(tvp, RW_READER);
1648                                         in_crit = 1;
1649 
1650                                         tva.va_mask = AT_SIZE;
1651                                         error = VOP_GETATTR(tvp, &tva, 0, cr,
1652                                             NULL);
1653                                         /*
1654                                          * Can't check for conflicts, so return
1655                                          * error.
1656                                          */
1657                                         if (error)
1658                                                 goto out;
1659 
1660                                         offset = tva.va_size < va.va_size ?
1661                                             tva.va_size : va.va_size;
1662                                         len = tva.va_size < va.va_size ?
1663                                             va.va_size - tva.va_size :
1664                                             tva.va_size - va.va_size;
1665                                         if (nbl_conflict(tvp, NBL_WRITE,
1666                                             offset, len, 0, NULL)) {
1667                                                 error = EACCES;
1668                                                 goto out;
1669                                         }
1670                                 } else if (tvp) {
1671                                         VN_RELE(tvp);
1672                                         tvp = NULL;
1673                                 }
1674                         }
1675                 }
1676                 if (va.va_mask & AT_SIZE)
1677                         reqsize = va.va_size;
1678         }
1679 
1680         /*
1681          * Must specify the mode.
1682          */
1683         if (!(va.va_mask & AT_MODE)) {
1684                 resp->status = NFS3ERR_INVAL;
1685                 goto out1;
1686         }
1687 
1688         /*
1689          * If the filesystem is exported with nosuid, then mask off
1690          * the setuid and setgid bits.
1691          */
1692         if (va.va_type == VREG && (exi->exi_export.ex_flags & EX_NOSUID))
1693                 va.va_mode &= ~(VSUID | VSGID);
1694 
1695 tryagain:
1696         /*
1697          * The file open mode used is VWRITE.  If the client needs
1698          * some other semantic, then it should do the access checking
1699          * itself.  It would have been nice to have the file open mode
1700          * passed as part of the arguments.
1701          */
1702         error = VOP_CREATE(dvp, name, &va, excl, VWRITE,
1703             &vp, cr, 0, NULL, NULL);
1704 
1705         dava.va_mask = AT_ALL;
1706         davap = VOP_GETATTR(dvp, &dava, 0, cr, NULL) ? NULL : &dava;
1707 
1708         if (error) {
1709                 /*
1710                  * If we got something other than file already exists
1711                  * then just return this error.  Otherwise, we got
1712                  * EEXIST.  If we were doing a GUARDED create, then
1713                  * just return this error.  Otherwise, we need to
1714                  * make sure that this wasn't a duplicate of an
1715                  * exclusive create request.
1716                  *
1717                  * The assumption is made that a non-exclusive create
1718                  * request will never return EEXIST.
1719                  */
1720                 if (error != EEXIST || args->how.mode == GUARDED)
1721                         goto out;
1722                 /*
1723                  * Lookup the file so that we can get a vnode for it.
1724                  */
1725                 error = VOP_LOOKUP(dvp, name, &vp, NULL, 0,
1726                     NULL, cr, NULL, NULL, NULL);
1727                 if (error) {
1728                         /*
1729                          * We couldn't find the file that we thought that
1730                          * we just created.  So, we'll just try creating
1731                          * it again.
1732                          */
1733                         if (error == ENOENT)
1734                                 goto tryagain;
1735                         goto out;
1736                 }
1737 
1738                 /*
1739                  * If the file is delegated to a v4 client, go ahead
1740                  * and initiate recall, this create is a hint that a
1741                  * conflicting v3 open has occurred.
1742                  */
1743 
1744                 if (rfs4_check_delegated(FWRITE, vp, FALSE)) {
1745                         VN_RELE(vp);
1746                         resp->status = NFS3ERR_JUKEBOX;
1747                         goto out1;
1748                 }
1749 
1750                 va.va_mask = AT_ALL;
1751                 vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
1752 
1753                 mtime = (nfstime3 *)&args->how.createhow3_u.verf;
1754                 /* % with INT32_MAX to prevent overflows */
1755                 if (args->how.mode == EXCLUSIVE && (vap == NULL ||
1756                     vap->va_mtime.tv_sec !=
1757                     (mtime->seconds % INT32_MAX) ||
1758                     vap->va_mtime.tv_nsec != mtime->nseconds)) {
1759                         VN_RELE(vp);
1760                         error = EEXIST;
1761                         goto out;
1762                 }
1763         } else {
1764 
1765                 if ((args->how.mode == UNCHECKED ||
1766                     args->how.mode == GUARDED) &&
1767                     args->how.createhow3_u.obj_attributes.size.set_it &&
1768                     va.va_size == 0)
1769                         trunc = TRUE;
1770                 else
1771                         trunc = FALSE;
1772 
1773                 if (rfs4_check_delegated(FWRITE, vp, trunc)) {
1774                         VN_RELE(vp);
1775                         resp->status = NFS3ERR_JUKEBOX;
1776                         goto out1;
1777                 }
1778 
1779                 va.va_mask = AT_ALL;
1780                 vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
1781 
1782                 /*
1783                  * We need to check to make sure that the file got
1784                  * created to the indicated size.  If not, we do a
1785                  * setattr to try to change the size, but we don't
1786                  * try too hard.  This shouldn't a problem as most
1787                  * clients will only specifiy a size of zero which
1788                  * local file systems handle.  However, even if
1789                  * the client does specify a non-zero size, it can
1790                  * still recover by checking the size of the file
1791                  * after it has created it and then issue a setattr
1792                  * request of its own to set the size of the file.
1793                  */
1794                 if (vap != NULL &&
1795                     (args->how.mode == UNCHECKED ||
1796                     args->how.mode == GUARDED) &&
1797                     args->how.createhow3_u.obj_attributes.size.set_it &&
1798                     vap->va_size != reqsize) {
1799                         va.va_mask = AT_SIZE;
1800                         va.va_size = reqsize;
1801                         (void) VOP_SETATTR(vp, &va, 0, cr, NULL);
1802                         va.va_mask = AT_ALL;
1803                         vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
1804                 }
1805         }
1806 
1807         if (name != args->where.name)
1808                 kmem_free(name, MAXPATHLEN + 1);
1809 
1810         error = makefh3(&resp->resok.obj.handle, vp, exi);
1811         if (error)
1812                 resp->resok.obj.handle_follows = FALSE;
1813         else
1814                 resp->resok.obj.handle_follows = TRUE;
1815 
1816         /*
1817          * Force modified data and metadata out to stable storage.
1818          */
1819         (void) VOP_FSYNC(vp, FNODSYNC, cr, NULL);
1820         (void) VOP_FSYNC(dvp, 0, cr, NULL);
1821 
1822         VN_RELE(vp);
1823         if (tvp != NULL) {
1824                 if (in_crit)
1825                         nbl_end_crit(tvp);
1826                 VN_RELE(tvp);
1827         }
1828 
1829         resp->status = NFS3_OK;
1830         vattr_to_post_op_attr(vap, &resp->resok.obj_attributes);
1831         vattr_to_wcc_data(dbvap, davap, &resp->resok.dir_wcc);
1832 
1833         DTRACE_NFSV3_4(op__create__done, struct svc_req *, req,
1834             cred_t *, cr, vnode_t *, dvp, CREATE3res *, resp);
1835 
1836         VN_RELE(dvp);
1837         return;
1838 
1839 out:
1840         if (curthread->t_flag & T_WOULDBLOCK) {
1841                 curthread->t_flag &= ~T_WOULDBLOCK;
1842                 resp->status = NFS3ERR_JUKEBOX;
1843         } else
1844                 resp->status = puterrno3(error);
1845 out1:
1846         DTRACE_NFSV3_4(op__create__done, struct svc_req *, req,
1847             cred_t *, cr, vnode_t *, dvp, CREATE3res *, resp);
1848 
1849         if (name != NULL && name != args->where.name)
1850                 kmem_free(name, MAXPATHLEN + 1);
1851 
1852         if (tvp != NULL) {
1853                 if (in_crit)
1854                         nbl_end_crit(tvp);
1855                 VN_RELE(tvp);
1856         }
1857         if (dvp != NULL)
1858                 VN_RELE(dvp);
1859         vattr_to_wcc_data(dbvap, davap, &resp->resfail.dir_wcc);
1860 }
1861 
1862 void *
1863 rfs3_create_getfh(CREATE3args *args)
1864 {
1865 
1866         return (&args->where.dir);
1867 }
1868 
1869 void
1870 rfs3_mkdir(MKDIR3args *args, MKDIR3res *resp, struct exportinfo *exi,
1871     struct svc_req *req, cred_t *cr, bool_t ro)
1872 {
1873         int error;
1874         vnode_t *vp = NULL;
1875         vnode_t *dvp;
1876         struct vattr *vap;
1877         struct vattr va;
1878         struct vattr *dbvap;
1879         struct vattr dbva;
1880         struct vattr *davap;
1881         struct vattr dava;
1882         struct sockaddr *ca;
1883         char *name = NULL;
1884 
1885         dbvap = NULL;
1886         davap = NULL;
1887 
1888         dvp = nfs3_fhtovp(&args->where.dir, exi);
1889 
1890         DTRACE_NFSV3_4(op__mkdir__start, struct svc_req *, req,
1891             cred_t *, cr, vnode_t *, dvp, MKDIR3args *, args);
1892 
1893         if (dvp == NULL) {
1894                 error = ESTALE;
1895                 goto out;
1896         }
1897 
1898         dbva.va_mask = AT_ALL;
1899         dbvap = VOP_GETATTR(dvp, &dbva, 0, cr, NULL) ? NULL : &dbva;
1900         davap = dbvap;
1901 
1902         if (args->where.name == nfs3nametoolong) {
1903                 resp->status = NFS3ERR_NAMETOOLONG;
1904                 goto out1;
1905         }
1906 
1907         if (args->where.name == NULL || *(args->where.name) == '\0') {
1908                 resp->status = NFS3ERR_ACCES;
1909                 goto out1;
1910         }
1911 
1912         if (rdonly(ro, dvp)) {
1913                 resp->status = NFS3ERR_ROFS;
1914                 goto out1;
1915         }
1916 
1917         if (is_system_labeled()) {
1918                 bslabel_t *clabel = req->rq_label;
1919 
1920                 ASSERT(clabel != NULL);
1921                 DTRACE_PROBE2(tx__rfs3__log__info__opmkdir__clabel, char *,
1922                     "got client label from request(1)", struct svc_req *, req);
1923 
1924                 if (!blequal(&l_admin_low->tsl_label, clabel)) {
1925                         if (!do_rfs_label_check(clabel, dvp, EQUALITY_CHECK,
1926                             exi)) {
1927                                 resp->status = NFS3ERR_ACCES;
1928                                 goto out1;
1929                         }
1930                 }
1931         }
1932 
1933         error = sattr3_to_vattr(&args->attributes, &va);
1934         if (error)
1935                 goto out;
1936 
1937         if (!(va.va_mask & AT_MODE)) {
1938                 resp->status = NFS3ERR_INVAL;
1939                 goto out1;
1940         }
1941 
1942         ca = (struct sockaddr *)svc_getrpccaller(req->rq_xprt)->buf;
1943         name = nfscmd_convname(ca, exi, args->where.name,
1944             NFSCMD_CONV_INBOUND, MAXPATHLEN + 1);
1945 
1946         if (name == NULL) {
1947                 resp->status = NFS3ERR_INVAL;
1948                 goto out1;
1949         }
1950 
1951         va.va_mask |= AT_TYPE;
1952         va.va_type = VDIR;
1953 
1954         error = VOP_MKDIR(dvp, name, &va, &vp, cr, NULL, 0, NULL);
1955 
1956         if (name != args->where.name)
1957                 kmem_free(name, MAXPATHLEN + 1);
1958 
1959         dava.va_mask = AT_ALL;
1960         davap = VOP_GETATTR(dvp, &dava, 0, cr, NULL) ? NULL : &dava;
1961 
1962         /*
1963          * Force modified data and metadata out to stable storage.
1964          */
1965         (void) VOP_FSYNC(dvp, 0, cr, NULL);
1966 
1967         if (error)
1968                 goto out;
1969 
1970         error = makefh3(&resp->resok.obj.handle, vp, exi);
1971         if (error)
1972                 resp->resok.obj.handle_follows = FALSE;
1973         else
1974                 resp->resok.obj.handle_follows = TRUE;
1975 
1976         va.va_mask = AT_ALL;
1977         vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
1978 
1979         /*
1980          * Force modified data and metadata out to stable storage.
1981          */
1982         (void) VOP_FSYNC(vp, 0, cr, NULL);
1983 
1984         VN_RELE(vp);
1985 
1986         resp->status = NFS3_OK;
1987         vattr_to_post_op_attr(vap, &resp->resok.obj_attributes);
1988         vattr_to_wcc_data(dbvap, davap, &resp->resok.dir_wcc);
1989 
1990         DTRACE_NFSV3_4(op__mkdir__done, struct svc_req *, req,
1991             cred_t *, cr, vnode_t *, dvp, MKDIR3res *, resp);
1992         VN_RELE(dvp);
1993 
1994         return;
1995 
1996 out:
1997         if (curthread->t_flag & T_WOULDBLOCK) {
1998                 curthread->t_flag &= ~T_WOULDBLOCK;
1999                 resp->status = NFS3ERR_JUKEBOX;
2000         } else
2001                 resp->status = puterrno3(error);
2002 out1:
2003         DTRACE_NFSV3_4(op__mkdir__done, struct svc_req *, req,
2004             cred_t *, cr, vnode_t *, dvp, MKDIR3res *, resp);
2005         if (dvp != NULL)
2006                 VN_RELE(dvp);
2007         vattr_to_wcc_data(dbvap, davap, &resp->resfail.dir_wcc);
2008 }
2009 
2010 void *
2011 rfs3_mkdir_getfh(MKDIR3args *args)
2012 {
2013 
2014         return (&args->where.dir);
2015 }
2016 
2017 void
2018 rfs3_symlink(SYMLINK3args *args, SYMLINK3res *resp, struct exportinfo *exi,
2019     struct svc_req *req, cred_t *cr, bool_t ro)
2020 {
2021         int error;
2022         vnode_t *vp;
2023         vnode_t *dvp;
2024         struct vattr *vap;
2025         struct vattr va;
2026         struct vattr *dbvap;
2027         struct vattr dbva;
2028         struct vattr *davap;
2029         struct vattr dava;
2030         struct sockaddr *ca;
2031         char *name = NULL;
2032         char *symdata = NULL;
2033 
2034         dbvap = NULL;
2035         davap = NULL;
2036 
2037         dvp = nfs3_fhtovp(&args->where.dir, exi);
2038 
2039         DTRACE_NFSV3_4(op__symlink__start, struct svc_req *, req,
2040             cred_t *, cr, vnode_t *, dvp, SYMLINK3args *, args);
2041 
2042         if (dvp == NULL) {
2043                 error = ESTALE;
2044                 goto err;
2045         }
2046 
2047         dbva.va_mask = AT_ALL;
2048         dbvap = VOP_GETATTR(dvp, &dbva, 0, cr, NULL) ? NULL : &dbva;
2049         davap = dbvap;
2050 
2051         if (args->where.name == nfs3nametoolong) {
2052                 resp->status = NFS3ERR_NAMETOOLONG;
2053                 goto err1;
2054         }
2055 
2056         if (args->where.name == NULL || *(args->where.name) == '\0') {
2057                 resp->status = NFS3ERR_ACCES;
2058                 goto err1;
2059         }
2060 
2061         if (rdonly(ro, dvp)) {
2062                 resp->status = NFS3ERR_ROFS;
2063                 goto err1;
2064         }
2065 
2066         if (is_system_labeled()) {
2067                 bslabel_t *clabel = req->rq_label;
2068 
2069                 ASSERT(clabel != NULL);
2070                 DTRACE_PROBE2(tx__rfs3__log__info__opsymlink__clabel, char *,
2071                     "got client label from request(1)", struct svc_req *, req);
2072 
2073                 if (!blequal(&l_admin_low->tsl_label, clabel)) {
2074                         if (!do_rfs_label_check(clabel, dvp, EQUALITY_CHECK,
2075                             exi)) {
2076                                 resp->status = NFS3ERR_ACCES;
2077                                 goto err1;
2078                         }
2079                 }
2080         }
2081 
2082         error = sattr3_to_vattr(&args->symlink.symlink_attributes, &va);
2083         if (error)
2084                 goto err;
2085 
2086         if (!(va.va_mask & AT_MODE)) {
2087                 resp->status = NFS3ERR_INVAL;
2088                 goto err1;
2089         }
2090 
2091         if (args->symlink.symlink_data == nfs3nametoolong) {
2092                 resp->status = NFS3ERR_NAMETOOLONG;
2093                 goto err1;
2094         }
2095 
2096         ca = (struct sockaddr *)svc_getrpccaller(req->rq_xprt)->buf;
2097         name = nfscmd_convname(ca, exi, args->where.name,
2098             NFSCMD_CONV_INBOUND, MAXPATHLEN + 1);
2099 
2100         if (name == NULL) {
2101                 /* This is really a Solaris EILSEQ */
2102                 resp->status = NFS3ERR_INVAL;
2103                 goto err1;
2104         }
2105 
2106         symdata = nfscmd_convname(ca, exi, args->symlink.symlink_data,
2107             NFSCMD_CONV_INBOUND, MAXPATHLEN + 1);
2108         if (symdata == NULL) {
2109                 /* This is really a Solaris EILSEQ */
2110                 resp->status = NFS3ERR_INVAL;
2111                 goto err1;
2112         }
2113 
2114 
2115         va.va_mask |= AT_TYPE;
2116         va.va_type = VLNK;
2117 
2118         error = VOP_SYMLINK(dvp, name, &va, symdata, cr, NULL, 0);
2119 
2120         dava.va_mask = AT_ALL;
2121         davap = VOP_GETATTR(dvp, &dava, 0, cr, NULL) ? NULL : &dava;
2122 
2123         if (error)
2124                 goto err;
2125 
2126         error = VOP_LOOKUP(dvp, name, &vp, NULL, 0, NULL, cr,
2127             NULL, NULL, NULL);
2128 
2129         /*
2130          * Force modified data and metadata out to stable storage.
2131          */
2132         (void) VOP_FSYNC(dvp, 0, cr, NULL);
2133 
2134 
2135         resp->status = NFS3_OK;
2136         if (error) {
2137                 resp->resok.obj.handle_follows = FALSE;
2138                 vattr_to_post_op_attr(NULL, &resp->resok.obj_attributes);
2139                 vattr_to_wcc_data(dbvap, davap, &resp->resok.dir_wcc);
2140                 goto out;
2141         }
2142 
2143         error = makefh3(&resp->resok.obj.handle, vp, exi);
2144         if (error)
2145                 resp->resok.obj.handle_follows = FALSE;
2146         else
2147                 resp->resok.obj.handle_follows = TRUE;
2148 
2149         va.va_mask = AT_ALL;
2150         vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
2151 
2152         /*
2153          * Force modified data and metadata out to stable storage.
2154          */
2155         (void) VOP_FSYNC(vp, 0, cr, NULL);
2156 
2157         VN_RELE(vp);
2158 
2159         vattr_to_post_op_attr(vap, &resp->resok.obj_attributes);
2160         vattr_to_wcc_data(dbvap, davap, &resp->resok.dir_wcc);
2161         goto out;
2162 
2163 err:
2164         if (curthread->t_flag & T_WOULDBLOCK) {
2165                 curthread->t_flag &= ~T_WOULDBLOCK;
2166                 resp->status = NFS3ERR_JUKEBOX;
2167         } else
2168                 resp->status = puterrno3(error);
2169 err1:
2170         vattr_to_wcc_data(dbvap, davap, &resp->resfail.dir_wcc);
2171 out:
2172         if (name != NULL && name != args->where.name)
2173                 kmem_free(name, MAXPATHLEN + 1);
2174         if (symdata != NULL && symdata != args->symlink.symlink_data)
2175                 kmem_free(symdata, MAXPATHLEN + 1);
2176 
2177         DTRACE_NFSV3_4(op__symlink__done, struct svc_req *, req,
2178             cred_t *, cr, vnode_t *, dvp, SYMLINK3res *, resp);
2179 
2180         if (dvp != NULL)
2181                 VN_RELE(dvp);
2182 }
2183 
2184 void *
2185 rfs3_symlink_getfh(SYMLINK3args *args)
2186 {
2187 
2188         return (&args->where.dir);
2189 }
2190 
2191 void
2192 rfs3_mknod(MKNOD3args *args, MKNOD3res *resp, struct exportinfo *exi,
2193     struct svc_req *req, cred_t *cr, bool_t ro)
2194 {
2195         int error;
2196         vnode_t *vp;
2197         vnode_t *realvp;
2198         vnode_t *dvp;
2199         struct vattr *vap;
2200         struct vattr va;
2201         struct vattr *dbvap;
2202         struct vattr dbva;
2203         struct vattr *davap;
2204         struct vattr dava;
2205         int mode;
2206         enum vcexcl excl;
2207         struct sockaddr *ca;
2208         char *name = NULL;
2209 
2210         dbvap = NULL;
2211         davap = NULL;
2212 
2213         dvp = nfs3_fhtovp(&args->where.dir, exi);
2214 
2215         DTRACE_NFSV3_4(op__mknod__start, struct svc_req *, req,
2216             cred_t *, cr, vnode_t *, dvp, MKNOD3args *, args);
2217 
2218         if (dvp == NULL) {
2219                 error = ESTALE;
2220                 goto out;
2221         }
2222 
2223         dbva.va_mask = AT_ALL;
2224         dbvap = VOP_GETATTR(dvp, &dbva, 0, cr, NULL) ? NULL : &dbva;
2225         davap = dbvap;
2226 
2227         if (args->where.name == nfs3nametoolong) {
2228                 resp->status = NFS3ERR_NAMETOOLONG;
2229                 goto out1;
2230         }
2231 
2232         if (args->where.name == NULL || *(args->where.name) == '\0') {
2233                 resp->status = NFS3ERR_ACCES;
2234                 goto out1;
2235         }
2236 
2237         if (rdonly(ro, dvp)) {
2238                 resp->status = NFS3ERR_ROFS;
2239                 goto out1;
2240         }
2241 
2242         if (is_system_labeled()) {
2243                 bslabel_t *clabel = req->rq_label;
2244 
2245                 ASSERT(clabel != NULL);
2246                 DTRACE_PROBE2(tx__rfs3__log__info__opmknod__clabel, char *,
2247                     "got client label from request(1)", struct svc_req *, req);
2248 
2249                 if (!blequal(&l_admin_low->tsl_label, clabel)) {
2250                         if (!do_rfs_label_check(clabel, dvp, EQUALITY_CHECK,
2251                             exi)) {
2252                                 resp->status = NFS3ERR_ACCES;
2253                                 goto out1;
2254                         }
2255                 }
2256         }
2257 
2258         switch (args->what.type) {
2259         case NF3CHR:
2260         case NF3BLK:
2261                 error = sattr3_to_vattr(
2262                     &args->what.mknoddata3_u.device.dev_attributes, &va);
2263                 if (error)
2264                         goto out;
2265                 if (secpolicy_sys_devices(cr) != 0) {
2266                         resp->status = NFS3ERR_PERM;
2267                         goto out1;
2268                 }
2269                 if (args->what.type == NF3CHR)
2270                         va.va_type = VCHR;
2271                 else
2272                         va.va_type = VBLK;
2273                 va.va_rdev = makedevice(
2274                     args->what.mknoddata3_u.device.spec.specdata1,
2275                     args->what.mknoddata3_u.device.spec.specdata2);
2276                 va.va_mask |= AT_TYPE | AT_RDEV;
2277                 break;
2278         case NF3SOCK:
2279                 error = sattr3_to_vattr(
2280                     &args->what.mknoddata3_u.pipe_attributes, &va);
2281                 if (error)
2282                         goto out;
2283                 va.va_type = VSOCK;
2284                 va.va_mask |= AT_TYPE;
2285                 break;
2286         case NF3FIFO:
2287                 error = sattr3_to_vattr(
2288                     &args->what.mknoddata3_u.pipe_attributes, &va);
2289                 if (error)
2290                         goto out;
2291                 va.va_type = VFIFO;
2292                 va.va_mask |= AT_TYPE;
2293                 break;
2294         default:
2295                 resp->status = NFS3ERR_BADTYPE;
2296                 goto out1;
2297         }
2298 
2299         /*
2300          * Must specify the mode.
2301          */
2302         if (!(va.va_mask & AT_MODE)) {
2303                 resp->status = NFS3ERR_INVAL;
2304                 goto out1;
2305         }
2306 
2307         ca = (struct sockaddr *)svc_getrpccaller(req->rq_xprt)->buf;
2308         name = nfscmd_convname(ca, exi, args->where.name,
2309             NFSCMD_CONV_INBOUND, MAXPATHLEN + 1);
2310 
2311         if (name == NULL) {
2312                 resp->status = NFS3ERR_INVAL;
2313                 goto out1;
2314         }
2315 
2316         excl = EXCL;
2317 
2318         mode = 0;
2319 
2320         error = VOP_CREATE(dvp, name, &va, excl, mode,
2321             &vp, cr, 0, NULL, NULL);
2322 
2323         if (name != args->where.name)
2324                 kmem_free(name, MAXPATHLEN + 1);
2325 
2326         dava.va_mask = AT_ALL;
2327         davap = VOP_GETATTR(dvp, &dava, 0, cr, NULL) ? NULL : &dava;
2328 
2329         /*
2330          * Force modified data and metadata out to stable storage.
2331          */
2332         (void) VOP_FSYNC(dvp, 0, cr, NULL);
2333 
2334         if (error)
2335                 goto out;
2336 
2337         resp->status = NFS3_OK;
2338 
2339         error = makefh3(&resp->resok.obj.handle, vp, exi);
2340         if (error)
2341                 resp->resok.obj.handle_follows = FALSE;
2342         else
2343                 resp->resok.obj.handle_follows = TRUE;
2344 
2345         va.va_mask = AT_ALL;
2346         vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
2347 
2348         /*
2349          * Force modified metadata out to stable storage.
2350          *
2351          * if a underlying vp exists, pass it to VOP_FSYNC
2352          */
2353         if (VOP_REALVP(vp, &realvp, NULL) == 0)
2354                 (void) VOP_FSYNC(realvp, FNODSYNC, cr, NULL);
2355         else
2356                 (void) VOP_FSYNC(vp, FNODSYNC, cr, NULL);
2357 
2358         VN_RELE(vp);
2359 
2360         vattr_to_post_op_attr(vap, &resp->resok.obj_attributes);
2361         vattr_to_wcc_data(dbvap, davap, &resp->resok.dir_wcc);
2362         DTRACE_NFSV3_4(op__mknod__done, struct svc_req *, req,
2363             cred_t *, cr, vnode_t *, dvp, MKNOD3res *, resp);
2364         VN_RELE(dvp);
2365         return;
2366 
2367 out:
2368         if (curthread->t_flag & T_WOULDBLOCK) {
2369                 curthread->t_flag &= ~T_WOULDBLOCK;
2370                 resp->status = NFS3ERR_JUKEBOX;
2371         } else
2372                 resp->status = puterrno3(error);
2373 out1:
2374         DTRACE_NFSV3_4(op__mknod__done, struct svc_req *, req,
2375             cred_t *, cr, vnode_t *, dvp, MKNOD3res *, resp);
2376         if (dvp != NULL)
2377                 VN_RELE(dvp);
2378         vattr_to_wcc_data(dbvap, davap, &resp->resfail.dir_wcc);
2379 }
2380 
2381 void *
2382 rfs3_mknod_getfh(MKNOD3args *args)
2383 {
2384 
2385         return (&args->where.dir);
2386 }
2387 
2388 void
2389 rfs3_remove(REMOVE3args *args, REMOVE3res *resp, struct exportinfo *exi,
2390     struct svc_req *req, cred_t *cr, bool_t ro)
2391 {
2392         int error = 0;
2393         vnode_t *vp;
2394         struct vattr *bvap;
2395         struct vattr bva;
2396         struct vattr *avap;
2397         struct vattr ava;
2398         vnode_t *targvp = NULL;
2399         struct sockaddr *ca;
2400         char *name = NULL;
2401 
2402         bvap = NULL;
2403         avap = NULL;
2404 
2405         vp = nfs3_fhtovp(&args->object.dir, exi);
2406 
2407         DTRACE_NFSV3_4(op__remove__start, struct svc_req *, req,
2408             cred_t *, cr, vnode_t *, vp, REMOVE3args *, args);
2409 
2410         if (vp == NULL) {
2411                 error = ESTALE;
2412                 goto err;
2413         }
2414 
2415         bva.va_mask = AT_ALL;
2416         bvap = VOP_GETATTR(vp, &bva, 0, cr, NULL) ? NULL : &bva;
2417         avap = bvap;
2418 
2419         if (vp->v_type != VDIR) {
2420                 resp->status = NFS3ERR_NOTDIR;
2421                 goto err1;
2422         }
2423 
2424         if (args->object.name == nfs3nametoolong) {
2425                 resp->status = NFS3ERR_NAMETOOLONG;
2426                 goto err1;
2427         }
2428 
2429         if (args->object.name == NULL || *(args->object.name) == '\0') {
2430                 resp->status = NFS3ERR_ACCES;
2431                 goto err1;
2432         }
2433 
2434         if (rdonly(ro, vp)) {
2435                 resp->status = NFS3ERR_ROFS;
2436                 goto err1;
2437         }
2438 
2439         if (is_system_labeled()) {
2440                 bslabel_t *clabel = req->rq_label;
2441 
2442                 ASSERT(clabel != NULL);
2443                 DTRACE_PROBE2(tx__rfs3__log__info__opremove__clabel, char *,
2444                     "got client label from request(1)", struct svc_req *, req);
2445 
2446                 if (!blequal(&l_admin_low->tsl_label, clabel)) {
2447                         if (!do_rfs_label_check(clabel, vp, EQUALITY_CHECK,
2448                             exi)) {
2449                                 resp->status = NFS3ERR_ACCES;
2450                                 goto err1;
2451                         }
2452                 }
2453         }
2454 
2455         ca = (struct sockaddr *)svc_getrpccaller(req->rq_xprt)->buf;
2456         name = nfscmd_convname(ca, exi, args->object.name,
2457             NFSCMD_CONV_INBOUND, MAXPATHLEN + 1);
2458 
2459         if (name == NULL) {
2460                 resp->status = NFS3ERR_INVAL;
2461                 goto err1;
2462         }
2463 
2464         /*
2465          * Check for a conflict with a non-blocking mandatory share
2466          * reservation and V4 delegations
2467          */
2468         error = VOP_LOOKUP(vp, name, &targvp, NULL, 0,
2469             NULL, cr, NULL, NULL, NULL);
2470         if (error != 0)
2471                 goto err;
2472 
2473         if (rfs4_check_delegated(FWRITE, targvp, TRUE)) {
2474                 resp->status = NFS3ERR_JUKEBOX;
2475                 goto err1;
2476         }
2477 
2478         if (!nbl_need_check(targvp)) {
2479                 error = VOP_REMOVE(vp, name, cr, NULL, 0);
2480         } else {
2481                 nbl_start_crit(targvp, RW_READER);
2482                 if (nbl_conflict(targvp, NBL_REMOVE, 0, 0, 0, NULL)) {
2483                         error = EACCES;
2484                 } else {
2485                         error = VOP_REMOVE(vp, name, cr, NULL, 0);
2486                 }
2487                 nbl_end_crit(targvp);
2488         }
2489         VN_RELE(targvp);
2490         targvp = NULL;
2491 
2492         ava.va_mask = AT_ALL;
2493         avap = VOP_GETATTR(vp, &ava, 0, cr, NULL) ? NULL : &ava;
2494 
2495         /*
2496          * Force modified data and metadata out to stable storage.
2497          */
2498         (void) VOP_FSYNC(vp, 0, cr, NULL);
2499 
2500         if (error)
2501                 goto err;
2502 
2503         resp->status = NFS3_OK;
2504         vattr_to_wcc_data(bvap, avap, &resp->resok.dir_wcc);
2505         goto out;
2506 
2507 err:
2508         if (curthread->t_flag & T_WOULDBLOCK) {
2509                 curthread->t_flag &= ~T_WOULDBLOCK;
2510                 resp->status = NFS3ERR_JUKEBOX;
2511         } else
2512                 resp->status = puterrno3(error);
2513 err1:
2514         vattr_to_wcc_data(bvap, avap, &resp->resfail.dir_wcc);
2515 out:
2516         DTRACE_NFSV3_4(op__remove__done, struct svc_req *, req,
2517             cred_t *, cr, vnode_t *, vp, REMOVE3res *, resp);
2518 
2519         if (name != NULL && name != args->object.name)
2520                 kmem_free(name, MAXPATHLEN + 1);
2521 
2522         if (vp != NULL)
2523                 VN_RELE(vp);
2524 }
2525 
2526 void *
2527 rfs3_remove_getfh(REMOVE3args *args)
2528 {
2529 
2530         return (&args->object.dir);
2531 }
2532 
2533 void
2534 rfs3_rmdir(RMDIR3args *args, RMDIR3res *resp, struct exportinfo *exi,
2535     struct svc_req *req, cred_t *cr, bool_t ro)
2536 {
2537         int error;
2538         vnode_t *vp;
2539         struct vattr *bvap;
2540         struct vattr bva;
2541         struct vattr *avap;
2542         struct vattr ava;
2543         struct sockaddr *ca;
2544         char *name = NULL;
2545 
2546         bvap = NULL;
2547         avap = NULL;
2548 
2549         vp = nfs3_fhtovp(&args->object.dir, exi);
2550 
2551         DTRACE_NFSV3_4(op__rmdir__start, struct svc_req *, req,
2552             cred_t *, cr, vnode_t *, vp, RMDIR3args *, args);
2553 
2554         if (vp == NULL) {
2555                 error = ESTALE;
2556                 goto err;
2557         }
2558 
2559         bva.va_mask = AT_ALL;
2560         bvap = VOP_GETATTR(vp, &bva, 0, cr, NULL) ? NULL : &bva;
2561         avap = bvap;
2562 
2563         if (vp->v_type != VDIR) {
2564                 resp->status = NFS3ERR_NOTDIR;
2565                 goto err1;
2566         }
2567 
2568         if (args->object.name == nfs3nametoolong) {
2569                 resp->status = NFS3ERR_NAMETOOLONG;
2570                 goto err1;
2571         }
2572 
2573         if (args->object.name == NULL || *(args->object.name) == '\0') {
2574                 resp->status = NFS3ERR_ACCES;
2575                 goto err1;
2576         }
2577 
2578         if (rdonly(ro, vp)) {
2579                 resp->status = NFS3ERR_ROFS;
2580                 goto err1;
2581         }
2582 
2583         if (is_system_labeled()) {
2584                 bslabel_t *clabel = req->rq_label;
2585 
2586                 ASSERT(clabel != NULL);
2587                 DTRACE_PROBE2(tx__rfs3__log__info__opremovedir__clabel, char *,
2588                     "got client label from request(1)", struct svc_req *, req);
2589 
2590                 if (!blequal(&l_admin_low->tsl_label, clabel)) {
2591                         if (!do_rfs_label_check(clabel, vp, EQUALITY_CHECK,
2592                             exi)) {
2593                                 resp->status = NFS3ERR_ACCES;
2594                                 goto err1;
2595                         }
2596                 }
2597         }
2598 
2599         ca = (struct sockaddr *)svc_getrpccaller(req->rq_xprt)->buf;
2600         name = nfscmd_convname(ca, exi, args->object.name,
2601             NFSCMD_CONV_INBOUND, MAXPATHLEN + 1);
2602 
2603         if (name == NULL) {
2604                 resp->status = NFS3ERR_INVAL;
2605                 goto err1;
2606         }
2607 
2608         error = VOP_RMDIR(vp, name, rootdir, cr, NULL, 0);
2609 
2610         if (name != args->object.name)
2611                 kmem_free(name, MAXPATHLEN + 1);
2612 
2613         ava.va_mask = AT_ALL;
2614         avap = VOP_GETATTR(vp, &ava, 0, cr, NULL) ? NULL : &ava;
2615 
2616         /*
2617          * Force modified data and metadata out to stable storage.
2618          */
2619         (void) VOP_FSYNC(vp, 0, cr, NULL);
2620 
2621         if (error) {
2622                 /*
2623                  * System V defines rmdir to return EEXIST, not ENOTEMPTY,
2624                  * if the directory is not empty.  A System V NFS server
2625                  * needs to map NFS3ERR_EXIST to NFS3ERR_NOTEMPTY to transmit
2626                  * over the wire.
2627                  */
2628                 if (error == EEXIST)
2629                         error = ENOTEMPTY;
2630                 goto err;
2631         }
2632 
2633         resp->status = NFS3_OK;
2634         vattr_to_wcc_data(bvap, avap, &resp->resok.dir_wcc);
2635         goto out;
2636 
2637 err:
2638         if (curthread->t_flag & T_WOULDBLOCK) {
2639                 curthread->t_flag &= ~T_WOULDBLOCK;
2640                 resp->status = NFS3ERR_JUKEBOX;
2641         } else
2642                 resp->status = puterrno3(error);
2643 err1:
2644         vattr_to_wcc_data(bvap, avap, &resp->resfail.dir_wcc);
2645 out:
2646         DTRACE_NFSV3_4(op__rmdir__done, struct svc_req *, req,
2647             cred_t *, cr, vnode_t *, vp, RMDIR3res *, resp);
2648         if (vp != NULL)
2649                 VN_RELE(vp);
2650 
2651 }
2652 
2653 void *
2654 rfs3_rmdir_getfh(RMDIR3args *args)
2655 {
2656 
2657         return (&args->object.dir);
2658 }
2659 
2660 void
2661 rfs3_rename(RENAME3args *args, RENAME3res *resp, struct exportinfo *exi,
2662     struct svc_req *req, cred_t *cr, bool_t ro)
2663 {
2664         int error = 0;
2665         vnode_t *fvp;
2666         vnode_t *tvp;
2667         vnode_t *targvp;
2668         struct vattr *fbvap;
2669         struct vattr fbva;
2670         struct vattr *favap;
2671         struct vattr fava;
2672         struct vattr *tbvap;
2673         struct vattr tbva;
2674         struct vattr *tavap;
2675         struct vattr tava;
2676         nfs_fh3 *fh3;
2677         struct exportinfo *to_exi;
2678         vnode_t *srcvp = NULL;
2679         bslabel_t *clabel;
2680         struct sockaddr *ca;
2681         char *name = NULL;
2682         char *toname = NULL;
2683 
2684         fbvap = NULL;
2685         favap = NULL;
2686         tbvap = NULL;
2687         tavap = NULL;
2688         tvp = NULL;
2689 
2690         fvp = nfs3_fhtovp(&args->from.dir, exi);
2691 
2692         DTRACE_NFSV3_4(op__rename__start, struct svc_req *, req,
2693             cred_t *, cr, vnode_t *, fvp, RENAME3args *, args);
2694 
2695         if (fvp == NULL) {
2696                 error = ESTALE;
2697                 goto err;
2698         }
2699 
2700         if (is_system_labeled()) {
2701                 clabel = req->rq_label;
2702                 ASSERT(clabel != NULL);
2703                 DTRACE_PROBE2(tx__rfs3__log__info__oprename__clabel, char *,
2704                     "got client label from request(1)", struct svc_req *, req);
2705 
2706                 if (!blequal(&l_admin_low->tsl_label, clabel)) {
2707                         if (!do_rfs_label_check(clabel, fvp, EQUALITY_CHECK,
2708                             exi)) {
2709                                 resp->status = NFS3ERR_ACCES;
2710                                 goto err1;
2711                         }
2712                 }
2713         }
2714 
2715         fbva.va_mask = AT_ALL;
2716         fbvap = VOP_GETATTR(fvp, &fbva, 0, cr, NULL) ? NULL : &fbva;
2717         favap = fbvap;
2718 
2719         fh3 = &args->to.dir;
2720         to_exi = checkexport(&fh3->fh3_fsid, FH3TOXFIDP(fh3), NULL);
2721         if (to_exi == NULL) {
2722                 resp->status = NFS3ERR_ACCES;
2723                 goto err1;
2724         }
2725         exi_rele(to_exi);
2726 
2727         if (to_exi != exi) {
2728                 resp->status = NFS3ERR_XDEV;
2729                 goto err1;
2730         }
2731 
2732         tvp = nfs3_fhtovp(&args->to.dir, exi);
2733         if (tvp == NULL) {
2734                 error = ESTALE;
2735                 goto err;
2736         }
2737 
2738         tbva.va_mask = AT_ALL;
2739         tbvap = VOP_GETATTR(tvp, &tbva, 0, cr, NULL) ? NULL : &tbva;
2740         tavap = tbvap;
2741 
2742         if (fvp->v_type != VDIR || tvp->v_type != VDIR) {
2743                 resp->status = NFS3ERR_NOTDIR;
2744                 goto err1;
2745         }
2746 
2747         if (args->from.name == nfs3nametoolong ||
2748             args->to.name == nfs3nametoolong) {
2749                 resp->status = NFS3ERR_NAMETOOLONG;
2750                 goto err1;
2751         }
2752         if (args->from.name == NULL || *(args->from.name) == '\0' ||
2753             args->to.name == NULL || *(args->to.name) == '\0') {
2754                 resp->status = NFS3ERR_ACCES;
2755                 goto err1;
2756         }
2757 
2758         if (rdonly(ro, tvp)) {
2759                 resp->status = NFS3ERR_ROFS;
2760                 goto err1;
2761         }
2762 
2763         if (is_system_labeled()) {
2764                 if (!blequal(&l_admin_low->tsl_label, clabel)) {
2765                         if (!do_rfs_label_check(clabel, tvp, EQUALITY_CHECK,
2766                             exi)) {
2767                                 resp->status = NFS3ERR_ACCES;
2768                                 goto err1;
2769                         }
2770                 }
2771         }
2772 
2773         ca = (struct sockaddr *)svc_getrpccaller(req->rq_xprt)->buf;
2774         name = nfscmd_convname(ca, exi, args->from.name,
2775             NFSCMD_CONV_INBOUND, MAXPATHLEN + 1);
2776 
2777         if (name == NULL) {
2778                 resp->status = NFS3ERR_INVAL;
2779                 goto err1;
2780         }
2781 
2782         toname = nfscmd_convname(ca, exi, args->to.name,
2783             NFSCMD_CONV_INBOUND, MAXPATHLEN + 1);
2784 
2785         if (toname == NULL) {
2786                 resp->status = NFS3ERR_INVAL;
2787                 goto err1;
2788         }
2789 
2790         /*
2791          * Check for a conflict with a non-blocking mandatory share
2792          * reservation or V4 delegations.
2793          */
2794         error = VOP_LOOKUP(fvp, name, &srcvp, NULL, 0,
2795             NULL, cr, NULL, NULL, NULL);
2796         if (error != 0)
2797                 goto err;
2798 
2799         /*
2800          * If we rename a delegated file we should recall the
2801          * delegation, since future opens should fail or would
2802          * refer to a new file.
2803          */
2804         if (rfs4_check_delegated(FWRITE, srcvp, FALSE)) {
2805                 resp->status = NFS3ERR_JUKEBOX;
2806                 goto err1;
2807         }
2808 
2809         /*
2810          * Check for renaming over a delegated file.  Check rfs4_deleg_policy
2811          * first to avoid VOP_LOOKUP if possible.
2812          */
2813         if (rfs4_deleg_policy != SRV_NEVER_DELEGATE &&
2814             VOP_LOOKUP(tvp, toname, &targvp, NULL, 0, NULL, cr,
2815             NULL, NULL, NULL) == 0) {
2816 
2817                 if (rfs4_check_delegated(FWRITE, targvp, TRUE)) {
2818                         VN_RELE(targvp);
2819                         resp->status = NFS3ERR_JUKEBOX;
2820                         goto err1;
2821                 }
2822                 VN_RELE(targvp);
2823         }
2824 
2825         if (!nbl_need_check(srcvp)) {
2826                 error = VOP_RENAME(fvp, name, tvp, toname, cr, NULL, 0);
2827         } else {
2828                 nbl_start_crit(srcvp, RW_READER);
2829                 if (nbl_conflict(srcvp, NBL_RENAME, 0, 0, 0, NULL))
2830                         error = EACCES;
2831                 else
2832                         error = VOP_RENAME(fvp, name, tvp, toname, cr, NULL, 0);
2833                 nbl_end_crit(srcvp);
2834         }
2835         if (error == 0)
2836                 vn_renamepath(tvp, srcvp, args->to.name,
2837                     strlen(args->to.name));
2838         VN_RELE(srcvp);
2839         srcvp = NULL;
2840 
2841         fava.va_mask = AT_ALL;
2842         favap = VOP_GETATTR(fvp, &fava, 0, cr, NULL) ? NULL : &fava;
2843         tava.va_mask = AT_ALL;
2844         tavap = VOP_GETATTR(tvp, &tava, 0, cr, NULL) ? NULL : &tava;
2845 
2846         /*
2847          * Force modified data and metadata out to stable storage.
2848          */
2849         (void) VOP_FSYNC(fvp, 0, cr, NULL);
2850         (void) VOP_FSYNC(tvp, 0, cr, NULL);
2851 
2852         if (error)
2853                 goto err;
2854 
2855         resp->status = NFS3_OK;
2856         vattr_to_wcc_data(fbvap, favap, &resp->resok.fromdir_wcc);
2857         vattr_to_wcc_data(tbvap, tavap, &resp->resok.todir_wcc);
2858         goto out;
2859 
2860 err:
2861         if (curthread->t_flag & T_WOULDBLOCK) {
2862                 curthread->t_flag &= ~T_WOULDBLOCK;
2863                 resp->status = NFS3ERR_JUKEBOX;
2864         } else {
2865                 resp->status = puterrno3(error);
2866         }
2867 err1:
2868         vattr_to_wcc_data(fbvap, favap, &resp->resfail.fromdir_wcc);
2869         vattr_to_wcc_data(tbvap, tavap, &resp->resfail.todir_wcc);
2870 
2871 out:
2872         if (name != NULL && name != args->from.name)
2873                 kmem_free(name, MAXPATHLEN + 1);
2874         if (toname != NULL && toname != args->to.name)
2875                 kmem_free(toname, MAXPATHLEN + 1);
2876 
2877         DTRACE_NFSV3_4(op__rename__done, struct svc_req *, req,
2878             cred_t *, cr, vnode_t *, fvp, RENAME3res *, resp);
2879         if (fvp != NULL)
2880                 VN_RELE(fvp);
2881         if (tvp != NULL)
2882                 VN_RELE(tvp);
2883 }
2884 
2885 void *
2886 rfs3_rename_getfh(RENAME3args *args)
2887 {
2888 
2889         return (&args->from.dir);
2890 }
2891 
2892 void
2893 rfs3_link(LINK3args *args, LINK3res *resp, struct exportinfo *exi,
2894     struct svc_req *req, cred_t *cr, bool_t ro)
2895 {
2896         int error;
2897         vnode_t *vp;
2898         vnode_t *dvp;
2899         struct vattr *vap;
2900         struct vattr va;
2901         struct vattr *bvap;
2902         struct vattr bva;
2903         struct vattr *avap;
2904         struct vattr ava;
2905         nfs_fh3 *fh3;
2906         struct exportinfo *to_exi;
2907         bslabel_t *clabel;
2908         struct sockaddr *ca;
2909         char *name = NULL;
2910 
2911         vap = NULL;
2912         bvap = NULL;
2913         avap = NULL;
2914         dvp = NULL;
2915 
2916         vp = nfs3_fhtovp(&args->file, exi);
2917 
2918         DTRACE_NFSV3_4(op__link__start, struct svc_req *, req,
2919             cred_t *, cr, vnode_t *, vp, LINK3args *, args);
2920 
2921         if (vp == NULL) {
2922                 error = ESTALE;
2923                 goto out;
2924         }
2925 
2926         va.va_mask = AT_ALL;
2927         vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
2928 
2929         fh3 = &args->link.dir;
2930         to_exi = checkexport(&fh3->fh3_fsid, FH3TOXFIDP(fh3), NULL);
2931         if (to_exi == NULL) {
2932                 resp->status = NFS3ERR_ACCES;
2933                 goto out1;
2934         }
2935         exi_rele(to_exi);
2936 
2937         if (to_exi != exi) {
2938                 resp->status = NFS3ERR_XDEV;
2939                 goto out1;
2940         }
2941 
2942         if (is_system_labeled()) {
2943                 clabel = req->rq_label;
2944 
2945                 ASSERT(clabel != NULL);
2946                 DTRACE_PROBE2(tx__rfs3__log__info__oplink__clabel, char *,
2947                     "got client label from request(1)", struct svc_req *, req);
2948 
2949                 if (!blequal(&l_admin_low->tsl_label, clabel)) {
2950                         if (!do_rfs_label_check(clabel, vp, DOMINANCE_CHECK,
2951                             exi)) {
2952                                 resp->status = NFS3ERR_ACCES;
2953                                 goto out1;
2954                         }
2955                 }
2956         }
2957 
2958         dvp = nfs3_fhtovp(&args->link.dir, exi);
2959         if (dvp == NULL) {
2960                 error = ESTALE;
2961                 goto out;
2962         }
2963 
2964         bva.va_mask = AT_ALL;
2965         bvap = VOP_GETATTR(dvp, &bva, 0, cr, NULL) ? NULL : &bva;
2966 
2967         if (dvp->v_type != VDIR) {
2968                 resp->status = NFS3ERR_NOTDIR;
2969                 goto out1;
2970         }
2971 
2972         if (args->link.name == nfs3nametoolong) {
2973                 resp->status = NFS3ERR_NAMETOOLONG;
2974                 goto out1;
2975         }
2976 
2977         if (args->link.name == NULL || *(args->link.name) == '\0') {
2978                 resp->status = NFS3ERR_ACCES;
2979                 goto out1;
2980         }
2981 
2982         if (rdonly(ro, dvp)) {
2983                 resp->status = NFS3ERR_ROFS;
2984                 goto out1;
2985         }
2986 
2987         if (is_system_labeled()) {
2988                 DTRACE_PROBE2(tx__rfs3__log__info__oplinkdir__clabel, char *,
2989                     "got client label from request(1)", struct svc_req *, req);
2990 
2991                 if (!blequal(&l_admin_low->tsl_label, clabel)) {
2992                         if (!do_rfs_label_check(clabel, dvp, EQUALITY_CHECK,
2993                             exi)) {
2994                                 resp->status = NFS3ERR_ACCES;
2995                                 goto out1;
2996                         }
2997                 }
2998         }
2999 
3000         ca = (struct sockaddr *)svc_getrpccaller(req->rq_xprt)->buf;
3001         name = nfscmd_convname(ca, exi, args->link.name,
3002             NFSCMD_CONV_INBOUND, MAXPATHLEN + 1);
3003 
3004         if (name == NULL) {
3005                 resp->status = NFS3ERR_SERVERFAULT;
3006                 goto out1;
3007         }
3008 
3009         error = VOP_LINK(dvp, vp, name, cr, NULL, 0);
3010 
3011         va.va_mask = AT_ALL;
3012         vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
3013         ava.va_mask = AT_ALL;
3014         avap = VOP_GETATTR(dvp, &ava, 0, cr, NULL) ? NULL : &ava;
3015 
3016         /*
3017          * Force modified data and metadata out to stable storage.
3018          */
3019         (void) VOP_FSYNC(vp, FNODSYNC, cr, NULL);
3020         (void) VOP_FSYNC(dvp, 0, cr, NULL);
3021 
3022         if (error)
3023                 goto out;
3024 
3025         VN_RELE(dvp);
3026 
3027         resp->status = NFS3_OK;
3028         vattr_to_post_op_attr(vap, &resp->resok.file_attributes);
3029         vattr_to_wcc_data(bvap, avap, &resp->resok.linkdir_wcc);
3030 
3031         DTRACE_NFSV3_4(op__link__done, struct svc_req *, req,
3032             cred_t *, cr, vnode_t *, vp, LINK3res *, resp);
3033 
3034         VN_RELE(vp);
3035 
3036         return;
3037 
3038 out:
3039         if (curthread->t_flag & T_WOULDBLOCK) {
3040                 curthread->t_flag &= ~T_WOULDBLOCK;
3041                 resp->status = NFS3ERR_JUKEBOX;
3042         } else
3043                 resp->status = puterrno3(error);
3044 out1:
3045         if (name != NULL && name != args->link.name)
3046                 kmem_free(name, MAXPATHLEN + 1);
3047 
3048         DTRACE_NFSV3_4(op__link__done, struct svc_req *, req,
3049             cred_t *, cr, vnode_t *, vp, LINK3res *, resp);
3050 
3051         if (vp != NULL)
3052                 VN_RELE(vp);
3053         if (dvp != NULL)
3054                 VN_RELE(dvp);
3055         vattr_to_post_op_attr(vap, &resp->resfail.file_attributes);
3056         vattr_to_wcc_data(bvap, avap, &resp->resfail.linkdir_wcc);
3057 }
3058 
3059 void *
3060 rfs3_link_getfh(LINK3args *args)
3061 {
3062 
3063         return (&args->file);
3064 }
3065 
3066 /*
3067  * This macro defines the size of a response which contains attribute
3068  * information and one directory entry (whose length is specified by
3069  * the macro parameter).  If the incoming request is larger than this,
3070  * then we are guaranteed to be able to return at one directory entry
3071  * if one exists.  Therefore, we do not need to check for
3072  * NFS3ERR_TOOSMALL if the requested size is larger then this.  If it
3073  * is not, then we need to check to make sure that this error does not
3074  * need to be returned.
3075  *
3076  * NFS3_READDIR_MIN_COUNT is comprised of following :
3077  *
3078  * status - 1 * BYTES_PER_XDR_UNIT
3079  * attr. flag - 1 * BYTES_PER_XDR_UNIT
3080  * cookie verifier - 2 * BYTES_PER_XDR_UNIT
3081  * attributes  - NFS3_SIZEOF_FATTR3 * BYTES_PER_XDR_UNIT
3082  * boolean - 1 * BYTES_PER_XDR_UNIT
3083  * file id - 2 * BYTES_PER_XDR_UNIT
3084  * directory name length - 1 * BYTES_PER_XDR_UNIT
3085  * cookie - 2 * BYTES_PER_XDR_UNIT
3086  * end of list - 1 * BYTES_PER_XDR_UNIT
3087  * end of file - 1 * BYTES_PER_XDR_UNIT
3088  * Name length of directory to the nearest byte
3089  */
3090 
3091 #define NFS3_READDIR_MIN_COUNT(length)  \
3092         ((1 + 1 + 2 + NFS3_SIZEOF_FATTR3 + 1 + 2 + 1 + 2 + 1 + 1) * \
3093                 BYTES_PER_XDR_UNIT + roundup((length), BYTES_PER_XDR_UNIT))
3094 
3095 /* ARGSUSED */
3096 void
3097 rfs3_readdir(READDIR3args *args, READDIR3res *resp, struct exportinfo *exi,
3098     struct svc_req *req, cred_t *cr, bool_t ro)
3099 {
3100         int error;
3101         vnode_t *vp;
3102         struct vattr *vap;
3103         struct vattr va;
3104         struct iovec iov;
3105         struct uio uio;
3106         char *data;
3107         int iseof;
3108         int bufsize;
3109         int namlen;
3110         uint_t count;
3111         struct sockaddr *ca;
3112 
3113         vap = NULL;
3114 
3115         vp = nfs3_fhtovp(&args->dir, exi);
3116 
3117         DTRACE_NFSV3_4(op__readdir__start, struct svc_req *, req,
3118             cred_t *, cr, vnode_t *, vp, READDIR3args *, args);
3119 
3120         if (vp == NULL) {
3121                 error = ESTALE;
3122                 goto out;
3123         }
3124 
3125         if (is_system_labeled()) {
3126                 bslabel_t *clabel = req->rq_label;
3127 
3128                 ASSERT(clabel != NULL);
3129                 DTRACE_PROBE2(tx__rfs3__log__info__opreaddir__clabel, char *,
3130                     "got client label from request(1)", struct svc_req *, req);
3131 
3132                 if (!blequal(&l_admin_low->tsl_label, clabel)) {
3133                         if (!do_rfs_label_check(clabel, vp, DOMINANCE_CHECK,
3134                             exi)) {
3135                                 resp->status = NFS3ERR_ACCES;
3136                                 goto out1;
3137                         }
3138                 }
3139         }
3140 
3141         (void) VOP_RWLOCK(vp, V_WRITELOCK_FALSE, NULL);
3142 
3143         va.va_mask = AT_ALL;
3144         vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
3145 
3146         if (vp->v_type != VDIR) {
3147                 resp->status = NFS3ERR_NOTDIR;
3148                 goto out1;
3149         }
3150 
3151         error = VOP_ACCESS(vp, VREAD, 0, cr, NULL);
3152         if (error)
3153                 goto out;
3154 
3155         /*
3156          * Now don't allow arbitrary count to alloc;
3157          * allow the maximum not to exceed rfs3_tsize()
3158          */
3159         if (args->count > rfs3_tsize(req))
3160                 args->count = rfs3_tsize(req);
3161 
3162         /*
3163          * Make sure that there is room to read at least one entry
3164          * if any are available.
3165          */
3166         if (args->count < DIRENT64_RECLEN(MAXNAMELEN))
3167                 count = DIRENT64_RECLEN(MAXNAMELEN);
3168         else
3169                 count = args->count;
3170 
3171         data = kmem_alloc(count, KM_SLEEP);
3172 
3173         iov.iov_base = data;
3174         iov.iov_len = count;
3175         uio.uio_iov = &iov;
3176         uio.uio_iovcnt = 1;
3177         uio.uio_segflg = UIO_SYSSPACE;
3178         uio.uio_extflg = UIO_COPY_CACHED;
3179         uio.uio_loffset = (offset_t)args->cookie;
3180         uio.uio_resid = count;
3181 
3182         error = VOP_READDIR(vp, &uio, cr, &iseof, NULL, 0);
3183 
3184         va.va_mask = AT_ALL;
3185         vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
3186 
3187         if (error) {
3188                 kmem_free(data, count);
3189                 goto out;
3190         }
3191 
3192         /*
3193          * If the count was not large enough to be able to guarantee
3194          * to be able to return at least one entry, then need to
3195          * check to see if NFS3ERR_TOOSMALL should be returned.
3196          */
3197         if (args->count < NFS3_READDIR_MIN_COUNT(MAXNAMELEN)) {
3198                 /*
3199                  * bufsize is used to keep track of the size of the response.
3200                  * It is primed with:
3201                  *      1 for the status +
3202                  *      1 for the dir_attributes.attributes boolean +
3203                  *      2 for the cookie verifier
3204                  * all times BYTES_PER_XDR_UNIT to convert from XDR units
3205                  * to bytes.  If there are directory attributes to be
3206                  * returned, then:
3207                  *      NFS3_SIZEOF_FATTR3 for the dir_attributes.attr fattr3
3208                  * time BYTES_PER_XDR_UNIT is added to account for them.
3209                  */
3210                 bufsize = (1 + 1 + 2) * BYTES_PER_XDR_UNIT;
3211                 if (vap != NULL)
3212                         bufsize += NFS3_SIZEOF_FATTR3 * BYTES_PER_XDR_UNIT;
3213                 /*
3214                  * An entry is composed of:
3215                  *      1 for the true/false list indicator +
3216                  *      2 for the fileid +
3217                  *      1 for the length of the name +
3218                  *      2 for the cookie +
3219                  * all times BYTES_PER_XDR_UNIT to convert from
3220                  * XDR units to bytes, plus the length of the name
3221                  * rounded up to the nearest BYTES_PER_XDR_UNIT.
3222                  */
3223                 if (count != uio.uio_resid) {
3224                         namlen = strlen(((struct dirent64 *)data)->d_name);
3225                         bufsize += (1 + 2 + 1 + 2) * BYTES_PER_XDR_UNIT +
3226                             roundup(namlen, BYTES_PER_XDR_UNIT);
3227                 }
3228                 /*
3229                  * We need to check to see if the number of bytes left
3230                  * to go into the buffer will actually fit into the
3231                  * buffer.  This is calculated as the size of this
3232                  * entry plus:
3233                  *      1 for the true/false list indicator +
3234                  *      1 for the eof indicator
3235                  * times BYTES_PER_XDR_UNIT to convert from from
3236                  * XDR units to bytes.
3237                  */
3238                 bufsize += (1 + 1) * BYTES_PER_XDR_UNIT;
3239                 if (bufsize > args->count) {
3240                         kmem_free(data, count);
3241                         resp->status = NFS3ERR_TOOSMALL;
3242                         goto out1;
3243                 }
3244         }
3245 
3246         /*
3247          * Have a valid readir buffer for the native character
3248          * set. Need to check if a conversion is necessary and
3249          * potentially rewrite the whole buffer. Note that if the
3250          * conversion expands names enough, the structure may not
3251          * fit. In this case, we need to drop entries until if fits
3252          * and patch the counts in order that the next readdir will
3253          * get the correct entries.
3254          */
3255         ca = (struct sockaddr *)svc_getrpccaller(req->rq_xprt)->buf;
3256         data = nfscmd_convdirent(ca, exi, data, count, &resp->status);
3257 
3258 
3259         VOP_RWUNLOCK(vp, V_WRITELOCK_FALSE, NULL);
3260 
3261 #if 0 /* notyet */
3262         /*
3263          * Don't do this.  It causes local disk writes when just
3264          * reading the file and the overhead is deemed larger
3265          * than the benefit.
3266          */
3267         /*
3268          * Force modified metadata out to stable storage.
3269          */
3270         (void) VOP_FSYNC(vp, FNODSYNC, cr, NULL);
3271 #endif
3272 
3273         resp->status = NFS3_OK;
3274         vattr_to_post_op_attr(vap, &resp->resok.dir_attributes);
3275         resp->resok.cookieverf = 0;
3276         resp->resok.reply.entries = (entry3 *)data;
3277         resp->resok.reply.eof = iseof;
3278         resp->resok.size = count - uio.uio_resid;
3279         resp->resok.count = args->count;
3280         resp->resok.freecount = count;
3281 
3282         DTRACE_NFSV3_4(op__readdir__done, struct svc_req *, req,
3283             cred_t *, cr, vnode_t *, vp, READDIR3res *, resp);
3284 
3285         VN_RELE(vp);
3286 
3287         return;
3288 
3289 out:
3290         if (curthread->t_flag & T_WOULDBLOCK) {
3291                 curthread->t_flag &= ~T_WOULDBLOCK;
3292                 resp->status = NFS3ERR_JUKEBOX;
3293         } else
3294                 resp->status = puterrno3(error);
3295 out1:
3296         DTRACE_NFSV3_4(op__readdir__done, struct svc_req *, req,
3297             cred_t *, cr, vnode_t *, vp, READDIR3res *, resp);
3298 
3299         if (vp != NULL) {
3300                 VOP_RWUNLOCK(vp, V_WRITELOCK_FALSE, NULL);
3301                 VN_RELE(vp);
3302         }
3303         vattr_to_post_op_attr(vap, &resp->resfail.dir_attributes);
3304 }
3305 
3306 void *
3307 rfs3_readdir_getfh(READDIR3args *args)
3308 {
3309 
3310         return (&args->dir);
3311 }
3312 
3313 void
3314 rfs3_readdir_free(READDIR3res *resp)
3315 {
3316 
3317         if (resp->status == NFS3_OK)
3318                 kmem_free(resp->resok.reply.entries, resp->resok.freecount);
3319 }
3320 
3321 #ifdef nextdp
3322 #undef nextdp
3323 #endif
3324 #define nextdp(dp)      ((struct dirent64 *)((char *)(dp) + (dp)->d_reclen))
3325 
3326 /*
3327  * This macro computes the size of a response which contains
3328  * one directory entry including the attributes as well as file handle.
3329  * If the incoming request is larger than this, then we are guaranteed to be
3330  * able to return at least one more directory entry if one exists.
3331  *
3332  * NFS3_READDIRPLUS_ENTRY is made up of the following:
3333  *
3334  * boolean - 1 * BYTES_PER_XDR_UNIT
3335  * file id - 2 * BYTES_PER_XDR_UNIT
3336  * directory name length - 1 * BYTES_PER_XDR_UNIT
3337  * cookie - 2 * BYTES_PER_XDR_UNIT
3338  * attribute flag - 1 * BYTES_PER_XDR_UNIT
3339  * attributes - NFS3_SIZEOF_FATTR3 * BYTES_PER_XDR_UNIT
3340  * status byte for file handle - 1 *  BYTES_PER_XDR_UNIT
3341  * length of a file handle - 1 * BYTES_PER_XDR_UNIT
3342  * Maximum length of a file handle (NFS3_MAXFHSIZE)
3343  * name length of the entry to the nearest bytes
3344  */
3345 #define NFS3_READDIRPLUS_ENTRY(namelen) \
3346         ((1 + 2 + 1 + 2 + 1 + NFS3_SIZEOF_FATTR3 + 1 + 1) * \
3347                 BYTES_PER_XDR_UNIT + \
3348         NFS3_MAXFHSIZE + roundup(namelen, BYTES_PER_XDR_UNIT))
3349 
3350 static int rfs3_readdir_unit = MAXBSIZE;
3351 
3352 /* ARGSUSED */
3353 void
3354 rfs3_readdirplus(READDIRPLUS3args *args, READDIRPLUS3res *resp,
3355     struct exportinfo *exi, struct svc_req *req, cred_t *cr, bool_t ro)
3356 {
3357         int error;
3358         vnode_t *vp;
3359         struct vattr *vap;
3360         struct vattr va;
3361         struct iovec iov;
3362         struct uio uio;
3363         char *data;
3364         int iseof;
3365         struct dirent64 *dp;
3366         vnode_t *nvp;
3367         struct vattr *nvap;
3368         struct vattr nva;
3369         entryplus3_info *infop = NULL;
3370         int size = 0;
3371         int nents = 0;
3372         int bufsize = 0;
3373         int entrysize = 0;
3374         int tofit = 0;
3375         int rd_unit = rfs3_readdir_unit;
3376         int prev_len;
3377         int space_left;
3378         int i;
3379         uint_t *namlen = NULL;
3380         char *ndata = NULL;
3381         struct sockaddr *ca;
3382         size_t ret;
3383 
3384         vap = NULL;
3385 
3386         vp = nfs3_fhtovp(&args->dir, exi);
3387 
3388         DTRACE_NFSV3_4(op__readdirplus__start, struct svc_req *, req,
3389             cred_t *, cr, vnode_t *, vp, READDIRPLUS3args *, args);
3390 
3391         if (vp == NULL) {
3392                 error = ESTALE;
3393                 goto out;
3394         }
3395 
3396         if (is_system_labeled()) {
3397                 bslabel_t *clabel = req->rq_label;
3398 
3399                 ASSERT(clabel != NULL);
3400                 DTRACE_PROBE2(tx__rfs3__log__info__opreaddirplus__clabel,
3401                     char *, "got client label from request(1)",
3402                     struct svc_req *, req);
3403 
3404                 if (!blequal(&l_admin_low->tsl_label, clabel)) {
3405                         if (!do_rfs_label_check(clabel, vp, DOMINANCE_CHECK,
3406                             exi)) {
3407                                 resp->status = NFS3ERR_ACCES;
3408                                 goto out1;
3409                         }
3410                 }
3411         }
3412 
3413         (void) VOP_RWLOCK(vp, V_WRITELOCK_FALSE, NULL);
3414 
3415         va.va_mask = AT_ALL;
3416         vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
3417 
3418         if (vp->v_type != VDIR) {
3419                 error = ENOTDIR;
3420                 goto out;
3421         }
3422 
3423         error = VOP_ACCESS(vp, VREAD, 0, cr, NULL);
3424         if (error)
3425                 goto out;
3426 
3427         /*
3428          * Don't allow arbitrary counts for allocation
3429          */
3430         if (args->maxcount > rfs3_tsize(req))
3431                 args->maxcount = rfs3_tsize(req);
3432 
3433         /*
3434          * Make sure that there is room to read at least one entry
3435          * if any are available
3436          */
3437         args->dircount = MIN(args->dircount, args->maxcount);
3438 
3439         if (args->dircount < DIRENT64_RECLEN(MAXNAMELEN))
3440                 args->dircount = DIRENT64_RECLEN(MAXNAMELEN);
3441 
3442         /*
3443          * This allocation relies on a minimum directory entry
3444          * being roughly 24 bytes.  Therefore, the namlen array
3445          * will have enough space based on the maximum number of
3446          * entries to read.
3447          */
3448         namlen = kmem_alloc(args->dircount, KM_SLEEP);
3449 
3450         space_left = args->dircount;
3451         data = kmem_alloc(args->dircount, KM_SLEEP);
3452         dp = (struct dirent64 *)data;
3453         uio.uio_iov = &iov;
3454         uio.uio_iovcnt = 1;
3455         uio.uio_segflg = UIO_SYSSPACE;
3456         uio.uio_extflg = UIO_COPY_CACHED;
3457         uio.uio_loffset = (offset_t)args->cookie;
3458 
3459         /*
3460          * bufsize is used to keep track of the size of the response as we
3461          * get post op attributes and filehandles for each entry.  This is
3462          * an optimization as the server may have read more entries than will
3463          * fit in the buffer specified by maxcount.  We stop calculating
3464          * post op attributes and filehandles once we have exceeded maxcount.
3465          * This will minimize the effect of truncation.
3466          *
3467          * It is primed with:
3468          *      1 for the status +
3469          *      1 for the dir_attributes.attributes boolean +
3470          *      2 for the cookie verifier
3471          * all times BYTES_PER_XDR_UNIT to convert from XDR units
3472          * to bytes.  If there are directory attributes to be
3473          * returned, then:
3474          *      NFS3_SIZEOF_FATTR3 for the dir_attributes.attr fattr3
3475          * time BYTES_PER_XDR_UNIT is added to account for them.
3476          */
3477         bufsize = (1 + 1 + 2) * BYTES_PER_XDR_UNIT;
3478         if (vap != NULL)
3479                 bufsize += NFS3_SIZEOF_FATTR3 * BYTES_PER_XDR_UNIT;
3480 
3481 getmoredents:
3482         /*
3483          * Here we make a check so that our read unit is not larger than
3484          * the space left in the buffer.
3485          */
3486         rd_unit = MIN(rd_unit, space_left);
3487         iov.iov_base = (char *)dp;
3488         iov.iov_len = rd_unit;
3489         uio.uio_resid = rd_unit;
3490         prev_len = rd_unit;
3491 
3492         error = VOP_READDIR(vp, &uio, cr, &iseof, NULL, 0);
3493 
3494         if (error) {
3495                 kmem_free(data, args->dircount);
3496                 goto out;
3497         }
3498 
3499         if (uio.uio_resid == prev_len && !iseof) {
3500                 if (nents == 0) {
3501                         kmem_free(data, args->dircount);
3502                         resp->status = NFS3ERR_TOOSMALL;
3503                         goto out1;
3504                 }
3505 
3506                 /*
3507                  * We could not get any more entries, so get the attributes
3508                  * and filehandle for the entries already obtained.
3509                  */
3510                 goto good;
3511         }
3512 
3513         /*
3514          * We estimate the size of the response by assuming the
3515          * entry exists and attributes and filehandle are also valid
3516          */
3517         for (size = prev_len - uio.uio_resid;
3518             size > 0;
3519             size -= dp->d_reclen, dp = nextdp(dp)) {
3520 
3521                 if (dp->d_ino == 0) {
3522                         nents++;
3523                         continue;
3524                 }
3525 
3526                 namlen[nents] = strlen(dp->d_name);
3527                 entrysize = NFS3_READDIRPLUS_ENTRY(namlen[nents]);
3528 
3529                 /*
3530                  * We need to check to see if the number of bytes left
3531                  * to go into the buffer will actually fit into the
3532                  * buffer.  This is calculated as the size of this
3533                  * entry plus:
3534                  *      1 for the true/false list indicator +
3535                  *      1 for the eof indicator
3536                  * times BYTES_PER_XDR_UNIT to convert from XDR units
3537                  * to bytes.
3538                  *
3539                  * Also check the dircount limit against the first entry read
3540                  *
3541                  */
3542                 tofit = entrysize + (1 + 1) * BYTES_PER_XDR_UNIT;
3543                 if (bufsize + tofit > args->maxcount) {
3544                         /*
3545                          * We make a check here to see if this was the
3546                          * first entry being measured.  If so, then maxcount
3547                          * was too small to begin with and so we need to
3548                          * return with NFS3ERR_TOOSMALL.
3549                          */
3550                         if (nents == 0) {
3551                                 kmem_free(data, args->dircount);
3552                                 resp->status = NFS3ERR_TOOSMALL;
3553                                 goto out1;
3554                         }
3555                         iseof = FALSE;
3556                         goto good;
3557                 }
3558                 bufsize += entrysize;
3559                 nents++;
3560         }
3561 
3562         /*
3563          * If there is enough room to fit at least 1 more entry including
3564          * post op attributes and filehandle in the buffer AND that we haven't
3565          * exceeded dircount then go back and get some more.
3566          */
3567         if (!iseof &&
3568             (args->maxcount - bufsize) >= NFS3_READDIRPLUS_ENTRY(MAXNAMELEN)) {
3569                 space_left -= (prev_len - uio.uio_resid);
3570                 if (space_left >= DIRENT64_RECLEN(MAXNAMELEN))
3571                         goto getmoredents;
3572 
3573                 /* else, fall through */
3574         }
3575 good:
3576         va.va_mask = AT_ALL;
3577         vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
3578 
3579         VOP_RWUNLOCK(vp, V_WRITELOCK_FALSE, NULL);
3580 
3581         infop = kmem_alloc(nents * sizeof (struct entryplus3_info), KM_SLEEP);
3582         resp->resok.infop = infop;
3583 
3584         dp = (struct dirent64 *)data;
3585         for (i = 0; i < nents; i++) {
3586 
3587                 if (dp->d_ino == 0) {
3588                         infop[i].attr.attributes = FALSE;
3589                         infop[i].fh.handle_follows = FALSE;
3590                         dp = nextdp(dp);
3591                         continue;
3592                 }
3593 
3594                 infop[i].namelen = namlen[i];
3595 
3596                 error = VOP_LOOKUP(vp, dp->d_name, &nvp, NULL, 0, NULL, cr,
3597                     NULL, NULL, NULL);
3598                 if (error) {
3599                         infop[i].attr.attributes = FALSE;
3600                         infop[i].fh.handle_follows = FALSE;
3601                         dp = nextdp(dp);
3602                         continue;
3603                 }
3604 
3605                 nva.va_mask = AT_ALL;
3606                 nvap = rfs4_delegated_getattr(nvp, &nva, 0, cr) ? NULL : &nva;
3607 
3608                 /* Lie about the object type for a referral */
3609                 if (vn_is_nfs_reparse(nvp, cr))
3610                         nvap->va_type = VLNK;
3611 
3612                 vattr_to_post_op_attr(nvap, &infop[i].attr);
3613 
3614                 error = makefh3(&infop[i].fh.handle, nvp, exi);
3615                 if (!error)
3616                         infop[i].fh.handle_follows = TRUE;
3617                 else
3618                         infop[i].fh.handle_follows = FALSE;
3619 
3620                 VN_RELE(nvp);
3621                 dp = nextdp(dp);
3622         }
3623 
3624         ca = (struct sockaddr *)svc_getrpccaller(req->rq_xprt)->buf;
3625         ret = nfscmd_convdirplus(ca, exi, data, nents, args->dircount, &ndata);
3626         if (ndata == NULL)
3627                 ndata = data;
3628 
3629         if (ret > 0) {
3630                 /*
3631                  * We had to drop one or more entries in order to fit
3632                  * during the character conversion.  We need to patch
3633                  * up the size and eof info.
3634                  */
3635                 if (iseof)
3636                         iseof = FALSE;
3637 
3638                 ret = nfscmd_dropped_entrysize((struct dirent64 *)data,
3639                     nents, ret);
3640         }
3641 
3642 
3643 #if 0 /* notyet */
3644         /*
3645          * Don't do this.  It causes local disk writes when just
3646          * reading the file and the overhead is deemed larger
3647          * than the benefit.
3648          */
3649         /*
3650          * Force modified metadata out to stable storage.
3651          */
3652         (void) VOP_FSYNC(vp, FNODSYNC, cr, NULL);
3653 #endif
3654 
3655         kmem_free(namlen, args->dircount);
3656 
3657         resp->status = NFS3_OK;
3658         vattr_to_post_op_attr(vap, &resp->resok.dir_attributes);
3659         resp->resok.cookieverf = 0;
3660         resp->resok.reply.entries = (entryplus3 *)ndata;
3661         resp->resok.reply.eof = iseof;
3662         resp->resok.size = nents;
3663         resp->resok.count = args->dircount - ret;
3664         resp->resok.maxcount = args->maxcount;
3665 
3666         DTRACE_NFSV3_4(op__readdirplus__done, struct svc_req *, req,
3667             cred_t *, cr, vnode_t *, vp, READDIRPLUS3res *, resp);
3668         if (ndata != data)
3669                 kmem_free(data, args->dircount);
3670 
3671 
3672         VN_RELE(vp);
3673 
3674         return;
3675 
3676 out:
3677         if (curthread->t_flag & T_WOULDBLOCK) {
3678                 curthread->t_flag &= ~T_WOULDBLOCK;
3679                 resp->status = NFS3ERR_JUKEBOX;
3680         } else {
3681                 resp->status = puterrno3(error);
3682         }
3683 out1:
3684         DTRACE_NFSV3_4(op__readdirplus__done, struct svc_req *, req,
3685             cred_t *, cr, vnode_t *, vp, READDIRPLUS3res *, resp);
3686 
3687         if (vp != NULL) {
3688                 VOP_RWUNLOCK(vp, V_WRITELOCK_FALSE, NULL);
3689                 VN_RELE(vp);
3690         }
3691 
3692         if (namlen != NULL)
3693                 kmem_free(namlen, args->dircount);
3694 
3695         vattr_to_post_op_attr(vap, &resp->resfail.dir_attributes);
3696 }
3697 
3698 void *
3699 rfs3_readdirplus_getfh(READDIRPLUS3args *args)
3700 {
3701 
3702         return (&args->dir);
3703 }
3704 
3705 void
3706 rfs3_readdirplus_free(READDIRPLUS3res *resp)
3707 {
3708 
3709         if (resp->status == NFS3_OK) {
3710                 kmem_free(resp->resok.reply.entries, resp->resok.count);
3711                 kmem_free(resp->resok.infop,
3712                     resp->resok.size * sizeof (struct entryplus3_info));
3713         }
3714 }
3715 
3716 /* ARGSUSED */
3717 void
3718 rfs3_fsstat(FSSTAT3args *args, FSSTAT3res *resp, struct exportinfo *exi,
3719     struct svc_req *req, cred_t *cr, bool_t ro)
3720 {
3721         int error;
3722         vnode_t *vp;
3723         struct vattr *vap;
3724         struct vattr va;
3725         struct statvfs64 sb;
3726 
3727         vap = NULL;
3728 
3729         vp = nfs3_fhtovp(&args->fsroot, exi);
3730 
3731         DTRACE_NFSV3_4(op__fsstat__start, struct svc_req *, req,
3732             cred_t *, cr, vnode_t *, vp, FSSTAT3args *, args);
3733 
3734         if (vp == NULL) {
3735                 error = ESTALE;
3736                 goto out;
3737         }
3738 
3739         if (is_system_labeled()) {
3740                 bslabel_t *clabel = req->rq_label;
3741 
3742                 ASSERT(clabel != NULL);
3743                 DTRACE_PROBE2(tx__rfs3__log__info__opfsstat__clabel, char *,
3744                     "got client label from request(1)", struct svc_req *, req);
3745 
3746                 if (!blequal(&l_admin_low->tsl_label, clabel)) {
3747                         if (!do_rfs_label_check(clabel, vp, DOMINANCE_CHECK,
3748                             exi)) {
3749                                 resp->status = NFS3ERR_ACCES;
3750                                 goto out1;
3751                         }
3752                 }
3753         }
3754 
3755         error = VFS_STATVFS(vp->v_vfsp, &sb);
3756 
3757         va.va_mask = AT_ALL;
3758         vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
3759 
3760         if (error)
3761                 goto out;
3762 
3763         resp->status = NFS3_OK;
3764         vattr_to_post_op_attr(vap, &resp->resok.obj_attributes);
3765         if (sb.f_blocks != (fsblkcnt64_t)-1)
3766                 resp->resok.tbytes = (size3)sb.f_frsize * (size3)sb.f_blocks;
3767         else
3768                 resp->resok.tbytes = (size3)sb.f_blocks;
3769         if (sb.f_bfree != (fsblkcnt64_t)-1)
3770                 resp->resok.fbytes = (size3)sb.f_frsize * (size3)sb.f_bfree;
3771         else
3772                 resp->resok.fbytes = (size3)sb.f_bfree;
3773         if (sb.f_bavail != (fsblkcnt64_t)-1)
3774                 resp->resok.abytes = (size3)sb.f_frsize * (size3)sb.f_bavail;
3775         else
3776                 resp->resok.abytes = (size3)sb.f_bavail;
3777         resp->resok.tfiles = (size3)sb.f_files;
3778         resp->resok.ffiles = (size3)sb.f_ffree;
3779         resp->resok.afiles = (size3)sb.f_favail;
3780         resp->resok.invarsec = 0;
3781 
3782         DTRACE_NFSV3_4(op__fsstat__done, struct svc_req *, req,
3783             cred_t *, cr, vnode_t *, vp, FSSTAT3res *, resp);
3784         VN_RELE(vp);
3785 
3786         return;
3787 
3788 out:
3789         if (curthread->t_flag & T_WOULDBLOCK) {
3790                 curthread->t_flag &= ~T_WOULDBLOCK;
3791                 resp->status = NFS3ERR_JUKEBOX;
3792         } else
3793                 resp->status = puterrno3(error);
3794 out1:
3795         DTRACE_NFSV3_4(op__fsstat__done, struct svc_req *, req,
3796             cred_t *, cr, vnode_t *, vp, FSSTAT3res *, resp);
3797 
3798         if (vp != NULL)
3799                 VN_RELE(vp);
3800         vattr_to_post_op_attr(vap, &resp->resfail.obj_attributes);
3801 }
3802 
3803 void *
3804 rfs3_fsstat_getfh(FSSTAT3args *args)
3805 {
3806 
3807         return (&args->fsroot);
3808 }
3809 
3810 /* ARGSUSED */
3811 void
3812 rfs3_fsinfo(FSINFO3args *args, FSINFO3res *resp, struct exportinfo *exi,
3813     struct svc_req *req, cred_t *cr, bool_t ro)
3814 {
3815         vnode_t *vp;
3816         struct vattr *vap;
3817         struct vattr va;
3818         uint32_t xfer_size;
3819         ulong_t l = 0;
3820         int error;
3821 
3822         vp = nfs3_fhtovp(&args->fsroot, exi);
3823 
3824         DTRACE_NFSV3_4(op__fsinfo__start, struct svc_req *, req,
3825             cred_t *, cr, vnode_t *, vp, FSINFO3args *, args);
3826 
3827         if (vp == NULL) {
3828                 if (curthread->t_flag & T_WOULDBLOCK) {
3829                         curthread->t_flag &= ~T_WOULDBLOCK;
3830                         resp->status = NFS3ERR_JUKEBOX;
3831                 } else
3832                         resp->status = NFS3ERR_STALE;
3833                 vattr_to_post_op_attr(NULL, &resp->resfail.obj_attributes);
3834                 goto out;
3835         }
3836 
3837         if (is_system_labeled()) {
3838                 bslabel_t *clabel = req->rq_label;
3839 
3840                 ASSERT(clabel != NULL);
3841                 DTRACE_PROBE2(tx__rfs3__log__info__opfsinfo__clabel, char *,
3842                     "got client label from request(1)", struct svc_req *, req);
3843 
3844                 if (!blequal(&l_admin_low->tsl_label, clabel)) {
3845                         if (!do_rfs_label_check(clabel, vp, DOMINANCE_CHECK,
3846                             exi)) {
3847                                 resp->status = NFS3ERR_STALE;
3848                                 vattr_to_post_op_attr(NULL,
3849                                     &resp->resfail.obj_attributes);
3850                                 goto out;
3851                         }
3852                 }
3853         }
3854 
3855         va.va_mask = AT_ALL;
3856         vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
3857 
3858         resp->status = NFS3_OK;
3859         vattr_to_post_op_attr(vap, &resp->resok.obj_attributes);
3860         xfer_size = rfs3_tsize(req);
3861         resp->resok.rtmax = xfer_size;
3862         resp->resok.rtpref = xfer_size;
3863         resp->resok.rtmult = DEV_BSIZE;
3864         resp->resok.wtmax = xfer_size;
3865         resp->resok.wtpref = xfer_size;
3866         resp->resok.wtmult = DEV_BSIZE;
3867         resp->resok.dtpref = MAXBSIZE;
3868 
3869         /*
3870          * Large file spec: want maxfilesize based on limit of
3871          * underlying filesystem.  We can guess 2^31-1 if need be.
3872          */
3873         error = VOP_PATHCONF(vp, _PC_FILESIZEBITS, &l, cr, NULL);
3874         if (error) {
3875                 resp->status = puterrno3(error);
3876                 goto out;
3877         }
3878 
3879         /*
3880          * If the underlying file system does not support _PC_FILESIZEBITS,
3881          * return a reasonable default. Note that error code on VOP_PATHCONF
3882          * will be 0, even if the underlying file system does not support
3883          * _PC_FILESIZEBITS.
3884          */
3885         if (l == (ulong_t)-1) {
3886                 resp->resok.maxfilesize = MAXOFF32_T;
3887         } else {
3888                 if (l >= (sizeof (uint64_t) * 8))
3889                         resp->resok.maxfilesize = INT64_MAX;
3890                 else
3891                         resp->resok.maxfilesize = (1LL << (l-1)) - 1;
3892         }
3893 
3894         resp->resok.time_delta.seconds = 0;
3895         resp->resok.time_delta.nseconds = 1000;
3896         resp->resok.properties = FSF3_LINK | FSF3_SYMLINK |
3897             FSF3_HOMOGENEOUS | FSF3_CANSETTIME;
3898 
3899         DTRACE_NFSV3_4(op__fsinfo__done, struct svc_req *, req,
3900             cred_t *, cr, vnode_t *, vp, FSINFO3res *, resp);
3901 
3902         VN_RELE(vp);
3903 
3904         return;
3905 
3906 out:
3907         DTRACE_NFSV3_4(op__fsinfo__done, struct svc_req *, req,
3908             cred_t *, cr, vnode_t *, NULL, FSINFO3res *, resp);
3909         if (vp != NULL)
3910                 VN_RELE(vp);
3911 }
3912 
3913 void *
3914 rfs3_fsinfo_getfh(FSINFO3args *args)
3915 {
3916         return (&args->fsroot);
3917 }
3918 
3919 /* ARGSUSED */
3920 void
3921 rfs3_pathconf(PATHCONF3args *args, PATHCONF3res *resp, struct exportinfo *exi,
3922     struct svc_req *req, cred_t *cr, bool_t ro)
3923 {
3924         int error;
3925         vnode_t *vp;
3926         struct vattr *vap;
3927         struct vattr va;
3928         ulong_t val;
3929 
3930         vap = NULL;
3931 
3932         vp = nfs3_fhtovp(&args->object, exi);
3933 
3934         DTRACE_NFSV3_4(op__pathconf__start, struct svc_req *, req,
3935             cred_t *, cr, vnode_t *, vp, PATHCONF3args *, args);
3936 
3937         if (vp == NULL) {
3938                 error = ESTALE;
3939                 goto out;
3940         }
3941 
3942         if (is_system_labeled()) {
3943                 bslabel_t *clabel = req->rq_label;
3944 
3945                 ASSERT(clabel != NULL);
3946                 DTRACE_PROBE2(tx__rfs3__log__info__oppathconf__clabel, char *,
3947                     "got client label from request(1)", struct svc_req *, req);
3948 
3949                 if (!blequal(&l_admin_low->tsl_label, clabel)) {
3950                         if (!do_rfs_label_check(clabel, vp, DOMINANCE_CHECK,
3951                             exi)) {
3952                                 resp->status = NFS3ERR_ACCES;
3953                                 goto out1;
3954                         }
3955                 }
3956         }
3957 
3958         va.va_mask = AT_ALL;
3959         vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
3960 
3961         error = VOP_PATHCONF(vp, _PC_LINK_MAX, &val, cr, NULL);
3962         if (error)
3963                 goto out;
3964         resp->resok.info.link_max = (uint32)val;
3965 
3966         error = VOP_PATHCONF(vp, _PC_NAME_MAX, &val, cr, NULL);
3967         if (error)
3968                 goto out;
3969         resp->resok.info.name_max = (uint32)val;
3970 
3971         error = VOP_PATHCONF(vp, _PC_NO_TRUNC, &val, cr, NULL);
3972         if (error)
3973                 goto out;
3974         if (val == 1)
3975                 resp->resok.info.no_trunc = TRUE;
3976         else
3977                 resp->resok.info.no_trunc = FALSE;
3978 
3979         error = VOP_PATHCONF(vp, _PC_CHOWN_RESTRICTED, &val, cr, NULL);
3980         if (error)
3981                 goto out;
3982         if (val == 1)
3983                 resp->resok.info.chown_restricted = TRUE;
3984         else
3985                 resp->resok.info.chown_restricted = FALSE;
3986 
3987         resp->status = NFS3_OK;
3988         vattr_to_post_op_attr(vap, &resp->resok.obj_attributes);
3989         resp->resok.info.case_insensitive = FALSE;
3990         resp->resok.info.case_preserving = TRUE;
3991         DTRACE_NFSV3_4(op__pathconf__done, struct svc_req *, req,
3992             cred_t *, cr, vnode_t *, vp, PATHCONF3res *, resp);
3993         VN_RELE(vp);
3994         return;
3995 
3996 out:
3997         if (curthread->t_flag & T_WOULDBLOCK) {
3998                 curthread->t_flag &= ~T_WOULDBLOCK;
3999                 resp->status = NFS3ERR_JUKEBOX;
4000         } else
4001                 resp->status = puterrno3(error);
4002 out1:
4003         DTRACE_NFSV3_4(op__pathconf__done, struct svc_req *, req,
4004             cred_t *, cr, vnode_t *, vp, PATHCONF3res *, resp);
4005         if (vp != NULL)
4006                 VN_RELE(vp);
4007         vattr_to_post_op_attr(vap, &resp->resfail.obj_attributes);
4008 }
4009 
4010 void *
4011 rfs3_pathconf_getfh(PATHCONF3args *args)
4012 {
4013 
4014         return (&args->object);
4015 }
4016 
4017 void
4018 rfs3_commit(COMMIT3args *args, COMMIT3res *resp, struct exportinfo *exi,
4019     struct svc_req *req, cred_t *cr, bool_t ro)
4020 {
4021         int error;
4022         vnode_t *vp;
4023         struct vattr *bvap;
4024         struct vattr bva;
4025         struct vattr *avap;
4026         struct vattr ava;
4027 
4028         bvap = NULL;
4029         avap = NULL;
4030 
4031         vp = nfs3_fhtovp(&args->file, exi);
4032 
4033         DTRACE_NFSV3_4(op__commit__start, struct svc_req *, req,
4034             cred_t *, cr, vnode_t *, vp, COMMIT3args *, args);
4035 
4036         if (vp == NULL) {
4037                 error = ESTALE;
4038                 goto out;
4039         }
4040 
4041         bva.va_mask = AT_ALL;
4042         error = VOP_GETATTR(vp, &bva, 0, cr, NULL);
4043 
4044         /*
4045          * If we can't get the attributes, then we can't do the
4046          * right access checking.  So, we'll fail the request.
4047          */
4048         if (error)
4049                 goto out;
4050 
4051         bvap = &bva;
4052 
4053         if (rdonly(ro, vp)) {
4054                 resp->status = NFS3ERR_ROFS;
4055                 goto out1;
4056         }
4057 
4058         if (vp->v_type != VREG) {
4059                 resp->status = NFS3ERR_INVAL;
4060                 goto out1;
4061         }
4062 
4063         if (is_system_labeled()) {
4064                 bslabel_t *clabel = req->rq_label;
4065 
4066                 ASSERT(clabel != NULL);
4067                 DTRACE_PROBE2(tx__rfs3__log__info__opcommit__clabel, char *,
4068                     "got client label from request(1)", struct svc_req *, req);
4069 
4070                 if (!blequal(&l_admin_low->tsl_label, clabel)) {
4071                         if (!do_rfs_label_check(clabel, vp, EQUALITY_CHECK,
4072                             exi)) {
4073                                 resp->status = NFS3ERR_ACCES;
4074                                 goto out1;
4075                         }
4076                 }
4077         }
4078 
4079         if (crgetuid(cr) != bva.va_uid &&
4080             (error = VOP_ACCESS(vp, VWRITE, 0, cr, NULL)))
4081                 goto out;
4082 
4083         error = VOP_FSYNC(vp, FSYNC, cr, NULL);
4084 
4085         ava.va_mask = AT_ALL;
4086         avap = VOP_GETATTR(vp, &ava, 0, cr, NULL) ? NULL : &ava;
4087 
4088         if (error)
4089                 goto out;
4090 
4091         resp->status = NFS3_OK;
4092         vattr_to_wcc_data(bvap, avap, &resp->resok.file_wcc);
4093         resp->resok.verf = write3verf;
4094 
4095         DTRACE_NFSV3_4(op__commit__done, struct svc_req *, req,
4096             cred_t *, cr, vnode_t *, vp, COMMIT3res *, resp);
4097 
4098         VN_RELE(vp);
4099 
4100         return;
4101 
4102 out:
4103         if (curthread->t_flag & T_WOULDBLOCK) {
4104                 curthread->t_flag &= ~T_WOULDBLOCK;
4105                 resp->status = NFS3ERR_JUKEBOX;
4106         } else
4107                 resp->status = puterrno3(error);
4108 out1:
4109         DTRACE_NFSV3_4(op__commit__done, struct svc_req *, req,
4110             cred_t *, cr, vnode_t *, vp, COMMIT3res *, resp);
4111 
4112         if (vp != NULL)
4113                 VN_RELE(vp);
4114         vattr_to_wcc_data(bvap, avap, &resp->resfail.file_wcc);
4115 }
4116 
4117 void *
4118 rfs3_commit_getfh(COMMIT3args *args)
4119 {
4120 
4121         return (&args->file);
4122 }
4123 
4124 static int
4125 sattr3_to_vattr(sattr3 *sap, struct vattr *vap)
4126 {
4127 
4128         vap->va_mask = 0;
4129 
4130         if (sap->mode.set_it) {
4131                 vap->va_mode = (mode_t)sap->mode.mode;
4132                 vap->va_mask |= AT_MODE;
4133         }
4134         if (sap->uid.set_it) {
4135                 vap->va_uid = (uid_t)sap->uid.uid;
4136                 vap->va_mask |= AT_UID;
4137         }
4138         if (sap->gid.set_it) {
4139                 vap->va_gid = (gid_t)sap->gid.gid;
4140                 vap->va_mask |= AT_GID;
4141         }
4142         if (sap->size.set_it) {
4143                 if (sap->size.size > (size3)((u_longlong_t)-1))
4144                         return (EINVAL);
4145                 vap->va_size = sap->size.size;
4146                 vap->va_mask |= AT_SIZE;
4147         }
4148         if (sap->atime.set_it == SET_TO_CLIENT_TIME) {
4149 #ifndef _LP64
4150                 /* check time validity */
4151                 if (!NFS3_TIME_OK(sap->atime.atime.seconds))
4152                         return (EOVERFLOW);
4153 #endif
4154                 /*
4155                  * nfs protocol defines times as unsigned so don't extend sign,
4156                  * unless sysadmin set nfs_allow_preepoch_time.
4157                  */
4158                 NFS_TIME_T_CONVERT(vap->va_atime.tv_sec,
4159                     sap->atime.atime.seconds);
4160                 vap->va_atime.tv_nsec = (uint32_t)sap->atime.atime.nseconds;
4161                 vap->va_mask |= AT_ATIME;
4162         } else if (sap->atime.set_it == SET_TO_SERVER_TIME) {
4163                 gethrestime(&vap->va_atime);
4164                 vap->va_mask |= AT_ATIME;
4165         }
4166         if (sap->mtime.set_it == SET_TO_CLIENT_TIME) {
4167 #ifndef _LP64
4168                 /* check time validity */
4169                 if (!NFS3_TIME_OK(sap->mtime.mtime.seconds))
4170                         return (EOVERFLOW);
4171 #endif
4172                 /*
4173                  * nfs protocol defines times as unsigned so don't extend sign,
4174                  * unless sysadmin set nfs_allow_preepoch_time.
4175                  */
4176                 NFS_TIME_T_CONVERT(vap->va_mtime.tv_sec,
4177                     sap->mtime.mtime.seconds);
4178                 vap->va_mtime.tv_nsec = (uint32_t)sap->mtime.mtime.nseconds;
4179                 vap->va_mask |= AT_MTIME;
4180         } else if (sap->mtime.set_it == SET_TO_SERVER_TIME) {
4181                 gethrestime(&vap->va_mtime);
4182                 vap->va_mask |= AT_MTIME;
4183         }
4184 
4185         return (0);
4186 }
4187 
4188 static ftype3 vt_to_nf3[] = {
4189         0, NF3REG, NF3DIR, NF3BLK, NF3CHR, NF3LNK, NF3FIFO, 0, 0, NF3SOCK, 0
4190 };
4191 
4192 static int
4193 vattr_to_fattr3(struct vattr *vap, fattr3 *fap)
4194 {
4195 
4196         ASSERT(vap->va_type >= VNON && vap->va_type <= VBAD);
4197         /* Return error if time or size overflow */
4198         if (! (NFS_VAP_TIME_OK(vap) && NFS3_SIZE_OK(vap->va_size))) {
4199                 return (EOVERFLOW);
4200         }
4201         fap->type = vt_to_nf3[vap->va_type];
4202         fap->mode = (mode3)(vap->va_mode & MODEMASK);
4203         fap->nlink = (uint32)vap->va_nlink;
4204         if (vap->va_uid == UID_NOBODY)
4205                 fap->uid = (uid3)NFS_UID_NOBODY;
4206         else
4207                 fap->uid = (uid3)vap->va_uid;
4208         if (vap->va_gid == GID_NOBODY)
4209                 fap->gid = (gid3)NFS_GID_NOBODY;
4210         else
4211                 fap->gid = (gid3)vap->va_gid;
4212         fap->size = (size3)vap->va_size;
4213         fap->used = (size3)DEV_BSIZE * (size3)vap->va_nblocks;
4214         fap->rdev.specdata1 = (uint32)getmajor(vap->va_rdev);
4215         fap->rdev.specdata2 = (uint32)getminor(vap->va_rdev);
4216         fap->fsid = (uint64)vap->va_fsid;
4217         fap->fileid = (fileid3)vap->va_nodeid;
4218         fap->atime.seconds = vap->va_atime.tv_sec;
4219         fap->atime.nseconds = vap->va_atime.tv_nsec;
4220         fap->mtime.seconds = vap->va_mtime.tv_sec;
4221         fap->mtime.nseconds = vap->va_mtime.tv_nsec;
4222         fap->ctime.seconds = vap->va_ctime.tv_sec;
4223         fap->ctime.nseconds = vap->va_ctime.tv_nsec;
4224         return (0);
4225 }
4226 
4227 static int
4228 vattr_to_wcc_attr(struct vattr *vap, wcc_attr *wccap)
4229 {
4230 
4231         /* Return error if time or size overflow */
4232         if (!(NFS_TIME_T_OK(vap->va_mtime.tv_sec) &&
4233             NFS_TIME_T_OK(vap->va_ctime.tv_sec) &&
4234             NFS3_SIZE_OK(vap->va_size))) {
4235                 return (EOVERFLOW);
4236         }
4237         wccap->size = (size3)vap->va_size;
4238         wccap->mtime.seconds = vap->va_mtime.tv_sec;
4239         wccap->mtime.nseconds = vap->va_mtime.tv_nsec;
4240         wccap->ctime.seconds = vap->va_ctime.tv_sec;
4241         wccap->ctime.nseconds = vap->va_ctime.tv_nsec;
4242         return (0);
4243 }
4244 
4245 static void
4246 vattr_to_pre_op_attr(struct vattr *vap, pre_op_attr *poap)
4247 {
4248 
4249         /* don't return attrs if time overflow */
4250         if ((vap != NULL) && !vattr_to_wcc_attr(vap, &poap->attr)) {
4251                 poap->attributes = TRUE;
4252         } else
4253                 poap->attributes = FALSE;
4254 }
4255 
4256 void
4257 vattr_to_post_op_attr(struct vattr *vap, post_op_attr *poap)
4258 {
4259 
4260         /* don't return attrs if time overflow */
4261         if ((vap != NULL) && !vattr_to_fattr3(vap, &poap->attr)) {
4262                 poap->attributes = TRUE;
4263         } else
4264                 poap->attributes = FALSE;
4265 }
4266 
4267 static void
4268 vattr_to_wcc_data(struct vattr *bvap, struct vattr *avap, wcc_data *wccp)
4269 {
4270 
4271         vattr_to_pre_op_attr(bvap, &wccp->before);
4272         vattr_to_post_op_attr(avap, &wccp->after);
4273 }
4274 
4275 void
4276 rfs3_srvrinit(void)
4277 {
4278         struct rfs3_verf_overlay {
4279                 uint_t id; /* a "unique" identifier */
4280                 int ts; /* a unique timestamp */
4281         } *verfp;
4282         timestruc_t now;
4283 
4284         /*
4285          * The following algorithm attempts to find a unique verifier
4286          * to be used as the write verifier returned from the server
4287          * to the client.  It is important that this verifier change
4288          * whenever the server reboots.  Of secondary importance, it
4289          * is important for the verifier to be unique between two
4290          * different servers.
4291          *
4292          * Thus, an attempt is made to use the system hostid and the
4293          * current time in seconds when the nfssrv kernel module is
4294          * loaded.  It is assumed that an NFS server will not be able
4295          * to boot and then to reboot in less than a second.  If the
4296          * hostid has not been set, then the current high resolution
4297          * time is used.  This will ensure different verifiers each
4298          * time the server reboots and minimize the chances that two
4299          * different servers will have the same verifier.
4300          */
4301 
4302 #ifndef lint
4303         /*
4304          * We ASSERT that this constant logic expression is
4305          * always true because in the past, it wasn't.
4306          */
4307         ASSERT(sizeof (*verfp) <= sizeof (write3verf));
4308 #endif
4309 
4310         gethrestime(&now);
4311         verfp = (struct rfs3_verf_overlay *)&write3verf;
4312         verfp->ts = (int)now.tv_sec;
4313         verfp->id = zone_get_hostid(NULL);
4314 
4315         if (verfp->id == 0)
4316                 verfp->id = (uint_t)now.tv_nsec;
4317 
4318         nfs3_srv_caller_id = fs_new_caller_id();
4319 
4320 }
4321 
4322 static int
4323 rdma_setup_read_data3(READ3args *args, READ3resok *rok)
4324 {
4325         struct clist    *wcl;
4326         int             wlist_len;
4327         count3          count = rok->count;
4328 
4329         wcl = args->wlist;
4330         if (rdma_setup_read_chunks(wcl, count, &wlist_len) == FALSE) {
4331                 return (FALSE);
4332         }
4333 
4334         wcl = args->wlist;
4335         rok->wlist_len = wlist_len;
4336         rok->wlist = wcl;
4337         return (TRUE);
4338 }
4339 
4340 void
4341 rfs3_srvrfini(void)
4342 {
4343         /* Nothing to do */
4344 }