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