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_add_32(&(vp->v_rdcnt), 1);
1248         if (filemode & FWRITE)
1249                 atomic_add_32(&(vp->v_wrcnt), 1);
1250 
1251 }
1252 
1253 void
1254 vn_open_downgrade(
1255         vnode_t *vp,
1256         int filemode)
1257 {
1258         ASSERT(vp->v_type == VREG);
1259 
1260         if (filemode & FREAD) {
1261                 ASSERT(vp->v_rdcnt > 0);
1262                 atomic_add_32(&(vp->v_rdcnt), -1);
1263         }
1264         if (filemode & FWRITE) {
1265                 ASSERT(vp->v_wrcnt > 0);
1266                 atomic_add_32(&(vp->v_wrcnt), -1);
1267         }
1268 
1269 }
1270 
1271 int
1272 vn_create(
1273         char *pnamep,
1274         enum uio_seg seg,
1275         struct vattr *vap,
1276         enum vcexcl excl,
1277         int mode,
1278         struct vnode **vpp,
1279         enum create why,
1280         int flag,
1281         mode_t umask)
1282 {
1283         return (vn_createat(pnamep, seg, vap, excl, mode, vpp, why, flag,
1284             umask, NULL));
1285 }
1286 
1287 /*
1288  * Create a vnode (makenode).
1289  */
1290 int
1291 vn_createat(
1292         char *pnamep,
1293         enum uio_seg seg,
1294         struct vattr *vap,
1295         enum vcexcl excl,
1296         int mode,
1297         struct vnode **vpp,
1298         enum create why,
1299         int flag,
1300         mode_t umask,
1301         struct vnode *startvp)
1302 {
1303         struct vnode *dvp;      /* ptr to parent dir vnode */
1304         struct vnode *vp = NULL;
1305         struct pathname pn;
1306         int error;
1307         int in_crit = 0;
1308         struct vattr vattr;
1309         enum symfollow follow;
1310         int estale_retry = 0;
1311         uint32_t auditing = AU_AUDITING();
1312 
1313         ASSERT((vap->va_mask & (AT_TYPE|AT_MODE)) == (AT_TYPE|AT_MODE));
1314 
1315         /* symlink interpretation */
1316         if ((flag & FNOFOLLOW) || excl == EXCL)
1317                 follow = NO_FOLLOW;
1318         else
1319                 follow = FOLLOW;
1320         flag &= ~(FNOFOLLOW|FNOLINKS);
1321 
1322 top:
1323         /*
1324          * Lookup directory.
1325          * If new object is a file, call lower level to create it.
1326          * Note that it is up to the lower level to enforce exclusive
1327          * creation, if the file is already there.
1328          * This allows the lower level to do whatever
1329          * locking or protocol that is needed to prevent races.
1330          * If the new object is directory call lower level to make
1331          * the new directory, with "." and "..".
1332          */
1333         if (error = pn_get(pnamep, seg, &pn))
1334                 return (error);
1335         if (auditing)
1336                 audit_vncreate_start();
1337         dvp = NULL;
1338         *vpp = NULL;
1339         /*
1340          * lookup will find the parent directory for the vnode.
1341          * When it is done the pn holds the name of the entry
1342          * in the directory.
1343          * If this is a non-exclusive create we also find the node itself.
1344          */
1345         error = lookuppnat(&pn, NULL, follow, &dvp,
1346             (excl == EXCL) ? NULLVPP : vpp, startvp);
1347         if (error) {
1348                 pn_free(&pn);
1349                 if ((error == ESTALE) && fs_need_estale_retry(estale_retry++))
1350                         goto top;
1351                 if (why == CRMKDIR && error == EINVAL)
1352                         error = EEXIST;         /* SVID */
1353                 return (error);
1354         }
1355 
1356         if (why != CRMKNOD)
1357                 vap->va_mode &= ~VSVTX;
1358 
1359         /*
1360          * If default ACLs are defined for the directory don't apply the
1361          * umask if umask is passed.
1362          */
1363 
1364         if (umask) {
1365 
1366                 vsecattr_t vsec;
1367 
1368                 vsec.vsa_aclcnt = 0;
1369                 vsec.vsa_aclentp = NULL;
1370                 vsec.vsa_dfaclcnt = 0;
1371                 vsec.vsa_dfaclentp = NULL;
1372                 vsec.vsa_mask = VSA_DFACLCNT;
1373                 error = VOP_GETSECATTR(dvp, &vsec, 0, CRED(), NULL);
1374                 /*
1375                  * If error is ENOSYS then treat it as no error
1376                  * Don't want to force all file systems to support
1377                  * aclent_t style of ACL's.
1378                  */
1379                 if (error == ENOSYS)
1380                         error = 0;
1381                 if (error) {
1382                         if (*vpp != NULL)
1383                                 VN_RELE(*vpp);
1384                         goto out;
1385                 } else {
1386                         /*
1387                          * Apply the umask if no default ACLs.
1388                          */
1389                         if (vsec.vsa_dfaclcnt == 0)
1390                                 vap->va_mode &= ~umask;
1391 
1392                         /*
1393                          * VOP_GETSECATTR() may have allocated memory for
1394                          * ACLs we didn't request, so double-check and
1395                          * free it if necessary.
1396                          */
1397                         if (vsec.vsa_aclcnt && vsec.vsa_aclentp != NULL)
1398                                 kmem_free((caddr_t)vsec.vsa_aclentp,
1399                                     vsec.vsa_aclcnt * sizeof (aclent_t));
1400                         if (vsec.vsa_dfaclcnt && vsec.vsa_dfaclentp != NULL)
1401                                 kmem_free((caddr_t)vsec.vsa_dfaclentp,
1402                                     vsec.vsa_dfaclcnt * sizeof (aclent_t));
1403                 }
1404         }
1405 
1406         /*
1407          * In general we want to generate EROFS if the file system is
1408          * readonly.  However, POSIX (IEEE Std. 1003.1) section 5.3.1
1409          * documents the open system call, and it says that O_CREAT has no
1410          * effect if the file already exists.  Bug 1119649 states
1411          * that open(path, O_CREAT, ...) fails when attempting to open an
1412          * existing file on a read only file system.  Thus, the first part
1413          * of the following if statement has 3 checks:
1414          *      if the file exists &&
1415          *              it is being open with write access &&
1416          *              the file system is read only
1417          *      then generate EROFS
1418          */
1419         if ((*vpp != NULL && (mode & VWRITE) && ISROFILE(*vpp)) ||
1420             (*vpp == NULL && dvp->v_vfsp->vfs_flag & VFS_RDONLY)) {
1421                 if (*vpp)
1422                         VN_RELE(*vpp);
1423                 error = EROFS;
1424         } else if (excl == NONEXCL && *vpp != NULL) {
1425                 vnode_t *rvp;
1426 
1427                 /*
1428                  * File already exists.  If a mandatory lock has been
1429                  * applied, return error.
1430                  */
1431                 vp = *vpp;
1432                 if (VOP_REALVP(vp, &rvp, NULL) != 0)
1433                         rvp = vp;
1434                 if ((vap->va_mask & AT_SIZE) && nbl_need_check(vp)) {
1435                         nbl_start_crit(vp, RW_READER);
1436                         in_crit = 1;
1437                 }
1438                 if (rvp->v_filocks != NULL || rvp->v_shrlocks != NULL) {
1439                         vattr.va_mask = AT_MODE|AT_SIZE;
1440                         if (error = VOP_GETATTR(vp, &vattr, 0, CRED(), NULL)) {
1441                                 goto out;
1442                         }
1443                         if (MANDLOCK(vp, vattr.va_mode)) {
1444                                 error = EAGAIN;
1445                                 goto out;
1446                         }
1447                         /*
1448                          * File cannot be truncated if non-blocking mandatory
1449                          * locks are currently on the file.
1450                          */
1451                         if ((vap->va_mask & AT_SIZE) && in_crit) {
1452                                 u_offset_t offset;
1453                                 ssize_t length;
1454 
1455                                 offset = vap->va_size > vattr.va_size ?
1456                                     vattr.va_size : vap->va_size;
1457                                 length = vap->va_size > vattr.va_size ?
1458                                     vap->va_size - vattr.va_size :
1459                                     vattr.va_size - vap->va_size;
1460                                 if (nbl_conflict(vp, NBL_WRITE, offset,
1461                                     length, 0, NULL)) {
1462                                         error = EACCES;
1463                                         goto out;
1464                                 }
1465                         }
1466                 }
1467 
1468                 /*
1469                  * If the file is the root of a VFS, we've crossed a
1470                  * mount point and the "containing" directory that we
1471                  * acquired above (dvp) is irrelevant because it's in
1472                  * a different file system.  We apply VOP_CREATE to the
1473                  * target itself instead of to the containing directory
1474                  * and supply a null path name to indicate (conventionally)
1475                  * the node itself as the "component" of interest.
1476                  *
1477                  * The intercession of the file system is necessary to
1478                  * ensure that the appropriate permission checks are
1479                  * done.
1480                  */
1481                 if (vp->v_flag & VROOT) {
1482                         ASSERT(why != CRMKDIR);
1483                         error = VOP_CREATE(vp, "", vap, excl, mode, vpp,
1484                             CRED(), flag, NULL, NULL);
1485                         /*
1486                          * If the create succeeded, it will have created
1487                          * a new reference to the vnode.  Give up the
1488                          * original reference.  The assertion should not
1489                          * get triggered because NBMAND locks only apply to
1490                          * VREG files.  And if in_crit is non-zero for some
1491                          * reason, detect that here, rather than when we
1492                          * deference a null vp.
1493                          */
1494                         ASSERT(in_crit == 0);
1495                         VN_RELE(vp);
1496                         vp = NULL;
1497                         goto out;
1498                 }
1499 
1500                 /*
1501                  * Large File API - non-large open (FOFFMAX flag not set)
1502                  * of regular file fails if the file size exceeds MAXOFF32_T.
1503                  */
1504                 if (why != CRMKDIR &&
1505                     !(flag & FOFFMAX) &&
1506                     (vp->v_type == VREG)) {
1507                         vattr.va_mask = AT_SIZE;
1508                         if ((error = VOP_GETATTR(vp, &vattr, 0,
1509                             CRED(), NULL))) {
1510                                 goto out;
1511                         }
1512                         if ((vattr.va_size > (u_offset_t)MAXOFF32_T)) {
1513                                 error = EOVERFLOW;
1514                                 goto out;
1515                         }
1516                 }
1517         }
1518 
1519         if (error == 0) {
1520                 /*
1521                  * Call mkdir() if specified, otherwise create().
1522                  */
1523                 int must_be_dir = pn_fixslash(&pn); /* trailing '/'? */
1524 
1525                 if (why == CRMKDIR)
1526                         /*
1527                          * N.B., if vn_createat() ever requests
1528                          * case-insensitive behavior then it will need
1529                          * to be passed to VOP_MKDIR().  VOP_CREATE()
1530                          * will already get it via "flag"
1531                          */
1532                         error = VOP_MKDIR(dvp, pn.pn_path, vap, vpp, CRED(),
1533                             NULL, 0, NULL);
1534                 else if (!must_be_dir)
1535                         error = VOP_CREATE(dvp, pn.pn_path, vap,
1536                             excl, mode, vpp, CRED(), flag, NULL, NULL);
1537                 else
1538                         error = ENOTDIR;
1539         }
1540 
1541 out:
1542 
1543         if (auditing)
1544                 audit_vncreate_finish(*vpp, error);
1545         if (in_crit) {
1546                 nbl_end_crit(vp);
1547                 in_crit = 0;
1548         }
1549         if (vp != NULL) {
1550                 VN_RELE(vp);
1551                 vp = NULL;
1552         }
1553         pn_free(&pn);
1554         VN_RELE(dvp);
1555         /*
1556          * The following clause was added to handle a problem
1557          * with NFS consistency.  It is possible that a lookup
1558          * of the file to be created succeeded, but the file
1559          * itself doesn't actually exist on the server.  This
1560          * is chiefly due to the DNLC containing an entry for
1561          * the file which has been removed on the server.  In
1562          * this case, we just start over.  If there was some
1563          * other cause for the ESTALE error, then the lookup
1564          * of the file will fail and the error will be returned
1565          * above instead of looping around from here.
1566          */
1567         if ((error == ESTALE) && fs_need_estale_retry(estale_retry++))
1568                 goto top;
1569         return (error);
1570 }
1571 
1572 int
1573 vn_link(char *from, char *to, enum uio_seg seg)
1574 {
1575         return (vn_linkat(NULL, from, NO_FOLLOW, NULL, to, seg));
1576 }
1577 
1578 int
1579 vn_linkat(vnode_t *fstartvp, char *from, enum symfollow follow,
1580     vnode_t *tstartvp, char *to, enum uio_seg seg)
1581 {
1582         struct vnode *fvp;              /* from vnode ptr */
1583         struct vnode *tdvp;             /* to directory vnode ptr */
1584         struct pathname pn;
1585         int error;
1586         struct vattr vattr;
1587         dev_t fsid;
1588         int estale_retry = 0;
1589         uint32_t auditing = AU_AUDITING();
1590 
1591 top:
1592         fvp = tdvp = NULL;
1593         if (error = pn_get(to, seg, &pn))
1594                 return (error);
1595         if (auditing && fstartvp != NULL)
1596                 audit_setfsat_path(1);
1597         if (error = lookupnameat(from, seg, follow, NULLVPP, &fvp, fstartvp))
1598                 goto out;
1599         if (auditing && tstartvp != NULL)
1600                 audit_setfsat_path(3);
1601         if (error = lookuppnat(&pn, NULL, NO_FOLLOW, &tdvp, NULLVPP, tstartvp))
1602                 goto out;
1603         /*
1604          * Make sure both source vnode and target directory vnode are
1605          * in the same vfs and that it is writeable.
1606          */
1607         vattr.va_mask = AT_FSID;
1608         if (error = VOP_GETATTR(fvp, &vattr, 0, CRED(), NULL))
1609                 goto out;
1610         fsid = vattr.va_fsid;
1611         vattr.va_mask = AT_FSID;
1612         if (error = VOP_GETATTR(tdvp, &vattr, 0, CRED(), NULL))
1613                 goto out;
1614         if (fsid != vattr.va_fsid) {
1615                 error = EXDEV;
1616                 goto out;
1617         }
1618         if (tdvp->v_vfsp->vfs_flag & VFS_RDONLY) {
1619                 error = EROFS;
1620                 goto out;
1621         }
1622         /*
1623          * Do the link.
1624          */
1625         (void) pn_fixslash(&pn);
1626         error = VOP_LINK(tdvp, fvp, pn.pn_path, CRED(), NULL, 0);
1627 out:
1628         pn_free(&pn);
1629         if (fvp)
1630                 VN_RELE(fvp);
1631         if (tdvp)
1632                 VN_RELE(tdvp);
1633         if ((error == ESTALE) && fs_need_estale_retry(estale_retry++))
1634                 goto top;
1635         return (error);
1636 }
1637 
1638 int
1639 vn_rename(char *from, char *to, enum uio_seg seg)
1640 {
1641         return (vn_renameat(NULL, from, NULL, to, seg));
1642 }
1643 
1644 int
1645 vn_renameat(vnode_t *fdvp, char *fname, vnode_t *tdvp,
1646                 char *tname, enum uio_seg seg)
1647 {
1648         int error;
1649         struct vattr vattr;
1650         struct pathname fpn;            /* from pathname */
1651         struct pathname tpn;            /* to pathname */
1652         dev_t fsid;
1653         int in_crit_src, in_crit_targ;
1654         vnode_t *fromvp, *fvp;
1655         vnode_t *tovp, *targvp;
1656         int estale_retry = 0;
1657         uint32_t auditing = AU_AUDITING();
1658 
1659 top:
1660         fvp = fromvp = tovp = targvp = NULL;
1661         in_crit_src = in_crit_targ = 0;
1662         /*
1663          * Get to and from pathnames.
1664          */
1665         if (error = pn_get(fname, seg, &fpn))
1666                 return (error);
1667         if (error = pn_get(tname, seg, &tpn)) {
1668                 pn_free(&fpn);
1669                 return (error);
1670         }
1671 
1672         /*
1673          * First we need to resolve the correct directories
1674          * The passed in directories may only be a starting point,
1675          * but we need the real directories the file(s) live in.
1676          * For example the fname may be something like usr/lib/sparc
1677          * and we were passed in the / directory, but we need to
1678          * use the lib directory for the rename.
1679          */
1680 
1681         if (auditing && fdvp != NULL)
1682                 audit_setfsat_path(1);
1683         /*
1684          * Lookup to and from directories.
1685          */
1686         if (error = lookuppnat(&fpn, NULL, NO_FOLLOW, &fromvp, &fvp, fdvp)) {
1687                 goto out;
1688         }
1689 
1690         /*
1691          * Make sure there is an entry.
1692          */
1693         if (fvp == NULL) {
1694                 error = ENOENT;
1695                 goto out;
1696         }
1697 
1698         if (auditing && tdvp != NULL)
1699                 audit_setfsat_path(3);
1700         if (error = lookuppnat(&tpn, NULL, NO_FOLLOW, &tovp, &targvp, tdvp)) {
1701                 goto out;
1702         }
1703 
1704         /*
1705          * Make sure both the from vnode directory and the to directory
1706          * are in the same vfs and the to directory is writable.
1707          * We check fsid's, not vfs pointers, so loopback fs works.
1708          */
1709         if (fromvp != tovp) {
1710                 vattr.va_mask = AT_FSID;
1711                 if (error = VOP_GETATTR(fromvp, &vattr, 0, CRED(), NULL))
1712                         goto out;
1713                 fsid = vattr.va_fsid;
1714                 vattr.va_mask = AT_FSID;
1715                 if (error = VOP_GETATTR(tovp, &vattr, 0, CRED(), NULL))
1716                         goto out;
1717                 if (fsid != vattr.va_fsid) {
1718                         error = EXDEV;
1719                         goto out;
1720                 }
1721         }
1722 
1723         if (tovp->v_vfsp->vfs_flag & VFS_RDONLY) {
1724                 error = EROFS;
1725                 goto out;
1726         }
1727 
1728         if (targvp && (fvp != targvp)) {
1729                 nbl_start_crit(targvp, RW_READER);
1730                 in_crit_targ = 1;
1731                 if (nbl_conflict(targvp, NBL_REMOVE, 0, 0, 0, NULL)) {
1732                         error = EACCES;
1733                         goto out;
1734                 }
1735         }
1736 
1737         if (nbl_need_check(fvp)) {
1738                 nbl_start_crit(fvp, RW_READER);
1739                 in_crit_src = 1;
1740                 if (nbl_conflict(fvp, NBL_RENAME, 0, 0, 0, NULL)) {
1741                         error = EACCES;
1742                         goto out;
1743                 }
1744         }
1745 
1746         /*
1747          * Do the rename.
1748          */
1749         (void) pn_fixslash(&tpn);
1750         error = VOP_RENAME(fromvp, fpn.pn_path, tovp, tpn.pn_path, CRED(),
1751             NULL, 0);
1752 
1753 out:
1754         pn_free(&fpn);
1755         pn_free(&tpn);
1756         if (in_crit_src)
1757                 nbl_end_crit(fvp);
1758         if (in_crit_targ)
1759                 nbl_end_crit(targvp);
1760         if (fromvp)
1761                 VN_RELE(fromvp);
1762         if (tovp)
1763                 VN_RELE(tovp);
1764         if (targvp)
1765                 VN_RELE(targvp);
1766         if (fvp)
1767                 VN_RELE(fvp);
1768         if ((error == ESTALE) && fs_need_estale_retry(estale_retry++))
1769                 goto top;
1770         return (error);
1771 }
1772 
1773 /*
1774  * Remove a file or directory.
1775  */
1776 int
1777 vn_remove(char *fnamep, enum uio_seg seg, enum rm dirflag)
1778 {
1779         return (vn_removeat(NULL, fnamep, seg, dirflag));
1780 }
1781 
1782 int
1783 vn_removeat(vnode_t *startvp, char *fnamep, enum uio_seg seg, enum rm dirflag)
1784 {
1785         struct vnode *vp;               /* entry vnode */
1786         struct vnode *dvp;              /* ptr to parent dir vnode */
1787         struct vnode *coveredvp;
1788         struct pathname pn;             /* name of entry */
1789         enum vtype vtype;
1790         int error;
1791         struct vfs *vfsp;
1792         struct vfs *dvfsp;      /* ptr to parent dir vfs */
1793         int in_crit = 0;
1794         int estale_retry = 0;
1795 
1796 top:
1797         if (error = pn_get(fnamep, seg, &pn))
1798                 return (error);
1799         dvp = vp = NULL;
1800         if (error = lookuppnat(&pn, NULL, NO_FOLLOW, &dvp, &vp, startvp)) {
1801                 pn_free(&pn);
1802                 if ((error == ESTALE) && fs_need_estale_retry(estale_retry++))
1803                         goto top;
1804                 return (error);
1805         }
1806 
1807         /*
1808          * Make sure there is an entry.
1809          */
1810         if (vp == NULL) {
1811                 error = ENOENT;
1812                 goto out;
1813         }
1814 
1815         vfsp = vp->v_vfsp;
1816         dvfsp = dvp->v_vfsp;
1817 
1818         /*
1819          * If the named file is the root of a mounted filesystem, fail,
1820          * unless it's marked unlinkable.  In that case, unmount the
1821          * filesystem and proceed to unlink the covered vnode.  (If the
1822          * covered vnode is a directory, use rmdir instead of unlink,
1823          * to avoid file system corruption.)
1824          */
1825         if (vp->v_flag & VROOT) {
1826                 if ((vfsp->vfs_flag & VFS_UNLINKABLE) == 0) {
1827                         error = EBUSY;
1828                         goto out;
1829                 }
1830 
1831                 /*
1832                  * Namefs specific code starts here.
1833                  */
1834 
1835                 if (dirflag == RMDIRECTORY) {
1836                         /*
1837                          * User called rmdir(2) on a file that has
1838                          * been namefs mounted on top of.  Since
1839                          * namefs doesn't allow directories to
1840                          * be mounted on other files we know
1841                          * vp is not of type VDIR so fail to operation.
1842                          */
1843                         error = ENOTDIR;
1844                         goto out;
1845                 }
1846 
1847                 /*
1848                  * If VROOT is still set after grabbing vp->v_lock,
1849                  * noone has finished nm_unmount so far and coveredvp
1850                  * is valid.
1851                  * If we manage to grab vn_vfswlock(coveredvp) before releasing
1852                  * vp->v_lock, any race window is eliminated.
1853                  */
1854 
1855                 mutex_enter(&vp->v_lock);
1856                 if ((vp->v_flag & VROOT) == 0) {
1857                         /* Someone beat us to the unmount */
1858                         mutex_exit(&vp->v_lock);
1859                         error = EBUSY;
1860                         goto out;
1861                 }
1862                 vfsp = vp->v_vfsp;
1863                 coveredvp = vfsp->vfs_vnodecovered;
1864                 ASSERT(coveredvp);
1865                 /*
1866                  * Note: Implementation of vn_vfswlock shows that ordering of
1867                  * v_lock / vn_vfswlock is not an issue here.
1868                  */
1869                 error = vn_vfswlock(coveredvp);
1870                 mutex_exit(&vp->v_lock);
1871 
1872                 if (error)
1873                         goto out;
1874 
1875                 VN_HOLD(coveredvp);
1876                 VN_RELE(vp);
1877                 error = dounmount(vfsp, 0, CRED());
1878 
1879                 /*
1880                  * Unmounted the namefs file system; now get
1881                  * the object it was mounted over.
1882                  */
1883                 vp = coveredvp;
1884                 /*
1885                  * If namefs was mounted over a directory, then
1886                  * we want to use rmdir() instead of unlink().
1887                  */
1888                 if (vp->v_type == VDIR)
1889                         dirflag = RMDIRECTORY;
1890 
1891                 if (error)
1892                         goto out;
1893         }
1894 
1895         /*
1896          * Make sure filesystem is writeable.
1897          * We check the parent directory's vfs in case this is an lofs vnode.
1898          */
1899         if (dvfsp && dvfsp->vfs_flag & VFS_RDONLY) {
1900                 error = EROFS;
1901                 goto out;
1902         }
1903 
1904         vtype = vp->v_type;
1905 
1906         /*
1907          * If there is the possibility of an nbmand share reservation, make
1908          * sure it's okay to remove the file.  Keep a reference to the
1909          * vnode, so that we can exit the nbl critical region after
1910          * calling VOP_REMOVE.
1911          * If there is no possibility of an nbmand share reservation,
1912          * release the vnode reference now.  Filesystems like NFS may
1913          * behave differently if there is an extra reference, so get rid of
1914          * this one.  Fortunately, we can't have nbmand mounts on NFS
1915          * filesystems.
1916          */
1917         if (nbl_need_check(vp)) {
1918                 nbl_start_crit(vp, RW_READER);
1919                 in_crit = 1;
1920                 if (nbl_conflict(vp, NBL_REMOVE, 0, 0, 0, NULL)) {
1921                         error = EACCES;
1922                         goto out;
1923                 }
1924         } else {
1925                 VN_RELE(vp);
1926                 vp = NULL;
1927         }
1928 
1929         if (dirflag == RMDIRECTORY) {
1930                 /*
1931                  * Caller is using rmdir(2), which can only be applied to
1932                  * directories.
1933                  */
1934                 if (vtype != VDIR) {
1935                         error = ENOTDIR;
1936                 } else {
1937                         vnode_t *cwd;
1938                         proc_t *pp = curproc;
1939 
1940                         mutex_enter(&pp->p_lock);
1941                         cwd = PTOU(pp)->u_cdir;
1942                         VN_HOLD(cwd);
1943                         mutex_exit(&pp->p_lock);
1944                         error = VOP_RMDIR(dvp, pn.pn_path, cwd, CRED(),
1945                             NULL, 0);
1946                         VN_RELE(cwd);
1947                 }
1948         } else {
1949                 /*
1950                  * Unlink(2) can be applied to anything.
1951                  */
1952                 error = VOP_REMOVE(dvp, pn.pn_path, CRED(), NULL, 0);
1953         }
1954 
1955 out:
1956         pn_free(&pn);
1957         if (in_crit) {
1958                 nbl_end_crit(vp);
1959                 in_crit = 0;
1960         }
1961         if (vp != NULL)
1962                 VN_RELE(vp);
1963         if (dvp != NULL)
1964                 VN_RELE(dvp);
1965         if ((error == ESTALE) && fs_need_estale_retry(estale_retry++))
1966                 goto top;
1967         return (error);
1968 }
1969 
1970 /*
1971  * Utility function to compare equality of vnodes.
1972  * Compare the underlying real vnodes, if there are underlying vnodes.
1973  * This is a more thorough comparison than the VN_CMP() macro provides.
1974  */
1975 int
1976 vn_compare(vnode_t *vp1, vnode_t *vp2)
1977 {
1978         vnode_t *realvp;
1979 
1980         if (vp1 != NULL && VOP_REALVP(vp1, &realvp, NULL) == 0)
1981                 vp1 = realvp;
1982         if (vp2 != NULL && VOP_REALVP(vp2, &realvp, NULL) == 0)
1983                 vp2 = realvp;
1984         return (VN_CMP(vp1, vp2));
1985 }
1986 
1987 /*
1988  * The number of locks to hash into.  This value must be a power
1989  * of 2 minus 1 and should probably also be prime.
1990  */
1991 #define NUM_BUCKETS     1023
1992 
1993 struct  vn_vfslocks_bucket {
1994         kmutex_t vb_lock;
1995         vn_vfslocks_entry_t *vb_list;
1996         char pad[64 - sizeof (kmutex_t) - sizeof (void *)];
1997 };
1998 
1999 /*
2000  * Total number of buckets will be NUM_BUCKETS + 1 .
2001  */
2002 
2003 #pragma align   64(vn_vfslocks_buckets)
2004 static  struct vn_vfslocks_bucket       vn_vfslocks_buckets[NUM_BUCKETS + 1];
2005 
2006 #define VN_VFSLOCKS_SHIFT       9
2007 
2008 #define VN_VFSLOCKS_HASH(vfsvpptr)      \
2009         ((((intptr_t)(vfsvpptr)) >> VN_VFSLOCKS_SHIFT) & NUM_BUCKETS)
2010 
2011 /*
2012  * vn_vfslocks_getlock() uses an HASH scheme to generate
2013  * rwstlock using vfs/vnode pointer passed to it.
2014  *
2015  * vn_vfslocks_rele() releases a reference in the
2016  * HASH table which allows the entry allocated by
2017  * vn_vfslocks_getlock() to be freed at a later
2018  * stage when the refcount drops to zero.
2019  */
2020 
2021 vn_vfslocks_entry_t *
2022 vn_vfslocks_getlock(void *vfsvpptr)
2023 {
2024         struct vn_vfslocks_bucket *bp;
2025         vn_vfslocks_entry_t *vep;
2026         vn_vfslocks_entry_t *tvep;
2027 
2028         ASSERT(vfsvpptr != NULL);
2029         bp = &vn_vfslocks_buckets[VN_VFSLOCKS_HASH(vfsvpptr)];
2030 
2031         mutex_enter(&bp->vb_lock);
2032         for (vep = bp->vb_list; vep != NULL; vep = vep->ve_next) {
2033                 if (vep->ve_vpvfs == vfsvpptr) {
2034                         vep->ve_refcnt++;
2035                         mutex_exit(&bp->vb_lock);
2036                         return (vep);
2037                 }
2038         }
2039         mutex_exit(&bp->vb_lock);
2040         vep = kmem_alloc(sizeof (*vep), KM_SLEEP);
2041         rwst_init(&vep->ve_lock, NULL, RW_DEFAULT, NULL);
2042         vep->ve_vpvfs = (char *)vfsvpptr;
2043         vep->ve_refcnt = 1;
2044         mutex_enter(&bp->vb_lock);
2045         for (tvep = bp->vb_list; tvep != NULL; tvep = tvep->ve_next) {
2046                 if (tvep->ve_vpvfs == vfsvpptr) {
2047                         tvep->ve_refcnt++;
2048                         mutex_exit(&bp->vb_lock);
2049 
2050                         /*
2051                          * There is already an entry in the hash
2052                          * destroy what we just allocated.
2053                          */
2054                         rwst_destroy(&vep->ve_lock);
2055                         kmem_free(vep, sizeof (*vep));
2056                         return (tvep);
2057                 }
2058         }
2059         vep->ve_next = bp->vb_list;
2060         bp->vb_list = vep;
2061         mutex_exit(&bp->vb_lock);
2062         return (vep);
2063 }
2064 
2065 void
2066 vn_vfslocks_rele(vn_vfslocks_entry_t *vepent)
2067 {
2068         struct vn_vfslocks_bucket *bp;
2069         vn_vfslocks_entry_t *vep;
2070         vn_vfslocks_entry_t *pvep;
2071 
2072         ASSERT(vepent != NULL);
2073         ASSERT(vepent->ve_vpvfs != NULL);
2074 
2075         bp = &vn_vfslocks_buckets[VN_VFSLOCKS_HASH(vepent->ve_vpvfs)];
2076 
2077         mutex_enter(&bp->vb_lock);
2078         vepent->ve_refcnt--;
2079 
2080         if ((int32_t)vepent->ve_refcnt < 0)
2081                 cmn_err(CE_PANIC, "vn_vfslocks_rele: refcount negative");
2082 
2083         if (vepent->ve_refcnt == 0) {
2084                 for (vep = bp->vb_list; vep != NULL; vep = vep->ve_next) {
2085                         if (vep->ve_vpvfs == vepent->ve_vpvfs) {
2086                                 if (bp->vb_list == vep)
2087                                         bp->vb_list = vep->ve_next;
2088                                 else {
2089                                         /* LINTED */
2090                                         pvep->ve_next = vep->ve_next;
2091                                 }
2092                                 mutex_exit(&bp->vb_lock);
2093                                 rwst_destroy(&vep->ve_lock);
2094                                 kmem_free(vep, sizeof (*vep));
2095                                 return;
2096                         }
2097                         pvep = vep;
2098                 }
2099                 cmn_err(CE_PANIC, "vn_vfslocks_rele: vp/vfs not found");
2100         }
2101         mutex_exit(&bp->vb_lock);
2102 }
2103 
2104 /*
2105  * vn_vfswlock_wait is used to implement a lock which is logically a writers
2106  * lock protecting the v_vfsmountedhere field.
2107  * vn_vfswlock_wait has been modified to be similar to vn_vfswlock,
2108  * except that it blocks to acquire the lock VVFSLOCK.
2109  *
2110  * traverse() and routines re-implementing part of traverse (e.g. autofs)
2111  * need to hold this lock. mount(), vn_rename(), vn_remove() and so on
2112  * need the non-blocking version of the writers lock i.e. vn_vfswlock
2113  */
2114 int
2115 vn_vfswlock_wait(vnode_t *vp)
2116 {
2117         int retval;
2118         vn_vfslocks_entry_t *vpvfsentry;
2119         ASSERT(vp != NULL);
2120 
2121         vpvfsentry = vn_vfslocks_getlock(vp);
2122         retval = rwst_enter_sig(&vpvfsentry->ve_lock, RW_WRITER);
2123 
2124         if (retval == EINTR) {
2125                 vn_vfslocks_rele(vpvfsentry);
2126                 return (EINTR);
2127         }
2128         return (retval);
2129 }
2130 
2131 int
2132 vn_vfsrlock_wait(vnode_t *vp)
2133 {
2134         int retval;
2135         vn_vfslocks_entry_t *vpvfsentry;
2136         ASSERT(vp != NULL);
2137 
2138         vpvfsentry = vn_vfslocks_getlock(vp);
2139         retval = rwst_enter_sig(&vpvfsentry->ve_lock, RW_READER);
2140 
2141         if (retval == EINTR) {
2142                 vn_vfslocks_rele(vpvfsentry);
2143                 return (EINTR);
2144         }
2145 
2146         return (retval);
2147 }
2148 
2149 
2150 /*
2151  * vn_vfswlock is used to implement a lock which is logically a writers lock
2152  * protecting the v_vfsmountedhere field.
2153  */
2154 int
2155 vn_vfswlock(vnode_t *vp)
2156 {
2157         vn_vfslocks_entry_t *vpvfsentry;
2158 
2159         /*
2160          * If vp is NULL then somebody is trying to lock the covered vnode
2161          * of /.  (vfs_vnodecovered is NULL for /).  This situation will
2162          * only happen when unmounting /.  Since that operation will fail
2163          * anyway, return EBUSY here instead of in VFS_UNMOUNT.
2164          */
2165         if (vp == NULL)
2166                 return (EBUSY);
2167 
2168         vpvfsentry = vn_vfslocks_getlock(vp);
2169 
2170         if (rwst_tryenter(&vpvfsentry->ve_lock, RW_WRITER))
2171                 return (0);
2172 
2173         vn_vfslocks_rele(vpvfsentry);
2174         return (EBUSY);
2175 }
2176 
2177 int
2178 vn_vfsrlock(vnode_t *vp)
2179 {
2180         vn_vfslocks_entry_t *vpvfsentry;
2181 
2182         /*
2183          * If vp is NULL then somebody is trying to lock the covered vnode
2184          * of /.  (vfs_vnodecovered is NULL for /).  This situation will
2185          * only happen when unmounting /.  Since that operation will fail
2186          * anyway, return EBUSY here instead of in VFS_UNMOUNT.
2187          */
2188         if (vp == NULL)
2189                 return (EBUSY);
2190 
2191         vpvfsentry = vn_vfslocks_getlock(vp);
2192 
2193         if (rwst_tryenter(&vpvfsentry->ve_lock, RW_READER))
2194                 return (0);
2195 
2196         vn_vfslocks_rele(vpvfsentry);
2197         return (EBUSY);
2198 }
2199 
2200 void
2201 vn_vfsunlock(vnode_t *vp)
2202 {
2203         vn_vfslocks_entry_t *vpvfsentry;
2204 
2205         /*
2206          * ve_refcnt needs to be decremented twice.
2207          * 1. To release refernce after a call to vn_vfslocks_getlock()
2208          * 2. To release the reference from the locking routines like
2209          *    vn_vfsrlock/vn_vfswlock etc,.
2210          */
2211         vpvfsentry = vn_vfslocks_getlock(vp);
2212         vn_vfslocks_rele(vpvfsentry);
2213 
2214         rwst_exit(&vpvfsentry->ve_lock);
2215         vn_vfslocks_rele(vpvfsentry);
2216 }
2217 
2218 int
2219 vn_vfswlock_held(vnode_t *vp)
2220 {
2221         int held;
2222         vn_vfslocks_entry_t *vpvfsentry;
2223 
2224         ASSERT(vp != NULL);
2225 
2226         vpvfsentry = vn_vfslocks_getlock(vp);
2227         held = rwst_lock_held(&vpvfsentry->ve_lock, RW_WRITER);
2228 
2229         vn_vfslocks_rele(vpvfsentry);
2230         return (held);
2231 }
2232 
2233 
2234 int
2235 vn_make_ops(
2236         const char *name,                       /* Name of file system */
2237         const fs_operation_def_t *templ,        /* Operation specification */
2238         vnodeops_t **actual)                    /* Return the vnodeops */
2239 {
2240         int unused_ops;
2241         int error;
2242 
2243         *actual = (vnodeops_t *)kmem_alloc(sizeof (vnodeops_t), KM_SLEEP);
2244 
2245         (*actual)->vnop_name = name;
2246 
2247         error = fs_build_vector(*actual, &unused_ops, vn_ops_table, templ);
2248         if (error) {
2249                 kmem_free(*actual, sizeof (vnodeops_t));
2250         }
2251 
2252 #if DEBUG
2253         if (unused_ops != 0)
2254                 cmn_err(CE_WARN, "vn_make_ops: %s: %d operations supplied "
2255                     "but not used", name, unused_ops);
2256 #endif
2257 
2258         return (error);
2259 }
2260 
2261 /*
2262  * Free the vnodeops created as a result of vn_make_ops()
2263  */
2264 void
2265 vn_freevnodeops(vnodeops_t *vnops)
2266 {
2267         kmem_free(vnops, sizeof (vnodeops_t));
2268 }
2269 
2270 /*
2271  * Vnode cache.
2272  */
2273 
2274 /* ARGSUSED */
2275 static int
2276 vn_cache_constructor(void *buf, void *cdrarg, int kmflags)
2277 {
2278         struct vnode *vp;
2279 
2280         vp = buf;
2281 
2282         mutex_init(&vp->v_lock, NULL, MUTEX_DEFAULT, NULL);
2283         mutex_init(&vp->v_vsd_lock, NULL, MUTEX_DEFAULT, NULL);
2284         cv_init(&vp->v_cv, NULL, CV_DEFAULT, NULL);
2285         rw_init(&vp->v_nbllock, NULL, RW_DEFAULT, NULL);
2286         vp->v_femhead = NULL;        /* Must be done before vn_reinit() */
2287         vp->v_path = NULL;
2288         vp->v_mpssdata = NULL;
2289         vp->v_vsd = NULL;
2290         vp->v_fopdata = NULL;
2291 
2292         return (0);
2293 }
2294 
2295 /* ARGSUSED */
2296 static void
2297 vn_cache_destructor(void *buf, void *cdrarg)
2298 {
2299         struct vnode *vp;
2300 
2301         vp = buf;
2302 
2303         rw_destroy(&vp->v_nbllock);
2304         cv_destroy(&vp->v_cv);
2305         mutex_destroy(&vp->v_vsd_lock);
2306         mutex_destroy(&vp->v_lock);
2307 }
2308 
2309 void
2310 vn_create_cache(void)
2311 {
2312         /* LINTED */
2313         ASSERT((1 << VNODE_ALIGN_LOG2) ==
2314             P2ROUNDUP(sizeof (struct vnode), VNODE_ALIGN));
2315         vn_cache = kmem_cache_create("vn_cache", sizeof (struct vnode),
2316             VNODE_ALIGN, vn_cache_constructor, vn_cache_destructor, NULL, NULL,
2317             NULL, 0);
2318 }
2319 
2320 void
2321 vn_destroy_cache(void)
2322 {
2323         kmem_cache_destroy(vn_cache);
2324 }
2325 
2326 /*
2327  * Used by file systems when fs-specific nodes (e.g., ufs inodes) are
2328  * cached by the file system and vnodes remain associated.
2329  */
2330 void
2331 vn_recycle(vnode_t *vp)
2332 {
2333         ASSERT(vp->v_pages == NULL);
2334 
2335         /*
2336          * XXX - This really belongs in vn_reinit(), but we have some issues
2337          * with the counts.  Best to have it here for clean initialization.
2338          */
2339         vp->v_rdcnt = 0;
2340         vp->v_wrcnt = 0;
2341         vp->v_mmap_read = 0;
2342         vp->v_mmap_write = 0;
2343 
2344         /*
2345          * If FEM was in use, make sure everything gets cleaned up
2346          * NOTE: vp->v_femhead is initialized to NULL in the vnode
2347          * constructor.
2348          */
2349         if (vp->v_femhead) {
2350                 /* XXX - There should be a free_femhead() that does all this */
2351                 ASSERT(vp->v_femhead->femh_list == NULL);
2352                 mutex_destroy(&vp->v_femhead->femh_lock);
2353                 kmem_free(vp->v_femhead, sizeof (*(vp->v_femhead)));
2354                 vp->v_femhead = NULL;
2355         }
2356         if (vp->v_path) {
2357                 kmem_free(vp->v_path, strlen(vp->v_path) + 1);
2358                 vp->v_path = NULL;
2359         }
2360 
2361         if (vp->v_fopdata != NULL) {
2362                 free_fopdata(vp);
2363         }
2364         vp->v_mpssdata = NULL;
2365         vsd_free(vp);
2366 }
2367 
2368 /*
2369  * Used to reset the vnode fields including those that are directly accessible
2370  * as well as those which require an accessor function.
2371  *
2372  * Does not initialize:
2373  *      synchronization objects: v_lock, v_vsd_lock, v_nbllock, v_cv
2374  *      v_data (since FS-nodes and vnodes point to each other and should
2375  *              be updated simultaneously)
2376  *      v_op (in case someone needs to make a VOP call on this object)
2377  */
2378 void
2379 vn_reinit(vnode_t *vp)
2380 {
2381         vp->v_count = 1;
2382         vp->v_count_dnlc = 0;
2383         vp->v_vfsp = NULL;
2384         vp->v_stream = NULL;
2385         vp->v_vfsmountedhere = NULL;
2386         vp->v_flag = 0;
2387         vp->v_type = VNON;
2388         vp->v_rdev = NODEV;
2389 
2390         vp->v_filocks = NULL;
2391         vp->v_shrlocks = NULL;
2392         vp->v_pages = NULL;
2393 
2394         vp->v_locality = NULL;
2395         vp->v_xattrdir = NULL;
2396 
2397         /* Handles v_femhead, v_path, and the r/w/map counts */
2398         vn_recycle(vp);
2399 }
2400 
2401 vnode_t *
2402 vn_alloc(int kmflag)
2403 {
2404         vnode_t *vp;
2405 
2406         vp = kmem_cache_alloc(vn_cache, kmflag);
2407 
2408         if (vp != NULL) {
2409                 vp->v_femhead = NULL;        /* Must be done before vn_reinit() */
2410                 vp->v_fopdata = NULL;
2411                 vn_reinit(vp);
2412         }
2413 
2414         return (vp);
2415 }
2416 
2417 void
2418 vn_free(vnode_t *vp)
2419 {
2420         ASSERT(vp->v_shrlocks == NULL);
2421         ASSERT(vp->v_filocks == NULL);
2422 
2423         /*
2424          * Some file systems call vn_free() with v_count of zero,
2425          * some with v_count of 1.  In any case, the value should
2426          * never be anything else.
2427          */
2428         ASSERT((vp->v_count == 0) || (vp->v_count == 1));
2429         ASSERT(vp->v_count_dnlc == 0);
2430         if (vp->v_path != NULL) {
2431                 kmem_free(vp->v_path, strlen(vp->v_path) + 1);
2432                 vp->v_path = NULL;
2433         }
2434 
2435         /* If FEM was in use, make sure everything gets cleaned up */
2436         if (vp->v_femhead) {
2437                 /* XXX - There should be a free_femhead() that does all this */
2438                 ASSERT(vp->v_femhead->femh_list == NULL);
2439                 mutex_destroy(&vp->v_femhead->femh_lock);
2440                 kmem_free(vp->v_femhead, sizeof (*(vp->v_femhead)));
2441                 vp->v_femhead = NULL;
2442         }
2443 
2444         if (vp->v_fopdata != NULL) {
2445                 free_fopdata(vp);
2446         }
2447         vp->v_mpssdata = NULL;
2448         vsd_free(vp);
2449         kmem_cache_free(vn_cache, vp);
2450 }
2451 
2452 /*
2453  * vnode status changes, should define better states than 1, 0.
2454  */
2455 void
2456 vn_reclaim(vnode_t *vp)
2457 {
2458         vfs_t   *vfsp = vp->v_vfsp;
2459 
2460         if (vfsp == NULL ||
2461             vfsp->vfs_implp == NULL || vfsp->vfs_femhead == NULL) {
2462                 return;
2463         }
2464         (void) VFS_VNSTATE(vfsp, vp, VNTRANS_RECLAIMED);
2465 }
2466 
2467 void
2468 vn_idle(vnode_t *vp)
2469 {
2470         vfs_t   *vfsp = vp->v_vfsp;
2471 
2472         if (vfsp == NULL ||
2473             vfsp->vfs_implp == NULL || vfsp->vfs_femhead == NULL) {
2474                 return;
2475         }
2476         (void) VFS_VNSTATE(vfsp, vp, VNTRANS_IDLED);
2477 }
2478 void
2479 vn_exists(vnode_t *vp)
2480 {
2481         vfs_t   *vfsp = vp->v_vfsp;
2482 
2483         if (vfsp == NULL ||
2484             vfsp->vfs_implp == NULL || vfsp->vfs_femhead == NULL) {
2485                 return;
2486         }
2487         (void) VFS_VNSTATE(vfsp, vp, VNTRANS_EXISTS);
2488 }
2489 
2490 void
2491 vn_invalid(vnode_t *vp)
2492 {
2493         vfs_t   *vfsp = vp->v_vfsp;
2494 
2495         if (vfsp == NULL ||
2496             vfsp->vfs_implp == NULL || vfsp->vfs_femhead == NULL) {
2497                 return;
2498         }
2499         (void) VFS_VNSTATE(vfsp, vp, VNTRANS_DESTROYED);
2500 }
2501 
2502 /* Vnode event notification */
2503 
2504 int
2505 vnevent_support(vnode_t *vp, caller_context_t *ct)
2506 {
2507         if (vp == NULL)
2508                 return (EINVAL);
2509 
2510         return (VOP_VNEVENT(vp, VE_SUPPORT, NULL, NULL, ct));
2511 }
2512 
2513 void
2514 vnevent_rename_src(vnode_t *vp, vnode_t *dvp, char *name, caller_context_t *ct)
2515 {
2516         if (vp == NULL || vp->v_femhead == NULL) {
2517                 return;
2518         }
2519         (void) VOP_VNEVENT(vp, VE_RENAME_SRC, dvp, name, ct);
2520 }
2521 
2522 void
2523 vnevent_rename_dest(vnode_t *vp, vnode_t *dvp, char *name,
2524     caller_context_t *ct)
2525 {
2526         if (vp == NULL || vp->v_femhead == NULL) {
2527                 return;
2528         }
2529         (void) VOP_VNEVENT(vp, VE_RENAME_DEST, dvp, name, ct);
2530 }
2531 
2532 void
2533 vnevent_rename_dest_dir(vnode_t *vp, caller_context_t *ct)
2534 {
2535         if (vp == NULL || vp->v_femhead == NULL) {
2536                 return;
2537         }
2538         (void) VOP_VNEVENT(vp, VE_RENAME_DEST_DIR, NULL, NULL, ct);
2539 }
2540 
2541 void
2542 vnevent_remove(vnode_t *vp, vnode_t *dvp, char *name, caller_context_t *ct)
2543 {
2544         if (vp == NULL || vp->v_femhead == NULL) {
2545                 return;
2546         }
2547         (void) VOP_VNEVENT(vp, VE_REMOVE, dvp, name, ct);
2548 }
2549 
2550 void
2551 vnevent_rmdir(vnode_t *vp, vnode_t *dvp, char *name, caller_context_t *ct)
2552 {
2553         if (vp == NULL || vp->v_femhead == NULL) {
2554                 return;
2555         }
2556         (void) VOP_VNEVENT(vp, VE_RMDIR, dvp, name, ct);
2557 }
2558 
2559 void
2560 vnevent_create(vnode_t *vp, caller_context_t *ct)
2561 {
2562         if (vp == NULL || vp->v_femhead == NULL) {
2563                 return;
2564         }
2565         (void) VOP_VNEVENT(vp, VE_CREATE, NULL, NULL, ct);
2566 }
2567 
2568 void
2569 vnevent_link(vnode_t *vp, caller_context_t *ct)
2570 {
2571         if (vp == NULL || vp->v_femhead == NULL) {
2572                 return;
2573         }
2574         (void) VOP_VNEVENT(vp, VE_LINK, NULL, NULL, ct);
2575 }
2576 
2577 void
2578 vnevent_mountedover(vnode_t *vp, caller_context_t *ct)
2579 {
2580         if (vp == NULL || vp->v_femhead == NULL) {
2581                 return;
2582         }
2583         (void) VOP_VNEVENT(vp, VE_MOUNTEDOVER, NULL, NULL, ct);
2584 }
2585 
2586 void
2587 vnevent_truncate(vnode_t *vp, caller_context_t *ct)
2588 {
2589         if (vp == NULL || vp->v_femhead == NULL) {
2590                 return;
2591         }
2592         (void) VOP_VNEVENT(vp, VE_TRUNCATE, NULL, NULL, ct);
2593 }
2594 
2595 /*
2596  * Vnode accessors.
2597  */
2598 
2599 int
2600 vn_is_readonly(vnode_t *vp)
2601 {
2602         return (vp->v_vfsp->vfs_flag & VFS_RDONLY);
2603 }
2604 
2605 int
2606 vn_has_flocks(vnode_t *vp)
2607 {
2608         return (vp->v_filocks != NULL);
2609 }
2610 
2611 int
2612 vn_has_mandatory_locks(vnode_t *vp, int mode)
2613 {
2614         return ((vp->v_filocks != NULL) && (MANDLOCK(vp, mode)));
2615 }
2616 
2617 int
2618 vn_has_cached_data(vnode_t *vp)
2619 {
2620         return (vp->v_pages != NULL);
2621 }
2622 
2623 /*
2624  * Return 0 if the vnode in question shouldn't be permitted into a zone via
2625  * zone_enter(2).
2626  */
2627 int
2628 vn_can_change_zones(vnode_t *vp)
2629 {
2630         struct vfssw *vswp;
2631         int allow = 1;
2632         vnode_t *rvp;
2633 
2634         if (nfs_global_client_only != 0)
2635                 return (1);
2636 
2637         /*
2638          * We always want to look at the underlying vnode if there is one.
2639          */
2640         if (VOP_REALVP(vp, &rvp, NULL) != 0)
2641                 rvp = vp;
2642         /*
2643          * Some pseudo filesystems (including doorfs) don't actually register
2644          * their vfsops_t, so the following may return NULL; we happily let
2645          * such vnodes switch zones.
2646          */
2647         vswp = vfs_getvfsswbyvfsops(vfs_getops(rvp->v_vfsp));
2648         if (vswp != NULL) {
2649                 if (vswp->vsw_flag & VSW_NOTZONESAFE)
2650                         allow = 0;
2651                 vfs_unrefvfssw(vswp);
2652         }
2653         return (allow);
2654 }
2655 
2656 /*
2657  * Return nonzero if the vnode is a mount point, zero if not.
2658  */
2659 int
2660 vn_ismntpt(vnode_t *vp)
2661 {
2662         return (vp->v_vfsmountedhere != NULL);
2663 }
2664 
2665 /* Retrieve the vfs (if any) mounted on this vnode */
2666 vfs_t *
2667 vn_mountedvfs(vnode_t *vp)
2668 {
2669         return (vp->v_vfsmountedhere);
2670 }
2671 
2672 /*
2673  * Return nonzero if the vnode is referenced by the dnlc, zero if not.
2674  */
2675 int
2676 vn_in_dnlc(vnode_t *vp)
2677 {
2678         return (vp->v_count_dnlc > 0);
2679 }
2680 
2681 /*
2682  * vn_has_other_opens() checks whether a particular file is opened by more than
2683  * just the caller and whether the open is for read and/or write.
2684  * This routine is for calling after the caller has already called VOP_OPEN()
2685  * and the caller wishes to know if they are the only one with it open for
2686  * the mode(s) specified.
2687  *
2688  * Vnode counts are only kept on regular files (v_type=VREG).
2689  */
2690 int
2691 vn_has_other_opens(
2692         vnode_t *vp,
2693         v_mode_t mode)
2694 {
2695 
2696         ASSERT(vp != NULL);
2697 
2698         switch (mode) {
2699         case V_WRITE:
2700                 if (vp->v_wrcnt > 1)
2701                         return (V_TRUE);
2702                 break;
2703         case V_RDORWR:
2704                 if ((vp->v_rdcnt > 1) || (vp->v_wrcnt > 1))
2705                         return (V_TRUE);
2706                 break;
2707         case V_RDANDWR:
2708                 if ((vp->v_rdcnt > 1) && (vp->v_wrcnt > 1))
2709                         return (V_TRUE);
2710                 break;
2711         case V_READ:
2712                 if (vp->v_rdcnt > 1)
2713                         return (V_TRUE);
2714                 break;
2715         }
2716 
2717         return (V_FALSE);
2718 }
2719 
2720 /*
2721  * vn_is_opened() checks whether a particular file is opened and
2722  * whether the open is for read and/or write.
2723  *
2724  * Vnode counts are only kept on regular files (v_type=VREG).
2725  */
2726 int
2727 vn_is_opened(
2728         vnode_t *vp,
2729         v_mode_t mode)
2730 {
2731 
2732         ASSERT(vp != NULL);
2733 
2734         switch (mode) {
2735         case V_WRITE:
2736                 if (vp->v_wrcnt)
2737                         return (V_TRUE);
2738                 break;
2739         case V_RDANDWR:
2740                 if (vp->v_rdcnt && vp->v_wrcnt)
2741                         return (V_TRUE);
2742                 break;
2743         case V_RDORWR:
2744                 if (vp->v_rdcnt || vp->v_wrcnt)
2745                         return (V_TRUE);
2746                 break;
2747         case V_READ:
2748                 if (vp->v_rdcnt)
2749                         return (V_TRUE);
2750                 break;
2751         }
2752 
2753         return (V_FALSE);
2754 }
2755 
2756 /*
2757  * vn_is_mapped() checks whether a particular file is mapped and whether
2758  * the file is mapped read and/or write.
2759  */
2760 int
2761 vn_is_mapped(
2762         vnode_t *vp,
2763         v_mode_t mode)
2764 {
2765 
2766         ASSERT(vp != NULL);
2767 
2768 #if !defined(_LP64)
2769         switch (mode) {
2770         /*
2771          * The atomic_add_64_nv functions force atomicity in the
2772          * case of 32 bit architectures. Otherwise the 64 bit values
2773          * require two fetches. The value of the fields may be
2774          * (potentially) changed between the first fetch and the
2775          * second
2776          */
2777         case V_WRITE:
2778                 if (atomic_add_64_nv((&(vp->v_mmap_write)), 0))
2779                         return (V_TRUE);
2780                 break;
2781         case V_RDANDWR:
2782                 if ((atomic_add_64_nv((&(vp->v_mmap_read)), 0)) &&
2783                     (atomic_add_64_nv((&(vp->v_mmap_write)), 0)))
2784                         return (V_TRUE);
2785                 break;
2786         case V_RDORWR:
2787                 if ((atomic_add_64_nv((&(vp->v_mmap_read)), 0)) ||
2788                     (atomic_add_64_nv((&(vp->v_mmap_write)), 0)))
2789                         return (V_TRUE);
2790                 break;
2791         case V_READ:
2792                 if (atomic_add_64_nv((&(vp->v_mmap_read)), 0))
2793                         return (V_TRUE);
2794                 break;
2795         }
2796 #else
2797         switch (mode) {
2798         case V_WRITE:
2799                 if (vp->v_mmap_write)
2800                         return (V_TRUE);
2801                 break;
2802         case V_RDANDWR:
2803                 if (vp->v_mmap_read && vp->v_mmap_write)
2804                         return (V_TRUE);
2805                 break;
2806         case V_RDORWR:
2807                 if (vp->v_mmap_read || vp->v_mmap_write)
2808                         return (V_TRUE);
2809                 break;
2810         case V_READ:
2811                 if (vp->v_mmap_read)
2812                         return (V_TRUE);
2813                 break;
2814         }
2815 #endif
2816 
2817         return (V_FALSE);
2818 }
2819 
2820 /*
2821  * Set the operations vector for a vnode.
2822  *
2823  * FEM ensures that the v_femhead pointer is filled in before the
2824  * v_op pointer is changed.  This means that if the v_femhead pointer
2825  * is NULL, and the v_op field hasn't changed since before which checked
2826  * the v_femhead pointer; then our update is ok - we are not racing with
2827  * FEM.
2828  */
2829 void
2830 vn_setops(vnode_t *vp, vnodeops_t *vnodeops)
2831 {
2832         vnodeops_t      *op;
2833 
2834         ASSERT(vp != NULL);
2835         ASSERT(vnodeops != NULL);
2836 
2837         op = vp->v_op;
2838         membar_consumer();
2839         /*
2840          * If vp->v_femhead == NULL, then we'll call atomic_cas_ptr() to do
2841          * the compare-and-swap on vp->v_op.  If either fails, then FEM is
2842          * in effect on the vnode and we need to have FEM deal with it.
2843          */
2844         if (vp->v_femhead != NULL || atomic_cas_ptr(&vp->v_op, op, vnodeops) !=
2845             op) {
2846                 fem_setvnops(vp, vnodeops);
2847         }
2848 }
2849 
2850 /*
2851  * Retrieve the operations vector for a vnode
2852  * As with vn_setops(above); make sure we aren't racing with FEM.
2853  * FEM sets the v_op to a special, internal, vnodeops that wouldn't
2854  * make sense to the callers of this routine.
2855  */
2856 vnodeops_t *
2857 vn_getops(vnode_t *vp)
2858 {
2859         vnodeops_t      *op;
2860 
2861         ASSERT(vp != NULL);
2862 
2863         op = vp->v_op;
2864         membar_consumer();
2865         if (vp->v_femhead == NULL && op == vp->v_op) {
2866                 return (op);
2867         } else {
2868                 return (fem_getvnops(vp));
2869         }
2870 }
2871 
2872 /*
2873  * Returns non-zero (1) if the vnodeops matches that of the vnode.
2874  * Returns zero (0) if not.
2875  */
2876 int
2877 vn_matchops(vnode_t *vp, vnodeops_t *vnodeops)
2878 {
2879         return (vn_getops(vp) == vnodeops);
2880 }
2881 
2882 /*
2883  * Returns non-zero (1) if the specified operation matches the
2884  * corresponding operation for that the vnode.
2885  * Returns zero (0) if not.
2886  */
2887 
2888 #define MATCHNAME(n1, n2) (((n1)[0] == (n2)[0]) && (strcmp((n1), (n2)) == 0))
2889 
2890 int
2891 vn_matchopval(vnode_t *vp, char *vopname, fs_generic_func_p funcp)
2892 {
2893         const fs_operation_trans_def_t *otdp;
2894         fs_generic_func_p *loc = NULL;
2895         vnodeops_t      *vop = vn_getops(vp);
2896 
2897         ASSERT(vopname != NULL);
2898 
2899         for (otdp = vn_ops_table; otdp->name != NULL; otdp++) {
2900                 if (MATCHNAME(otdp->name, vopname)) {
2901                         loc = (fs_generic_func_p *)
2902                             ((char *)(vop) + otdp->offset);
2903                         break;
2904                 }
2905         }
2906 
2907         return ((loc != NULL) && (*loc == funcp));
2908 }
2909 
2910 /*
2911  * fs_new_caller_id() needs to return a unique ID on a given local system.
2912  * The IDs do not need to survive across reboots.  These are primarily
2913  * used so that (FEM) monitors can detect particular callers (such as
2914  * the NFS server) to a given vnode/vfs operation.
2915  */
2916 u_longlong_t
2917 fs_new_caller_id()
2918 {
2919         static uint64_t next_caller_id = 0LL; /* First call returns 1 */
2920 
2921         return ((u_longlong_t)atomic_add_64_nv(&next_caller_id, 1));
2922 }
2923 
2924 /*
2925  * Given a starting vnode and a path, updates the path in the target vnode in
2926  * a safe manner.  If the vnode already has path information embedded, then the
2927  * cached path is left untouched.
2928  */
2929 
2930 size_t max_vnode_path = 4 * MAXPATHLEN;
2931 
2932 void
2933 vn_setpath(vnode_t *rootvp, struct vnode *startvp, struct vnode *vp,
2934     const char *path, size_t plen)
2935 {
2936         char    *rpath;
2937         vnode_t *base;
2938         size_t  rpathlen, rpathalloc;
2939         int     doslash = 1;
2940 
2941         if (*path == '/') {
2942                 base = rootvp;
2943                 path++;
2944                 plen--;
2945         } else {
2946                 base = startvp;
2947         }
2948 
2949         /*
2950          * We cannot grab base->v_lock while we hold vp->v_lock because of
2951          * the potential for deadlock.
2952          */
2953         mutex_enter(&base->v_lock);
2954         if (base->v_path == NULL) {
2955                 mutex_exit(&base->v_lock);
2956                 return;
2957         }
2958 
2959         rpathlen = strlen(base->v_path);
2960         rpathalloc = rpathlen + plen + 1;
2961         /* Avoid adding a slash if there's already one there */
2962         if (base->v_path[rpathlen-1] == '/')
2963                 doslash = 0;
2964         else
2965                 rpathalloc++;
2966 
2967         /*
2968          * We don't want to call kmem_alloc(KM_SLEEP) with kernel locks held,
2969          * so we must do this dance.  If, by chance, something changes the path,
2970          * just give up since there is no real harm.
2971          */
2972         mutex_exit(&base->v_lock);
2973 
2974         /* Paths should stay within reason */
2975         if (rpathalloc > max_vnode_path)
2976                 return;
2977 
2978         rpath = kmem_alloc(rpathalloc, KM_SLEEP);
2979 
2980         mutex_enter(&base->v_lock);
2981         if (base->v_path == NULL || strlen(base->v_path) != rpathlen) {
2982                 mutex_exit(&base->v_lock);
2983                 kmem_free(rpath, rpathalloc);
2984                 return;
2985         }
2986         bcopy(base->v_path, rpath, rpathlen);
2987         mutex_exit(&base->v_lock);
2988 
2989         if (doslash)
2990                 rpath[rpathlen++] = '/';
2991         bcopy(path, rpath + rpathlen, plen);
2992         rpath[rpathlen + plen] = '\0';
2993 
2994         mutex_enter(&vp->v_lock);
2995         if (vp->v_path != NULL) {
2996                 mutex_exit(&vp->v_lock);
2997                 kmem_free(rpath, rpathalloc);
2998         } else {
2999                 vp->v_path = rpath;
3000                 mutex_exit(&vp->v_lock);
3001         }
3002 }
3003 
3004 /*
3005  * Sets the path to the vnode to be the given string, regardless of current
3006  * context.  The string must be a complete path from rootdir.  This is only used
3007  * by fsop_root() for setting the path based on the mountpoint.
3008  */
3009 void
3010 vn_setpath_str(struct vnode *vp, const char *str, size_t len)
3011 {
3012         char *buf = kmem_alloc(len + 1, KM_SLEEP);
3013 
3014         mutex_enter(&vp->v_lock);
3015         if (vp->v_path != NULL) {
3016                 mutex_exit(&vp->v_lock);
3017                 kmem_free(buf, len + 1);
3018                 return;
3019         }
3020 
3021         vp->v_path = buf;
3022         bcopy(str, vp->v_path, len);
3023         vp->v_path[len] = '\0';
3024 
3025         mutex_exit(&vp->v_lock);
3026 }
3027 
3028 /*
3029  * Called from within filesystem's vop_rename() to handle renames once the
3030  * target vnode is available.
3031  */
3032 void
3033 vn_renamepath(vnode_t *dvp, vnode_t *vp, const char *nm, size_t len)
3034 {
3035         char *tmp;
3036 
3037         mutex_enter(&vp->v_lock);
3038         tmp = vp->v_path;
3039         vp->v_path = NULL;
3040         mutex_exit(&vp->v_lock);
3041         vn_setpath(rootdir, dvp, vp, nm, len);
3042         if (tmp != NULL)
3043                 kmem_free(tmp, strlen(tmp) + 1);
3044 }
3045 
3046 /*
3047  * Similar to vn_setpath_str(), this function sets the path of the destination
3048  * vnode to the be the same as the source vnode.
3049  */
3050 void
3051 vn_copypath(struct vnode *src, struct vnode *dst)
3052 {
3053         char *buf;
3054         int alloc;
3055 
3056         mutex_enter(&src->v_lock);
3057         if (src->v_path == NULL) {
3058                 mutex_exit(&src->v_lock);
3059                 return;
3060         }
3061         alloc = strlen(src->v_path) + 1;
3062 
3063         /* avoid kmem_alloc() with lock held */
3064         mutex_exit(&src->v_lock);
3065         buf = kmem_alloc(alloc, KM_SLEEP);
3066         mutex_enter(&src->v_lock);
3067         if (src->v_path == NULL || strlen(src->v_path) + 1 != alloc) {
3068                 mutex_exit(&src->v_lock);
3069                 kmem_free(buf, alloc);
3070                 return;
3071         }
3072         bcopy(src->v_path, buf, alloc);
3073         mutex_exit(&src->v_lock);
3074 
3075         mutex_enter(&dst->v_lock);
3076         if (dst->v_path != NULL) {
3077                 mutex_exit(&dst->v_lock);
3078                 kmem_free(buf, alloc);
3079                 return;
3080         }
3081         dst->v_path = buf;
3082         mutex_exit(&dst->v_lock);
3083 }
3084 
3085 /*
3086  * XXX Private interface for segvn routines that handle vnode
3087  * large page segments.
3088  *
3089  * return 1 if vp's file system VOP_PAGEIO() implementation
3090  * can be safely used instead of VOP_GETPAGE() for handling
3091  * pagefaults against regular non swap files. VOP_PAGEIO()
3092  * interface is considered safe here if its implementation
3093  * is very close to VOP_GETPAGE() implementation.
3094  * e.g. It zero's out the part of the page beyond EOF. Doesn't
3095  * panic if there're file holes but instead returns an error.
3096  * Doesn't assume file won't be changed by user writes, etc.
3097  *
3098  * return 0 otherwise.
3099  *
3100  * For now allow segvn to only use VOP_PAGEIO() with ufs and nfs.
3101  */
3102 int
3103 vn_vmpss_usepageio(vnode_t *vp)
3104 {
3105         vfs_t   *vfsp = vp->v_vfsp;
3106         char *fsname = vfssw[vfsp->vfs_fstype].vsw_name;
3107         char *pageio_ok_fss[] = {"ufs", "nfs", NULL};
3108         char **fsok = pageio_ok_fss;
3109 
3110         if (fsname == NULL) {
3111                 return (0);
3112         }
3113 
3114         for (; *fsok; fsok++) {
3115                 if (strcmp(*fsok, fsname) == 0) {
3116                         return (1);
3117                 }
3118         }
3119         return (0);
3120 }
3121 
3122 /* VOP_XXX() macros call the corresponding fop_xxx() function */
3123 
3124 int
3125 fop_open(
3126         vnode_t **vpp,
3127         int mode,
3128         cred_t *cr,
3129         caller_context_t *ct)
3130 {
3131         int ret;
3132         vnode_t *vp = *vpp;
3133 
3134         VN_HOLD(vp);
3135         /*
3136          * Adding to the vnode counts before calling open
3137          * avoids the need for a mutex. It circumvents a race
3138          * condition where a query made on the vnode counts results in a
3139          * false negative. The inquirer goes away believing the file is
3140          * not open when there is an open on the file already under way.
3141          *
3142          * The counts are meant to prevent NFS from granting a delegation
3143          * when it would be dangerous to do so.
3144          *
3145          * The vnode counts are only kept on regular files
3146          */
3147         if ((*vpp)->v_type == VREG) {
3148                 if (mode & FREAD)
3149                         atomic_add_32(&((*vpp)->v_rdcnt), 1);
3150                 if (mode & FWRITE)
3151                         atomic_add_32(&((*vpp)->v_wrcnt), 1);
3152         }
3153 
3154         VOPXID_MAP_CR(vp, cr);
3155 
3156         ret = (*(*(vpp))->v_op->vop_open)(vpp, mode, cr, ct);
3157 
3158         if (ret) {
3159                 /*
3160                  * Use the saved vp just in case the vnode ptr got trashed
3161                  * by the error.
3162                  */
3163                 VOPSTATS_UPDATE(vp, open);
3164                 if ((vp->v_type == VREG) && (mode & FREAD))
3165                         atomic_add_32(&(vp->v_rdcnt), -1);
3166                 if ((vp->v_type == VREG) && (mode & FWRITE))
3167                         atomic_add_32(&(vp->v_wrcnt), -1);
3168         } else {
3169                 /*
3170                  * Some filesystems will return a different vnode,
3171                  * but the same path was still used to open it.
3172                  * So if we do change the vnode and need to
3173                  * copy over the path, do so here, rather than special
3174                  * casing each filesystem. Adjust the vnode counts to
3175                  * reflect the vnode switch.
3176                  */
3177                 VOPSTATS_UPDATE(*vpp, open);
3178                 if (*vpp != vp && *vpp != NULL) {
3179                         vn_copypath(vp, *vpp);
3180                         if (((*vpp)->v_type == VREG) && (mode & FREAD))
3181                                 atomic_add_32(&((*vpp)->v_rdcnt), 1);
3182                         if ((vp->v_type == VREG) && (mode & FREAD))
3183                                 atomic_add_32(&(vp->v_rdcnt), -1);
3184                         if (((*vpp)->v_type == VREG) && (mode & FWRITE))
3185                                 atomic_add_32(&((*vpp)->v_wrcnt), 1);
3186                         if ((vp->v_type == VREG) && (mode & FWRITE))
3187                                 atomic_add_32(&(vp->v_wrcnt), -1);
3188                 }
3189         }
3190         VN_RELE(vp);
3191         return (ret);
3192 }
3193 
3194 int
3195 fop_close(
3196         vnode_t *vp,
3197         int flag,
3198         int count,
3199         offset_t offset,
3200         cred_t *cr,
3201         caller_context_t *ct)
3202 {
3203         int err;
3204 
3205         VOPXID_MAP_CR(vp, cr);
3206 
3207         err = (*(vp)->v_op->vop_close)(vp, flag, count, offset, cr, ct);
3208         VOPSTATS_UPDATE(vp, close);
3209         /*
3210          * Check passed in count to handle possible dups. Vnode counts are only
3211          * kept on regular files
3212          */
3213         if ((vp->v_type == VREG) && (count == 1))  {
3214                 if (flag & FREAD) {
3215                         ASSERT(vp->v_rdcnt > 0);
3216                         atomic_add_32(&(vp->v_rdcnt), -1);
3217                 }
3218                 if (flag & FWRITE) {
3219                         ASSERT(vp->v_wrcnt > 0);
3220                         atomic_add_32(&(vp->v_wrcnt), -1);
3221                 }
3222         }
3223         return (err);
3224 }
3225 
3226 int
3227 fop_read(
3228         vnode_t *vp,
3229         uio_t *uiop,
3230         int ioflag,
3231         cred_t *cr,
3232         caller_context_t *ct)
3233 {
3234         int     err;
3235         ssize_t resid_start = uiop->uio_resid;
3236 
3237         VOPXID_MAP_CR(vp, cr);
3238 
3239         err = (*(vp)->v_op->vop_read)(vp, uiop, ioflag, cr, ct);
3240         VOPSTATS_UPDATE_IO(vp, read,
3241             read_bytes, (resid_start - uiop->uio_resid));
3242         return (err);
3243 }
3244 
3245 int
3246 fop_write(
3247         vnode_t *vp,
3248         uio_t *uiop,
3249         int ioflag,
3250         cred_t *cr,
3251         caller_context_t *ct)
3252 {
3253         int     err;
3254         ssize_t resid_start = uiop->uio_resid;
3255 
3256         VOPXID_MAP_CR(vp, cr);
3257 
3258         err = (*(vp)->v_op->vop_write)(vp, uiop, ioflag, cr, ct);
3259         VOPSTATS_UPDATE_IO(vp, write,
3260             write_bytes, (resid_start - uiop->uio_resid));
3261         return (err);
3262 }
3263 
3264 int
3265 fop_ioctl(
3266         vnode_t *vp,
3267         int cmd,
3268         intptr_t arg,
3269         int flag,
3270         cred_t *cr,
3271         int *rvalp,
3272         caller_context_t *ct)
3273 {
3274         int     err;
3275 
3276         VOPXID_MAP_CR(vp, cr);
3277 
3278         err = (*(vp)->v_op->vop_ioctl)(vp, cmd, arg, flag, cr, rvalp, ct);
3279         VOPSTATS_UPDATE(vp, ioctl);
3280         return (err);
3281 }
3282 
3283 int
3284 fop_setfl(
3285         vnode_t *vp,
3286         int oflags,
3287         int nflags,
3288         cred_t *cr,
3289         caller_context_t *ct)
3290 {
3291         int     err;
3292 
3293         VOPXID_MAP_CR(vp, cr);
3294 
3295         err = (*(vp)->v_op->vop_setfl)(vp, oflags, nflags, cr, ct);
3296         VOPSTATS_UPDATE(vp, setfl);
3297         return (err);
3298 }
3299 
3300 int
3301 fop_getattr(
3302         vnode_t *vp,
3303         vattr_t *vap,
3304         int flags,
3305         cred_t *cr,
3306         caller_context_t *ct)
3307 {
3308         int     err;
3309 
3310         VOPXID_MAP_CR(vp, cr);
3311 
3312         /*
3313          * If this file system doesn't understand the xvattr extensions
3314          * then turn off the xvattr bit.
3315          */
3316         if (vfs_has_feature(vp->v_vfsp, VFSFT_XVATTR) == 0) {
3317                 vap->va_mask &= ~AT_XVATTR;
3318         }
3319 
3320         /*
3321          * We're only allowed to skip the ACL check iff we used a 32 bit
3322          * ACE mask with VOP_ACCESS() to determine permissions.
3323          */
3324         if ((flags & ATTR_NOACLCHECK) &&
3325             vfs_has_feature(vp->v_vfsp, VFSFT_ACEMASKONACCESS) == 0) {
3326                 return (EINVAL);
3327         }
3328         err = (*(vp)->v_op->vop_getattr)(vp, vap, flags, cr, ct);
3329         VOPSTATS_UPDATE(vp, getattr);
3330         return (err);
3331 }
3332 
3333 int
3334 fop_setattr(
3335         vnode_t *vp,
3336         vattr_t *vap,
3337         int flags,
3338         cred_t *cr,
3339         caller_context_t *ct)
3340 {
3341         int     err;
3342 
3343         VOPXID_MAP_CR(vp, cr);
3344 
3345         /*
3346          * If this file system doesn't understand the xvattr extensions
3347          * then turn off the xvattr bit.
3348          */
3349         if (vfs_has_feature(vp->v_vfsp, VFSFT_XVATTR) == 0) {
3350                 vap->va_mask &= ~AT_XVATTR;
3351         }
3352 
3353         /*
3354          * We're only allowed to skip the ACL check iff we used a 32 bit
3355          * ACE mask with VOP_ACCESS() to determine permissions.
3356          */
3357         if ((flags & ATTR_NOACLCHECK) &&
3358             vfs_has_feature(vp->v_vfsp, VFSFT_ACEMASKONACCESS) == 0) {
3359                 return (EINVAL);
3360         }
3361         err = (*(vp)->v_op->vop_setattr)(vp, vap, flags, cr, ct);
3362         VOPSTATS_UPDATE(vp, setattr);
3363         return (err);
3364 }
3365 
3366 int
3367 fop_access(
3368         vnode_t *vp,
3369         int mode,
3370         int flags,
3371         cred_t *cr,
3372         caller_context_t *ct)
3373 {
3374         int     err;
3375 
3376         if ((flags & V_ACE_MASK) &&
3377             vfs_has_feature(vp->v_vfsp, VFSFT_ACEMASKONACCESS) == 0) {
3378                 return (EINVAL);
3379         }
3380 
3381         VOPXID_MAP_CR(vp, cr);
3382 
3383         err = (*(vp)->v_op->vop_access)(vp, mode, flags, cr, ct);
3384         VOPSTATS_UPDATE(vp, access);
3385         return (err);
3386 }
3387 
3388 int
3389 fop_lookup(
3390         vnode_t *dvp,
3391         char *nm,
3392         vnode_t **vpp,
3393         pathname_t *pnp,
3394         int flags,
3395         vnode_t *rdir,
3396         cred_t *cr,
3397         caller_context_t *ct,
3398         int *deflags,           /* Returned per-dirent flags */
3399         pathname_t *ppnp)       /* Returned case-preserved name in directory */
3400 {
3401         int ret;
3402 
3403         /*
3404          * If this file system doesn't support case-insensitive access
3405          * and said access is requested, fail quickly.  It is required
3406          * that if the vfs supports case-insensitive lookup, it also
3407          * supports extended dirent flags.
3408          */
3409         if (flags & FIGNORECASE &&
3410             (vfs_has_feature(dvp->v_vfsp, VFSFT_CASEINSENSITIVE) == 0 &&
3411             vfs_has_feature(dvp->v_vfsp, VFSFT_NOCASESENSITIVE) == 0))
3412                 return (EINVAL);
3413 
3414         VOPXID_MAP_CR(dvp, cr);
3415 
3416         if ((flags & LOOKUP_XATTR) && (flags & LOOKUP_HAVE_SYSATTR_DIR) == 0) {
3417                 ret = xattr_dir_lookup(dvp, vpp, flags, cr);
3418         } else {
3419                 ret = (*(dvp)->v_op->vop_lookup)
3420                     (dvp, nm, vpp, pnp, flags, rdir, cr, ct, deflags, ppnp);
3421         }
3422         if (ret == 0 && *vpp) {
3423                 VOPSTATS_UPDATE(*vpp, lookup);
3424                 if ((*vpp)->v_path == NULL) {
3425                         vn_setpath(rootdir, dvp, *vpp, nm, strlen(nm));
3426                 }
3427         }
3428 
3429         return (ret);
3430 }
3431 
3432 int
3433 fop_create(
3434         vnode_t *dvp,
3435         char *name,
3436         vattr_t *vap,
3437         vcexcl_t excl,
3438         int mode,
3439         vnode_t **vpp,
3440         cred_t *cr,
3441         int flags,
3442         caller_context_t *ct,
3443         vsecattr_t *vsecp)      /* ACL to set during create */
3444 {
3445         int ret;
3446 
3447         if (vsecp != NULL &&
3448             vfs_has_feature(dvp->v_vfsp, VFSFT_ACLONCREATE) == 0) {
3449                 return (EINVAL);
3450         }
3451         /*
3452          * If this file system doesn't support case-insensitive access
3453          * and said access is requested, fail quickly.
3454          */
3455         if (flags & FIGNORECASE &&
3456             (vfs_has_feature(dvp->v_vfsp, VFSFT_CASEINSENSITIVE) == 0 &&
3457             vfs_has_feature(dvp->v_vfsp, VFSFT_NOCASESENSITIVE) == 0))
3458                 return (EINVAL);
3459 
3460         VOPXID_MAP_CR(dvp, cr);
3461 
3462         ret = (*(dvp)->v_op->vop_create)
3463             (dvp, name, vap, excl, mode, vpp, cr, flags, ct, vsecp);
3464         if (ret == 0 && *vpp) {
3465                 VOPSTATS_UPDATE(*vpp, create);
3466                 if ((*vpp)->v_path == NULL) {
3467                         vn_setpath(rootdir, dvp, *vpp, name, strlen(name));
3468                 }
3469         }
3470 
3471         return (ret);
3472 }
3473 
3474 int
3475 fop_remove(
3476         vnode_t *dvp,
3477         char *nm,
3478         cred_t *cr,
3479         caller_context_t *ct,
3480         int flags)
3481 {
3482         int     err;
3483 
3484         /*
3485          * If this file system doesn't support case-insensitive access
3486          * and said access is requested, fail quickly.
3487          */
3488         if (flags & FIGNORECASE &&
3489             (vfs_has_feature(dvp->v_vfsp, VFSFT_CASEINSENSITIVE) == 0 &&
3490             vfs_has_feature(dvp->v_vfsp, VFSFT_NOCASESENSITIVE) == 0))
3491                 return (EINVAL);
3492 
3493         VOPXID_MAP_CR(dvp, cr);
3494 
3495         err = (*(dvp)->v_op->vop_remove)(dvp, nm, cr, ct, flags);
3496         VOPSTATS_UPDATE(dvp, remove);
3497         return (err);
3498 }
3499 
3500 int
3501 fop_link(
3502         vnode_t *tdvp,
3503         vnode_t *svp,
3504         char *tnm,
3505         cred_t *cr,
3506         caller_context_t *ct,
3507         int flags)
3508 {
3509         int     err;
3510 
3511         /*
3512          * If the target file system doesn't support case-insensitive access
3513          * and said access is requested, fail quickly.
3514          */
3515         if (flags & FIGNORECASE &&
3516             (vfs_has_feature(tdvp->v_vfsp, VFSFT_CASEINSENSITIVE) == 0 &&
3517             vfs_has_feature(tdvp->v_vfsp, VFSFT_NOCASESENSITIVE) == 0))
3518                 return (EINVAL);
3519 
3520         VOPXID_MAP_CR(tdvp, cr);
3521 
3522         err = (*(tdvp)->v_op->vop_link)(tdvp, svp, tnm, cr, ct, flags);
3523         VOPSTATS_UPDATE(tdvp, link);
3524         return (err);
3525 }
3526 
3527 int
3528 fop_rename(
3529         vnode_t *sdvp,
3530         char *snm,
3531         vnode_t *tdvp,
3532         char *tnm,
3533         cred_t *cr,
3534         caller_context_t *ct,
3535         int flags)
3536 {
3537         int     err;
3538 
3539         /*
3540          * If the file system involved does not support
3541          * case-insensitive access and said access is requested, fail
3542          * quickly.
3543          */
3544         if (flags & FIGNORECASE &&
3545             ((vfs_has_feature(sdvp->v_vfsp, VFSFT_CASEINSENSITIVE) == 0 &&
3546             vfs_has_feature(sdvp->v_vfsp, VFSFT_NOCASESENSITIVE) == 0)))
3547                 return (EINVAL);
3548 
3549         VOPXID_MAP_CR(tdvp, cr);
3550 
3551         err = (*(sdvp)->v_op->vop_rename)(sdvp, snm, tdvp, tnm, cr, ct, flags);
3552         VOPSTATS_UPDATE(sdvp, rename);
3553         return (err);
3554 }
3555 
3556 int
3557 fop_mkdir(
3558         vnode_t *dvp,
3559         char *dirname,
3560         vattr_t *vap,
3561         vnode_t **vpp,
3562         cred_t *cr,
3563         caller_context_t *ct,
3564         int flags,
3565         vsecattr_t *vsecp)      /* ACL to set during create */
3566 {
3567         int ret;
3568 
3569         if (vsecp != NULL &&
3570             vfs_has_feature(dvp->v_vfsp, VFSFT_ACLONCREATE) == 0) {
3571                 return (EINVAL);
3572         }
3573         /*
3574          * If this file system doesn't support case-insensitive access
3575          * and said access is requested, fail quickly.
3576          */
3577         if (flags & FIGNORECASE &&
3578             (vfs_has_feature(dvp->v_vfsp, VFSFT_CASEINSENSITIVE) == 0 &&
3579             vfs_has_feature(dvp->v_vfsp, VFSFT_NOCASESENSITIVE) == 0))
3580                 return (EINVAL);
3581 
3582         VOPXID_MAP_CR(dvp, cr);
3583 
3584         ret = (*(dvp)->v_op->vop_mkdir)
3585             (dvp, dirname, vap, vpp, cr, ct, flags, vsecp);
3586         if (ret == 0 && *vpp) {
3587                 VOPSTATS_UPDATE(*vpp, mkdir);
3588                 if ((*vpp)->v_path == NULL) {
3589                         vn_setpath(rootdir, dvp, *vpp, dirname,
3590                             strlen(dirname));
3591                 }
3592         }
3593 
3594         return (ret);
3595 }
3596 
3597 int
3598 fop_rmdir(
3599         vnode_t *dvp,
3600         char *nm,
3601         vnode_t *cdir,
3602         cred_t *cr,
3603         caller_context_t *ct,
3604         int flags)
3605 {
3606         int     err;
3607 
3608         /*
3609          * If this file system doesn't support case-insensitive access
3610          * and said access is requested, fail quickly.
3611          */
3612         if (flags & FIGNORECASE &&
3613             (vfs_has_feature(dvp->v_vfsp, VFSFT_CASEINSENSITIVE) == 0 &&
3614             vfs_has_feature(dvp->v_vfsp, VFSFT_NOCASESENSITIVE) == 0))
3615                 return (EINVAL);
3616 
3617         VOPXID_MAP_CR(dvp, cr);
3618 
3619         err = (*(dvp)->v_op->vop_rmdir)(dvp, nm, cdir, cr, ct, flags);
3620         VOPSTATS_UPDATE(dvp, rmdir);
3621         return (err);
3622 }
3623 
3624 int
3625 fop_readdir(
3626         vnode_t *vp,
3627         uio_t *uiop,
3628         cred_t *cr,
3629         int *eofp,
3630         caller_context_t *ct,
3631         int flags)
3632 {
3633         int     err;
3634         ssize_t resid_start = uiop->uio_resid;
3635 
3636         /*
3637          * If this file system doesn't support retrieving directory
3638          * entry flags and said access is requested, fail quickly.
3639          */
3640         if (flags & V_RDDIR_ENTFLAGS &&
3641             vfs_has_feature(vp->v_vfsp, VFSFT_DIRENTFLAGS) == 0)
3642                 return (EINVAL);
3643 
3644         VOPXID_MAP_CR(vp, cr);
3645 
3646         err = (*(vp)->v_op->vop_readdir)(vp, uiop, cr, eofp, ct, flags);
3647         VOPSTATS_UPDATE_IO(vp, readdir,
3648             readdir_bytes, (resid_start - uiop->uio_resid));
3649         return (err);
3650 }
3651 
3652 int
3653 fop_symlink(
3654         vnode_t *dvp,
3655         char *linkname,
3656         vattr_t *vap,
3657         char *target,
3658         cred_t *cr,
3659         caller_context_t *ct,
3660         int flags)
3661 {
3662         int     err;
3663         xvattr_t xvattr;
3664 
3665         /*
3666          * If this file system doesn't support case-insensitive access
3667          * and said access is requested, fail quickly.
3668          */
3669         if (flags & FIGNORECASE &&
3670             (vfs_has_feature(dvp->v_vfsp, VFSFT_CASEINSENSITIVE) == 0 &&
3671             vfs_has_feature(dvp->v_vfsp, VFSFT_NOCASESENSITIVE) == 0))
3672                 return (EINVAL);
3673 
3674         VOPXID_MAP_CR(dvp, cr);
3675 
3676         /* check for reparse point */
3677         if ((vfs_has_feature(dvp->v_vfsp, VFSFT_REPARSE)) &&
3678             (strncmp(target, FS_REPARSE_TAG_STR,
3679             strlen(FS_REPARSE_TAG_STR)) == 0)) {
3680                 if (!fs_reparse_mark(target, vap, &xvattr))
3681                         vap = (vattr_t *)&xvattr;
3682         }
3683 
3684         err = (*(dvp)->v_op->vop_symlink)
3685             (dvp, linkname, vap, target, cr, ct, flags);
3686         VOPSTATS_UPDATE(dvp, symlink);
3687         return (err);
3688 }
3689 
3690 int
3691 fop_readlink(
3692         vnode_t *vp,
3693         uio_t *uiop,
3694         cred_t *cr,
3695         caller_context_t *ct)
3696 {
3697         int     err;
3698 
3699         VOPXID_MAP_CR(vp, cr);
3700 
3701         err = (*(vp)->v_op->vop_readlink)(vp, uiop, cr, ct);
3702         VOPSTATS_UPDATE(vp, readlink);
3703         return (err);
3704 }
3705 
3706 int
3707 fop_fsync(
3708         vnode_t *vp,
3709         int syncflag,
3710         cred_t *cr,
3711         caller_context_t *ct)
3712 {
3713         int     err;
3714 
3715         VOPXID_MAP_CR(vp, cr);
3716 
3717         err = (*(vp)->v_op->vop_fsync)(vp, syncflag, cr, ct);
3718         VOPSTATS_UPDATE(vp, fsync);
3719         return (err);
3720 }
3721 
3722 void
3723 fop_inactive(
3724         vnode_t *vp,
3725         cred_t *cr,
3726         caller_context_t *ct)
3727 {
3728         /* Need to update stats before vop call since we may lose the vnode */
3729         VOPSTATS_UPDATE(vp, inactive);
3730 
3731         VOPXID_MAP_CR(vp, cr);
3732 
3733         (*(vp)->v_op->vop_inactive)(vp, cr, ct);
3734 }
3735 
3736 int
3737 fop_fid(
3738         vnode_t *vp,
3739         fid_t *fidp,
3740         caller_context_t *ct)
3741 {
3742         int     err;
3743 
3744         err = (*(vp)->v_op->vop_fid)(vp, fidp, ct);
3745         VOPSTATS_UPDATE(vp, fid);
3746         return (err);
3747 }
3748 
3749 int
3750 fop_rwlock(
3751         vnode_t *vp,
3752         int write_lock,
3753         caller_context_t *ct)
3754 {
3755         int     ret;
3756 
3757         ret = ((*(vp)->v_op->vop_rwlock)(vp, write_lock, ct));
3758         VOPSTATS_UPDATE(vp, rwlock);
3759         return (ret);
3760 }
3761 
3762 void
3763 fop_rwunlock(
3764         vnode_t *vp,
3765         int write_lock,
3766         caller_context_t *ct)
3767 {
3768         (*(vp)->v_op->vop_rwunlock)(vp, write_lock, ct);
3769         VOPSTATS_UPDATE(vp, rwunlock);
3770 }
3771 
3772 int
3773 fop_seek(
3774         vnode_t *vp,
3775         offset_t ooff,
3776         offset_t *noffp,
3777         caller_context_t *ct)
3778 {
3779         int     err;
3780 
3781         err = (*(vp)->v_op->vop_seek)(vp, ooff, noffp, ct);
3782         VOPSTATS_UPDATE(vp, seek);
3783         return (err);
3784 }
3785 
3786 int
3787 fop_cmp(
3788         vnode_t *vp1,
3789         vnode_t *vp2,
3790         caller_context_t *ct)
3791 {
3792         int     err;
3793 
3794         err = (*(vp1)->v_op->vop_cmp)(vp1, vp2, ct);
3795         VOPSTATS_UPDATE(vp1, cmp);
3796         return (err);
3797 }
3798 
3799 int
3800 fop_frlock(
3801         vnode_t *vp,
3802         int cmd,
3803         flock64_t *bfp,
3804         int flag,
3805         offset_t offset,
3806         struct flk_callback *flk_cbp,
3807         cred_t *cr,
3808         caller_context_t *ct)
3809 {
3810         int     err;
3811 
3812         VOPXID_MAP_CR(vp, cr);
3813 
3814         err = (*(vp)->v_op->vop_frlock)
3815             (vp, cmd, bfp, flag, offset, flk_cbp, cr, ct);
3816         VOPSTATS_UPDATE(vp, frlock);
3817         return (err);
3818 }
3819 
3820 int
3821 fop_space(
3822         vnode_t *vp,
3823         int cmd,
3824         flock64_t *bfp,
3825         int flag,
3826         offset_t offset,
3827         cred_t *cr,
3828         caller_context_t *ct)
3829 {
3830         int     err;
3831 
3832         VOPXID_MAP_CR(vp, cr);
3833 
3834         err = (*(vp)->v_op->vop_space)(vp, cmd, bfp, flag, offset, cr, ct);
3835         VOPSTATS_UPDATE(vp, space);
3836         return (err);
3837 }
3838 
3839 int
3840 fop_realvp(
3841         vnode_t *vp,
3842         vnode_t **vpp,
3843         caller_context_t *ct)
3844 {
3845         int     err;
3846 
3847         err = (*(vp)->v_op->vop_realvp)(vp, vpp, ct);
3848         VOPSTATS_UPDATE(vp, realvp);
3849         return (err);
3850 }
3851 
3852 int
3853 fop_getpage(
3854         vnode_t *vp,
3855         offset_t off,
3856         size_t len,
3857         uint_t *protp,
3858         page_t **plarr,
3859         size_t plsz,
3860         struct seg *seg,
3861         caddr_t addr,
3862         enum seg_rw rw,
3863         cred_t *cr,
3864         caller_context_t *ct)
3865 {
3866         int     err;
3867 
3868         VOPXID_MAP_CR(vp, cr);
3869 
3870         err = (*(vp)->v_op->vop_getpage)
3871             (vp, off, len, protp, plarr, plsz, seg, addr, rw, cr, ct);
3872         VOPSTATS_UPDATE(vp, getpage);
3873         return (err);
3874 }
3875 
3876 int
3877 fop_putpage(
3878         vnode_t *vp,
3879         offset_t off,
3880         size_t len,
3881         int flags,
3882         cred_t *cr,
3883         caller_context_t *ct)
3884 {
3885         int     err;
3886 
3887         VOPXID_MAP_CR(vp, cr);
3888 
3889         err = (*(vp)->v_op->vop_putpage)(vp, off, len, flags, cr, ct);
3890         VOPSTATS_UPDATE(vp, putpage);
3891         return (err);
3892 }
3893 
3894 int
3895 fop_map(
3896         vnode_t *vp,
3897         offset_t off,
3898         struct as *as,
3899         caddr_t *addrp,
3900         size_t len,
3901         uchar_t prot,
3902         uchar_t maxprot,
3903         uint_t flags,
3904         cred_t *cr,
3905         caller_context_t *ct)
3906 {
3907         int     err;
3908 
3909         VOPXID_MAP_CR(vp, cr);
3910 
3911         err = (*(vp)->v_op->vop_map)
3912             (vp, off, as, addrp, len, prot, maxprot, flags, cr, ct);
3913         VOPSTATS_UPDATE(vp, map);
3914         return (err);
3915 }
3916 
3917 int
3918 fop_addmap(
3919         vnode_t *vp,
3920         offset_t off,
3921         struct as *as,
3922         caddr_t addr,
3923         size_t len,
3924         uchar_t prot,
3925         uchar_t maxprot,
3926         uint_t flags,
3927         cred_t *cr,
3928         caller_context_t *ct)
3929 {
3930         int error;
3931         u_longlong_t delta;
3932 
3933         VOPXID_MAP_CR(vp, cr);
3934 
3935         error = (*(vp)->v_op->vop_addmap)
3936             (vp, off, as, addr, len, prot, maxprot, flags, cr, ct);
3937 
3938         if ((!error) && (vp->v_type == VREG)) {
3939                 delta = (u_longlong_t)btopr(len);
3940                 /*
3941                  * If file is declared MAP_PRIVATE, it can't be written back
3942                  * even if open for write. Handle as read.
3943                  */
3944                 if (flags & MAP_PRIVATE) {
3945                         atomic_add_64((uint64_t *)(&(vp->v_mmap_read)),
3946                             (int64_t)delta);
3947                 } else {
3948                         /*
3949                          * atomic_add_64 forces the fetch of a 64 bit value to
3950                          * be atomic on 32 bit machines
3951                          */
3952                         if (maxprot & PROT_WRITE)
3953                                 atomic_add_64((uint64_t *)(&(vp->v_mmap_write)),
3954                                     (int64_t)delta);
3955                         if (maxprot & PROT_READ)
3956                                 atomic_add_64((uint64_t *)(&(vp->v_mmap_read)),
3957                                     (int64_t)delta);
3958                         if (maxprot & PROT_EXEC)
3959                                 atomic_add_64((uint64_t *)(&(vp->v_mmap_read)),
3960                                     (int64_t)delta);
3961                 }
3962         }
3963         VOPSTATS_UPDATE(vp, addmap);
3964         return (error);
3965 }
3966 
3967 int
3968 fop_delmap(
3969         vnode_t *vp,
3970         offset_t off,
3971         struct as *as,
3972         caddr_t addr,
3973         size_t len,
3974         uint_t prot,
3975         uint_t maxprot,
3976         uint_t flags,
3977         cred_t *cr,
3978         caller_context_t *ct)
3979 {
3980         int error;
3981         u_longlong_t delta;
3982 
3983         VOPXID_MAP_CR(vp, cr);
3984 
3985         error = (*(vp)->v_op->vop_delmap)
3986             (vp, off, as, addr, len, prot, maxprot, flags, cr, ct);
3987 
3988         /*
3989          * NFS calls into delmap twice, the first time
3990          * it simply establishes a callback mechanism and returns EAGAIN
3991          * while the real work is being done upon the second invocation.
3992          * We have to detect this here and only decrement the counts upon
3993          * the second delmap request.
3994          */
3995         if ((error != EAGAIN) && (vp->v_type == VREG)) {
3996 
3997                 delta = (u_longlong_t)btopr(len);
3998 
3999                 if (flags & MAP_PRIVATE) {
4000                         atomic_add_64((uint64_t *)(&(vp->v_mmap_read)),
4001                             (int64_t)(-delta));
4002                 } else {
4003                         /*
4004                          * atomic_add_64 forces the fetch of a 64 bit value
4005                          * to be atomic on 32 bit machines
4006                          */
4007                         if (maxprot & PROT_WRITE)
4008                                 atomic_add_64((uint64_t *)(&(vp->v_mmap_write)),
4009                                     (int64_t)(-delta));
4010                         if (maxprot & PROT_READ)
4011                                 atomic_add_64((uint64_t *)(&(vp->v_mmap_read)),
4012                                     (int64_t)(-delta));
4013                         if (maxprot & PROT_EXEC)
4014                                 atomic_add_64((uint64_t *)(&(vp->v_mmap_read)),
4015                                     (int64_t)(-delta));
4016                 }
4017         }
4018         VOPSTATS_UPDATE(vp, delmap);
4019         return (error);
4020 }
4021 
4022 
4023 int
4024 fop_poll(
4025         vnode_t *vp,
4026         short events,
4027         int anyyet,
4028         short *reventsp,
4029         struct pollhead **phpp,
4030         caller_context_t *ct)
4031 {
4032         int     err;
4033 
4034         err = (*(vp)->v_op->vop_poll)(vp, events, anyyet, reventsp, phpp, ct);
4035         VOPSTATS_UPDATE(vp, poll);
4036         return (err);
4037 }
4038 
4039 int
4040 fop_dump(
4041         vnode_t *vp,
4042         caddr_t addr,
4043         offset_t lbdn,
4044         offset_t dblks,
4045         caller_context_t *ct)
4046 {
4047         int     err;
4048 
4049         /* ensure lbdn and dblks can be passed safely to bdev_dump */
4050         if ((lbdn != (daddr_t)lbdn) || (dblks != (int)dblks))
4051                 return (EIO);
4052 
4053         err = (*(vp)->v_op->vop_dump)(vp, addr, lbdn, dblks, ct);
4054         VOPSTATS_UPDATE(vp, dump);
4055         return (err);
4056 }
4057 
4058 int
4059 fop_pathconf(
4060         vnode_t *vp,
4061         int cmd,
4062         ulong_t *valp,
4063         cred_t *cr,
4064         caller_context_t *ct)
4065 {
4066         int     err;
4067 
4068         VOPXID_MAP_CR(vp, cr);
4069 
4070         err = (*(vp)->v_op->vop_pathconf)(vp, cmd, valp, cr, ct);
4071         VOPSTATS_UPDATE(vp, pathconf);
4072         return (err);
4073 }
4074 
4075 int
4076 fop_pageio(
4077         vnode_t *vp,
4078         struct page *pp,
4079         u_offset_t io_off,
4080         size_t io_len,
4081         int flags,
4082         cred_t *cr,
4083         caller_context_t *ct)
4084 {
4085         int     err;
4086 
4087         VOPXID_MAP_CR(vp, cr);
4088 
4089         err = (*(vp)->v_op->vop_pageio)(vp, pp, io_off, io_len, flags, cr, ct);
4090         VOPSTATS_UPDATE(vp, pageio);
4091         return (err);
4092 }
4093 
4094 int
4095 fop_dumpctl(
4096         vnode_t *vp,
4097         int action,
4098         offset_t *blkp,
4099         caller_context_t *ct)
4100 {
4101         int     err;
4102         err = (*(vp)->v_op->vop_dumpctl)(vp, action, blkp, ct);
4103         VOPSTATS_UPDATE(vp, dumpctl);
4104         return (err);
4105 }
4106 
4107 void
4108 fop_dispose(
4109         vnode_t *vp,
4110         page_t *pp,
4111         int flag,
4112         int dn,
4113         cred_t *cr,
4114         caller_context_t *ct)
4115 {
4116         /* Must do stats first since it's possible to lose the vnode */
4117         VOPSTATS_UPDATE(vp, dispose);
4118 
4119         VOPXID_MAP_CR(vp, cr);
4120 
4121         (*(vp)->v_op->vop_dispose)(vp, pp, flag, dn, cr, ct);
4122 }
4123 
4124 int
4125 fop_setsecattr(
4126         vnode_t *vp,
4127         vsecattr_t *vsap,
4128         int flag,
4129         cred_t *cr,
4130         caller_context_t *ct)
4131 {
4132         int     err;
4133 
4134         VOPXID_MAP_CR(vp, cr);
4135 
4136         /*
4137          * We're only allowed to skip the ACL check iff we used a 32 bit
4138          * ACE mask with VOP_ACCESS() to determine permissions.
4139          */
4140         if ((flag & ATTR_NOACLCHECK) &&
4141             vfs_has_feature(vp->v_vfsp, VFSFT_ACEMASKONACCESS) == 0) {
4142                 return (EINVAL);
4143         }
4144         err = (*(vp)->v_op->vop_setsecattr) (vp, vsap, flag, cr, ct);
4145         VOPSTATS_UPDATE(vp, setsecattr);
4146         return (err);
4147 }
4148 
4149 int
4150 fop_getsecattr(
4151         vnode_t *vp,
4152         vsecattr_t *vsap,
4153         int flag,
4154         cred_t *cr,
4155         caller_context_t *ct)
4156 {
4157         int     err;
4158 
4159         /*
4160          * We're only allowed to skip the ACL check iff we used a 32 bit
4161          * ACE mask with VOP_ACCESS() to determine permissions.
4162          */
4163         if ((flag & ATTR_NOACLCHECK) &&
4164             vfs_has_feature(vp->v_vfsp, VFSFT_ACEMASKONACCESS) == 0) {
4165                 return (EINVAL);
4166         }
4167 
4168         VOPXID_MAP_CR(vp, cr);
4169 
4170         err = (*(vp)->v_op->vop_getsecattr) (vp, vsap, flag, cr, ct);
4171         VOPSTATS_UPDATE(vp, getsecattr);
4172         return (err);
4173 }
4174 
4175 int
4176 fop_shrlock(
4177         vnode_t *vp,
4178         int cmd,
4179         struct shrlock *shr,
4180         int flag,
4181         cred_t *cr,
4182         caller_context_t *ct)
4183 {
4184         int     err;
4185 
4186         VOPXID_MAP_CR(vp, cr);
4187 
4188         err = (*(vp)->v_op->vop_shrlock)(vp, cmd, shr, flag, cr, ct);
4189         VOPSTATS_UPDATE(vp, shrlock);
4190         return (err);
4191 }
4192 
4193 int
4194 fop_vnevent(vnode_t *vp, vnevent_t vnevent, vnode_t *dvp, char *fnm,
4195     caller_context_t *ct)
4196 {
4197         int     err;
4198 
4199         err = (*(vp)->v_op->vop_vnevent)(vp, vnevent, dvp, fnm, ct);
4200         VOPSTATS_UPDATE(vp, vnevent);
4201         return (err);
4202 }
4203 
4204 int
4205 fop_reqzcbuf(vnode_t *vp, enum uio_rw ioflag, xuio_t *uiop, cred_t *cr,
4206     caller_context_t *ct)
4207 {
4208         int err;
4209 
4210         if (vfs_has_feature(vp->v_vfsp, VFSFT_ZEROCOPY_SUPPORTED) == 0)
4211                 return (ENOTSUP);
4212         err = (*(vp)->v_op->vop_reqzcbuf)(vp, ioflag, uiop, cr, ct);
4213         VOPSTATS_UPDATE(vp, reqzcbuf);
4214         return (err);
4215 }
4216 
4217 int
4218 fop_retzcbuf(vnode_t *vp, xuio_t *uiop, cred_t *cr, caller_context_t *ct)
4219 {
4220         int err;
4221 
4222         if (vfs_has_feature(vp->v_vfsp, VFSFT_ZEROCOPY_SUPPORTED) == 0)
4223                 return (ENOTSUP);
4224         err = (*(vp)->v_op->vop_retzcbuf)(vp, uiop, cr, ct);
4225         VOPSTATS_UPDATE(vp, retzcbuf);
4226         return (err);
4227 }
4228 
4229 /*
4230  * Default destructor
4231  *      Needed because NULL destructor means that the key is unused
4232  */
4233 /* ARGSUSED */
4234 void
4235 vsd_defaultdestructor(void *value)
4236 {}
4237 
4238 /*
4239  * Create a key (index into per vnode array)
4240  *      Locks out vsd_create, vsd_destroy, and vsd_free
4241  *      May allocate memory with lock held
4242  */
4243 void
4244 vsd_create(uint_t *keyp, void (*destructor)(void *))
4245 {
4246         int     i;
4247         uint_t  nkeys;
4248 
4249         /*
4250          * if key is allocated, do nothing
4251          */
4252         mutex_enter(&vsd_lock);
4253         if (*keyp) {
4254                 mutex_exit(&vsd_lock);
4255                 return;
4256         }
4257         /*
4258          * find an unused key
4259          */
4260         if (destructor == NULL)
4261                 destructor = vsd_defaultdestructor;
4262 
4263         for (i = 0; i < vsd_nkeys; ++i)
4264                 if (vsd_destructor[i] == NULL)
4265                         break;
4266 
4267         /*
4268          * if no unused keys, increase the size of the destructor array
4269          */
4270         if (i == vsd_nkeys) {
4271                 if ((nkeys = (vsd_nkeys << 1)) == 0)
4272                         nkeys = 1;
4273                 vsd_destructor =
4274                     (void (**)(void *))vsd_realloc((void *)vsd_destructor,
4275                     (size_t)(vsd_nkeys * sizeof (void (*)(void *))),
4276                     (size_t)(nkeys * sizeof (void (*)(void *))));
4277                 vsd_nkeys = nkeys;
4278         }
4279 
4280         /*
4281          * allocate the next available unused key
4282          */
4283         vsd_destructor[i] = destructor;
4284         *keyp = i + 1;
4285 
4286         /* create vsd_list, if it doesn't exist */
4287         if (vsd_list == NULL) {
4288                 vsd_list = kmem_alloc(sizeof (list_t), KM_SLEEP);
4289                 list_create(vsd_list, sizeof (struct vsd_node),
4290                     offsetof(struct vsd_node, vs_nodes));
4291         }
4292 
4293         mutex_exit(&vsd_lock);
4294 }
4295 
4296 /*
4297  * Destroy a key
4298  *
4299  * Assumes that the caller is preventing vsd_set and vsd_get
4300  * Locks out vsd_create, vsd_destroy, and vsd_free
4301  * May free memory with lock held
4302  */
4303 void
4304 vsd_destroy(uint_t *keyp)
4305 {
4306         uint_t key;
4307         struct vsd_node *vsd;
4308 
4309         /*
4310          * protect the key namespace and our destructor lists
4311          */
4312         mutex_enter(&vsd_lock);
4313         key = *keyp;
4314         *keyp = 0;
4315 
4316         ASSERT(key <= vsd_nkeys);
4317 
4318         /*
4319          * if the key is valid
4320          */
4321         if (key != 0) {
4322                 uint_t k = key - 1;
4323                 /*
4324                  * for every vnode with VSD, call key's destructor
4325                  */
4326                 for (vsd = list_head(vsd_list); vsd != NULL;
4327                     vsd = list_next(vsd_list, vsd)) {
4328                         /*
4329                          * no VSD for key in this vnode
4330                          */
4331                         if (key > vsd->vs_nkeys)
4332                                 continue;
4333                         /*
4334                          * call destructor for key
4335                          */
4336                         if (vsd->vs_value[k] && vsd_destructor[k])
4337                                 (*vsd_destructor[k])(vsd->vs_value[k]);
4338                         /*
4339                          * reset value for key
4340                          */
4341                         vsd->vs_value[k] = NULL;
4342                 }
4343                 /*
4344                  * actually free the key (NULL destructor == unused)
4345                  */
4346                 vsd_destructor[k] = NULL;
4347         }
4348 
4349         mutex_exit(&vsd_lock);
4350 }
4351 
4352 /*
4353  * Quickly return the per vnode value that was stored with the specified key
4354  * Assumes the caller is protecting key from vsd_create and vsd_destroy
4355  * Assumes the caller is holding v_vsd_lock to protect the vsd.
4356  */
4357 void *
4358 vsd_get(vnode_t *vp, uint_t key)
4359 {
4360         struct vsd_node *vsd;
4361 
4362         ASSERT(vp != NULL);
4363         ASSERT(mutex_owned(&vp->v_vsd_lock));
4364 
4365         vsd = vp->v_vsd;
4366 
4367         if (key && vsd != NULL && key <= vsd->vs_nkeys)
4368                 return (vsd->vs_value[key - 1]);
4369         return (NULL);
4370 }
4371 
4372 /*
4373  * Set a per vnode value indexed with the specified key
4374  * Assumes the caller is holding v_vsd_lock to protect the vsd.
4375  */
4376 int
4377 vsd_set(vnode_t *vp, uint_t key, void *value)
4378 {
4379         struct vsd_node *vsd;
4380 
4381         ASSERT(vp != NULL);
4382         ASSERT(mutex_owned(&vp->v_vsd_lock));
4383 
4384         if (key == 0)
4385                 return (EINVAL);
4386 
4387         vsd = vp->v_vsd;
4388         if (vsd == NULL)
4389                 vsd = vp->v_vsd = kmem_zalloc(sizeof (*vsd), KM_SLEEP);
4390 
4391         /*
4392          * If the vsd was just allocated, vs_nkeys will be 0, so the following
4393          * code won't happen and we will continue down and allocate space for
4394          * the vs_value array.
4395          * If the caller is replacing one value with another, then it is up
4396          * to the caller to free/rele/destroy the previous value (if needed).
4397          */
4398         if (key <= vsd->vs_nkeys) {
4399                 vsd->vs_value[key - 1] = value;
4400                 return (0);
4401         }
4402 
4403         ASSERT(key <= vsd_nkeys);
4404 
4405         if (vsd->vs_nkeys == 0) {
4406                 mutex_enter(&vsd_lock);     /* lock out vsd_destroy() */
4407                 /*
4408                  * Link onto list of all VSD nodes.
4409                  */
4410                 list_insert_head(vsd_list, vsd);
4411                 mutex_exit(&vsd_lock);
4412         }
4413 
4414         /*
4415          * Allocate vnode local storage and set the value for key
4416          */
4417         vsd->vs_value = vsd_realloc(vsd->vs_value,
4418             vsd->vs_nkeys * sizeof (void *),
4419             key * sizeof (void *));
4420         vsd->vs_nkeys = key;
4421         vsd->vs_value[key - 1] = value;
4422 
4423         return (0);
4424 }
4425 
4426 /*
4427  * Called from vn_free() to run the destructor function for each vsd
4428  *      Locks out vsd_create and vsd_destroy
4429  *      Assumes that the destructor *DOES NOT* use vsd
4430  */
4431 void
4432 vsd_free(vnode_t *vp)
4433 {
4434         int i;
4435         struct vsd_node *vsd = vp->v_vsd;
4436 
4437         if (vsd == NULL)
4438                 return;
4439 
4440         if (vsd->vs_nkeys == 0) {
4441                 kmem_free(vsd, sizeof (*vsd));
4442                 vp->v_vsd = NULL;
4443                 return;
4444         }
4445 
4446         /*
4447          * lock out vsd_create and vsd_destroy, call
4448          * the destructor, and mark the value as destroyed.
4449          */
4450         mutex_enter(&vsd_lock);
4451 
4452         for (i = 0; i < vsd->vs_nkeys; i++) {
4453                 if (vsd->vs_value[i] && vsd_destructor[i])
4454                         (*vsd_destructor[i])(vsd->vs_value[i]);
4455                 vsd->vs_value[i] = NULL;
4456         }
4457 
4458         /*
4459          * remove from linked list of VSD nodes
4460          */
4461         list_remove(vsd_list, vsd);
4462 
4463         mutex_exit(&vsd_lock);
4464 
4465         /*
4466          * free up the VSD
4467          */
4468         kmem_free(vsd->vs_value, vsd->vs_nkeys * sizeof (void *));
4469         kmem_free(vsd, sizeof (struct vsd_node));
4470         vp->v_vsd = NULL;
4471 }
4472 
4473 /*
4474  * realloc
4475  */
4476 static void *
4477 vsd_realloc(void *old, size_t osize, size_t nsize)
4478 {
4479         void *new;
4480 
4481         new = kmem_zalloc(nsize, KM_SLEEP);
4482         if (old) {
4483                 bcopy(old, new, osize);
4484                 kmem_free(old, osize);
4485         }
4486         return (new);
4487 }
4488 
4489 /*
4490  * Setup the extensible system attribute for creating a reparse point.
4491  * The symlink data 'target' is validated for proper format of a reparse
4492  * string and a check also made to make sure the symlink data does not
4493  * point to an existing file.
4494  *
4495  * return 0 if ok else -1.
4496  */
4497 static int
4498 fs_reparse_mark(char *target, vattr_t *vap, xvattr_t *xvattr)
4499 {
4500         xoptattr_t *xoap;
4501 
4502         if ((!target) || (!vap) || (!xvattr))
4503                 return (-1);
4504 
4505         /* validate reparse string */
4506         if (reparse_validate((const char *)target))
4507                 return (-1);
4508 
4509         xva_init(xvattr);
4510         xvattr->xva_vattr = *vap;
4511         xvattr->xva_vattr.va_mask |= AT_XVATTR;
4512         xoap = xva_getxoptattr(xvattr);
4513         ASSERT(xoap);
4514         XVA_SET_REQ(xvattr, XAT_REPARSE);
4515         xoap->xoa_reparse = 1;
4516 
4517         return (0);
4518 }
4519 
4520 /*
4521  * Function to check whether a symlink is a reparse point.
4522  * Return B_TRUE if it is a reparse point, else return B_FALSE
4523  */
4524 boolean_t
4525 vn_is_reparse(vnode_t *vp, cred_t *cr, caller_context_t *ct)
4526 {
4527         xvattr_t xvattr;
4528         xoptattr_t *xoap;
4529 
4530         if ((vp->v_type != VLNK) ||
4531             !(vfs_has_feature(vp->v_vfsp, VFSFT_XVATTR)))
4532                 return (B_FALSE);
4533 
4534         xva_init(&xvattr);
4535         xoap = xva_getxoptattr(&xvattr);
4536         ASSERT(xoap);
4537         XVA_SET_REQ(&xvattr, XAT_REPARSE);
4538 
4539         if (VOP_GETATTR(vp, &xvattr.xva_vattr, 0, cr, ct))
4540                 return (B_FALSE);
4541 
4542         if ((!(xvattr.xva_vattr.va_mask & AT_XVATTR)) ||
4543             (!(XVA_ISSET_RTN(&xvattr, XAT_REPARSE))))
4544                 return (B_FALSE);
4545 
4546         return (xoap->xoa_reparse ? B_TRUE : B_FALSE);
4547 }