kernel/fs/nfs/nfs_acl_vnops.c

   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, Version 1.0 only
   6  * (the "License").  You may not use this file except in compliance
   7  * with the License.
   8  *
   9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  10  * or http://www.opensolaris.org/os/licensing.
  11  * See the License for the specific language governing permissions
  12  * and limitations under the License.
  13  *
  14  * When distributing Covered Code, include this CDDL HEADER in each
  15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  16  * If applicable, add the following below this CDDL HEADER, with the
  17  * fields enclosed by brackets "[]" replaced with your own identifying
  18  * information: Portions Copyright [yyyy] [name of copyright owner]
  19  *
  20  * CDDL HEADER END
  21  */
  22 /*
  23  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 #pragma ident   "%Z%%M% %I%     %E% SMI"
  28
  29 #include <sys/param.h>
  30 #include <sys/types.h>
  31 #include <sys/systm.h>
  32 #include <sys/cred.h>
  33 #include <sys/proc.h>
  34 #include <sys/user.h>
  35 #include <sys/time.h>
  36 #include <sys/vnode.h>
  37 #include <sys/vfs.h>
  38 #include <sys/file.h>
  39 #include <sys/uio.h>
  40 #include <sys/buf.h>
  41 #include <sys/mman.h>
  42 #include <sys/tiuser.h>
  43 #include <sys/pathname.h>
  44 #include <sys/dirent.h>
  45 #include <sys/conf.h>
  46 #include <sys/debug.h>
  47 #include <sys/unistd.h>
  48 #include <sys/vmsystm.h>
  49 #include <sys/fcntl.h>
  50 #include <sys/flock.h>
  51 #include <sys/swap.h>
  52 #include <sys/errno.h>
  53 #include <sys/sysmacros.h>
  54 #include <sys/disp.h>
  55 #include <sys/kmem.h>
  56 #include <sys/cmn_err.h>
  57 #include <sys/vtrace.h>
  58 #include <sys/pathconf.h>
  59 #include <sys/dnlc.h>
  60 #include <sys/acl.h>
  61
  62 #include <rpc/types.h>
  63 #include <rpc/auth.h>
  64 #include <rpc/clnt.h>
  65 #include <rpc/xdr.h>
  66 #include <nfs/nfs.h>
  67 #include <nfs/nfs_clnt.h>
  68 #include <nfs/rnode.h>
  69 #include <nfs/nfs_acl.h>
  70
  71 #include <vm/hat.h>
  72 #include <vm/as.h>
  73 #include <vm/page.h>
  74 #include <vm/pvn.h>
  75 #include <vm/seg.h>
  76 #include <vm/seg_map.h>
  77 #include <vm/seg_kmem.h>
  78 #include <vm/seg_vn.h>
  79 #include <vm/rm.h>
  80
  81 #include <sys/fs_subr.h>
  82
  83 /*
  84  * The order and contents of this structure must be kept in sync with that of
  85  * aclreqcnt_v2_tmpl in nfs_stats.c
  86  */
  87 char *aclnames_v2[] = {
  88         "null", "getacl", "setacl", "getattr", "access", "getxattrdir"
  89 };
  90
  91 /*
  92  * This table maps from NFS protocol number into call type.
  93  * Zero means a "Lookup" type call
  94  * One  means a "Read" type call
  95  * Two  means a "Write" type call
  96  * This is used to select a default time-out.
  97  */
  98 uchar_t acl_call_type_v2[] = {
  99         0, 0, 1, 0, 0, 0
 100 };
 101
 102 /*
 103  * Similar table, but to determine which timer to use
 104  * (only real reads and writes!)
 105  */
 106 uchar_t acl_timer_type_v2[] = {
 107         0, 0, 0, 0, 0, 0
 108 };
 109
 110 /*
 111  * This table maps from acl operation into a call type
 112  * for the semisoft mount option.
 113  * Zero means do not repeat operation.
 114  * One  means repeat.
 115  */
 116 uchar_t acl_ss_call_type_v2[] = {
 117         0, 0, 1, 0, 0, 0
 118 };
 119
 120 static int nfs_acl_dup_cache(vsecattr_t *, vsecattr_t *);
 121 static void nfs_acl_dup_res(rnode_t *, vsecattr_t *);
 122
 123 /* ARGSUSED */
 124 int
 125 acl_getacl2(vnode_t *vp, vsecattr_t *vsp, int flag, cred_t *cr)
 126 {
 127         int error;
 128         GETACL2args args;
 129         GETACL2res res;
 130         int doqueue;
 131         vattr_t va;
 132         rnode_t *rp;
 133         failinfo_t fi;
 134         hrtime_t t;
 135
 136         rp = VTOR(vp);
 137         if (rp->r_secattr != NULL) {
 138                 error = nfs_validate_caches(vp, cr);
 139                 if (error)
 140                         return (error);
 141                 mutex_enter(&rp->r_statelock);
 142                 if (rp->r_secattr != NULL) {
 143                         if (nfs_acl_dup_cache(vsp, rp->r_secattr)) {
 144                                 mutex_exit(&rp->r_statelock);
 145                                 return (0);
 146                         }
 147                 }
 148                 mutex_exit(&rp->r_statelock);
 149         }
 150
 151         args.mask = vsp->vsa_mask;
 152         args.fh = *VTOFH(vp);
 153         fi.vp = vp;
 154         fi.fhp = (caddr_t)&args.fh;
 155         fi.copyproc = nfscopyfh;
 156         fi.lookupproc = nfslookup;
 157         fi.xattrdirproc = acl_getxattrdir2;
 158
 159         res.resok.acl.vsa_aclentp = NULL;
 160         res.resok.acl.vsa_dfaclentp = NULL;
 161
 162         doqueue = 1;
 163
 164         t = gethrtime();
 165
 166         error = acl2call(VTOMI(vp), ACLPROC2_GETACL,
 167             xdr_GETACL2args, (caddr_t)&args,
 168             xdr_GETACL2res, (caddr_t)&res, cr,
 169             &doqueue, &res.status, 0, &fi);
 170
 171         if (error)
 172                 return (error);
 173
 174         error = geterrno(res.status);
 175         if (!error) {
 176                 (void) nfs_cache_fattr(vp, &res.resok.attr, &va, t, cr);
 177                 nfs_acl_dup_res(rp, &res.resok.acl);
 178                 *vsp = res.resok.acl;
 179         } else {
 180                 PURGE_STALE_FH(error, vp, cr);
 181         }
 182
 183         return (error);
 184 }
 185
 186 /* ARGSUSED */
 187 int
 188 acl_setacl2(vnode_t *vp, vsecattr_t *vsp, int flag, cred_t *cr)
 189 {
 190         int error;
 191         SETACL2args args;
 192         SETACL2res res;
 193         int doqueue;
 194         vattr_t va;
 195         rnode_t *rp;
 196         hrtime_t t;
 197
 198         args.fh = *VTOFH(vp);
 199         args.acl = *vsp;
 200
 201         doqueue = 1;
 202
 203         t = gethrtime();
 204
 205         error = acl2call(VTOMI(vp), ACLPROC2_SETACL,
 206             xdr_SETACL2args, (caddr_t)&args,
 207             xdr_SETACL2res, (caddr_t)&res, cr,
 208             &doqueue, &res.status, 0, NULL);
 209
 210         /*
 211          * On success, adding the arguments to setsecattr into the cache have
 212          * not proven adequate.  On error, we cannot depend on cache.
 213          * Simply flush the cache to force the next getsecattr
 214          * to go over the wire.
 215          */
 216         rp = VTOR(vp);
 217         mutex_enter(&rp->r_statelock);
 218         if (rp->r_secattr != NULL) {
 219                 nfs_acl_free(rp->r_secattr);
 220                 rp->r_secattr = NULL;
 221         }
 222         mutex_exit(&rp->r_statelock);
 223
 224         if (error)
 225                 return (error);
 226
 227         error = geterrno(res.status);
 228         if (!error) {
 229                 (void) nfs_cache_fattr(vp, &res.resok.attr, &va, t, cr);
 230         } else {
 231                 PURGE_STALE_FH(error, vp, cr);
 232         }
 233
 234         return (error);
 235 }
 236
 237 int
 238 acl_getattr2_otw(vnode_t *vp, vattr_t *vap, cred_t *cr)
 239 {
 240         int error;
 241         GETATTR2args args;
 242         GETATTR2res res;
 243         int doqueue;
 244         failinfo_t fi;
 245         hrtime_t t;
 246
 247         args.fh = *VTOFH(vp);
 248         fi.vp = vp;
 249         fi.fhp = (caddr_t)&args.fh;
 250         fi.copyproc = nfscopyfh;
 251         fi.lookupproc = nfslookup;
 252         fi.xattrdirproc = acl_getxattrdir2;
 253
 254         doqueue = 1;
 255
 256         t = gethrtime();
 257
 258         error = acl2call(VTOMI(vp), ACLPROC2_GETATTR,
 259             xdr_GETATTR2args, (caddr_t)&args,
 260             xdr_GETATTR2res, (caddr_t)&res, cr,
 261             &doqueue, &res.status, 0, &fi);
 262
 263         if (error)
 264                 return (error);
 265         error = geterrno(res.status);
 266
 267         if (!error) {
 268                 error = nfs_cache_fattr(vp, &res.resok.attr, vap, t, cr);
 269         } else {
 270                 PURGE_STALE_FH(error, vp, cr);
 271         }
 272
 273         return (error);
 274 }
 275
 276 /* ARGSUSED */
 277 int
 278 acl_access2(vnode_t *vp, int mode, int flags, cred_t *cr)
 279 {
 280         int error;
 281         ACCESS2args args;
 282         ACCESS2res res;
 283         int doqueue;
 284         uint32 acc;
 285         rnode_t *rp;
 286         cred_t *cred, *ncr, *ncrfree = NULL;
 287         vattr_t va;
 288         failinfo_t fi;
 289         nfs_access_type_t cacc;
 290         hrtime_t t;
 291
 292         acc = 0;
 293         if (mode & VREAD)
 294                 acc |= ACCESS2_READ;
 295         if (mode & VWRITE) {
 296                 if (vn_is_readonly(vp) && !IS_DEVVP(vp))
 297                         return (EROFS);
 298                 if (vp->v_type == VDIR)
 299                         acc |= ACCESS2_DELETE;
 300                 acc |= ACCESS2_MODIFY | ACCESS2_EXTEND;
 301         }
 302         if (mode & VEXEC) {
 303                 if (vp->v_type == VDIR)
 304                         acc |= ACCESS2_LOOKUP;
 305                 else
 306                         acc |= ACCESS2_EXECUTE;
 307         }
 308
 309         rp = VTOR(vp);
 310         if (vp->v_type == VDIR) {
 311                 args.access = ACCESS2_READ | ACCESS2_DELETE | ACCESS2_MODIFY |
 312                     ACCESS2_EXTEND | ACCESS2_LOOKUP;
 313         } else {
 314                 args.access = ACCESS2_READ | ACCESS2_MODIFY | ACCESS2_EXTEND |
 315                     ACCESS2_EXECUTE;
 316         }
 317         args.fh = *VTOFH(vp);
 318         fi.vp = vp;
 319         fi.fhp = (caddr_t)&args.fh;
 320         fi.copyproc = nfscopyfh;
 321         fi.lookupproc = nfslookup;
 322         fi.xattrdirproc = acl_getxattrdir2;
 323
 324         cred = cr;
 325         /*
 326          * ncr and ncrfree both initially
 327          * point to the memory area returned
 328          * by crnetadjust();
 329          * ncrfree not NULL when exiting means
 330          * that we need to release it
 331          */
 332         ncr = crnetadjust(cred);
 333         ncrfree = ncr;
 334
 335 tryagain:
 336         if (rp->r_acache != NULL) {
 337                 cacc = nfs_access_check(rp, acc, cr);
 338                 if (cacc == NFS_ACCESS_ALLOWED) {
 339                         if (ncrfree != NULL)
 340                                 crfree(ncrfree);
 341                         return (0);
 342                 }
 343                 if (cacc == NFS_ACCESS_DENIED) {
 344                         /*
 345                          * If the cred can be adjusted, try again
 346                          * with the new cred.
 347                          */
 348                         if (ncr != NULL) {
 349                                 cred = ncr;
 350                                 ncr = NULL;
 351                                 goto tryagain;
 352                         }
 353                         if (ncrfree != NULL)
 354                                 crfree(ncrfree);
 355                         return (EACCES);
 356                 }
 357         }
 358
 359         doqueue = 1;
 360
 361         t = gethrtime();
 362
 363         error = acl2call(VTOMI(vp), ACLPROC2_ACCESS,
 364             xdr_ACCESS2args, (caddr_t)&args,
 365             xdr_ACCESS2res, (caddr_t)&res, cred,
 366             &doqueue, &res.status, 0, &fi);
 367
 368         if (error) {
 369                 if (ncrfree != NULL)
 370                         crfree(ncrfree);
 371                 return (error);
 372         }
 373
 374         error = geterrno(res.status);
 375         if (!error) {
 376                 (void) nfs_cache_fattr(vp, &res.resok.attr, &va, t, cr);
 377                 nfs_access_cache(rp, args.access, res.resok.access, cred);
 378                 /*
 379                  * we just cached results with cred; if cred is the
 380                  * adjusted credentials from crnetadjust, we do not want
 381                  * to release them before exiting: hence setting ncrfree
 382                  * to NULL
 383                  */
 384                 if (cred != cr)
 385                         ncrfree = NULL;
 386                 if ((acc & res.resok.access) != acc) {
 387                         /*
 388                          * If the cred can be adjusted, try again
 389                          * with the new cred.
 390                          */
 391                         if (ncr != NULL) {
 392                                 cred = ncr;
 393                                 ncr = NULL;
 394                                 goto tryagain;
 395                         }
 396                         error = EACCES;
 397                 }
 398         } else {
 399                 PURGE_STALE_FH(error, vp, cr);
 400         }
 401
 402         if (ncrfree != NULL)
 403                 crfree(ncrfree);
 404
 405         return (error);
 406 }
 407
 408 static int xattr_lookup_neg_cache = 1;
 409
 410 /*
 411  * Look up a hidden attribute directory over the wire; the vnode
 412  * we start with could be a file or directory.  We have to be
 413  * tricky in recording the name in the rnode r_path - we use the
 414  * magic name XATTR_RPATH and rely on code in failover_lookup() to
 415  * detect this and use this routine to do the same lookup on
 416  * remapping.  DNLC is easier: slashes are legal, so we use
 417  * XATTR_DIR_NAME as UFS does.
 418  */
 419 int
 420 acl_getxattrdir2(vnode_t *vp, vnode_t **vpp, bool_t create, cred_t *cr,
 421         int rfscall_flags)
 422 {
 423         int error;
 424         GETXATTRDIR2args args;
 425         GETXATTRDIR2res res;
 426         int doqueue;
 427         failinfo_t fi;
 428         hrtime_t t;
 429
 430         args.fh = *VTOFH(vp);
 431         args.create = create;
 432
 433         fi.vp = vp;
 434         fi.fhp = NULL;          /* no need to update, filehandle not copied */
 435         fi.copyproc = nfscopyfh;
 436         fi.lookupproc = nfslookup;
 437         fi.xattrdirproc = acl_getxattrdir2;
 438
 439         doqueue = 1;
 440
 441         t = gethrtime();
 442
 443         error = acl2call(VTOMI(vp), ACLPROC2_GETXATTRDIR,
 444             xdr_GETXATTRDIR2args, (caddr_t)&args,
 445             xdr_GETXATTRDIR2res, (caddr_t)&res, cr,
 446             &doqueue, &res.status, rfscall_flags, &fi);
 447
 448         if (!error) {
 449                 error = geterrno(res.status);
 450                 if (!error) {
 451                         *vpp = makenfsnode(&res.resok.fh, &res.resok.attr,
 452                             vp->v_vfsp, t, cr, VTOR(vp)->r_path, XATTR_RPATH);
 453                         mutex_enter(&(*vpp)->v_lock);
 454                         (*vpp)->v_flag |= V_XATTRDIR;
 455                         mutex_exit(&(*vpp)->v_lock);
 456                         if (!(rfscall_flags & RFSCALL_SOFT))
 457                                 dnlc_update(vp, XATTR_DIR_NAME, *vpp);
 458                 } else {
 459                         PURGE_STALE_FH(error, vp, cr);
 460                         if (error == ENOENT && xattr_lookup_neg_cache)
 461                                 dnlc_enter(vp, XATTR_DIR_NAME, DNLC_NO_VNODE);
 462                 }
 463         }
 464         return (error);
 465 }
 466
 467 /*
 468  * The order and contents of this structure must be kept in sync with that of
 469  * aclreqcnt_v3_tmpl in nfs_stats.c
 470  */
 471 char *aclnames_v3[] = {
 472         "null", "getacl", "setacl", "getxattrdir"
 473 };
 474
 475 /*
 476  * This table maps from NFS protocol number into call type.
 477  * Zero means a "Lookup" type call
 478  * One  means a "Read" type call
 479  * Two  means a "Write" type call
 480  * This is used to select a default time-out.
 481  */
 482 uchar_t acl_call_type_v3[] = {
 483         0, 0, 1, 0
 484 };
 485
 486 /*
 487  * This table maps from acl operation into a call type
 488  * for the semisoft mount option.
 489  * Zero means do not repeat operation.
 490  * One  means repeat.
 491  */
 492 uchar_t acl_ss_call_type_v3[] = {
 493         0, 0, 1, 0
 494 };
 495
 496 /*
 497  * Similar table, but to determine which timer to use
 498  * (only real reads and writes!)
 499  */
 500 uchar_t acl_timer_type_v3[] = {
 501         0, 0, 0, 0
 502 };
 503
 504 /* ARGSUSED */
 505 int
 506 acl_getacl3(vnode_t *vp, vsecattr_t *vsp, int flag, cred_t *cr)
 507 {
 508         int error;
 509         GETACL3args args;
 510         GETACL3res res;
 511         int doqueue;
 512         rnode_t *rp;
 513         failinfo_t fi;
 514         hrtime_t t;
 515
 516         rp = VTOR(vp);
 517         if (rp->r_secattr != NULL) {
 518                 error = nfs3_validate_caches(vp, cr);
 519                 if (error)
 520                         return (error);
 521                 mutex_enter(&rp->r_statelock);
 522                 if (rp->r_secattr != NULL) {
 523                         if (nfs_acl_dup_cache(vsp, rp->r_secattr)) {
 524                                 mutex_exit(&rp->r_statelock);
 525                                 return (0);
 526                         }
 527                 }
 528                 mutex_exit(&rp->r_statelock);
 529         }
 530
 531         args.mask = vsp->vsa_mask;
 532         args.fh = *VTOFH3(vp);
 533         fi.vp = vp;
 534         fi.fhp = (caddr_t)&args.fh;
 535         fi.copyproc = nfs3copyfh;
 536         fi.lookupproc = nfs3lookup;
 537         fi.xattrdirproc = acl_getxattrdir3;
 538
 539         res.resok.acl.vsa_aclentp = NULL;
 540         res.resok.acl.vsa_dfaclentp = NULL;
 541
 542         doqueue = 1;
 543
 544         t = gethrtime();
 545
 546         error = acl3call(VTOMI(vp), ACLPROC3_GETACL,
 547             xdr_GETACL3args, (caddr_t)&args,
 548             xdr_GETACL3res, (caddr_t)&res, cr,
 549             &doqueue, &res.status, 0, &fi);
 550
 551         if (error)
 552                 return (error);
 553
 554         error = geterrno3(res.status);
 555
 556         if (!error) {
 557                 nfs3_cache_post_op_attr(vp, &res.resok.attr, t, cr);
 558                 nfs_acl_dup_res(rp, &res.resok.acl);
 559                 *vsp = res.resok.acl;
 560         } else {
 561                 nfs3_cache_post_op_attr(vp, &res.resfail.attr, t, cr);
 562                 PURGE_STALE_FH(error, vp, cr);
 563         }
 564
 565         return (error);
 566 }
 567
 568 /* ARGSUSED */
 569 int
 570 acl_setacl3(vnode_t *vp, vsecattr_t *vsp, int flag, cred_t *cr)
 571 {
 572         int error;
 573         SETACL3args args;
 574         SETACL3res res;
 575         rnode_t *rp;
 576         int doqueue;
 577         hrtime_t t;
 578
 579         args.fh = *VTOFH3(vp);
 580         args.acl = *vsp;
 581
 582         doqueue = 1;
 583
 584         t = gethrtime();
 585
 586         error = acl3call(VTOMI(vp), ACLPROC3_SETACL,
 587             xdr_SETACL3args, (caddr_t)&args,
 588             xdr_SETACL3res, (caddr_t)&res, cr,
 589             &doqueue, &res.status, 0, NULL);
 590
 591         /*
 592          * On success, adding the arguments to setsecattr into the cache have
 593          * not proven adequate.  On error, we cannot depend on cache.
 594          * Simply flush the cache to force the next getsecattr
 595          * to go over the wire.
 596          */
 597         rp = VTOR(vp);
 598         mutex_enter(&rp->r_statelock);
 599         if (rp->r_secattr != NULL) {
 600                 nfs_acl_free(rp->r_secattr);
 601                 rp->r_secattr = NULL;
 602         }
 603         mutex_exit(&rp->r_statelock);
 604
 605         if (error)
 606                 return (error);
 607
 608         error = geterrno3(res.status);
 609         if (!error) {
 610                 nfs3_cache_post_op_attr(vp, &res.resok.attr, t, cr);
 611         } else {
 612                 nfs3_cache_post_op_attr(vp, &res.resfail.attr, t, cr);
 613                 PURGE_STALE_FH(error, vp, cr);
 614         }
 615
 616         return (error);
 617 }
 618
 619 int
 620 acl_getxattrdir3(vnode_t *vp, vnode_t **vpp, bool_t create, cred_t *cr,
 621         int rfscall_flags)
 622 {
 623         int error;
 624         GETXATTRDIR3args args;
 625         GETXATTRDIR3res res;
 626         int doqueue;
 627         struct vattr vattr;
 628         vnode_t *nvp;
 629         failinfo_t fi;
 630         hrtime_t t;
 631
 632         args.fh = *VTOFH3(vp);
 633         args.create = create;
 634
 635         fi.vp = vp;
 636         fi.fhp = (caddr_t)&args.fh;
 637         fi.copyproc = nfs3copyfh;
 638         fi.lookupproc = nfs3lookup;
 639         fi.xattrdirproc = acl_getxattrdir3;
 640
 641         doqueue = 1;
 642
 643         t = gethrtime();
 644
 645         error = acl3call(VTOMI(vp), ACLPROC3_GETXATTRDIR,
 646             xdr_GETXATTRDIR3args, (caddr_t)&args,
 647             xdr_GETXATTRDIR3res, (caddr_t)&res, cr,
 648             &doqueue, &res.status, rfscall_flags, &fi);
 649
 650         if (error)
 651                 return (error);
 652
 653         error = geterrno3(res.status);
 654         if (!error) {
 655                 if (res.resok.attr.attributes) {
 656                         nvp = makenfs3node(&res.resok.fh,
 657                             &res.resok.attr.attr,
 658                             vp->v_vfsp, t, cr, VTOR(vp)->r_path, XATTR_RPATH);
 659                 } else {
 660                         nvp = makenfs3node(&res.resok.fh, NULL,
 661                             vp->v_vfsp, t, cr, VTOR(vp)->r_path, XATTR_RPATH);
 662                         if (nvp->v_type == VNON) {
 663                                 vattr.va_mask = AT_TYPE;
 664                                 error = nfs3getattr(nvp, &vattr, cr);
 665                                 if (error) {
 666                                         VN_RELE(nvp);
 667                                         return (error);
 668                                 }
 669                                 nvp->v_type = vattr.va_type;
 670                         }
 671                 }
 672                 mutex_enter(&nvp->v_lock);
 673                 nvp->v_flag |= V_XATTRDIR;
 674                 mutex_exit(&nvp->v_lock);
 675                 if (!(rfscall_flags & RFSCALL_SOFT))
 676                         dnlc_update(vp, XATTR_DIR_NAME, nvp);
 677                 *vpp = nvp;
 678         } else {
 679                 PURGE_STALE_FH(error, vp, cr);
 680                 if (error == ENOENT && xattr_lookup_neg_cache)
 681                         dnlc_enter(vp, XATTR_DIR_NAME, DNLC_NO_VNODE);
 682         }
 683
 684         return (error);
 685 }
 686
 687 void
 688 nfs_acl_free(vsecattr_t *vsp)
 689 {
 690
 691         if (vsp->vsa_aclentp != NULL) {
 692                 kmem_free(vsp->vsa_aclentp, vsp->vsa_aclcnt *
 693                     sizeof (aclent_t));
 694         }
 695         if (vsp->vsa_dfaclentp != NULL) {
 696                 kmem_free(vsp->vsa_dfaclentp, vsp->vsa_dfaclcnt *
 697                     sizeof (aclent_t));
 698         }
 699         kmem_free(vsp, sizeof (*vsp));
 700 }
 701
 702 static int
 703 nfs_acl_dup_cache(vsecattr_t *vsp, vsecattr_t *rvsp)
 704 {
 705         size_t aclsize;
 706
 707         if ((rvsp->vsa_mask & vsp->vsa_mask) != vsp->vsa_mask)
 708                 return (0);
 709
 710         if (vsp->vsa_mask & VSA_ACL) {
 711                 ASSERT(rvsp->vsa_mask & VSA_ACLCNT);
 712                 aclsize = rvsp->vsa_aclcnt * sizeof (aclent_t);
 713                 vsp->vsa_aclentp = kmem_alloc(aclsize, KM_SLEEP);
 714                 bcopy(rvsp->vsa_aclentp, vsp->vsa_aclentp, aclsize);
 715         }
 716         if (vsp->vsa_mask & VSA_ACLCNT)
 717                 vsp->vsa_aclcnt = rvsp->vsa_aclcnt;
 718         if (vsp->vsa_mask & VSA_DFACL) {
 719                 ASSERT(rvsp->vsa_mask & VSA_DFACLCNT);
 720                 aclsize = rvsp->vsa_dfaclcnt * sizeof (aclent_t);
 721                 vsp->vsa_dfaclentp = kmem_alloc(aclsize, KM_SLEEP);
 722                 bcopy(rvsp->vsa_dfaclentp, vsp->vsa_dfaclentp, aclsize);
 723         }
 724         if (vsp->vsa_mask & VSA_DFACLCNT)
 725                 vsp->vsa_dfaclcnt = rvsp->vsa_dfaclcnt;
 726
 727         return (1);
 728 }
 729
 730 static void
 731 nfs_acl_dup_res_impl(kmutex_t *statelock, vsecattr_t **rspp, vsecattr_t *vsp)
 732 {
 733         size_t aclsize;
 734         vsecattr_t *rvsp;
 735
 736         mutex_enter(statelock);
 737         if (*rspp != NULL)
 738                 rvsp = *rspp;
 739         else {
 740                 rvsp = kmem_zalloc(sizeof (*rvsp), KM_NOSLEEP);
 741                 if (rvsp == NULL) {
 742                         mutex_exit(statelock);
 743                         return;
 744                 }
 745                 *rspp = rvsp;
 746         }
 747
 748         if (vsp->vsa_mask & VSA_ACL) {
 749                 if (rvsp->vsa_aclentp != NULL &&
 750                     rvsp->vsa_aclcnt != vsp->vsa_aclcnt) {
 751                         aclsize = rvsp->vsa_aclcnt * sizeof (aclent_t);
 752                         kmem_free(rvsp->vsa_aclentp, aclsize);
 753                         rvsp->vsa_aclentp = NULL;
 754                 }
 755                 if (vsp->vsa_aclcnt > 0) {
 756                         aclsize = vsp->vsa_aclcnt * sizeof (aclent_t);
 757                         if (rvsp->vsa_aclentp == NULL) {
 758                                 rvsp->vsa_aclentp = kmem_alloc(aclsize,
 759                                     KM_SLEEP);
 760                         }
 761                         bcopy(vsp->vsa_aclentp, rvsp->vsa_aclentp, aclsize);
 762                 }
 763                 rvsp->vsa_aclcnt = vsp->vsa_aclcnt;
 764                 rvsp->vsa_mask |= VSA_ACL | VSA_ACLCNT;
 765         }
 766         if (vsp->vsa_mask & VSA_ACLCNT) {
 767                 if (rvsp->vsa_aclentp != NULL &&
 768                     rvsp->vsa_aclcnt != vsp->vsa_aclcnt) {
 769                         aclsize = rvsp->vsa_aclcnt * sizeof (aclent_t);
 770                         kmem_free(rvsp->vsa_aclentp, aclsize);
 771                         rvsp->vsa_aclentp = NULL;
 772                         rvsp->vsa_mask &= ~VSA_ACL;
 773                 }
 774                 rvsp->vsa_aclcnt = vsp->vsa_aclcnt;
 775                 rvsp->vsa_mask |= VSA_ACLCNT;
 776         }
 777         if (vsp->vsa_mask & VSA_DFACL) {
 778                 if (rvsp->vsa_dfaclentp != NULL &&
 779                     rvsp->vsa_dfaclcnt != vsp->vsa_dfaclcnt) {
 780                         aclsize = rvsp->vsa_dfaclcnt * sizeof (aclent_t);
 781                         kmem_free(rvsp->vsa_dfaclentp, aclsize);
 782                         rvsp->vsa_dfaclentp = NULL;
 783                 }
 784                 if (vsp->vsa_dfaclcnt > 0) {
 785                         aclsize = vsp->vsa_dfaclcnt * sizeof (aclent_t);
 786                         if (rvsp->vsa_dfaclentp == NULL) {
 787                                 rvsp->vsa_dfaclentp = kmem_alloc(aclsize,
 788                                     KM_SLEEP);
 789                         }
 790                         bcopy(vsp->vsa_dfaclentp, rvsp->vsa_dfaclentp, aclsize);
 791                 }
 792                 rvsp->vsa_dfaclcnt = vsp->vsa_dfaclcnt;
 793                 rvsp->vsa_mask |= VSA_DFACL | VSA_DFACLCNT;
 794         }
 795         if (vsp->vsa_mask & VSA_DFACLCNT) {
 796                 if (rvsp->vsa_dfaclentp != NULL &&
 797                     rvsp->vsa_dfaclcnt != vsp->vsa_dfaclcnt) {
 798                         aclsize = rvsp->vsa_dfaclcnt * sizeof (aclent_t);
 799                         kmem_free(rvsp->vsa_dfaclentp, aclsize);
 800                         rvsp->vsa_dfaclentp = NULL;
 801                         rvsp->vsa_mask &= ~VSA_DFACL;
 802                 }
 803                 rvsp->vsa_dfaclcnt = vsp->vsa_dfaclcnt;
 804                 rvsp->vsa_mask |= VSA_DFACLCNT;
 805         }
 806         mutex_exit(statelock);
 807 }
 808
 809 static void
 810 nfs_acl_dup_res(rnode_t *rp, vsecattr_t *vsp)
 811 {
 812         nfs_acl_dup_res_impl(&rp->r_statelock, &rp->r_secattr, vsp);
 813 }