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  * Copyright (c) 2013, Joyent, Inc. All rights reserved.
  25  */
  26 
  27 /*      Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
  28 /*        All Rights Reserved   */
  29 
  30 /*
  31  * University Copyright- Copyright (c) 1982, 1986, 1988
  32  * The Regents of the University of California
  33  * All Rights Reserved
  34  *
  35  * University Acknowledgment- Portions of this document are derived from
  36  * software developed by the University of California, Berkeley, and its
  37  * contributors.
  38  */
  39 
  40 #include <sys/types.h>
  41 #include <sys/param.h>
  42 #include <sys/t_lock.h>
  43 #include <sys/errno.h>
  44 #include <sys/cred.h>
  45 #include <sys/user.h>
  46 #include <sys/uio.h>
  47 #include <sys/file.h>
  48 #include <sys/pathname.h>
  49 #include <sys/vfs.h>
  50 #include <sys/vfs_opreg.h>
  51 #include <sys/vnode.h>
  52 #include <sys/rwstlock.h>
  53 #include <sys/fem.h>
  54 #include <sys/stat.h>
  55 #include <sys/mode.h>
  56 #include <sys/conf.h>
  57 #include <sys/sysmacros.h>
  58 #include <sys/cmn_err.h>
  59 #include <sys/systm.h>
  60 #include <sys/kmem.h>
  61 #include <sys/debug.h>
  62 #include <c2/audit.h>
  63 #include <sys/acl.h>
  64 #include <sys/nbmlock.h>
  65 #include <sys/fcntl.h>
  66 #include <fs/fs_subr.h>
  67 #include <sys/taskq.h>
  68 #include <fs/fs_reparse.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_inc_32(&vp->v_rdcnt);
