50 #include <sys/vnode.h>
77 	    ("%s: non-unionfs vnode", __func__))
80 unionfs_lookup_isroot(struct componentname *cnp, struct vnode *dvp)  in unionfs_lookup_isroot()
98 	struct vnode   *dvp, *udvp, *ldvp, *vp, *uvp, *lvp, *dtmpvp;  in unionfs_lookup()
139 	 * end up dropping dvp's lock to look up a lower vnode or to create  in unionfs_lookup()
145 	 * existing unionfs vnode to be loaded from the VFS cache.  in unionfs_lookup()
148 	 * the vfs_hash_* functions to manage a per-mount vnode cache keyed  in unionfs_lookup()
185 		 * reference for the unionfs parent vnode's lock and  in unionfs_lookup()
332 	 * check vnode type  in unionfs_lookup()
346 		/* get unionfs vnode in order to create a new shadow dir. */  in unionfs_lookup()
382 	 * get unionfs vnode.  in unionfs_lookup()
395 			    "unionfs_lookup: Unable to create unionfs vnode.");  in unionfs_lookup()
434 	struct vnode   *udvp;  in unionfs_create()
435 	struct vnode   *vp;  in unionfs_create()
477 	struct vnode   *udvp;  in unionfs_whiteout()
515 	struct vnode   *udvp;  in unionfs_mknod()
516 	struct vnode   *vp;  in unionfs_mknod()
556 	UNIONFS_LKUPGRADE_DOOMED   /* lock was upgraded, but vnode reclaimed */
560 unionfs_upgrade_lock(struct vnode *vp)  in unionfs_upgrade_lock()
576 unionfs_downgrade_lock(struct vnode *vp, enum unionfs_lkupgrade status)  in unionfs_downgrade_lock()
583  * Exchange the default (upper vnode) lock on a unionfs vnode for the lower
584  * vnode lock, in support of operations that require access to the lower vnode
585  * even when an upper vnode is present.  We don't use vn_lock_pair() to hold
588  * which may not be safe in the presence of a locked vnode from another FS.
592  * vp must be a locked unionfs vnode; the lock state of this vnode is
595  * Returns the locked lower vnode, or NULL if the lower vnode (and therefore
596  * also the unionfs vnode above it) has been doomed.
598 static struct vnode *
599 unionfs_lock_lvp(struct vnode *vp, int *lkflags)  in unionfs_lock_lvp()
602 	struct vnode *lvp;  in unionfs_lock_lvp()
622  * on the unionfs vnode.  This function reloads and returns the vnode
623  * private data for the unionfs vnode, which will be NULL if the unionfs
624  * vnode became doomed while its lock was dropped.  The caller must check
628 unionfs_unlock_lvp(struct vnode *vp, struct vnode *lvp, int lkflags)  in unionfs_unlock_lvp()
642 	struct vnode   *vp;  in unionfs_open()
643 	struct vnode   *uvp;  in unionfs_open()
644 	struct vnode   *lvp;  in unionfs_open()
645 	struct vnode   *targetvp;  in unionfs_open()
666 	 * shared.  If the vnode is reclaimed while upgrading, we can't safely  in unionfs_open()
681 		/* vnode is already opend. */  in unionfs_open()
787 	struct vnode   *vp;  in unionfs_close()
788 	struct vnode   *uvp;  in unionfs_close()
789 	struct vnode   *lvp;  in unionfs_close()
790 	struct vnode   *ovp;  in unionfs_close()
807 	 * If the vnode is reclaimed while upgrading, we can't safely use unp  in unionfs_close()
902 	uid_t		uid;	/* upper side vnode's uid */  in unionfs_check_corrected_access()
903 	gid_t		gid;	/* upper side vnode's gid */  in unionfs_check_corrected_access()
904 	u_short		vmode;	/* upper side vnode's mode */  in unionfs_check_corrected_access()
950 	struct vnode   *uvp;  in unionfs_access()
951 	struct vnode   *lvp;  in unionfs_access()
1031 	struct vnode   *uvp;  in unionfs_getattr()
1032 	struct vnode   *lvp;  in unionfs_getattr()
1086 	struct vnode   *uvp;  in unionfs_setattr()
1087 	struct vnode   *lvp;  in unionfs_setattr()
1133 	struct vnode   *tvp;  in unionfs_read()
1154 	struct vnode   *tvp;  in unionfs_write()
1179 	struct vnode   *ovp;  in unionfs_ioctl()
1209 	struct vnode *ovp;  in unionfs_poll()
1231 	struct vnode *ovp;  in unionfs_fsync()
1266 	struct vnode   *udvp;  in unionfs_remove()
1267 	struct vnode   *uvp;  in unionfs_remove()
1268 	struct vnode   *lvp;  in unionfs_remove()
1320 	struct vnode   *udvp;  in unionfs_link()
1321 	struct vnode   *uvp;  in unionfs_link()
1374 	struct vnode   *fdvp;  in unionfs_rename()
1375 	struct vnode   *fvp;  in unionfs_rename()
1377 	struct vnode   *tdvp;  in unionfs_rename()
1378 	struct vnode   *tvp;  in unionfs_rename()
1383 	struct vnode   *rfdvp;  in unionfs_rename()
1384 	struct vnode   *rfvp;  in unionfs_rename()
1385 	struct vnode   *rtdvp;  in unionfs_rename()
1386 	struct vnode   *rtvp;  in unionfs_rename()
1460 	 * If we only have a lower vnode, copy the source file to the upper  in unionfs_rename()
1471 			 * fdvp's upper parent directory vnode to be unlocked  in unionfs_rename()
1484 			 * fdvp's upper parent directory vnode to be locked  in unionfs_rename()
1629 	struct vnode   *dvp;  in unionfs_mkdir()
1630 	struct vnode   *udvp;  in unionfs_mkdir()
1631 	struct vnode   *uvp;  in unionfs_mkdir()
1691 	struct vnode   *udvp;  in unionfs_rmdir()
1692 	struct vnode   *uvp;  in unionfs_rmdir()
1693 	struct vnode   *lvp;  in unionfs_rmdir()
1721 			 * directory check also requires the lower vnode lock.  in unionfs_rmdir()
1724 			 * implementations (which require 2-4 vnode locks).  in unionfs_rmdir()
1726 			 * that fails we drops the other two vnode locks,  in unionfs_rmdir()
1783 	struct vnode   *udvp;  in unionfs_symlink()
1784 	struct vnode   *uvp;  in unionfs_symlink()
1830 	struct vnode   *vp;  in unionfs_readdir()
1831 	struct vnode   *uvp;  in unionfs_readdir()
1832 	struct vnode   *lvp;  in unionfs_readdir()
1863 	 * If the vnode is reclaimed while upgrading, we can't safely use unp  in unionfs_readdir()
2035 	struct vnode   *vp;  in unionfs_readlink()
2056 	struct vnode   *uvp;  in unionfs_getwritemount()
2057 	struct vnode   *vp, *ovp;  in unionfs_getwritemount()
2072 	 * If our node has no upper vnode, check the parent directory.  in unionfs_getwritemount()
2074 	 * new upper vnode through CoW.  in unionfs_getwritemount()
2080 		 * Only the root vnode should have an empty parent, but it  in unionfs_getwritemount()
2083 		VNASSERT(vp != NULL, ovp, ("%s: NULL parent vnode", __func__));  in unionfs_getwritemount()
2156 	struct vnode   *vp;  in unionfs_lock()
2157 	struct vnode   *tvp;  in unionfs_lock()
2172 	 * access the unionfs vnode's private data.  We may be able to  in unionfs_lock()
2198 	 * During unmount, the root vnode lock may be taken recursively,  in unionfs_lock()
2199 	 * because it may share the same v_vnlock field as the vnode covered by  in unionfs_lock()
2200 	 * the unionfs mount.  The covered vnode is locked across VFS_UNMOUNT(),  in unionfs_lock()
2214 		 * in which another thread may acquire the lower vnode lock  in unionfs_lock()
2215 		 * and then either doom the unionfs vnode or create an upper  in unionfs_lock()
2216 		 * vnode.  In either case, we will effectively be holding the  in unionfs_lock()
2217 		 * wrong lock, so we must drop the lower vnode lock and  in unionfs_lock()
2223 		 * the vnode private data, ensuring it can't be concurrently  in unionfs_lock()
2226 		 * an upper vnode.  Without those guarantees, we would need to  in unionfs_lock()
2227 		 * reacquire the vnode interlock here.  in unionfs_lock()
2229 		 * this is the root vnode, but the root vnode should always  in unionfs_lock()
2230 		 * have an upper vnode and therefore we should never use its  in unionfs_lock()
2231 		 * lower vnode lock here.  in unionfs_lock()
2248 			    ("%s: vnode doomed during downgrade", __func__));  in unionfs_lock()
2260 	struct vnode   *vp;  in unionfs_unlock()
2261 	struct vnode   *tvp;  in unionfs_unlock()
2281 	struct vnode   *vp;  in unionfs_pathconf()
2296 	struct vnode   *vp;  in unionfs_advlock()
2297 	struct vnode   *uvp;  in unionfs_advlock()
2321 			/* try reopen the vnode */  in unionfs_advlock()
2354 	struct vnode   *vp;  in unionfs_strategy()
2376 	struct vnode   *vp;  in unionfs_getacl()
2397 	struct vnode   *uvp;  in unionfs_setacl()
2398 	struct vnode   *lvp;  in unionfs_setacl()
2437 	struct vnode   *vp;  in unionfs_aclcheck()
2458 	struct vnode   *vp;  in unionfs_openextattr()
2459 	struct vnode   *tvp;  in unionfs_openextattr()
2493 	struct vnode   *vp;  in unionfs_closeextattr()
2494 	struct vnode   *tvp;  in unionfs_closeextattr()
2532 	struct vnode   *vp;  in unionfs_getextattr()
2555 	struct vnode   *uvp;  in unionfs_setextattr()
2556 	struct vnode   *lvp;  in unionfs_setextattr()
2557 	struct vnode   *ovp;  in unionfs_setextattr()
2627 	struct vnode *vp;  in unionfs_listextattr()
2650 	struct vnode   *uvp;  in unionfs_deleteextattr()
2651 	struct vnode   *lvp;  in unionfs_deleteextattr()
2652 	struct vnode   *ovp;  in unionfs_deleteextattr()
2718 	struct vnode   *uvp;  in unionfs_setlabel()
2719 	struct vnode   *lvp;  in unionfs_setlabel()
2759 	struct vnode *tvp, *vp;  in unionfs_add_writecount()
2767 	    ("%s: adding write ref without upper vnode", __func__));  in unionfs_add_writecount()
2789 	struct vnode *dvp, *vp, **vpp, *lvp, *uvp, *tvp, *tdvp, *tempvp;  in unionfs_vput_pair()
2829 		 * If we're being asked to return a locked child vnode, then  in unionfs_vput_pair()
2830 		 * we may need to create a replacement vnode in case the  in unionfs_vput_pair()
2872 	 * We're being asked to return a locked vnode.  At this point, the  in unionfs_vput_pair()
2899 	struct vnode *tvp;  in unionfs_set_text()
2918 	struct vnode *tvp;  in unionfs_unset_text()
2931 	struct vnode *tvp;  in unionfs_unp_bind()
2944 	struct vnode *tvp;  in unionfs_unp_connect()
2957 	struct vnode *tvp;  in unionfs_unp_detach()
2963 	 * vnode locked, so we take the interlock to prevent a concurrent  in unionfs_unp_detach()
2972 		 * Hold the target vnode to prevent a concurrent unionfs  in unionfs_unp_detach()