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