kernel/fs/nfs/nfs4_srv_attr.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 (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25 /*
  26  * Copyright 2012 Nexenta Systems, Inc. All rights reserved.
  27  */
  28
  29 #include <sys/systm.h>
  30 #include <sys/cmn_err.h>
  31 #include <nfs/nfs.h>
  32 #include <nfs/export.h>
  33 #include <nfs/nfs4.h>
  34 #include <sys/ddi.h>
  35 #include <sys/door.h>
  36 #include <sys/sdt.h>
  37 #include <nfs/nfssys.h>
  38
  39 void    rfs4_init_compound_state(struct compound_state *);
  40
  41 bitmap4 rfs4_supported_attrs;
  42 int MSG_PRT_DEBUG = FALSE;
  43
  44 /* If building with DEBUG enabled, enable mandattr tunable by default */
  45 #ifdef DEBUG
  46 #ifndef RFS4_SUPPORT_MANDATTR_ONLY
  47 #define RFS4_SUPPORT_MANDATTR_ONLY
  48 #endif
  49 #endif
  50
  51 /*
  52  * If building with mandattr only code, disable it by default.
  53  * To enable, set rfs4_mandattr_only in /etc/system and reboot.
  54  * When building without mandattr ifdef, the compiler should
  55  * optimize away the the comparisons because RFS4_MANDATTR_ONLY
  56  * is defined to be 0.
  57  */
  58 #ifdef RFS4_SUPPORT_MANDATTR_ONLY
  59 #define NFS4_LAST_MANDATTR FATTR4_RDATTR_ERROR
  60 #define RFS4_MANDATTR_ONLY rfs4_mandattr_only
  61 int rfs4_mandattr_only = 0;
  62 #else
  63 #define RFS4_MANDATTR_ONLY 0
  64 #endif
  65
  66
  67 static void rfs4_ntov_init(void);
  68 static int rfs4_fattr4_supported_attrs();
  69 static int rfs4_fattr4_type();
  70 static int rfs4_fattr4_fh_expire_type();
  71 static int rfs4_fattr4_change();
  72 static int rfs4_fattr4_size();
  73 static int rfs4_fattr4_link_support();
  74 static int rfs4_fattr4_symlink_support();
  75 static int rfs4_fattr4_named_attr();
  76 static int rfs4_fattr4_fsid();
  77 static int rfs4_fattr4_unique_handles();
  78 static int rfs4_fattr4_lease_time();
  79 static int rfs4_fattr4_rdattr_error();
  80 static int rfs4_fattr4_acl();
  81 static int rfs4_fattr4_aclsupport();
  82 static int rfs4_fattr4_archive();
  83 static int rfs4_fattr4_cansettime();
  84 static int rfs4_fattr4_case_insensitive();
  85 static int rfs4_fattr4_case_preserving();
  86 static int rfs4_fattr4_chown_restricted();
  87 static int rfs4_fattr4_filehandle();
  88 static int rfs4_fattr4_fileid();
  89 static int rfs4_fattr4_files_avail();
  90 static int rfs4_fattr4_files_free();
  91 static int rfs4_fattr4_files_total();
  92 static int rfs4_fattr4_fs_locations();
  93 static int rfs4_fattr4_hidden();
  94 static int rfs4_fattr4_homogeneous();
  95 static int rfs4_fattr4_maxfilesize();
  96 static int rfs4_fattr4_maxlink();
  97 static int rfs4_fattr4_maxname();
  98 static int rfs4_fattr4_maxread();
  99 static int rfs4_fattr4_maxwrite();
 100 static int rfs4_fattr4_mimetype();
 101 static int rfs4_fattr4_mode();
 102 static int rfs4_fattr4_no_trunc();
 103 static int rfs4_fattr4_numlinks();
 104 static int rfs4_fattr4_owner();
 105 static int rfs4_fattr4_owner_group();
 106 static int rfs4_fattr4_quota_avail_hard();
 107 static int rfs4_fattr4_quota_avail_soft();
 108 static int rfs4_fattr4_quota_used();
 109 static int rfs4_fattr4_rawdev();
 110 static int rfs4_fattr4_space_avail();
 111 static int rfs4_fattr4_space_free();
 112 static int rfs4_fattr4_space_total();
 113 static int rfs4_fattr4_space_used();
 114 static int rfs4_fattr4_system();
 115 static int rfs4_fattr4_time_access();
 116 static int rfs4_fattr4_time_access_set();
 117 static int rfs4_fattr4_time_backup();
 118 static int rfs4_fattr4_time_create();
 119 static int rfs4_fattr4_time_delta();
 120 static int rfs4_fattr4_time_metadata();
 121 static int rfs4_fattr4_time_modify();
 122 static int rfs4_fattr4_time_modify_set();
 123
 124 /*
 125  * Initialize the supported attributes
 126  */
 127 void
 128 rfs4_attr_init()
 129 {
 130         int i;
 131         struct nfs4_svgetit_arg sarg;
 132         struct compound_state cs;
 133         struct statvfs64 sb;
 134
 135         rfs4_init_compound_state(&cs);
 136         cs.vp = rootvp;
 137         cs.fh.nfs_fh4_val = NULL;
 138         cs.cr = kcred;
 139
 140         /*
 141          * Get all the supported attributes
 142          */
 143         sarg.op = NFS4ATTR_SUPPORTED;
 144         sarg.cs = &cs;
 145         sarg.vap->va_mask = VATTR_ALL;
 146         sarg.sbp = &sb;
 147         sarg.flag = 0;
 148         sarg.rdattr_error = NFS4_OK;
 149         sarg.rdattr_error_req = FALSE;
 150         sarg.is_referral = B_FALSE;
 151
 152         rfs4_ntov_init();
 153
 154         rfs4_supported_attrs = 0;
 155         for (i = 0; i < NFS4_MAXNUM_ATTRS; i++) {
 156 #ifdef RFS4_SUPPORT_MANDATTR_ONLY
 157                 if (rfs4_mandattr_only == TRUE && i > NFS4_LAST_MANDATTR)
 158                         continue;
 159 #endif
 160                 if ((*nfs4_ntov_map[i].sv_getit)(NFS4ATTR_SUPPORTED,
 161                     &sarg, NULL) == 0) {
 162                         rfs4_supported_attrs |= nfs4_ntov_map[i].fbit;
 163                 }
 164         }
 165 }
 166
 167 /*
 168  * The following rfs4_fattr4_* functions convert between the fattr4
 169  * arguments/attributes and the system (e.g. vattr) values. The following
 170  * commands are currently in use:
 171  *
 172  * NFS4ATTR_SUPPORTED: checks if the attribute in question is supported:
 173  *      sarg.op = SUPPORTED - all supported attrs
 174  *      sarg.op = GETIT - only supported readable attrs
 175  *      sarg.op = SETIT - only supported writable attrs
 176  *
 177  * NFS4ATTR_GETIT: getattr type conversion - convert system values
 178  * (e.g. vattr struct) to fattr4 type values to be returned to the
 179  * user - usually in response to nfsv4 getattr request.
 180  *
 181  * NFS4ATTR_SETIT: convert fattr4 type values to system values to use by
 182  * setattr. Allows only read/write and write attributes,
 183  * even if not supported by the filesystem. Note that ufs only allows setattr
 184  * of owner/group, mode, size, atime/mtime.
 185  *
 186  * NFS4ATTR_VERIT: convert fattr4 type values to system values to use by
 187  * verify/nverify. Implemented to allow
 188  * almost everything that can be returned by getattr into known structs
 189  * (like vfsstat64 or vattr_t), that is, both read only and read/write attrs.
 190  * The function will return -1 if it found that the arguments don't match.
 191  * This applies to system-wide values that don't require a fop_getattr
 192  * or other further checks to verify. It will return no error if they
 193  * either match or were retrieved successfully for later checking.
 194  *
 195  * NFS4ATTR_FREEIT: free up any space allocated by either of the above.
 196  * The sargp->op should be either NFS4ATTR_GETIT or NFS4ATTR_SETIT
 197  * to indicate which op was used to allocate the space.
 198  *
 199  * XXX Note: these functions are currently used by the server only. A
 200  * XXX different method of conversion is used on the client side.
 201  * XXX Eventually combining the two (possibly by adding NFS4ATTR_CLNT_GETIT
 202  * XXX and SETIT) may be a cleaner approach.
 203  */
 204
 205 /*
 206  * Mandatory attributes
 207  */
 208
 209 /* ARGSUSED */
 210 static int
 211 rfs4_fattr4_supported_attrs(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
 212     union nfs4_attr_u *na)
 213 {
 214         int     error = 0;
 215
 216         switch (cmd) {
 217         case NFS4ATTR_SUPPORTED:
 218                 if (sarg->op == NFS4ATTR_SETIT)
 219                         error = EINVAL;
 220                 break;          /* this attr is supported */
 221         case NFS4ATTR_GETIT:
 222                 na->supported_attrs = rfs4_supported_attrs;
 223                 break;
 224         case NFS4ATTR_SETIT:
 225                 /*
 226                  * read-only attr
 227                  */
 228                 error = EINVAL;
 229                 break;
 230         case NFS4ATTR_VERIT:
 231                 /*
 232                  * Compare the input bitmap to the server's bitmap
 233                  */
 234                 if (na->supported_attrs != rfs4_supported_attrs) {
 235                         error = -1;     /* no match */
 236                 }
 237                 break;
 238         case NFS4ATTR_FREEIT:
 239                 break;
 240         }
 241         return (error);
 242 }
 243
 244 /*
 245  * Translate vnode vtype to nfsv4_ftype.
 246  */
 247 static nfs_ftype4 vt_to_nf4[] = {
 248         0, NF4REG, NF4DIR, NF4BLK, NF4CHR, NF4LNK, NF4FIFO, 0, 0, NF4SOCK, 0
 249 };
 250
 251 /* ARGSUSED */
 252 static int
 253 rfs4_fattr4_type(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
 254     union nfs4_attr_u *na)
 255 {
 256         int             error = 0;
 257
 258         switch (cmd) {
 259         case NFS4ATTR_SUPPORTED:
 260                 if (sarg->op == NFS4ATTR_SETIT)
 261                         error = EINVAL;
 262                 break;          /* this attr is supported */
 263         case NFS4ATTR_GETIT:
 264                 if (sarg->rdattr_error && !(sarg->vap->va_mask & VATTR_TYPE)) {
 265                         error = -1;     /* may be okay if rdattr_error */
 266                         break;
 267                 }
 268                 ASSERT(sarg->vap->va_mask & VATTR_TYPE);
 269
 270                 /*
 271                  * if xattr flag not set, use v4_to_nf4 mapping;
 272                  * otherwise verify xattr flag is in sync with va_type
 273                  * and set xattr types.
 274                  */
 275                 if (! (sarg->xattr & (FH4_NAMEDATTR | FH4_ATTRDIR)))
 276                         na->type = vt_to_nf4[sarg->vap->va_type];
 277                 else {
 278                         /*
 279                          * FH4 flag was set.  Dir type maps to attrdir,
 280                          * and all other types map to namedattr.
 281                          */
 282                         if (sarg->vap->va_type == VDIR)
 283                                 na->type = NF4ATTRDIR;
 284                         else
 285                                 na->type = NF4NAMEDATTR;
 286                 }
 287                 break;
 288         case NFS4ATTR_SETIT:
 289                 /*
 290                  * read-only attr
 291                  */
 292                 error = EINVAL;
 293                 break;
 294         case NFS4ATTR_VERIT:
 295                 /*
 296                  * Compare the input type to the object type on server
 297                  */
 298                 ASSERT(sarg->vap->va_mask & VATTR_TYPE);
 299                 if (sarg->vap->va_type != nf4_to_vt[na->type])
 300                         error = -1;     /* no match */
 301                 break;
 302         case NFS4ATTR_FREEIT:
 303                 break;
 304         }
 305         return (error);
 306 }
 307
 308 /* ARGSUSED */
 309 static int
 310 fattr4_get_fh_expire_type(struct exportinfo *exi, uint32_t *fh_expire_typep)
 311 {
 312 #ifdef  VOLATILE_FH_TEST
 313         int     ex_flags;
 314
 315         if (exi == NULL)
 316                 return (ESTALE);
 317         ex_flags = exi->exi_export.ex_flags;
 318         if ((ex_flags & (EX_VOLFH | EX_VOLRNM | EX_VOLMIG | EX_NOEXPOPEN))
 319             == 0) {
 320                 *fh_expire_typep = FH4_PERSISTENT;
 321                 return (0);
 322         }
 323         *fh_expire_typep = 0;
 324
 325         if (ex_flags & EX_NOEXPOPEN) {
 326                 /* file handles should not expire with open - not used */
 327                 *fh_expire_typep = FH4_NOEXPIRE_WITH_OPEN;
 328         }
 329         if (ex_flags & EX_VOLFH) {
 330                 /*
 331                  * file handles may expire any time - on share here.
 332                  * If volatile any, no need to check other flags.
 333                  */
 334                 *fh_expire_typep |= FH4_VOLATILE_ANY;
 335                 return (0);
 336         }
 337         if (ex_flags & EX_VOLRNM) {
 338                 /* file handles may expire on rename */
 339                 *fh_expire_typep |= FH4_VOL_RENAME;
 340         }
 341         if (ex_flags & EX_VOLMIG) {
 342                 /* file handles may expire on migration - not used */
 343                 *fh_expire_typep |= FH4_VOL_MIGRATION;
 344         }
 345 #else   /* not VOLATILE_FH_TEST */
 346         *fh_expire_typep = FH4_PERSISTENT;
 347 #endif  /* VOLATILE_FH_TEST */
 348
 349         return (0);
 350 }
 351
 352 /*
 353  * At this point the only volatile filehandles we allow (for test purposes
 354  * only) are either fh's that expire when the filesystem is shared (reshared),
 355  * fh's that expire on a rename and persistent ones.
 356  */
 357 /* ARGSUSED */
 358 static int
 359 rfs4_fattr4_fh_expire_type(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
 360     union nfs4_attr_u *na)
 361 {
 362         uint32_t fh_expire_type;
 363         int error = 0;
 364
 365         switch (cmd) {
 366         case NFS4ATTR_SUPPORTED:
 367                 if (sarg->op == NFS4ATTR_SETIT)
 368                         error = EINVAL;
 369                 break;          /* this attr is supported */
 370         case NFS4ATTR_GETIT:
 371                 error = fattr4_get_fh_expire_type(sarg->cs->exi,
 372                     &na->fh_expire_type);
 373                 break;
 374         case NFS4ATTR_SETIT:
 375                 /*
 376                  * read-only attr
 377                  */
 378                 error = EINVAL;
 379                 break;
 380         case NFS4ATTR_VERIT:
 381                 error = fattr4_get_fh_expire_type(sarg->cs->exi,
 382                     &fh_expire_type);
 383                 if (!error && (na->fh_expire_type != fh_expire_type))
 384                         error = -1;     /* no match */
 385                 break;
 386         case NFS4ATTR_FREEIT:
 387                 break;
 388         }
 389         return (error);
 390 }
 391
 392 static int
 393 fattr4_get_change(struct nfs4_svgetit_arg *sarg, fattr4_change *changep)
 394 {
 395         vattr_t vap2[1], *vap = sarg->vap;
 396         struct compound_state *cs = sarg->cs;
 397         vnode_t *vp = cs->vp;
 398         nfsstat4 status;
 399         timespec_t vis_change;
 400
 401         if ((vap->va_mask & VATTR_CTIME) == 0) {
 402                 if (sarg->rdattr_error && (vp == NULL)) {
 403                         return (-1);    /* may be okay if rdattr_error */
 404                 }
 405                 ASSERT(vp != NULL);
 406                 vap = vap2;
 407                 vap->va_mask = VATTR_CTIME;
 408                 status = rfs4_vop_getattr(vp, vap, 0, cs->cr);
 409                 if (status != NFS4_OK)
 410                         return (geterrno4(status));
 411         }
 412         NFS4_SET_FATTR4_CHANGE(*changep, vap->va_ctime);
 413
 414         if (nfs_visible_change(cs->exi, vp, &vis_change)) {
 415                 fattr4_change visch;
 416                 NFS4_SET_FATTR4_CHANGE(visch, vis_change);
 417                 if (visch > *changep)
 418                         *changep = visch;
 419         }
 420
 421         return (0);
 422 }
 423
 424 /* ARGSUSED */
 425 static int
 426 rfs4_fattr4_change(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
 427     union nfs4_attr_u *na)
 428 {
 429         int error = 0;
 430         fattr4_change change;
 431         uint_t mask;
 432         vattr_t *vap = sarg->vap;
 433
 434         switch (cmd) {
 435         case NFS4ATTR_SUPPORTED:
 436                 if (sarg->op == NFS4ATTR_SETIT)
 437                         error = EINVAL;
 438                 break;          /* this attr is supported */
 439         case NFS4ATTR_GETIT:
 440                 error = fattr4_get_change(sarg, &na->change);
 441                 break;
 442         case NFS4ATTR_SETIT:
 443                 /*
 444                  * read-only attr
 445                  */
 446                 error = EINVAL;
 447                 break;
 448         case NFS4ATTR_VERIT:
 449                 mask = vap->va_mask;
 450                 vap->va_mask &= ~VATTR_CTIME;   /* force a fop_getattr */
 451                 error = fattr4_get_change(sarg, &change);
 452                 vap->va_mask = mask;
 453                 if (!error && (na->change != change))
 454                         error = -1;
 455                 break;
 456         case NFS4ATTR_FREEIT:
 457                 break;
 458         }
 459         return (error);
 460 }
 461
 462 /* ARGSUSED */
 463 static int
 464 rfs4_fattr4_size(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
 465     union nfs4_attr_u *na)
 466 {
 467         int     error = 0;
 468
 469         switch (cmd) {
 470         case NFS4ATTR_SUPPORTED:
 471                 break;          /* this attr is supported */
 472         case NFS4ATTR_GETIT:
 473                 if (sarg->rdattr_error && !(sarg->vap->va_mask & VATTR_SIZE)) {
 474                         error = -1;     /* may be okay if rdattr_error */
 475                         break;
 476                 }
 477                 ASSERT(sarg->vap->va_mask & VATTR_SIZE);
 478                 na->size = sarg->vap->va_size;
 479                 break;
 480         case NFS4ATTR_SETIT:
 481                 ASSERT(sarg->vap->va_mask & VATTR_SIZE);
 482                 sarg->vap->va_size = na->size;
 483                 break;
 484         case NFS4ATTR_VERIT:
 485                 ASSERT(sarg->vap->va_mask & VATTR_SIZE);
 486                 if (sarg->vap->va_size != na->size)
 487                         error = -1;     /* no match */
 488                 break;
 489         case NFS4ATTR_FREEIT:
 490                 break;
 491         }
 492         return (error);
 493 }
 494
 495 /*
 496  * XXX - need VOP extension to ask file system (e.g. pcfs) if it supports
 497  * hard links.
 498  */
 499 /* ARGSUSED */
 500 static int
 501 rfs4_fattr4_link_support(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
 502     union nfs4_attr_u *na)
 503 {
 504         int error = 0;
 505
 506         switch (cmd) {
 507         case NFS4ATTR_SUPPORTED:
 508                 if (sarg->op == NFS4ATTR_SETIT)
 509                         error = EINVAL;
 510                 break;          /* this attr is supported */
 511         case NFS4ATTR_GETIT:
 512                 na->link_support = TRUE;
 513                 break;
 514         case NFS4ATTR_SETIT:
 515                 /*
 516                  * read-only attr
 517                  */
 518                 error = EINVAL;
 519                 break;
 520         case NFS4ATTR_VERIT:
 521                 if (!na->link_support)
 522                         error = -1;     /* no match */
 523                 break;
 524         case NFS4ATTR_FREEIT:
 525                 break;
 526         }
 527         return (error);
 528 }
 529
 530 /*
 531  * XXX - need VOP extension to ask file system (e.g. pcfs) if it supports
 532  * sym links.
 533  */
 534 /* ARGSUSED */
 535 static int
 536 rfs4_fattr4_symlink_support(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
 537     union nfs4_attr_u *na)
 538 {
 539         int error = 0;
 540
 541         switch (cmd) {
 542         case NFS4ATTR_SUPPORTED:
 543                 if (sarg->op == NFS4ATTR_SETIT)
 544                         error = EINVAL;
 545                 break;          /* this attr is supported */
 546         case NFS4ATTR_GETIT:
 547                 na->symlink_support = TRUE;
 548                 break;
 549         case NFS4ATTR_SETIT:
 550                 /*
 551                  * read-only attr
 552                  */
 553                 error = EINVAL;
 554                 break;
 555         case NFS4ATTR_VERIT:
 556                 if (!na->symlink_support)
 557                         error = -1;     /* no match */
 558                 break;
 559         case NFS4ATTR_FREEIT:
 560                 break;
 561         }
 562         return (error);
 563 }
 564
 565 /* ARGSUSED */
 566 static int
 567 rfs4_fattr4_named_attr(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
 568     union nfs4_attr_u *na)
 569 {
 570         int error = 0;
 571         ulong_t val;
 572
 573         switch (cmd) {
 574         case NFS4ATTR_SUPPORTED:
 575                 if (sarg->op == NFS4ATTR_SETIT)
 576                         error = EINVAL;
 577                 break;          /* this attr is supported */
 578         case NFS4ATTR_GETIT:
 579                 if (sarg->rdattr_error && (sarg->cs->vp == NULL)) {
 580                         error = -1;     /* may be okay if rdattr_error */
 581                         break;
 582                 }
 583                 ASSERT(sarg->cs->vp != NULL);
 584
 585                 /*
 586                  * Solaris xattr model requires that VFS_XATTR is set
 587                  * in file systems enabled for generic xattr.  If VFS_XATTR
 588                  * not set, no need to call pathconf for _PC_XATTR_EXISTS..
 589                  *
 590                  * However the VFS_XATTR flag doesn't indicate sysattr support
 591                  * so always check for sysattrs and then only do the
 592                  * _PC_XATTR_EXISTS pathconf if needed.
 593                  */
 594
 595                 val = 0;
 596                 error = fop_pathconf(sarg->cs->vp, _PC_SATTR_EXISTS,
 597                     &val, sarg->cs->cr, NULL);
 598                 if ((error || val == 0) &&
 599                     sarg->cs->vp->v_vfsp->vfs_flag & VFS_XATTR) {
 600                         error = fop_pathconf(sarg->cs->vp,
 601                             _PC_XATTR_EXISTS, &val, sarg->cs->cr, NULL);
 602                         if (error)
 603                                 break;
 604                 }
 605                 na->named_attr = (val ? TRUE : FALSE);
 606                 break;
 607         case NFS4ATTR_SETIT:
 608                 /*
 609                  * read-only attr
 610                  */
 611                 error = EINVAL;
 612                 break;
 613         case NFS4ATTR_VERIT:
 614                 ASSERT(sarg->cs->vp != NULL);
 615                 if (sarg->cs->vp->v_vfsp->vfs_flag & VFS_XATTR) {
 616                         error = fop_pathconf(sarg->cs->vp, _PC_SATTR_EXISTS,
 617                             &val, sarg->cs->cr, NULL);
 618                         if (error || val == 0)
 619                                 error = fop_pathconf(sarg->cs->vp,
 620                                     _PC_XATTR_EXISTS, &val,
 621                                     sarg->cs->cr, NULL);
 622                         if (error)
 623                                 break;
 624                 } else
 625                         val = 0;
 626                 if (na->named_attr != (val ? TRUE : FALSE))
 627                         error = -1;     /* no match */
 628                 break;
 629         case NFS4ATTR_FREEIT:
 630                 break;
 631         }
 632         return (error);
 633 }
 634
 635 /* ARGSUSED */
 636 static int
 637 rfs4_fattr4_fsid(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
 638     union nfs4_attr_u *na)
 639 {
 640         int error = 0;
 641         int *pmaj = (int *)&na->fsid.major;
 642
 643         /*
 644          * fsid_t is 64bits so it fits completely in fattr4_fsid.major.
 645          * fattr4_fsid.minor is always set to 0 since it isn't needed (yet).
 646          */
 647         switch (cmd) {
 648         case NFS4ATTR_SUPPORTED:
 649                 if (sarg->op == NFS4ATTR_SETIT)
 650                         error = EINVAL;
 651                 break;          /* this attr is supported */
 652         case NFS4ATTR_GETIT:
 653                 if (sarg->is_referral) {
 654                         na->fsid.major = 1;
 655                         na->fsid.minor = 0;
 656                 } else if (sarg->cs->exi->exi_volatile_dev) {
 657                         pmaj[0] = sarg->cs->exi->exi_fsid.val[0];
 658                         pmaj[1] = sarg->cs->exi->exi_fsid.val[1];
 659                         na->fsid.minor = 0;
 660                 } else {
 661                         na->fsid.major = getmajor(sarg->vap->va_fsid);
 662                         na->fsid.minor = getminor(sarg->vap->va_fsid);
 663                 }
 664                 break;
 665         case NFS4ATTR_SETIT:
 666                 error = EINVAL;
 667                 break;
 668         case NFS4ATTR_VERIT:
 669                 if (sarg->is_referral) {
 670                         if (na->fsid.major != 1 ||
 671                             na->fsid.minor != 0)
 672                                 error = -1;
 673                 } else if (sarg->cs->exi->exi_volatile_dev) {
 674                         if (pmaj[0] != sarg->cs->exi->exi_fsid.val[0] ||
 675                             pmaj[1] != sarg->cs->exi->exi_fsid.val[1] ||
 676                             na->fsid.minor != 0)
 677                                 error = -1;
 678                 } else {
 679                         if (na->fsid.major != getmajor(sarg->vap->va_fsid) ||
 680                             na->fsid.minor != getminor(sarg->vap->va_fsid))
 681                                 error = -1;
 682                 }
 683                 break;
 684         case NFS4ATTR_FREEIT:
 685                 break;
 686         }
 687         return (error);
 688 }
 689
 690 /* ARGSUSED */
 691 static int
 692 rfs4_fattr4_unique_handles(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
 693     union nfs4_attr_u *na)
 694 {
 695         /*
 696          * XXX
 697          * For now, we can't support this. Problem of /export, beinging
 698          * a file system, /export/a and /export/b shared separately,
 699          * and /export/a/l and /export/b/l are ahrd links of each other.
 700          */
 701         int error = 0;
 702
 703         switch (cmd) {
 704         case NFS4ATTR_SUPPORTED:
 705                 if (sarg->op == NFS4ATTR_SETIT)
 706                         error = EINVAL;
 707                 break;          /* this attr is supported */
 708         case NFS4ATTR_GETIT:
 709                 na->unique_handles = FALSE;
 710                 break;
 711         case NFS4ATTR_SETIT:
 712                 /*
 713                  * read-only attr
 714                  */
 715                 error = EINVAL;
 716                 break;
 717         case NFS4ATTR_VERIT:
 718                 if (na->unique_handles)
 719                         error = -1;     /* no match */
 720                 break;
 721         case NFS4ATTR_FREEIT:
 722                 break;
 723         }
 724         return (error);
 725 }
 726
 727 /* ARGSUSED */
 728 static int
 729 rfs4_fattr4_lease_time(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
 730     union nfs4_attr_u *na)
 731 {
 732         int error = 0;
 733
 734         switch (cmd) {
 735         case NFS4ATTR_SUPPORTED:
 736                 if (sarg->op == NFS4ATTR_SETIT)
 737                         error = EINVAL;
 738                 break;          /* this attr is supported */
 739         case NFS4ATTR_GETIT:
 740                 na->lease_time = rfs4_lease_time;
 741                 break;
 742         case NFS4ATTR_SETIT:
 743                 /*
 744                  * read-only attr
 745                  */
 746                 error = EINVAL;
 747                 break;
 748         case NFS4ATTR_VERIT:
 749                 if (na->lease_time != rfs4_lease_time)
 750                         error = -1;     /* no match */
 751                 break;
 752         case NFS4ATTR_FREEIT:
 753                 break;
 754         }
 755         return (error);
 756 }
 757
 758 /* ARGSUSED */
 759 static int
 760 rfs4_fattr4_rdattr_error(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
 761     union nfs4_attr_u *na)
 762 {
 763         int error = 0;
 764
 765         switch (cmd) {
 766         case NFS4ATTR_SUPPORTED:
 767                 if ((sarg->op == NFS4ATTR_SETIT) ||
 768                     (sarg->op == NFS4ATTR_VERIT))
 769                         error = EINVAL;
 770                 break;          /* this attr is supported */
 771         case NFS4ATTR_GETIT:
 772                 ASSERT(sarg->rdattr_error_req);
 773                 na->rdattr_error = sarg->rdattr_error;
 774                 break;
 775         case NFS4ATTR_SETIT:
 776         case NFS4ATTR_VERIT:
 777                 /*
 778                  * read-only attr
 779                  */
 780                 error = EINVAL;
 781                 break;
 782         case NFS4ATTR_FREEIT:
 783                 break;
 784         }
 785         return (error);
 786 }
 787
 788 /*
 789  * Server side compare of a filehandle from the wire to a native
 790  * server filehandle.
 791  */
 792 static int
 793 rfs4fhcmp(nfs_fh4 *wirefh, nfs_fh4 *srvfh)
 794 {
 795         nfs_fh4_fmt_t fh;
 796
 797         ASSERT(IS_P2ALIGNED(wirefh->nfs_fh4_val, sizeof (uint32_t)));
 798
 799         bzero(&fh, sizeof (nfs_fh4_fmt_t));
 800         if (!xdr_inline_decode_nfs_fh4((uint32_t *)wirefh->nfs_fh4_val, &fh,
 801             wirefh->nfs_fh4_len))
 802                 return (1);
 803
 804         return (bcmp(srvfh->nfs_fh4_val, &fh, srvfh->nfs_fh4_len));
 805 }
 806
 807 /* ARGSUSED */
 808 static int
 809 rfs4_fattr4_filehandle(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
 810     union nfs4_attr_u *na)
 811 {
 812         nfs_fh4 *fh;
 813
 814         switch (cmd) {
 815         case NFS4ATTR_SUPPORTED:
 816                 if (sarg->op == NFS4ATTR_SETIT)
 817                         return (EINVAL);
 818                 return (0);     /* this attr is supported */
 819         case NFS4ATTR_GETIT:
 820                 /*
 821                  * If sarg->cs->fh is all zeros then should makefh a new
 822                  * one, otherwise, copy that one over.
 823                  */
 824                 fh = &sarg->cs->fh;
 825                 if (sarg->cs->fh.nfs_fh4_len == 0) {
 826                         if (sarg->rdattr_error && (sarg->cs->vp == NULL))
 827                                 return (-1);    /* okay if rdattr_error */
 828                         ASSERT(sarg->cs->vp != NULL);
 829                         na->filehandle.nfs_fh4_val =
 830                             kmem_alloc(NFS_FH4_LEN, KM_SLEEP);
 831                         return (makefh4(&na->filehandle, sarg->cs->vp,
 832                             sarg->cs->exi));
 833                 }
 834                 na->filehandle.nfs_fh4_val =
 835                     kmem_alloc(fh->nfs_fh4_len, KM_SLEEP);
 836                 nfs_fh4_copy(fh, &na->filehandle);
 837                 return (0);
 838         case NFS4ATTR_SETIT:
 839                 /*
 840                  * read-only attr
 841                  */
 842                 return (EINVAL);
 843         case NFS4ATTR_VERIT:
 844                 /*
 845                  * A verify of a filehandle will have the client sending
 846                  * the raw format which needs to be compared to the
 847                  * native format.
 848                  */
 849                 if (rfs4fhcmp(&na->filehandle, &sarg->cs->fh) == 1)
 850                         return (-1);    /* no match */
 851                 return (0);
 852         case NFS4ATTR_FREEIT:
 853                 if (sarg->op != NFS4ATTR_GETIT)
 854                         return (0);
 855                 if (na->filehandle.nfs_fh4_val == NULL)
 856                         return (0);
 857                 kmem_free(na->filehandle.nfs_fh4_val,
 858                     na->filehandle.nfs_fh4_len);
 859                 na->filehandle.nfs_fh4_val = NULL;
 860                 na->filehandle.nfs_fh4_len = 0;
 861                 return (0);
 862         }
 863         return (0);
 864 }
 865
 866 /*
 867  * Recommended attributes
 868  */
 869
 870 /* ARGSUSED */
 871 static int
 872 rfs4_fattr4_acl(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
 873     union nfs4_attr_u *na)
 874 {
 875         int error = 0;
 876         vsecattr_t vs_native, vs_ace4;
 877         ulong_t whichacl;
 878         nfsstat4 status;
 879         vattr_t va, *vap = sarg->vap;
 880         vnode_t *vp = sarg->cs->vp;
 881
 882         if (RFS4_MANDATTR_ONLY)
 883                 return (ENOTSUP);
 884
 885         switch (cmd) {
 886         case NFS4ATTR_SUPPORTED:
 887                 break;
 888
 889         case NFS4ATTR_VERIT:
 890         case NFS4ATTR_GETIT:
 891                 if (sarg->rdattr_error && (vp == NULL)) {
 892                         return (-1);
 893                 }
 894                 ASSERT(vp != NULL);
 895                 bzero(&vs_native, sizeof (vs_native));
 896
 897                 /* see which ACLs fs supports */
 898                 error = fop_pathconf(vp, _PC_ACL_ENABLED, &whichacl,
 899                     sarg->cs->cr, NULL);
 900                 if (error != 0) {
 901                         /*
 902                          * If we got an error, then the filesystem
 903                          * likely does not understand the _PC_ACL_ENABLED
 904                          * pathconf.  In this case, we fall back to trying
 905                          * POSIX-draft (aka UFS-style) ACLs, since that's
 906                          * the behavior used by earlier version of NFS.
 907                          */
 908                         error = 0;
 909                         whichacl = _ACL_ACLENT_ENABLED;
 910                 }
 911
 912                 if (!(whichacl & (_ACL_ACE_ENABLED | _ACL_ACLENT_ENABLED))) {
 913                         /*
 914                          * If the file system supports neither ACE nor
 915                          * ACLENT ACLs we will fall back to UFS-style ACLs
 916                          * like we did above if there was an error upon
 917                          * calling fop_pathconf.
 918                          *
 919                          * ACE and ACLENT type ACLs are the only interfaces
 920                          * supported thus far.  If any other bits are set on
 921                          * 'whichacl' upon return from fop_pathconf, we will
 922                          * ignore them.
 923                          */
 924                         whichacl = _ACL_ACLENT_ENABLED;
 925                 }
 926
 927                 if (whichacl & _ACL_ACE_ENABLED)
 928                         vs_native.vsa_mask = VSA_ACE | VSA_ACECNT;
 929                 else if (whichacl & _ACL_ACLENT_ENABLED)
 930                         vs_native.vsa_mask = VSA_ACL | VSA_ACLCNT |
 931                             VSA_DFACL | VSA_DFACLCNT;
 932
 933                 if (error != 0)
 934                         break;
 935
 936                 /* get the ACL, and translate it into nfsace4 style */
 937                 error = fop_getsecattr(vp, &vs_native,
 938                     0, sarg->cs->cr, NULL);
 939                 if (error != 0)
 940                         break;
 941                 if (whichacl & _ACL_ACE_ENABLED) {
 942                         error = vs_acet_to_ace4(&vs_native, &vs_ace4, TRUE);
 943                         vs_acet_destroy(&vs_native);
 944                 } else {
 945                         error = vs_aent_to_ace4(&vs_native, &vs_ace4,
 946                             vp->v_type == VDIR, TRUE);
 947                         vs_aent_destroy(&vs_native);
 948                 }
 949                 if (error != 0)
 950                         break;
 951
 952                 if (cmd == NFS4ATTR_GETIT) {
 953                         na->acl.fattr4_acl_len = vs_ace4.vsa_aclcnt;
 954                         /* see case NFS4ATTR_FREEIT for this being freed */
 955                         na->acl.fattr4_acl_val = vs_ace4.vsa_aclentp;
 956                 } else {
 957                         if (na->acl.fattr4_acl_len != vs_ace4.vsa_aclcnt)
 958                                 error = -1; /* no match */
 959                         else if (ln_ace4_cmp(na->acl.fattr4_acl_val,
 960                             vs_ace4.vsa_aclentp,
 961                             vs_ace4.vsa_aclcnt) != 0)
 962                                 error = -1; /* no match */
 963                 }
 964
 965                 break;
 966
 967         case NFS4ATTR_SETIT:
 968                 if (sarg->rdattr_error && (vp == NULL)) {
 969                         return (-1);
 970                 }
 971                 ASSERT(vp != NULL);
 972
 973                 /* prepare vs_ace4 from fattr4 data */
 974                 bzero(&vs_ace4, sizeof (vs_ace4));
 975                 vs_ace4.vsa_mask = VSA_ACE | VSA_ACECNT;
 976                 vs_ace4.vsa_aclcnt = na->acl.fattr4_acl_len;
 977                 vs_ace4.vsa_aclentp = na->acl.fattr4_acl_val;
 978                 vs_ace4.vsa_aclentsz = vs_ace4.vsa_aclcnt * sizeof (ace_t);
 979                 /* make sure we have correct owner/group */
 980                 if ((vap->va_mask & (VATTR_UID | VATTR_GID)) !=
 981                     (VATTR_UID | VATTR_GID)) {
 982                         vap = &va;
 983                         vap->va_mask = VATTR_UID | VATTR_GID;
 984                         status = rfs4_vop_getattr(vp,
 985                             vap, 0, sarg->cs->cr);
 986                         if (status != NFS4_OK)
 987                                 return (geterrno4(status));
 988                 }
 989
 990                 /* see which ACLs the fs supports */
 991                 error = fop_pathconf(vp, _PC_ACL_ENABLED, &whichacl,
 992                     sarg->cs->cr, NULL);
 993                 if (error != 0) {
 994                         /*
 995                          * If we got an error, then the filesystem
 996                          * likely does not understand the _PC_ACL_ENABLED
 997                          * pathconf.  In this case, we fall back to trying
 998                          * POSIX-draft (aka UFS-style) ACLs, since that's
 999                          * the behavior used by earlier version of NFS.
1000                          */
1001                         error = 0;
1002                         whichacl = _ACL_ACLENT_ENABLED;
1003                 }
1004
1005                 if (!(whichacl & (_ACL_ACLENT_ENABLED | _ACL_ACE_ENABLED))) {
1006                         /*
1007                          * If the file system supports neither ACE nor
1008                          * ACLENT ACLs we will fall back to UFS-style ACLs
1009                          * like we did above if there was an error upon
1010                          * calling fop_pathconf.
1011                          *
1012                          * ACE and ACLENT type ACLs are the only interfaces
1013                          * supported thus far.  If any other bits are set on
1014                          * 'whichacl' upon return from fop_pathconf, we will
1015                          * ignore them.
1016                          */
1017                         whichacl = _ACL_ACLENT_ENABLED;
1018                 }
1019
1020                 if (whichacl & _ACL_ACE_ENABLED) {
1021                         error = vs_ace4_to_acet(&vs_ace4, &vs_native,
1022                             vap->va_uid, vap->va_gid, TRUE);
1023                         if (error != 0)
1024                                 break;
1025                         (void) fop_rwlock(vp, V_WRITELOCK_TRUE, NULL);
1026                         error = fop_setsecattr(vp, &vs_native,
1027                             0, sarg->cs->cr, NULL);
1028                         fop_rwunlock(vp, V_WRITELOCK_TRUE, NULL);
1029                         vs_acet_destroy(&vs_native);
1030                 } else if (whichacl & _ACL_ACLENT_ENABLED) {
1031                         error = vs_ace4_to_aent(&vs_ace4, &vs_native,
1032                             vap->va_uid, vap->va_gid, vp->v_type == VDIR, TRUE);
1033                         if (error != 0)
1034                                 break;
1035                         (void) fop_rwlock(vp, V_WRITELOCK_TRUE, NULL);
1036                         error = fop_setsecattr(vp, &vs_native,
1037                             0, sarg->cs->cr, NULL);
1038                         fop_rwunlock(vp, V_WRITELOCK_TRUE, NULL);
1039                         vs_aent_destroy(&vs_native);
1040                 }
1041                 break;
1042
1043         case NFS4ATTR_FREEIT:
1044                 if (sarg->op == NFS4ATTR_GETIT) {
1045                         vs_ace4.vsa_mask = VSA_ACE | VSA_ACECNT;
1046                         vs_ace4.vsa_aclcnt = na->acl.fattr4_acl_len;
1047                         vs_ace4.vsa_aclentp = na->acl.fattr4_acl_val;
1048                         vs_ace4_destroy(&vs_ace4);
1049                 }
1050                 break;
1051         }
1052
1053         return (error);
1054 }
1055
1056 /* ARGSUSED */
1057 static int
1058 rfs4_fattr4_aclsupport(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
1059     union nfs4_attr_u *na)
1060 {
1061         int error = 0;
1062
1063         if (RFS4_MANDATTR_ONLY)
1064                 return (ENOTSUP);
1065
1066         switch (cmd) {
1067         case NFS4ATTR_SUPPORTED:
1068                 if (sarg->op == NFS4ATTR_SETIT)
1069                         error = EINVAL;
1070                 break;  /* supported */
1071         case NFS4ATTR_GETIT:
1072                 na->aclsupport = ACL4_SUPPORT_ALLOW_ACL |
1073                     ACL4_SUPPORT_DENY_ACL;
1074                 break;
1075         case NFS4ATTR_SETIT:
1076                 error = EINVAL;
1077                 break;
1078         case NFS4ATTR_VERIT:
1079                 if (na->aclsupport != (ACL4_SUPPORT_ALLOW_ACL |
1080                     ACL4_SUPPORT_DENY_ACL))
1081                         error = -1;     /* no match */
1082                 break;
1083         }
1084
1085         return (error);
1086 }
1087
1088 /* ARGSUSED */
1089 static int
1090 rfs4_fattr4_archive(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
1091     union nfs4_attr_u *na)
1092 {
1093         return (ENOTSUP);
1094 }
1095
1096 /* ARGSUSED */
1097 static int
1098 rfs4_fattr4_cansettime(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
1099     union nfs4_attr_u *na)
1100 {
1101         int error = 0;
1102
1103         if (RFS4_MANDATTR_ONLY)
1104                 return (ENOTSUP);
1105
1106         switch (cmd) {
1107         case NFS4ATTR_SUPPORTED:
1108                 if (sarg->op == NFS4ATTR_SETIT)
1109                         error = EINVAL;
1110                 break;          /* this attr is supported */
1111         case NFS4ATTR_GETIT:
1112                 na->cansettime = TRUE;
1113                 break;
1114         case NFS4ATTR_SETIT:
1115                 /*
1116                  * read-only attr
1117                  */
1118                 error = EINVAL;
1119                 break;
1120         case NFS4ATTR_VERIT:
1121                 if (!na->cansettime)
1122                         error = -1;     /* no match */
1123                 break;
1124         case NFS4ATTR_FREEIT:
1125                 break;
1126         }
1127         return (error);
1128 }
1129
1130 /*
1131  * XXX - need VOP extension to ask file system (e.g. pcfs) if it supports
1132  * case insensitive.
1133  */
1134 /* ARGSUSED */
1135 static int
1136 rfs4_fattr4_case_insensitive(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
1137     union nfs4_attr_u *na)
1138 {
1139         int error = 0;
1140
1141         if (RFS4_MANDATTR_ONLY)
1142                 return (ENOTSUP);
1143
1144         switch (cmd) {
1145         case NFS4ATTR_SUPPORTED:
1146                 if (sarg->op == NFS4ATTR_SETIT)
1147                         error = EINVAL;
1148                 break;          /* this attr is supported */
1149         case NFS4ATTR_GETIT:
1150                 na->case_insensitive = FALSE;
1151                 break;
1152         case NFS4ATTR_SETIT:
1153                 /*
1154                  * read-only attr
1155                  */
1156                 error = EINVAL;
1157                 break;
1158         case NFS4ATTR_VERIT:
1159                 if (!na->case_insensitive)
1160                         error = -1;     /* no match */
1161                 break;
1162         case NFS4ATTR_FREEIT:
1163                 break;
1164         }
1165         return (error);
1166 }
1167
1168 /* ARGSUSED */
1169 static int
1170 rfs4_fattr4_case_preserving(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
1171     union nfs4_attr_u *na)
1172 {
1173         int error = 0;
1174
1175         if (RFS4_MANDATTR_ONLY)
1176                 return (ENOTSUP);
1177
1178         switch (cmd) {
1179         case NFS4ATTR_SUPPORTED:
1180                 if (sarg->op == NFS4ATTR_SETIT)
1181                         error = EINVAL;
1182                 break;          /* this attr is supported */
1183         case NFS4ATTR_GETIT:
1184                 na->case_preserving = TRUE;
1185                 break;
1186         case NFS4ATTR_SETIT:
1187                 /*
1188                  * read-only attr
1189                  */
1190                 error = EINVAL;
1191                 break;
1192         case NFS4ATTR_VERIT:
1193                 if (!na->case_preserving)
1194                         error = -1;     /* no match */
1195                 break;
1196         case NFS4ATTR_FREEIT:
1197                 break;
1198         }
1199         return (error);
1200 }
1201
1202 /* fattr4_chown_restricted should reall be fattr4_chown_allowed */
1203 /* ARGSUSED */
1204 static int
1205 rfs4_fattr4_chown_restricted(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
1206     union nfs4_attr_u *na)
1207 {
1208         int error = 0;
1209         ulong_t val;
1210
1211         if (RFS4_MANDATTR_ONLY)
1212                 return (ENOTSUP);
1213
1214         switch (cmd) {
1215         case NFS4ATTR_SUPPORTED:
1216                 if (sarg->op == NFS4ATTR_SETIT)
1217                         error = EINVAL;
1218                 break;          /* this attr is supported */
1219         case NFS4ATTR_GETIT:
1220                 if (sarg->rdattr_error && (sarg->cs->vp == NULL)) {
1221                         error = -1;     /* may be okay if rdattr_error */
1222                         break;
1223                 }
1224                 ASSERT(sarg->cs->vp != NULL);
1225                 error = fop_pathconf(sarg->cs->vp,
1226                     _PC_CHOWN_RESTRICTED, &val, sarg->cs->cr, NULL);
1227                 if (error)
1228                         break;
1229
1230                 na->chown_restricted = (val == 1);
1231                 break;
1232         case NFS4ATTR_SETIT:
1233                 /*
1234                  * read-only attr
1235                  */
1236                 error = EINVAL;
1237                 break;
1238         case NFS4ATTR_VERIT:
1239                 ASSERT(sarg->cs->vp != NULL);
1240                 error = fop_pathconf(sarg->cs->vp,
1241                     _PC_CHOWN_RESTRICTED, &val, sarg->cs->cr, NULL);
1242                 if (error)
1243                         break;
1244                 if (na->chown_restricted != (val == 1))
1245                         error = -1;     /* no match */
1246                 break;
1247         case NFS4ATTR_FREEIT:
1248                 break;
1249         }
1250         return (error);
1251 }
1252
1253 /* ARGSUSED */
1254 static int
1255 rfs4_fattr4_fileid(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
1256     union nfs4_attr_u *na)
1257 {
1258         int     error = 0;
1259
1260         if (RFS4_MANDATTR_ONLY)
1261                 return (ENOTSUP);
1262
1263         switch (cmd) {
1264         case NFS4ATTR_SUPPORTED:
1265                 if (sarg->op == NFS4ATTR_SETIT)
1266                         error = EINVAL;
1267                 break;          /* this attr is supported */
1268         case NFS4ATTR_GETIT:
1269                 if (sarg->rdattr_error && !(sarg->vap->va_mask & VATTR_NODEID)) {
1270                         error = -1;     /* may be okay if rdattr_error */
1271                         break;
1272                 }
1273                 ASSERT(sarg->vap->va_mask & VATTR_NODEID);
1274                 na->fileid = sarg->vap->va_nodeid;
1275                 break;
1276         case NFS4ATTR_SETIT:
1277                 /*
1278                  * read-only attr
1279                  */
1280                 error = EINVAL;
1281                 break;
1282         case NFS4ATTR_VERIT:
1283                 ASSERT(sarg->vap->va_mask & VATTR_NODEID);
1284                 if (sarg->vap->va_nodeid != na->fileid)
1285                         error = -1;     /* no match */
1286                 break;
1287         case NFS4ATTR_FREEIT:
1288                 break;
1289         }
1290         return (error);
1291 }
1292
1293 /* ARGSUSED */
1294 static int
1295 rfs4_get_mntdfileid(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg)
1296 {
1297         int error = 0;
1298         vattr_t *vap, va;
1299         vnode_t *stubvp = NULL, *vp;
1300
1301         vp = sarg->cs->vp;
1302         sarg->mntdfid_set = FALSE;
1303
1304         /* VROOT object, must untraverse */
1305         if (vp->v_flag & VROOT) {
1306
1307                 /* extra hold for vp since untraverse might rele */
1308                 VN_HOLD(vp);
1309                 stubvp = untraverse(vp);
1310
1311                 /*
1312                  * If vp/stubvp are same, we must be at system
1313                  * root because untraverse returned same vp
1314                  * for a VROOT object.  sarg->vap was setup
1315                  * before we got here, so there's no need to do
1316                  * another getattr -- just use the one in sarg.
1317                  */
1318                 if (VN_CMP(vp, stubvp)) {
1319                         ASSERT(VN_CMP(vp, rootdir));
1320                         vap = sarg->vap;
1321                 } else {
1322                         va.va_mask = VATTR_NODEID;
1323                         vap = &va;
1324                         error = rfs4_vop_getattr(stubvp, vap, 0, sarg->cs->cr);
1325                 }
1326
1327                 /*
1328                  * Done with stub, time to rele.  If vp and stubvp
1329                  * were the same, then we need to rele either vp or
1330                  * stubvp.  If they weren't the same, then untraverse()
1331                  * already took case of the extra hold on vp, and only
1332                  * the stub needs to be rele'd.  Both cases are handled
1333                  * by unconditionally rele'ing the stub.
1334                  */
1335                 VN_RELE(stubvp);
1336         } else
1337                 vap = sarg->vap;
1338
1339         /*
1340          * At this point, vap should contain "correct" VATTR_NODEID --
1341          * (for V_ROOT case, nodeid of stub, for non-VROOT case,
1342          * nodeid of vp).  If error or VATTR_NODEID not available, then
1343          * make the obligatory (yet mysterious) rdattr_error
1344          * check that is so common in the attr code.
1345          */
1346         if (!error && (vap->va_mask & VATTR_NODEID)) {
1347                 sarg->mounted_on_fileid = vap->va_nodeid;
1348                 sarg->mntdfid_set = TRUE;
1349         } else if (sarg->rdattr_error)
1350                 error = -1;
1351
1352         /*
1353          * error describes these cases:
1354          *      0 : success
1355          *      -1: failure due to previous attr processing error (rddir only).
1356          *      * : new attr failure  (if rddir, caller will set rdattr_error)
1357          */
1358         return (error);
1359 }
1360
1361 /* ARGSUSED */
1362 static int
1363 rfs4_fattr4_mounted_on_fileid(nfs4_attr_cmd_t cmd,
1364     struct nfs4_svgetit_arg *sarg, union nfs4_attr_u *na)
1365 {
1366         int     error = 0;
1367
1368         if (RFS4_MANDATTR_ONLY)
1369                 return (ENOTSUP);
1370
1371         switch (cmd) {
1372         case NFS4ATTR_SUPPORTED:
1373                 if (sarg->op == NFS4ATTR_SETIT)
1374                         error = EINVAL;
1375                 break;          /* this attr is supported */
1376         case NFS4ATTR_GETIT:
1377         case NFS4ATTR_VERIT:
1378                 if (! sarg->mntdfid_set)
1379                         error = rfs4_get_mntdfileid(cmd, sarg);
1380
1381                 if (! error && sarg->mntdfid_set) {
1382                         if (cmd == NFS4ATTR_GETIT)
1383                                 na->mounted_on_fileid = sarg->mounted_on_fileid;
1384                         else
1385                                 if (na->mounted_on_fileid !=
1386                                     sarg->mounted_on_fileid)
1387                                         error = -1;
1388                 }
1389                 break;
1390         case NFS4ATTR_SETIT:
1391                 /* read-only attr */
1392                 error = EINVAL;
1393                 break;
1394         case NFS4ATTR_FREEIT:
1395                 break;
1396         }
1397         return (error);
1398 }
1399
1400 /* ARGSUSED */
1401 static int
1402 rfs4_fattr4_files_avail(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
1403     union nfs4_attr_u *na)
1404 {
1405         int     error = 0;
1406
1407         if (RFS4_MANDATTR_ONLY)
1408                 return (ENOTSUP);
1409
1410         switch (cmd) {
1411         case NFS4ATTR_SUPPORTED:
1412                 if (sarg->op == NFS4ATTR_SETIT)
1413                         error = EINVAL;
1414                 break;          /* this attr is supported */
1415         case NFS4ATTR_GETIT:
1416                 if (sarg->rdattr_error && (sarg->sbp == NULL)) {
1417                         error = -1;     /* may be okay if rdattr_error */
1418                         break;
1419                 }
1420                 ASSERT(sarg->sbp != NULL);
1421                 na->files_avail = sarg->sbp->f_favail;
1422                 break;
1423         case NFS4ATTR_SETIT:
1424                 /*
1425                  * read-only attr
1426                  */
1427                 error = EINVAL;
1428                 break;
1429         case NFS4ATTR_VERIT:
1430                 ASSERT(sarg->sbp != NULL);
1431                 if (sarg->sbp->f_favail != na->files_avail)
1432                         error = -1;     /* no match */
1433                 break;
1434         case NFS4ATTR_FREEIT:
1435                 break;
1436         }
1437         return (error);
1438 }
1439
1440 /* ARGSUSED */
1441 static int
1442 rfs4_fattr4_files_free(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
1443     union nfs4_attr_u *na)
1444 {
1445         int     error = 0;
1446
1447         if (RFS4_MANDATTR_ONLY)
1448                 return (ENOTSUP);
1449
1450         switch (cmd) {
1451         case NFS4ATTR_SUPPORTED:
1452                 if (sarg->op == NFS4ATTR_SETIT)
1453                         error = EINVAL;
1454                 break;          /* this attr is supported */
1455         case NFS4ATTR_GETIT:
1456                 if (sarg->rdattr_error && (sarg->sbp == NULL)) {
1457                         error = -1;     /* may be okay if rdattr_error */
1458                         break;
1459                 }
1460                 ASSERT(sarg->sbp != NULL);
1461                 na->files_free = sarg->sbp->f_ffree;
1462                 break;
1463         case NFS4ATTR_SETIT:
1464                 /*
1465                  * read-only attr
1466                  */
1467                 error = EINVAL;
1468                 break;
1469         case NFS4ATTR_VERIT:
1470                 ASSERT(sarg->sbp != NULL);
1471                 if (sarg->sbp->f_ffree != na->files_free)
1472                         error = -1;     /* no match */
1473                 break;
1474         case NFS4ATTR_FREEIT:
1475                 break;
1476         }
1477         return (error);
1478 }
1479
1480 /* ARGSUSED */
1481 static int
1482 rfs4_fattr4_files_total(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
1483     union nfs4_attr_u *na)
1484 {
1485         int     error = 0;
1486
1487         if (RFS4_MANDATTR_ONLY)
1488                 return (ENOTSUP);
1489
1490         switch (cmd) {
1491         case NFS4ATTR_SUPPORTED:
1492                 if (sarg->op == NFS4ATTR_SETIT)
1493                         error = EINVAL;
1494                 break;          /* this attr is supported */
1495         case NFS4ATTR_GETIT:
1496                 if (sarg->rdattr_error && (sarg->sbp == NULL)) {
1497                         error = -1;     /* may be okay if rdattr_error */
1498                         break;
1499                 }
1500                 ASSERT(sarg->sbp != NULL);
1501                 na->files_total = sarg->sbp->f_files;
1502                 break;
1503         case NFS4ATTR_SETIT:
1504                 /*
1505                  * read-only attr
1506                  */
1507                 error = EINVAL;
1508                 break;
1509         case NFS4ATTR_VERIT:
1510                 ASSERT(sarg->sbp != NULL);
1511                 if (sarg->sbp->f_files != na->files_total)
1512                         error = -1;     /* no match */
1513                 break;
1514         case NFS4ATTR_FREEIT:
1515                 break;
1516         }
1517         return (error);
1518 }
1519
1520 static void
1521 rfs4_free_pathname4(pathname4 *pn4)
1522 {
1523         int i, len;
1524         utf8string *utf8s;
1525
1526         if (pn4 == NULL || (len = pn4->pathname4_len) == 0 ||
1527             (utf8s = pn4->pathname4_val) == NULL)
1528                 return;
1529
1530         for (i = 0; i < len; i++, utf8s++) {
1531                 if (utf8s->utf8string_val == NULL ||
1532                     utf8s->utf8string_len == 0)
1533                         continue;
1534
1535                 kmem_free(utf8s->utf8string_val, utf8s->utf8string_len);
1536                 utf8s->utf8string_val = NULL;
1537         }
1538
1539         kmem_free(pn4->pathname4_val,
1540             sizeof (utf8string) * pn4->pathname4_len);
1541         pn4->pathname4_val = 0;
1542 }
1543
1544 static void
1545 rfs4_free_fs_location4(fs_location4 *fsl4)
1546 {
1547         if (fsl4 == NULL)
1548                 return;
1549
1550         rfs4_free_pathname4((pathname4 *)&fsl4->server_len);
1551         rfs4_free_pathname4(&fsl4->rootpath);
1552 }
1553
1554 void
1555 rfs4_free_fs_locations4(fs_locations4 *fsls4)
1556 {
1557         int i, len;
1558         fs_location4 *fsl4;
1559
1560         if (fsls4 == NULL)
1561                 return;
1562
1563         /* free fs_root */
1564         rfs4_free_pathname4(&fsls4->fs_root);
1565
1566         if ((len = fsls4->locations_len) == 0 ||
1567             (fsl4 = fsls4->locations_val) == NULL)
1568                 return;
1569
1570         /* free fs_location4 */
1571         for (i = 0; i < len; i++) {
1572                 rfs4_free_fs_location4(fsl4);
1573                 fsl4++;
1574         }
1575
1576         kmem_free(fsls4->locations_val, sizeof (fs_location4) * len);
1577         fsls4->locations_val = NULL;
1578 }
1579
1580 /* ARGSUSED */
1581 static int
1582 rfs4_fattr4_fs_locations(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
1583     union nfs4_attr_u *na)
1584 {
1585         int error = 0;
1586         fs_locations4 *fsl;
1587
1588         if (RFS4_MANDATTR_ONLY)
1589                 return (ENOTSUP);
1590
1591         switch (cmd) {
1592         case NFS4ATTR_SUPPORTED:
1593                 if (sarg->op == NFS4ATTR_SETIT || sarg->op == NFS4ATTR_VERIT)
1594                         error = EINVAL;
1595                 break;  /* this attr is supported */
1596
1597         case NFS4ATTR_GETIT:
1598                 fsl = fetch_referral(sarg->cs->vp, sarg->cs->cr);
1599                 if (fsl == NULL)
1600                         (void) memset(&(na->fs_locations), 0,
1601                             sizeof (fs_locations4));
1602                 else {
1603                         na->fs_locations = *fsl;
1604                         kmem_free(fsl, sizeof (fs_locations4));
1605                 }
1606                 global_svstat_ptr[4][NFS_REFERRALS].value.ui64++;
1607                 break;
1608
1609         case NFS4ATTR_FREEIT:
1610                 if (sarg->op == NFS4ATTR_SETIT || sarg->op == NFS4ATTR_VERIT)
1611                         error = EINVAL;
1612                 rfs4_free_fs_locations4(&na->fs_locations);
1613                 break;
1614
1615         case NFS4ATTR_SETIT:
1616         case NFS4ATTR_VERIT:
1617                 /*
1618                  * read-only attr
1619                  */
1620                 error = EINVAL;
1621                 break;
1622         }
1623         return (error);
1624 }
1625
1626 /* ARGSUSED */
1627 static int
1628 rfs4_fattr4_hidden(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
1629     union nfs4_attr_u *na)
1630 {
1631         return (ENOTSUP);
1632 }
1633
1634 /* ARGSUSED */
1635 static int
1636 rfs4_fattr4_homogeneous(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
1637     union nfs4_attr_u *na)
1638 {
1639         int error = 0;
1640
1641         if (RFS4_MANDATTR_ONLY)
1642                 return (ENOTSUP);
1643
1644         switch (cmd) {
1645         case NFS4ATTR_SUPPORTED:
1646                 if (sarg->op == NFS4ATTR_SETIT)
1647                         error = EINVAL;
1648                 break;          /* this attr is supported */
1649         case NFS4ATTR_GETIT:
1650                 na->homogeneous = TRUE; /* XXX - need a VOP extension */
1651                 break;
1652         case NFS4ATTR_SETIT:
1653                 /*
1654                  * read-only attr
1655                  */
1656                 error = EINVAL;
1657                 break;
1658         case NFS4ATTR_VERIT:
1659                 if (!na->homogeneous)
1660                         error = -1;     /* no match */
1661                 break;
1662         case NFS4ATTR_FREEIT:
1663                 break;
1664         }
1665         return (error);
1666 }
1667
1668 /* ARGSUSED */
1669 static int
1670 rfs4_fattr4_maxfilesize(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
1671     union nfs4_attr_u *na)
1672 {
1673         int error = 0;
1674         ulong_t val;
1675         fattr4_maxfilesize maxfilesize;
1676
1677         if (RFS4_MANDATTR_ONLY)
1678                 return (ENOTSUP);
1679
1680         switch (cmd) {
1681         case NFS4ATTR_SUPPORTED:
1682                 if (sarg->op == NFS4ATTR_SETIT)
1683                         error = EINVAL;
1684                 break;          /* this attr is supported */
1685         case NFS4ATTR_GETIT:
1686                 if (sarg->rdattr_error && (sarg->cs->vp == NULL)) {
1687                         error = -1;     /* may be okay if rdattr_error */
1688                         break;
1689                 }
1690                 ASSERT(sarg->cs->vp != NULL);
1691                 error = fop_pathconf(sarg->cs->vp, _PC_FILESIZEBITS, &val,
1692                     sarg->cs->cr, NULL);
1693                 if (error)
1694                         break;
1695
1696                 /*
1697                  * If the underlying file system does not support
1698                  * _PC_FILESIZEBITS, return a reasonable default. Note that
1699                  * error code on fop_pathconf will be 0, even if the underlying
1700                  * file system does not support _PC_FILESIZEBITS.
1701                  */
1702                 if (val == (ulong_t)-1) {
1703                         na->maxfilesize = MAXOFF32_T;
1704                 } else {
1705                         if (val >= (sizeof (uint64_t) * 8))
1706                                 na->maxfilesize = INT64_MAX;
1707                         else
1708                                 na->maxfilesize = ((1LL << (val - 1)) - 1);
1709                 }
1710                 break;
1711         case NFS4ATTR_SETIT:
1712                 /*
1713                  * read-only attr
1714                  */
1715                 error = EINVAL;
1716                 break;
1717         case NFS4ATTR_VERIT:
1718                 ASSERT(sarg->cs->vp != NULL);
1719                 error = fop_pathconf(sarg->cs->vp, _PC_FILESIZEBITS, &val,
1720                     sarg->cs->cr, NULL);
1721                 if (error)
1722                         break;
1723                 /*
1724                  * If the underlying file system does not support
1725                  * _PC_FILESIZEBITS, return a reasonable default. Note that
1726                  * error code on fop_pathconf will be 0, even if the underlying
1727                  * file system does not support _PC_FILESIZEBITS.
1728                  */
1729                 if (val == (ulong_t)-1) {
1730                         maxfilesize = MAXOFF32_T;
1731                 } else {
1732                         if (val >= (sizeof (uint64_t) * 8))
1733                                 maxfilesize = INT64_MAX;
1734                         else
1735                                 maxfilesize = ((1LL << (val - 1)) - 1);
1736                 }
1737                 if (na->maxfilesize != maxfilesize)
1738                         error = -1;     /* no match */
1739                 break;
1740         case NFS4ATTR_FREEIT:
1741                 break;
1742         }
1743         return (error);
1744 }
1745
1746 /* ARGSUSED */
1747 static int
1748 rfs4_fattr4_maxlink(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
1749     union nfs4_attr_u *na)
1750 {
1751         int error = 0;
1752         ulong_t val;
1753
1754         if (RFS4_MANDATTR_ONLY)
1755                 return (ENOTSUP);
1756
1757         switch (cmd) {
1758         case NFS4ATTR_SUPPORTED:
1759                 if (sarg->op == NFS4ATTR_SETIT)
1760                         error = EINVAL;
1761                 break;          /* this attr is supported */
1762         case NFS4ATTR_GETIT:
1763                 if (sarg->rdattr_error && (sarg->cs->vp == NULL)) {
1764                         error = -1;     /* may be okay if rdattr_error */
1765                         break;
1766                 }
1767                 ASSERT(sarg->cs->vp != NULL);
1768                 error = fop_pathconf(sarg->cs->vp, _PC_LINK_MAX, &val,
1769                     sarg->cs->cr, NULL);
1770                 if (error == 0) {
1771                         na->maxlink = val;
1772                 }
1773                 break;
1774         case NFS4ATTR_SETIT:
1775                 /*
1776                  * read-only attr
1777                  */
1778                 error = EINVAL;
1779                 break;
1780         case NFS4ATTR_VERIT:
1781                 ASSERT(sarg->cs->vp != NULL);
1782                 error = fop_pathconf(sarg->cs->vp, _PC_LINK_MAX, &val,
1783                     sarg->cs->cr, NULL);
1784                 if (!error && (na->maxlink != (uint32_t)val))
1785                         error = -1;     /* no match */
1786                 break;
1787         case NFS4ATTR_FREEIT:
1788                 break;
1789         }
1790         return (error);
1791 }
1792
1793 /* ARGSUSED */
1794 static int
1795 rfs4_fattr4_maxname(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
1796     union nfs4_attr_u *na)
1797 {
1798         int error = 0;
1799         ulong_t val;
1800
1801         if (RFS4_MANDATTR_ONLY)
1802                 return (ENOTSUP);
1803
1804         switch (cmd) {
1805         case NFS4ATTR_SUPPORTED:
1806                 if (sarg->op == NFS4ATTR_SETIT)
1807                         error = EINVAL;
1808                 break;          /* this attr is supported */
1809         case NFS4ATTR_GETIT:
1810                 if (sarg->rdattr_error && (sarg->cs->vp == NULL)) {
1811                         error = -1;     /* may be okay if rdattr_error */
1812                         break;
1813                 }
1814                 ASSERT(sarg->cs->vp != NULL);
1815                 error = fop_pathconf(sarg->cs->vp, _PC_NAME_MAX, &val,
1816                     sarg->cs->cr, NULL);
1817                 if (error == 0) {
1818                         na->maxname = val;
1819                 }
1820                 break;
1821         case NFS4ATTR_SETIT:
1822                 /*
1823                  * read-only attr
1824                  */
1825                 error = EINVAL;
1826                 break;
1827         case NFS4ATTR_VERIT:
1828                 ASSERT(sarg->cs->vp != NULL);
1829                 error = fop_pathconf(sarg->cs->vp, _PC_NAME_MAX, &val,
1830                     sarg->cs->cr, NULL);
1831                 if (!error && (na->maxname != val))
1832                         error = -1;     /* no match */
1833                 break;
1834         case NFS4ATTR_FREEIT:
1835                 break;
1836         }
1837         return (error);
1838 }
1839
1840 /* ARGSUSED */
1841 static int
1842 rfs4_fattr4_maxread(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
1843     union nfs4_attr_u *na)
1844 {
1845         int error = 0;
1846
1847         if (RFS4_MANDATTR_ONLY)
1848                 return (ENOTSUP);
1849
1850         switch (cmd) {
1851         case NFS4ATTR_SUPPORTED:
1852                 if (sarg->op == NFS4ATTR_SETIT)
1853                         error = EINVAL;
1854                 break;          /* this attr is supported */
1855         case NFS4ATTR_GETIT:
1856                 na->maxread = rfs4_tsize(sarg->cs->req);
1857                 break;
1858         case NFS4ATTR_SETIT:
1859                 /*
1860                  * read-only attr
1861                  */
1862                 error = EINVAL;
1863                 break;
1864         case NFS4ATTR_VERIT:
1865                 if (na->maxread != rfs4_tsize(sarg->cs->req))
1866                         error = -1;     /* no match */
1867                 break;
1868         case NFS4ATTR_FREEIT:
1869                 break;
1870         }
1871         return (error);
1872 }
1873
1874 /* ARGSUSED */
1875 static int
1876 rfs4_fattr4_maxwrite(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
1877     union nfs4_attr_u *na)
1878 {
1879         int error = 0;
1880
1881         if (RFS4_MANDATTR_ONLY)
1882                 return (ENOTSUP);
1883
1884         switch (cmd) {
1885         case NFS4ATTR_SUPPORTED:
1886                 if (sarg->op == NFS4ATTR_SETIT)
1887                         error = EINVAL;
1888                 break;          /* this attr is supported */
1889         case NFS4ATTR_GETIT:
1890                 na->maxwrite = rfs4_tsize(sarg->cs->req);
1891                 break;
1892         case NFS4ATTR_SETIT:
1893                 /*
1894                  * read-only attr
1895                  */
1896                 error = EINVAL;
1897                 break;
1898         case NFS4ATTR_VERIT:
1899                 if (na->maxwrite != rfs4_tsize(sarg->cs->req))
1900                         error = -1;     /* no match */
1901                 break;
1902         case NFS4ATTR_FREEIT:
1903                 break;
1904         }
1905         return (error);
1906 }
1907
1908 /* ARGSUSED */
1909 static int
1910 rfs4_fattr4_mimetype(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
1911     union nfs4_attr_u *na)
1912 {
1913         return (ENOTSUP);
1914 }
1915
1916 /* ARGSUSED */
1917 static int
1918 rfs4_fattr4_mode(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
1919     union nfs4_attr_u *na)
1920 {
1921         int     error = 0;
1922
1923         if (RFS4_MANDATTR_ONLY)
1924                 return (ENOTSUP);
1925
1926         switch (cmd) {
1927         case NFS4ATTR_SUPPORTED:
1928                 break;          /* this attr is supported */
1929         case NFS4ATTR_GETIT:
1930                 if (sarg->rdattr_error && !(sarg->vap->va_mask & VATTR_MODE)) {
1931                         error = -1;     /* may be okay if rdattr_error */
1932                         break;
1933                 }
1934                 ASSERT(sarg->vap->va_mask & VATTR_MODE);
1935                 na->mode = sarg->vap->va_mode;
1936                 break;
1937         case NFS4ATTR_SETIT:
1938                 ASSERT(sarg->vap->va_mask & VATTR_MODE);
1939                 sarg->vap->va_mode = na->mode;
1940                 /*
1941                  * If the filesystem is exported with nosuid, then mask off
1942                  * the setuid and setgid bits.
1943                  */
1944                 if (sarg->cs->vp->v_type == VREG &&
1945                     (sarg->cs->exi->exi_export.ex_flags & EX_NOSUID))
1946                         sarg->vap->va_mode &= ~(VSUID | VSGID);
1947                 break;
1948         case NFS4ATTR_VERIT:
1949                 ASSERT(sarg->vap->va_mask & VATTR_MODE);
1950                 if (sarg->vap->va_mode != na->mode)
1951                         error = -1;     /* no match */
1952                 break;
1953         case NFS4ATTR_FREEIT:
1954                 break;
1955         }
1956         return (error);
1957 }
1958
1959 /* ARGSUSED */
1960 static int
1961 rfs4_fattr4_no_trunc(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
1962     union nfs4_attr_u *na)
1963 {
1964         int error = 0;
1965
1966         if (RFS4_MANDATTR_ONLY)
1967                 return (ENOTSUP);
1968
1969         switch (cmd) {
1970         case NFS4ATTR_SUPPORTED:
1971                 if (sarg->op == NFS4ATTR_SETIT)
1972                         error = EINVAL;
1973                 break;          /* this attr is supported */
1974         case NFS4ATTR_GETIT:
1975                 na->no_trunc = TRUE;
1976                 break;
1977         case NFS4ATTR_SETIT:
1978                 /*
1979                  * read-only attr
1980                  */
1981                 error = EINVAL;
1982                 break;
1983         case NFS4ATTR_VERIT:
1984                 if (!na->no_trunc)
1985                         error = -1;     /* no match */
1986                 break;
1987         case NFS4ATTR_FREEIT:
1988                 break;
1989         }
1990         return (error);
1991 }
1992
1993 /* ARGSUSED */
1994 static int
1995 rfs4_fattr4_numlinks(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
1996     union nfs4_attr_u *na)
1997 {
1998         int     error = 0;
1999
2000         if (RFS4_MANDATTR_ONLY)
2001                 return (ENOTSUP);
2002
2003         switch (cmd) {
2004         case NFS4ATTR_SUPPORTED:
2005                 if (sarg->op == NFS4ATTR_SETIT)
2006                         error = EINVAL;
2007                 break;          /* this attr is supported */
2008         case NFS4ATTR_GETIT:
2009                 if (sarg->rdattr_error && !(sarg->vap->va_mask & VATTR_NLINK)) {
2010                         error = -1;     /* may be okay if rdattr_error */
2011                         break;
2012                 }
2013                 ASSERT(sarg->vap->va_mask & VATTR_NLINK);
2014                 na->numlinks = sarg->vap->va_nlink;
2015                 break;
2016         case NFS4ATTR_SETIT:
2017                 /*
2018                  * read-only attr
2019                  */
2020                 error = EINVAL;
2021                 break;
2022         case NFS4ATTR_VERIT:
2023                 ASSERT(sarg->vap->va_mask & VATTR_NLINK);
2024                 if (sarg->vap->va_nlink != na->numlinks)
2025                         error = -1;     /* no match */
2026                 break;
2027         case NFS4ATTR_FREEIT:
2028                 break;
2029         }
2030         return (error);
2031 }
2032
2033 /* ARGSUSED */
2034 static int
2035 rfs4_fattr4_owner(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
2036     union nfs4_attr_u *na)
2037 {
2038         int     error = 0;
2039         uid_t   uid;
2040
2041         if (RFS4_MANDATTR_ONLY)
2042                 return (ENOTSUP);
2043
2044         switch (cmd) {
2045         case NFS4ATTR_SUPPORTED:
2046                 break;          /* this attr is supported */
2047         case NFS4ATTR_GETIT:
2048                 if (sarg->rdattr_error && !(sarg->vap->va_mask & VATTR_UID)) {
2049                         error = -1;     /* may be okay if rdattr_error */
2050                         break;
2051                 }
2052                 ASSERT(sarg->vap->va_mask & VATTR_UID);
2053
2054                 /*
2055                  * There are well defined polices for what happens on server-
2056                  * side GETATTR when uid to attribute string conversion cannot
2057                  * occur. Please refer to nfs4_idmap.c for details.
2058                  */
2059                 error = nfs_idmap_uid_str(sarg->vap->va_uid, &na->owner, TRUE);
2060                 switch (error) {
2061                 case ECONNREFUSED:
2062                         error = NFS4ERR_DELAY;
2063                         break;
2064                 default:
2065                         break;
2066                 }
2067                 break;
2068
2069         case NFS4ATTR_SETIT:
2070                 ASSERT(sarg->vap->va_mask & VATTR_UID);
2071
2072                 /*
2073                  * There are well defined policies for what happens on server-
2074                  * side SETATTR of 'owner' when a "user@domain" mapping cannot
2075                  * occur. Please refer to nfs4_idmap.c for details.
2076                  *
2077                  * Any other errors, such as the mapping not being found by
2078                  * nfsmapid(1m), and interrupted clnt_call, etc, will result
2079                  * in NFS4ERR_BADOWNER.
2080                  *
2081                  * XXX need to return consistent errors, perhaps all
2082                  * server side attribute routines should return NFS4ERR*.
2083                  */
2084                 error = nfs_idmap_str_uid(&na->owner, &sarg->vap->va_uid, TRUE);
2085                 switch (error) {
2086                 case NFS4_OK:
2087                 case ENOTSUP:
2088                         /*
2089                          * Ignore warning that we are the
2090                          * nfsmapid (can't happen on srv)
2091                          */
2092                         error = 0;
2093                         MSG_PRT_DEBUG = FALSE;
2094                         break;
2095
2096                 case ECOMM:
2097                 case ECONNREFUSED:
2098                         if (!MSG_PRT_DEBUG) {
2099                                 /*
2100                                  * printed just once per daemon death,
2101                                  * inform the user and then stay silent
2102                                  */
2103                                 cmn_err(CE_WARN, "!Unable to contact "
2104                                     "nfsmapid");
2105                                 MSG_PRT_DEBUG = TRUE;
2106                         }
2107                         error = NFS4ERR_DELAY;
2108                         break;
2109
2110                 case EINVAL:
2111                         error = NFS4ERR_INVAL;
2112                         break;
2113
2114                 default:
2115                         error = NFS4ERR_BADOWNER;
2116                         break;
2117                 }
2118                 break;
2119
2120         case NFS4ATTR_VERIT:
2121                 ASSERT(sarg->vap->va_mask & VATTR_UID);
2122                 error = nfs_idmap_str_uid(&na->owner, &uid, TRUE);
2123                 /*
2124                  * Ignore warning that we are the nfsmapid (can't happen on srv)
2125                  */
2126                 if (error == ENOTSUP)
2127                         error = 0;
2128                 if (error)
2129                         error = -1;     /* no match */
2130                 else if (sarg->vap->va_uid != uid)
2131                         error = -1;     /* no match */
2132                 break;
2133         case NFS4ATTR_FREEIT:
2134                 if (sarg->op == NFS4ATTR_GETIT) {
2135                         if (na->owner.utf8string_val) {
2136                                 UTF8STRING_FREE(na->owner)
2137                                 bzero(&na->owner, sizeof (na->owner));
2138                         }
2139                 }
2140                 break;
2141         }
2142         return (error);
2143 }
2144
2145 /* ARGSUSED */
2146 static int
2147 rfs4_fattr4_owner_group(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
2148     union nfs4_attr_u *na)
2149 {
2150         int     error = 0;
2151         gid_t   gid;
2152
2153         if (RFS4_MANDATTR_ONLY)
2154                 return (ENOTSUP);
2155
2156         switch (cmd) {
2157         case NFS4ATTR_SUPPORTED:
2158                 break;          /* this attr is supported */
2159         case NFS4ATTR_GETIT:
2160                 if (sarg->rdattr_error && !(sarg->vap->va_mask & VATTR_GID)) {
2161                         error = -1;     /* may be okay if rdattr_error */
2162                         break;
2163                 }
2164                 ASSERT(sarg->vap->va_mask & VATTR_GID);
2165
2166                 /*
2167                  * There are well defined polices for what happens on server-
2168                  * side GETATTR when gid to attribute string conversion cannot
2169                  * occur. Please refer to nfs4_idmap.c for details.
2170                  */
2171                 error = nfs_idmap_gid_str(sarg->vap->va_gid, &na->owner_group,
2172                     TRUE);
2173                 switch (error) {
2174                 case ECONNREFUSED:
2175                         error = NFS4ERR_DELAY;
2176                         break;
2177                 default:
2178                         break;
2179                 }
2180                 break;
2181
2182         case NFS4ATTR_SETIT:
2183                 ASSERT(sarg->vap->va_mask & VATTR_GID);
2184
2185                 /*
2186                  * There are well defined policies for what happens on server-
2187                  * side SETATTR of 'owner_group' when a "group@domain" mapping
2188                  * cannot occur. Please refer to nfs4_idmap.c for details.
2189                  *
2190                  * Any other errors, such as the mapping not being found by
2191                  * nfsmapid(1m), and interrupted clnt_call, etc, will result
2192                  * in NFS4ERR_BADOWNER.
2193                  *
2194                  * XXX need to return consistent errors, perhaps all
2195                  * server side attribute routines should return NFS4ERR*.
2196                  */
2197                 error = nfs_idmap_str_gid(&na->owner_group, &sarg->vap->va_gid,
2198                     TRUE);
2199                 switch (error) {
2200                 case NFS4_OK:
2201                 case ENOTSUP:
2202                         /*
2203                          * Ignore warning that we are the
2204                          * nfsmapid (can't happen on srv)
2205                          */
2206                         error = 0;
2207                         MSG_PRT_DEBUG = FALSE;
2208                         break;
2209
2210                 case ECOMM:
2211                 case ECONNREFUSED:
2212                         if (!MSG_PRT_DEBUG) {
2213                                 /*
2214                                  * printed just once per daemon death,
2215                                  * inform the user and then stay silent
2216                                  */
2217                                 cmn_err(CE_WARN, "!Unable to contact "
2218                                     "nfsmapid");
2219                                 MSG_PRT_DEBUG = TRUE;
2220                         }
2221                         error = NFS4ERR_DELAY;
2222                         break;
2223
2224                 case EINVAL:
2225                         error = NFS4ERR_INVAL;
2226                         break;
2227
2228                 default:
2229                         error = NFS4ERR_BADOWNER;
2230                         break;
2231                 }
2232                 break;
2233
2234         case NFS4ATTR_VERIT:
2235                 ASSERT(sarg->vap->va_mask & VATTR_GID);
2236                 error = nfs_idmap_str_gid(&na->owner_group, &gid, TRUE);
2237                 /*
2238                  * Ignore warning that we are the nfsmapid (can't happen on srv)
2239                  */
2240                 if (error == ENOTSUP)
2241                         error = 0;
2242                 if (error)
2243                         error = -1;     /* no match */
2244                 else if (sarg->vap->va_gid != gid)
2245                         error = -1;     /* no match */
2246                 break;
2247         case NFS4ATTR_FREEIT:
2248                 if (sarg->op == NFS4ATTR_GETIT) {
2249                         if (na->owner_group.utf8string_val) {
2250                                 UTF8STRING_FREE(na->owner_group)
2251                                 bzero(&na->owner_group,
2252                                     sizeof (na->owner_group));
2253                         }
2254                 }
2255                 break;
2256         }
2257         return (error);
2258 }
2259
2260 /* XXX - quota attributes should be supportable on Solaris 2 */
2261 /* ARGSUSED */
2262 static int
2263 rfs4_fattr4_quota_avail_hard(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
2264     union nfs4_attr_u *na)
2265 {
2266         return (ENOTSUP);
2267 }
2268
2269 /* ARGSUSED */
2270 static int
2271 rfs4_fattr4_quota_avail_soft(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
2272     union nfs4_attr_u *na)
2273 {
2274         return (ENOTSUP);
2275 }
2276
2277 /* ARGSUSED */
2278 static int
2279 rfs4_fattr4_quota_used(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
2280     union nfs4_attr_u *na)
2281 {
2282         return (ENOTSUP);
2283 }
2284
2285 /* ARGSUSED */
2286 static int
2287 rfs4_fattr4_rawdev(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
2288     union nfs4_attr_u *na)
2289 {
2290         int     error = 0;
2291
2292         if (RFS4_MANDATTR_ONLY)
2293                 return (ENOTSUP);
2294
2295         switch (cmd) {
2296         case NFS4ATTR_SUPPORTED:
2297                 if (sarg->op == NFS4ATTR_SETIT)
2298                         error = EINVAL;
2299                 break;          /* this attr is supported */
2300         case NFS4ATTR_GETIT:
2301                 if (sarg->rdattr_error && !(sarg->vap->va_mask & VATTR_RDEV)) {
2302                         error = -1;     /* may be okay if rdattr_error */
2303                         break;
2304                 }
2305                 ASSERT(sarg->vap->va_mask & VATTR_RDEV);
2306                 na->rawdev.specdata1 =  (uint32)getmajor(sarg->vap->va_rdev);
2307                 na->rawdev.specdata2 =  (uint32)getminor(sarg->vap->va_rdev);
2308                 break;
2309         case NFS4ATTR_SETIT:
2310                 /*
2311                  * read-only attr
2312                  */
2313                 error = EINVAL;
2314                 break;
2315         case NFS4ATTR_VERIT:
2316                 ASSERT(sarg->vap->va_mask & VATTR_RDEV);
2317                 if ((na->rawdev.specdata1 !=
2318                     (uint32)getmajor(sarg->vap->va_rdev)) ||
2319                     (na->rawdev.specdata2 !=
2320                     (uint32)getminor(sarg->vap->va_rdev)))
2321                         error = -1;     /* no match */
2322                 break;
2323         case NFS4ATTR_FREEIT:
2324                 break;
2325         }
2326         return (error);
2327 }
2328
2329 /* ARGSUSED */
2330 static int
2331 rfs4_fattr4_space_avail(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
2332     union nfs4_attr_u *na)
2333 {
2334         int     error = 0;
2335
2336         if (RFS4_MANDATTR_ONLY)
2337                 return (ENOTSUP);
2338
2339         switch (cmd) {
2340         case NFS4ATTR_SUPPORTED:
2341                 if (sarg->op == NFS4ATTR_SETIT)
2342                         error = EINVAL;
2343                 break;          /* this attr is supported */
2344         case NFS4ATTR_GETIT:
2345                 if (sarg->rdattr_error && (sarg->sbp == NULL)) {
2346                         error = -1;     /* may be okay if rdattr_error */
2347                         break;
2348                 }
2349                 ASSERT(sarg->sbp != NULL);
2350                 if (sarg->sbp->f_bavail != (fsblkcnt64_t)-1) {
2351                         na->space_avail =
2352                             (fattr4_space_avail) sarg->sbp->f_frsize *
2353                             (fattr4_space_avail) sarg->sbp->f_bavail;
2354                 } else {
2355                         na->space_avail =
2356                             (fattr4_space_avail) sarg->sbp->f_bavail;
2357                 }
2358                 break;
2359         case NFS4ATTR_SETIT:
2360                 /*
2361                  * read-only attr
2362                  */
2363                 error = EINVAL;
2364                 break;
2365         case NFS4ATTR_VERIT:
2366                 ASSERT(sarg->sbp != NULL);
2367                 if (sarg->sbp->f_bavail != na->space_avail)
2368                         error = -1;     /* no match */
2369                 break;
2370         case NFS4ATTR_FREEIT:
2371                 break;
2372         }
2373         return (error);
2374 }
2375
2376 /* ARGSUSED */
2377 static int
2378 rfs4_fattr4_space_free(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
2379     union nfs4_attr_u *na)
2380 {
2381         int     error = 0;
2382
2383         if (RFS4_MANDATTR_ONLY)
2384                 return (ENOTSUP);
2385
2386         switch (cmd) {
2387         case NFS4ATTR_SUPPORTED:
2388                 if (sarg->op == NFS4ATTR_SETIT)
2389                         error = EINVAL;
2390                 break;          /* this attr is supported */
2391         case NFS4ATTR_GETIT:
2392                 if (sarg->rdattr_error && (sarg->sbp == NULL)) {
2393                         error = -1;     /* may be okay if rdattr_error */
2394                         break;
2395                 }
2396                 ASSERT(sarg->sbp != NULL);
2397                 if (sarg->sbp->f_bfree != (fsblkcnt64_t)-1) {
2398                         na->space_free =
2399                             (fattr4_space_free) sarg->sbp->f_frsize *
2400                             (fattr4_space_free) sarg->sbp->f_bfree;
2401                 } else {
2402                         na->space_free =
2403                             (fattr4_space_free) sarg->sbp->f_bfree;
2404                 }
2405                 break;
2406         case NFS4ATTR_SETIT:
2407                 /*
2408                  * read-only attr
2409                  */
2410                 error = EINVAL;
2411                 break;
2412         case NFS4ATTR_VERIT:
2413                 ASSERT(sarg->sbp != NULL);
2414                 if (sarg->sbp->f_bfree != na->space_free)
2415                         error = -1;     /* no match */
2416                 break;
2417         case NFS4ATTR_FREEIT:
2418                 break;
2419         }
2420         return (error);
2421 }
2422
2423 /* ARGSUSED */
2424 static int
2425 rfs4_fattr4_space_total(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
2426     union nfs4_attr_u *na)
2427 {
2428         int     error = 0;
2429
2430         if (RFS4_MANDATTR_ONLY)
2431                 return (ENOTSUP);
2432
2433         switch (cmd) {
2434         case NFS4ATTR_SUPPORTED:
2435                 if (sarg->op == NFS4ATTR_SETIT)
2436                         error = EINVAL;
2437                 break;          /* this attr is supported */
2438         case NFS4ATTR_GETIT:
2439                 if (sarg->rdattr_error_req && (sarg->sbp == NULL)) {
2440                         error = -1;     /* may be okay if rdattr_error */
2441                         break;
2442                 }
2443                 ASSERT(sarg->sbp != NULL);
2444                 if (sarg->sbp->f_blocks != (fsblkcnt64_t)-1) {
2445                         na->space_total =
2446                             (fattr4_space_total) sarg->sbp->f_frsize *
2447                             (fattr4_space_total) sarg->sbp->f_blocks;
2448                 } else {
2449                         na->space_total =
2450                             (fattr4_space_total) sarg->sbp->f_blocks;
2451                 }
2452                 break;
2453         case NFS4ATTR_SETIT:
2454                 /*
2455                  * read-only attr
2456                  */
2457                 error = EINVAL;
2458                 break;
2459         case NFS4ATTR_VERIT:
2460                 ASSERT(sarg->sbp != NULL);
2461                 if (sarg->sbp->f_blocks != na->space_total)
2462                         error = -1;     /* no match */
2463                 break;
2464         case NFS4ATTR_FREEIT:
2465                 break;
2466         }
2467         return (error);
2468 }
2469
2470 /* ARGSUSED */
2471 static int
2472 rfs4_fattr4_space_used(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
2473     union nfs4_attr_u *na)
2474 {
2475         int     error = 0;
2476
2477         if (RFS4_MANDATTR_ONLY)
2478                 return (ENOTSUP);
2479
2480         switch (cmd) {
2481         case NFS4ATTR_SUPPORTED:
2482                 if (sarg->op == NFS4ATTR_SETIT)
2483                         error = EINVAL;
2484                 break;          /* this attr is supported */
2485         case NFS4ATTR_GETIT:
2486                 if (sarg->rdattr_error && !(sarg->vap->va_mask & VATTR_NBLOCKS)) {
2487                         error = -1;     /* may be okay if rdattr_error */
2488                         break;
2489                 }
2490                 ASSERT(sarg->vap->va_mask & VATTR_NBLOCKS);
2491                 na->space_used =  (fattr4_space_used) DEV_BSIZE *
2492                     (fattr4_space_used) sarg->vap->va_nblocks;
2493                 break;
2494         case NFS4ATTR_SETIT:
2495                 /*
2496                  * read-only attr
2497                  */
2498                 error = EINVAL;
2499                 break;
2500         case NFS4ATTR_VERIT:
2501                 ASSERT(sarg->vap->va_mask & VATTR_NBLOCKS);
2502                 if (sarg->vap->va_nblocks != na->space_used)
2503                         error = -1;     /* no match */
2504                 break;
2505         case NFS4ATTR_FREEIT:
2506                 break;
2507         }
2508         return (error);
2509 }
2510
2511 /* ARGSUSED */
2512 static int
2513 rfs4_fattr4_system(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
2514     union nfs4_attr_u *na)
2515 {
2516         return (ENOTSUP);
2517 }
2518
2519 /* ARGSUSED */
2520 static int
2521 rfs4_fattr4_time_access(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
2522     union nfs4_attr_u *na)
2523 {
2524         int     error = 0;
2525         timestruc_t atime;
2526
2527         if (RFS4_MANDATTR_ONLY)
2528                 return (ENOTSUP);
2529
2530         switch (cmd) {
2531         case NFS4ATTR_SUPPORTED:
2532                 if (sarg->op == NFS4ATTR_SETIT)
2533                         error = EINVAL;
2534                 break;          /* this attr is supported */
2535         case NFS4ATTR_GETIT:
2536                 if (sarg->rdattr_error && !(sarg->vap->va_mask & VATTR_ATIME)) {
2537                         error = -1;     /* may be okay if rdattr_error */
2538                         break;
2539                 }
2540                 ASSERT(sarg->vap->va_mask & VATTR_ATIME);
2541                 error = nfs4_time_vton(&sarg->vap->va_atime, &na->time_access);
2542                 break;
2543         case NFS4ATTR_SETIT:
2544                 /*
2545                  * read-only attr
2546                  */
2547                 error = EINVAL;
2548                 break;
2549         case NFS4ATTR_VERIT:
2550                 ASSERT(sarg->vap->va_mask & VATTR_ATIME);
2551                 error = nfs4_time_ntov(&na->time_access, &atime);
2552                 if (error)
2553                         break;
2554                 if (bcmp(&atime, &sarg->vap->va_atime, sizeof (atime)))
2555                         error = -1;     /* no match */
2556                 break;
2557         case NFS4ATTR_FREEIT:
2558                 break;
2559         }
2560         return (error);
2561 }
2562
2563 /*
2564  * XXX - need to support the setting of access time
2565  */
2566 /* ARGSUSED */
2567 static int
2568 rfs4_fattr4_time_access_set(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
2569     union nfs4_attr_u *na)
2570 {
2571         int     error = 0;
2572         settime4 *ta;
2573
2574         if (RFS4_MANDATTR_ONLY)
2575                 return (ENOTSUP);
2576
2577         switch (cmd) {
2578         case NFS4ATTR_SUPPORTED:
2579                 if ((sarg->op == NFS4ATTR_GETIT) ||
2580                     (sarg->op == NFS4ATTR_VERIT))
2581                         error = EINVAL;
2582                 break;          /* this attr is supported */
2583         case NFS4ATTR_GETIT:
2584         case NFS4ATTR_VERIT:
2585                 /*
2586                  * write only attr
2587                  */
2588                 error = EINVAL;
2589                 break;
2590         case NFS4ATTR_SETIT:
2591                 ASSERT(sarg->vap->va_mask & VATTR_ATIME);
2592                 /*
2593                  * Set access time (by server or by client)
2594                  */
2595                 ta = &na->time_access_set;
2596                 if (ta->set_it == SET_TO_CLIENT_TIME4) {
2597                         error = nfs4_time_ntov(&ta->time, &sarg->vap->va_atime);
2598                 } else if (ta->set_it == SET_TO_SERVER_TIME4) {
2599                         gethrestime(&sarg->vap->va_atime);
2600                 } else {
2601                         error = EINVAL;
2602                 }
2603                 break;
2604         case NFS4ATTR_FREEIT:
2605                 break;
2606         }
2607         return (error);
2608 }
2609
2610 /* ARGSUSED */
2611 static int
2612 rfs4_fattr4_time_backup(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
2613     union nfs4_attr_u *na)
2614 {
2615         return (ENOTSUP);
2616 }
2617
2618 /* ARGSUSED */
2619 static int
2620 rfs4_fattr4_time_create(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
2621     union nfs4_attr_u *na)
2622 {
2623         return (ENOTSUP);
2624 }
2625
2626 /* ARGSUSED */
2627 static int
2628 rfs4_fattr4_time_delta(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
2629     union nfs4_attr_u *na)
2630 {
2631         int error = 0;
2632
2633         if (RFS4_MANDATTR_ONLY)
2634                 return (ENOTSUP);
2635
2636         switch (cmd) {
2637         case NFS4ATTR_SUPPORTED:
2638                 if (sarg->op == NFS4ATTR_SETIT)
2639                         error = EINVAL;
2640                 break;          /* this attr is supported */
2641         case NFS4ATTR_GETIT:
2642                 na->time_delta.seconds = 0;
2643                 na->time_delta.nseconds = 1000;
2644                 break;
2645         case NFS4ATTR_SETIT:
2646                 /*
2647                  * write only attr
2648                  */
2649                 error = EINVAL;
2650                 break;
2651         case NFS4ATTR_VERIT:
2652                 if ((na->time_delta.seconds != 0) ||
2653                     (na->time_delta.nseconds != 1000))
2654                         error = -1;     /* no match */
2655                 break;
2656         case NFS4ATTR_FREEIT:
2657                 break;
2658         }
2659         return (error);
2660 }
2661
2662 /* ARGSUSED */
2663 static int
2664 rfs4_fattr4_time_metadata(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
2665     union nfs4_attr_u *na)
2666 {
2667         int     error = 0;
2668         timestruc_t ctime;
2669
2670         if (RFS4_MANDATTR_ONLY)
2671                 return (ENOTSUP);
2672
2673         switch (cmd) {
2674         case NFS4ATTR_SUPPORTED:
2675                 if (sarg->op == NFS4ATTR_SETIT)
2676                         error = EINVAL;
2677                 break;          /* this attr is supported */
2678         case NFS4ATTR_GETIT:
2679                 if (sarg->rdattr_error && !(sarg->vap->va_mask & VATTR_CTIME)) {
2680                         error = -1;     /* may be okay if rdattr_error */
2681                         break;
2682                 }
2683                 ASSERT(sarg->vap->va_mask & VATTR_CTIME);
2684                 error = nfs4_time_vton(&sarg->vap->va_ctime,
2685                     &na->time_metadata);
2686                 break;
2687         case NFS4ATTR_SETIT:
2688                 /*
2689                  * read-only attr
2690                  */
2691                 error = EINVAL;
2692                 break;
2693         case NFS4ATTR_VERIT:
2694                 ASSERT(sarg->vap->va_mask & VATTR_CTIME);
2695                 error = nfs4_time_ntov(&na->time_metadata, &ctime);
2696                 if (error)
2697                         break;
2698                 if (bcmp(&ctime, &sarg->vap->va_ctime, sizeof (ctime)))
2699                         error = -1;     /* no match */
2700                 break;
2701         case NFS4ATTR_FREEIT:
2702                 break;
2703         }
2704         return (error);
2705 }
2706
2707 /* ARGSUSED */
2708 static int
2709 rfs4_fattr4_time_modify(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
2710     union nfs4_attr_u *na)
2711 {
2712         int     error = 0;
2713         timestruc_t mtime;
2714
2715         if (RFS4_MANDATTR_ONLY)
2716                 return (ENOTSUP);
2717
2718         switch (cmd) {
2719         case NFS4ATTR_SUPPORTED:
2720                 if (sarg->op == NFS4ATTR_SETIT)
2721                         error = EINVAL;
2722                 break;          /* this attr is supported */
2723         case NFS4ATTR_GETIT:
2724                 if (sarg->rdattr_error && !(sarg->vap->va_mask & VATTR_MTIME)) {
2725                         error = -1;     /* may be okay if rdattr_error */
2726                         break;
2727                 }
2728                 ASSERT(sarg->vap->va_mask & VATTR_MTIME);
2729                 error = nfs4_time_vton(&sarg->vap->va_mtime, &na->time_modify);
2730                 break;
2731         case NFS4ATTR_SETIT:
2732                 /*
2733                  * read-only attr
2734                  */
2735                 error = EINVAL;
2736                 break;
2737         case NFS4ATTR_VERIT:
2738                 ASSERT(sarg->vap->va_mask & VATTR_MTIME);
2739                 error = nfs4_time_ntov(&na->time_modify, &mtime);
2740                 if (error)
2741                         break;
2742                 if (bcmp(&mtime, &sarg->vap->va_mtime, sizeof (mtime)))
2743                         error = -1;     /* no match */
2744                 break;
2745         case NFS4ATTR_FREEIT:
2746                 break;
2747         }
2748         return (error);
2749 }
2750
2751 /*
2752  * XXX - need to add support for setting modify time
2753  */
2754 /* ARGSUSED */
2755 static int
2756 rfs4_fattr4_time_modify_set(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
2757     union nfs4_attr_u *na)
2758 {
2759         int     error = 0;
2760         settime4 *tm;
2761
2762         if (RFS4_MANDATTR_ONLY)
2763                 return (ENOTSUP);
2764
2765         switch (cmd) {
2766         case NFS4ATTR_SUPPORTED:
2767                 if ((sarg->op == NFS4ATTR_GETIT) ||
2768                     (sarg->op == NFS4ATTR_VERIT))
2769                         error = EINVAL;
2770                 break;          /* this attr is supported */
2771         case NFS4ATTR_GETIT:
2772         case NFS4ATTR_VERIT:
2773                 /*
2774                  * write only attr
2775                  */
2776                 error = EINVAL;
2777                 break;
2778         case NFS4ATTR_SETIT:
2779                 ASSERT(sarg->vap->va_mask & VATTR_MTIME);
2780                 /*
2781                  * Set modify time (by server or by client)
2782                  */
2783                 tm = &na->time_modify_set;
2784                 if (tm->set_it == SET_TO_CLIENT_TIME4) {
2785                         error = nfs4_time_ntov(&tm->time, &sarg->vap->va_mtime);
2786                         sarg->flag = ATTR_UTIME;
2787                 } else if (tm->set_it == SET_TO_SERVER_TIME4) {
2788                         gethrestime(&sarg->vap->va_mtime);
2789                 } else {
2790                         error = EINVAL;
2791                 }
2792                 break;
2793         case NFS4ATTR_FREEIT:
2794                 break;
2795         }
2796         return (error);
2797 }
2798
2799
2800 static void
2801 rfs4_ntov_init(void)
2802 {
2803         /* index must be same as corresponding FATTR4_* define */
2804         nfs4_ntov_map[0].sv_getit = rfs4_fattr4_supported_attrs;
2805         nfs4_ntov_map[1].sv_getit = rfs4_fattr4_type;
2806         nfs4_ntov_map[2].sv_getit = rfs4_fattr4_fh_expire_type;
2807         nfs4_ntov_map[3].sv_getit = rfs4_fattr4_change;
2808         nfs4_ntov_map[4].sv_getit = rfs4_fattr4_size;
2809         nfs4_ntov_map[5].sv_getit = rfs4_fattr4_link_support;
2810         nfs4_ntov_map[6].sv_getit = rfs4_fattr4_symlink_support;
2811         nfs4_ntov_map[7].sv_getit = rfs4_fattr4_named_attr;
2812         nfs4_ntov_map[8].sv_getit = rfs4_fattr4_fsid;
2813         nfs4_ntov_map[9].sv_getit = rfs4_fattr4_unique_handles;
2814         nfs4_ntov_map[10].sv_getit = rfs4_fattr4_lease_time;
2815         nfs4_ntov_map[11].sv_getit = rfs4_fattr4_rdattr_error;
2816         nfs4_ntov_map[12].sv_getit = rfs4_fattr4_acl;
2817         nfs4_ntov_map[13].sv_getit = rfs4_fattr4_aclsupport;
2818         nfs4_ntov_map[14].sv_getit = rfs4_fattr4_archive;
2819         nfs4_ntov_map[15].sv_getit = rfs4_fattr4_cansettime;
2820         nfs4_ntov_map[16].sv_getit = rfs4_fattr4_case_insensitive;
2821         nfs4_ntov_map[17].sv_getit = rfs4_fattr4_case_preserving;
2822         nfs4_ntov_map[18].sv_getit = rfs4_fattr4_chown_restricted;
2823         nfs4_ntov_map[19].sv_getit = rfs4_fattr4_filehandle;
2824         nfs4_ntov_map[20].sv_getit = rfs4_fattr4_fileid;
2825         nfs4_ntov_map[21].sv_getit = rfs4_fattr4_files_avail;
2826         nfs4_ntov_map[22].sv_getit = rfs4_fattr4_files_free;
2827         nfs4_ntov_map[23].sv_getit = rfs4_fattr4_files_total;
2828         nfs4_ntov_map[24].sv_getit = rfs4_fattr4_fs_locations;
2829         nfs4_ntov_map[25].sv_getit = rfs4_fattr4_hidden;
2830         nfs4_ntov_map[26].sv_getit = rfs4_fattr4_homogeneous;
2831         nfs4_ntov_map[27].sv_getit = rfs4_fattr4_maxfilesize;
2832         nfs4_ntov_map[28].sv_getit = rfs4_fattr4_maxlink;
2833         nfs4_ntov_map[29].sv_getit = rfs4_fattr4_maxname;
2834         nfs4_ntov_map[30].sv_getit = rfs4_fattr4_maxread;
2835         nfs4_ntov_map[31].sv_getit = rfs4_fattr4_maxwrite;
2836         nfs4_ntov_map[32].sv_getit = rfs4_fattr4_mimetype;
2837         nfs4_ntov_map[33].sv_getit = rfs4_fattr4_mode;
2838         nfs4_ntov_map[34].sv_getit = rfs4_fattr4_no_trunc;
2839         nfs4_ntov_map[35].sv_getit = rfs4_fattr4_numlinks;
2840         nfs4_ntov_map[36].sv_getit = rfs4_fattr4_owner;
2841         nfs4_ntov_map[37].sv_getit = rfs4_fattr4_owner_group;
2842         nfs4_ntov_map[38].sv_getit = rfs4_fattr4_quota_avail_hard;
2843         nfs4_ntov_map[39].sv_getit = rfs4_fattr4_quota_avail_soft;
2844         nfs4_ntov_map[40].sv_getit = rfs4_fattr4_quota_used;
2845         nfs4_ntov_map[41].sv_getit = rfs4_fattr4_rawdev;
2846         nfs4_ntov_map[42].sv_getit = rfs4_fattr4_space_avail;
2847         nfs4_ntov_map[43].sv_getit = rfs4_fattr4_space_free;
2848         nfs4_ntov_map[44].sv_getit = rfs4_fattr4_space_total;
2849         nfs4_ntov_map[45].sv_getit = rfs4_fattr4_space_used;
2850         nfs4_ntov_map[46].sv_getit = rfs4_fattr4_system;
2851         nfs4_ntov_map[47].sv_getit = rfs4_fattr4_time_access;
2852         nfs4_ntov_map[48].sv_getit = rfs4_fattr4_time_access_set;
2853         nfs4_ntov_map[49].sv_getit = rfs4_fattr4_time_backup;
2854         nfs4_ntov_map[50].sv_getit = rfs4_fattr4_time_create;
2855         nfs4_ntov_map[51].sv_getit = rfs4_fattr4_time_delta;
2856         nfs4_ntov_map[52].sv_getit = rfs4_fattr4_time_metadata;
2857         nfs4_ntov_map[53].sv_getit = rfs4_fattr4_time_modify;
2858         nfs4_ntov_map[54].sv_getit = rfs4_fattr4_time_modify_set;
2859         nfs4_ntov_map[55].sv_getit = rfs4_fattr4_mounted_on_fileid;
2860 }