1248         if (filemode & FWRITE)
1249                 atomic_inc_32(&vp->v_wrcnt);
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_dec_32(&vp->v_rdcnt);
1263         }
1264         if (filemode & FWRITE) {
1265                 ASSERT(vp->v_wrcnt > 0);
1266                 atomic_dec_32(&vp->v_wrcnt);
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_pre_rename_src(vnode_t *vp, vnode_t *dvp, char *name,
2561     caller_context_t *ct)
2562 {
2563         if (vp == NULL || vp->v_femhead == NULL) {
2564                 return;
2565         }
2566         (void) VOP_VNEVENT(vp, VE_PRE_RENAME_SRC, dvp, name, ct);
2567 }
2568 
2569 void
2570 vnevent_pre_rename_dest(vnode_t *vp, vnode_t *dvp, char *name,
2571     caller_context_t *ct)
2572 {
2573         if (vp == NULL || vp->v_femhead == NULL) {
2574                 return;
2575         }
2576         (void) VOP_VNEVENT(vp, VE_PRE_RENAME_DEST, dvp, name, ct);
2577 }
2578 
2579 void
2580 vnevent_pre_rename_dest_dir(vnode_t *vp, vnode_t *nvp, char *name,
2581     caller_context_t *ct)
2582 {
2583         if (vp == NULL || vp->v_femhead == NULL) {
2584                 return;
2585         }
2586         (void) VOP_VNEVENT(vp, VE_PRE_RENAME_DEST_DIR, nvp, name, ct);
2587 }
2588 
2589 void
2590 vnevent_create(vnode_t *vp, caller_context_t *ct)
2591 {
2592         if (vp == NULL || vp->v_femhead == NULL) {
2593                 return;
2594         }
2595         (void) VOP_VNEVENT(vp, VE_CREATE, NULL, NULL, ct);
2596 }
2597 
2598 void
2599 vnevent_link(vnode_t *vp, caller_context_t *ct)
2600 {
2601         if (vp == NULL || vp->v_femhead == NULL) {
2602                 return;
2603         }
2604         (void) VOP_VNEVENT(vp, VE_LINK, NULL, NULL, ct);
2605 }
2606 
2607 void
2608 vnevent_mountedover(vnode_t *vp, caller_context_t *ct)
2609 {
2610         if (vp == NULL || vp->v_femhead == NULL) {
2611                 return;
2612         }
2613         (void) VOP_VNEVENT(vp, VE_MOUNTEDOVER, NULL, NULL, ct);
2614 }
2615 
2616 void
2617 vnevent_truncate(vnode_t *vp, caller_context_t *ct)
2618 {
2619         if (vp == NULL || vp->v_femhead == NULL) {
2620                 return;
2621         }
2622         (void) VOP_VNEVENT(vp, VE_TRUNCATE, NULL, NULL, ct);
2623 }
2624 
2625 /*
2626  * Vnode accessors.
2627  */
2628 
2629 int
2630 vn_is_readonly(vnode_t *vp)
2631 {
2632         return (vp->v_vfsp->vfs_flag & VFS_RDONLY);
2633 }
2634 
2635 int
2636 vn_has_flocks(vnode_t *vp)
2637 {
2638         return (vp->v_filocks != NULL);
2639 }
2640 
2641 int
2642 vn_has_mandatory_locks(vnode_t *vp, int mode)
2643 {
2644         return ((vp->v_filocks != NULL) && (MANDLOCK(vp, mode)));
2645 }
2646 
2647 int
2648 vn_has_cached_data(vnode_t *vp)
2649 {
2650         return (vp->v_pages != NULL);
2651 }
2652 
2653 /*
2654  * Return 0 if the vnode in question shouldn't be permitted into a zone via
2655  * zone_enter(2).
2656  */
2657 int
2658 vn_can_change_zones(vnode_t *vp)
2659 {
2660         struct vfssw *vswp;
2661         int allow = 1;
2662         vnode_t *rvp;
2663 
2664         if (nfs_global_client_only != 0)
2665                 return (1);
2666 
2667         /*
2668          * We always want to look at the underlying vnode if there is one.
2669          */
2670         if (VOP_REALVP(vp, &rvp, NULL) != 0)
2671                 rvp = vp;
2672         /*
2673          * Some pseudo filesystems (including doorfs) don't actually register
2674          * their vfsops_t, so the following may return NULL; we happily let
2675          * such vnodes switch zones.
2676          */
2677         vswp = vfs_getvfsswbyvfsops(vfs_getops(rvp->v_vfsp));
2678         if (vswp != NULL) {
2679                 if (vswp->vsw_flag & VSW_NOTZONESAFE)
2680                         allow = 0;
2681                 vfs_unrefvfssw(vswp);
2682         }
2683         return (allow);
2684 }
2685 
2686 /*
2687  * Return nonzero if the vnode is a mount point, zero if not.
2688  */
2689 int
2690 vn_ismntpt(vnode_t *vp)
2691 {
2692         return (vp->v_vfsmountedhere != NULL);
2693 }
2694 
2695 /* Retrieve the vfs (if any) mounted on this vnode */
2696 vfs_t *
2697 vn_mountedvfs(vnode_t *vp)
2698 {
2699         return (vp->v_vfsmountedhere);
2700 }
2701 
2702 /*
2703  * Return nonzero if the vnode is referenced by the dnlc, zero if not.
2704  */
2705 int
2706 vn_in_dnlc(vnode_t *vp)
2707 {
2708         return (vp->v_count_dnlc > 0);
2709 }
2710 
2711 /*
2712  * vn_has_other_opens() checks whether a particular file is opened by more than
2713  * just the caller and whether the open is for read and/or write.
2714  * This routine is for calling after the caller has already called VOP_OPEN()
2715  * and the caller wishes to know if they are the only one with it open for
2716  * the mode(s) specified.
2717  *
2718  * Vnode counts are only kept on regular files (v_type=VREG).
2719  */
2720 int
2721 vn_has_other_opens(
2722         vnode_t *vp,
2723         v_mode_t mode)
2724 {
2725 
2726         ASSERT(vp != NULL);
2727 
2728         switch (mode) {
2729         case V_WRITE:
2730                 if (vp->v_wrcnt > 1)
2731                         return (V_TRUE);
2732                 break;
2733         case V_RDORWR:
2734                 if ((vp->v_rdcnt > 1) || (vp->v_wrcnt > 1))
2735                         return (V_TRUE);
2736                 break;
2737         case V_RDANDWR:
2738                 if ((vp->v_rdcnt > 1) && (vp->v_wrcnt > 1))
2739                         return (V_TRUE);
2740                 break;
2741         case V_READ:
2742                 if (vp->v_rdcnt > 1)
2743                         return (V_TRUE);
2744                 break;
2745         }
2746 
2747         return (V_FALSE);
2748 }
2749 
2750 /*
2751  * vn_is_opened() checks whether a particular file is opened and
2752  * whether the open is for read and/or write.
2753  *
2754  * Vnode counts are only kept on regular files (v_type=VREG).
2755  */
2756 int
2757 vn_is_opened(
2758         vnode_t *vp,
2759         v_mode_t mode)
2760 {
2761 
2762         ASSERT(vp != NULL);
2763 
2764         switch (mode) {
2765         case V_WRITE:
2766                 if (vp->v_wrcnt)
2767                         return (V_TRUE);
2768                 break;
2769         case V_RDANDWR:
2770                 if (vp->v_rdcnt && vp->v_wrcnt)
2771                         return (V_TRUE);
2772                 break;
2773         case V_RDORWR:
2774                 if (vp->v_rdcnt || vp->v_wrcnt)
2775                         return (V_TRUE);
2776                 break;
2777         case V_READ:
2778                 if (vp->v_rdcnt)
2779                         return (V_TRUE);
2780                 break;
2781         }
2782 
2783         return (V_FALSE);
2784 }
2785 
2786 /*
2787  * vn_is_mapped() checks whether a particular file is mapped and whether
2788  * the file is mapped read and/or write.
2789  */
2790 int
2791 vn_is_mapped(
2792         vnode_t *vp,
2793         v_mode_t mode)
2794 {
2795 
2796         ASSERT(vp != NULL);
2797 
2798 #if !defined(_LP64)
2799         switch (mode) {
2800         /*
2801          * The atomic_add_64_nv functions force atomicity in the
2802          * case of 32 bit architectures. Otherwise the 64 bit values
2803          * require two fetches. The value of the fields may be
2804          * (potentially) changed between the first fetch and the
2805          * second
2806          */
2807         case V_WRITE:
2808                 if (atomic_add_64_nv((&(vp->v_mmap_write)), 0))
2809                         return (V_TRUE);
2810                 break;
2811         case V_RDANDWR:
2812                 if ((atomic_add_64_nv((&(vp->v_mmap_read)), 0)) &&
2813                     (atomic_add_64_nv((&(vp->v_mmap_write)), 0)))
2814                         return (V_TRUE);
2815                 break;
2816         case V_RDORWR:
2817                 if ((atomic_add_64_nv((&(vp->v_mmap_read)), 0)) ||
2818                     (atomic_add_64_nv((&(vp->v_mmap_write)), 0)))
2819                         return (V_TRUE);
2820                 break;
2821         case V_READ:
2822                 if (atomic_add_64_nv((&(vp->v_mmap_read)), 0))
2823                         return (V_TRUE);
2824                 break;
2825         }
2826 #else
2827         switch (mode) {
2828         case V_WRITE:
2829                 if (vp->v_mmap_write)
2830                         return (V_TRUE);
2831                 break;
2832         case V_RDANDWR:
2833                 if (vp->v_mmap_read && vp->v_mmap_write)
2834                         return (V_TRUE);
2835                 break;
2836         case V_RDORWR:
2837                 if (vp->v_mmap_read || vp->v_mmap_write)
2838                         return (V_TRUE);
2839                 break;
2840         case V_READ:
2841                 if (vp->v_mmap_read)
2842                         return (V_TRUE);
2843                 break;
2844         }
2845 #endif
2846 
2847         return (V_FALSE);
2848 }
2849 
2850 /*
2851  * Set the operations vector for a vnode.
2852  *
2853  * FEM ensures that the v_femhead pointer is filled in before the
2854  * v_op pointer is changed.  This means that if the v_femhead pointer
2855  * is NULL, and the v_op field hasn't changed since before which checked
2856  * the v_femhead pointer; then our update is ok - we are not racing with
2857  * FEM.
2858  */
2859 void
2860 vn_setops(vnode_t *vp, vnodeops_t *vnodeops)
2861 {
2862         vnodeops_t      *op;
2863 
2864         ASSERT(vp != NULL);
2865         ASSERT(vnodeops != NULL);
2866 
2867         op = vp->v_op;
2868         membar_consumer();
2869         /*
2870          * If vp->v_femhead == NULL, then we'll call atomic_cas_ptr() to do
2871          * the compare-and-swap on vp->v_op.  If either fails, then FEM is
2872          * in effect on the vnode and we need to have FEM deal with it.
2873          */
2874         if (vp->v_femhead != NULL || atomic_cas_ptr(&vp->v_op, op, vnodeops) !=
2875             op) {
2876                 fem_setvnops(vp, vnodeops);
2877         }
2878 }
2879 
2880 /*
2881  * Retrieve the operations vector for a vnode
2882  * As with vn_setops(above); make sure we aren't racing with FEM.
2883  * FEM sets the v_op to a special, internal, vnodeops that wouldn't
2884  * make sense to the callers of this routine.
2885  */
2886 vnodeops_t *
2887 vn_getops(vnode_t *vp)
2888 {
2889         vnodeops_t      *op;
2890 
2891         ASSERT(vp != NULL);
2892 
2893         op = vp->v_op;
2894         membar_consumer();
2895         if (vp->v_femhead == NULL && op == vp->v_op) {
2896                 return (op);
2897         } else {
2898                 return (fem_getvnops(vp));
2899         }
2900 }
2901 
2902 /*
2903  * Returns non-zero (1) if the vnodeops matches that of the vnode.
2904  * Returns zero (0) if not.
2905  */
2906 int
2907 vn_matchops(vnode_t *vp, vnodeops_t *vnodeops)
2908 {
2909         return (vn_getops(vp) == vnodeops);
2910 }
2911 
2912 /*
2913  * Returns non-zero (1) if the specified operation matches the
2914  * corresponding operation for that the vnode.
2915  * Returns zero (0) if not.
2916  */
2917 
2918 #define MATCHNAME(n1, n2) (((n1)[0] == (n2)[0]) && (strcmp((n1), (n2)) == 0))
2919 
2920 int
2921 vn_matchopval(vnode_t *vp, char *vopname, fs_generic_func_p funcp)
2922 {
2923         const fs_operation_trans_def_t *otdp;
2924         fs_generic_func_p *loc = NULL;
2925         vnodeops_t      *vop = vn_getops(vp);
2926 
2927         ASSERT(vopname != NULL);
2928 
2929         for (otdp = vn_ops_table; otdp->name != NULL; otdp++) {
2930                 if (MATCHNAME(otdp->name, vopname)) {
2931                         loc = (fs_generic_func_p *)
2932                             ((char *)(vop) + otdp->offset);
2933                         break;
2934                 }
2935         }
2936 
2937         return ((loc != NULL) && (*loc == funcp));
2938 }
2939 
2940 /*
2941  * fs_new_caller_id() needs to return a unique ID on a given local system.
2942  * The IDs do not need to survive across reboots.  These are primarily
2943  * used so that (FEM) monitors can detect particular callers (such as
2944  * the NFS server) to a given vnode/vfs operation.
2945  */
2946 u_longlong_t
2947 fs_new_caller_id()
2948 {
2949         static uint64_t next_caller_id = 0LL; /* First call returns 1 */
2950 
2951         return ((u_longlong_t)atomic_inc_64_nv(&next_caller_id));
2952 }
2953 
2954 /*
2955  * Given a starting vnode and a path, updates the path in the target vnode in
2956  * a safe manner.  If the vnode already has path information embedded, then the
2957  * cached path is left untouched.
2958  */
2959 
2960 size_t max_vnode_path = 4 * MAXPATHLEN;
2961 
2962 void
2963 vn_setpath(vnode_t *rootvp, struct vnode *startvp, struct vnode *vp,
2964     const char *path, size_t plen)
2965 {
2966         char    *rpath;
2967         vnode_t *base;
2968         size_t  rpathlen, rpathalloc;
2969         int     doslash = 1;
2970 
2971         if (*path == '/') {
2972                 base = rootvp;
2973                 path++;
2974                 plen--;
2975         } else {
2976                 base = startvp;
2977         }
2978 
2979         /*
2980          * We cannot grab base->v_lock while we hold vp->v_lock because of
2981          * the potential for deadlock.
2982          */
2983         mutex_enter(&base->v_lock);
2984         if (base->v_path == NULL) {
2985                 mutex_exit(&base->v_lock);
2986                 return;
2987         }
2988 
2989         rpathlen = strlen(base->v_path);
2990         rpathalloc = rpathlen + plen + 1;
2991         /* Avoid adding a slash if there's already one there */
2992         if (base->v_path[rpathlen-1] == '/')
2993                 doslash = 0;
2994         else
2995                 rpathalloc++;
2996 
2997         /*
2998          * We don't want to call kmem_alloc(KM_SLEEP) with kernel locks held,
2999          * so we must do this dance.  If, by chance, something changes the path,
3000          * just give up since there is no real harm.
3001          */
3002         mutex_exit(&base->v_lock);
3003 
3004         /* Paths should stay within reason */
3005         if (rpathalloc > max_vnode_path)
3006                 return;
3007 
3008         rpath = kmem_alloc(rpathalloc, KM_SLEEP);
3009 
3010         mutex_enter(&base->v_lock);
3011         if (base->v_path == NULL || strlen(base->v_path) != rpathlen) {
3012                 mutex_exit(&base->v_lock);
3013                 kmem_free(rpath, rpathalloc);
3014                 return;
3015         }
3016         bcopy(base->v_path, rpath, rpathlen);
3017         mutex_exit(&base->v_lock);
3018 
3019         if (doslash)
3020                 rpath[rpathlen++] = '/';
3021         bcopy(path, rpath + rpathlen, plen);
3022         rpath[rpathlen + plen] = '\0';
3023 
3024         mutex_enter(&vp->v_lock);
3025         if (vp->v_path != NULL) {
3026                 mutex_exit(&vp->v_lock);
3027                 kmem_free(rpath, rpathalloc);
3028         } else {
3029                 vp->v_path = rpath;
3030                 mutex_exit(&vp->v_lock);
3031         }
3032 }
3033 
3034 /*
3035  * Sets the path to the vnode to be the given string, regardless of current
3036  * context.  The string must be a complete path from rootdir.  This is only used
3037  * by fsop_root() for setting the path based on the mountpoint.
3038  */
3039 void
3040 vn_setpath_str(struct vnode *vp, const char *str, size_t len)
3041 {
3042         char *buf = kmem_alloc(len + 1, KM_SLEEP);
3043 
3044         mutex_enter(&vp->v_lock);
3045         if (vp->v_path != NULL) {
3046                 mutex_exit(&vp->v_lock);
3047                 kmem_free(buf, len + 1);
3048                 return;
3049         }
3050 
3051         vp->v_path = buf;
3052         bcopy(str, vp->v_path, len);
3053         vp->v_path[len] = '\0';
3054 
3055         mutex_exit(&vp->v_lock);
3056 }
3057 
3058 /*
3059  * Called from within filesystem's vop_rename() to handle renames once the
3060  * target vnode is available.
3061  */
3062 void
3063 vn_renamepath(vnode_t *dvp, vnode_t *vp, const char *nm, size_t len)
3064 {
3065         char *tmp;
3066 
3067         mutex_enter(&vp->v_lock);
3068         tmp = vp->v_path;
3069         vp->v_path = NULL;
3070         mutex_exit(&vp->v_lock);
3071         vn_setpath(rootdir, dvp, vp, nm, len);
3072         if (tmp != NULL)
3073                 kmem_free(tmp, strlen(tmp) + 1);
3074 }
3075 
3076 /*
3077  * Similar to vn_setpath_str(), this function sets the path of the destination
3078  * vnode to the be the same as the source vnode.
3079  */
3080 void
3081 vn_copypath(struct vnode *src, struct vnode *dst)
3082 {
3083         char *buf;
3084         int alloc;
3085 
3086         mutex_enter(&src->v_lock);
3087         if (src->v_path == NULL) {
3088                 mutex_exit(&src->v_lock);
3089                 return;
3090         }
3091         alloc = strlen(src->v_path) + 1;
3092 
3093         /* avoid kmem_alloc() with lock held */
3094         mutex_exit(&src->v_lock);
3095         buf = kmem_alloc(alloc, KM_SLEEP);
3096         mutex_enter(&src->v_lock);
3097         if (src->v_path == NULL || strlen(src->v_path) + 1 != alloc) {
3098                 mutex_exit(&src->v_lock);
3099                 kmem_free(buf, alloc);
3100                 return;
3101         }
3102         bcopy(src->v_path, buf, alloc);
3103         mutex_exit(&src->v_lock);
3104 
3105         mutex_enter(&dst->v_lock);
3106         if (dst->v_path != NULL) {
3107                 mutex_exit(&dst->v_lock);
3108                 kmem_free(buf, alloc);
3109                 return;
3110         }
3111         dst->v_path = buf;
3112         mutex_exit(&dst->v_lock);
3113 }
3114 
3115 /*
3116  * XXX Private interface for segvn routines that handle vnode
3117  * large page segments.
3118  *
3119  * return 1 if vp's file system VOP_PAGEIO() implementation
3120  * can be safely used instead of VOP_GETPAGE() for handling
3121  * pagefaults against regular non swap files. VOP_PAGEIO()
3122  * interface is considered safe here if its implementation
3123  * is very close to VOP_GETPAGE() implementation.
3124  * e.g. It zero's out the part of the page beyond EOF. Doesn't
3125  * panic if there're file holes but instead returns an error.
3126  * Doesn't assume file won't be changed by user writes, etc.
3127  *
3128  * return 0 otherwise.
3129  *
3130  * For now allow segvn to only use VOP_PAGEIO() with ufs and nfs.
3131  */
3132 int
3133 vn_vmpss_usepageio(vnode_t *vp)
3134 {
3135         vfs_t   *vfsp = vp->v_vfsp;
3136         char *fsname = vfssw[vfsp->vfs_fstype].vsw_name;
3137         char *pageio_ok_fss[] = {"ufs", "nfs", NULL};
3138         char **fsok = pageio_ok_fss;
3139 
3140         if (fsname == NULL) {
3141                 return (0);
3142         }
3143 
3144         for (; *fsok; fsok++) {
3145                 if (strcmp(*fsok, fsname) == 0) {
3146                         return (1);
3147                 }
3148         }
3149         return (0);
3150 }
3151 
3152 /* VOP_XXX() macros call the corresponding fop_xxx() function */
3153 
3154 int
3155 fop_open(
3156         vnode_t **vpp,
3157         int mode,
3158         cred_t *cr,
3159         caller_context_t *ct)
3160 {
3161         int ret;
3162         vnode_t *vp = *vpp;
3163 
3164         VN_HOLD(vp);
3165         /*
3166          * Adding to the vnode counts before calling open
3167          * avoids the need for a mutex. It circumvents a race
3168          * condition where a query made on the vnode counts results in a
3169          * false negative. The inquirer goes away believing the file is
3170          * not open when there is an open on the file already under way.
3171          *
3172          * The counts are meant to prevent NFS from granting a delegation
3173          * when it would be dangerous to do so.
3174          *
3175          * The vnode counts are only kept on regular files
3176          */
3177         if ((*vpp)->v_type == VREG) {
3178                 if (mode & FREAD)
3179                         atomic_inc_32(&(*vpp)->v_rdcnt);
3180                 if (mode & FWRITE)
3181                         atomic_inc_32(&(*vpp)->v_wrcnt);
3182         }
3183 
3184         VOPXID_MAP_CR(vp, cr);
3185 
3186         ret = (*(*(vpp))->v_op->vop_open)(vpp, mode, cr, ct);
3187 
3188         if (ret) {
3189                 /*
3190                  * Use the saved vp just in case the vnode ptr got trashed
3191                  * by the error.
3192                  */
3193                 VOPSTATS_UPDATE(vp, open);
3194                 if ((vp->v_type == VREG) && (mode & FREAD))
3195                         atomic_dec_32(&vp->v_rdcnt);
3196                 if ((vp->v_type == VREG) && (mode & FWRITE))
3197                         atomic_dec_32(&vp->v_wrcnt);
3198         } else {
3199                 /*
3200                  * Some filesystems will return a different vnode,
3201                  * but the same path was still used to open it.
3202                  * So if we do change the vnode and need to
3203                  * copy over the path, do so here, rather than special
3204                  * casing each filesystem. Adjust the vnode counts to
3205                  * reflect the vnode switch.
3206                  */
3207                 VOPSTATS_UPDATE(*vpp, open);
3208                 if (*vpp != vp && *vpp != NULL) {
3209                         vn_copypath(vp, *vpp);
3210                         if (((*vpp)->v_type == VREG) && (mode & FREAD))
3211                                 atomic_inc_32(&(*vpp)->v_rdcnt);
3212                         if ((vp->v_type == VREG) && (mode & FREAD))
3213                                 atomic_dec_32(&vp->v_rdcnt);
3214                         if (((*vpp)->v_type == VREG) && (mode & FWRITE))
3215                                 atomic_inc_32(&(*vpp)->v_wrcnt);
3216                         if ((vp->v_type == VREG) && (mode & FWRITE))
3217                                 atomic_dec_32(&vp->v_wrcnt);
3218                 }
3219         }
3220         VN_RELE(vp);
3221         return (ret);
3222 }
3223 
3224 int
3225 fop_close(
3226         vnode_t *vp,
3227         int flag,
3228         int count,
3229         offset_t offset,
3230         cred_t *cr,
3231         caller_context_t *ct)
3232 {
3233         int err;
3234 
3235         VOPXID_MAP_CR(vp, cr);
3236 
3237         err = (*(vp)->v_op->vop_close)(vp, flag, count, offset, cr, ct);
3238         VOPSTATS_UPDATE(vp, close);
3239         /*
3240          * Check passed in count to handle possible dups. Vnode counts are only
3241          * kept on regular files
3242          */
3243         if ((vp->v_type == VREG) && (count == 1))  {
3244                 if (flag & FREAD) {
3245                         ASSERT(vp->v_rdcnt > 0);
3246                         atomic_dec_32(&vp->v_rdcnt);
3247                 }
3248                 if (flag & FWRITE) {
3249                         ASSERT(vp->v_wrcnt > 0);
3250                         atomic_dec_32(&vp->v_wrcnt);
3251                 }
3252         }
3253         return (err);
3254 }
3255 
3256 int
3257 fop_read(
3258         vnode_t *vp,
3259         uio_t *uiop,
3260         int ioflag,
3261         cred_t *cr,
3262         caller_context_t *ct)
3263 {
3264         int     err;
3265         ssize_t resid_start = uiop->uio_resid;
3266 
3267         VOPXID_MAP_CR(vp, cr);
3268 
3269         err = (*(vp)->v_op->vop_read)(vp, uiop, ioflag, cr, ct);
3270         VOPSTATS_UPDATE_IO(vp, read,
3271             read_bytes, (resid_start - uiop->uio_resid));
3272         return (err);
3273 }
3274 
3275 int
3276 fop_write(
3277         vnode_t *vp,
3278         uio_t *uiop,
3279         int ioflag,
3280         cred_t *cr,
3281         caller_context_t *ct)
3282 {
3283         int     err;
3284         ssize_t resid_start = uiop->uio_resid;
3285 
3286         VOPXID_MAP_CR(vp, cr);
3287 
3288         err = (*(vp)->v_op->vop_write)(vp, uiop, ioflag, cr, ct);
3289         VOPSTATS_UPDATE_IO(vp, write,
3290             write_bytes, (resid_start - uiop->uio_resid));
3291         return (err);
3292 }
3293 
3294 int
3295 fop_ioctl(
3296         vnode_t *vp,
3297         int cmd,
3298         intptr_t arg,
3299         int flag,
3300         cred_t *cr,
3301         int *rvalp,
3302         caller_context_t *ct)
3303 {
3304         int     err;
3305 
3306         VOPXID_MAP_CR(vp, cr);
3307 
3308         err = (*(vp)->v_op->vop_ioctl)(vp, cmd, arg, flag, cr, rvalp, ct);
3309         VOPSTATS_UPDATE(vp, ioctl);
3310         return (err);
3311 }
3312 
3313 int
3314 fop_setfl(
3315         vnode_t *vp,
3316         int oflags,
3317         int nflags,
3318         cred_t *cr,
3319         caller_context_t *ct)
3320 {
3321         int     err;
3322 
3323         VOPXID_MAP_CR(vp, cr);
3324 
3325         err = (*(vp)->v_op->vop_setfl)(vp, oflags, nflags, cr, ct);
3326         VOPSTATS_UPDATE(vp, setfl);
3327         return (err);
3328 }
3329 
3330 int
3331 fop_getattr(
3332         vnode_t *vp,
3333         vattr_t *vap,
3334         int flags,
3335         cred_t *cr,
3336         caller_context_t *ct)
3337 {
3338         int     err;
3339 
3340         VOPXID_MAP_CR(vp, cr);
3341 
3342         /*
3343          * If this file system doesn't understand the xvattr extensions
3344          * then turn off the xvattr bit.
3345          */
3346         if (vfs_has_feature(vp->v_vfsp, VFSFT_XVATTR) == 0) {
3347                 vap->va_mask &= ~AT_XVATTR;
3348         }
3349 
3350         /*
3351          * We're only allowed to skip the ACL check iff we used a 32 bit
3352          * ACE mask with VOP_ACCESS() to determine permissions.
3353          */
3354         if ((flags & ATTR_NOACLCHECK) &&
3355             vfs_has_feature(vp->v_vfsp, VFSFT_ACEMASKONACCESS) == 0) {
3356                 return (EINVAL);
3357         }
3358         err = (*(vp)->v_op->vop_getattr)(vp, vap, flags, cr, ct);
3359         VOPSTATS_UPDATE(vp, getattr);
3360         return (err);
3361 }
3362 
3363 int
3364 fop_setattr(
3365         vnode_t *vp,
3366         vattr_t *vap,
3367         int flags,
3368         cred_t *cr,
3369         caller_context_t *ct)
3370 {
3371         int     err;
3372 
3373         VOPXID_MAP_CR(vp, cr);
3374 
3375         /*
3376          * If this file system doesn't understand the xvattr extensions
3377          * then turn off the xvattr bit.
3378          */
3379         if (vfs_has_feature(vp->v_vfsp, VFSFT_XVATTR) == 0) {
3380                 vap->va_mask &= ~AT_XVATTR;
3381         }
3382 
3383         /*
3384          * We're only allowed to skip the ACL check iff we used a 32 bit
3385          * ACE mask with VOP_ACCESS() to determine permissions.
3386          */
3387         if ((flags & ATTR_NOACLCHECK) &&
3388             vfs_has_feature(vp->v_vfsp, VFSFT_ACEMASKONACCESS) == 0) {
3389                 return (EINVAL);
3390         }
3391         err = (*(vp)->v_op->vop_setattr)(vp, vap, flags, cr, ct);
3392         VOPSTATS_UPDATE(vp, setattr);
3393         return (err);
3394 }
3395 
3396 int
3397 fop_access(
3398         vnode_t *vp,
3399         int mode,
3400         int flags,
3401         cred_t *cr,
3402         caller_context_t *ct)
3403 {
3404         int     err;
3405 
3406         if ((flags & V_ACE_MASK) &&
3407             vfs_has_feature(vp->v_vfsp, VFSFT_ACEMASKONACCESS) == 0) {
3408                 return (EINVAL);
3409         }
3410 
3411         VOPXID_MAP_CR(vp, cr);
3412 
3413         err = (*(vp)->v_op->vop_access)(vp, mode, flags, cr, ct);
3414         VOPSTATS_UPDATE(vp, access);
3415         return (err);
3416 }
3417 
3418 int
3419 fop_lookup(
3420         vnode_t *dvp,
3421         char *nm,
3422         vnode_t **vpp,
3423         pathname_t *pnp,
3424         int flags,
3425         vnode_t *rdir,
3426         cred_t *cr,
3427         caller_context_t *ct,
3428         int *deflags,           /* Returned per-dirent flags */
3429         pathname_t *ppnp)       /* Returned case-preserved name in directory */
3430 {
3431         int ret;
3432 
3433         /*
3434          * If this file system doesn't support case-insensitive access
3435          * and said access is requested, fail quickly.  It is required
3436          * that if the vfs supports case-insensitive lookup, it also
3437          * supports extended dirent flags.
3438          */
3439         if (flags & FIGNORECASE &&
3440             (vfs_has_feature(dvp->v_vfsp, VFSFT_CASEINSENSITIVE) == 0 &&
3441             vfs_has_feature(dvp->v_vfsp, VFSFT_NOCASESENSITIVE) == 0))
3442                 return (EINVAL);
3443 
3444         VOPXID_MAP_CR(dvp, cr);
3445 
3446         if ((flags & LOOKUP_XATTR) && (flags & LOOKUP_HAVE_SYSATTR_DIR) == 0) {
3447                 ret = xattr_dir_lookup(dvp, vpp, flags, cr);
3448         } else {
3449                 ret = (*(dvp)->v_op->vop_lookup)
3450                     (dvp, nm, vpp, pnp, flags, rdir, cr, ct, deflags, ppnp);
3451         }
3452         if (ret == 0 && *vpp) {
3453                 VOPSTATS_UPDATE(*vpp, lookup);
3454                 if ((*vpp)->v_path == NULL) {
3455                         vn_setpath(rootdir, dvp, *vpp, nm, strlen(nm));
3456                 }
3457         }
3458 
3459         return (ret);
3460 }
3461 
3462 int
3463 fop_create(
3464         vnode_t *dvp,
3465         char *name,
3466         vattr_t *vap,
3467         vcexcl_t excl,
3468         int mode,
3469         vnode_t **vpp,
3470         cred_t *cr,
3471         int flags,
3472         caller_context_t *ct,
3473         vsecattr_t *vsecp)      /* ACL to set during create */
3474 {
3475         int ret;
3476 
3477         if (vsecp != NULL &&
3478             vfs_has_feature(dvp->v_vfsp, VFSFT_ACLONCREATE) == 0) {
3479                 return (EINVAL);
3480         }
3481         /*
3482          * If this file system doesn't support case-insensitive access
3483          * and said access is requested, fail quickly.
3484          */
3485         if (flags & FIGNORECASE &&
3486             (vfs_has_feature(dvp->v_vfsp, VFSFT_CASEINSENSITIVE) == 0 &&
3487             vfs_has_feature(dvp->v_vfsp, VFSFT_NOCASESENSITIVE) == 0))
3488                 return (EINVAL);
3489 
3490         VOPXID_MAP_CR(dvp, cr);
3491 
3492         ret = (*(dvp)->v_op->vop_create)
3493             (dvp, name, vap, excl, mode, vpp, cr, flags, ct, vsecp);
3494         if (ret == 0 && *vpp) {
3495                 VOPSTATS_UPDATE(*vpp, create);
3496                 if ((*vpp)->v_path == NULL) {
3497                         vn_setpath(rootdir, dvp, *vpp, name, strlen(name));
3498                 }
3499         }
3500 
3501         return (ret);
3502 }
3503 
3504 int
3505 fop_remove(
3506         vnode_t *dvp,
3507         char *nm,
3508         cred_t *cr,
3509         caller_context_t *ct,
3510         int flags)
3511 {
3512         int     err;
3513 
3514         /*
3515          * If this file system doesn't support case-insensitive access
3516          * and said access is requested, fail quickly.
3517          */
3518         if (flags & FIGNORECASE &&
3519             (vfs_has_feature(dvp->v_vfsp, VFSFT_CASEINSENSITIVE) == 0 &&
3520             vfs_has_feature(dvp->v_vfsp, VFSFT_NOCASESENSITIVE) == 0))
3521                 return (EINVAL);
3522 
3523         VOPXID_MAP_CR(dvp, cr);
3524 
3525         err = (*(dvp)->v_op->vop_remove)(dvp, nm, cr, ct, flags);
3526         VOPSTATS_UPDATE(dvp, remove);
3527         return (err);
3528 }
3529 
3530 int
3531 fop_link(
3532         vnode_t *tdvp,
3533         vnode_t *svp,
3534         char *tnm,
3535         cred_t *cr,
3536         caller_context_t *ct,
3537         int flags)
3538 {
3539         int     err;
3540 
3541         /*
3542          * If the target file system doesn't support case-insensitive access
3543          * and said access is requested, fail quickly.
3544          */
3545         if (flags & FIGNORECASE &&
3546             (vfs_has_feature(tdvp->v_vfsp, VFSFT_CASEINSENSITIVE) == 0 &&
3547             vfs_has_feature(tdvp->v_vfsp, VFSFT_NOCASESENSITIVE) == 0))
3548                 return (EINVAL);
3549 
3550         VOPXID_MAP_CR(tdvp, cr);
3551 
3552         err = (*(tdvp)->v_op->vop_link)(tdvp, svp, tnm, cr, ct, flags);
3553         VOPSTATS_UPDATE(tdvp, link);
3554         return (err);
3555 }
3556 
3557 int
3558 fop_rename(
3559         vnode_t *sdvp,
3560         char *snm,
3561         vnode_t *tdvp,
3562         char *tnm,
3563         cred_t *cr,
3564         caller_context_t *ct,
3565         int flags)
3566 {
3567         int     err;
3568 
3569         /*
3570          * If the file system involved does not support
3571          * case-insensitive access and said access is requested, fail
3572          * quickly.
3573          */
3574         if (flags & FIGNORECASE &&
3575             ((vfs_has_feature(sdvp->v_vfsp, VFSFT_CASEINSENSITIVE) == 0 &&
3576             vfs_has_feature(sdvp->v_vfsp, VFSFT_NOCASESENSITIVE) == 0)))
3577                 return (EINVAL);
3578 
3579         VOPXID_MAP_CR(tdvp, cr);
3580 
3581         err = (*(sdvp)->v_op->vop_rename)(sdvp, snm, tdvp, tnm, cr, ct, flags);
3582         VOPSTATS_UPDATE(sdvp, rename);
3583         return (err);
3584 }
3585 
3586 int
3587 fop_mkdir(
3588         vnode_t *dvp,
3589         char *dirname,
3590         vattr_t *vap,
3591         vnode_t **vpp,
3592         cred_t *cr,
3593         caller_context_t *ct,
3594         int flags,
3595         vsecattr_t *vsecp)      /* ACL to set during create */
3596 {
3597         int ret;
3598 
3599         if (vsecp != NULL &&
3600             vfs_has_feature(dvp->v_vfsp, VFSFT_ACLONCREATE) == 0) {
3601                 return (EINVAL);
3602         }
3603         /*
3604          * If this file system doesn't support case-insensitive access
3605          * and said access is requested, fail quickly.
3606          */
3607         if (flags & FIGNORECASE &&
3608             (vfs_has_feature(dvp->v_vfsp, VFSFT_CASEINSENSITIVE) == 0 &&
3609             vfs_has_feature(dvp->v_vfsp, VFSFT_NOCASESENSITIVE) == 0))
3610                 return (EINVAL);
3611 
3612         VOPXID_MAP_CR(dvp, cr);
3613 
3614         ret = (*(dvp)->v_op->vop_mkdir)
3615             (dvp, dirname, vap, vpp, cr, ct, flags, vsecp);
3616         if (ret == 0 && *vpp) {
3617                 VOPSTATS_UPDATE(*vpp, mkdir);
3618                 if ((*vpp)->v_path == NULL) {
3619                         vn_setpath(rootdir, dvp, *vpp, dirname,
3620                             strlen(dirname));
3621                 }
3622         }
3623 
3624         return (ret);
3625 }
3626 
3627 int
3628 fop_rmdir(
3629         vnode_t *dvp,
3630         char *nm,
3631         vnode_t *cdir,
3632         cred_t *cr,
3633         caller_context_t *ct,
3634         int flags)
3635 {
3636         int     err;
3637 
3638         /*
3639          * If this file system doesn't support case-insensitive access
3640          * and said access is requested, fail quickly.
3641          */
3642         if (flags & FIGNORECASE &&
3643             (vfs_has_feature(dvp->v_vfsp, VFSFT_CASEINSENSITIVE) == 0 &&
3644             vfs_has_feature(dvp->v_vfsp, VFSFT_NOCASESENSITIVE) == 0))
3645                 return (EINVAL);
3646 
3647         VOPXID_MAP_CR(dvp, cr);
3648 
3649         err = (*(dvp)->v_op->vop_rmdir)(dvp, nm, cdir, cr, ct, flags);
3650         VOPSTATS_UPDATE(dvp, rmdir);
3651         return (err);
3652 }
3653 
3654 int
3655 fop_readdir(
3656         vnode_t *vp,
3657         uio_t *uiop,
3658         cred_t *cr,
3659         int *eofp,
3660         caller_context_t *ct,
3661         int flags)
3662 {
3663         int     err;
3664         ssize_t resid_start = uiop->uio_resid;
3665 
3666         /*
3667          * If this file system doesn't support retrieving directory
3668          * entry flags and said access is requested, fail quickly.
3669          */
3670         if (flags & V_RDDIR_ENTFLAGS &&
3671             vfs_has_feature(vp->v_vfsp, VFSFT_DIRENTFLAGS) == 0)
3672                 return (EINVAL);
3673 
3674         VOPXID_MAP_CR(vp, cr);
3675 
3676         err = (*(vp)->v_op->vop_readdir)(vp, uiop, cr, eofp, ct, flags);
3677         VOPSTATS_UPDATE_IO(vp, readdir,
3678             readdir_bytes, (resid_start - uiop->uio_resid));
3679         return (err);
3680 }
3681 
3682 int
3683 fop_symlink(
3684         vnode_t *dvp,
3685         char *linkname,
3686         vattr_t *vap,
3687         char *target,
3688         cred_t *cr,
3689         caller_context_t *ct,
3690         int flags)
3691 {
3692         int     err;
3693         xvattr_t xvattr;
3694 
3695         /*
3696          * If this file system doesn't support case-insensitive access
3697          * and said access is requested, fail quickly.
3698          */
3699         if (flags & FIGNORECASE &&
3700             (vfs_has_feature(dvp->v_vfsp, VFSFT_CASEINSENSITIVE) == 0 &&
3701             vfs_has_feature(dvp->v_vfsp, VFSFT_NOCASESENSITIVE) == 0))
3702                 return (EINVAL);
3703 
3704         VOPXID_MAP_CR(dvp, cr);
3705 
3706         /* check for reparse point */
3707         if ((vfs_has_feature(dvp->v_vfsp, VFSFT_REPARSE)) &&
3708             (strncmp(target, FS_REPARSE_TAG_STR,
3709             strlen(FS_REPARSE_TAG_STR)) == 0)) {
3710                 if (!fs_reparse_mark(target, vap, &xvattr))
3711                         vap = (vattr_t *)&xvattr;
3712         }
3713 
3714         err = (*(dvp)->v_op->vop_symlink)
3715             (dvp, linkname, vap, target, cr, ct, flags);
3716         VOPSTATS_UPDATE(dvp, symlink);
3717         return (err);
3718 }
3719 
3720 int
3721 fop_readlink(
3722         vnode_t *vp,
3723         uio_t *uiop,
3724         cred_t *cr,
3725         caller_context_t *ct)
3726 {
3727         int     err;
3728 
3729         VOPXID_MAP_CR(vp, cr);
3730 
3731         err = (*(vp)->v_op->vop_readlink)(vp, uiop, cr, ct);
3732         VOPSTATS_UPDATE(vp, readlink);
3733         return (err);
3734 }
3735 
3736 int
3737 fop_fsync(
3738         vnode_t *vp,
3739         int syncflag,
3740         cred_t *cr,
3741         caller_context_t *ct)
3742 {
3743         int     err;
3744 
3745         VOPXID_MAP_CR(vp, cr);
3746 
3747         err = (*(vp)->v_op->vop_fsync)(vp, syncflag, cr, ct);
3748         VOPSTATS_UPDATE(vp, fsync);
3749         return (err);
3750 }
3751 
3752 void
3753 fop_inactive(
3754         vnode_t *vp,
3755         cred_t *cr,
3756         caller_context_t *ct)
3757 {
3758         /* Need to update stats before vop call since we may lose the vnode */
3759         VOPSTATS_UPDATE(vp, inactive);
3760 
3761         VOPXID_MAP_CR(vp, cr);
3762 
3763         (*(vp)->v_op->vop_inactive)(vp, cr, ct);
3764 }
3765 
3766 int
3767 fop_fid(
3768         vnode_t *vp,
3769         fid_t *fidp,
3770         caller_context_t *ct)
3771 {
3772         int     err;
3773 
3774         err = (*(vp)->v_op->vop_fid)(vp, fidp, ct);
3775         VOPSTATS_UPDATE(vp, fid);
3776         return (err);
3777 }
3778 
3779 int
3780 fop_rwlock(
3781         vnode_t *vp,
3782         int write_lock,
3783         caller_context_t *ct)
3784 {
3785         int     ret;
3786 
3787         ret = ((*(vp)->v_op->vop_rwlock)(vp, write_lock, ct));
3788         VOPSTATS_UPDATE(vp, rwlock);
3789         return (ret);
3790 }
3791 
3792 void
3793 fop_rwunlock(
3794         vnode_t *vp,
3795         int write_lock,
3796         caller_context_t *ct)
3797 {
3798         (*(vp)->v_op->vop_rwunlock)(vp, write_lock, ct);
3799         VOPSTATS_UPDATE(vp, rwunlock);
3800 }
3801 
3802 int
3803 fop_seek(
3804         vnode_t *vp,
3805         offset_t ooff,
3806         offset_t *noffp,
3807         caller_context_t *ct)
3808 {
3809         int     err;
3810 
3811         err = (*(vp)->v_op->vop_seek)(vp, ooff, noffp, ct);
3812         VOPSTATS_UPDATE(vp, seek);
3813         return (err);
3814 }
3815 
3816 int
3817 fop_cmp(
3818         vnode_t *vp1,
3819         vnode_t *vp2,
3820         caller_context_t *ct)
3821 {
3822         int     err;
3823 
3824         err = (*(vp1)->v_op->vop_cmp)(vp1, vp2, ct);
3825         VOPSTATS_UPDATE(vp1, cmp);
3826         return (err);
3827 }
3828 
3829 int
3830 fop_frlock(
3831         vnode_t *vp,
3832         int cmd,
3833         flock64_t *bfp,
3834         int flag,
3835         offset_t offset,
3836         struct flk_callback *flk_cbp,
3837         cred_t *cr,
3838         caller_context_t *ct)
3839 {
3840         int     err;
3841 
3842         VOPXID_MAP_CR(vp, cr);
3843 
3844         err = (*(vp)->v_op->vop_frlock)
3845             (vp, cmd, bfp, flag, offset, flk_cbp, cr, ct);
3846         VOPSTATS_UPDATE(vp, frlock);
3847         return (err);
3848 }
3849 
3850 int
3851 fop_space(
3852         vnode_t *vp,
3853         int cmd,
3854         flock64_t *bfp,
3855         int flag,
3856         offset_t offset,
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_space)(vp, cmd, bfp, flag, offset, cr, ct);
3865         VOPSTATS_UPDATE(vp, space);
3866         return (err);
3867 }
3868 
3869 int
3870 fop_realvp(
3871         vnode_t *vp,
3872         vnode_t **vpp,
3873         caller_context_t *ct)
3874 {
3875         int     err;
3876 
3877         err = (*(vp)->v_op->vop_realvp)(vp, vpp, ct);
3878         VOPSTATS_UPDATE(vp, realvp);
3879         return (err);
3880 }
3881 
3882 int
3883 fop_getpage(
3884         vnode_t *vp,
3885         offset_t off,
3886         size_t len,
3887         uint_t *protp,
3888         page_t **plarr,
3889         size_t plsz,
3890         struct seg *seg,
3891         caddr_t addr,
3892         enum seg_rw rw,
3893         cred_t *cr,
3894         caller_context_t *ct)
3895 {
3896         int     err;
3897 
3898         VOPXID_MAP_CR(vp, cr);
3899 
3900         err = (*(vp)->v_op->vop_getpage)
3901             (vp, off, len, protp, plarr, plsz, seg, addr, rw, cr, ct);
3902         VOPSTATS_UPDATE(vp, getpage);
3903         return (err);
3904 }
3905 
3906 int
3907 fop_putpage(
3908         vnode_t *vp,
3909         offset_t off,
3910         size_t len,
3911         int flags,
3912         cred_t *cr,
3913         caller_context_t *ct)
3914 {
3915         int     err;
3916 
3917         VOPXID_MAP_CR(vp, cr);
3918 
3919         err = (*(vp)->v_op->vop_putpage)(vp, off, len, flags, cr, ct);
3920         VOPSTATS_UPDATE(vp, putpage);
3921         return (err);
3922 }
3923 
3924 int
3925 fop_map(
3926         vnode_t *vp,
3927         offset_t off,
3928         struct as *as,
3929         caddr_t *addrp,
3930         size_t len,
3931         uchar_t prot,
3932         uchar_t maxprot,
3933         uint_t flags,
3934         cred_t *cr,
3935         caller_context_t *ct)
3936 {
3937         int     err;
3938 
3939         VOPXID_MAP_CR(vp, cr);
3940 
3941         err = (*(vp)->v_op->vop_map)
3942             (vp, off, as, addrp, len, prot, maxprot, flags, cr, ct);
3943         VOPSTATS_UPDATE(vp, map);
3944         return (err);
3945 }
3946 
3947 int
3948 fop_addmap(
3949         vnode_t *vp,
3950         offset_t off,
3951         struct as *as,
3952         caddr_t addr,
3953         size_t len,
3954         uchar_t prot,
3955         uchar_t maxprot,
3956         uint_t flags,
3957         cred_t *cr,
3958         caller_context_t *ct)
3959 {
3960         int error;
3961         u_longlong_t delta;
3962 
3963         VOPXID_MAP_CR(vp, cr);
3964 
3965         error = (*(vp)->v_op->vop_addmap)
3966             (vp, off, as, addr, len, prot, maxprot, flags, cr, ct);
3967 
3968         if ((!error) && (vp->v_type == VREG)) {
3969                 delta = (u_longlong_t)btopr(len);
3970                 /*
3971                  * If file is declared MAP_PRIVATE, it can't be written back
3972                  * even if open for write. Handle as read.
3973                  */
3974                 if (flags & MAP_PRIVATE) {
3975                         atomic_add_64((uint64_t *)(&(vp->v_mmap_read)),
3976                             (int64_t)delta);
3977                 } else {
3978                         /*
3979                          * atomic_add_64 forces the fetch of a 64 bit value to
3980                          * be atomic on 32 bit machines
3981                          */
3982                         if (maxprot & PROT_WRITE)
3983                                 atomic_add_64((uint64_t *)(&(vp->v_mmap_write)),
3984                                     (int64_t)delta);
3985                         if (maxprot & PROT_READ)
3986                                 atomic_add_64((uint64_t *)(&(vp->v_mmap_read)),
3987                                     (int64_t)delta);
3988                         if (maxprot & PROT_EXEC)
3989                                 atomic_add_64((uint64_t *)(&(vp->v_mmap_read)),
3990                                     (int64_t)delta);
3991                 }
3992         }
3993         VOPSTATS_UPDATE(vp, addmap);
3994         return (error);
3995 }
3996 
3997 int
3998 fop_delmap(
3999         vnode_t *vp,
4000         offset_t off,
4001         struct as *as,
4002         caddr_t addr,
4003         size_t len,
4004         uint_t prot,
4005         uint_t maxprot,
4006         uint_t flags,
4007         cred_t *cr,
4008         caller_context_t *ct)
4009 {
4010         int error;
4011         u_longlong_t delta;
4012 
4013         VOPXID_MAP_CR(vp, cr);
4014 
4015         error = (*(vp)->v_op->vop_delmap)
4016             (vp, off, as, addr, len, prot, maxprot, flags, cr, ct);
4017 
4018         /*
4019          * NFS calls into delmap twice, the first time
4020          * it simply establishes a callback mechanism and returns EAGAIN
4021          * while the real work is being done upon the second invocation.
4022          * We have to detect this here and only decrement the counts upon
4023          * the second delmap request.
4024          */
4025         if ((error != EAGAIN) && (vp->v_type == VREG)) {
4026 
4027                 delta = (u_longlong_t)btopr(len);
4028 
4029                 if (flags & MAP_PRIVATE) {
4030                         atomic_add_64((uint64_t *)(&(vp->v_mmap_read)),
4031                             (int64_t)(-delta));
4032                 } else {
4033                         /*
4034                          * atomic_add_64 forces the fetch of a 64 bit value
4035                          * to be atomic on 32 bit machines
4036                          */
4037                         if (maxprot & PROT_WRITE)
4038                                 atomic_add_64((uint64_t *)(&(vp->v_mmap_write)),
4039                                     (int64_t)(-delta));
4040                         if (maxprot & PROT_READ)
4041                                 atomic_add_64((uint64_t *)(&(vp->v_mmap_read)),
4042                                     (int64_t)(-delta));
4043                         if (maxprot & PROT_EXEC)
4044                                 atomic_add_64((uint64_t *)(&(vp->v_mmap_read)),
4045                                     (int64_t)(-delta));
4046                 }
4047         }
4048         VOPSTATS_UPDATE(vp, delmap);
4049         return (error);
4050 }
4051 
4052 
4053 int
4054 fop_poll(
4055         vnode_t *vp,
4056         short events,
4057         int anyyet,
4058         short *reventsp,
4059         struct pollhead **phpp,
4060         caller_context_t *ct)
4061 {
4062         int     err;
4063 
4064         err = (*(vp)->v_op->vop_poll)(vp, events, anyyet, reventsp, phpp, ct);
4065         VOPSTATS_UPDATE(vp, poll);
4066         return (err);
4067 }
4068 
4069 int
4070 fop_dump(
4071         vnode_t *vp,
4072         caddr_t addr,
4073         offset_t lbdn,
4074         offset_t dblks,
4075         caller_context_t *ct)
4076 {
4077         int     err;
4078 
4079         /* ensure lbdn and dblks can be passed safely to bdev_dump */
4080         if ((lbdn != (daddr_t)lbdn) || (dblks != (int)dblks))
4081                 return (EIO);
4082 
4083         err = (*(vp)->v_op->vop_dump)(vp, addr, lbdn, dblks, ct);
4084         VOPSTATS_UPDATE(vp, dump);
4085         return (err);
4086 }
4087 
4088 int
4089 fop_pathconf(
4090         vnode_t *vp,
4091         int cmd,
4092         ulong_t *valp,
4093         cred_t *cr,
4094         caller_context_t *ct)
4095 {
4096         int     err;
4097 
4098         VOPXID_MAP_CR(vp, cr);
4099 
4100         err = (*(vp)->v_op->vop_pathconf)(vp, cmd, valp, cr, ct);
4101         VOPSTATS_UPDATE(vp, pathconf);
4102         return (err);
4103 }
4104 
4105 int
4106 fop_pageio(
4107         vnode_t *vp,
4108         struct page *pp,
4109         u_offset_t io_off,
4110         size_t io_len,
4111         int flags,
4112         cred_t *cr,
4113         caller_context_t *ct)
4114 {
4115         int     err;
4116 
4117         VOPXID_MAP_CR(vp, cr);
4118 
4119         err = (*(vp)->v_op->vop_pageio)(vp, pp, io_off, io_len, flags, cr, ct);
4120         VOPSTATS_UPDATE(vp, pageio);
4121         return (err);
4122 }
4123 
4124 int
4125 fop_dumpctl(
4126         vnode_t *vp,
4127         int action,
4128         offset_t *blkp,
4129         caller_context_t *ct)
4130 {
4131         int     err;
4132         err = (*(vp)->v_op->vop_dumpctl)(vp, action, blkp, ct);
4133         VOPSTATS_UPDATE(vp, dumpctl);
4134         return (err);
4135 }
4136 
4137 void
4138 fop_dispose(
4139         vnode_t *vp,
4140         page_t *pp,
4141         int flag,
4142         int dn,
4143         cred_t *cr,
4144         caller_context_t *ct)
4145 {
4146         /* Must do stats first since it's possible to lose the vnode */
4147         VOPSTATS_UPDATE(vp, dispose);
4148 
4149         VOPXID_MAP_CR(vp, cr);
4150 
4151         (*(vp)->v_op->vop_dispose)(vp, pp, flag, dn, cr, ct);
4152 }
4153 
4154 int
4155 fop_setsecattr(
4156         vnode_t *vp,
4157         vsecattr_t *vsap,
4158         int flag,
4159         cred_t *cr,
4160         caller_context_t *ct)
4161 {
4162         int     err;
4163 
4164         VOPXID_MAP_CR(vp, cr);
4165 
4166         /*
4167          * We're only allowed to skip the ACL check iff we used a 32 bit
4168          * ACE mask with VOP_ACCESS() to determine permissions.
4169          */
4170         if ((flag & ATTR_NOACLCHECK) &&
4171             vfs_has_feature(vp->v_vfsp, VFSFT_ACEMASKONACCESS) == 0) {
4172                 return (EINVAL);
4173         }
4174         err = (*(vp)->v_op->vop_setsecattr) (vp, vsap, flag, cr, ct);
4175         VOPSTATS_UPDATE(vp, setsecattr);
4176         return (err);
4177 }
4178 
4179 int
4180 fop_getsecattr(
4181         vnode_t *vp,
4182         vsecattr_t *vsap,
4183         int flag,
4184         cred_t *cr,
4185         caller_context_t *ct)
4186 {
4187         int     err;
4188 
4189         /*
4190          * We're only allowed to skip the ACL check iff we used a 32 bit
4191          * ACE mask with VOP_ACCESS() to determine permissions.
4192          */
4193         if ((flag & ATTR_NOACLCHECK) &&
4194             vfs_has_feature(vp->v_vfsp, VFSFT_ACEMASKONACCESS) == 0) {
4195                 return (EINVAL);
4196         }
4197 
4198         VOPXID_MAP_CR(vp, cr);
4199 
4200         err = (*(vp)->v_op->vop_getsecattr) (vp, vsap, flag, cr, ct);
4201         VOPSTATS_UPDATE(vp, getsecattr);
4202         return (err);
4203 }
4204 
4205 int
4206 fop_shrlock(
4207         vnode_t *vp,
4208         int cmd,
4209         struct shrlock *shr,
4210         int flag,
4211         cred_t *cr,
4212         caller_context_t *ct)
4213 {
4214         int     err;
4215 
4216         VOPXID_MAP_CR(vp, cr);
4217 
4218         err = (*(vp)->v_op->vop_shrlock)(vp, cmd, shr, flag, cr, ct);
4219         VOPSTATS_UPDATE(vp, shrlock);
4220         return (err);
4221 }
4222 
4223 int
4224 fop_vnevent(vnode_t *vp, vnevent_t vnevent, vnode_t *dvp, char *fnm,
4225     caller_context_t *ct)
4226 {
4227         int     err;
4228 
4229         err = (*(vp)->v_op->vop_vnevent)(vp, vnevent, dvp, fnm, ct);
4230         VOPSTATS_UPDATE(vp, vnevent);
4231         return (err);
4232 }
4233 
4234 int
4235 fop_reqzcbuf(vnode_t *vp, enum uio_rw ioflag, xuio_t *uiop, cred_t *cr,
4236     caller_context_t *ct)
4237 {
4238         int err;
4239 
4240         if (vfs_has_feature(vp->v_vfsp, VFSFT_ZEROCOPY_SUPPORTED) == 0)
4241                 return (ENOTSUP);
4242         err = (*(vp)->v_op->vop_reqzcbuf)(vp, ioflag, uiop, cr, ct);
4243         VOPSTATS_UPDATE(vp, reqzcbuf);
4244         return (err);
4245 }
4246 
4247 int
4248 fop_retzcbuf(vnode_t *vp, xuio_t *uiop, cred_t *cr, caller_context_t *ct)
4249 {
4250         int err;
4251 
4252         if (vfs_has_feature(vp->v_vfsp, VFSFT_ZEROCOPY_SUPPORTED) == 0)
4253                 return (ENOTSUP);
4254         err = (*(vp)->v_op->vop_retzcbuf)(vp, uiop, cr, ct);
4255         VOPSTATS_UPDATE(vp, retzcbuf);
4256         return (err);
4257 }
4258 
4259 /*
4260  * Default destructor
4261  *      Needed because NULL destructor means that the key is unused
4262  */
4263 /* ARGSUSED */
4264 void
4265 vsd_defaultdestructor(void *value)
4266 {}
4267 
4268 /*
4269  * Create a key (index into per vnode array)
4270  *      Locks out vsd_create, vsd_destroy, and vsd_free
4271  *      May allocate memory with lock held
4272  */
4273 void
4274 vsd_create(uint_t *keyp, void (*destructor)(void *))
4275 {
4276         int     i;
4277         uint_t  nkeys;
4278 
4279         /*
4280          * if key is allocated, do nothing
4281          */
4282         mutex_enter(&vsd_lock);
4283         if (*keyp) {
4284                 mutex_exit(&vsd_lock);
4285                 return;
4286         }
4287         /*
4288          * find an unused key
4289          */
4290         if (destructor == NULL)
4291                 destructor = vsd_defaultdestructor;
4292 
4293         for (i = 0; i < vsd_nkeys; ++i)
4294                 if (vsd_destructor[i] == NULL)
4295                         break;
4296 
4297         /*
4298          * if no unused keys, increase the size of the destructor array
4299          */
4300         if (i == vsd_nkeys) {
4301                 if ((nkeys = (vsd_nkeys << 1)) == 0)
4302                         nkeys = 1;
4303                 vsd_destructor =
4304                     (void (**)(void *))vsd_realloc((void *)vsd_destructor,
4305                     (size_t)(vsd_nkeys * sizeof (void (*)(void *))),
4306                     (size_t)(nkeys * sizeof (void (*)(void *))));
4307                 vsd_nkeys = nkeys;
4308         }
4309 
4310         /*
4311          * allocate the next available unused key
4312          */
4313         vsd_destructor[i] = destructor;
4314         *keyp = i + 1;
4315 
4316         /* create vsd_list, if it doesn't exist */
4317         if (vsd_list == NULL) {
4318                 vsd_list = kmem_alloc(sizeof (list_t), KM_SLEEP);
4319                 list_create(vsd_list, sizeof (struct vsd_node),
4320                     offsetof(struct vsd_node, vs_nodes));
4321         }
4322 
4323         mutex_exit(&vsd_lock);
4324 }
4325 
4326 /*
4327  * Destroy a key
4328  *
4329  * Assumes that the caller is preventing vsd_set and vsd_get
4330  * Locks out vsd_create, vsd_destroy, and vsd_free
4331  * May free memory with lock held
4332  */
4333 void
4334 vsd_destroy(uint_t *keyp)
4335 {
4336         uint_t key;
4337         struct vsd_node *vsd;
4338 
4339         /*
4340          * protect the key namespace and our destructor lists
4341          */
4342         mutex_enter(&vsd_lock);
4343         key = *keyp;
4344         *keyp = 0;
4345 
4346         ASSERT(key <= vsd_nkeys);
4347 
4348         /*
4349          * if the key is valid
4350          */
4351         if (key != 0) {
4352                 uint_t k = key - 1;
4353                 /*
4354                  * for every vnode with VSD, call key's destructor
4355                  */
4356                 for (vsd = list_head(vsd_list); vsd != NULL;
4357                     vsd = list_next(vsd_list, vsd)) {
4358                         /*
4359                          * no VSD for key in this vnode
4360                          */
4361                         if (key > vsd->vs_nkeys)
4362                                 continue;
4363                         /*
4364                          * call destructor for key
4365                          */
4366                         if (vsd->vs_value[k] && vsd_destructor[k])
4367                                 (*vsd_destructor[k])(vsd->vs_value[k]);
4368                         /*
4369                          * reset value for key
4370                          */
4371                         vsd->vs_value[k] = NULL;
4372                 }
4373                 /*
4374                  * actually free the key (NULL destructor == unused)
4375                  */
4376                 vsd_destructor[k] = NULL;
4377         }
4378 
4379         mutex_exit(&vsd_lock);
4380 }
4381 
4382 /*
4383  * Quickly return the per vnode value that was stored with the specified key
4384  * Assumes the caller is protecting key from vsd_create and vsd_destroy
4385  * Assumes the caller is holding v_vsd_lock to protect the vsd.
4386  */
4387 void *
4388 vsd_get(vnode_t *vp, uint_t key)
4389 {
4390         struct vsd_node *vsd;
4391 
4392         ASSERT(vp != NULL);
4393         ASSERT(mutex_owned(&vp->v_vsd_lock));
4394 
4395         vsd = vp->v_vsd;
4396 
4397         if (key && vsd != NULL && key <= vsd->vs_nkeys)
4398                 return (vsd->vs_value[key - 1]);
4399         return (NULL);
4400 }
4401 
4402 /*
4403  * Set a per vnode value indexed with the specified key
4404  * Assumes the caller is holding v_vsd_lock to protect the vsd.
4405  */
4406 int
4407 vsd_set(vnode_t *vp, uint_t key, void *value)
4408 {
4409         struct vsd_node *vsd;
4410 
4411         ASSERT(vp != NULL);
4412         ASSERT(mutex_owned(&vp->v_vsd_lock));
4413 
4414         if (key == 0)
4415                 return (EINVAL);
4416 
4417         vsd = vp->v_vsd;
4418         if (vsd == NULL)
4419                 vsd = vp->v_vsd = kmem_zalloc(sizeof (*vsd), KM_SLEEP);
4420 
4421         /*
4422          * If the vsd was just allocated, vs_nkeys will be 0, so the following
4423          * code won't happen and we will continue down and allocate space for
4424          * the vs_value array.
4425          * If the caller is replacing one value with another, then it is up
4426          * to the caller to free/rele/destroy the previous value (if needed).
4427          */
4428         if (key <= vsd->vs_nkeys) {
4429                 vsd->vs_value[key - 1] = value;
4430                 return (0);
4431         }
4432 
4433         ASSERT(key <= vsd_nkeys);
4434 
4435         if (vsd->vs_nkeys == 0) {
4436                 mutex_enter(&vsd_lock);     /* lock out vsd_destroy() */
4437                 /*
4438                  * Link onto list of all VSD nodes.
4439                  */
4440                 list_insert_head(vsd_list, vsd);
4441                 mutex_exit(&vsd_lock);
4442         }
4443 
4444         /*
4445          * Allocate vnode local storage and set the value for key
4446          */
4447         vsd->vs_value = vsd_realloc(vsd->vs_value,
4448             vsd->vs_nkeys * sizeof (void *),
4449             key * sizeof (void *));
4450         vsd->vs_nkeys = key;
4451         vsd->vs_value[key - 1] = value;
4452 
4453         return (0);
4454 }
4455 
4456 /*
4457  * Called from vn_free() to run the destructor function for each vsd
4458  *      Locks out vsd_create and vsd_destroy
4459  *      Assumes that the destructor *DOES NOT* use vsd
4460  */
4461 void
4462 vsd_free(vnode_t *vp)
4463 {
4464         int i;
4465         struct vsd_node *vsd = vp->v_vsd;
4466 
4467         if (vsd == NULL)
4468                 return;
4469 
4470         if (vsd->vs_nkeys == 0) {
4471                 kmem_free(vsd, sizeof (*vsd));
4472                 vp->v_vsd = NULL;
4473                 return;
4474         }
4475 
4476         /*
4477          * lock out vsd_create and vsd_destroy, call
4478          * the destructor, and mark the value as destroyed.
4479          */
4480         mutex_enter(&vsd_lock);
4481 
4482         for (i = 0; i < vsd->vs_nkeys; i++) {
4483                 if (vsd->vs_value[i] && vsd_destructor[i])
4484                         (*vsd_destructor[i])(vsd->vs_value[i]);
4485                 vsd->vs_value[i] = NULL;
4486         }
4487 
4488         /*
4489          * remove from linked list of VSD nodes
4490          */
4491         list_remove(vsd_list, vsd);
4492 
4493         mutex_exit(&vsd_lock);
4494 
4495         /*
4496          * free up the VSD
4497          */
4498         kmem_free(vsd->vs_value, vsd->vs_nkeys * sizeof (void *));
4499         kmem_free(vsd, sizeof (struct vsd_node));
4500         vp->v_vsd = NULL;
4501 }
4502 
4503 /*
4504  * realloc
4505  */
4506 static void *
4507 vsd_realloc(void *old, size_t osize, size_t nsize)
4508 {
4509         void *new;
4510 
4511         new = kmem_zalloc(nsize, KM_SLEEP);
4512         if (old) {
4513                 bcopy(old, new, osize);
4514                 kmem_free(old, osize);
4515         }
4516         return (new);
4517 }
4518 
4519 /*
4520  * Setup the extensible system attribute for creating a reparse point.
4521  * The symlink data 'target' is validated for proper format of a reparse
4522  * string and a check also made to make sure the symlink data does not
4523  * point to an existing file.
4524  *
4525  * return 0 if ok else -1.
4526  */
4527 static int
4528 fs_reparse_mark(char *target, vattr_t *vap, xvattr_t *xvattr)
4529 {
4530         xoptattr_t *xoap;
4531 
4532         if ((!target) || (!vap) || (!xvattr))
4533                 return (-1);
4534 
4535         /* validate reparse string */
4536         if (reparse_validate((const char *)target))
4537                 return (-1);
4538 
4539         xva_init(xvattr);
4540         xvattr->xva_vattr = *vap;
4541         xvattr->xva_vattr.va_mask |= AT_XVATTR;
4542         xoap = xva_getxoptattr(xvattr);
4543         ASSERT(xoap);
4544         XVA_SET_REQ(xvattr, XAT_REPARSE);
4545         xoap->xoa_reparse = 1;
4546 
4547         return (0);
4548 }
4549 
4550 /*
4551  * Function to check whether a symlink is a reparse point.
4552  * Return B_TRUE if it is a reparse point, else return B_FALSE
4553  */
4554 boolean_t
4555 vn_is_reparse(vnode_t *vp, cred_t *cr, caller_context_t *ct)
4556 {
4557         xvattr_t xvattr;
4558         xoptattr_t *xoap;
4559 
4560         if ((vp->v_type != VLNK) ||
4561             !(vfs_has_feature(vp->v_vfsp, VFSFT_XVATTR)))
4562                 return (B_FALSE);
4563 
4564         xva_init(&xvattr);
4565         xoap = xva_getxoptattr(&xvattr);
4566         ASSERT(xoap);
4567         XVA_SET_REQ(&xvattr, XAT_REPARSE);
4568 
4569         if (VOP_GETATTR(vp, &xvattr.xva_vattr, 0, cr, ct))
4570                 return (B_FALSE);
4571 
4572         if ((!(xvattr.xva_vattr.va_mask & AT_XVATTR)) ||
4573             (!(XVA_ISSET_RTN(&xvattr, XAT_REPARSE))))
4574                 return (B_FALSE);
4575 
4576         return (xoap->xoa_reparse ? B_TRUE : B_FALSE);
4577 }