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