2 * SPDX-License-Identifier: BSD-3-Clause
4 * Copyright (c) 1992, 1993, 1994, 1995 Jan-Simon Pendry.
5 * Copyright (c) 1992, 1993, 1994, 1995
6 * The Regents of the University of California.
7 * Copyright (c) 2005, 2006, 2012 Masanori Ozawa <ozawa@ongs.co.jp>, ONGS Inc.
8 * Copyright (c) 2006, 2012 Daichi Goto <daichi@freebsd.org>
11 * This code is derived from software contributed to Berkeley by
14 * Redistribution and use in source and binary forms, with or without
15 * modification, are permitted provided that the following conditions
17 * 1. Redistributions of source code must retain the above copyright
18 * notice, this list of conditions and the following disclaimer.
19 * 2. Redistributions in binary form must reproduce the above copyright
20 * notice, this list of conditions and the following disclaimer in the
21 * documentation and/or other materials provided with the distribution.
22 * 3. Neither the name of the University nor the names of its contributors
23 * may be used to endorse or promote products derived from this software
24 * without specific prior written permission.
26 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
27 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
30 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
38 * @(#)union_vnops.c 8.32 (Berkeley) 6/23/95
43 #include <sys/param.h>
44 #include <sys/systm.h>
46 #include <sys/kernel.h>
48 #include <sys/malloc.h>
49 #include <sys/mount.h>
50 #include <sys/mutex.h>
51 #include <sys/namei.h>
52 #include <sys/sysctl.h>
53 #include <sys/vnode.h>
55 #include <sys/fcntl.h>
57 #include <sys/dirent.h>
62 #include <fs/unionfs/union.h>
65 #include <vm/vm_extern.h>
66 #include <vm/vm_object.h>
67 #include <vm/vnode_pager.h>
70 #define UNIONFS_INTERNAL_DEBUG(msg, args...) printf(msg, ## args)
71 #define UNIONFS_IDBG_RENAME
73 #define UNIONFS_INTERNAL_DEBUG(msg, args...)
76 #define KASSERT_UNIONFS_VNODE(vp) \
77 KASSERT(((vp)->v_op == &unionfs_vnodeops), \
78 ("unionfs: it is not unionfs-vnode"))
81 unionfs_lookup(struct vop_cachedlookup_args *ap)
85 int error , uerror, lerror;
87 u_long cnflags, cnflagsbk;
88 struct unionfs_node *dunp;
89 struct vnode *dvp, *udvp, *ldvp, *vp, *uvp, *lvp, *dtmpvp;
91 struct componentname *cnp;
96 error = uerror = lerror = ENOENT;
98 nameiop = cnp->cn_nameiop;
99 cnflags = cnp->cn_flags;
101 dunp = VTOUNIONFS(dvp);
102 udvp = dunp->un_uppervp;
103 ldvp = dunp->un_lowervp;
104 vp = uvp = lvp = NULLVP;
106 *(ap->a_vpp) = NULLVP;
108 UNIONFS_INTERNAL_DEBUG("unionfs_lookup: enter: nameiop=%ld, flags=%lx, path=%s\n", nameiop, cnflags, cnp->cn_nameptr);
110 if (dvp->v_type != VDIR)
114 * If read-only and op is not LOOKUP, will return EROFS.
116 if ((cnflags & ISLASTCN) &&
117 (dvp->v_mount->mnt_flag & MNT_RDONLY) &&
124 if (cnflags & ISDOTDOT) {
125 if (LOOKUP != nameiop && udvp == NULLVP)
128 if (udvp != NULLVP) {
136 error = VOP_LOOKUP(dtmpvp, &vp, cnp);
138 if (dtmpvp == udvp && ldvp != NULLVP) {
140 vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY);
145 * Exchange lock and reference from vp to
146 * dunp->un_dvp. vp is upper/lower vnode, but it
147 * will need to return the unionfs vnode.
149 if (nameiop == DELETE || nameiop == RENAME ||
150 (cnp->cn_lkflags & LK_TYPE_MASK))
155 *(ap->a_vpp) = dunp->un_dvp;
158 if (nameiop == DELETE || nameiop == RENAME)
159 vn_lock(dunp->un_dvp, LK_EXCLUSIVE | LK_RETRY);
160 else if (cnp->cn_lkflags & LK_TYPE_MASK)
161 vn_lock(dunp->un_dvp, cnp->cn_lkflags |
164 vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY);
165 } else if (error == ENOENT && (cnflags & MAKEENTRY) != 0)
166 cache_enter(dvp, NULLVP, cnp);
168 UNIONFS_INTERNAL_DEBUG("unionfs_lookup: leave (%d)\n", error);
176 if (udvp != NULLVP) {
177 uerror = VOP_LOOKUP(udvp, &uvp, cnp);
180 if (udvp == uvp) { /* is dot */
185 UNIONFS_INTERNAL_DEBUG("unionfs_lookup: leave (%d)\n", uerror);
189 if (nameiop == DELETE || nameiop == RENAME ||
190 (cnp->cn_lkflags & LK_TYPE_MASK))
195 if (uerror == ENOENT || uerror == EJUSTRETURN)
196 if (cnp->cn_flags & ISWHITEOUT)
197 iswhiteout = 1; /* don't lookup lower */
198 if (iswhiteout == 0 && ldvp != NULLVP)
199 if (!VOP_GETATTR(udvp, &va, cnp->cn_cred) &&
200 (va.va_flags & OPAQUE))
201 iswhiteout = 1; /* don't lookup lower */
203 UNIONFS_INTERNAL_DEBUG("unionfs_lookup: debug: whiteout=%d, path=%s\n", iswhiteout, cnp->cn_nameptr);
210 if (ldvp != NULLVP && !(cnflags & DOWHITEOUT) && iswhiteout == 0) {
211 /* always op is LOOKUP */
212 cnp->cn_nameiop = LOOKUP;
213 cnflagsbk = cnp->cn_flags;
214 cnp->cn_flags = cnflags;
216 lerror = VOP_LOOKUP(ldvp, &lvp, cnp);
218 cnp->cn_nameiop = nameiop;
219 if (udvp != NULLVP && (uerror == 0 || uerror == EJUSTRETURN))
220 cnp->cn_flags = cnflagsbk;
223 if (ldvp == lvp) { /* is dot */
225 vrele(uvp); /* no need? */
230 UNIONFS_INTERNAL_DEBUG("unionfs_lookup: leave (%d)\n", lerror);
234 if (cnp->cn_lkflags & LK_TYPE_MASK)
240 * check lookup result
242 if (uvp == NULLVP && lvp == NULLVP) {
243 UNIONFS_INTERNAL_DEBUG("unionfs_lookup: leave (%d)\n",
244 (udvp != NULLVP ? uerror : lerror));
245 return (udvp != NULLVP ? uerror : lerror);
251 if (uvp != NULLVP && lvp != NULLVP && uvp->v_type != lvp->v_type) {
259 if (uerror != 0 && uerror != EJUSTRETURN && udvp != NULLVP &&
260 lerror == 0 && lvp != NULLVP && lvp->v_type == VDIR &&
261 !(dvp->v_mount->mnt_flag & MNT_RDONLY) &&
262 (1 < cnp->cn_namelen || '.' != *(cnp->cn_nameptr))) {
263 /* get unionfs vnode in order to create a new shadow dir. */
264 error = unionfs_nodeget(dvp->v_mount, NULLVP, lvp, dvp, &vp,
267 goto unionfs_lookup_out;
269 if (LK_SHARED == (cnp->cn_lkflags & LK_TYPE_MASK))
271 if (LK_EXCLUSIVE != VOP_ISLOCKED(vp)) {
272 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
275 error = unionfs_mkshadowdir(MOUNTTOUNIONFSMOUNT(dvp->v_mount),
276 udvp, VTOUNIONFS(vp), cnp, td);
280 UNIONFSDEBUG("unionfs_lookup: Unable to create shadow dir.");
281 if ((cnp->cn_lkflags & LK_TYPE_MASK) == LK_EXCLUSIVE)
285 goto unionfs_lookup_out;
287 if ((cnp->cn_lkflags & LK_TYPE_MASK) == LK_SHARED)
288 vn_lock(vp, LK_SHARED | LK_RETRY);
299 goto unionfs_lookup_out;
303 if (uvp != NULLVP && uvp->v_type == VSOCK) {
306 if (cnp->cn_lkflags & LK_TYPE_MASK)
307 vn_lock(vp, cnp->cn_lkflags | LK_RETRY);
309 else if (lvp != NULLVP && lvp->v_type == VSOCK) {
312 if (cnp->cn_lkflags & LK_TYPE_MASK)
313 vn_lock(vp, cnp->cn_lkflags | LK_RETRY);
319 error = unionfs_nodeget(dvp->v_mount, uvp, lvp,
322 UNIONFSDEBUG("unionfs_lookup: Unable to create unionfs vnode.");
323 goto unionfs_lookup_out;
325 if ((nameiop == DELETE || nameiop == RENAME) &&
326 (cnp->cn_lkflags & LK_TYPE_MASK) == 0)
327 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
332 if ((cnflags & MAKEENTRY) && vp->v_type != VSOCK)
333 cache_enter(dvp, vp, cnp);
341 if (error == ENOENT && (cnflags & MAKEENTRY) != 0)
342 cache_enter(dvp, NULLVP, cnp);
344 UNIONFS_INTERNAL_DEBUG("unionfs_lookup: leave (%d)\n", error);
350 unionfs_create(struct vop_create_args *ap)
352 struct unionfs_node *dunp;
353 struct componentname *cnp;
358 UNIONFS_INTERNAL_DEBUG("unionfs_create: enter\n");
360 KASSERT_UNIONFS_VNODE(ap->a_dvp);
362 dunp = VTOUNIONFS(ap->a_dvp);
364 udvp = dunp->un_uppervp;
367 if (udvp != NULLVP) {
368 error = VOP_CREATE(udvp, &vp, cnp, ap->a_vap);
370 goto unionfs_create_abort;
372 if (vp->v_type == VSOCK)
376 error = unionfs_nodeget(ap->a_dvp->v_mount, vp, NULLVP,
377 ap->a_dvp, ap->a_vpp, cnp, curthread);
382 unionfs_create_abort:
383 UNIONFS_INTERNAL_DEBUG("unionfs_create: leave (%d)\n", error);
389 unionfs_whiteout(struct vop_whiteout_args *ap)
391 struct unionfs_node *dunp;
392 struct componentname *cnp;
396 UNIONFS_INTERNAL_DEBUG("unionfs_whiteout: enter\n");
398 KASSERT_UNIONFS_VNODE(ap->a_dvp);
400 dunp = VTOUNIONFS(ap->a_dvp);
402 udvp = dunp->un_uppervp;
405 if (udvp != NULLVP) {
406 switch (ap->a_flags) {
410 error = VOP_WHITEOUT(udvp, cnp, ap->a_flags);
418 UNIONFS_INTERNAL_DEBUG("unionfs_whiteout: leave (%d)\n", error);
424 unionfs_mknod(struct vop_mknod_args *ap)
426 struct unionfs_node *dunp;
427 struct componentname *cnp;
432 UNIONFS_INTERNAL_DEBUG("unionfs_mknod: enter\n");
434 KASSERT_UNIONFS_VNODE(ap->a_dvp);
436 dunp = VTOUNIONFS(ap->a_dvp);
438 udvp = dunp->un_uppervp;
441 if (udvp != NULLVP) {
442 error = VOP_MKNOD(udvp, &vp, cnp, ap->a_vap);
444 goto unionfs_mknod_abort;
446 if (vp->v_type == VSOCK)
450 error = unionfs_nodeget(ap->a_dvp->v_mount, vp, NULLVP,
451 ap->a_dvp, ap->a_vpp, cnp, curthread);
457 UNIONFS_INTERNAL_DEBUG("unionfs_mknod: leave (%d)\n", error);
463 unionfs_open(struct vop_open_args *ap)
466 struct unionfs_node *unp;
467 struct unionfs_node_status *unsp;
470 struct vnode *targetvp;
474 UNIONFS_INTERNAL_DEBUG("unionfs_open: enter\n");
476 KASSERT_UNIONFS_VNODE(ap->a_vp);
479 unp = VTOUNIONFS(ap->a_vp);
480 uvp = unp->un_uppervp;
481 lvp = unp->un_lowervp;
486 unionfs_get_node_status(unp, td, &unsp);
488 if (unsp->uns_lower_opencnt > 0 || unsp->uns_upper_opencnt > 0) {
489 /* vnode is already opend. */
490 if (unsp->uns_upper_opencnt > 0)
495 if (targetvp == lvp &&
496 (ap->a_mode & FWRITE) && lvp->v_type == VREG)
499 if (targetvp == NULLVP) {
501 if ((ap->a_mode & FWRITE) && lvp->v_type == VREG) {
502 error = unionfs_copyfile(unp,
503 !(ap->a_mode & O_TRUNC), cred, td);
505 goto unionfs_open_abort;
506 targetvp = uvp = unp->un_uppervp;
513 error = VOP_OPEN(targetvp, ap->a_mode, cred, td, ap->a_fp);
515 if (targetvp == uvp) {
516 if (uvp->v_type == VDIR && lvp != NULLVP &&
517 unsp->uns_lower_opencnt <= 0) {
518 /* open lower for readdir */
519 error = VOP_OPEN(lvp, FREAD, cred, td, NULL);
521 VOP_CLOSE(uvp, ap->a_mode, cred, td);
522 goto unionfs_open_abort;
524 unsp->uns_node_flag |= UNS_OPENL_4_READDIR;
525 unsp->uns_lower_opencnt++;
527 unsp->uns_upper_opencnt++;
529 unsp->uns_lower_opencnt++;
530 unsp->uns_lower_openmode = ap->a_mode;
532 ap->a_vp->v_object = targetvp->v_object;
537 unionfs_tryrem_node_status(unp, unsp);
539 UNIONFS_INTERNAL_DEBUG("unionfs_open: leave (%d)\n", error);
545 unionfs_close(struct vop_close_args *ap)
549 struct unionfs_node *unp;
550 struct unionfs_node_status *unsp;
556 UNIONFS_INTERNAL_DEBUG("unionfs_close: enter\n");
558 KASSERT_UNIONFS_VNODE(ap->a_vp);
562 unp = VTOUNIONFS(vp);
566 if (VOP_ISLOCKED(vp) != LK_EXCLUSIVE) {
567 if (vn_lock(vp, LK_UPGRADE) != 0)
568 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
571 unionfs_get_node_status(unp, td, &unsp);
573 if (unsp->uns_lower_opencnt <= 0 && unsp->uns_upper_opencnt <= 0) {
575 printf("unionfs_close: warning: open count is 0\n");
577 if (unp->un_uppervp != NULLVP)
578 ovp = unp->un_uppervp;
580 ovp = unp->un_lowervp;
581 } else if (unsp->uns_upper_opencnt > 0)
582 ovp = unp->un_uppervp;
584 ovp = unp->un_lowervp;
586 error = VOP_CLOSE(ovp, ap->a_fflag, cred, td);
589 goto unionfs_close_abort;
591 vp->v_object = ovp->v_object;
593 if (ovp == unp->un_uppervp) {
594 unsp->uns_upper_opencnt--;
595 if (unsp->uns_upper_opencnt == 0) {
596 if (unsp->uns_node_flag & UNS_OPENL_4_READDIR) {
597 VOP_CLOSE(unp->un_lowervp, FREAD, cred, td);
598 unsp->uns_node_flag &= ~UNS_OPENL_4_READDIR;
599 unsp->uns_lower_opencnt--;
601 if (unsp->uns_lower_opencnt > 0)
602 vp->v_object = unp->un_lowervp->v_object;
605 unsp->uns_lower_opencnt--;
608 unionfs_tryrem_node_status(unp, unsp);
611 vn_lock(vp, LK_DOWNGRADE | LK_RETRY);
613 UNIONFS_INTERNAL_DEBUG("unionfs_close: leave (%d)\n", error);
619 * Check the access mode toward shadow file/dir.
622 unionfs_check_corrected_access(accmode_t accmode,
627 uid_t uid; /* upper side vnode's uid */
628 gid_t gid; /* upper side vnode's gid */
629 u_short vmode; /* upper side vnode's mode */
638 if (cred->cr_uid == uid) {
643 if (accmode & VWRITE)
645 return ((vmode & mask) == mask ? 0 : EACCES);
650 if (groupmember(gid, cred)) {
655 if (accmode & VWRITE)
657 return ((vmode & mask) == mask ? 0 : EACCES);
665 if (accmode & VWRITE)
668 return ((vmode & mask) == mask ? 0 : EACCES);
672 unionfs_access(struct vop_access_args *ap)
674 struct unionfs_mount *ump;
675 struct unionfs_node *unp;
683 UNIONFS_INTERNAL_DEBUG("unionfs_access: enter\n");
685 KASSERT_UNIONFS_VNODE(ap->a_vp);
687 ump = MOUNTTOUNIONFSMOUNT(ap->a_vp->v_mount);
688 unp = VTOUNIONFS(ap->a_vp);
689 uvp = unp->un_uppervp;
690 lvp = unp->un_lowervp;
692 accmode = ap->a_accmode;
695 if ((accmode & VWRITE) &&
696 (ap->a_vp->v_mount->mnt_flag & MNT_RDONLY)) {
697 switch (ap->a_vp->v_type) {
708 error = VOP_ACCESS(uvp, accmode, ap->a_cred, td);
710 UNIONFS_INTERNAL_DEBUG("unionfs_access: leave (%d)\n", error);
716 if (accmode & VWRITE) {
717 if (ump->um_uppervp->v_mount->mnt_flag & MNT_RDONLY) {
718 switch (ap->a_vp->v_type) {
726 } else if (ap->a_vp->v_type == VREG || ap->a_vp->v_type == VDIR) {
727 /* check shadow file/dir */
728 if (ump->um_copymode != UNIONFS_TRANSPARENT) {
729 error = unionfs_create_uppervattr(ump,
730 lvp, &va, ap->a_cred, td);
734 error = unionfs_check_corrected_access(
735 accmode, &va, ap->a_cred);
740 accmode &= ~(VWRITE | VAPPEND);
741 accmode |= VREAD; /* will copy to upper */
743 error = VOP_ACCESS(lvp, accmode, ap->a_cred, td);
746 UNIONFS_INTERNAL_DEBUG("unionfs_access: leave (%d)\n", error);
752 unionfs_getattr(struct vop_getattr_args *ap)
755 struct unionfs_node *unp;
756 struct unionfs_mount *ump;
762 UNIONFS_INTERNAL_DEBUG("unionfs_getattr: enter\n");
764 KASSERT_UNIONFS_VNODE(ap->a_vp);
766 unp = VTOUNIONFS(ap->a_vp);
767 ump = MOUNTTOUNIONFSMOUNT(ap->a_vp->v_mount);
768 uvp = unp->un_uppervp;
769 lvp = unp->un_lowervp;
773 if ((error = VOP_GETATTR(uvp, ap->a_vap, ap->a_cred)) == 0)
774 ap->a_vap->va_fsid = ap->a_vp->v_mount->mnt_stat.f_fsid.val[0];
776 UNIONFS_INTERNAL_DEBUG("unionfs_getattr: leave mode=%o, uid=%d, gid=%d (%d)\n",
777 ap->a_vap->va_mode, ap->a_vap->va_uid,
778 ap->a_vap->va_gid, error);
783 error = VOP_GETATTR(lvp, ap->a_vap, ap->a_cred);
785 if (error == 0 && !(ump->um_uppervp->v_mount->mnt_flag & MNT_RDONLY)) {
786 /* correct the attr toward shadow file/dir. */
787 if (ap->a_vp->v_type == VREG || ap->a_vp->v_type == VDIR) {
788 unionfs_create_uppervattr_core(ump, ap->a_vap, &va, td);
789 ap->a_vap->va_mode = va.va_mode;
790 ap->a_vap->va_uid = va.va_uid;
791 ap->a_vap->va_gid = va.va_gid;
796 ap->a_vap->va_fsid = ap->a_vp->v_mount->mnt_stat.f_fsid.val[0];
798 UNIONFS_INTERNAL_DEBUG("unionfs_getattr: leave mode=%o, uid=%d, gid=%d (%d)\n",
799 ap->a_vap->va_mode, ap->a_vap->va_uid, ap->a_vap->va_gid, error);
805 unionfs_setattr(struct vop_setattr_args *ap)
808 struct unionfs_node *unp;
814 UNIONFS_INTERNAL_DEBUG("unionfs_setattr: enter\n");
816 KASSERT_UNIONFS_VNODE(ap->a_vp);
819 unp = VTOUNIONFS(ap->a_vp);
820 uvp = unp->un_uppervp;
821 lvp = unp->un_lowervp;
825 if ((ap->a_vp->v_mount->mnt_flag & MNT_RDONLY) &&
826 (vap->va_flags != VNOVAL || vap->va_uid != (uid_t)VNOVAL ||
827 vap->va_gid != (gid_t)VNOVAL || vap->va_atime.tv_sec != VNOVAL ||
828 vap->va_mtime.tv_sec != VNOVAL || vap->va_mode != (mode_t)VNOVAL))
831 if (uvp == NULLVP && lvp->v_type == VREG) {
832 error = unionfs_copyfile(unp, (vap->va_size != 0),
836 uvp = unp->un_uppervp;
840 error = VOP_SETATTR(uvp, vap, ap->a_cred);
842 UNIONFS_INTERNAL_DEBUG("unionfs_setattr: leave (%d)\n", error);
848 unionfs_read(struct vop_read_args *ap)
851 struct unionfs_node *unp;
854 /* UNIONFS_INTERNAL_DEBUG("unionfs_read: enter\n"); */
856 KASSERT_UNIONFS_VNODE(ap->a_vp);
858 unp = VTOUNIONFS(ap->a_vp);
859 tvp = (unp->un_uppervp != NULLVP ? unp->un_uppervp : unp->un_lowervp);
861 error = VOP_READ(tvp, ap->a_uio, ap->a_ioflag, ap->a_cred);
863 /* UNIONFS_INTERNAL_DEBUG("unionfs_read: leave (%d)\n", error); */
869 unionfs_write(struct vop_write_args *ap)
872 struct unionfs_node *unp;
875 /* UNIONFS_INTERNAL_DEBUG("unionfs_write: enter\n"); */
877 KASSERT_UNIONFS_VNODE(ap->a_vp);
879 unp = VTOUNIONFS(ap->a_vp);
880 tvp = (unp->un_uppervp != NULLVP ? unp->un_uppervp : unp->un_lowervp);
882 error = VOP_WRITE(tvp, ap->a_uio, ap->a_ioflag, ap->a_cred);
884 /* UNIONFS_INTERNAL_DEBUG("unionfs_write: leave (%d)\n", error); */
890 unionfs_ioctl(struct vop_ioctl_args *ap)
893 struct unionfs_node *unp;
894 struct unionfs_node_status *unsp;
897 UNIONFS_INTERNAL_DEBUG("unionfs_ioctl: enter\n");
899 KASSERT_UNIONFS_VNODE(ap->a_vp);
901 vn_lock(ap->a_vp, LK_EXCLUSIVE | LK_RETRY);
902 unp = VTOUNIONFS(ap->a_vp);
903 unionfs_get_node_status(unp, ap->a_td, &unsp);
904 ovp = (unsp->uns_upper_opencnt ? unp->un_uppervp : unp->un_lowervp);
905 unionfs_tryrem_node_status(unp, unsp);
906 VOP_UNLOCK(ap->a_vp);
911 error = VOP_IOCTL(ovp, ap->a_command, ap->a_data, ap->a_fflag,
912 ap->a_cred, ap->a_td);
914 UNIONFS_INTERNAL_DEBUG("unionfs_ioctl: leave (%d)\n", error);
920 unionfs_poll(struct vop_poll_args *ap)
922 struct unionfs_node *unp;
923 struct unionfs_node_status *unsp;
926 KASSERT_UNIONFS_VNODE(ap->a_vp);
928 vn_lock(ap->a_vp, LK_EXCLUSIVE | LK_RETRY);
929 unp = VTOUNIONFS(ap->a_vp);
930 unionfs_get_node_status(unp, ap->a_td, &unsp);
931 ovp = (unsp->uns_upper_opencnt ? unp->un_uppervp : unp->un_lowervp);
932 unionfs_tryrem_node_status(unp, unsp);
933 VOP_UNLOCK(ap->a_vp);
938 return (VOP_POLL(ovp, ap->a_events, ap->a_cred, ap->a_td));
942 unionfs_fsync(struct vop_fsync_args *ap)
944 struct unionfs_node *unp;
945 struct unionfs_node_status *unsp;
948 KASSERT_UNIONFS_VNODE(ap->a_vp);
950 unp = VTOUNIONFS(ap->a_vp);
951 unionfs_get_node_status(unp, ap->a_td, &unsp);
952 ovp = (unsp->uns_upper_opencnt ? unp->un_uppervp : unp->un_lowervp);
953 unionfs_tryrem_node_status(unp, unsp);
958 return (VOP_FSYNC(ovp, ap->a_waitfor, ap->a_td));
962 unionfs_remove(struct vop_remove_args *ap)
966 struct unionfs_node *dunp;
967 struct unionfs_node *unp;
968 struct unionfs_mount *ump;
973 struct componentname *cnp;
974 struct componentname cn;
977 UNIONFS_INTERNAL_DEBUG("unionfs_remove: enter\n");
979 KASSERT_UNIONFS_VNODE(ap->a_dvp);
982 dunp = VTOUNIONFS(ap->a_dvp);
983 udvp = dunp->un_uppervp;
987 if (ap->a_vp->v_op != &unionfs_vnodeops) {
988 if (ap->a_vp->v_type != VSOCK)
991 vp = uvp = lvp = NULLVP;
993 VOP_UNLOCK(ap->a_vp);
994 error = unionfs_relookup(udvp, &vp, cnp, &cn, td,
995 cnp->cn_nameptr, strlen(cnp->cn_nameptr), DELETE);
996 if (error != 0 && error != ENOENT) {
997 vn_lock(ap->a_vp, LK_EXCLUSIVE | LK_RETRY);
1001 if (error == 0 && vp == ap->a_vp) {
1002 /* target vnode in upper */
1007 /* target vnode in lower */
1014 vn_lock(ap->a_vp, LK_EXCLUSIVE | LK_RETRY);
1016 path = ap->a_cnp->cn_nameptr;
1019 ump = MOUNTTOUNIONFSMOUNT(ap->a_vp->v_mount);
1020 unp = VTOUNIONFS(ap->a_vp);
1021 uvp = unp->un_uppervp;
1022 lvp = unp->un_lowervp;
1023 path = unp->un_path;
1029 if (uvp != NULLVP) {
1031 * XXX: if the vnode type is VSOCK, it will create whiteout
1034 if (ump == NULL || ump->um_whitemode == UNIONFS_WHITE_ALWAYS ||
1036 cnp->cn_flags |= DOWHITEOUT;
1037 error = VOP_REMOVE(udvp, uvp, cnp);
1038 } else if (lvp != NULLVP)
1039 error = unionfs_mkwhiteout(udvp, cnp, td, path);
1041 UNIONFS_INTERNAL_DEBUG("unionfs_remove: leave (%d)\n", error);
1047 unionfs_link(struct vop_link_args *ap)
1051 struct unionfs_node *dunp;
1052 struct unionfs_node *unp;
1055 struct componentname *cnp;
1058 UNIONFS_INTERNAL_DEBUG("unionfs_link: enter\n");
1060 KASSERT_UNIONFS_VNODE(ap->a_tdvp);
1061 KASSERT_UNIONFS_VNODE(ap->a_vp);
1065 dunp = VTOUNIONFS(ap->a_tdvp);
1067 udvp = dunp->un_uppervp;
1075 if (ap->a_vp->v_op != &unionfs_vnodeops)
1078 unp = VTOUNIONFS(ap->a_vp);
1080 if (unp->un_uppervp == NULLVP) {
1081 if (ap->a_vp->v_type != VREG)
1082 return (EOPNOTSUPP);
1084 error = unionfs_copyfile(unp, 1, cnp->cn_cred, td);
1089 uvp = unp->un_uppervp;
1092 if (needrelookup != 0)
1093 error = unionfs_relookup_for_create(ap->a_tdvp, cnp, td);
1096 error = VOP_LINK(udvp, uvp, cnp);
1098 UNIONFS_INTERNAL_DEBUG("unionfs_link: leave (%d)\n", error);
1104 unionfs_rename(struct vop_rename_args *ap)
1109 struct componentname *fcnp;
1112 struct componentname *tcnp;
1113 struct vnode *ltdvp;
1117 /* rename target vnodes */
1118 struct vnode *rfdvp;
1120 struct vnode *rtdvp;
1124 struct unionfs_mount *ump;
1125 struct unionfs_node *unp;
1127 UNIONFS_INTERNAL_DEBUG("unionfs_rename: enter\n");
1146 if (!(fcnp->cn_flags & HASBUF) || !(tcnp->cn_flags & HASBUF))
1147 panic("unionfs_rename: no name");
1150 /* check for cross device rename */
1151 if (fvp->v_mount != tdvp->v_mount ||
1152 (tvp != NULLVP && fvp->v_mount != tvp->v_mount)) {
1153 if (fvp->v_op != &unionfs_vnodeops)
1157 goto unionfs_rename_abort;
1160 /* Renaming a file to itself has no effect. */
1162 goto unionfs_rename_abort;
1165 * from/to vnode is unionfs node.
1168 KASSERT_UNIONFS_VNODE(fdvp);
1169 KASSERT_UNIONFS_VNODE(fvp);
1170 KASSERT_UNIONFS_VNODE(tdvp);
1172 KASSERT_UNIONFS_VNODE(tvp);
1174 unp = VTOUNIONFS(fdvp);
1175 #ifdef UNIONFS_IDBG_RENAME
1176 UNIONFS_INTERNAL_DEBUG("fdvp=%p, ufdvp=%p, lfdvp=%p\n", fdvp, unp->un_uppervp, unp->un_lowervp);
1178 if (unp->un_uppervp == NULLVP) {
1180 goto unionfs_rename_abort;
1182 rfdvp = unp->un_uppervp;
1185 unp = VTOUNIONFS(fvp);
1186 #ifdef UNIONFS_IDBG_RENAME
1187 UNIONFS_INTERNAL_DEBUG("fvp=%p, ufvp=%p, lfvp=%p\n", fvp, unp->un_uppervp, unp->un_lowervp);
1189 ump = MOUNTTOUNIONFSMOUNT(fvp->v_mount);
1190 if (unp->un_uppervp == NULLVP) {
1191 switch (fvp->v_type) {
1193 if ((error = vn_lock(fvp, LK_EXCLUSIVE)) != 0)
1194 goto unionfs_rename_abort;
1195 error = unionfs_copyfile(unp, 1, fcnp->cn_cred, td);
1198 goto unionfs_rename_abort;
1201 if ((error = vn_lock(fvp, LK_EXCLUSIVE)) != 0)
1202 goto unionfs_rename_abort;
1203 error = unionfs_mkshadowdir(ump, rfdvp, unp, fcnp, td);
1206 goto unionfs_rename_abort;
1210 goto unionfs_rename_abort;
1216 if (unp->un_lowervp != NULLVP)
1217 fcnp->cn_flags |= DOWHITEOUT;
1218 rfvp = unp->un_uppervp;
1221 unp = VTOUNIONFS(tdvp);
1222 #ifdef UNIONFS_IDBG_RENAME
1223 UNIONFS_INTERNAL_DEBUG("tdvp=%p, utdvp=%p, ltdvp=%p\n", tdvp, unp->un_uppervp, unp->un_lowervp);
1225 if (unp->un_uppervp == NULLVP) {
1227 goto unionfs_rename_abort;
1229 rtdvp = unp->un_uppervp;
1230 ltdvp = unp->un_lowervp;
1236 } else if (tvp != NULLVP) {
1237 unp = VTOUNIONFS(tvp);
1238 #ifdef UNIONFS_IDBG_RENAME
1239 UNIONFS_INTERNAL_DEBUG("tvp=%p, utvp=%p, ltvp=%p\n", tvp, unp->un_uppervp, unp->un_lowervp);
1241 if (unp->un_uppervp == NULLVP)
1244 if (tvp->v_type == VDIR) {
1246 goto unionfs_rename_abort;
1248 rtvp = unp->un_uppervp;
1249 ltvp = unp->un_lowervp;
1255 goto unionfs_rename_abort;
1257 if (needrelookup != 0) {
1258 if ((error = vn_lock(fdvp, LK_EXCLUSIVE)) != 0)
1259 goto unionfs_rename_abort;
1260 error = unionfs_relookup_for_delete(fdvp, fcnp, td);
1263 goto unionfs_rename_abort;
1265 /* Locke of tvp is canceled in order to avoid recursive lock. */
1266 if (tvp != NULLVP && tvp != tdvp)
1268 error = unionfs_relookup_for_rename(tdvp, tcnp, td);
1269 if (tvp != NULLVP && tvp != tdvp)
1270 vn_lock(tvp, LK_EXCLUSIVE | LK_RETRY);
1272 goto unionfs_rename_abort;
1275 error = VOP_RENAME(rfdvp, rfvp, fcnp, rtdvp, rtvp, tcnp);
1278 if (rtvp != NULLVP && rtvp->v_type == VDIR)
1280 if (fvp->v_type == VDIR && fdvp != tdvp)
1284 if (ltdvp != NULLVP)
1290 if (tvp != rtvp && tvp != NULLVP) {
1301 UNIONFS_INTERNAL_DEBUG("unionfs_rename: leave (%d)\n", error);
1305 unionfs_rename_abort:
1309 if (tvp != NULLVP) {
1315 if (tvp != rtvp && rtvp != NULLVP)
1324 UNIONFS_INTERNAL_DEBUG("unionfs_rename: leave (%d)\n", error);
1330 unionfs_mkdir(struct vop_mkdir_args *ap)
1334 struct unionfs_node *dunp;
1335 struct componentname *cnp;
1341 UNIONFS_INTERNAL_DEBUG("unionfs_mkdir: enter\n");
1343 KASSERT_UNIONFS_VNODE(ap->a_dvp);
1346 dunp = VTOUNIONFS(ap->a_dvp);
1348 lkflags = cnp->cn_lkflags;
1350 udvp = dunp->un_uppervp;
1352 if (udvp != NULLVP) {
1354 if (!(cnp->cn_flags & ISWHITEOUT)) {
1355 error = VOP_GETATTR(udvp, &va, cnp->cn_cred);
1358 if (va.va_flags & OPAQUE)
1359 cnp->cn_flags |= ISWHITEOUT;
1362 if ((error = VOP_MKDIR(udvp, &uvp, cnp, ap->a_vap)) == 0) {
1364 cnp->cn_lkflags = LK_EXCLUSIVE;
1365 error = unionfs_nodeget(ap->a_dvp->v_mount, uvp, NULLVP,
1366 ap->a_dvp, ap->a_vpp, cnp, td);
1367 cnp->cn_lkflags = lkflags;
1372 UNIONFS_INTERNAL_DEBUG("unionfs_mkdir: leave (%d)\n", error);
1378 unionfs_rmdir(struct vop_rmdir_args *ap)
1381 struct unionfs_node *dunp;
1382 struct unionfs_node *unp;
1383 struct unionfs_mount *ump;
1384 struct componentname *cnp;
1390 UNIONFS_INTERNAL_DEBUG("unionfs_rmdir: enter\n");
1392 KASSERT_UNIONFS_VNODE(ap->a_dvp);
1393 KASSERT_UNIONFS_VNODE(ap->a_vp);
1396 dunp = VTOUNIONFS(ap->a_dvp);
1397 unp = VTOUNIONFS(ap->a_vp);
1400 udvp = dunp->un_uppervp;
1401 uvp = unp->un_uppervp;
1402 lvp = unp->un_lowervp;
1408 return (EOPNOTSUPP);
1410 if (uvp != NULLVP) {
1411 if (lvp != NULLVP) {
1412 error = unionfs_check_rmdir(ap->a_vp, cnp->cn_cred, td);
1416 ump = MOUNTTOUNIONFSMOUNT(ap->a_vp->v_mount);
1417 if (ump->um_whitemode == UNIONFS_WHITE_ALWAYS || lvp != NULLVP)
1418 cnp->cn_flags |= DOWHITEOUT;
1419 error = unionfs_relookup_for_delete(ap->a_dvp, cnp, td);
1421 error = VOP_RMDIR(udvp, uvp, cnp);
1423 else if (lvp != NULLVP)
1424 error = unionfs_mkwhiteout(udvp, cnp, td, unp->un_path);
1427 cache_purge(ap->a_dvp);
1428 cache_purge(ap->a_vp);
1431 UNIONFS_INTERNAL_DEBUG("unionfs_rmdir: leave (%d)\n", error);
1437 unionfs_symlink(struct vop_symlink_args *ap)
1441 struct unionfs_node *dunp;
1442 struct componentname *cnp;
1447 UNIONFS_INTERNAL_DEBUG("unionfs_symlink: enter\n");
1449 KASSERT_UNIONFS_VNODE(ap->a_dvp);
1452 dunp = VTOUNIONFS(ap->a_dvp);
1454 lkflags = cnp->cn_lkflags;
1456 udvp = dunp->un_uppervp;
1458 if (udvp != NULLVP) {
1459 error = VOP_SYMLINK(udvp, &uvp, cnp, ap->a_vap, ap->a_target);
1462 cnp->cn_lkflags = LK_EXCLUSIVE;
1463 error = unionfs_nodeget(ap->a_dvp->v_mount, uvp, NULLVP,
1464 ap->a_dvp, ap->a_vpp, cnp, td);
1465 cnp->cn_lkflags = lkflags;
1470 UNIONFS_INTERNAL_DEBUG("unionfs_symlink: leave (%d)\n", error);
1476 unionfs_readdir(struct vop_readdir_args *ap)
1482 struct unionfs_node *unp;
1483 struct unionfs_node_status *unsp;
1494 UNIONFS_INTERNAL_DEBUG("unionfs_readdir: enter\n");
1496 KASSERT_UNIONFS_VNODE(ap->a_vp);
1510 if (vp->v_type != VDIR)
1513 /* check the open count. unionfs needs to open before readdir. */
1514 if (VOP_ISLOCKED(vp) != LK_EXCLUSIVE) {
1515 if (vn_lock(vp, LK_UPGRADE) != 0)
1516 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
1519 unp = VTOUNIONFS(vp);
1523 uvp = unp->un_uppervp;
1524 lvp = unp->un_lowervp;
1525 unionfs_get_node_status(unp, td, &unsp);
1526 if ((uvp != NULLVP && unsp->uns_upper_opencnt <= 0) ||
1527 (lvp != NULLVP && unsp->uns_lower_opencnt <= 0)) {
1528 unionfs_tryrem_node_status(unp, unsp);
1533 vn_lock(vp, LK_DOWNGRADE | LK_RETRY);
1535 goto unionfs_readdir_exit;
1538 if (uvp != NULLVP && lvp != NULLVP) {
1539 if ((error = VOP_GETATTR(uvp, &va, ap->a_cred)) != 0)
1540 goto unionfs_readdir_exit;
1541 if (va.va_flags & OPAQUE)
1546 if (uvp != NULLVP && lvp == NULLVP) {
1547 error = VOP_READDIR(uvp, uio, ap->a_cred, ap->a_eofflag,
1548 ap->a_ncookies, ap->a_cookies);
1549 unsp->uns_readdir_status = 0;
1551 goto unionfs_readdir_exit;
1555 if (uvp == NULLVP && lvp != NULLVP) {
1556 error = VOP_READDIR(lvp, uio, ap->a_cred, ap->a_eofflag,
1557 ap->a_ncookies, ap->a_cookies);
1558 unsp->uns_readdir_status = 2;
1560 goto unionfs_readdir_exit;
1564 * readdir upper and lower
1566 KASSERT(uvp != NULLVP, ("unionfs_readdir: null upper vp"));
1567 KASSERT(lvp != NULLVP, ("unionfs_readdir: null lower vp"));
1568 if (uio->uio_offset == 0)
1569 unsp->uns_readdir_status = 0;
1571 if (unsp->uns_readdir_status == 0) {
1573 error = VOP_READDIR(uvp, uio, ap->a_cred, &eofflag,
1574 ap->a_ncookies, ap->a_cookies);
1576 if (error != 0 || eofflag == 0)
1577 goto unionfs_readdir_exit;
1578 unsp->uns_readdir_status = 1;
1581 * UFS(and other FS) needs size of uio_resid larger than
1583 * size of DIRBLKSIZ equals DEV_BSIZE.
1584 * (see: ufs/ufs/ufs_vnops.c ufs_readdir func , ufs/ufs/dir.h)
1586 if (uio->uio_resid <= (uio->uio_resid & (DEV_BSIZE -1)))
1587 goto unionfs_readdir_exit;
1591 * It prepares to readdir in lower.
1593 if (ap->a_ncookies != NULL) {
1594 ncookies_bk = *(ap->a_ncookies);
1595 *(ap->a_ncookies) = 0;
1597 if (ap->a_cookies != NULL) {
1598 cookies_bk = *(ap->a_cookies);
1599 *(ap->a_cookies) = NULL;
1603 /* initialize for readdir in lower */
1604 if (unsp->uns_readdir_status == 1) {
1605 unsp->uns_readdir_status = 2;
1607 * Backup uio_offset. See the comment after the
1608 * VOP_READDIR call on the lower layer.
1610 uio_offset_bk = uio->uio_offset;
1611 uio->uio_offset = 0;
1614 if (lvp == NULLVP) {
1616 goto unionfs_readdir_exit;
1619 error = VOP_READDIR(lvp, uio, ap->a_cred, ap->a_eofflag,
1620 ap->a_ncookies, ap->a_cookies);
1623 * We can't return an uio_offset of 0: this would trigger an
1624 * infinite loop, because the next call to unionfs_readdir would
1625 * always restart with the upper layer (uio_offset == 0) and
1626 * always return some data.
1628 * This happens when the lower layer root directory is removed.
1629 * (A root directory deleting of unionfs should not be permitted.
1630 * But current VFS can not do it.)
1632 if (uio->uio_offset == 0)
1633 uio->uio_offset = uio_offset_bk;
1635 if (cookies_bk != NULL) {
1638 u_long *newcookies, *pos;
1640 size = *(ap->a_ncookies) + ncookies_bk;
1641 newcookies = (u_long *) malloc(size * sizeof(u_long),
1645 memcpy(pos, cookies_bk, ncookies_bk * sizeof(u_long));
1647 memcpy(pos, *(ap->a_cookies), *(ap->a_ncookies) * sizeof(u_long));
1648 free(cookies_bk, M_TEMP);
1649 free(*(ap->a_cookies), M_TEMP);
1650 *(ap->a_ncookies) = size;
1651 *(ap->a_cookies) = newcookies;
1654 unionfs_readdir_exit:
1655 if (error != 0 && ap->a_eofflag != NULL)
1656 *(ap->a_eofflag) = 1;
1658 UNIONFS_INTERNAL_DEBUG("unionfs_readdir: leave (%d)\n", error);
1664 unionfs_readlink(struct vop_readlink_args *ap)
1667 struct unionfs_node *unp;
1670 UNIONFS_INTERNAL_DEBUG("unionfs_readlink: enter\n");
1672 KASSERT_UNIONFS_VNODE(ap->a_vp);
1674 unp = VTOUNIONFS(ap->a_vp);
1675 vp = (unp->un_uppervp != NULLVP ? unp->un_uppervp : unp->un_lowervp);
1677 error = VOP_READLINK(vp, ap->a_uio, ap->a_cred);
1679 UNIONFS_INTERNAL_DEBUG("unionfs_readlink: leave (%d)\n", error);
1685 unionfs_getwritemount(struct vop_getwritemount_args *ap)
1691 UNIONFS_INTERNAL_DEBUG("unionfs_getwritemount: enter\n");
1696 if (vp == NULLVP || (vp->v_mount->mnt_flag & MNT_RDONLY))
1699 KASSERT_UNIONFS_VNODE(vp);
1701 uvp = UNIONFSVPTOUPPERVP(vp);
1702 if (uvp == NULLVP && VREG == vp->v_type)
1703 uvp = UNIONFSVPTOUPPERVP(VTOUNIONFS(vp)->un_dvp);
1706 error = VOP_GETWRITEMOUNT(uvp, ap->a_mpp);
1709 if (vp->v_holdcnt == 0)
1716 UNIONFS_INTERNAL_DEBUG("unionfs_getwritemount: leave (%d)\n", error);
1722 unionfs_inactive(struct vop_inactive_args *ap)
1724 ap->a_vp->v_object = NULL;
1730 unionfs_reclaim(struct vop_reclaim_args *ap)
1732 /* UNIONFS_INTERNAL_DEBUG("unionfs_reclaim: enter\n"); */
1734 unionfs_noderem(ap->a_vp, curthread);
1736 /* UNIONFS_INTERNAL_DEBUG("unionfs_reclaim: leave\n"); */
1742 unionfs_print(struct vop_print_args *ap)
1744 struct unionfs_node *unp;
1745 /* struct unionfs_node_status *unsp; */
1747 unp = VTOUNIONFS(ap->a_vp);
1748 /* unionfs_get_node_status(unp, curthread, &unsp); */
1750 printf("unionfs_vp=%p, uppervp=%p, lowervp=%p\n",
1751 ap->a_vp, unp->un_uppervp, unp->un_lowervp);
1753 printf("unionfs opencnt: uppervp=%d, lowervp=%d\n",
1754 unsp->uns_upper_opencnt, unsp->uns_lower_opencnt);
1757 if (unp->un_uppervp != NULLVP)
1758 vn_printf(unp->un_uppervp, "unionfs: upper ");
1759 if (unp->un_lowervp != NULLVP)
1760 vn_printf(unp->un_lowervp, "unionfs: lower ");
1766 unionfs_islocked(struct vop_islocked_args *ap)
1768 struct unionfs_node *unp;
1770 KASSERT_UNIONFS_VNODE(ap->a_vp);
1772 unp = VTOUNIONFS(ap->a_vp);
1774 return (vop_stdislocked(ap));
1776 if (unp->un_uppervp != NULLVP)
1777 return (VOP_ISLOCKED(unp->un_uppervp));
1778 if (unp->un_lowervp != NULLVP)
1779 return (VOP_ISLOCKED(unp->un_lowervp));
1780 return (vop_stdislocked(ap));
1784 unionfs_get_llt_revlock(struct vnode *vp, int flags)
1790 switch (flags & LK_TYPE_MASK) {
1792 if (VOP_ISLOCKED(vp) == LK_EXCLUSIVE)
1793 revlock = LK_UPGRADE;
1795 revlock = LK_RELEASE;
1799 revlock = LK_RELEASE;
1802 revlock = LK_UPGRADE;
1812 * The state of an acquired lock is adjusted similarly to
1813 * the time of error generating.
1814 * flags: LK_RELEASE or LK_UPGRADE
1817 unionfs_revlock(struct vnode *vp, int flags)
1819 if (flags & LK_RELEASE)
1820 VOP_UNLOCK_FLAGS(vp, flags);
1823 if (vn_lock(vp, flags) != 0)
1824 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
1829 unionfs_lock(struct vop_lock1_args *ap)
1837 struct unionfs_mount *ump;
1838 struct unionfs_node *unp;
1843 KASSERT_UNIONFS_VNODE(ap->a_vp);
1848 flags = ap->a_flags;
1851 if (LK_RELEASE == (flags & LK_TYPE_MASK) || !(flags & LK_TYPE_MASK))
1852 return (VOP_UNLOCK_FLAGS(vp, flags | LK_RELEASE));
1854 if ((flags & LK_INTERLOCK) == 0)
1859 goto unionfs_lock_null_vnode;
1861 ump = MOUNTTOUNIONFSMOUNT(mp);
1862 unp = VTOUNIONFS(vp);
1863 if (ump == NULL || unp == NULL)
1864 goto unionfs_lock_null_vnode;
1865 lvp = unp->un_lowervp;
1866 uvp = unp->un_uppervp;
1868 if ((revlock = unionfs_get_llt_revlock(vp, flags)) == 0)
1869 panic("unknown lock type: 0x%x", flags & LK_TYPE_MASK);
1871 if ((vp->v_iflag & VI_OWEINACT) != 0)
1875 * Sometimes, lower or upper is already exclusive locked.
1876 * (ex. vfs_domount: mounted vnode is already locked.)
1878 if ((flags & LK_TYPE_MASK) == LK_EXCLUSIVE &&
1879 vp == ump->um_rootvp)
1880 flags |= LK_CANRECURSE;
1882 if (lvp != NULLVP) {
1883 if (uvp != NULLVP && flags & LK_UPGRADE) {
1884 /* Share Lock is once released and a deadlock is avoided. */
1888 unp = VTOUNIONFS(vp);
1890 /* vnode is released. */
1897 VI_LOCK_FLAGS(lvp, MTX_DUPOK);
1898 flags |= LK_INTERLOCK;
1902 ap->a_flags &= ~LK_INTERLOCK;
1904 error = VOP_LOCK(lvp, flags);
1907 unp = VTOUNIONFS(vp);
1909 /* vnode is released. */
1916 return (vop_stdlock(ap));
1920 if (error == 0 && uvp != NULLVP) {
1921 if (uhold && flags & LK_UPGRADE) {
1922 flags &= ~LK_TYPE_MASK;
1923 flags |= LK_EXCLUSIVE;
1925 VI_LOCK_FLAGS(uvp, MTX_DUPOK);
1926 flags |= LK_INTERLOCK;
1933 ap->a_flags &= ~LK_INTERLOCK;
1935 error = VOP_LOCK(uvp, flags);
1938 unp = VTOUNIONFS(vp);
1940 /* vnode is released. */
1945 if (lvp != NULLVP) {
1949 return (vop_stdlock(ap));
1951 if (error != 0 && lvp != NULLVP) {
1954 unionfs_revlock(lvp, revlock);
1968 unionfs_lock_null_vnode:
1969 ap->a_flags |= LK_INTERLOCK;
1970 return (vop_stdlock(ap));
1974 unionfs_unlock(struct vop_unlock_args *ap)
1981 struct unionfs_node *unp;
1983 KASSERT_UNIONFS_VNODE(ap->a_vp);
1989 unp = VTOUNIONFS(vp);
1991 goto unionfs_unlock_null_vnode;
1992 lvp = unp->un_lowervp;
1993 uvp = unp->un_uppervp;
1995 if (lvp != NULLVP) {
1997 error = VOP_UNLOCK(lvp);
2000 if (error == 0 && uvp != NULLVP) {
2003 error = VOP_UNLOCK(uvp);
2013 unionfs_unlock_null_vnode:
2014 return (vop_stdunlock(ap));
2018 unionfs_pathconf(struct vop_pathconf_args *ap)
2020 struct unionfs_node *unp;
2023 KASSERT_UNIONFS_VNODE(ap->a_vp);
2025 unp = VTOUNIONFS(ap->a_vp);
2026 vp = (unp->un_uppervp != NULLVP ? unp->un_uppervp : unp->un_lowervp);
2028 return (VOP_PATHCONF(vp, ap->a_name, ap->a_retval));
2032 unionfs_advlock(struct vop_advlock_args *ap)
2035 struct unionfs_node *unp;
2036 struct unionfs_node_status *unsp;
2041 UNIONFS_INTERNAL_DEBUG("unionfs_advlock: enter\n");
2043 KASSERT_UNIONFS_VNODE(ap->a_vp);
2048 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
2050 unp = VTOUNIONFS(ap->a_vp);
2051 uvp = unp->un_uppervp;
2053 if (uvp == NULLVP) {
2054 error = unionfs_copyfile(unp, 1, td->td_ucred, td);
2056 goto unionfs_advlock_abort;
2057 uvp = unp->un_uppervp;
2059 unionfs_get_node_status(unp, td, &unsp);
2060 if (unsp->uns_lower_opencnt > 0) {
2061 /* try reopen the vnode */
2062 error = VOP_OPEN(uvp, unsp->uns_lower_openmode,
2063 td->td_ucred, td, NULL);
2065 goto unionfs_advlock_abort;
2066 unsp->uns_upper_opencnt++;
2067 VOP_CLOSE(unp->un_lowervp, unsp->uns_lower_openmode, td->td_ucred, td);
2068 unsp->uns_lower_opencnt--;
2070 unionfs_tryrem_node_status(unp, unsp);
2075 error = VOP_ADVLOCK(uvp, ap->a_id, ap->a_op, ap->a_fl, ap->a_flags);
2077 UNIONFS_INTERNAL_DEBUG("unionfs_advlock: leave (%d)\n", error);
2081 unionfs_advlock_abort:
2084 UNIONFS_INTERNAL_DEBUG("unionfs_advlock: leave (%d)\n", error);
2090 unionfs_strategy(struct vop_strategy_args *ap)
2092 struct unionfs_node *unp;
2095 KASSERT_UNIONFS_VNODE(ap->a_vp);
2097 unp = VTOUNIONFS(ap->a_vp);
2098 vp = (unp->un_uppervp != NULLVP ? unp->un_uppervp : unp->un_lowervp);
2102 panic("unionfs_strategy: nullvp");
2104 if (ap->a_bp->b_iocmd == BIO_WRITE && vp == unp->un_lowervp)
2105 panic("unionfs_strategy: writing to lowervp");
2108 return (VOP_STRATEGY(vp, ap->a_bp));
2112 unionfs_getacl(struct vop_getacl_args *ap)
2115 struct unionfs_node *unp;
2118 KASSERT_UNIONFS_VNODE(ap->a_vp);
2120 unp = VTOUNIONFS(ap->a_vp);
2121 vp = (unp->un_uppervp != NULLVP ? unp->un_uppervp : unp->un_lowervp);
2123 UNIONFS_INTERNAL_DEBUG("unionfs_getacl: enter\n");
2125 error = VOP_GETACL(vp, ap->a_type, ap->a_aclp, ap->a_cred, ap->a_td);
2127 UNIONFS_INTERNAL_DEBUG("unionfs_getacl: leave (%d)\n", error);
2133 unionfs_setacl(struct vop_setacl_args *ap)
2136 struct unionfs_node *unp;
2141 UNIONFS_INTERNAL_DEBUG("unionfs_setacl: enter\n");
2143 KASSERT_UNIONFS_VNODE(ap->a_vp);
2146 unp = VTOUNIONFS(ap->a_vp);
2147 uvp = unp->un_uppervp;
2148 lvp = unp->un_lowervp;
2151 if (ap->a_vp->v_mount->mnt_flag & MNT_RDONLY)
2154 if (uvp == NULLVP && lvp->v_type == VREG) {
2155 if ((error = unionfs_copyfile(unp, 1, ap->a_cred, td)) != 0)
2157 uvp = unp->un_uppervp;
2161 error = VOP_SETACL(uvp, ap->a_type, ap->a_aclp, ap->a_cred, td);
2163 UNIONFS_INTERNAL_DEBUG("unionfs_setacl: leave (%d)\n", error);
2169 unionfs_aclcheck(struct vop_aclcheck_args *ap)
2172 struct unionfs_node *unp;
2175 UNIONFS_INTERNAL_DEBUG("unionfs_aclcheck: enter\n");
2177 KASSERT_UNIONFS_VNODE(ap->a_vp);
2179 unp = VTOUNIONFS(ap->a_vp);
2180 vp = (unp->un_uppervp != NULLVP ? unp->un_uppervp : unp->un_lowervp);
2182 error = VOP_ACLCHECK(vp, ap->a_type, ap->a_aclp, ap->a_cred, ap->a_td);
2184 UNIONFS_INTERNAL_DEBUG("unionfs_aclcheck: leave (%d)\n", error);
2190 unionfs_openextattr(struct vop_openextattr_args *ap)
2193 struct unionfs_node *unp;
2197 KASSERT_UNIONFS_VNODE(ap->a_vp);
2200 unp = VTOUNIONFS(vp);
2201 tvp = (unp->un_uppervp != NULLVP ? unp->un_uppervp : unp->un_lowervp);
2203 if ((tvp == unp->un_uppervp && (unp->un_flag & UNIONFS_OPENEXTU)) ||
2204 (tvp == unp->un_lowervp && (unp->un_flag & UNIONFS_OPENEXTL)))
2207 error = VOP_OPENEXTATTR(tvp, ap->a_cred, ap->a_td);
2210 if (vn_lock(vp, LK_UPGRADE) != 0)
2211 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
2212 if (tvp == unp->un_uppervp)
2213 unp->un_flag |= UNIONFS_OPENEXTU;
2215 unp->un_flag |= UNIONFS_OPENEXTL;
2216 vn_lock(vp, LK_DOWNGRADE | LK_RETRY);
2223 unionfs_closeextattr(struct vop_closeextattr_args *ap)
2226 struct unionfs_node *unp;
2230 KASSERT_UNIONFS_VNODE(ap->a_vp);
2233 unp = VTOUNIONFS(vp);
2236 if (unp->un_flag & UNIONFS_OPENEXTU)
2237 tvp = unp->un_uppervp;
2238 else if (unp->un_flag & UNIONFS_OPENEXTL)
2239 tvp = unp->un_lowervp;
2242 return (EOPNOTSUPP);
2244 error = VOP_CLOSEEXTATTR(tvp, ap->a_commit, ap->a_cred, ap->a_td);
2247 if (vn_lock(vp, LK_UPGRADE) != 0)
2248 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
2249 if (tvp == unp->un_uppervp)
2250 unp->un_flag &= ~UNIONFS_OPENEXTU;
2252 unp->un_flag &= ~UNIONFS_OPENEXTL;
2253 vn_lock(vp, LK_DOWNGRADE | LK_RETRY);
2260 unionfs_getextattr(struct vop_getextattr_args *ap)
2262 struct unionfs_node *unp;
2265 KASSERT_UNIONFS_VNODE(ap->a_vp);
2267 unp = VTOUNIONFS(ap->a_vp);
2270 if (unp->un_flag & UNIONFS_OPENEXTU)
2271 vp = unp->un_uppervp;
2272 else if (unp->un_flag & UNIONFS_OPENEXTL)
2273 vp = unp->un_lowervp;
2276 return (EOPNOTSUPP);
2278 return (VOP_GETEXTATTR(vp, ap->a_attrnamespace, ap->a_name,
2279 ap->a_uio, ap->a_size, ap->a_cred, ap->a_td));
2283 unionfs_setextattr(struct vop_setextattr_args *ap)
2286 struct unionfs_node *unp;
2293 KASSERT_UNIONFS_VNODE(ap->a_vp);
2296 unp = VTOUNIONFS(ap->a_vp);
2297 uvp = unp->un_uppervp;
2298 lvp = unp->un_lowervp;
2303 UNIONFS_INTERNAL_DEBUG("unionfs_setextattr: enter (un_flag=%x)\n", unp->un_flag);
2305 if (ap->a_vp->v_mount->mnt_flag & MNT_RDONLY)
2308 if (unp->un_flag & UNIONFS_OPENEXTU)
2309 ovp = unp->un_uppervp;
2310 else if (unp->un_flag & UNIONFS_OPENEXTL)
2311 ovp = unp->un_lowervp;
2314 return (EOPNOTSUPP);
2316 if (ovp == lvp && lvp->v_type == VREG) {
2317 VOP_CLOSEEXTATTR(lvp, 0, cred, td);
2318 if (uvp == NULLVP &&
2319 (error = unionfs_copyfile(unp, 1, cred, td)) != 0) {
2320 unionfs_setextattr_reopen:
2321 if ((unp->un_flag & UNIONFS_OPENEXTL) &&
2322 VOP_OPENEXTATTR(lvp, cred, td)) {
2324 panic("unionfs: VOP_OPENEXTATTR failed");
2326 unp->un_flag &= ~UNIONFS_OPENEXTL;
2328 goto unionfs_setextattr_abort;
2330 uvp = unp->un_uppervp;
2331 if ((error = VOP_OPENEXTATTR(uvp, cred, td)) != 0)
2332 goto unionfs_setextattr_reopen;
2333 unp->un_flag &= ~UNIONFS_OPENEXTL;
2334 unp->un_flag |= UNIONFS_OPENEXTU;
2339 error = VOP_SETEXTATTR(ovp, ap->a_attrnamespace, ap->a_name,
2340 ap->a_uio, cred, td);
2342 unionfs_setextattr_abort:
2343 UNIONFS_INTERNAL_DEBUG("unionfs_setextattr: leave (%d)\n", error);
2349 unionfs_listextattr(struct vop_listextattr_args *ap)
2351 struct unionfs_node *unp;
2354 KASSERT_UNIONFS_VNODE(ap->a_vp);
2356 unp = VTOUNIONFS(ap->a_vp);
2359 if (unp->un_flag & UNIONFS_OPENEXTU)
2360 vp = unp->un_uppervp;
2361 else if (unp->un_flag & UNIONFS_OPENEXTL)
2362 vp = unp->un_lowervp;
2365 return (EOPNOTSUPP);
2367 return (VOP_LISTEXTATTR(vp, ap->a_attrnamespace, ap->a_uio,
2368 ap->a_size, ap->a_cred, ap->a_td));
2372 unionfs_deleteextattr(struct vop_deleteextattr_args *ap)
2375 struct unionfs_node *unp;
2382 KASSERT_UNIONFS_VNODE(ap->a_vp);
2385 unp = VTOUNIONFS(ap->a_vp);
2386 uvp = unp->un_uppervp;
2387 lvp = unp->un_lowervp;
2392 UNIONFS_INTERNAL_DEBUG("unionfs_deleteextattr: enter (un_flag=%x)\n", unp->un_flag);
2394 if (ap->a_vp->v_mount->mnt_flag & MNT_RDONLY)
2397 if (unp->un_flag & UNIONFS_OPENEXTU)
2398 ovp = unp->un_uppervp;
2399 else if (unp->un_flag & UNIONFS_OPENEXTL)
2400 ovp = unp->un_lowervp;
2403 return (EOPNOTSUPP);
2405 if (ovp == lvp && lvp->v_type == VREG) {
2406 VOP_CLOSEEXTATTR(lvp, 0, cred, td);
2407 if (uvp == NULLVP &&
2408 (error = unionfs_copyfile(unp, 1, cred, td)) != 0) {
2409 unionfs_deleteextattr_reopen:
2410 if ((unp->un_flag & UNIONFS_OPENEXTL) &&
2411 VOP_OPENEXTATTR(lvp, cred, td)) {
2413 panic("unionfs: VOP_OPENEXTATTR failed");
2415 unp->un_flag &= ~UNIONFS_OPENEXTL;
2417 goto unionfs_deleteextattr_abort;
2419 uvp = unp->un_uppervp;
2420 if ((error = VOP_OPENEXTATTR(uvp, cred, td)) != 0)
2421 goto unionfs_deleteextattr_reopen;
2422 unp->un_flag &= ~UNIONFS_OPENEXTL;
2423 unp->un_flag |= UNIONFS_OPENEXTU;
2428 error = VOP_DELETEEXTATTR(ovp, ap->a_attrnamespace, ap->a_name,
2429 ap->a_cred, ap->a_td);
2431 unionfs_deleteextattr_abort:
2432 UNIONFS_INTERNAL_DEBUG("unionfs_deleteextattr: leave (%d)\n", error);
2438 unionfs_setlabel(struct vop_setlabel_args *ap)
2441 struct unionfs_node *unp;
2446 UNIONFS_INTERNAL_DEBUG("unionfs_setlabel: enter\n");
2448 KASSERT_UNIONFS_VNODE(ap->a_vp);
2451 unp = VTOUNIONFS(ap->a_vp);
2452 uvp = unp->un_uppervp;
2453 lvp = unp->un_lowervp;
2456 if (ap->a_vp->v_mount->mnt_flag & MNT_RDONLY)
2459 if (uvp == NULLVP && lvp->v_type == VREG) {
2460 if ((error = unionfs_copyfile(unp, 1, ap->a_cred, td)) != 0)
2462 uvp = unp->un_uppervp;
2466 error = VOP_SETLABEL(uvp, ap->a_label, ap->a_cred, td);
2468 UNIONFS_INTERNAL_DEBUG("unionfs_setlabel: leave (%d)\n", error);
2474 unionfs_vptofh(struct vop_vptofh_args *ap)
2476 return (EOPNOTSUPP);
2480 unionfs_add_writecount(struct vop_add_writecount_args *ap)
2482 struct vnode *tvp, *vp;
2483 struct unionfs_node *unp;
2487 unp = VTOUNIONFS(vp);
2488 tvp = unp->un_uppervp != NULL ? unp->un_uppervp : unp->un_lowervp;
2490 /* text refs are bypassed to lowervp */
2491 VNASSERT(vp->v_writecount >= 0, vp, ("wrong null writecount"));
2492 VNASSERT(vp->v_writecount + ap->a_inc >= 0, vp,
2493 ("wrong writecount inc %d", ap->a_inc));
2495 error = VOP_ADD_WRITECOUNT(tvp, ap->a_inc);
2496 else if (vp->v_writecount < 0)
2501 vp->v_writecount += ap->a_inc;
2506 struct vop_vector unionfs_vnodeops = {
2507 .vop_default = &default_vnodeops,
2509 .vop_access = unionfs_access,
2510 .vop_aclcheck = unionfs_aclcheck,
2511 .vop_advlock = unionfs_advlock,
2512 .vop_bmap = VOP_EOPNOTSUPP,
2513 .vop_cachedlookup = unionfs_lookup,
2514 .vop_close = unionfs_close,
2515 .vop_closeextattr = unionfs_closeextattr,
2516 .vop_create = unionfs_create,
2517 .vop_deleteextattr = unionfs_deleteextattr,
2518 .vop_fsync = unionfs_fsync,
2519 .vop_getacl = unionfs_getacl,
2520 .vop_getattr = unionfs_getattr,
2521 .vop_getextattr = unionfs_getextattr,
2522 .vop_getwritemount = unionfs_getwritemount,
2523 .vop_inactive = unionfs_inactive,
2524 .vop_need_inactive = vop_stdneed_inactive,
2525 .vop_islocked = unionfs_islocked,
2526 .vop_ioctl = unionfs_ioctl,
2527 .vop_link = unionfs_link,
2528 .vop_listextattr = unionfs_listextattr,
2529 .vop_lock1 = unionfs_lock,
2530 .vop_lookup = vfs_cache_lookup,
2531 .vop_mkdir = unionfs_mkdir,
2532 .vop_mknod = unionfs_mknod,
2533 .vop_open = unionfs_open,
2534 .vop_openextattr = unionfs_openextattr,
2535 .vop_pathconf = unionfs_pathconf,
2536 .vop_poll = unionfs_poll,
2537 .vop_print = unionfs_print,
2538 .vop_read = unionfs_read,
2539 .vop_readdir = unionfs_readdir,
2540 .vop_readlink = unionfs_readlink,
2541 .vop_reclaim = unionfs_reclaim,
2542 .vop_remove = unionfs_remove,
2543 .vop_rename = unionfs_rename,
2544 .vop_rmdir = unionfs_rmdir,
2545 .vop_setacl = unionfs_setacl,
2546 .vop_setattr = unionfs_setattr,
2547 .vop_setextattr = unionfs_setextattr,
2548 .vop_setlabel = unionfs_setlabel,
2549 .vop_strategy = unionfs_strategy,
2550 .vop_symlink = unionfs_symlink,
2551 .vop_unlock = unionfs_unlock,
2552 .vop_whiteout = unionfs_whiteout,
2553 .vop_write = unionfs_write,
2554 .vop_vptofh = unionfs_vptofh,
2555 .vop_add_writecount = unionfs_add_writecount,
2557 VFS_VOP_VECTOR_REGISTER(unionfs_vnodeops);