1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 
  22 /*
  23  * Copyright (c) 1988, 2010, Oracle and/or its affiliates. All rights reserved.
  24  */
  25 
  26 /*      Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
  27 /*        All Rights Reserved   */
  28 
  29 /*
  30  * University Copyright- Copyright (c) 1982, 1986, 1988
  31  * The Regents of the University of California
  32  * All Rights Reserved
  33  *
  34  * University Acknowledgment- Portions of this document are derived from
  35  * software developed by the University of California, Berkeley, and its
  36  * contributors.
  37  */
  38 
  39 #include <sys/types.h>
  40 #include <sys/param.h>
  41 #include <sys/t_lock.h>
  42 #include <sys/errno.h>
  43 #include <sys/cred.h>
  44 #include <sys/user.h>
  45 #include <sys/uio.h>
  46 #include <sys/file.h>
  47 #include <sys/pathname.h>
  48 #include <sys/vfs.h>
  49 #include <sys/vfs_opreg.h>
  50 #include <sys/vnode.h>
  51 #include <sys/rwstlock.h>
  52 #include <sys/fem.h>
  53 #include <sys/stat.h>
  54 #include <sys/mode.h>
  55 #include <sys/conf.h>
  56 #include <sys/sysmacros.h>
  57 #include <sys/cmn_err.h>
  58 #include <sys/systm.h>
  59 #include <sys/kmem.h>
  60 #include <sys/debug.h>
  61 #include <c2/audit.h>
  62 #include <sys/acl.h>
  63 #include <sys/nbmlock.h>
  64 #include <sys/fcntl.h>
  65 #include <fs/fs_subr.h>
  66 #include <sys/taskq.h>
  67 #include <fs/fs_reparse.h>
  68 #include <sys/fsh_impl.h>
  69 
  70 /* Determine if this vnode is a file that is read-only */
  71 #define ISROFILE(vp)    \
  72         ((vp)->v_type != VCHR && (vp)->v_type != VBLK && \
  73             (vp)->v_type != VFIFO && vn_is_readonly(vp))
  74 
  75 /* Tunable via /etc/system; used only by admin/install */
  76 int nfs_global_client_only;
  77 
  78 /*
  79  * Array of vopstats_t for per-FS-type vopstats.  This array has the same
  80  * number of entries as and parallel to the vfssw table.  (Arguably, it could
  81  * be part of the vfssw table.)  Once it's initialized, it's accessed using
  82  * the same fstype index that is used to index into the vfssw table.
  83  */
  84 vopstats_t **vopstats_fstype;
  85 
  86 /* vopstats initialization template used for fast initialization via bcopy() */
  87 static vopstats_t *vs_templatep;
  88 
  89 /* Kmem cache handle for vsk_anchor_t allocations */
  90 kmem_cache_t *vsk_anchor_cache;
  91 
  92 /* file events cleanup routine */
  93 extern void free_fopdata(vnode_t *);
  94 
  95 /*
  96  * Root of AVL tree for the kstats associated with vopstats.  Lock protects
  97  * updates to vsktat_tree.
  98  */
  99 avl_tree_t      vskstat_tree;
 100 kmutex_t        vskstat_tree_lock;
 101 
 102 /* Global variable which enables/disables the vopstats collection */
 103 int vopstats_enabled = 1;
 104 
 105 /*
 106  * forward declarations for internal vnode specific data (vsd)
 107  */
 108 static void *vsd_realloc(void *, size_t, size_t);
 109 
 110 /*
 111  * forward declarations for reparse point functions
 112  */
 113 static int fs_reparse_mark(char *target, vattr_t *vap, xvattr_t *xvattr);
 114 
 115 /*
 116  * VSD -- VNODE SPECIFIC DATA
 117  * The v_data pointer is typically used by a file system to store a
 118  * pointer to the file system's private node (e.g. ufs inode, nfs rnode).
 119  * However, there are times when additional project private data needs
 120  * to be stored separately from the data (node) pointed to by v_data.
 121  * This additional data could be stored by the file system itself or
 122  * by a completely different kernel entity.  VSD provides a way for
 123  * callers to obtain a key and store a pointer to private data associated
 124  * with a vnode.
 125  *
 126  * Callers are responsible for protecting the vsd by holding v_vsd_lock
 127  * for calls to vsd_set() and vsd_get().
 128  */
 129 
 130 /*
 131  * vsd_lock protects:
 132  *   vsd_nkeys - creation and deletion of vsd keys
 133  *   vsd_list - insertion and deletion of vsd_node in the vsd_list
 134  *   vsd_destructor - adding and removing destructors to the list
 135  */
 136 static kmutex_t         vsd_lock;
 137 static uint_t           vsd_nkeys;       /* size of destructor array */
 138 /* list of vsd_node's */
 139 static list_t *vsd_list = NULL;
 140 /* per-key destructor funcs */
 141 static void             (**vsd_destructor)(void *);
 142 
 143 /*
 144  * The following is the common set of actions needed to update the
 145  * vopstats structure from a vnode op.  Both VOPSTATS_UPDATE() and
 146  * VOPSTATS_UPDATE_IO() do almost the same thing, except for the
 147  * recording of the bytes transferred.  Since the code is similar
 148  * but small, it is nearly a duplicate.  Consequently any changes
 149  * to one may need to be reflected in the other.
 150  * Rundown of the variables:
 151  * vp - Pointer to the vnode
 152  * counter - Partial name structure member to update in vopstats for counts
 153  * bytecounter - Partial name structure member to update in vopstats for bytes
 154  * bytesval - Value to update in vopstats for bytes
 155  * fstype - Index into vsanchor_fstype[], same as index into vfssw[]
 156  * vsp - Pointer to vopstats structure (either in vfs or vsanchor_fstype[i])
 157  */
 158 
 159 #define VOPSTATS_UPDATE(vp, counter) {                                  \
 160         vfs_t *vfsp = (vp)->v_vfsp;                                  \
 161         if (vfsp && vfsp->vfs_implp &&                                       \
 162             (vfsp->vfs_flag & VFS_STATS) && (vp)->v_type != VBAD) {   \
 163                 vopstats_t *vsp = &vfsp->vfs_vopstats;                   \
 164                 uint64_t *stataddr = &(vsp->n##counter.value.ui64);      \
 165                 extern void __dtrace_probe___fsinfo_##counter(vnode_t *, \
 166                     size_t, uint64_t *);                                \
 167                 __dtrace_probe___fsinfo_##counter(vp, 0, stataddr);     \
 168                 (*stataddr)++;                                          \
 169                 if ((vsp = vfsp->vfs_fstypevsp) != NULL) {           \
 170                         vsp->n##counter.value.ui64++;                        \
 171                 }                                                       \
 172         }                                                               \
 173 }
 174 
 175 #define VOPSTATS_UPDATE_IO(vp, counter, bytecounter, bytesval) {        \
 176         vfs_t *vfsp = (vp)->v_vfsp;                                  \
 177         if (vfsp && vfsp->vfs_implp &&                                       \
 178             (vfsp->vfs_flag & VFS_STATS) && (vp)->v_type != VBAD) {   \
 179                 vopstats_t *vsp = &vfsp->vfs_vopstats;                   \
 180                 uint64_t *stataddr = &(vsp->n##counter.value.ui64);      \
 181                 extern void __dtrace_probe___fsinfo_##counter(vnode_t *, \
 182                     size_t, uint64_t *);                                \
 183                 __dtrace_probe___fsinfo_##counter(vp, bytesval, stataddr); \
 184                 (*stataddr)++;                                          \
 185                 vsp->bytecounter.value.ui64 += bytesval;             \
 186                 if ((vsp = vfsp->vfs_fstypevsp) != NULL) {           \
 187                         vsp->n##counter.value.ui64++;                        \
 188                         vsp->bytecounter.value.ui64 += bytesval;     \
 189                 }                                                       \
 190         }                                                               \
 191 }
 192 
 193 /*
 194  * If the filesystem does not support XIDs map credential
 195  * If the vfsp is NULL, perhaps we should also map?
 196  */
 197 #define VOPXID_MAP_CR(vp, cr)   {                                       \
 198         vfs_t *vfsp = (vp)->v_vfsp;                                  \
 199         if (vfsp != NULL && (vfsp->vfs_flag & VFS_XID) == 0)             \
 200                 cr = crgetmapped(cr);                                   \
 201         }
 202 
 203 /*
 204  * Convert stat(2) formats to vnode types and vice versa.  (Knows about
 205  * numerical order of S_IFMT and vnode types.)
 206  */
 207 enum vtype iftovt_tab[] = {
 208         VNON, VFIFO, VCHR, VNON, VDIR, VNON, VBLK, VNON,
 209         VREG, VNON, VLNK, VNON, VSOCK, VNON, VNON, VNON
 210 };
 211 
 212 ushort_t vttoif_tab[] = {
 213         0, S_IFREG, S_IFDIR, S_IFBLK, S_IFCHR, S_IFLNK, S_IFIFO,
 214         S_IFDOOR, 0, S_IFSOCK, S_IFPORT, 0
 215 };
 216 
 217 /*
 218  * The system vnode cache.
 219  */
 220 
 221 kmem_cache_t *vn_cache;
 222 
 223 
 224 /*
 225  * Vnode operations vector.
 226  */
 227 
 228 static const fs_operation_trans_def_t vn_ops_table[] = {
 229         VOPNAME_OPEN, offsetof(struct vnodeops, vop_open),
 230             fs_nosys, fs_nosys,
 231 
 232         VOPNAME_CLOSE, offsetof(struct vnodeops, vop_close),
 233             fs_nosys, fs_nosys,
 234 
 235         VOPNAME_READ, offsetof(struct vnodeops, vop_read),
 236             fs_nosys, fs_nosys,
 237 
 238         VOPNAME_WRITE, offsetof(struct vnodeops, vop_write),
 239             fs_nosys, fs_nosys,
 240 
 241         VOPNAME_IOCTL, offsetof(struct vnodeops, vop_ioctl),
 242             fs_nosys, fs_nosys,
 243 
 244         VOPNAME_SETFL, offsetof(struct vnodeops, vop_setfl),
 245             fs_setfl, fs_nosys,
 246 
 247         VOPNAME_GETATTR, offsetof(struct vnodeops, vop_getattr),
 248             fs_nosys, fs_nosys,
 249 
 250         VOPNAME_SETATTR, offsetof(struct vnodeops, vop_setattr),
 251             fs_nosys, fs_nosys,
 252 
 253         VOPNAME_ACCESS, offsetof(struct vnodeops, vop_access),
 254             fs_nosys, fs_nosys,
 255 
 256         VOPNAME_LOOKUP, offsetof(struct vnodeops, vop_lookup),
 257             fs_nosys, fs_nosys,
 258 
 259         VOPNAME_CREATE, offsetof(struct vnodeops, vop_create),
 260             fs_nosys, fs_nosys,
 261 
 262         VOPNAME_REMOVE, offsetof(struct vnodeops, vop_remove),
 263             fs_nosys, fs_nosys,
 264 
 265         VOPNAME_LINK, offsetof(struct vnodeops, vop_link),
 266             fs_nosys, fs_nosys,
 267 
 268         VOPNAME_RENAME, offsetof(struct vnodeops, vop_rename),
 269             fs_nosys, fs_nosys,
 270 
 271         VOPNAME_MKDIR, offsetof(struct vnodeops, vop_mkdir),
 272             fs_nosys, fs_nosys,
 273 
 274         VOPNAME_RMDIR, offsetof(struct vnodeops, vop_rmdir),
 275             fs_nosys, fs_nosys,
 276 
 277         VOPNAME_READDIR, offsetof(struct vnodeops, vop_readdir),
 278             fs_nosys, fs_nosys,
 279 
 280         VOPNAME_SYMLINK, offsetof(struct vnodeops, vop_symlink),
 281             fs_nosys, fs_nosys,
 282 
 283         VOPNAME_READLINK, offsetof(struct vnodeops, vop_readlink),
 284             fs_nosys, fs_nosys,
 285 
 286         VOPNAME_FSYNC, offsetof(struct vnodeops, vop_fsync),
 287             fs_nosys, fs_nosys,
 288 
 289         VOPNAME_INACTIVE, offsetof(struct vnodeops, vop_inactive),
 290             fs_nosys, fs_nosys,
 291 
 292         VOPNAME_FID, offsetof(struct vnodeops, vop_fid),
 293             fs_nosys, fs_nosys,
 294 
 295         VOPNAME_RWLOCK, offsetof(struct vnodeops, vop_rwlock),
 296             fs_rwlock, fs_rwlock,
 297 
 298         VOPNAME_RWUNLOCK, offsetof(struct vnodeops, vop_rwunlock),
 299             (fs_generic_func_p) fs_rwunlock,
 300             (fs_generic_func_p) fs_rwunlock,    /* no errors allowed */
 301 
 302         VOPNAME_SEEK, offsetof(struct vnodeops, vop_seek),
 303             fs_nosys, fs_nosys,
 304 
 305         VOPNAME_CMP, offsetof(struct vnodeops, vop_cmp),
 306             fs_cmp, fs_cmp,             /* no errors allowed */
 307 
 308         VOPNAME_FRLOCK, offsetof(struct vnodeops, vop_frlock),
 309             fs_frlock, fs_nosys,
 310 
 311         VOPNAME_SPACE, offsetof(struct vnodeops, vop_space),
 312             fs_nosys, fs_nosys,
 313 
 314         VOPNAME_REALVP, offsetof(struct vnodeops, vop_realvp),
 315             fs_nosys, fs_nosys,
 316 
 317         VOPNAME_GETPAGE, offsetof(struct vnodeops, vop_getpage),
 318             fs_nosys, fs_nosys,
 319 
 320         VOPNAME_PUTPAGE, offsetof(struct vnodeops, vop_putpage),
 321             fs_nosys, fs_nosys,
 322 
 323         VOPNAME_MAP, offsetof(struct vnodeops, vop_map),
 324             (fs_generic_func_p) fs_nosys_map,
 325             (fs_generic_func_p) fs_nosys_map,
 326 
 327         VOPNAME_ADDMAP, offsetof(struct vnodeops, vop_addmap),
 328             (fs_generic_func_p) fs_nosys_addmap,
 329             (fs_generic_func_p) fs_nosys_addmap,
 330 
 331         VOPNAME_DELMAP, offsetof(struct vnodeops, vop_delmap),
 332             fs_nosys, fs_nosys,
 333 
 334         VOPNAME_POLL, offsetof(struct vnodeops, vop_poll),
 335             (fs_generic_func_p) fs_poll, (fs_generic_func_p) fs_nosys_poll,
 336 
 337         VOPNAME_DUMP, offsetof(struct vnodeops, vop_dump),
 338             fs_nosys, fs_nosys,
 339 
 340         VOPNAME_PATHCONF, offsetof(struct vnodeops, vop_pathconf),
 341             fs_pathconf, fs_nosys,
 342 
 343         VOPNAME_PAGEIO, offsetof(struct vnodeops, vop_pageio),
 344             fs_nosys, fs_nosys,
 345 
 346         VOPNAME_DUMPCTL, offsetof(struct vnodeops, vop_dumpctl),
 347             fs_nosys, fs_nosys,
 348 
 349         VOPNAME_DISPOSE, offsetof(struct vnodeops, vop_dispose),
 350             (fs_generic_func_p) fs_dispose,
 351             (fs_generic_func_p) fs_nodispose,
 352 
 353         VOPNAME_SETSECATTR, offsetof(struct vnodeops, vop_setsecattr),
 354             fs_nosys, fs_nosys,
 355 
 356         VOPNAME_GETSECATTR, offsetof(struct vnodeops, vop_getsecattr),
 357             fs_fab_acl, fs_nosys,
 358 
 359         VOPNAME_SHRLOCK, offsetof(struct vnodeops, vop_shrlock),
 360             fs_shrlock, fs_nosys,
 361 
 362         VOPNAME_VNEVENT, offsetof(struct vnodeops, vop_vnevent),
 363             (fs_generic_func_p) fs_vnevent_nosupport,
 364             (fs_generic_func_p) fs_vnevent_nosupport,
 365 
 366         VOPNAME_REQZCBUF, offsetof(struct vnodeops, vop_reqzcbuf),
 367             fs_nosys, fs_nosys,
 368 
 369         VOPNAME_RETZCBUF, offsetof(struct vnodeops, vop_retzcbuf),
 370             fs_nosys, fs_nosys,
 371 
 372         NULL, 0, NULL, NULL
 373 };
 374 
 375 /* Extensible attribute (xva) routines. */
 376 
 377 /*
 378  * Zero out the structure, set the size of the requested/returned bitmaps,
 379  * set AT_XVATTR in the embedded vattr_t's va_mask, and set up the pointer
 380  * to the returned attributes array.
 381  */
 382 void
 383 xva_init(xvattr_t *xvap)
 384 {
 385         bzero(xvap, sizeof (xvattr_t));
 386         xvap->xva_mapsize = XVA_MAPSIZE;
 387         xvap->xva_magic = XVA_MAGIC;
 388         xvap->xva_vattr.va_mask = AT_XVATTR;
 389         xvap->xva_rtnattrmapp = &(xvap->xva_rtnattrmap)[0];
 390 }
 391 
 392 /*
 393  * If AT_XVATTR is set, returns a pointer to the embedded xoptattr_t
 394  * structure.  Otherwise, returns NULL.
 395  */
 396 xoptattr_t *
 397 xva_getxoptattr(xvattr_t *xvap)
 398 {
 399         xoptattr_t *xoap = NULL;
 400         if (xvap->xva_vattr.va_mask & AT_XVATTR)
 401                 xoap = &xvap->xva_xoptattrs;
 402         return (xoap);
 403 }
 404 
 405 /*
 406  * Used by the AVL routines to compare two vsk_anchor_t structures in the tree.
 407  * We use the f_fsid reported by VFS_STATVFS() since we use that for the
 408  * kstat name.
 409  */
 410 static int
 411 vska_compar(const void *n1, const void *n2)
 412 {
 413         int ret;
 414         ulong_t p1 = ((vsk_anchor_t *)n1)->vsk_fsid;
 415         ulong_t p2 = ((vsk_anchor_t *)n2)->vsk_fsid;
 416 
 417         if (p1 < p2) {
 418                 ret = -1;
 419         } else if (p1 > p2) {
 420                 ret = 1;
 421         } else {
 422                 ret = 0;
 423         }
 424 
 425         return (ret);
 426 }
 427 
 428 /*
 429  * Used to create a single template which will be bcopy()ed to a newly
 430  * allocated vsanchor_combo_t structure in new_vsanchor(), below.
 431  */
 432 static vopstats_t *
 433 create_vopstats_template()
 434 {
 435         vopstats_t              *vsp;
 436 
 437         vsp = kmem_alloc(sizeof (vopstats_t), KM_SLEEP);
 438         bzero(vsp, sizeof (*vsp));      /* Start fresh */
 439 
 440         /* VOP_OPEN */
 441         kstat_named_init(&vsp->nopen, "nopen", KSTAT_DATA_UINT64);
 442         /* VOP_CLOSE */
 443         kstat_named_init(&vsp->nclose, "nclose", KSTAT_DATA_UINT64);
 444         /* VOP_READ I/O */
 445         kstat_named_init(&vsp->nread, "nread", KSTAT_DATA_UINT64);
 446         kstat_named_init(&vsp->read_bytes, "read_bytes", KSTAT_DATA_UINT64);
 447         /* VOP_WRITE I/O */
 448         kstat_named_init(&vsp->nwrite, "nwrite", KSTAT_DATA_UINT64);
 449         kstat_named_init(&vsp->write_bytes, "write_bytes", KSTAT_DATA_UINT64);
 450         /* VOP_IOCTL */
 451         kstat_named_init(&vsp->nioctl, "nioctl", KSTAT_DATA_UINT64);
 452         /* VOP_SETFL */
 453         kstat_named_init(&vsp->nsetfl, "nsetfl", KSTAT_DATA_UINT64);
 454         /* VOP_GETATTR */
 455         kstat_named_init(&vsp->ngetattr, "ngetattr", KSTAT_DATA_UINT64);
 456         /* VOP_SETATTR */
 457         kstat_named_init(&vsp->nsetattr, "nsetattr", KSTAT_DATA_UINT64);
 458         /* VOP_ACCESS */
 459         kstat_named_init(&vsp->naccess, "naccess", KSTAT_DATA_UINT64);
 460         /* VOP_LOOKUP */
 461         kstat_named_init(&vsp->nlookup, "nlookup", KSTAT_DATA_UINT64);
 462         /* VOP_CREATE */
 463         kstat_named_init(&vsp->ncreate, "ncreate", KSTAT_DATA_UINT64);
 464         /* VOP_REMOVE */
 465         kstat_named_init(&vsp->nremove, "nremove", KSTAT_DATA_UINT64);
 466         /* VOP_LINK */
 467         kstat_named_init(&vsp->nlink, "nlink", KSTAT_DATA_UINT64);
 468         /* VOP_RENAME */
 469         kstat_named_init(&vsp->nrename, "nrename", KSTAT_DATA_UINT64);
 470         /* VOP_MKDIR */
 471         kstat_named_init(&vsp->nmkdir, "nmkdir", KSTAT_DATA_UINT64);
 472         /* VOP_RMDIR */
 473         kstat_named_init(&vsp->nrmdir, "nrmdir", KSTAT_DATA_UINT64);
 474         /* VOP_READDIR I/O */
 475         kstat_named_init(&vsp->nreaddir, "nreaddir", KSTAT_DATA_UINT64);
 476         kstat_named_init(&vsp->readdir_bytes, "readdir_bytes",
 477             KSTAT_DATA_UINT64);
 478         /* VOP_SYMLINK */
 479         kstat_named_init(&vsp->nsymlink, "nsymlink", KSTAT_DATA_UINT64);
 480         /* VOP_READLINK */
 481         kstat_named_init(&vsp->nreadlink, "nreadlink", KSTAT_DATA_UINT64);
 482         /* VOP_FSYNC */
 483         kstat_named_init(&vsp->nfsync, "nfsync", KSTAT_DATA_UINT64);
 484         /* VOP_INACTIVE */
 485         kstat_named_init(&vsp->ninactive, "ninactive", KSTAT_DATA_UINT64);
 486         /* VOP_FID */
 487         kstat_named_init(&vsp->nfid, "nfid", KSTAT_DATA_UINT64);
 488         /* VOP_RWLOCK */
 489         kstat_named_init(&vsp->nrwlock, "nrwlock", KSTAT_DATA_UINT64);
 490         /* VOP_RWUNLOCK */
 491         kstat_named_init(&vsp->nrwunlock, "nrwunlock", KSTAT_DATA_UINT64);
 492         /* VOP_SEEK */
 493         kstat_named_init(&vsp->nseek, "nseek", KSTAT_DATA_UINT64);
 494         /* VOP_CMP */
 495         kstat_named_init(&vsp->ncmp, "ncmp", KSTAT_DATA_UINT64);
 496         /* VOP_FRLOCK */
 497         kstat_named_init(&vsp->nfrlock, "nfrlock", KSTAT_DATA_UINT64);
 498         /* VOP_SPACE */
 499         kstat_named_init(&vsp->nspace, "nspace", KSTAT_DATA_UINT64);
 500         /* VOP_REALVP */
 501         kstat_named_init(&vsp->nrealvp, "nrealvp", KSTAT_DATA_UINT64);
 502         /* VOP_GETPAGE */
 503         kstat_named_init(&vsp->ngetpage, "ngetpage", KSTAT_DATA_UINT64);
 504         /* VOP_PUTPAGE */
 505         kstat_named_init(&vsp->nputpage, "nputpage", KSTAT_DATA_UINT64);
 506         /* VOP_MAP */
 507         kstat_named_init(&vsp->nmap, "nmap", KSTAT_DATA_UINT64);
 508         /* VOP_ADDMAP */
 509         kstat_named_init(&vsp->naddmap, "naddmap", KSTAT_DATA_UINT64);
 510         /* VOP_DELMAP */
 511         kstat_named_init(&vsp->ndelmap, "ndelmap", KSTAT_DATA_UINT64);
 512         /* VOP_POLL */
 513         kstat_named_init(&vsp->npoll, "npoll", KSTAT_DATA_UINT64);
 514         /* VOP_DUMP */
 515         kstat_named_init(&vsp->ndump, "ndump", KSTAT_DATA_UINT64);
 516         /* VOP_PATHCONF */
 517         kstat_named_init(&vsp->npathconf, "npathconf", KSTAT_DATA_UINT64);
 518         /* VOP_PAGEIO */
 519         kstat_named_init(&vsp->npageio, "npageio", KSTAT_DATA_UINT64);
 520         /* VOP_DUMPCTL */
 521         kstat_named_init(&vsp->ndumpctl, "ndumpctl", KSTAT_DATA_UINT64);
 522         /* VOP_DISPOSE */
 523         kstat_named_init(&vsp->ndispose, "ndispose", KSTAT_DATA_UINT64);
 524         /* VOP_SETSECATTR */
 525         kstat_named_init(&vsp->nsetsecattr, "nsetsecattr", KSTAT_DATA_UINT64);
 526         /* VOP_GETSECATTR */
 527         kstat_named_init(&vsp->ngetsecattr, "ngetsecattr", KSTAT_DATA_UINT64);
 528         /* VOP_SHRLOCK */
 529         kstat_named_init(&vsp->nshrlock, "nshrlock", KSTAT_DATA_UINT64);
 530         /* VOP_VNEVENT */
 531         kstat_named_init(&vsp->nvnevent, "nvnevent", KSTAT_DATA_UINT64);
 532         /* VOP_REQZCBUF */
 533         kstat_named_init(&vsp->nreqzcbuf, "nreqzcbuf", KSTAT_DATA_UINT64);
 534         /* VOP_RETZCBUF */
 535         kstat_named_init(&vsp->nretzcbuf, "nretzcbuf", KSTAT_DATA_UINT64);
 536 
 537         return (vsp);
 538 }
 539 
 540 /*
 541  * Creates a kstat structure associated with a vopstats structure.
 542  */
 543 kstat_t *
 544 new_vskstat(char *ksname, vopstats_t *vsp)
 545 {
 546         kstat_t         *ksp;
 547 
 548         if (!vopstats_enabled) {
 549                 return (NULL);
 550         }
 551 
 552         ksp = kstat_create("unix", 0, ksname, "misc", KSTAT_TYPE_NAMED,
 553             sizeof (vopstats_t)/sizeof (kstat_named_t),
 554             KSTAT_FLAG_VIRTUAL|KSTAT_FLAG_WRITABLE);
 555         if (ksp) {
 556                 ksp->ks_data = vsp;
 557                 kstat_install(ksp);
 558         }
 559 
 560         return (ksp);
 561 }
 562 
 563 /*
 564  * Called from vfsinit() to initialize the support mechanisms for vopstats
 565  */
 566 void
 567 vopstats_startup()
 568 {
 569         if (!vopstats_enabled)
 570                 return;
 571 
 572         /*
 573          * Creates the AVL tree which holds per-vfs vopstat anchors.  This
 574          * is necessary since we need to check if a kstat exists before we
 575          * attempt to create it.  Also, initialize its lock.
 576          */
 577         avl_create(&vskstat_tree, vska_compar, sizeof (vsk_anchor_t),
 578             offsetof(vsk_anchor_t, vsk_node));
 579         mutex_init(&vskstat_tree_lock, NULL, MUTEX_DEFAULT, NULL);
 580 
 581         vsk_anchor_cache = kmem_cache_create("vsk_anchor_cache",
 582             sizeof (vsk_anchor_t), sizeof (uintptr_t), NULL, NULL, NULL,
 583             NULL, NULL, 0);
 584 
 585         /*
 586          * Set up the array of pointers for the vopstats-by-FS-type.
 587          * The entries will be allocated/initialized as each file system
 588          * goes through modload/mod_installfs.
 589          */
 590         vopstats_fstype = (vopstats_t **)kmem_zalloc(
 591             (sizeof (vopstats_t *) * nfstype), KM_SLEEP);
 592 
 593         /* Set up the global vopstats initialization template */
 594         vs_templatep = create_vopstats_template();
 595 }
 596 
 597 /*
 598  * We need to have the all of the counters zeroed.
 599  * The initialization of the vopstats_t includes on the order of
 600  * 50 calls to kstat_named_init().  Rather that do that on every call,
 601  * we do it once in a template (vs_templatep) then bcopy it over.
 602  */
 603 void
 604 initialize_vopstats(vopstats_t *vsp)
 605 {
 606         if (vsp == NULL)
 607                 return;
 608 
 609         bcopy(vs_templatep, vsp, sizeof (vopstats_t));
 610 }
 611 
 612 /*
 613  * If possible, determine which vopstats by fstype to use and
 614  * return a pointer to the caller.
 615  */
 616 vopstats_t *
 617 get_fstype_vopstats(vfs_t *vfsp, struct vfssw *vswp)
 618 {
 619         int             fstype = 0;     /* Index into vfssw[] */
 620         vopstats_t      *vsp = NULL;
 621 
 622         if (vfsp == NULL || (vfsp->vfs_flag & VFS_STATS) == 0 ||
 623             !vopstats_enabled)
 624                 return (NULL);
 625         /*
 626          * Set up the fstype.  We go to so much trouble because all versions
 627          * of NFS use the same fstype in their vfs even though they have
 628          * distinct entries in the vfssw[] table.
 629          * NOTE: A special vfs (e.g., EIO_vfs) may not have an entry.
 630          */
 631         if (vswp) {
 632                 fstype = vswp - vfssw;  /* Gets us the index */
 633         } else {
 634                 fstype = vfsp->vfs_fstype;
 635         }
 636 
 637         /*
 638          * Point to the per-fstype vopstats. The only valid values are
 639          * non-zero positive values less than the number of vfssw[] table
 640          * entries.
 641          */
 642         if (fstype > 0 && fstype < nfstype) {
 643                 vsp = vopstats_fstype[fstype];
 644         }
 645 
 646         return (vsp);
 647 }
 648 
 649 /*
 650  * Generate a kstat name, create the kstat structure, and allocate a
 651  * vsk_anchor_t to hold it together.  Return the pointer to the vsk_anchor_t
 652  * to the caller.  This must only be called from a mount.
 653  */
 654 vsk_anchor_t *
 655 get_vskstat_anchor(vfs_t *vfsp)
 656 {
 657         char            kstatstr[KSTAT_STRLEN]; /* kstat name for vopstats */
 658         statvfs64_t     statvfsbuf;             /* Needed to find f_fsid */
 659         vsk_anchor_t    *vskp = NULL;           /* vfs <--> kstat anchor */
 660         kstat_t         *ksp;                   /* Ptr to new kstat */
 661         avl_index_t     where;                  /* Location in the AVL tree */
 662 
 663         if (vfsp == NULL || vfsp->vfs_implp == NULL ||
 664             (vfsp->vfs_flag & VFS_STATS) == 0 || !vopstats_enabled)
 665                 return (NULL);
 666 
 667         /* Need to get the fsid to build a kstat name */
 668         if (VFS_STATVFS(vfsp, &statvfsbuf) == 0) {
 669                 /* Create a name for our kstats based on fsid */
 670                 (void) snprintf(kstatstr, KSTAT_STRLEN, "%s%lx",
 671                     VOPSTATS_STR, statvfsbuf.f_fsid);
 672 
 673                 /* Allocate and initialize the vsk_anchor_t */
 674                 vskp = kmem_cache_alloc(vsk_anchor_cache, KM_SLEEP);
 675                 bzero(vskp, sizeof (*vskp));
 676                 vskp->vsk_fsid = statvfsbuf.f_fsid;
 677 
 678                 mutex_enter(&vskstat_tree_lock);
 679                 if (avl_find(&vskstat_tree, vskp, &where) == NULL) {
 680                         avl_insert(&vskstat_tree, vskp, where);
 681                         mutex_exit(&vskstat_tree_lock);
 682 
 683                         /*
 684                          * Now that we've got the anchor in the AVL
 685                          * tree, we can create the kstat.
 686                          */
 687                         ksp = new_vskstat(kstatstr, &vfsp->vfs_vopstats);
 688                         if (ksp) {
 689                                 vskp->vsk_ksp = ksp;
 690                         }
 691                 } else {
 692                         /* Oops, found one! Release memory and lock. */
 693                         mutex_exit(&vskstat_tree_lock);
 694                         kmem_cache_free(vsk_anchor_cache, vskp);
 695                         vskp = NULL;
 696                 }
 697         }
 698         return (vskp);
 699 }
 700 
 701 /*
 702  * We're in the process of tearing down the vfs and need to cleanup
 703  * the data structures associated with the vopstats. Must only be called
 704  * from dounmount().
 705  */
 706 void
 707 teardown_vopstats(vfs_t *vfsp)
 708 {
 709         vsk_anchor_t    *vskap;
 710         avl_index_t     where;
 711 
 712         if (vfsp == NULL || vfsp->vfs_implp == NULL ||
 713             (vfsp->vfs_flag & VFS_STATS) == 0 || !vopstats_enabled)
 714                 return;
 715 
 716         /* This is a safe check since VFS_STATS must be set (see above) */
 717         if ((vskap = vfsp->vfs_vskap) == NULL)
 718                 return;
 719 
 720         /* Whack the pointer right away */
 721         vfsp->vfs_vskap = NULL;
 722 
 723         /* Lock the tree, remove the node, and delete the kstat */
 724         mutex_enter(&vskstat_tree_lock);
 725         if (avl_find(&vskstat_tree, vskap, &where)) {
 726                 avl_remove(&vskstat_tree, vskap);
 727         }
 728 
 729         if (vskap->vsk_ksp) {
 730                 kstat_delete(vskap->vsk_ksp);
 731         }
 732         mutex_exit(&vskstat_tree_lock);
 733 
 734         kmem_cache_free(vsk_anchor_cache, vskap);
 735 }
 736 
 737 /*
 738  * Read or write a vnode.  Called from kernel code.
 739  */
 740 int
 741 vn_rdwr(
 742         enum uio_rw rw,
 743         struct vnode *vp,
 744         caddr_t base,
 745         ssize_t len,
 746         offset_t offset,
 747         enum uio_seg seg,
 748         int ioflag,
 749         rlim64_t ulimit,        /* meaningful only if rw is UIO_WRITE */
 750         cred_t *cr,
 751         ssize_t *residp)
 752 {
 753         struct uio uio;
 754         struct iovec iov;
 755         int error;
 756         int in_crit = 0;
 757 
 758         if (rw == UIO_WRITE && ISROFILE(vp))
 759                 return (EROFS);
 760 
 761         if (len < 0)
 762                 return (EIO);
 763 
 764         VOPXID_MAP_CR(vp, cr);
 765 
 766         iov.iov_base = base;
 767         iov.iov_len = len;
 768         uio.uio_iov = &iov;
 769         uio.uio_iovcnt = 1;
 770         uio.uio_loffset = offset;
 771         uio.uio_segflg = (short)seg;
 772         uio.uio_resid = len;
 773         uio.uio_llimit = ulimit;
 774 
 775         /*
 776          * We have to enter the critical region before calling VOP_RWLOCK
 777          * to avoid a deadlock with ufs.
 778          */
 779         if (nbl_need_check(vp)) {
 780                 int svmand;
 781 
 782                 nbl_start_crit(vp, RW_READER);
 783                 in_crit = 1;
 784                 error = nbl_svmand(vp, cr, &svmand);
 785                 if (error != 0)
 786                         goto done;
 787                 if (nbl_conflict(vp, rw == UIO_WRITE ? NBL_WRITE : NBL_READ,
 788                     uio.uio_offset, uio.uio_resid, svmand, NULL)) {
 789                         error = EACCES;
 790                         goto done;
 791                 }
 792         }
 793 
 794         (void) VOP_RWLOCK(vp,
 795             rw == UIO_WRITE ? V_WRITELOCK_TRUE : V_WRITELOCK_FALSE, NULL);
 796         if (rw == UIO_WRITE) {
 797                 uio.uio_fmode = FWRITE;
 798                 uio.uio_extflg = UIO_COPY_DEFAULT;
 799                 error = VOP_WRITE(vp, &uio, ioflag, cr, NULL);
 800         } else {
 801                 uio.uio_fmode = FREAD;
 802                 uio.uio_extflg = UIO_COPY_CACHED;
 803                 error = VOP_READ(vp, &uio, ioflag, cr, NULL);
 804         }
 805         VOP_RWUNLOCK(vp,
 806             rw == UIO_WRITE ? V_WRITELOCK_TRUE : V_WRITELOCK_FALSE, NULL);
 807         if (residp)
 808                 *residp = uio.uio_resid;
 809         else if (uio.uio_resid)
 810                 error = EIO;
 811 
 812 done:
 813         if (in_crit)
 814                 nbl_end_crit(vp);
 815         return (error);
 816 }
 817 
 818 /*
 819  * Release a vnode.  Call VOP_INACTIVE on last reference or
 820  * decrement reference count.
 821  *
 822  * To avoid race conditions, the v_count is left at 1 for
 823  * the call to VOP_INACTIVE. This prevents another thread
 824  * from reclaiming and releasing the vnode *before* the
 825  * VOP_INACTIVE routine has a chance to destroy the vnode.
 826  * We can't have more than 1 thread calling VOP_INACTIVE
 827  * on a vnode.
 828  */
 829 void
 830 vn_rele(vnode_t *vp)
 831 {
 832         VERIFY(vp->v_count > 0);
 833         mutex_enter(&vp->v_lock);
 834         if (vp->v_count == 1) {
 835                 mutex_exit(&vp->v_lock);
 836                 VOP_INACTIVE(vp, CRED(), NULL);
 837                 return;
 838         }
 839         vp->v_count--;
 840         mutex_exit(&vp->v_lock);
 841 }
 842 
 843 /*
 844  * Release a vnode referenced by the DNLC. Multiple DNLC references are treated
 845  * as a single reference, so v_count is not decremented until the last DNLC hold
 846  * is released. This makes it possible to distinguish vnodes that are referenced
 847  * only by the DNLC.
 848  */
 849 void
 850 vn_rele_dnlc(vnode_t *vp)
 851 {
 852         VERIFY((vp->v_count > 0) && (vp->v_count_dnlc > 0));
 853         mutex_enter(&vp->v_lock);
 854         if (--vp->v_count_dnlc == 0) {
 855                 if (vp->v_count == 1) {
 856                         mutex_exit(&vp->v_lock);
 857                         VOP_INACTIVE(vp, CRED(), NULL);
 858                         return;
 859                 }
 860                 vp->v_count--;
 861         }
 862         mutex_exit(&vp->v_lock);
 863 }
 864 
 865 /*
 866  * Like vn_rele() except that it clears v_stream under v_lock.
 867  * This is used by sockfs when it dismantels the association between
 868  * the sockfs node and the vnode in the underlaying file system.
 869  * v_lock has to be held to prevent a thread coming through the lookupname
 870  * path from accessing a stream head that is going away.
 871  */
 872 void
 873 vn_rele_stream(vnode_t *vp)
 874 {
 875         VERIFY(vp->v_count > 0);
 876         mutex_enter(&vp->v_lock);
 877         vp->v_stream = NULL;
 878         if (vp->v_count == 1) {
 879                 mutex_exit(&vp->v_lock);
 880                 VOP_INACTIVE(vp, CRED(), NULL);
 881                 return;
 882         }
 883         vp->v_count--;
 884         mutex_exit(&vp->v_lock);
 885 }
 886 
 887 static void
 888 vn_rele_inactive(vnode_t *vp)
 889 {
 890         VOP_INACTIVE(vp, CRED(), NULL);
 891 }
 892 
 893 /*
 894  * Like vn_rele() except if we are going to call VOP_INACTIVE() then do it
 895  * asynchronously using a taskq. This can avoid deadlocks caused by re-entering
 896  * the file system as a result of releasing the vnode. Note, file systems
 897  * already have to handle the race where the vnode is incremented before the
 898  * inactive routine is called and does its locking.
 899  *
 900  * Warning: Excessive use of this routine can lead to performance problems.
 901  * This is because taskqs throttle back allocation if too many are created.
 902  */
 903 void
 904 vn_rele_async(vnode_t *vp, taskq_t *taskq)
 905 {
 906         VERIFY(vp->v_count > 0);
 907         mutex_enter(&vp->v_lock);
 908         if (vp->v_count == 1) {
 909                 mutex_exit(&vp->v_lock);
 910                 VERIFY(taskq_dispatch(taskq, (task_func_t *)vn_rele_inactive,
 911                     vp, TQ_SLEEP) != NULL);
 912                 return;
 913         }
 914         vp->v_count--;
 915         mutex_exit(&vp->v_lock);
 916 }
 917 
 918 int
 919 vn_open(
 920         char *pnamep,
 921         enum uio_seg seg,
 922         int filemode,
 923         int createmode,
 924         struct vnode **vpp,
 925         enum create crwhy,
 926         mode_t umask)
 927 {
 928         return (vn_openat(pnamep, seg, filemode, createmode, vpp, crwhy,
 929             umask, NULL, -1));
 930 }
 931 
 932 
 933 /*
 934  * Open/create a vnode.
 935  * This may be callable by the kernel, the only known use
 936  * of user context being that the current user credentials
 937  * are used for permissions.  crwhy is defined iff filemode & FCREAT.
 938  */
 939 int
 940 vn_openat(
 941         char *pnamep,
 942         enum uio_seg seg,
 943         int filemode,
 944         int createmode,
 945         struct vnode **vpp,
 946         enum create crwhy,
 947         mode_t umask,
 948         struct vnode *startvp,
 949         int fd)
 950 {
 951         struct vnode *vp;
 952         int mode;
 953         int accessflags;
 954         int error;
 955         int in_crit = 0;
 956         int open_done = 0;
 957         int shrlock_done = 0;
 958         struct vattr vattr;
 959         enum symfollow follow;
 960         int estale_retry = 0;
 961         struct shrlock shr;
 962         struct shr_locowner shr_own;
 963 
 964         mode = 0;
 965         accessflags = 0;
 966         if (filemode & FREAD)
 967                 mode |= VREAD;
 968         if (filemode & (FWRITE|FTRUNC))
 969                 mode |= VWRITE;
 970         if (filemode & (FSEARCH|FEXEC|FXATTRDIROPEN))
 971                 mode |= VEXEC;
 972 
 973         /* symlink interpretation */
 974         if (filemode & FNOFOLLOW)
 975                 follow = NO_FOLLOW;
 976         else
 977                 follow = FOLLOW;
 978 
 979         if (filemode & FAPPEND)
 980                 accessflags |= V_APPEND;
 981 
 982 top:
 983         if (filemode & FCREAT) {
 984                 enum vcexcl excl;
 985 
 986                 /*
 987                  * Wish to create a file.
 988                  */
 989                 vattr.va_type = VREG;
 990                 vattr.va_mode = createmode;
 991                 vattr.va_mask = AT_TYPE|AT_MODE;
 992                 if (filemode & FTRUNC) {
 993                         vattr.va_size = 0;
 994                         vattr.va_mask |= AT_SIZE;
 995                 }
 996                 if (filemode & FEXCL)
 997                         excl = EXCL;
 998                 else
 999                         excl = NONEXCL;
1000 
1001                 if (error =
1002                     vn_createat(pnamep, seg, &vattr, excl, mode, &vp, crwhy,
1003                     (filemode & ~(FTRUNC|FEXCL)), umask, startvp))
1004                         return (error);
1005         } else {
1006                 /*
1007                  * Wish to open a file.  Just look it up.
1008                  */
1009                 if (error = lookupnameat(pnamep, seg, follow,
1010                     NULLVPP, &vp, startvp)) {
1011                         if ((error == ESTALE) &&
1012                             fs_need_estale_retry(estale_retry++))
1013                                 goto top;
1014                         return (error);
1015                 }
1016 
1017                 /*
1018                  * Get the attributes to check whether file is large.
1019                  * We do this only if the FOFFMAX flag is not set and
1020                  * only for regular files.
1021                  */
1022 
1023                 if (!(filemode & FOFFMAX) && (vp->v_type == VREG)) {
1024                         vattr.va_mask = AT_SIZE;
1025                         if ((error = VOP_GETATTR(vp, &vattr, 0,
1026                             CRED(), NULL))) {
1027                                 goto out;
1028                         }
1029                         if (vattr.va_size > (u_offset_t)MAXOFF32_T) {
1030                                 /*
1031                                  * Large File API - regular open fails
1032                                  * if FOFFMAX flag is set in file mode
1033                                  */
1034                                 error = EOVERFLOW;
1035                                 goto out;
1036                         }
1037                 }
1038                 /*
1039                  * Can't write directories, active texts, or
1040                  * read-only filesystems.  Can't truncate files
1041                  * on which mandatory locking is in effect.
1042                  */
1043                 if (filemode & (FWRITE|FTRUNC)) {
1044                         /*
1045                          * Allow writable directory if VDIROPEN flag is set.
1046                          */
1047                         if (vp->v_type == VDIR && !(vp->v_flag & VDIROPEN)) {
1048                                 error = EISDIR;
1049                                 goto out;
1050                         }
1051                         if (ISROFILE(vp)) {
1052                                 error = EROFS;
1053                                 goto out;
1054                         }
1055                         /*
1056                          * Can't truncate files on which
1057                          * sysv mandatory locking is in effect.
1058                          */
1059                         if (filemode & FTRUNC) {
1060                                 vnode_t *rvp;
1061 
1062                                 if (VOP_REALVP(vp, &rvp, NULL) != 0)
1063                                         rvp = vp;
1064                                 if (rvp->v_filocks != NULL) {
1065                                         vattr.va_mask = AT_MODE;
1066                                         if ((error = VOP_GETATTR(vp,
1067                                             &vattr, 0, CRED(), NULL)) == 0 &&
1068                                             MANDLOCK(vp, vattr.va_mode))
1069                                                 error = EAGAIN;
1070                                 }
1071                         }
1072                         if (error)
1073                                 goto out;
1074                 }
1075                 /*
1076                  * Check permissions.
1077                  */
1078                 if (error = VOP_ACCESS(vp, mode, accessflags, CRED(), NULL))
1079                         goto out;
1080                 /*
1081                  * Require FSEARCH to return a directory.
1082                  * Require FEXEC to return a regular file.
1083                  */
1084                 if ((filemode & FSEARCH) && vp->v_type != VDIR) {
1085                         error = ENOTDIR;
1086                         goto out;
1087                 }
1088                 if ((filemode & FEXEC) && vp->v_type != VREG) {
1089                         error = ENOEXEC;        /* XXX: error code? */
1090                         goto out;
1091                 }
1092         }
1093 
1094         /*
1095          * Do remaining checks for FNOFOLLOW and FNOLINKS.
1096          */
1097         if ((filemode & FNOFOLLOW) && vp->v_type == VLNK) {
1098                 error = ELOOP;
1099                 goto out;
1100         }
1101         if (filemode & FNOLINKS) {
1102                 vattr.va_mask = AT_NLINK;
1103                 if ((error = VOP_GETATTR(vp, &vattr, 0, CRED(), NULL))) {
1104                         goto out;
1105                 }
1106                 if (vattr.va_nlink != 1) {
1107                         error = EMLINK;
1108                         goto out;
1109                 }
1110         }
1111 
1112         /*
1113          * Opening a socket corresponding to the AF_UNIX pathname
1114          * in the filesystem name space is not supported.
1115          * However, VSOCK nodes in namefs are supported in order
1116          * to make fattach work for sockets.
1117          *
1118          * XXX This uses VOP_REALVP to distinguish between
1119          * an unopened namefs node (where VOP_REALVP returns a
1120          * different VSOCK vnode) and a VSOCK created by vn_create
1121          * in some file system (where VOP_REALVP would never return
1122          * a different vnode).
1123          */
1124         if (vp->v_type == VSOCK) {
1125                 struct vnode *nvp;
1126 
1127                 error = VOP_REALVP(vp, &nvp, NULL);
1128                 if (error != 0 || nvp == NULL || nvp == vp ||
1129                     nvp->v_type != VSOCK) {
1130                         error = EOPNOTSUPP;
1131                         goto out;
1132                 }
1133         }
1134 
1135         if ((vp->v_type == VREG) && nbl_need_check(vp)) {
1136                 /* get share reservation */
1137                 shr.s_access = 0;
1138                 if (filemode & FWRITE)
1139                         shr.s_access |= F_WRACC;
1140                 if (filemode & FREAD)
1141                         shr.s_access |= F_RDACC;
1142                 shr.s_deny = 0;
1143                 shr.s_sysid = 0;
1144                 shr.s_pid = ttoproc(curthread)->p_pid;
1145                 shr_own.sl_pid = shr.s_pid;
1146                 shr_own.sl_id = fd;
1147                 shr.s_own_len = sizeof (shr_own);
1148                 shr.s_owner = (caddr_t)&shr_own;
1149                 error = VOP_SHRLOCK(vp, F_SHARE_NBMAND, &shr, filemode, CRED(),
1150                     NULL);
1151                 if (error)
1152                         goto out;
1153                 shrlock_done = 1;
1154 
1155                 /* nbmand conflict check if truncating file */
1156                 if ((filemode & FTRUNC) && !(filemode & FCREAT)) {
1157                         nbl_start_crit(vp, RW_READER);
1158                         in_crit = 1;
1159 
1160                         vattr.va_mask = AT_SIZE;
1161                         if (error = VOP_GETATTR(vp, &vattr, 0, CRED(), NULL))
1162                                 goto out;
1163                         if (nbl_conflict(vp, NBL_WRITE, 0, vattr.va_size, 0,
1164                             NULL)) {
1165                                 error = EACCES;
1166                                 goto out;
1167                         }
1168                 }
1169         }
1170 
1171         /*
1172          * Do opening protocol.
1173          */
1174         error = VOP_OPEN(&vp, filemode, CRED(), NULL);
1175         if (error)
1176                 goto out;
1177         open_done = 1;
1178 
1179         /*
1180          * Truncate if required.
1181          */
1182         if ((filemode & FTRUNC) && !(filemode & FCREAT)) {
1183                 vattr.va_size = 0;
1184                 vattr.va_mask = AT_SIZE;
1185                 if ((error = VOP_SETATTR(vp, &vattr, 0, CRED(), NULL)) != 0)
1186                         goto out;
1187         }
1188 out:
1189         ASSERT(vp->v_count > 0);
1190 
1191         if (in_crit) {
1192                 nbl_end_crit(vp);
1193                 in_crit = 0;
1194         }
1195         if (error) {
1196                 if (open_done) {
1197                         (void) VOP_CLOSE(vp, filemode, 1, (offset_t)0, CRED(),
1198                             NULL);
1199                         open_done = 0;
1200                         shrlock_done = 0;
1201                 }
1202                 if (shrlock_done) {
1203                         (void) VOP_SHRLOCK(vp, F_UNSHARE, &shr, 0, CRED(),
1204                             NULL);
1205                         shrlock_done = 0;
1206                 }
1207 
1208                 /*
1209                  * The following clause was added to handle a problem
1210                  * with NFS consistency.  It is possible that a lookup
1211                  * of the file to be opened succeeded, but the file
1212                  * itself doesn't actually exist on the server.  This
1213                  * is chiefly due to the DNLC containing an entry for
1214                  * the file which has been removed on the server.  In
1215                  * this case, we just start over.  If there was some
1216                  * other cause for the ESTALE error, then the lookup
1217                  * of the file will fail and the error will be returned
1218                  * above instead of looping around from here.
1219                  */
1220                 VN_RELE(vp);
1221                 if ((error == ESTALE) && fs_need_estale_retry(estale_retry++))
1222                         goto top;
1223         } else
1224                 *vpp = vp;
1225         return (error);
1226 }
1227 
1228 /*
1229  * The following two accessor functions are for the NFSv4 server.  Since there
1230  * is no VOP_OPEN_UP/DOWNGRADE we need a way for the NFS server to keep the
1231  * vnode open counts correct when a client "upgrades" an open or does an
1232  * open_downgrade.  In NFS, an upgrade or downgrade can not only change the
1233  * open mode (add or subtract read or write), but also change the share/deny
1234  * modes.  However, share reservations are not integrated with OPEN, yet, so
1235  * we need to handle each separately.  These functions are cleaner than having
1236  * the NFS server manipulate the counts directly, however, nobody else should
1237  * use these functions.
1238  */
1239 void
1240 vn_open_upgrade(
1241         vnode_t *vp,
1242         int filemode)
1243 {
1244         ASSERT(vp->v_type == VREG);
1245 
1246         if (filemode & FREAD)
1247                 atomic_add_32(&(vp->v_rdcnt), 1);
1248         if (filemode & FWRITE)
1249                 atomic_add_32(&(vp->v_wrcnt), 1);
1250 
1251 }
1252 
1253 void
1254 vn_open_downgrade(
1255         vnode_t *vp,
1256         int filemode)
1257 {
1258         ASSERT(vp->v_type == VREG);
1259 
1260         if (filemode & FREAD) {
1261                 ASSERT(vp->v_rdcnt > 0);
1262                 atomic_add_32(&(vp->v_rdcnt), -1);
1263         }
1264         if (filemode & FWRITE) {
1265                 ASSERT(vp->v_wrcnt > 0);
1266                 atomic_add_32(&(vp->v_wrcnt), -1);
1267         }
1268 
1269 }
1270 
1271 int
1272 vn_create(
1273         char *pnamep,
1274         enum uio_seg seg,
1275         struct vattr *vap,
1276         enum vcexcl excl,
1277         int mode,
1278         struct vnode **vpp,
1279         enum create why,
1280         int flag,
1281         mode_t umask)
1282 {
1283         return (vn_createat(pnamep, seg, vap, excl, mode, vpp, why, flag,
1284             umask, NULL));
1285 }
1286 
1287 /*
1288  * Create a vnode (makenode).
1289  */
1290 int
1291 vn_createat(
1292         char *pnamep,
1293         enum uio_seg seg,
1294         struct vattr *vap,
1295         enum vcexcl excl,
1296         int mode,
1297         struct vnode **vpp,
1298         enum create why,
1299         int flag,
1300         mode_t umask,
1301         struct vnode *startvp)
1302 {
1303         struct vnode *dvp;      /* ptr to parent dir vnode */
1304         struct vnode *vp = NULL;
1305         struct pathname pn;
1306         int error;
1307         int in_crit = 0;
1308         struct vattr vattr;
1309         enum symfollow follow;
1310         int estale_retry = 0;
1311         uint32_t auditing = AU_AUDITING();
1312 
1313         ASSERT((vap->va_mask & (AT_TYPE|AT_MODE)) == (AT_TYPE|AT_MODE));
1314 
1315         /* symlink interpretation */
1316         if ((flag & FNOFOLLOW) || excl == EXCL)
1317                 follow = NO_FOLLOW;
1318         else
1319                 follow = FOLLOW;
1320         flag &= ~(FNOFOLLOW|FNOLINKS);
1321 
1322 top:
1323         /*
1324          * Lookup directory.
1325          * If new object is a file, call lower level to create it.
1326          * Note that it is up to the lower level to enforce exclusive
1327          * creation, if the file is already there.
1328          * This allows the lower level to do whatever
1329          * locking or protocol that is needed to prevent races.
1330          * If the new object is directory call lower level to make
1331          * the new directory, with "." and "..".
1332          */
1333         if (error = pn_get(pnamep, seg, &pn))
1334                 return (error);
1335         if (auditing)
1336                 audit_vncreate_start();
1337         dvp = NULL;
1338         *vpp = NULL;
1339         /*
1340          * lookup will find the parent directory for the vnode.
1341          * When it is done the pn holds the name of the entry
1342          * in the directory.
1343          * If this is a non-exclusive create we also find the node itself.
1344          */
1345         error = lookuppnat(&pn, NULL, follow, &dvp,
1346             (excl == EXCL) ? NULLVPP : vpp, startvp);
1347         if (error) {
1348                 pn_free(&pn);
1349                 if ((error == ESTALE) && fs_need_estale_retry(estale_retry++))
1350                         goto top;
1351                 if (why == CRMKDIR && error == EINVAL)
1352                         error = EEXIST;         /* SVID */
1353                 return (error);
1354         }
1355 
1356         if (why != CRMKNOD)
1357                 vap->va_mode &= ~VSVTX;
1358 
1359         /*
1360          * If default ACLs are defined for the directory don't apply the
1361          * umask if umask is passed.
1362          */
1363 
1364         if (umask) {
1365 
1366                 vsecattr_t vsec;
1367 
1368                 vsec.vsa_aclcnt = 0;
1369                 vsec.vsa_aclentp = NULL;
1370                 vsec.vsa_dfaclcnt = 0;
1371                 vsec.vsa_dfaclentp = NULL;
1372                 vsec.vsa_mask = VSA_DFACLCNT;
1373                 error = VOP_GETSECATTR(dvp, &vsec, 0, CRED(), NULL);
1374                 /*
1375                  * If error is ENOSYS then treat it as no error
1376                  * Don't want to force all file systems to support
1377                  * aclent_t style of ACL's.
1378                  */
1379                 if (error == ENOSYS)
1380                         error = 0;
1381                 if (error) {
1382                         if (*vpp != NULL)
1383                                 VN_RELE(*vpp);
1384                         goto out;
1385                 } else {
1386                         /*
1387                          * Apply the umask if no default ACLs.
1388                          */
1389                         if (vsec.vsa_dfaclcnt == 0)
1390                                 vap->va_mode &= ~umask;
1391 
1392                         /*
1393                          * VOP_GETSECATTR() may have allocated memory for
1394                          * ACLs we didn't request, so double-check and
1395                          * free it if necessary.
1396                          */
1397                         if (vsec.vsa_aclcnt && vsec.vsa_aclentp != NULL)
1398                                 kmem_free((caddr_t)vsec.vsa_aclentp,
1399                                     vsec.vsa_aclcnt * sizeof (aclent_t));
1400                         if (vsec.vsa_dfaclcnt && vsec.vsa_dfaclentp != NULL)
1401                                 kmem_free((caddr_t)vsec.vsa_dfaclentp,
1402                                     vsec.vsa_dfaclcnt * sizeof (aclent_t));
1403                 }
1404         }
1405 
1406         /*
1407          * In general we want to generate EROFS if the file system is
1408          * readonly.  However, POSIX (IEEE Std. 1003.1) section 5.3.1
1409          * documents the open system call, and it says that O_CREAT has no
1410          * effect if the file already exists.  Bug 1119649 states
1411          * that open(path, O_CREAT, ...) fails when attempting to open an
1412          * existing file on a read only file system.  Thus, the first part
1413          * of the following if statement has 3 checks:
1414          *      if the file exists &&
1415          *              it is being open with write access &&
1416          *              the file system is read only
1417          *      then generate EROFS
1418          */
1419         if ((*vpp != NULL && (mode & VWRITE) && ISROFILE(*vpp)) ||
1420             (*vpp == NULL && dvp->v_vfsp->vfs_flag & VFS_RDONLY)) {
1421                 if (*vpp)
1422                         VN_RELE(*vpp);
1423                 error = EROFS;
1424         } else if (excl == NONEXCL && *vpp != NULL) {
1425                 vnode_t *rvp;
1426 
1427                 /*
1428                  * File already exists.  If a mandatory lock has been
1429                  * applied, return error.
1430                  */
1431                 vp = *vpp;
1432                 if (VOP_REALVP(vp, &rvp, NULL) != 0)
1433                         rvp = vp;
1434                 if ((vap->va_mask & AT_SIZE) && nbl_need_check(vp)) {
1435                         nbl_start_crit(vp, RW_READER);
1436                         in_crit = 1;
1437                 }
1438                 if (rvp->v_filocks != NULL || rvp->v_shrlocks != NULL) {
1439                         vattr.va_mask = AT_MODE|AT_SIZE;
1440                         if (error = VOP_GETATTR(vp, &vattr, 0, CRED(), NULL)) {
1441                                 goto out;
1442                         }
1443                         if (MANDLOCK(vp, vattr.va_mode)) {
1444                                 error = EAGAIN;
1445                                 goto out;
1446                         }
1447                         /*
1448                          * File cannot be truncated if non-blocking mandatory
1449                          * locks are currently on the file.
1450                          */
1451                         if ((vap->va_mask & AT_SIZE) && in_crit) {
1452                                 u_offset_t offset;
1453                                 ssize_t length;
1454 
1455                                 offset = vap->va_size > vattr.va_size ?
1456                                     vattr.va_size : vap->va_size;
1457                                 length = vap->va_size > vattr.va_size ?
1458                                     vap->va_size - vattr.va_size :
1459                                     vattr.va_size - vap->va_size;
1460                                 if (nbl_conflict(vp, NBL_WRITE, offset,
1461                                     length, 0, NULL)) {
1462                                         error = EACCES;
1463                                         goto out;
1464                                 }
1465                         }
1466                 }
1467 
1468                 /*
1469                  * If the file is the root of a VFS, we've crossed a
1470                  * mount point and the "containing" directory that we
1471                  * acquired above (dvp) is irrelevant because it's in
1472                  * a different file system.  We apply VOP_CREATE to the
1473                  * target itself instead of to the containing directory
1474                  * and supply a null path name to indicate (conventionally)
1475                  * the node itself as the "component" of interest.
1476                  *
1477                  * The intercession of the file system is necessary to
1478                  * ensure that the appropriate permission checks are
1479                  * done.
1480                  */
1481                 if (vp->v_flag & VROOT) {
1482                         ASSERT(why != CRMKDIR);
1483                         error = VOP_CREATE(vp, "", vap, excl, mode, vpp,
1484                             CRED(), flag, NULL, NULL);
1485                         /*
1486                          * If the create succeeded, it will have created
1487                          * a new reference to the vnode.  Give up the
1488                          * original reference.  The assertion should not
1489                          * get triggered because NBMAND locks only apply to
1490                          * VREG files.  And if in_crit is non-zero for some
1491                          * reason, detect that here, rather than when we
1492                          * deference a null vp.
1493                          */
1494                         ASSERT(in_crit == 0);
1495                         VN_RELE(vp);
1496                         vp = NULL;
1497                         goto out;
1498                 }
1499 
1500                 /*
1501                  * Large File API - non-large open (FOFFMAX flag not set)
1502                  * of regular file fails if the file size exceeds MAXOFF32_T.
1503                  */
1504                 if (why != CRMKDIR &&
1505                     !(flag & FOFFMAX) &&
1506                     (vp->v_type == VREG)) {
1507                         vattr.va_mask = AT_SIZE;
1508                         if ((error = VOP_GETATTR(vp, &vattr, 0,
1509                             CRED(), NULL))) {
1510                                 goto out;
1511                         }
1512                         if ((vattr.va_size > (u_offset_t)MAXOFF32_T)) {
1513                                 error = EOVERFLOW;
1514                                 goto out;
1515                         }
1516                 }
1517         }
1518 
1519         if (error == 0) {
1520                 /*
1521                  * Call mkdir() if specified, otherwise create().
1522                  */
1523                 int must_be_dir = pn_fixslash(&pn); /* trailing '/'? */
1524 
1525                 if (why == CRMKDIR)
1526                         /*
1527                          * N.B., if vn_createat() ever requests
1528                          * case-insensitive behavior then it will need
1529                          * to be passed to VOP_MKDIR().  VOP_CREATE()
1530                          * will already get it via "flag"
1531                          */
1532                         error = VOP_MKDIR(dvp, pn.pn_path, vap, vpp, CRED(),
1533                             NULL, 0, NULL);
1534                 else if (!must_be_dir)
1535                         error = VOP_CREATE(dvp, pn.pn_path, vap,
1536                             excl, mode, vpp, CRED(), flag, NULL, NULL);
1537                 else
1538                         error = ENOTDIR;
1539         }
1540 
1541 out:
1542 
1543         if (auditing)
1544                 audit_vncreate_finish(*vpp, error);
1545         if (in_crit) {
1546                 nbl_end_crit(vp);
1547                 in_crit = 0;
1548         }
1549         if (vp != NULL) {
1550                 VN_RELE(vp);
1551                 vp = NULL;
1552         }
1553         pn_free(&pn);
1554         VN_RELE(dvp);
1555         /*
1556          * The following clause was added to handle a problem
1557          * with NFS consistency.  It is possible that a lookup
1558          * of the file to be created succeeded, but the file
1559          * itself doesn't actually exist on the server.  This
1560          * is chiefly due to the DNLC containing an entry for
1561          * the file which has been removed on the server.  In
1562          * this case, we just start over.  If there was some
1563          * other cause for the ESTALE error, then the lookup
1564          * of the file will fail and the error will be returned
1565          * above instead of looping around from here.
1566          */
1567         if ((error == ESTALE) && fs_need_estale_retry(estale_retry++))
1568                 goto top;
1569         return (error);
1570 }
1571 
1572 int
1573 vn_link(char *from, char *to, enum uio_seg seg)
1574 {
1575         return (vn_linkat(NULL, from, NO_FOLLOW, NULL, to, seg));
1576 }
1577 
1578 int
1579 vn_linkat(vnode_t *fstartvp, char *from, enum symfollow follow,
1580     vnode_t *tstartvp, char *to, enum uio_seg seg)
1581 {
1582         struct vnode *fvp;              /* from vnode ptr */
1583         struct vnode *tdvp;             /* to directory vnode ptr */
1584         struct pathname pn;
1585         int error;
1586         struct vattr vattr;
1587         dev_t fsid;
1588         int estale_retry = 0;
1589         uint32_t auditing = AU_AUDITING();
1590 
1591 top:
1592         fvp = tdvp = NULL;
1593         if (error = pn_get(to, seg, &pn))
1594                 return (error);
1595         if (auditing && fstartvp != NULL)
1596                 audit_setfsat_path(1);
1597         if (error = lookupnameat(from, seg, follow, NULLVPP, &fvp, fstartvp))
1598                 goto out;
1599         if (auditing && tstartvp != NULL)
1600                 audit_setfsat_path(3);
1601         if (error = lookuppnat(&pn, NULL, NO_FOLLOW, &tdvp, NULLVPP, tstartvp))
1602                 goto out;
1603         /*
1604          * Make sure both source vnode and target directory vnode are
1605          * in the same vfs and that it is writeable.
1606          */
1607         vattr.va_mask = AT_FSID;
1608         if (error = VOP_GETATTR(fvp, &vattr, 0, CRED(), NULL))
1609                 goto out;
1610         fsid = vattr.va_fsid;
1611         vattr.va_mask = AT_FSID;
1612         if (error = VOP_GETATTR(tdvp, &vattr, 0, CRED(), NULL))
1613                 goto out;
1614         if (fsid != vattr.va_fsid) {
1615                 error = EXDEV;
1616                 goto out;
1617         }
1618         if (tdvp->v_vfsp->vfs_flag & VFS_RDONLY) {
1619                 error = EROFS;
1620                 goto out;
1621         }
1622         /*
1623          * Do the link.
1624          */
1625         (void) pn_fixslash(&pn);
1626         error = VOP_LINK(tdvp, fvp, pn.pn_path, CRED(), NULL, 0);
1627 out:
1628         pn_free(&pn);
1629         if (fvp)
1630                 VN_RELE(fvp);
1631         if (tdvp)
1632                 VN_RELE(tdvp);
1633         if ((error == ESTALE) && fs_need_estale_retry(estale_retry++))
1634                 goto top;
1635         return (error);
1636 }
1637 
1638 int
1639 vn_rename(char *from, char *to, enum uio_seg seg)
1640 {
1641         return (vn_renameat(NULL, from, NULL, to, seg));
1642 }
1643 
1644 int
1645 vn_renameat(vnode_t *fdvp, char *fname, vnode_t *tdvp,
1646                 char *tname, enum uio_seg seg)
1647 {
1648         int error;
1649         struct vattr vattr;
1650         struct pathname fpn;            /* from pathname */
1651         struct pathname tpn;            /* to pathname */
1652         dev_t fsid;
1653         int in_crit_src, in_crit_targ;
1654         vnode_t *fromvp, *fvp;
1655         vnode_t *tovp, *targvp;
1656         int estale_retry = 0;
1657         uint32_t auditing = AU_AUDITING();
1658 
1659 top:
1660         fvp = fromvp = tovp = targvp = NULL;
1661         in_crit_src = in_crit_targ = 0;
1662         /*
1663          * Get to and from pathnames.
1664          */
1665         if (error = pn_get(fname, seg, &fpn))
1666                 return (error);
1667         if (error = pn_get(tname, seg, &tpn)) {
1668                 pn_free(&fpn);
1669                 return (error);
1670         }
1671 
1672         /*
1673          * First we need to resolve the correct directories
1674          * The passed in directories may only be a starting point,
1675          * but we need the real directories the file(s) live in.
1676          * For example the fname may be something like usr/lib/sparc
1677          * and we were passed in the / directory, but we need to
1678          * use the lib directory for the rename.
1679          */
1680 
1681         if (auditing && fdvp != NULL)
1682                 audit_setfsat_path(1);
1683         /*
1684          * Lookup to and from directories.
1685          */
1686         if (error = lookuppnat(&fpn, NULL, NO_FOLLOW, &fromvp, &fvp, fdvp)) {
1687                 goto out;
1688         }
1689 
1690         /*
1691          * Make sure there is an entry.
1692          */
1693         if (fvp == NULL) {
1694                 error = ENOENT;
1695                 goto out;
1696         }
1697 
1698         if (auditing && tdvp != NULL)
1699                 audit_setfsat_path(3);
1700         if (error = lookuppnat(&tpn, NULL, NO_FOLLOW, &tovp, &targvp, tdvp)) {
1701                 goto out;
1702         }
1703 
1704         /*
1705          * Make sure both the from vnode directory and the to directory
1706          * are in the same vfs and the to directory is writable.
1707          * We check fsid's, not vfs pointers, so loopback fs works.
1708          */
1709         if (fromvp != tovp) {
1710                 vattr.va_mask = AT_FSID;
1711                 if (error = VOP_GETATTR(fromvp, &vattr, 0, CRED(), NULL))
1712                         goto out;
1713                 fsid = vattr.va_fsid;
1714                 vattr.va_mask = AT_FSID;
1715                 if (error = VOP_GETATTR(tovp, &vattr, 0, CRED(), NULL))
1716                         goto out;
1717                 if (fsid != vattr.va_fsid) {
1718                         error = EXDEV;
1719                         goto out;
1720                 }
1721         }
1722 
1723         if (tovp->v_vfsp->vfs_flag & VFS_RDONLY) {
1724                 error = EROFS;
1725                 goto out;
1726         }
1727 
1728         if (targvp && (fvp != targvp)) {
1729                 nbl_start_crit(targvp, RW_READER);
1730                 in_crit_targ = 1;
1731                 if (nbl_conflict(targvp, NBL_REMOVE, 0, 0, 0, NULL)) {
1732                         error = EACCES;
1733                         goto out;
1734                 }
1735         }
1736 
1737         if (nbl_need_check(fvp)) {
1738                 nbl_start_crit(fvp, RW_READER);
1739                 in_crit_src = 1;
1740                 if (nbl_conflict(fvp, NBL_RENAME, 0, 0, 0, NULL)) {
1741                         error = EACCES;
1742                         goto out;
1743                 }
1744         }
1745 
1746         /*
1747          * Do the rename.
1748          */
1749         (void) pn_fixslash(&tpn);
1750         error = VOP_RENAME(fromvp, fpn.pn_path, tovp, tpn.pn_path, CRED(),
1751             NULL, 0);
1752 
1753 out:
1754         pn_free(&fpn);
1755         pn_free(&tpn);
1756         if (in_crit_src)
1757                 nbl_end_crit(fvp);
1758         if (in_crit_targ)
1759                 nbl_end_crit(targvp);
1760         if (fromvp)
1761                 VN_RELE(fromvp);
1762         if (tovp)
1763                 VN_RELE(tovp);
1764         if (targvp)
1765                 VN_RELE(targvp);
1766         if (fvp)
1767                 VN_RELE(fvp);
1768         if ((error == ESTALE) && fs_need_estale_retry(estale_retry++))
1769                 goto top;
1770         return (error);
1771 }
1772 
1773 /*
1774  * Remove a file or directory.
1775  */
1776 int
1777 vn_remove(char *fnamep, enum uio_seg seg, enum rm dirflag)
1778 {
1779         return (vn_removeat(NULL, fnamep, seg, dirflag));
1780 }
1781 
1782 int
1783 vn_removeat(vnode_t *startvp, char *fnamep, enum uio_seg seg, enum rm dirflag)
1784 {
1785         struct vnode *vp;               /* entry vnode */
1786         struct vnode *dvp;              /* ptr to parent dir vnode */
1787         struct vnode *coveredvp;
1788         struct pathname pn;             /* name of entry */
1789         enum vtype vtype;
1790         int error;
1791         struct vfs *vfsp;
1792         struct vfs *dvfsp;      /* ptr to parent dir vfs */
1793         int in_crit = 0;
1794         int estale_retry = 0;
1795 
1796 top:
1797         if (error = pn_get(fnamep, seg, &pn))
1798                 return (error);
1799         dvp = vp = NULL;
1800         if (error = lookuppnat(&pn, NULL, NO_FOLLOW, &dvp, &vp, startvp)) {
1801                 pn_free(&pn);
1802                 if ((error == ESTALE) && fs_need_estale_retry(estale_retry++))
1803                         goto top;
1804                 return (error);
1805         }
1806 
1807         /*
1808          * Make sure there is an entry.
1809          */
1810         if (vp == NULL) {
1811                 error = ENOENT;
1812                 goto out;
1813         }
1814 
1815         vfsp = vp->v_vfsp;
1816         dvfsp = dvp->v_vfsp;
1817 
1818         /*
1819          * If the named file is the root of a mounted filesystem, fail,
1820          * unless it's marked unlinkable.  In that case, unmount the
1821          * filesystem and proceed to unlink the covered vnode.  (If the
1822          * covered vnode is a directory, use rmdir instead of unlink,
1823          * to avoid file system corruption.)
1824          */
1825         if (vp->v_flag & VROOT) {
1826                 if ((vfsp->vfs_flag & VFS_UNLINKABLE) == 0) {
1827                         error = EBUSY;
1828                         goto out;
1829                 }
1830 
1831                 /*
1832                  * Namefs specific code starts here.
1833                  */
1834 
1835                 if (dirflag == RMDIRECTORY) {
1836                         /*
1837                          * User called rmdir(2) on a file that has
1838                          * been namefs mounted on top of.  Since
1839                          * namefs doesn't allow directories to
1840                          * be mounted on other files we know
1841                          * vp is not of type VDIR so fail to operation.
1842                          */
1843                         error = ENOTDIR;
1844                         goto out;
1845                 }
1846 
1847                 /*
1848                  * If VROOT is still set after grabbing vp->v_lock,
1849                  * noone has finished nm_unmount so far and coveredvp
1850                  * is valid.
1851                  * If we manage to grab vn_vfswlock(coveredvp) before releasing
1852                  * vp->v_lock, any race window is eliminated.
1853                  */
1854 
1855                 mutex_enter(&vp->v_lock);
1856                 if ((vp->v_flag & VROOT) == 0) {
1857                         /* Someone beat us to the unmount */
1858                         mutex_exit(&vp->v_lock);
1859                         error = EBUSY;
1860                         goto out;
1861                 }
1862                 vfsp = vp->v_vfsp;
1863                 coveredvp = vfsp->vfs_vnodecovered;
1864                 ASSERT(coveredvp);
1865                 /*
1866                  * Note: Implementation of vn_vfswlock shows that ordering of
1867                  * v_lock / vn_vfswlock is not an issue here.
1868                  */
1869                 error = vn_vfswlock(coveredvp);
1870                 mutex_exit(&vp->v_lock);
1871 
1872                 if (error)
1873                         goto out;
1874 
1875                 VN_HOLD(coveredvp);
1876                 VN_RELE(vp);
1877                 error = dounmount(vfsp, 0, CRED());
1878 
1879                 /*
1880                  * Unmounted the namefs file system; now get
1881                  * the object it was mounted over.
1882                  */
1883                 vp = coveredvp;
1884                 /*
1885                  * If namefs was mounted over a directory, then
1886                  * we want to use rmdir() instead of unlink().
1887                  */
1888                 if (vp->v_type == VDIR)
1889                         dirflag = RMDIRECTORY;
1890 
1891                 if (error)
1892                         goto out;
1893         }
1894 
1895         /*
1896          * Make sure filesystem is writeable.
1897          * We check the parent directory's vfs in case this is an lofs vnode.
1898          */
1899         if (dvfsp && dvfsp->vfs_flag & VFS_RDONLY) {
1900                 error = EROFS;
1901                 goto out;
1902         }
1903 
1904         vtype = vp->v_type;
1905 
1906         /*
1907          * If there is the possibility of an nbmand share reservation, make
1908          * sure it's okay to remove the file.  Keep a reference to the
1909          * vnode, so that we can exit the nbl critical region after
1910          * calling VOP_REMOVE.
1911          * If there is no possibility of an nbmand share reservation,
1912          * release the vnode reference now.  Filesystems like NFS may
1913          * behave differently if there is an extra reference, so get rid of
1914          * this one.  Fortunately, we can't have nbmand mounts on NFS
1915          * filesystems.
1916          */
1917         if (nbl_need_check(vp)) {
1918                 nbl_start_crit(vp, RW_READER);
1919                 in_crit = 1;
1920                 if (nbl_conflict(vp, NBL_REMOVE, 0, 0, 0, NULL)) {
1921                         error = EACCES;
1922                         goto out;
1923                 }
1924         } else {
1925                 VN_RELE(vp);
1926                 vp = NULL;
1927         }
1928 
1929         if (dirflag == RMDIRECTORY) {
1930                 /*
1931                  * Caller is using rmdir(2), which can only be applied to
1932                  * directories.
1933                  */
1934                 if (vtype != VDIR) {
1935                         error = ENOTDIR;
1936                 } else {
1937                         vnode_t *cwd;
1938                         proc_t *pp = curproc;
1939 
1940                         mutex_enter(&pp->p_lock);
1941                         cwd = PTOU(pp)->u_cdir;
1942                         VN_HOLD(cwd);
1943                         mutex_exit(&pp->p_lock);
1944                         error = VOP_RMDIR(dvp, pn.pn_path, cwd, CRED(),
1945                             NULL, 0);
1946                         VN_RELE(cwd);
1947                 }
1948         } else {
1949                 /*
1950                  * Unlink(2) can be applied to anything.
1951                  */
1952                 error = VOP_REMOVE(dvp, pn.pn_path, CRED(), NULL, 0);
1953         }
1954 
1955 out:
1956         pn_free(&pn);
1957         if (in_crit) {
1958                 nbl_end_crit(vp);
1959                 in_crit = 0;
1960         }
1961         if (vp != NULL)
1962                 VN_RELE(vp);
1963         if (dvp != NULL)
1964                 VN_RELE(dvp);
1965         if ((error == ESTALE) && fs_need_estale_retry(estale_retry++))
1966                 goto top;
1967         return (error);
1968 }
1969 
1970 /*
1971  * Utility function to compare equality of vnodes.
1972  * Compare the underlying real vnodes, if there are underlying vnodes.
1973  * This is a more thorough comparison than the VN_CMP() macro provides.
1974  */
1975 int
1976 vn_compare(vnode_t *vp1, vnode_t *vp2)
1977 {
1978         vnode_t *realvp;
1979 
1980         if (vp1 != NULL && VOP_REALVP(vp1, &realvp, NULL) == 0)
1981                 vp1 = realvp;
1982         if (vp2 != NULL && VOP_REALVP(vp2, &realvp, NULL) == 0)
1983                 vp2 = realvp;
1984         return (VN_CMP(vp1, vp2));
1985 }
1986 
1987 /*
1988  * The number of locks to hash into.  This value must be a power
1989  * of 2 minus 1 and should probably also be prime.
1990  */
1991 #define NUM_BUCKETS     1023
1992 
1993 struct  vn_vfslocks_bucket {
1994         kmutex_t vb_lock;
1995         vn_vfslocks_entry_t *vb_list;
1996         char pad[64 - sizeof (kmutex_t) - sizeof (void *)];
1997 };
1998 
1999 /*
2000  * Total number of buckets will be NUM_BUCKETS + 1 .
2001  */
2002 
2003 #pragma align   64(vn_vfslocks_buckets)
2004 static  struct vn_vfslocks_bucket       vn_vfslocks_buckets[NUM_BUCKETS + 1];
2005 
2006 #define VN_VFSLOCKS_SHIFT       9
2007 
2008 #define VN_VFSLOCKS_HASH(vfsvpptr)      \
2009         ((((intptr_t)(vfsvpptr)) >> VN_VFSLOCKS_SHIFT) & NUM_BUCKETS)
2010 
2011 /*
2012  * vn_vfslocks_getlock() uses an HASH scheme to generate
2013  * rwstlock using vfs/vnode pointer passed to it.
2014  *
2015  * vn_vfslocks_rele() releases a reference in the
2016  * HASH table which allows the entry allocated by
2017  * vn_vfslocks_getlock() to be freed at a later
2018  * stage when the refcount drops to zero.
2019  */
2020 
2021 vn_vfslocks_entry_t *
2022 vn_vfslocks_getlock(void *vfsvpptr)
2023 {
2024         struct vn_vfslocks_bucket *bp;
2025         vn_vfslocks_entry_t *vep;
2026         vn_vfslocks_entry_t *tvep;
2027 
2028         ASSERT(vfsvpptr != NULL);
2029         bp = &vn_vfslocks_buckets[VN_VFSLOCKS_HASH(vfsvpptr)];
2030 
2031         mutex_enter(&bp->vb_lock);
2032         for (vep = bp->vb_list; vep != NULL; vep = vep->ve_next) {
2033                 if (vep->ve_vpvfs == vfsvpptr) {
2034                         vep->ve_refcnt++;
2035                         mutex_exit(&bp->vb_lock);
2036                         return (vep);
2037                 }
2038         }
2039         mutex_exit(&bp->vb_lock);
2040         vep = kmem_alloc(sizeof (*vep), KM_SLEEP);
2041         rwst_init(&vep->ve_lock, NULL, RW_DEFAULT, NULL);
2042         vep->ve_vpvfs = (char *)vfsvpptr;
2043         vep->ve_refcnt = 1;
2044         mutex_enter(&bp->vb_lock);
2045         for (tvep = bp->vb_list; tvep != NULL; tvep = tvep->ve_next) {
2046                 if (tvep->ve_vpvfs == vfsvpptr) {
2047                         tvep->ve_refcnt++;
2048                         mutex_exit(&bp->vb_lock);
2049 
2050                         /*
2051                          * There is already an entry in the hash
2052                          * destroy what we just allocated.
2053                          */
2054                         rwst_destroy(&vep->ve_lock);
2055                         kmem_free(vep, sizeof (*vep));
2056                         return (tvep);
2057                 }
2058         }
2059         vep->ve_next = bp->vb_list;
2060         bp->vb_list = vep;
2061         mutex_exit(&bp->vb_lock);
2062         return (vep);
2063 }
2064 
2065 void
2066 vn_vfslocks_rele(vn_vfslocks_entry_t *vepent)
2067 {
2068         struct vn_vfslocks_bucket *bp;
2069         vn_vfslocks_entry_t *vep;
2070         vn_vfslocks_entry_t *pvep;
2071 
2072         ASSERT(vepent != NULL);
2073         ASSERT(vepent->ve_vpvfs != NULL);
2074 
2075         bp = &vn_vfslocks_buckets[VN_VFSLOCKS_HASH(vepent->ve_vpvfs)];
2076 
2077         mutex_enter(&bp->vb_lock);
2078         vepent->ve_refcnt--;
2079 
2080         if ((int32_t)vepent->ve_refcnt < 0)
2081                 cmn_err(CE_PANIC, "vn_vfslocks_rele: refcount negative");
2082 
2083         if (vepent->ve_refcnt == 0) {
2084                 for (vep = bp->vb_list; vep != NULL; vep = vep->ve_next) {
2085                         if (vep->ve_vpvfs == vepent->ve_vpvfs) {
2086                                 if (bp->vb_list == vep)
2087                                         bp->vb_list = vep->ve_next;
2088                                 else {
2089                                         /* LINTED */
2090                                         pvep->ve_next = vep->ve_next;
2091                                 }
2092                                 mutex_exit(&bp->vb_lock);
2093                                 rwst_destroy(&vep->ve_lock);
2094                                 kmem_free(vep, sizeof (*vep));
2095                                 return;
2096                         }
2097                         pvep = vep;
2098                 }
2099                 cmn_err(CE_PANIC, "vn_vfslocks_rele: vp/vfs not found");
2100         }
2101         mutex_exit(&bp->vb_lock);
2102 }
2103 
2104 /*
2105  * vn_vfswlock_wait is used to implement a lock which is logically a writers
2106  * lock protecting the v_vfsmountedhere field.
2107  * vn_vfswlock_wait has been modified to be similar to vn_vfswlock,
2108  * except that it blocks to acquire the lock VVFSLOCK.
2109  *
2110  * traverse() and routines re-implementing part of traverse (e.g. autofs)
2111  * need to hold this lock. mount(), vn_rename(), vn_remove() and so on
2112  * need the non-blocking version of the writers lock i.e. vn_vfswlock
2113  */
2114 int
2115 vn_vfswlock_wait(vnode_t *vp)
2116 {
2117         int retval;
2118         vn_vfslocks_entry_t *vpvfsentry;
2119         ASSERT(vp != NULL);
2120 
2121         vpvfsentry = vn_vfslocks_getlock(vp);
2122         retval = rwst_enter_sig(&vpvfsentry->ve_lock, RW_WRITER);
2123 
2124         if (retval == EINTR) {
2125                 vn_vfslocks_rele(vpvfsentry);
2126                 return (EINTR);
2127         }
2128         return (retval);
2129 }
2130 
2131 int
2132 vn_vfsrlock_wait(vnode_t *vp)
2133 {
2134         int retval;
2135         vn_vfslocks_entry_t *vpvfsentry;
2136         ASSERT(vp != NULL);
2137 
2138         vpvfsentry = vn_vfslocks_getlock(vp);
2139         retval = rwst_enter_sig(&vpvfsentry->ve_lock, RW_READER);
2140 
2141         if (retval == EINTR) {
2142                 vn_vfslocks_rele(vpvfsentry);
2143                 return (EINTR);
2144         }
2145 
2146         return (retval);
2147 }
2148 
2149 
2150 /*
2151  * vn_vfswlock is used to implement a lock which is logically a writers lock
2152  * protecting the v_vfsmountedhere field.
2153  */
2154 int
2155 vn_vfswlock(vnode_t *vp)
2156 {
2157         vn_vfslocks_entry_t *vpvfsentry;
2158 
2159         /*
2160          * If vp is NULL then somebody is trying to lock the covered vnode
2161          * of /.  (vfs_vnodecovered is NULL for /).  This situation will
2162          * only happen when unmounting /.  Since that operation will fail
2163          * anyway, return EBUSY here instead of in VFS_UNMOUNT.
2164          */
2165         if (vp == NULL)
2166                 return (EBUSY);
2167 
2168         vpvfsentry = vn_vfslocks_getlock(vp);
2169 
2170         if (rwst_tryenter(&vpvfsentry->ve_lock, RW_WRITER))
2171                 return (0);
2172 
2173         vn_vfslocks_rele(vpvfsentry);
2174         return (EBUSY);
2175 }
2176 
2177 int
2178 vn_vfsrlock(vnode_t *vp)
2179 {
2180         vn_vfslocks_entry_t *vpvfsentry;
2181 
2182         /*
2183          * If vp is NULL then somebody is trying to lock the covered vnode
2184          * of /.  (vfs_vnodecovered is NULL for /).  This situation will
2185          * only happen when unmounting /.  Since that operation will fail
2186          * anyway, return EBUSY here instead of in VFS_UNMOUNT.
2187          */
2188         if (vp == NULL)
2189                 return (EBUSY);
2190 
2191         vpvfsentry = vn_vfslocks_getlock(vp);
2192 
2193         if (rwst_tryenter(&vpvfsentry->ve_lock, RW_READER))
2194                 return (0);
2195 
2196         vn_vfslocks_rele(vpvfsentry);
2197         return (EBUSY);
2198 }
2199 
2200 void
2201 vn_vfsunlock(vnode_t *vp)
2202 {
2203         vn_vfslocks_entry_t *vpvfsentry;
2204 
2205         /*
2206          * ve_refcnt needs to be decremented twice.
2207          * 1. To release refernce after a call to vn_vfslocks_getlock()
2208          * 2. To release the reference from the locking routines like
2209          *    vn_vfsrlock/vn_vfswlock etc,.
2210          */
2211         vpvfsentry = vn_vfslocks_getlock(vp);
2212         vn_vfslocks_rele(vpvfsentry);
2213 
2214         rwst_exit(&vpvfsentry->ve_lock);
2215         vn_vfslocks_rele(vpvfsentry);
2216 }
2217 
2218 int
2219 vn_vfswlock_held(vnode_t *vp)
2220 {
2221         int held;
2222         vn_vfslocks_entry_t *vpvfsentry;
2223 
2224         ASSERT(vp != NULL);
2225 
2226         vpvfsentry = vn_vfslocks_getlock(vp);
2227         held = rwst_lock_held(&vpvfsentry->ve_lock, RW_WRITER);
2228 
2229         vn_vfslocks_rele(vpvfsentry);
2230         return (held);
2231 }
2232 
2233 
2234 int
2235 vn_make_ops(
2236         const char *name,                       /* Name of file system */
2237         const fs_operation_def_t *templ,        /* Operation specification */
2238         vnodeops_t **actual)                    /* Return the vnodeops */
2239 {
2240         int unused_ops;
2241         int error;
2242 
2243         *actual = (vnodeops_t *)kmem_alloc(sizeof (vnodeops_t), KM_SLEEP);
2244 
2245         (*actual)->vnop_name = name;
2246 
2247         error = fs_build_vector(*actual, &unused_ops, vn_ops_table, templ);
2248         if (error) {
2249                 kmem_free(*actual, sizeof (vnodeops_t));
2250         }
2251 
2252 #if DEBUG
2253         if (unused_ops != 0)
2254                 cmn_err(CE_WARN, "vn_make_ops: %s: %d operations supplied "
2255                     "but not used", name, unused_ops);
2256 #endif
2257 
2258         return (error);
2259 }
2260 
2261 /*
2262  * Free the vnodeops created as a result of vn_make_ops()
2263  */
2264 void
2265 vn_freevnodeops(vnodeops_t *vnops)
2266 {
2267         kmem_free(vnops, sizeof (vnodeops_t));
2268 }
2269 
2270 /*
2271  * Vnode cache.
2272  */
2273 
2274 /* ARGSUSED */
2275 static int
2276 vn_cache_constructor(void *buf, void *cdrarg, int kmflags)
2277 {
2278         struct vnode *vp;
2279 
2280         vp = buf;
2281 
2282         mutex_init(&vp->v_lock, NULL, MUTEX_DEFAULT, NULL);
2283         mutex_init(&vp->v_vsd_lock, NULL, MUTEX_DEFAULT, NULL);
2284         cv_init(&vp->v_cv, NULL, CV_DEFAULT, NULL);
2285         rw_init(&vp->v_nbllock, NULL, RW_DEFAULT, NULL);
2286         vp->v_femhead = NULL;        /* Must be done before vn_reinit() */
2287         vp->v_path = NULL;
2288         vp->v_mpssdata = NULL;
2289         vp->v_vsd = NULL;
2290         vp->v_fopdata = NULL;
2291 
2292         return (0);
2293 }
2294 
2295 /* ARGSUSED */
2296 static void
2297 vn_cache_destructor(void *buf, void *cdrarg)
2298 {
2299         struct vnode *vp;
2300 
2301         vp = buf;
2302 
2303         rw_destroy(&vp->v_nbllock);
2304         cv_destroy(&vp->v_cv);
2305         mutex_destroy(&vp->v_vsd_lock);
2306         mutex_destroy(&vp->v_lock);
2307 }
2308 
2309 void
2310 vn_create_cache(void)
2311 {
2312         /* LINTED */
2313         ASSERT((1 << VNODE_ALIGN_LOG2) ==
2314             P2ROUNDUP(sizeof (struct vnode), VNODE_ALIGN));
2315         vn_cache = kmem_cache_create("vn_cache", sizeof (struct vnode),
2316             VNODE_ALIGN, vn_cache_constructor, vn_cache_destructor, NULL, NULL,
2317             NULL, 0);
2318 }
2319 
2320 void
2321 vn_destroy_cache(void)
2322 {
2323         kmem_cache_destroy(vn_cache);
2324 }
2325 
2326 /*
2327  * Used by file systems when fs-specific nodes (e.g., ufs inodes) are
2328  * cached by the file system and vnodes remain associated.
2329  */
2330 void
2331 vn_recycle(vnode_t *vp)
2332 {
2333         ASSERT(vp->v_pages == NULL);
2334 
2335         /*
2336          * XXX - This really belongs in vn_reinit(), but we have some issues
2337          * with the counts.  Best to have it here for clean initialization.
2338          */
2339         vp->v_rdcnt = 0;
2340         vp->v_wrcnt = 0;
2341         vp->v_mmap_read = 0;
2342         vp->v_mmap_write = 0;
2343 
2344         /*
2345          * If FEM was in use, make sure everything gets cleaned up
2346          * NOTE: vp->v_femhead is initialized to NULL in the vnode
2347          * constructor.
2348          */
2349         if (vp->v_femhead) {
2350                 /* XXX - There should be a free_femhead() that does all this */
2351                 ASSERT(vp->v_femhead->femh_list == NULL);
2352                 mutex_destroy(&vp->v_femhead->femh_lock);
2353                 kmem_free(vp->v_femhead, sizeof (*(vp->v_femhead)));
2354                 vp->v_femhead = NULL;
2355         }
2356         if (vp->v_path) {
2357                 kmem_free(vp->v_path, strlen(vp->v_path) + 1);
2358                 vp->v_path = NULL;
2359         }
2360 
2361         if (vp->v_fopdata != NULL) {
2362                 free_fopdata(vp);
2363         }
2364         vp->v_mpssdata = NULL;
2365         vsd_free(vp);
2366 }
2367 
2368 /*
2369  * Used to reset the vnode fields including those that are directly accessible
2370  * as well as those which require an accessor function.
2371  *
2372  * Does not initialize:
2373  *      synchronization objects: v_lock, v_vsd_lock, v_nbllock, v_cv
2374  *      v_data (since FS-nodes and vnodes point to each other and should
2375  *              be updated simultaneously)
2376  *      v_op (in case someone needs to make a VOP call on this object)
2377  */
2378 void
2379 vn_reinit(vnode_t *vp)
2380 {
2381         vp->v_count = 1;
2382         vp->v_count_dnlc = 0;
2383         vp->v_vfsp = NULL;
2384         vp->v_stream = NULL;
2385         vp->v_vfsmountedhere = NULL;
2386         vp->v_flag = 0;
2387         vp->v_type = VNON;
2388         vp->v_rdev = NODEV;
2389 
2390         vp->v_filocks = NULL;
2391         vp->v_shrlocks = NULL;
2392         vp->v_pages = NULL;
2393 
2394         vp->v_locality = NULL;
2395         vp->v_xattrdir = NULL;
2396 
2397         /* Handles v_femhead, v_path, and the r/w/map counts */
2398         vn_recycle(vp);
2399 }
2400 
2401 vnode_t *
2402 vn_alloc(int kmflag)
2403 {
2404         vnode_t *vp;
2405 
2406         vp = kmem_cache_alloc(vn_cache, kmflag);
2407 
2408         if (vp != NULL) {
2409                 vp->v_femhead = NULL;        /* Must be done before vn_reinit() */
2410                 vp->v_fopdata = NULL;
2411                 vn_reinit(vp);
2412         }
2413 
2414         return (vp);
2415 }
2416 
2417 void
2418 vn_free(vnode_t *vp)
2419 {
2420         ASSERT(vp->v_shrlocks == NULL);
2421         ASSERT(vp->v_filocks == NULL);
2422 
2423         /*
2424          * Some file systems call vn_free() with v_count of zero,
2425          * some with v_count of 1.  In any case, the value should
2426          * never be anything else.
2427          */
2428         ASSERT((vp->v_count == 0) || (vp->v_count == 1));
2429         ASSERT(vp->v_count_dnlc == 0);
2430         if (vp->v_path != NULL) {
2431                 kmem_free(vp->v_path, strlen(vp->v_path) + 1);
2432                 vp->v_path = NULL;
2433         }
2434 
2435         /* If FEM was in use, make sure everything gets cleaned up */
2436         if (vp->v_femhead) {
2437                 /* XXX - There should be a free_femhead() that does all this */
2438                 ASSERT(vp->v_femhead->femh_list == NULL);
2439                 mutex_destroy(&vp->v_femhead->femh_lock);
2440                 kmem_free(vp->v_femhead, sizeof (*(vp->v_femhead)));
2441                 vp->v_femhead = NULL;
2442         }
2443 
2444         if (vp->v_fopdata != NULL) {
2445                 free_fopdata(vp);
2446         }
2447         vp->v_mpssdata = NULL;
2448         vsd_free(vp);
2449         kmem_cache_free(vn_cache, vp);
2450 }
2451 
2452 /*
2453  * vnode status changes, should define better states than 1, 0.
2454  */
2455 void
2456 vn_reclaim(vnode_t *vp)
2457 {
2458         vfs_t   *vfsp = vp->v_vfsp;
2459 
2460         if (vfsp == NULL ||
2461             vfsp->vfs_implp == NULL || vfsp->vfs_femhead == NULL) {
2462                 return;
2463         }
2464         (void) VFS_VNSTATE(vfsp, vp, VNTRANS_RECLAIMED);
2465 }
2466 
2467 void
2468 vn_idle(vnode_t *vp)
2469 {
2470         vfs_t   *vfsp = vp->v_vfsp;
2471 
2472         if (vfsp == NULL ||
2473             vfsp->vfs_implp == NULL || vfsp->vfs_femhead == NULL) {
2474                 return;
2475         }
2476         (void) VFS_VNSTATE(vfsp, vp, VNTRANS_IDLED);
2477 }
2478 void
2479 vn_exists(vnode_t *vp)
2480 {
2481         vfs_t   *vfsp = vp->v_vfsp;
2482 
2483         if (vfsp == NULL ||
2484             vfsp->vfs_implp == NULL || vfsp->vfs_femhead == NULL) {
2485                 return;
2486         }
2487         (void) VFS_VNSTATE(vfsp, vp, VNTRANS_EXISTS);
2488 }
2489 
2490 void
2491 vn_invalid(vnode_t *vp)
2492 {
2493         vfs_t   *vfsp = vp->v_vfsp;
2494 
2495         if (vfsp == NULL ||
2496             vfsp->vfs_implp == NULL || vfsp->vfs_femhead == NULL) {
2497                 return;
2498         }
2499         (void) VFS_VNSTATE(vfsp, vp, VNTRANS_DESTROYED);
2500 }
2501 
2502 /* Vnode event notification */
2503 
2504 int
2505 vnevent_support(vnode_t *vp, caller_context_t *ct)
2506 {
2507         if (vp == NULL)
2508                 return (EINVAL);
2509 
2510         return (VOP_VNEVENT(vp, VE_SUPPORT, NULL, NULL, ct));
2511 }
2512 
2513 void
2514 vnevent_rename_src(vnode_t *vp, vnode_t *dvp, char *name, caller_context_t *ct)
2515 {
2516         if (vp == NULL || vp->v_femhead == NULL) {
2517                 return;
2518         }
2519         (void) VOP_VNEVENT(vp, VE_RENAME_SRC, dvp, name, ct);
2520 }
2521 
2522 void
2523 vnevent_rename_dest(vnode_t *vp, vnode_t *dvp, char *name,
2524     caller_context_t *ct)
2525 {
2526         if (vp == NULL || vp->v_femhead == NULL) {
2527                 return;
2528         }
2529         (void) VOP_VNEVENT(vp, VE_RENAME_DEST, dvp, name, ct);
2530 }
2531 
2532 void
2533 vnevent_rename_dest_dir(vnode_t *vp, caller_context_t *ct)
2534 {
2535         if (vp == NULL || vp->v_femhead == NULL) {
2536                 return;
2537         }
2538         (void) VOP_VNEVENT(vp, VE_RENAME_DEST_DIR, NULL, NULL, ct);
2539 }
2540 
2541 void
2542 vnevent_remove(vnode_t *vp, vnode_t *dvp, char *name, caller_context_t *ct)
2543 {
2544         if (vp == NULL || vp->v_femhead == NULL) {
2545                 return;
2546         }
2547         (void) VOP_VNEVENT(vp, VE_REMOVE, dvp, name, ct);
2548 }
2549 
2550 void
2551 vnevent_rmdir(vnode_t *vp, vnode_t *dvp, char *name, caller_context_t *ct)
2552 {
2553         if (vp == NULL || vp->v_femhead == NULL) {
2554                 return;
2555         }
2556         (void) VOP_VNEVENT(vp, VE_RMDIR, dvp, name, ct);
2557 }
2558 
2559 void
2560 vnevent_create(vnode_t *vp, caller_context_t *ct)
2561 {
2562         if (vp == NULL || vp->v_femhead == NULL) {
2563                 return;
2564         }
2565         (void) VOP_VNEVENT(vp, VE_CREATE, NULL, NULL, ct);
2566 }
2567 
2568 void
2569 vnevent_link(vnode_t *vp, caller_context_t *ct)
2570 {
2571         if (vp == NULL || vp->v_femhead == NULL) {
2572                 return;
2573         }
2574         (void) VOP_VNEVENT(vp, VE_LINK, NULL, NULL, ct);
2575 }
2576 
2577 void
2578 vnevent_mountedover(vnode_t *vp, caller_context_t *ct)
2579 {
2580         if (vp == NULL || vp->v_femhead == NULL) {
2581                 return;
2582         }
2583         (void) VOP_VNEVENT(vp, VE_MOUNTEDOVER, NULL, NULL, ct);
2584 }
2585 
2586 /*
2587  * Vnode accessors.
2588  */
2589 
2590 int
2591 vn_is_readonly(vnode_t *vp)
2592 {
2593         return (vp->v_vfsp->vfs_flag & VFS_RDONLY);
2594 }
2595 
2596 int
2597 vn_has_flocks(vnode_t *vp)
2598 {
2599         return (vp->v_filocks != NULL);
2600 }
2601 
2602 int
2603 vn_has_mandatory_locks(vnode_t *vp, int mode)
2604 {
2605         return ((vp->v_filocks != NULL) && (MANDLOCK(vp, mode)));
2606 }
2607 
2608 int
2609 vn_has_cached_data(vnode_t *vp)
2610 {
2611         return (vp->v_pages != NULL);
2612 }
2613 
2614 /*
2615  * Return 0 if the vnode in question shouldn't be permitted into a zone via
2616  * zone_enter(2).
2617  */
2618 int
2619 vn_can_change_zones(vnode_t *vp)
2620 {
2621         struct vfssw *vswp;
2622         int allow = 1;
2623         vnode_t *rvp;
2624 
2625         if (nfs_global_client_only != 0)
2626                 return (1);
2627 
2628         /*
2629          * We always want to look at the underlying vnode if there is one.
2630          */
2631         if (VOP_REALVP(vp, &rvp, NULL) != 0)
2632                 rvp = vp;
2633         /*
2634          * Some pseudo filesystems (including doorfs) don't actually register
2635          * their vfsops_t, so the following may return NULL; we happily let
2636          * such vnodes switch zones.
2637          */
2638         vswp = vfs_getvfsswbyvfsops(vfs_getops(rvp->v_vfsp));
2639         if (vswp != NULL) {
2640                 if (vswp->vsw_flag & VSW_NOTZONESAFE)
2641                         allow = 0;
2642                 vfs_unrefvfssw(vswp);
2643         }
2644         return (allow);
2645 }
2646 
2647 /*
2648  * Return nonzero if the vnode is a mount point, zero if not.
2649  */
2650 int
2651 vn_ismntpt(vnode_t *vp)
2652 {
2653         return (vp->v_vfsmountedhere != NULL);
2654 }
2655 
2656 /* Retrieve the vfs (if any) mounted on this vnode */
2657 vfs_t *
2658 vn_mountedvfs(vnode_t *vp)
2659 {
2660         return (vp->v_vfsmountedhere);
2661 }
2662 
2663 /*
2664  * Return nonzero if the vnode is referenced by the dnlc, zero if not.
2665  */
2666 int
2667 vn_in_dnlc(vnode_t *vp)
2668 {
2669         return (vp->v_count_dnlc > 0);
2670 }
2671 
2672 /*
2673  * vn_has_other_opens() checks whether a particular file is opened by more than
2674  * just the caller and whether the open is for read and/or write.
2675  * This routine is for calling after the caller has already called VOP_OPEN()
2676  * and the caller wishes to know if they are the only one with it open for
2677  * the mode(s) specified.
2678  *
2679  * Vnode counts are only kept on regular files (v_type=VREG).
2680  */
2681 int
2682 vn_has_other_opens(
2683         vnode_t *vp,
2684         v_mode_t mode)
2685 {
2686 
2687         ASSERT(vp != NULL);
2688 
2689         switch (mode) {
2690         case V_WRITE:
2691                 if (vp->v_wrcnt > 1)
2692                         return (V_TRUE);
2693                 break;
2694         case V_RDORWR:
2695                 if ((vp->v_rdcnt > 1) || (vp->v_wrcnt > 1))
2696                         return (V_TRUE);
2697                 break;
2698         case V_RDANDWR:
2699                 if ((vp->v_rdcnt > 1) && (vp->v_wrcnt > 1))
2700                         return (V_TRUE);
2701                 break;
2702         case V_READ:
2703                 if (vp->v_rdcnt > 1)
2704                         return (V_TRUE);
2705                 break;
2706         }
2707 
2708         return (V_FALSE);
2709 }
2710 
2711 /*
2712  * vn_is_opened() checks whether a particular file is opened and
2713  * whether the open is for read and/or write.
2714  *
2715  * Vnode counts are only kept on regular files (v_type=VREG).
2716  */
2717 int
2718 vn_is_opened(
2719         vnode_t *vp,
2720         v_mode_t mode)
2721 {
2722 
2723         ASSERT(vp != NULL);
2724 
2725         switch (mode) {
2726         case V_WRITE:
2727                 if (vp->v_wrcnt)
2728                         return (V_TRUE);
2729                 break;
2730         case V_RDANDWR:
2731                 if (vp->v_rdcnt && vp->v_wrcnt)
2732                         return (V_TRUE);
2733                 break;
2734         case V_RDORWR:
2735                 if (vp->v_rdcnt || vp->v_wrcnt)
2736                         return (V_TRUE);
2737                 break;
2738         case V_READ:
2739                 if (vp->v_rdcnt)
2740                         return (V_TRUE);
2741                 break;
2742         }
2743 
2744         return (V_FALSE);
2745 }
2746 
2747 /*
2748  * vn_is_mapped() checks whether a particular file is mapped and whether
2749  * the file is mapped read and/or write.
2750  */
2751 int
2752 vn_is_mapped(
2753         vnode_t *vp,
2754         v_mode_t mode)
2755 {
2756 
2757         ASSERT(vp != NULL);
2758 
2759 #if !defined(_LP64)
2760         switch (mode) {
2761         /*
2762          * The atomic_add_64_nv functions force atomicity in the
2763          * case of 32 bit architectures. Otherwise the 64 bit values
2764          * require two fetches. The value of the fields may be
2765          * (potentially) changed between the first fetch and the
2766          * second
2767          */
2768         case V_WRITE:
2769                 if (atomic_add_64_nv((&(vp->v_mmap_write)), 0))
2770                         return (V_TRUE);
2771                 break;
2772         case V_RDANDWR:
2773                 if ((atomic_add_64_nv((&(vp->v_mmap_read)), 0)) &&
2774                     (atomic_add_64_nv((&(vp->v_mmap_write)), 0)))
2775                         return (V_TRUE);
2776                 break;
2777         case V_RDORWR:
2778                 if ((atomic_add_64_nv((&(vp->v_mmap_read)), 0)) ||
2779                     (atomic_add_64_nv((&(vp->v_mmap_write)), 0)))
2780                         return (V_TRUE);
2781                 break;
2782         case V_READ:
2783                 if (atomic_add_64_nv((&(vp->v_mmap_read)), 0))
2784                         return (V_TRUE);
2785                 break;
2786         }
2787 #else
2788         switch (mode) {
2789         case V_WRITE:
2790                 if (vp->v_mmap_write)
2791                         return (V_TRUE);
2792                 break;
2793         case V_RDANDWR:
2794                 if (vp->v_mmap_read && vp->v_mmap_write)
2795                         return (V_TRUE);
2796                 break;
2797         case V_RDORWR:
2798                 if (vp->v_mmap_read || vp->v_mmap_write)
2799                         return (V_TRUE);
2800                 break;
2801         case V_READ:
2802                 if (vp->v_mmap_read)
2803                         return (V_TRUE);
2804                 break;
2805         }
2806 #endif
2807 
2808         return (V_FALSE);
2809 }
2810 
2811 /*
2812  * Set the operations vector for a vnode.
2813  *
2814  * FEM ensures that the v_femhead pointer is filled in before the
2815  * v_op pointer is changed.  This means that if the v_femhead pointer
2816  * is NULL, and the v_op field hasn't changed since before which checked
2817  * the v_femhead pointer; then our update is ok - we are not racing with
2818  * FEM.
2819  */
2820 void
2821 vn_setops(vnode_t *vp, vnodeops_t *vnodeops)
2822 {
2823         vnodeops_t      *op;
2824 
2825         ASSERT(vp != NULL);
2826         ASSERT(vnodeops != NULL);
2827 
2828         op = vp->v_op;
2829         membar_consumer();
2830         /*
2831          * If vp->v_femhead == NULL, then we'll call casptr() to do the
2832          * compare-and-swap on vp->v_op.  If either fails, then FEM is
2833          * in effect on the vnode and we need to have FEM deal with it.
2834          */
2835         if (vp->v_femhead != NULL || casptr(&vp->v_op, op, vnodeops) != op) {
2836                 fem_setvnops(vp, vnodeops);
2837         }
2838 }
2839 
2840 /*
2841  * Retrieve the operations vector for a vnode
2842  * As with vn_setops(above); make sure we aren't racing with FEM.
2843  * FEM sets the v_op to a special, internal, vnodeops that wouldn't
2844  * make sense to the callers of this routine.
2845  */
2846 vnodeops_t *
2847 vn_getops(vnode_t *vp)
2848 {
2849         vnodeops_t      *op;
2850 
2851         ASSERT(vp != NULL);
2852 
2853         op = vp->v_op;
2854         membar_consumer();
2855         if (vp->v_femhead == NULL && op == vp->v_op) {
2856                 return (op);
2857         } else {
2858                 return (fem_getvnops(vp));
2859         }
2860 }
2861 
2862 /*
2863  * Returns non-zero (1) if the vnodeops matches that of the vnode.
2864  * Returns zero (0) if not.
2865  */
2866 int
2867 vn_matchops(vnode_t *vp, vnodeops_t *vnodeops)
2868 {
2869         return (vn_getops(vp) == vnodeops);
2870 }
2871 
2872 /*
2873  * Returns non-zero (1) if the specified operation matches the
2874  * corresponding operation for that the vnode.
2875  * Returns zero (0) if not.
2876  */
2877 
2878 #define MATCHNAME(n1, n2) (((n1)[0] == (n2)[0]) && (strcmp((n1), (n2)) == 0))
2879 
2880 int
2881 vn_matchopval(vnode_t *vp, char *vopname, fs_generic_func_p funcp)
2882 {
2883         const fs_operation_trans_def_t *otdp;
2884         fs_generic_func_p *loc = NULL;
2885         vnodeops_t      *vop = vn_getops(vp);
2886 
2887         ASSERT(vopname != NULL);
2888 
2889         for (otdp = vn_ops_table; otdp->name != NULL; otdp++) {
2890                 if (MATCHNAME(otdp->name, vopname)) {
2891                         loc = (fs_generic_func_p *)
2892                             ((char *)(vop) + otdp->offset);
2893                         break;
2894                 }
2895         }
2896 
2897         return ((loc != NULL) && (*loc == funcp));
2898 }
2899 
2900 /*
2901  * fs_new_caller_id() needs to return a unique ID on a given local system.
2902  * The IDs do not need to survive across reboots.  These are primarily
2903  * used so that (FEM) monitors can detect particular callers (such as
2904  * the NFS server) to a given vnode/vfs operation.
2905  */
2906 u_longlong_t
2907 fs_new_caller_id()
2908 {
2909         static uint64_t next_caller_id = 0LL; /* First call returns 1 */
2910 
2911         return ((u_longlong_t)atomic_add_64_nv(&next_caller_id, 1));
2912 }
2913 
2914 /*
2915  * Given a starting vnode and a path, updates the path in the target vnode in
2916  * a safe manner.  If the vnode already has path information embedded, then the
2917  * cached path is left untouched.
2918  */
2919 
2920 size_t max_vnode_path = 4 * MAXPATHLEN;
2921 
2922 void
2923 vn_setpath(vnode_t *rootvp, struct vnode *startvp, struct vnode *vp,
2924     const char *path, size_t plen)
2925 {
2926         char    *rpath;
2927         vnode_t *base;
2928         size_t  rpathlen, rpathalloc;
2929         int     doslash = 1;
2930 
2931         if (*path == '/') {
2932                 base = rootvp;
2933                 path++;
2934                 plen--;
2935         } else {
2936                 base = startvp;
2937         }
2938 
2939         /*
2940          * We cannot grab base->v_lock while we hold vp->v_lock because of
2941          * the potential for deadlock.
2942          */
2943         mutex_enter(&base->v_lock);
2944         if (base->v_path == NULL) {
2945                 mutex_exit(&base->v_lock);
2946                 return;
2947         }
2948 
2949         rpathlen = strlen(base->v_path);
2950         rpathalloc = rpathlen + plen + 1;
2951         /* Avoid adding a slash if there's already one there */
2952         if (base->v_path[rpathlen-1] == '/')
2953                 doslash = 0;
2954         else
2955                 rpathalloc++;
2956 
2957         /*
2958          * We don't want to call kmem_alloc(KM_SLEEP) with kernel locks held,
2959          * so we must do this dance.  If, by chance, something changes the path,
2960          * just give up since there is no real harm.
2961          */
2962         mutex_exit(&base->v_lock);
2963 
2964         /* Paths should stay within reason */
2965         if (rpathalloc > max_vnode_path)
2966                 return;
2967 
2968         rpath = kmem_alloc(rpathalloc, KM_SLEEP);
2969 
2970         mutex_enter(&base->v_lock);
2971         if (base->v_path == NULL || strlen(base->v_path) != rpathlen) {
2972                 mutex_exit(&base->v_lock);
2973                 kmem_free(rpath, rpathalloc);
2974                 return;
2975         }
2976         bcopy(base->v_path, rpath, rpathlen);
2977         mutex_exit(&base->v_lock);
2978 
2979         if (doslash)
2980                 rpath[rpathlen++] = '/';
2981         bcopy(path, rpath + rpathlen, plen);
2982         rpath[rpathlen + plen] = '\0';
2983 
2984         mutex_enter(&vp->v_lock);
2985         if (vp->v_path != NULL) {
2986                 mutex_exit(&vp->v_lock);
2987                 kmem_free(rpath, rpathalloc);
2988         } else {
2989                 vp->v_path = rpath;
2990                 mutex_exit(&vp->v_lock);
2991         }
2992 }
2993 
2994 /*
2995  * Sets the path to the vnode to be the given string, regardless of current
2996  * context.  The string must be a complete path from rootdir.  This is only used
2997  * by fsop_root() for setting the path based on the mountpoint.
2998  */
2999 void
3000 vn_setpath_str(struct vnode *vp, const char *str, size_t len)
3001 {
3002         char *buf = kmem_alloc(len + 1, KM_SLEEP);
3003 
3004         mutex_enter(&vp->v_lock);
3005         if (vp->v_path != NULL) {
3006                 mutex_exit(&vp->v_lock);
3007                 kmem_free(buf, len + 1);
3008                 return;
3009         }
3010 
3011         vp->v_path = buf;
3012         bcopy(str, vp->v_path, len);
3013         vp->v_path[len] = '\0';
3014 
3015         mutex_exit(&vp->v_lock);
3016 }
3017 
3018 /*
3019  * Called from within filesystem's vop_rename() to handle renames once the
3020  * target vnode is available.
3021  */
3022 void
3023 vn_renamepath(vnode_t *dvp, vnode_t *vp, const char *nm, size_t len)
3024 {
3025         char *tmp;
3026 
3027         mutex_enter(&vp->v_lock);
3028         tmp = vp->v_path;
3029         vp->v_path = NULL;
3030         mutex_exit(&vp->v_lock);
3031         vn_setpath(rootdir, dvp, vp, nm, len);
3032         if (tmp != NULL)
3033                 kmem_free(tmp, strlen(tmp) + 1);
3034 }
3035 
3036 /*
3037  * Similar to vn_setpath_str(), this function sets the path of the destination
3038  * vnode to the be the same as the source vnode.
3039  */
3040 void
3041 vn_copypath(struct vnode *src, struct vnode *dst)
3042 {
3043         char *buf;
3044         int alloc;
3045 
3046         mutex_enter(&src->v_lock);
3047         if (src->v_path == NULL) {
3048                 mutex_exit(&src->v_lock);
3049                 return;
3050         }
3051         alloc = strlen(src->v_path) + 1;
3052 
3053         /* avoid kmem_alloc() with lock held */
3054         mutex_exit(&src->v_lock);
3055         buf = kmem_alloc(alloc, KM_SLEEP);
3056         mutex_enter(&src->v_lock);
3057         if (src->v_path == NULL || strlen(src->v_path) + 1 != alloc) {
3058                 mutex_exit(&src->v_lock);
3059                 kmem_free(buf, alloc);
3060                 return;
3061         }
3062         bcopy(src->v_path, buf, alloc);
3063         mutex_exit(&src->v_lock);
3064 
3065         mutex_enter(&dst->v_lock);
3066         if (dst->v_path != NULL) {
3067                 mutex_exit(&dst->v_lock);
3068                 kmem_free(buf, alloc);
3069                 return;
3070         }
3071         dst->v_path = buf;
3072         mutex_exit(&dst->v_lock);
3073 }
3074 
3075 /*
3076  * XXX Private interface for segvn routines that handle vnode
3077  * large page segments.
3078  *
3079  * return 1 if vp's file system VOP_PAGEIO() implementation
3080  * can be safely used instead of VOP_GETPAGE() for handling
3081  * pagefaults against regular non swap files. VOP_PAGEIO()
3082  * interface is considered safe here if its implementation
3083  * is very close to VOP_GETPAGE() implementation.
3084  * e.g. It zero's out the part of the page beyond EOF. Doesn't
3085  * panic if there're file holes but instead returns an error.
3086  * Doesn't assume file won't be changed by user writes, etc.
3087  *
3088  * return 0 otherwise.
3089  *
3090  * For now allow segvn to only use VOP_PAGEIO() with ufs and nfs.
3091  */
3092 int
3093 vn_vmpss_usepageio(vnode_t *vp)
3094 {
3095         vfs_t   *vfsp = vp->v_vfsp;
3096         char *fsname = vfssw[vfsp->vfs_fstype].vsw_name;
3097         char *pageio_ok_fss[] = {"ufs", "nfs", NULL};
3098         char **fsok = pageio_ok_fss;
3099 
3100         if (fsname == NULL) {
3101                 return (0);
3102         }
3103 
3104         for (; *fsok; fsok++) {
3105                 if (strcmp(*fsok, fsname) == 0) {
3106                         return (1);
3107                 }
3108         }
3109         return (0);
3110 }
3111 
3112 /* VOP_XXX() macros call the corresponding fop_xxx() function */
3113 
3114 int
3115 fop_open(
3116         vnode_t **vpp,
3117         int mode,
3118         cred_t *cr,
3119         caller_context_t *ct)
3120 {
3121         int ret;
3122         vnode_t *vp = *vpp;
3123 
3124         VN_HOLD(vp);
3125         /*
3126          * Adding to the vnode counts before calling open
3127          * avoids the need for a mutex. It circumvents a race
3128          * condition where a query made on the vnode counts results in a
3129          * false negative. The inquirer goes away believing the file is
3130          * not open when there is an open on the file already under way.
3131          *
3132          * The counts are meant to prevent NFS from granting a delegation
3133          * when it would be dangerous to do so.
3134          *
3135          * The vnode counts are only kept on regular files
3136          */
3137         if ((*vpp)->v_type == VREG) {
3138                 if (mode & FREAD)
3139                         atomic_add_32(&((*vpp)->v_rdcnt), 1);
3140                 if (mode & FWRITE)
3141                         atomic_add_32(&((*vpp)->v_wrcnt), 1);
3142         }
3143 
3144         VOPXID_MAP_CR(vp, cr);
3145         
3146         /*
3147          * Control is passed to fsh. In the end, underlying vop_vopen()
3148          * is called.
3149          */
3150         ret = fsh_open(vpp, mode, cr, ct);
3151 
3152         if (ret) {
3153                 /*
3154                  * Use the saved vp just in case the vnode ptr got trashed
3155                  * by the error.
3156                  */
3157                 VOPSTATS_UPDATE(vp, open);
3158                 if ((vp->v_type == VREG) && (mode & FREAD))
3159                         atomic_add_32(&(vp->v_rdcnt), -1);
3160                 if ((vp->v_type == VREG) && (mode & FWRITE))
3161                         atomic_add_32(&(vp->v_wrcnt), -1);
3162         } else {
3163                 /*
3164                  * Some filesystems will return a different vnode,
3165                  * but the same path was still used to open it.
3166                  * So if we do change the vnode and need to
3167                  * copy over the path, do so here, rather than special
3168                  * casing each filesystem. Adjust the vnode counts to
3169                  * reflect the vnode switch.
3170                  */
3171                 VOPSTATS_UPDATE(*vpp, open);
3172                 if (*vpp != vp && *vpp != NULL) {
3173                         vn_copypath(vp, *vpp);
3174                         if (((*vpp)->v_type == VREG) && (mode & FREAD))
3175                                 atomic_add_32(&((*vpp)->v_rdcnt), 1);
3176                         if ((vp->v_type == VREG) && (mode & FREAD))
3177                                 atomic_add_32(&(vp->v_rdcnt), -1);
3178                         if (((*vpp)->v_type == VREG) && (mode & FWRITE))
3179                                 atomic_add_32(&((*vpp)->v_wrcnt), 1);
3180                         if ((vp->v_type == VREG) && (mode & FWRITE))
3181                                 atomic_add_32(&(vp->v_wrcnt), -1);
3182                 }
3183         }
3184         VN_RELE(vp);
3185         return (ret);
3186 }
3187 
3188 int
3189 fop_close(
3190         vnode_t *vp,
3191         int flag,
3192         int count,
3193         offset_t offset,
3194         cred_t *cr,
3195         caller_context_t *ct)
3196 {
3197         int err;
3198 
3199         VOPXID_MAP_CR(vp, cr);
3200         
3201         err = fsh_close(vp, flag, count, offset, cr, ct);
3202         VOPSTATS_UPDATE(vp, close);
3203         /*
3204          * Check passed in count to handle possible dups. Vnode counts are only
3205          * kept on regular files
3206          */
3207         if ((vp->v_type == VREG) && (count == 1))  {
3208                 if (flag & FREAD) {
3209                         ASSERT(vp->v_rdcnt > 0);
3210                         atomic_add_32(&(vp->v_rdcnt), -1);
3211                 }
3212                 if (flag & FWRITE) {
3213                         ASSERT(vp->v_wrcnt > 0);
3214                         atomic_add_32(&(vp->v_wrcnt), -1);
3215                 }
3216         }
3217         return (err);
3218 }
3219 
3220 int
3221 fop_read(
3222         vnode_t *vp,
3223         uio_t *uiop,
3224         int ioflag,
3225         cred_t *cr,
3226         caller_context_t *ct)
3227 {
3228         int     err;
3229         ssize_t resid_start = uiop->uio_resid;
3230 
3231         VOPXID_MAP_CR(vp, cr);
3232         
3233         err = fsh_read(vp, uiop, ioflag, cr, ct);
3234         VOPSTATS_UPDATE_IO(vp, read,
3235             read_bytes, (resid_start - uiop->uio_resid));
3236         return (err);
3237 }
3238 
3239 int
3240 fop_write(
3241         vnode_t *vp,
3242         uio_t *uiop,
3243         int ioflag,
3244         cred_t *cr,
3245         caller_context_t *ct)
3246 {
3247         int     err;
3248         ssize_t resid_start = uiop->uio_resid;
3249 
3250         VOPXID_MAP_CR(vp, cr);
3251 
3252         err = fsh_write(vp, uiop, ioflag, cr, ct);
3253         VOPSTATS_UPDATE_IO(vp, write,
3254             write_bytes, (resid_start - uiop->uio_resid));
3255         return (err);
3256 }
3257 
3258 int
3259 fop_ioctl(
3260         vnode_t *vp,
3261         int cmd,
3262         intptr_t arg,
3263         int flag,
3264         cred_t *cr,
3265         int *rvalp,
3266         caller_context_t *ct)
3267 {
3268         int     err;
3269 
3270         VOPXID_MAP_CR(vp, cr);
3271 
3272         err = (*(vp)->v_op->vop_ioctl)(vp, cmd, arg, flag, cr, rvalp, ct);
3273         VOPSTATS_UPDATE(vp, ioctl);
3274         return (err);
3275 }
3276 
3277 int
3278 fop_setfl(
3279         vnode_t *vp,
3280         int oflags,
3281         int nflags,
3282         cred_t *cr,
3283         caller_context_t *ct)
3284 {
3285         int     err;
3286 
3287         VOPXID_MAP_CR(vp, cr);
3288 
3289         err = (*(vp)->v_op->vop_setfl)(vp, oflags, nflags, cr, ct);
3290         VOPSTATS_UPDATE(vp, setfl);
3291         return (err);
3292 }
3293 
3294 int
3295 fop_getattr(
3296         vnode_t *vp,
3297         vattr_t *vap,
3298         int flags,
3299         cred_t *cr,
3300         caller_context_t *ct)
3301 {
3302         int     err;
3303 
3304         VOPXID_MAP_CR(vp, cr);
3305 
3306         /*
3307          * If this file system doesn't understand the xvattr extensions
3308          * then turn off the xvattr bit.
3309          */
3310         if (vfs_has_feature(vp->v_vfsp, VFSFT_XVATTR) == 0) {
3311                 vap->va_mask &= ~AT_XVATTR;
3312         }
3313 
3314         /*
3315          * We're only allowed to skip the ACL check iff we used a 32 bit
3316          * ACE mask with VOP_ACCESS() to determine permissions.
3317          */
3318         if ((flags & ATTR_NOACLCHECK) &&
3319             vfs_has_feature(vp->v_vfsp, VFSFT_ACEMASKONACCESS) == 0) {
3320                 return (EINVAL);
3321         }
3322         err = (*(vp)->v_op->vop_getattr)(vp, vap, flags, cr, ct);
3323         VOPSTATS_UPDATE(vp, getattr);
3324         return (err);
3325 }
3326 
3327 int
3328 fop_setattr(
3329         vnode_t *vp,
3330         vattr_t *vap,
3331         int flags,
3332         cred_t *cr,
3333         caller_context_t *ct)
3334 {
3335         int     err;
3336 
3337         VOPXID_MAP_CR(vp, cr);
3338 
3339         /*
3340          * If this file system doesn't understand the xvattr extensions
3341          * then turn off the xvattr bit.
3342          */
3343         if (vfs_has_feature(vp->v_vfsp, VFSFT_XVATTR) == 0) {
3344                 vap->va_mask &= ~AT_XVATTR;
3345         }
3346 
3347         /*
3348          * We're only allowed to skip the ACL check iff we used a 32 bit
3349          * ACE mask with VOP_ACCESS() to determine permissions.
3350          */
3351         if ((flags & ATTR_NOACLCHECK) &&
3352             vfs_has_feature(vp->v_vfsp, VFSFT_ACEMASKONACCESS) == 0) {
3353                 return (EINVAL);
3354         }
3355         err = (*(vp)->v_op->vop_setattr)(vp, vap, flags, cr, ct);
3356         VOPSTATS_UPDATE(vp, setattr);
3357         return (err);
3358 }
3359 
3360 int
3361 fop_access(
3362         vnode_t *vp,
3363         int mode,
3364         int flags,
3365         cred_t *cr,
3366         caller_context_t *ct)
3367 {
3368         int     err;
3369 
3370         if ((flags & V_ACE_MASK) &&
3371             vfs_has_feature(vp->v_vfsp, VFSFT_ACEMASKONACCESS) == 0) {
3372                 return (EINVAL);
3373         }
3374 
3375         VOPXID_MAP_CR(vp, cr);
3376 
3377         err = (*(vp)->v_op->vop_access)(vp, mode, flags, cr, ct);
3378         VOPSTATS_UPDATE(vp, access);
3379         return (err);
3380 }
3381 
3382 int
3383 fop_lookup(
3384         vnode_t *dvp,
3385         char *nm,
3386         vnode_t **vpp,
3387         pathname_t *pnp,
3388         int flags,
3389         vnode_t *rdir,
3390         cred_t *cr,
3391         caller_context_t *ct,
3392         int *deflags,           /* Returned per-dirent flags */
3393         pathname_t *ppnp)       /* Returned case-preserved name in directory */
3394 {
3395         int ret;
3396 
3397         /*
3398          * If this file system doesn't support case-insensitive access
3399          * and said access is requested, fail quickly.  It is required
3400          * that if the vfs supports case-insensitive lookup, it also
3401          * supports extended dirent flags.
3402          */
3403         if (flags & FIGNORECASE &&
3404             (vfs_has_feature(dvp->v_vfsp, VFSFT_CASEINSENSITIVE) == 0 &&
3405             vfs_has_feature(dvp->v_vfsp, VFSFT_NOCASESENSITIVE) == 0))
3406                 return (EINVAL);
3407 
3408         VOPXID_MAP_CR(dvp, cr);
3409 
3410         if ((flags & LOOKUP_XATTR) && (flags & LOOKUP_HAVE_SYSATTR_DIR) == 0) {
3411                 ret = xattr_dir_lookup(dvp, vpp, flags, cr);
3412         } else {
3413                 ret = (*(dvp)->v_op->vop_lookup)
3414                     (dvp, nm, vpp, pnp, flags, rdir, cr, ct, deflags, ppnp);
3415         }
3416         if (ret == 0 && *vpp) {
3417                 VOPSTATS_UPDATE(*vpp, lookup);
3418                 if ((*vpp)->v_path == NULL) {
3419                         vn_setpath(rootdir, dvp, *vpp, nm, strlen(nm));
3420                 }
3421         }
3422 
3423         return (ret);
3424 }
3425 
3426 int
3427 fop_create(
3428         vnode_t *dvp,
3429         char *name,
3430         vattr_t *vap,
3431         vcexcl_t excl,
3432         int mode,
3433         vnode_t **vpp,
3434         cred_t *cr,
3435         int flags,
3436         caller_context_t *ct,
3437         vsecattr_t *vsecp)      /* ACL to set during create */
3438 {
3439         int ret;
3440 
3441         if (vsecp != NULL &&
3442             vfs_has_feature(dvp->v_vfsp, VFSFT_ACLONCREATE) == 0) {
3443                 return (EINVAL);
3444         }
3445         /*
3446          * If this file system doesn't support case-insensitive access
3447          * and said access is requested, fail quickly.
3448          */
3449         if (flags & FIGNORECASE &&
3450             (vfs_has_feature(dvp->v_vfsp, VFSFT_CASEINSENSITIVE) == 0 &&
3451             vfs_has_feature(dvp->v_vfsp, VFSFT_NOCASESENSITIVE) == 0))
3452                 return (EINVAL);
3453 
3454         VOPXID_MAP_CR(dvp, cr);
3455 
3456         ret = (*(dvp)->v_op->vop_create)
3457             (dvp, name, vap, excl, mode, vpp, cr, flags, ct, vsecp);
3458         if (ret == 0 && *vpp) {
3459                 VOPSTATS_UPDATE(*vpp, create);
3460                 if ((*vpp)->v_path == NULL) {
3461                         vn_setpath(rootdir, dvp, *vpp, name, strlen(name));
3462                 }
3463         }
3464 
3465         return (ret);
3466 }
3467 
3468 int
3469 fop_remove(
3470         vnode_t *dvp,
3471         char *nm,
3472         cred_t *cr,
3473         caller_context_t *ct,
3474         int flags)
3475 {
3476         int     err;
3477 
3478         /*
3479          * If this file system doesn't support case-insensitive access
3480          * and said access is requested, fail quickly.
3481          */
3482         if (flags & FIGNORECASE &&
3483             (vfs_has_feature(dvp->v_vfsp, VFSFT_CASEINSENSITIVE) == 0 &&
3484             vfs_has_feature(dvp->v_vfsp, VFSFT_NOCASESENSITIVE) == 0))
3485                 return (EINVAL);
3486 
3487         VOPXID_MAP_CR(dvp, cr);
3488 
3489         err = (*(dvp)->v_op->vop_remove)(dvp, nm, cr, ct, flags);
3490         VOPSTATS_UPDATE(dvp, remove);
3491         return (err);
3492 }
3493 
3494 int
3495 fop_link(
3496         vnode_t *tdvp,
3497         vnode_t *svp,
3498         char *tnm,
3499         cred_t *cr,
3500         caller_context_t *ct,
3501         int flags)
3502 {
3503         int     err;
3504 
3505         /*
3506          * If the target file system doesn't support case-insensitive access
3507          * and said access is requested, fail quickly.
3508          */
3509         if (flags & FIGNORECASE &&
3510             (vfs_has_feature(tdvp->v_vfsp, VFSFT_CASEINSENSITIVE) == 0 &&
3511             vfs_has_feature(tdvp->v_vfsp, VFSFT_NOCASESENSITIVE) == 0))
3512                 return (EINVAL);
3513 
3514         VOPXID_MAP_CR(tdvp, cr);
3515 
3516         err = (*(tdvp)->v_op->vop_link)(tdvp, svp, tnm, cr, ct, flags);
3517         VOPSTATS_UPDATE(tdvp, link);
3518         return (err);
3519 }
3520 
3521 int
3522 fop_rename(
3523         vnode_t *sdvp,
3524         char *snm,
3525         vnode_t *tdvp,
3526         char *tnm,
3527         cred_t *cr,
3528         caller_context_t *ct,
3529         int flags)
3530 {
3531         int     err;
3532 
3533         /*
3534          * If the file system involved does not support
3535          * case-insensitive access and said access is requested, fail
3536          * quickly.
3537          */
3538         if (flags & FIGNORECASE &&
3539             ((vfs_has_feature(sdvp->v_vfsp, VFSFT_CASEINSENSITIVE) == 0 &&
3540             vfs_has_feature(sdvp->v_vfsp, VFSFT_NOCASESENSITIVE) == 0)))
3541                 return (EINVAL);
3542 
3543         VOPXID_MAP_CR(tdvp, cr);
3544 
3545         err = (*(sdvp)->v_op->vop_rename)(sdvp, snm, tdvp, tnm, cr, ct, flags);
3546         VOPSTATS_UPDATE(sdvp, rename);
3547         return (err);
3548 }
3549 
3550 int
3551 fop_mkdir(
3552         vnode_t *dvp,
3553         char *dirname,
3554         vattr_t *vap,
3555         vnode_t **vpp,
3556         cred_t *cr,
3557         caller_context_t *ct,
3558         int flags,
3559         vsecattr_t *vsecp)      /* ACL to set during create */
3560 {
3561         int ret;
3562 
3563         if (vsecp != NULL &&
3564             vfs_has_feature(dvp->v_vfsp, VFSFT_ACLONCREATE) == 0) {
3565                 return (EINVAL);
3566         }
3567         /*
3568          * If this file system doesn't support case-insensitive access
3569          * and said access is requested, fail quickly.
3570          */
3571         if (flags & FIGNORECASE &&
3572             (vfs_has_feature(dvp->v_vfsp, VFSFT_CASEINSENSITIVE) == 0 &&
3573             vfs_has_feature(dvp->v_vfsp, VFSFT_NOCASESENSITIVE) == 0))
3574                 return (EINVAL);
3575 
3576         VOPXID_MAP_CR(dvp, cr);
3577 
3578         ret = (*(dvp)->v_op->vop_mkdir)
3579             (dvp, dirname, vap, vpp, cr, ct, flags, vsecp);
3580         if (ret == 0 && *vpp) {
3581                 VOPSTATS_UPDATE(*vpp, mkdir);
3582                 if ((*vpp)->v_path == NULL) {
3583                         vn_setpath(rootdir, dvp, *vpp, dirname,
3584                             strlen(dirname));
3585                 }
3586         }
3587 
3588         return (ret);
3589 }
3590 
3591 int
3592 fop_rmdir(
3593         vnode_t *dvp,
3594         char *nm,
3595         vnode_t *cdir,
3596         cred_t *cr,
3597         caller_context_t *ct,
3598         int flags)
3599 {
3600         int     err;
3601 
3602         /*
3603          * If this file system doesn't support case-insensitive access
3604          * and said access is requested, fail quickly.
3605          */
3606         if (flags & FIGNORECASE &&
3607             (vfs_has_feature(dvp->v_vfsp, VFSFT_CASEINSENSITIVE) == 0 &&
3608             vfs_has_feature(dvp->v_vfsp, VFSFT_NOCASESENSITIVE) == 0))
3609                 return (EINVAL);
3610 
3611         VOPXID_MAP_CR(dvp, cr);
3612 
3613         err = (*(dvp)->v_op->vop_rmdir)(dvp, nm, cdir, cr, ct, flags);
3614         VOPSTATS_UPDATE(dvp, rmdir);
3615         return (err);
3616 }
3617 
3618 int
3619 fop_readdir(
3620         vnode_t *vp,
3621         uio_t *uiop,
3622         cred_t *cr,
3623         int *eofp,
3624         caller_context_t *ct,
3625         int flags)
3626 {
3627         int     err;
3628         ssize_t resid_start = uiop->uio_resid;
3629 
3630         /*
3631          * If this file system doesn't support retrieving directory
3632          * entry flags and said access is requested, fail quickly.
3633          */
3634         if (flags & V_RDDIR_ENTFLAGS &&
3635             vfs_has_feature(vp->v_vfsp, VFSFT_DIRENTFLAGS) == 0)
3636                 return (EINVAL);
3637 
3638         VOPXID_MAP_CR(vp, cr);
3639 
3640         err = (*(vp)->v_op->vop_readdir)(vp, uiop, cr, eofp, ct, flags);
3641         VOPSTATS_UPDATE_IO(vp, readdir,
3642             readdir_bytes, (resid_start - uiop->uio_resid));
3643         return (err);
3644 }
3645 
3646 int
3647 fop_symlink(
3648         vnode_t *dvp,
3649         char *linkname,
3650         vattr_t *vap,
3651         char *target,
3652         cred_t *cr,
3653         caller_context_t *ct,
3654         int flags)
3655 {
3656         int     err;
3657         xvattr_t xvattr;
3658 
3659         /*
3660          * If this file system doesn't support case-insensitive access
3661          * and said access is requested, fail quickly.
3662          */
3663         if (flags & FIGNORECASE &&
3664             (vfs_has_feature(dvp->v_vfsp, VFSFT_CASEINSENSITIVE) == 0 &&
3665             vfs_has_feature(dvp->v_vfsp, VFSFT_NOCASESENSITIVE) == 0))
3666                 return (EINVAL);
3667 
3668         VOPXID_MAP_CR(dvp, cr);
3669 
3670         /* check for reparse point */
3671         if ((vfs_has_feature(dvp->v_vfsp, VFSFT_REPARSE)) &&
3672             (strncmp(target, FS_REPARSE_TAG_STR,
3673             strlen(FS_REPARSE_TAG_STR)) == 0)) {
3674                 if (!fs_reparse_mark(target, vap, &xvattr))
3675                         vap = (vattr_t *)&xvattr;
3676         }
3677 
3678         err = (*(dvp)->v_op->vop_symlink)
3679             (dvp, linkname, vap, target, cr, ct, flags);
3680         VOPSTATS_UPDATE(dvp, symlink);
3681         return (err);
3682 }
3683 
3684 int
3685 fop_readlink(
3686         vnode_t *vp,
3687         uio_t *uiop,
3688         cred_t *cr,
3689         caller_context_t *ct)
3690 {
3691         int     err;
3692 
3693         VOPXID_MAP_CR(vp, cr);
3694 
3695         err = (*(vp)->v_op->vop_readlink)(vp, uiop, cr, ct);
3696         VOPSTATS_UPDATE(vp, readlink);
3697         return (err);
3698 }
3699 
3700 int
3701 fop_fsync(
3702         vnode_t *vp,
3703         int syncflag,
3704         cred_t *cr,
3705         caller_context_t *ct)
3706 {
3707         int     err;
3708 
3709         VOPXID_MAP_CR(vp, cr);
3710 
3711         err = (*(vp)->v_op->vop_fsync)(vp, syncflag, cr, ct);
3712         VOPSTATS_UPDATE(vp, fsync);
3713         return (err);
3714 }
3715 
3716 void
3717 fop_inactive(
3718         vnode_t *vp,
3719         cred_t *cr,
3720         caller_context_t *ct)
3721 {
3722         /* Need to update stats before vop call since we may lose the vnode */
3723         VOPSTATS_UPDATE(vp, inactive);
3724 
3725         VOPXID_MAP_CR(vp, cr);
3726 
3727         (*(vp)->v_op->vop_inactive)(vp, cr, ct);
3728 }
3729 
3730 int
3731 fop_fid(
3732         vnode_t *vp,
3733         fid_t *fidp,
3734         caller_context_t *ct)
3735 {
3736         int     err;
3737 
3738         err = (*(vp)->v_op->vop_fid)(vp, fidp, ct);
3739         VOPSTATS_UPDATE(vp, fid);
3740         return (err);
3741 }
3742 
3743 int
3744 fop_rwlock(
3745         vnode_t *vp,
3746         int write_lock,
3747         caller_context_t *ct)
3748 {
3749         int     ret;
3750 
3751         ret = ((*(vp)->v_op->vop_rwlock)(vp, write_lock, ct));
3752         VOPSTATS_UPDATE(vp, rwlock);
3753         return (ret);
3754 }
3755 
3756 void
3757 fop_rwunlock(
3758         vnode_t *vp,
3759         int write_lock,
3760         caller_context_t *ct)
3761 {
3762         (*(vp)->v_op->vop_rwunlock)(vp, write_lock, ct);
3763         VOPSTATS_UPDATE(vp, rwunlock);
3764 }
3765 
3766 int
3767 fop_seek(
3768         vnode_t *vp,
3769         offset_t ooff,
3770         offset_t *noffp,
3771         caller_context_t *ct)
3772 {
3773         int     err;
3774 
3775         err = (*(vp)->v_op->vop_seek)(vp, ooff, noffp, ct);
3776         VOPSTATS_UPDATE(vp, seek);
3777         return (err);
3778 }
3779 
3780 int
3781 fop_cmp(
3782         vnode_t *vp1,
3783         vnode_t *vp2,
3784         caller_context_t *ct)
3785 {
3786         int     err;
3787 
3788         err = (*(vp1)->v_op->vop_cmp)(vp1, vp2, ct);
3789         VOPSTATS_UPDATE(vp1, cmp);
3790         return (err);
3791 }
3792 
3793 int
3794 fop_frlock(
3795         vnode_t *vp,
3796         int cmd,
3797         flock64_t *bfp,
3798         int flag,
3799         offset_t offset,
3800         struct flk_callback *flk_cbp,
3801         cred_t *cr,
3802         caller_context_t *ct)
3803 {
3804         int     err;
3805 
3806         VOPXID_MAP_CR(vp, cr);
3807 
3808         err = (*(vp)->v_op->vop_frlock)
3809             (vp, cmd, bfp, flag, offset, flk_cbp, cr, ct);
3810         VOPSTATS_UPDATE(vp, frlock);
3811         return (err);
3812 }
3813 
3814 int
3815 fop_space(
3816         vnode_t *vp,
3817         int cmd,
3818         flock64_t *bfp,
3819         int flag,
3820         offset_t offset,
3821         cred_t *cr,
3822         caller_context_t *ct)
3823 {
3824         int     err;
3825 
3826         VOPXID_MAP_CR(vp, cr);
3827 
3828         err = (*(vp)->v_op->vop_space)(vp, cmd, bfp, flag, offset, cr, ct);
3829         VOPSTATS_UPDATE(vp, space);
3830         return (err);
3831 }
3832 
3833 int
3834 fop_realvp(
3835         vnode_t *vp,
3836         vnode_t **vpp,
3837         caller_context_t *ct)
3838 {
3839         int     err;
3840 
3841         err = (*(vp)->v_op->vop_realvp)(vp, vpp, ct);
3842         VOPSTATS_UPDATE(vp, realvp);
3843         return (err);
3844 }
3845 
3846 int
3847 fop_getpage(
3848         vnode_t *vp,
3849         offset_t off,
3850         size_t len,
3851         uint_t *protp,
3852         page_t **plarr,
3853         size_t plsz,
3854         struct seg *seg,
3855         caddr_t addr,
3856         enum seg_rw rw,
3857         cred_t *cr,
3858         caller_context_t *ct)
3859 {
3860         int     err;
3861 
3862         VOPXID_MAP_CR(vp, cr);
3863 
3864         err = (*(vp)->v_op->vop_getpage)
3865             (vp, off, len, protp, plarr, plsz, seg, addr, rw, cr, ct);
3866         VOPSTATS_UPDATE(vp, getpage);
3867         return (err);
3868 }
3869 
3870 int
3871 fop_putpage(
3872         vnode_t *vp,
3873         offset_t off,
3874         size_t len,
3875         int flags,
3876         cred_t *cr,
3877         caller_context_t *ct)
3878 {
3879         int     err;
3880 
3881         VOPXID_MAP_CR(vp, cr);
3882 
3883         err = (*(vp)->v_op->vop_putpage)(vp, off, len, flags, cr, ct);
3884         VOPSTATS_UPDATE(vp, putpage);
3885         return (err);
3886 }
3887 
3888 int
3889 fop_map(
3890         vnode_t *vp,
3891         offset_t off,
3892         struct as *as,
3893         caddr_t *addrp,
3894         size_t len,
3895         uchar_t prot,
3896         uchar_t maxprot,
3897         uint_t flags,
3898         cred_t *cr,
3899         caller_context_t *ct)
3900 {
3901         int     err;
3902 
3903         VOPXID_MAP_CR(vp, cr);
3904 
3905         err = (*(vp)->v_op->vop_map)
3906             (vp, off, as, addrp, len, prot, maxprot, flags, cr, ct);
3907         VOPSTATS_UPDATE(vp, map);
3908         return (err);
3909 }
3910 
3911 int
3912 fop_addmap(
3913         vnode_t *vp,
3914         offset_t off,
3915         struct as *as,
3916         caddr_t addr,
3917         size_t len,
3918         uchar_t prot,
3919         uchar_t maxprot,
3920         uint_t flags,
3921         cred_t *cr,
3922         caller_context_t *ct)
3923 {
3924         int error;
3925         u_longlong_t delta;
3926 
3927         VOPXID_MAP_CR(vp, cr);
3928 
3929         error = (*(vp)->v_op->vop_addmap)
3930             (vp, off, as, addr, len, prot, maxprot, flags, cr, ct);
3931 
3932         if ((!error) && (vp->v_type == VREG)) {
3933                 delta = (u_longlong_t)btopr(len);
3934                 /*
3935                  * If file is declared MAP_PRIVATE, it can't be written back
3936                  * even if open for write. Handle as read.
3937                  */
3938                 if (flags & MAP_PRIVATE) {
3939                         atomic_add_64((uint64_t *)(&(vp->v_mmap_read)),
3940                             (int64_t)delta);
3941                 } else {
3942                         /*
3943                          * atomic_add_64 forces the fetch of a 64 bit value to
3944                          * be atomic on 32 bit machines
3945                          */
3946                         if (maxprot & PROT_WRITE)
3947                                 atomic_add_64((uint64_t *)(&(vp->v_mmap_write)),
3948                                     (int64_t)delta);
3949                         if (maxprot & PROT_READ)
3950                                 atomic_add_64((uint64_t *)(&(vp->v_mmap_read)),
3951                                     (int64_t)delta);
3952                         if (maxprot & PROT_EXEC)
3953                                 atomic_add_64((uint64_t *)(&(vp->v_mmap_read)),
3954                                     (int64_t)delta);
3955                 }
3956         }
3957         VOPSTATS_UPDATE(vp, addmap);
3958         return (error);
3959 }
3960 
3961 int
3962 fop_delmap(
3963         vnode_t *vp,
3964         offset_t off,
3965         struct as *as,
3966         caddr_t addr,
3967         size_t len,
3968         uint_t prot,
3969         uint_t maxprot,
3970         uint_t flags,
3971         cred_t *cr,
3972         caller_context_t *ct)
3973 {
3974         int error;
3975         u_longlong_t delta;
3976 
3977         VOPXID_MAP_CR(vp, cr);
3978 
3979         error = (*(vp)->v_op->vop_delmap)
3980             (vp, off, as, addr, len, prot, maxprot, flags, cr, ct);
3981 
3982         /*
3983          * NFS calls into delmap twice, the first time
3984          * it simply establishes a callback mechanism and returns EAGAIN
3985          * while the real work is being done upon the second invocation.
3986          * We have to detect this here and only decrement the counts upon
3987          * the second delmap request.
3988          */
3989         if ((error != EAGAIN) && (vp->v_type == VREG)) {
3990 
3991                 delta = (u_longlong_t)btopr(len);
3992 
3993                 if (flags & MAP_PRIVATE) {
3994                         atomic_add_64((uint64_t *)(&(vp->v_mmap_read)),
3995                             (int64_t)(-delta));
3996                 } else {
3997                         /*
3998                          * atomic_add_64 forces the fetch of a 64 bit value
3999                          * to be atomic on 32 bit machines
4000                          */
4001                         if (maxprot & PROT_WRITE)
4002                                 atomic_add_64((uint64_t *)(&(vp->v_mmap_write)),
4003                                     (int64_t)(-delta));
4004                         if (maxprot & PROT_READ)
4005                                 atomic_add_64((uint64_t *)(&(vp->v_mmap_read)),
4006                                     (int64_t)(-delta));
4007                         if (maxprot & PROT_EXEC)
4008                                 atomic_add_64((uint64_t *)(&(vp->v_mmap_read)),
4009                                     (int64_t)(-delta));
4010                 }
4011         }
4012         VOPSTATS_UPDATE(vp, delmap);
4013         return (error);
4014 }
4015 
4016 
4017 int
4018 fop_poll(
4019         vnode_t *vp,
4020         short events,
4021         int anyyet,
4022         short *reventsp,
4023         struct pollhead **phpp,
4024         caller_context_t *ct)
4025 {
4026         int     err;
4027 
4028         err = (*(vp)->v_op->vop_poll)(vp, events, anyyet, reventsp, phpp, ct);
4029         VOPSTATS_UPDATE(vp, poll);
4030         return (err);
4031 }
4032 
4033 int
4034 fop_dump(
4035         vnode_t *vp,
4036         caddr_t addr,
4037         offset_t lbdn,
4038         offset_t dblks,
4039         caller_context_t *ct)
4040 {
4041         int     err;
4042 
4043         /* ensure lbdn and dblks can be passed safely to bdev_dump */
4044         if ((lbdn != (daddr_t)lbdn) || (dblks != (int)dblks))
4045                 return (EIO);
4046 
4047         err = (*(vp)->v_op->vop_dump)(vp, addr, lbdn, dblks, ct);
4048         VOPSTATS_UPDATE(vp, dump);
4049         return (err);
4050 }
4051 
4052 int
4053 fop_pathconf(
4054         vnode_t *vp,
4055         int cmd,
4056         ulong_t *valp,
4057         cred_t *cr,
4058         caller_context_t *ct)
4059 {
4060         int     err;
4061 
4062         VOPXID_MAP_CR(vp, cr);
4063 
4064         err = (*(vp)->v_op->vop_pathconf)(vp, cmd, valp, cr, ct);
4065         VOPSTATS_UPDATE(vp, pathconf);
4066         return (err);
4067 }
4068 
4069 int
4070 fop_pageio(
4071         vnode_t *vp,
4072         struct page *pp,
4073         u_offset_t io_off,
4074         size_t io_len,
4075         int flags,
4076         cred_t *cr,
4077         caller_context_t *ct)
4078 {
4079         int     err;
4080 
4081         VOPXID_MAP_CR(vp, cr);
4082 
4083         err = (*(vp)->v_op->vop_pageio)(vp, pp, io_off, io_len, flags, cr, ct);
4084         VOPSTATS_UPDATE(vp, pageio);
4085         return (err);
4086 }
4087 
4088 int
4089 fop_dumpctl(
4090         vnode_t *vp,
4091         int action,
4092         offset_t *blkp,
4093         caller_context_t *ct)
4094 {
4095         int     err;
4096         err = (*(vp)->v_op->vop_dumpctl)(vp, action, blkp, ct);
4097         VOPSTATS_UPDATE(vp, dumpctl);
4098         return (err);
4099 }
4100 
4101 void
4102 fop_dispose(
4103         vnode_t *vp,
4104         page_t *pp,
4105         int flag,
4106         int dn,
4107         cred_t *cr,
4108         caller_context_t *ct)
4109 {
4110         /* Must do stats first since it's possible to lose the vnode */
4111         VOPSTATS_UPDATE(vp, dispose);
4112 
4113         VOPXID_MAP_CR(vp, cr);
4114 
4115         (*(vp)->v_op->vop_dispose)(vp, pp, flag, dn, cr, ct);
4116 }
4117 
4118 int
4119 fop_setsecattr(
4120         vnode_t *vp,
4121         vsecattr_t *vsap,
4122         int flag,
4123         cred_t *cr,
4124         caller_context_t *ct)
4125 {
4126         int     err;
4127 
4128         VOPXID_MAP_CR(vp, cr);
4129 
4130         /*
4131          * We're only allowed to skip the ACL check iff we used a 32 bit
4132          * ACE mask with VOP_ACCESS() to determine permissions.
4133          */
4134         if ((flag & ATTR_NOACLCHECK) &&
4135             vfs_has_feature(vp->v_vfsp, VFSFT_ACEMASKONACCESS) == 0) {
4136                 return (EINVAL);
4137         }
4138         err = (*(vp)->v_op->vop_setsecattr) (vp, vsap, flag, cr, ct);
4139         VOPSTATS_UPDATE(vp, setsecattr);
4140         return (err);
4141 }
4142 
4143 int
4144 fop_getsecattr(
4145         vnode_t *vp,
4146         vsecattr_t *vsap,
4147         int flag,
4148         cred_t *cr,
4149         caller_context_t *ct)
4150 {
4151         int     err;
4152 
4153         /*
4154          * We're only allowed to skip the ACL check iff we used a 32 bit
4155          * ACE mask with VOP_ACCESS() to determine permissions.
4156          */
4157         if ((flag & ATTR_NOACLCHECK) &&
4158             vfs_has_feature(vp->v_vfsp, VFSFT_ACEMASKONACCESS) == 0) {
4159                 return (EINVAL);
4160         }
4161 
4162         VOPXID_MAP_CR(vp, cr);
4163 
4164         err = (*(vp)->v_op->vop_getsecattr) (vp, vsap, flag, cr, ct);
4165         VOPSTATS_UPDATE(vp, getsecattr);
4166         return (err);
4167 }
4168 
4169 int
4170 fop_shrlock(
4171         vnode_t *vp,
4172         int cmd,
4173         struct shrlock *shr,
4174         int flag,
4175         cred_t *cr,
4176         caller_context_t *ct)
4177 {
4178         int     err;
4179 
4180         VOPXID_MAP_CR(vp, cr);
4181 
4182         err = (*(vp)->v_op->vop_shrlock)(vp, cmd, shr, flag, cr, ct);
4183         VOPSTATS_UPDATE(vp, shrlock);
4184         return (err);
4185 }
4186 
4187 int
4188 fop_vnevent(vnode_t *vp, vnevent_t vnevent, vnode_t *dvp, char *fnm,
4189     caller_context_t *ct)
4190 {
4191         int     err;
4192 
4193         err = (*(vp)->v_op->vop_vnevent)(vp, vnevent, dvp, fnm, ct);
4194         VOPSTATS_UPDATE(vp, vnevent);
4195         return (err);
4196 }
4197 
4198 int
4199 fop_reqzcbuf(vnode_t *vp, enum uio_rw ioflag, xuio_t *uiop, cred_t *cr,
4200     caller_context_t *ct)
4201 {
4202         int err;
4203 
4204         if (vfs_has_feature(vp->v_vfsp, VFSFT_ZEROCOPY_SUPPORTED) == 0)
4205                 return (ENOTSUP);
4206         err = (*(vp)->v_op->vop_reqzcbuf)(vp, ioflag, uiop, cr, ct);
4207         VOPSTATS_UPDATE(vp, reqzcbuf);
4208         return (err);
4209 }
4210 
4211 int
4212 fop_retzcbuf(vnode_t *vp, xuio_t *uiop, cred_t *cr, caller_context_t *ct)
4213 {
4214         int err;
4215 
4216         if (vfs_has_feature(vp->v_vfsp, VFSFT_ZEROCOPY_SUPPORTED) == 0)
4217                 return (ENOTSUP);
4218         err = (*(vp)->v_op->vop_retzcbuf)(vp, uiop, cr, ct);
4219         VOPSTATS_UPDATE(vp, retzcbuf);
4220         return (err);
4221 }
4222 
4223 /*
4224  * Default destructor
4225  *      Needed because NULL destructor means that the key is unused
4226  */
4227 /* ARGSUSED */
4228 void
4229 vsd_defaultdestructor(void *value)
4230 {}
4231 
4232 /*
4233  * Create a key (index into per vnode array)
4234  *      Locks out vsd_create, vsd_destroy, and vsd_free
4235  *      May allocate memory with lock held
4236  */
4237 void
4238 vsd_create(uint_t *keyp, void (*destructor)(void *))
4239 {
4240         int     i;
4241         uint_t  nkeys;
4242 
4243         /*
4244          * if key is allocated, do nothing
4245          */
4246         mutex_enter(&vsd_lock);
4247         if (*keyp) {
4248                 mutex_exit(&vsd_lock);
4249                 return;
4250         }
4251         /*
4252          * find an unused key
4253          */
4254         if (destructor == NULL)
4255                 destructor = vsd_defaultdestructor;
4256 
4257         for (i = 0; i < vsd_nkeys; ++i)
4258                 if (vsd_destructor[i] == NULL)
4259                         break;
4260 
4261         /*
4262          * if no unused keys, increase the size of the destructor array
4263          */
4264         if (i == vsd_nkeys) {
4265                 if ((nkeys = (vsd_nkeys << 1)) == 0)
4266                         nkeys = 1;
4267                 vsd_destructor =
4268                     (void (**)(void *))vsd_realloc((void *)vsd_destructor,
4269                     (size_t)(vsd_nkeys * sizeof (void (*)(void *))),
4270                     (size_t)(nkeys * sizeof (void (*)(void *))));
4271                 vsd_nkeys = nkeys;
4272         }
4273 
4274         /*
4275          * allocate the next available unused key
4276          */
4277         vsd_destructor[i] = destructor;
4278         *keyp = i + 1;
4279 
4280         /* create vsd_list, if it doesn't exist */
4281         if (vsd_list == NULL) {
4282                 vsd_list = kmem_alloc(sizeof (list_t), KM_SLEEP);
4283                 list_create(vsd_list, sizeof (struct vsd_node),
4284                     offsetof(struct vsd_node, vs_nodes));
4285         }
4286 
4287         mutex_exit(&vsd_lock);
4288 }
4289 
4290 /*
4291  * Destroy a key
4292  *
4293  * Assumes that the caller is preventing vsd_set and vsd_get
4294  * Locks out vsd_create, vsd_destroy, and vsd_free
4295  * May free memory with lock held
4296  */
4297 void
4298 vsd_destroy(uint_t *keyp)
4299 {
4300         uint_t key;
4301         struct vsd_node *vsd;
4302 
4303         /*
4304          * protect the key namespace and our destructor lists
4305          */
4306         mutex_enter(&vsd_lock);
4307         key = *keyp;
4308         *keyp = 0;
4309 
4310         ASSERT(key <= vsd_nkeys);
4311 
4312         /*
4313          * if the key is valid
4314          */
4315         if (key != 0) {
4316                 uint_t k = key - 1;
4317                 /*
4318                  * for every vnode with VSD, call key's destructor
4319                  */
4320                 for (vsd = list_head(vsd_list); vsd != NULL;
4321                     vsd = list_next(vsd_list, vsd)) {
4322                         /*
4323                          * no VSD for key in this vnode
4324                          */
4325                         if (key > vsd->vs_nkeys)
4326                                 continue;
4327                         /*
4328                          * call destructor for key
4329                          */
4330                         if (vsd->vs_value[k] && vsd_destructor[k])
4331                                 (*vsd_destructor[k])(vsd->vs_value[k]);
4332                         /*
4333                          * reset value for key
4334                          */
4335                         vsd->vs_value[k] = NULL;
4336                 }
4337                 /*
4338                  * actually free the key (NULL destructor == unused)
4339                  */
4340                 vsd_destructor[k] = NULL;
4341         }
4342 
4343         mutex_exit(&vsd_lock);
4344 }
4345 
4346 /*
4347  * Quickly return the per vnode value that was stored with the specified key
4348  * Assumes the caller is protecting key from vsd_create and vsd_destroy
4349  * Assumes the caller is holding v_vsd_lock to protect the vsd.
4350  */
4351 void *
4352 vsd_get(vnode_t *vp, uint_t key)
4353 {
4354         struct vsd_node *vsd;
4355 
4356         ASSERT(vp != NULL);
4357         ASSERT(mutex_owned(&vp->v_vsd_lock));
4358 
4359         vsd = vp->v_vsd;
4360 
4361         if (key && vsd != NULL && key <= vsd->vs_nkeys)
4362                 return (vsd->vs_value[key - 1]);
4363         return (NULL);
4364 }
4365 
4366 /*
4367  * Set a per vnode value indexed with the specified key
4368  * Assumes the caller is holding v_vsd_lock to protect the vsd.
4369  */
4370 int
4371 vsd_set(vnode_t *vp, uint_t key, void *value)
4372 {
4373         struct vsd_node *vsd;
4374 
4375         ASSERT(vp != NULL);
4376         ASSERT(mutex_owned(&vp->v_vsd_lock));
4377 
4378         if (key == 0)
4379                 return (EINVAL);
4380 
4381         vsd = vp->v_vsd;
4382         if (vsd == NULL)
4383                 vsd = vp->v_vsd = kmem_zalloc(sizeof (*vsd), KM_SLEEP);
4384 
4385         /*
4386          * If the vsd was just allocated, vs_nkeys will be 0, so the following
4387          * code won't happen and we will continue down and allocate space for
4388          * the vs_value array.
4389          * If the caller is replacing one value with another, then it is up
4390          * to the caller to free/rele/destroy the previous value (if needed).
4391          */
4392         if (key <= vsd->vs_nkeys) {
4393                 vsd->vs_value[key - 1] = value;
4394                 return (0);
4395         }
4396 
4397         ASSERT(key <= vsd_nkeys);
4398 
4399         if (vsd->vs_nkeys == 0) {
4400                 mutex_enter(&vsd_lock);     /* lock out vsd_destroy() */
4401                 /*
4402                  * Link onto list of all VSD nodes.
4403                  */
4404                 list_insert_head(vsd_list, vsd);
4405                 mutex_exit(&vsd_lock);
4406         }
4407 
4408         /*
4409          * Allocate vnode local storage and set the value for key
4410          */
4411         vsd->vs_value = vsd_realloc(vsd->vs_value,
4412             vsd->vs_nkeys * sizeof (void *),
4413             key * sizeof (void *));
4414         vsd->vs_nkeys = key;
4415         vsd->vs_value[key - 1] = value;
4416 
4417         return (0);
4418 }
4419 
4420 /*
4421  * Called from vn_free() to run the destructor function for each vsd
4422  *      Locks out vsd_create and vsd_destroy
4423  *      Assumes that the destructor *DOES NOT* use vsd
4424  */
4425 void
4426 vsd_free(vnode_t *vp)
4427 {
4428         int i;
4429         struct vsd_node *vsd = vp->v_vsd;
4430 
4431         if (vsd == NULL)
4432                 return;
4433 
4434         if (vsd->vs_nkeys == 0) {
4435                 kmem_free(vsd, sizeof (*vsd));
4436                 vp->v_vsd = NULL;
4437                 return;
4438         }
4439 
4440         /*
4441          * lock out vsd_create and vsd_destroy, call
4442          * the destructor, and mark the value as destroyed.
4443          */
4444         mutex_enter(&vsd_lock);
4445 
4446         for (i = 0; i < vsd->vs_nkeys; i++) {
4447                 if (vsd->vs_value[i] && vsd_destructor[i])
4448                         (*vsd_destructor[i])(vsd->vs_value[i]);
4449                 vsd->vs_value[i] = NULL;
4450         }
4451 
4452         /*
4453          * remove from linked list of VSD nodes
4454          */
4455         list_remove(vsd_list, vsd);
4456 
4457         mutex_exit(&vsd_lock);
4458 
4459         /*
4460          * free up the VSD
4461          */
4462         kmem_free(vsd->vs_value, vsd->vs_nkeys * sizeof (void *));
4463         kmem_free(vsd, sizeof (struct vsd_node));
4464         vp->v_vsd = NULL;
4465 }
4466 
4467 /*
4468  * realloc
4469  */
4470 static void *
4471 vsd_realloc(void *old, size_t osize, size_t nsize)
4472 {
4473         void *new;
4474 
4475         new = kmem_zalloc(nsize, KM_SLEEP);
4476         if (old) {
4477                 bcopy(old, new, osize);
4478                 kmem_free(old, osize);
4479         }
4480         return (new);
4481 }
4482 
4483 /*
4484  * Setup the extensible system attribute for creating a reparse point.
4485  * The symlink data 'target' is validated for proper format of a reparse
4486  * string and a check also made to make sure the symlink data does not
4487  * point to an existing file.
4488  *
4489  * return 0 if ok else -1.
4490  */
4491 static int
4492 fs_reparse_mark(char *target, vattr_t *vap, xvattr_t *xvattr)
4493 {
4494         xoptattr_t *xoap;
4495 
4496         if ((!target) || (!vap) || (!xvattr))
4497                 return (-1);
4498 
4499         /* validate reparse string */
4500         if (reparse_validate((const char *)target))
4501                 return (-1);
4502 
4503         xva_init(xvattr);
4504         xvattr->xva_vattr = *vap;
4505         xvattr->xva_vattr.va_mask |= AT_XVATTR;
4506         xoap = xva_getxoptattr(xvattr);
4507         ASSERT(xoap);
4508         XVA_SET_REQ(xvattr, XAT_REPARSE);
4509         xoap->xoa_reparse = 1;
4510 
4511         return (0);
4512 }
4513 
4514 /*
4515  * Function to check whether a symlink is a reparse point.
4516  * Return B_TRUE if it is a reparse point, else return B_FALSE
4517  */
4518 boolean_t
4519 vn_is_reparse(vnode_t *vp, cred_t *cr, caller_context_t *ct)
4520 {
4521         xvattr_t xvattr;
4522         xoptattr_t *xoap;
4523 
4524         if ((vp->v_type != VLNK) ||
4525             !(vfs_has_feature(vp->v_vfsp, VFSFT_XVATTR)))
4526                 return (B_FALSE);
4527 
4528         xva_init(&xvattr);
4529         xoap = xva_getxoptattr(&xvattr);
4530         ASSERT(xoap);
4531         XVA_SET_REQ(&xvattr, XAT_REPARSE);
4532 
4533         if (VOP_GETATTR(vp, &xvattr.xva_vattr, 0, cr, ct))
4534                 return (B_FALSE);
4535 
4536         if ((!(xvattr.xva_vattr.va_mask & AT_XVATTR)) ||
4537             (!(XVA_ISSET_RTN(&xvattr, XAT_REPARSE))))
4538                 return (B_FALSE);
4539 
4540         return (xoap->xoa_reparse ? B_TRUE : B_FALSE);
4541 }