Home | History | Annotate | Line # | Download | only in union
      1  1.84  dholland /*	$NetBSD: union_vnops.c,v 1.84 2025/09/02 21:46:54 dholland Exp $	*/
      2   1.1  jdolecek 
      3   1.1  jdolecek /*
      4   1.1  jdolecek  * Copyright (c) 1992, 1993, 1994, 1995
      5   1.1  jdolecek  *	The Regents of the University of California.  All rights reserved.
      6   1.1  jdolecek  *
      7   1.1  jdolecek  * This code is derived from software contributed to Berkeley by
      8   1.1  jdolecek  * Jan-Simon Pendry.
      9   1.1  jdolecek  *
     10   1.1  jdolecek  * Redistribution and use in source and binary forms, with or without
     11   1.1  jdolecek  * modification, are permitted provided that the following conditions
     12   1.1  jdolecek  * are met:
     13   1.1  jdolecek  * 1. Redistributions of source code must retain the above copyright
     14   1.1  jdolecek  *    notice, this list of conditions and the following disclaimer.
     15   1.1  jdolecek  * 2. Redistributions in binary form must reproduce the above copyright
     16   1.1  jdolecek  *    notice, this list of conditions and the following disclaimer in the
     17   1.1  jdolecek  *    documentation and/or other materials provided with the distribution.
     18   1.7       agc  * 3. Neither the name of the University nor the names of its contributors
     19   1.7       agc  *    may be used to endorse or promote products derived from this software
     20   1.7       agc  *    without specific prior written permission.
     21   1.7       agc  *
     22   1.7       agc  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     23   1.7       agc  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     24   1.7       agc  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     25   1.7       agc  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     26   1.7       agc  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     27   1.7       agc  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     28   1.7       agc  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     29   1.7       agc  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     30   1.7       agc  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     31   1.7       agc  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     32   1.7       agc  * SUCH DAMAGE.
     33   1.7       agc  *
     34   1.7       agc  *	@(#)union_vnops.c	8.33 (Berkeley) 7/31/95
     35   1.7       agc  */
     36   1.7       agc 
     37   1.7       agc /*
     38   1.7       agc  * Copyright (c) 1992, 1993, 1994, 1995 Jan-Simon Pendry.
     39   1.7       agc  *
     40   1.7       agc  * This code is derived from software contributed to Berkeley by
     41   1.7       agc  * Jan-Simon Pendry.
     42   1.7       agc  *
     43   1.7       agc  * Redistribution and use in source and binary forms, with or without
     44   1.7       agc  * modification, are permitted provided that the following conditions
     45   1.7       agc  * are met:
     46   1.7       agc  * 1. Redistributions of source code must retain the above copyright
     47   1.7       agc  *    notice, this list of conditions and the following disclaimer.
     48   1.7       agc  * 2. Redistributions in binary form must reproduce the above copyright
     49   1.7       agc  *    notice, this list of conditions and the following disclaimer in the
     50   1.7       agc  *    documentation and/or other materials provided with the distribution.
     51   1.1  jdolecek  * 3. All advertising materials mentioning features or use of this software
     52   1.1  jdolecek  *    must display the following acknowledgement:
     53   1.1  jdolecek  *	This product includes software developed by the University of
     54   1.1  jdolecek  *	California, Berkeley and its contributors.
     55   1.1  jdolecek  * 4. Neither the name of the University nor the names of its contributors
     56   1.1  jdolecek  *    may be used to endorse or promote products derived from this software
     57   1.1  jdolecek  *    without specific prior written permission.
     58   1.1  jdolecek  *
     59   1.1  jdolecek  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     60   1.1  jdolecek  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     61   1.1  jdolecek  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     62   1.1  jdolecek  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     63   1.1  jdolecek  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     64   1.1  jdolecek  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     65   1.1  jdolecek  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     66   1.1  jdolecek  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     67   1.1  jdolecek  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     68   1.1  jdolecek  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     69   1.1  jdolecek  * SUCH DAMAGE.
     70   1.1  jdolecek  *
     71   1.1  jdolecek  *	@(#)union_vnops.c	8.33 (Berkeley) 7/31/95
     72   1.1  jdolecek  */
     73   1.1  jdolecek 
     74   1.1  jdolecek #include <sys/cdefs.h>
     75  1.84  dholland __KERNEL_RCSID(0, "$NetBSD: union_vnops.c,v 1.84 2025/09/02 21:46:54 dholland Exp $");
     76   1.1  jdolecek 
     77   1.1  jdolecek #include <sys/param.h>
     78   1.1  jdolecek #include <sys/systm.h>
     79   1.1  jdolecek #include <sys/proc.h>
     80   1.1  jdolecek #include <sys/file.h>
     81   1.1  jdolecek #include <sys/time.h>
     82   1.1  jdolecek #include <sys/stat.h>
     83   1.1  jdolecek #include <sys/vnode.h>
     84   1.1  jdolecek #include <sys/mount.h>
     85   1.1  jdolecek #include <sys/namei.h>
     86   1.1  jdolecek #include <sys/malloc.h>
     87   1.1  jdolecek #include <sys/buf.h>
     88   1.1  jdolecek #include <sys/queue.h>
     89   1.1  jdolecek #include <sys/lock.h>
     90  1.16      elad #include <sys/kauth.h>
     91  1.16      elad 
     92   1.1  jdolecek #include <fs/union/union.h>
     93   1.1  jdolecek #include <miscfs/genfs/genfs.h>
     94  1.44   hannken #include <miscfs/specfs/specdev.h>
     95   1.1  jdolecek 
     96  1.76  dholland int union_parsepath(void *);
     97  1.12   xtraeme int union_lookup(void *);
     98  1.12   xtraeme int union_create(void *);
     99  1.12   xtraeme int union_whiteout(void *);
    100  1.12   xtraeme int union_mknod(void *);
    101  1.12   xtraeme int union_open(void *);
    102  1.12   xtraeme int union_close(void *);
    103  1.12   xtraeme int union_access(void *);
    104  1.12   xtraeme int union_getattr(void *);
    105  1.12   xtraeme int union_setattr(void *);
    106  1.12   xtraeme int union_read(void *);
    107  1.12   xtraeme int union_write(void *);
    108  1.12   xtraeme int union_ioctl(void *);
    109  1.12   xtraeme int union_poll(void *);
    110  1.12   xtraeme int union_revoke(void *);
    111  1.12   xtraeme int union_mmap(void *);
    112  1.12   xtraeme int union_fsync(void *);
    113  1.12   xtraeme int union_seek(void *);
    114  1.12   xtraeme int union_remove(void *);
    115  1.12   xtraeme int union_link(void *);
    116  1.12   xtraeme int union_rename(void *);
    117  1.12   xtraeme int union_mkdir(void *);
    118  1.12   xtraeme int union_rmdir(void *);
    119  1.12   xtraeme int union_symlink(void *);
    120  1.12   xtraeme int union_readdir(void *);
    121  1.12   xtraeme int union_readlink(void *);
    122  1.12   xtraeme int union_abortop(void *);
    123  1.12   xtraeme int union_inactive(void *);
    124  1.12   xtraeme int union_reclaim(void *);
    125  1.12   xtraeme int union_lock(void *);
    126  1.12   xtraeme int union_unlock(void *);
    127  1.12   xtraeme int union_bmap(void *);
    128  1.12   xtraeme int union_print(void *);
    129  1.12   xtraeme int union_islocked(void *);
    130  1.12   xtraeme int union_pathconf(void *);
    131  1.12   xtraeme int union_advlock(void *);
    132  1.12   xtraeme int union_strategy(void *);
    133  1.44   hannken int union_bwrite(void *);
    134  1.12   xtraeme int union_getpages(void *);
    135  1.12   xtraeme int union_putpages(void *);
    136  1.12   xtraeme int union_kqfilter(void *);
    137  1.12   xtraeme 
    138  1.12   xtraeme static int union_lookup1(struct vnode *, struct vnode **,
    139  1.12   xtraeme 			      struct vnode **, struct componentname *);
    140   1.1  jdolecek 
    141   1.1  jdolecek 
    142   1.1  jdolecek /*
    143   1.1  jdolecek  * Global vfs data structures
    144   1.1  jdolecek  */
    145  1.12   xtraeme int (**union_vnodeop_p)(void *);
    146   1.1  jdolecek const struct vnodeopv_entry_desc union_vnodeop_entries[] = {
    147   1.1  jdolecek 	{ &vop_default_desc, vn_default_error },
    148  1.76  dholland 	{ &vop_parsepath_desc, union_parsepath },	/* parsepath */
    149   1.1  jdolecek 	{ &vop_lookup_desc, union_lookup },		/* lookup */
    150   1.1  jdolecek 	{ &vop_create_desc, union_create },		/* create */
    151   1.1  jdolecek 	{ &vop_whiteout_desc, union_whiteout },		/* whiteout */
    152   1.1  jdolecek 	{ &vop_mknod_desc, union_mknod },		/* mknod */
    153   1.1  jdolecek 	{ &vop_open_desc, union_open },			/* open */
    154   1.1  jdolecek 	{ &vop_close_desc, union_close },		/* close */
    155   1.1  jdolecek 	{ &vop_access_desc, union_access },		/* access */
    156  1.73  christos 	{ &vop_accessx_desc, genfs_accessx },		/* accessx */
    157   1.1  jdolecek 	{ &vop_getattr_desc, union_getattr },		/* getattr */
    158   1.1  jdolecek 	{ &vop_setattr_desc, union_setattr },		/* setattr */
    159   1.1  jdolecek 	{ &vop_read_desc, union_read },			/* read */
    160   1.1  jdolecek 	{ &vop_write_desc, union_write },		/* write */
    161  1.62  dholland 	{ &vop_fallocate_desc, genfs_eopnotsupp },	/* fallocate */
    162  1.62  dholland 	{ &vop_fdiscard_desc, genfs_eopnotsupp },	/* fdiscard */
    163   1.1  jdolecek 	{ &vop_ioctl_desc, union_ioctl },		/* ioctl */
    164   1.1  jdolecek 	{ &vop_poll_desc, union_poll },			/* select */
    165   1.1  jdolecek 	{ &vop_revoke_desc, union_revoke },		/* revoke */
    166   1.1  jdolecek 	{ &vop_mmap_desc, union_mmap },			/* mmap */
    167   1.1  jdolecek 	{ &vop_fsync_desc, union_fsync },		/* fsync */
    168   1.1  jdolecek 	{ &vop_seek_desc, union_seek },			/* seek */
    169   1.1  jdolecek 	{ &vop_remove_desc, union_remove },		/* remove */
    170   1.1  jdolecek 	{ &vop_link_desc, union_link },			/* link */
    171   1.1  jdolecek 	{ &vop_rename_desc, union_rename },		/* rename */
    172   1.1  jdolecek 	{ &vop_mkdir_desc, union_mkdir },		/* mkdir */
    173   1.1  jdolecek 	{ &vop_rmdir_desc, union_rmdir },		/* rmdir */
    174   1.1  jdolecek 	{ &vop_symlink_desc, union_symlink },		/* symlink */
    175   1.1  jdolecek 	{ &vop_readdir_desc, union_readdir },		/* readdir */
    176   1.1  jdolecek 	{ &vop_readlink_desc, union_readlink },		/* readlink */
    177   1.1  jdolecek 	{ &vop_abortop_desc, union_abortop },		/* abortop */
    178   1.1  jdolecek 	{ &vop_inactive_desc, union_inactive },		/* inactive */
    179   1.1  jdolecek 	{ &vop_reclaim_desc, union_reclaim },		/* reclaim */
    180   1.1  jdolecek 	{ &vop_lock_desc, union_lock },			/* lock */
    181   1.1  jdolecek 	{ &vop_unlock_desc, union_unlock },		/* unlock */
    182   1.1  jdolecek 	{ &vop_bmap_desc, union_bmap },			/* bmap */
    183   1.1  jdolecek 	{ &vop_strategy_desc, union_strategy },		/* strategy */
    184  1.44   hannken 	{ &vop_bwrite_desc, union_bwrite },		/* bwrite */
    185   1.1  jdolecek 	{ &vop_print_desc, union_print },		/* print */
    186   1.1  jdolecek 	{ &vop_islocked_desc, union_islocked },		/* islocked */
    187   1.1  jdolecek 	{ &vop_pathconf_desc, union_pathconf },		/* pathconf */
    188   1.1  jdolecek 	{ &vop_advlock_desc, union_advlock },		/* advlock */
    189   1.1  jdolecek 	{ &vop_getpages_desc, union_getpages },		/* getpages */
    190   1.1  jdolecek 	{ &vop_putpages_desc, union_putpages },		/* putpages */
    191   1.2  jdolecek 	{ &vop_kqfilter_desc, union_kqfilter },		/* kqfilter */
    192   1.1  jdolecek 	{ NULL, NULL }
    193   1.1  jdolecek };
    194   1.1  jdolecek const struct vnodeopv_desc union_vnodeop_opv_desc =
    195   1.1  jdolecek 	{ &union_vnodeop_p, union_vnodeop_entries };
    196   1.1  jdolecek 
    197  1.44   hannken #define NODE_IS_SPECIAL(vp) \
    198  1.44   hannken 	((vp)->v_type == VBLK || (vp)->v_type == VCHR || \
    199  1.44   hannken 	(vp)->v_type == VSOCK || (vp)->v_type == VFIFO)
    200   1.1  jdolecek 
    201  1.76  dholland int
    202  1.76  dholland union_parsepath(void *v)
    203  1.76  dholland {
    204  1.76  dholland 	struct vop_parsepath_args /* {
    205  1.76  dholland 		struct vnode *a_dvp;
    206  1.76  dholland 		const char *a_name;
    207  1.76  dholland 		size_t *a_retval;
    208  1.76  dholland 	} */ *ap = v;
    209  1.76  dholland 	struct vnode *upperdvp, *lowerdvp;
    210  1.76  dholland 	size_t upper, lower;
    211  1.76  dholland 	int error;
    212  1.76  dholland 
    213  1.76  dholland 	upperdvp = UPPERVP(ap->a_dvp);
    214  1.76  dholland 	lowerdvp = LOWERVP(ap->a_dvp);
    215  1.76  dholland 
    216  1.78   hannken 	if (upperdvp != NULLVP) {
    217  1.78   hannken 		error = VOP_PARSEPATH(upperdvp, ap->a_name, &upper);
    218  1.78   hannken 		if (error) {
    219  1.78   hannken 			return error;
    220  1.78   hannken 		}
    221  1.78   hannken 	} else {
    222  1.78   hannken 		upper = 0;
    223  1.78   hannken 	}
    224  1.78   hannken 
    225  1.78   hannken 	if (lowerdvp != NULLVP) {
    226  1.78   hannken 		error = VOP_PARSEPATH(lowerdvp, ap->a_name, &lower);
    227  1.78   hannken 		if (error) {
    228  1.78   hannken 			return error;
    229  1.78   hannken 		}
    230  1.78   hannken 	} else {
    231  1.78   hannken 		lower = 0;
    232  1.76  dholland 	}
    233  1.76  dholland 
    234  1.78   hannken 	if (upper == 0 && lower == 0) {
    235  1.78   hannken 		panic("%s: missing both layers", __func__);
    236  1.76  dholland 	}
    237  1.76  dholland 
    238  1.76  dholland 	/*
    239  1.76  dholland 	 * If they're different, use the larger one. This is not a
    240  1.76  dholland 	 * comprehensive solution, but it's sufficient for the
    241  1.76  dholland 	 * non-default cases of parsepath that currently exist.
    242  1.76  dholland 	 */
    243  1.76  dholland 	*ap->a_retval = MAX(upper, lower);
    244  1.76  dholland 	return 0;
    245  1.76  dholland }
    246  1.76  dholland 
    247   1.1  jdolecek static int
    248  1.30      matt union_lookup1(struct vnode *udvp, struct vnode **dvpp, struct vnode **vpp,
    249  1.30      matt 	struct componentname *cnp)
    250   1.1  jdolecek {
    251   1.1  jdolecek 	int error;
    252   1.1  jdolecek 	struct vnode *tdvp;
    253   1.1  jdolecek 	struct vnode *dvp;
    254   1.1  jdolecek 	struct mount *mp;
    255   1.1  jdolecek 
    256   1.1  jdolecek 	dvp = *dvpp;
    257   1.1  jdolecek 
    258   1.1  jdolecek 	/*
    259   1.1  jdolecek 	 * If stepping up the directory tree, check for going
    260   1.1  jdolecek 	 * back across the mount point, in which case do what
    261   1.1  jdolecek 	 * lookup would do by stepping back down the mount
    262   1.1  jdolecek 	 * hierarchy.
    263   1.1  jdolecek 	 */
    264   1.1  jdolecek 	if (cnp->cn_flags & ISDOTDOT) {
    265  1.22        ad 		while ((dvp != udvp) && (dvp->v_vflag & VV_ROOT)) {
    266   1.1  jdolecek 			/*
    267   1.1  jdolecek 			 * Don't do the NOCROSSMOUNT check
    268   1.1  jdolecek 			 * at this level.  By definition,
    269   1.1  jdolecek 			 * union fs deals with namespaces, not
    270   1.1  jdolecek 			 * filesystems.
    271   1.1  jdolecek 			 */
    272   1.1  jdolecek 			tdvp = dvp;
    273   1.1  jdolecek 			*dvpp = dvp = dvp->v_mount->mnt_vnodecovered;
    274  1.36   hannken 			VOP_UNLOCK(tdvp);
    275   1.1  jdolecek 			vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY);
    276   1.1  jdolecek 		}
    277   1.1  jdolecek 	}
    278   1.1  jdolecek 
    279   1.1  jdolecek         error = VOP_LOOKUP(dvp, &tdvp, cnp);
    280   1.1  jdolecek 	if (error)
    281   1.1  jdolecek 		return (error);
    282  1.53   hannken 	if (dvp != tdvp) {
    283  1.53   hannken 		if (cnp->cn_flags & ISDOTDOT)
    284  1.53   hannken 			VOP_UNLOCK(dvp);
    285  1.53   hannken 		error = vn_lock(tdvp, LK_EXCLUSIVE);
    286  1.53   hannken 		if (cnp->cn_flags & ISDOTDOT)
    287  1.53   hannken 			vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY);
    288  1.53   hannken 		if (error) {
    289  1.53   hannken 			vrele(tdvp);
    290  1.53   hannken 			return error;
    291  1.53   hannken 		}
    292  1.53   hannken 		dvp = tdvp;
    293  1.52   hannken 	}
    294   1.1  jdolecek 
    295   1.1  jdolecek 	/*
    296   1.1  jdolecek 	 * Lastly check if the current node is a mount point in
    297   1.1  jdolecek 	 * which case walk up the mount hierarchy making sure not to
    298   1.1  jdolecek 	 * bump into the root of the mount tree (ie. dvp != udvp).
    299   1.1  jdolecek 	 */
    300   1.1  jdolecek 	while (dvp != udvp && (dvp->v_type == VDIR) &&
    301   1.1  jdolecek 	       (mp = dvp->v_mountedhere)) {
    302  1.66   hannken 		if (vfs_busy(mp))
    303   1.1  jdolecek 			continue;
    304  1.19       chs 		vput(dvp);
    305  1.71        ad 		error = VFS_ROOT(mp, LK_EXCLUSIVE, &tdvp);
    306  1.66   hannken 		vfs_unbusy(mp);
    307   1.1  jdolecek 		if (error) {
    308   1.1  jdolecek 			return (error);
    309   1.1  jdolecek 		}
    310   1.1  jdolecek 		dvp = tdvp;
    311   1.1  jdolecek 	}
    312   1.1  jdolecek 
    313   1.1  jdolecek 	*vpp = dvp;
    314   1.1  jdolecek 	return (0);
    315   1.1  jdolecek }
    316   1.1  jdolecek 
    317   1.1  jdolecek int
    318  1.30      matt union_lookup(void *v)
    319   1.1  jdolecek {
    320  1.52   hannken 	struct vop_lookup_v2_args /* {
    321   1.1  jdolecek 		struct vnodeop_desc *a_desc;
    322   1.1  jdolecek 		struct vnode *a_dvp;
    323   1.1  jdolecek 		struct vnode **a_vpp;
    324   1.1  jdolecek 		struct componentname *a_cnp;
    325   1.1  jdolecek 	} */ *ap = v;
    326   1.1  jdolecek 	int error;
    327   1.1  jdolecek 	int uerror, lerror;
    328   1.1  jdolecek 	struct vnode *uppervp, *lowervp;
    329   1.1  jdolecek 	struct vnode *upperdvp, *lowerdvp;
    330   1.1  jdolecek 	struct vnode *dvp = ap->a_dvp;
    331   1.1  jdolecek 	struct union_node *dun = VTOUNION(dvp);
    332   1.1  jdolecek 	struct componentname *cnp = ap->a_cnp;
    333   1.1  jdolecek 	struct union_mount *um = MOUNTTOUNIONMOUNT(dvp->v_mount);
    334  1.16      elad 	kauth_cred_t saved_cred = NULL;
    335   1.1  jdolecek 	int iswhiteout;
    336   1.1  jdolecek 	struct vattr va;
    337   1.1  jdolecek 
    338   1.1  jdolecek #ifdef notyet
    339   1.1  jdolecek 	if (cnp->cn_namelen == 3 &&
    340   1.1  jdolecek 			cnp->cn_nameptr[2] == '.' &&
    341   1.1  jdolecek 			cnp->cn_nameptr[1] == '.' &&
    342   1.1  jdolecek 			cnp->cn_nameptr[0] == '.') {
    343   1.1  jdolecek 		dvp = *ap->a_vpp = LOWERVP(ap->a_dvp);
    344   1.1  jdolecek 		if (dvp == NULLVP)
    345   1.1  jdolecek 			return (ENOENT);
    346  1.34     pooka 		vref(dvp);
    347   1.1  jdolecek 		vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY);
    348   1.1  jdolecek 		return (0);
    349   1.1  jdolecek 	}
    350   1.1  jdolecek #endif
    351   1.1  jdolecek 
    352   1.1  jdolecek 	if ((cnp->cn_flags & ISLASTCN) &&
    353   1.1  jdolecek 	    (dvp->v_mount->mnt_flag & MNT_RDONLY) &&
    354   1.1  jdolecek 	    (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME))
    355   1.1  jdolecek 		return (EROFS);
    356   1.1  jdolecek 
    357  1.41   hannken start:
    358   1.1  jdolecek 	upperdvp = dun->un_uppervp;
    359   1.1  jdolecek 	lowerdvp = dun->un_lowervp;
    360   1.1  jdolecek 	uppervp = NULLVP;
    361   1.1  jdolecek 	lowervp = NULLVP;
    362   1.1  jdolecek 	iswhiteout = 0;
    363   1.1  jdolecek 
    364   1.1  jdolecek 	/*
    365   1.1  jdolecek 	 * do the lookup in the upper level.
    366   1.1  jdolecek 	 * if that level comsumes additional pathnames,
    367   1.1  jdolecek 	 * then assume that something special is going
    368   1.1  jdolecek 	 * on and just return that vnode.
    369   1.1  jdolecek 	 */
    370   1.1  jdolecek 	if (upperdvp != NULLVP) {
    371   1.1  jdolecek 		uerror = union_lookup1(um->um_uppervp, &upperdvp,
    372   1.1  jdolecek 					&uppervp, cnp);
    373   1.1  jdolecek 		if (uerror == ENOENT || uerror == EJUSTRETURN) {
    374   1.1  jdolecek 			if (cnp->cn_flags & ISWHITEOUT) {
    375   1.1  jdolecek 				iswhiteout = 1;
    376   1.1  jdolecek 			} else if (lowerdvp != NULLVP) {
    377   1.1  jdolecek 				lerror = VOP_GETATTR(upperdvp, &va,
    378  1.23     pooka 					cnp->cn_cred);
    379   1.1  jdolecek 				if (lerror == 0 && (va.va_flags & OPAQUE))
    380   1.1  jdolecek 					iswhiteout = 1;
    381   1.1  jdolecek 			}
    382   1.1  jdolecek 		}
    383   1.1  jdolecek 	} else {
    384   1.1  jdolecek 		uerror = ENOENT;
    385   1.1  jdolecek 	}
    386   1.1  jdolecek 
    387   1.1  jdolecek 	/*
    388   1.1  jdolecek 	 * in a similar way to the upper layer, do the lookup
    389   1.1  jdolecek 	 * in the lower layer.   this time, if there is some
    390   1.1  jdolecek 	 * component magic going on, then vput whatever we got
    391   1.1  jdolecek 	 * back from the upper layer and return the lower vnode
    392   1.1  jdolecek 	 * instead.
    393   1.1  jdolecek 	 */
    394   1.1  jdolecek 	if (lowerdvp != NULLVP && !iswhiteout) {
    395   1.1  jdolecek 		int nameiop;
    396   1.1  jdolecek 
    397   1.1  jdolecek 		vn_lock(lowerdvp, LK_EXCLUSIVE | LK_RETRY);
    398   1.1  jdolecek 
    399   1.1  jdolecek 		/*
    400   1.1  jdolecek 		 * Only do a LOOKUP on the bottom node, since
    401   1.1  jdolecek 		 * we won't be making changes to it anyway.
    402   1.1  jdolecek 		 */
    403   1.1  jdolecek 		nameiop = cnp->cn_nameiop;
    404   1.1  jdolecek 		cnp->cn_nameiop = LOOKUP;
    405   1.1  jdolecek 		if (um->um_op == UNMNT_BELOW) {
    406   1.1  jdolecek 			saved_cred = cnp->cn_cred;
    407   1.1  jdolecek 			cnp->cn_cred = um->um_cred;
    408   1.1  jdolecek 		}
    409  1.18       chs 
    410   1.1  jdolecek 		/*
    411   1.1  jdolecek 		 * we shouldn't have to worry about locking interactions
    412   1.1  jdolecek 		 * between the lower layer and our union layer (w.r.t.
    413   1.1  jdolecek 		 * `..' processing) because we don't futz with lowervp
    414   1.1  jdolecek 		 * locks in the union-node instantiation code path.
    415   1.1  jdolecek 		 */
    416   1.1  jdolecek 		lerror = union_lookup1(um->um_lowervp, &lowerdvp,
    417   1.1  jdolecek 				&lowervp, cnp);
    418   1.1  jdolecek 		if (um->um_op == UNMNT_BELOW)
    419   1.1  jdolecek 			cnp->cn_cred = saved_cred;
    420   1.1  jdolecek 		cnp->cn_nameiop = nameiop;
    421   1.1  jdolecek 
    422   1.1  jdolecek 		if (lowervp != lowerdvp)
    423  1.36   hannken 			VOP_UNLOCK(lowerdvp);
    424   1.1  jdolecek 	} else {
    425   1.1  jdolecek 		lerror = ENOENT;
    426   1.1  jdolecek 		if ((cnp->cn_flags & ISDOTDOT) && dun->un_pvp != NULLVP) {
    427   1.1  jdolecek 			lowervp = LOWERVP(dun->un_pvp);
    428   1.1  jdolecek 			if (lowervp != NULLVP) {
    429  1.34     pooka 				vref(lowervp);
    430   1.1  jdolecek 				vn_lock(lowervp, LK_EXCLUSIVE | LK_RETRY);
    431   1.1  jdolecek 				lerror = 0;
    432   1.1  jdolecek 			}
    433   1.1  jdolecek 		}
    434   1.1  jdolecek 	}
    435   1.1  jdolecek 
    436   1.1  jdolecek 	/*
    437   1.1  jdolecek 	 * EJUSTRETURN is used by underlying filesystems to indicate that
    438   1.1  jdolecek 	 * a directory modification op was started successfully.
    439   1.1  jdolecek 	 * This will only happen in the upper layer, since
    440   1.1  jdolecek 	 * the lower layer only does LOOKUPs.
    441   1.1  jdolecek 	 * If this union is mounted read-only, bounce it now.
    442   1.1  jdolecek 	 */
    443   1.1  jdolecek 
    444   1.1  jdolecek 	if ((uerror == EJUSTRETURN) && (cnp->cn_flags & ISLASTCN) &&
    445   1.1  jdolecek 	    (dvp->v_mount->mnt_flag & MNT_RDONLY) &&
    446   1.1  jdolecek 	    ((cnp->cn_nameiop == CREATE) || (cnp->cn_nameiop == RENAME)))
    447   1.1  jdolecek 		uerror = EROFS;
    448  1.11     perry 
    449   1.1  jdolecek 	/*
    450   1.1  jdolecek 	 * at this point, we have uerror and lerror indicating
    451   1.1  jdolecek 	 * possible errors with the lookups in the upper and lower
    452   1.1  jdolecek 	 * layers.  additionally, uppervp and lowervp are (locked)
    453   1.1  jdolecek 	 * references to existing vnodes in the upper and lower layers.
    454   1.1  jdolecek 	 *
    455   1.1  jdolecek 	 * there are now three cases to consider.
    456   1.1  jdolecek 	 * 1. if both layers returned an error, then return whatever
    457   1.1  jdolecek 	 *    error the upper layer generated.
    458   1.1  jdolecek 	 *
    459   1.1  jdolecek 	 * 2. if the top layer failed and the bottom layer succeeded
    460   1.1  jdolecek 	 *    then two subcases occur.
    461   1.1  jdolecek 	 *    a.  the bottom vnode is not a directory, in which
    462   1.1  jdolecek 	 *	  case just return a new union vnode referencing
    463   1.1  jdolecek 	 *	  an empty top layer and the existing bottom layer.
    464   1.1  jdolecek 	 *    b.  the bottom vnode is a directory, in which case
    465   1.1  jdolecek 	 *	  create a new directory in the top-level and
    466   1.1  jdolecek 	 *	  continue as in case 3.
    467   1.1  jdolecek 	 *
    468   1.1  jdolecek 	 * 3. if the top layer succeeded then return a new union
    469   1.1  jdolecek 	 *    vnode referencing whatever the new top layer and
    470   1.1  jdolecek 	 *    whatever the bottom layer returned.
    471   1.1  jdolecek 	 */
    472   1.1  jdolecek 
    473   1.1  jdolecek 	*ap->a_vpp = NULLVP;
    474   1.1  jdolecek 
    475  1.11     perry 
    476   1.1  jdolecek 	/* case 1. */
    477   1.1  jdolecek 	if ((uerror != 0) && (lerror != 0)) {
    478   1.1  jdolecek 		return (uerror);
    479   1.1  jdolecek 	}
    480   1.1  jdolecek 
    481   1.1  jdolecek 	/* case 2. */
    482   1.1  jdolecek 	if (uerror != 0 /* && (lerror == 0) */ ) {
    483   1.1  jdolecek 		if (lowervp->v_type == VDIR) { /* case 2b. */
    484   1.1  jdolecek 			/*
    485   1.1  jdolecek 			 * We may be racing another process to make the
    486   1.1  jdolecek 			 * upper-level shadow directory.  Be careful with
    487   1.1  jdolecek 			 * locks/etc!
    488  1.41   hannken 			 * If we have to create a shadow directory and want
    489  1.41   hannken 			 * to commit the node we have to restart the lookup
    490  1.41   hannken 			 * to get the componentname right.
    491   1.1  jdolecek 			 */
    492  1.15  christos 			if (upperdvp) {
    493  1.36   hannken 				VOP_UNLOCK(upperdvp);
    494  1.15  christos 				uerror = union_mkshadow(um, upperdvp, cnp,
    495  1.15  christos 				    &uppervp);
    496  1.15  christos 				vn_lock(upperdvp, LK_EXCLUSIVE | LK_RETRY);
    497  1.41   hannken 				if (uerror == 0 && cnp->cn_nameiop != LOOKUP) {
    498  1.51   hannken 					vrele(uppervp);
    499  1.41   hannken 					if (lowervp != NULLVP)
    500  1.41   hannken 						vput(lowervp);
    501  1.41   hannken 					goto start;
    502  1.41   hannken 				}
    503  1.15  christos 			}
    504   1.1  jdolecek 			if (uerror) {
    505   1.1  jdolecek 				if (lowervp != NULLVP) {
    506   1.1  jdolecek 					vput(lowervp);
    507   1.1  jdolecek 					lowervp = NULLVP;
    508   1.1  jdolecek 				}
    509   1.1  jdolecek 				return (uerror);
    510   1.1  jdolecek 			}
    511   1.1  jdolecek 		}
    512  1.56   hannken 	} else { /* uerror == 0 */
    513  1.56   hannken 		if (uppervp != upperdvp)
    514  1.56   hannken 			VOP_UNLOCK(uppervp);
    515   1.1  jdolecek 	}
    516   1.1  jdolecek 
    517   1.1  jdolecek 	if (lowervp != NULLVP)
    518  1.36   hannken 		VOP_UNLOCK(lowervp);
    519   1.1  jdolecek 
    520   1.1  jdolecek 	error = union_allocvp(ap->a_vpp, dvp->v_mount, dvp, upperdvp, cnp,
    521   1.5   thorpej 			      uppervp, lowervp, 1);
    522   1.1  jdolecek 
    523   1.1  jdolecek 	if (error) {
    524   1.1  jdolecek 		if (uppervp != NULLVP)
    525  1.56   hannken 			vrele(uppervp);
    526   1.1  jdolecek 		if (lowervp != NULLVP)
    527   1.1  jdolecek 			vrele(lowervp);
    528  1.52   hannken 		return error;
    529   1.1  jdolecek 	}
    530   1.1  jdolecek 
    531  1.52   hannken 	return 0;
    532   1.1  jdolecek }
    533   1.1  jdolecek 
    534   1.1  jdolecek int
    535  1.30      matt union_create(void *v)
    536   1.1  jdolecek {
    537  1.51   hannken 	struct vop_create_v3_args /* {
    538   1.1  jdolecek 		struct vnode *a_dvp;
    539   1.1  jdolecek 		struct vnode **a_vpp;
    540   1.1  jdolecek 		struct componentname *a_cnp;
    541   1.1  jdolecek 		struct vattr *a_vap;
    542   1.1  jdolecek 	} */ *ap = v;
    543   1.1  jdolecek 	struct union_node *un = VTOUNION(ap->a_dvp);
    544   1.1  jdolecek 	struct vnode *dvp = un->un_uppervp;
    545   1.1  jdolecek 	struct componentname *cnp = ap->a_cnp;
    546   1.1  jdolecek 
    547   1.1  jdolecek 	if (dvp != NULLVP) {
    548   1.1  jdolecek 		int error;
    549   1.1  jdolecek 		struct vnode *vp;
    550   1.1  jdolecek 		struct mount *mp;
    551   1.1  jdolecek 
    552   1.1  jdolecek 		mp = ap->a_dvp->v_mount;
    553  1.60  dholland 
    554  1.60  dholland 		vp = NULL;
    555   1.1  jdolecek 		error = VOP_CREATE(dvp, &vp, cnp, ap->a_vap);
    556   1.1  jdolecek 		if (error)
    557   1.1  jdolecek 			return (error);
    558   1.1  jdolecek 
    559   1.1  jdolecek 		error = union_allocvp(ap->a_vpp, mp, NULLVP, NULLVP, cnp, vp,
    560   1.5   thorpej 				NULLVP, 1);
    561   1.1  jdolecek 		if (error)
    562  1.51   hannken 			vrele(vp);
    563   1.1  jdolecek 		return (error);
    564   1.1  jdolecek 	}
    565   1.1  jdolecek 
    566   1.1  jdolecek 	return (EROFS);
    567   1.1  jdolecek }
    568   1.1  jdolecek 
    569   1.1  jdolecek int
    570  1.30      matt union_whiteout(void *v)
    571   1.1  jdolecek {
    572   1.1  jdolecek 	struct vop_whiteout_args /* {
    573   1.1  jdolecek 		struct vnode *a_dvp;
    574   1.1  jdolecek 		struct componentname *a_cnp;
    575   1.1  jdolecek 		int a_flags;
    576   1.1  jdolecek 	} */ *ap = v;
    577   1.1  jdolecek 	struct union_node *un = VTOUNION(ap->a_dvp);
    578   1.1  jdolecek 	struct componentname *cnp = ap->a_cnp;
    579   1.1  jdolecek 
    580   1.1  jdolecek 	if (un->un_uppervp == NULLVP)
    581   1.1  jdolecek 		return (EOPNOTSUPP);
    582   1.1  jdolecek 
    583   1.1  jdolecek 	return (VOP_WHITEOUT(un->un_uppervp, cnp, ap->a_flags));
    584   1.1  jdolecek }
    585   1.1  jdolecek 
    586   1.1  jdolecek int
    587  1.30      matt union_mknod(void *v)
    588   1.1  jdolecek {
    589  1.51   hannken 	struct vop_mknod_v3_args /* {
    590   1.1  jdolecek 		struct vnode *a_dvp;
    591   1.1  jdolecek 		struct vnode **a_vpp;
    592   1.1  jdolecek 		struct componentname *a_cnp;
    593   1.1  jdolecek 		struct vattr *a_vap;
    594   1.1  jdolecek 	} */ *ap = v;
    595   1.1  jdolecek 	struct union_node *un = VTOUNION(ap->a_dvp);
    596   1.1  jdolecek 	struct vnode *dvp = un->un_uppervp;
    597   1.1  jdolecek 	struct componentname *cnp = ap->a_cnp;
    598   1.1  jdolecek 
    599   1.1  jdolecek 	if (dvp != NULLVP) {
    600   1.1  jdolecek 		int error;
    601   1.1  jdolecek 		struct vnode *vp;
    602   1.1  jdolecek 		struct mount *mp;
    603   1.1  jdolecek 
    604   1.1  jdolecek 		mp = ap->a_dvp->v_mount;
    605   1.1  jdolecek 		error = VOP_MKNOD(dvp, &vp, cnp, ap->a_vap);
    606   1.1  jdolecek 		if (error)
    607   1.1  jdolecek 			return (error);
    608   1.1  jdolecek 
    609   1.1  jdolecek 		error = union_allocvp(ap->a_vpp, mp, NULLVP, NULLVP,
    610   1.5   thorpej 				      cnp, vp, NULLVP, 1);
    611   1.1  jdolecek 		if (error)
    612  1.51   hannken 			vrele(vp);
    613   1.1  jdolecek 		return (error);
    614   1.1  jdolecek 	}
    615   1.1  jdolecek 
    616   1.1  jdolecek 	return (EROFS);
    617   1.1  jdolecek }
    618   1.1  jdolecek 
    619   1.1  jdolecek int
    620  1.30      matt union_open(void *v)
    621   1.1  jdolecek {
    622   1.1  jdolecek 	struct vop_open_args /* {
    623   1.1  jdolecek 		struct vnodeop_desc *a_desc;
    624   1.1  jdolecek 		struct vnode *a_vp;
    625   1.1  jdolecek 		int a_mode;
    626  1.16      elad 		kauth_cred_t a_cred;
    627   1.1  jdolecek 	} */ *ap = v;
    628   1.1  jdolecek 	struct union_node *un = VTOUNION(ap->a_vp);
    629   1.1  jdolecek 	struct vnode *tvp;
    630   1.1  jdolecek 	int mode = ap->a_mode;
    631  1.16      elad 	kauth_cred_t cred = ap->a_cred;
    632  1.23     pooka 	struct lwp *l = curlwp;
    633   1.1  jdolecek 	int error;
    634   1.1  jdolecek 
    635   1.1  jdolecek 	/*
    636   1.1  jdolecek 	 * If there is an existing upper vp then simply open that.
    637   1.1  jdolecek 	 */
    638   1.1  jdolecek 	tvp = un->un_uppervp;
    639   1.1  jdolecek 	if (tvp == NULLVP) {
    640   1.1  jdolecek 		/*
    641   1.1  jdolecek 		 * If the lower vnode is being opened for writing, then
    642   1.1  jdolecek 		 * copy the file contents to the upper vnode and open that,
    643   1.1  jdolecek 		 * otherwise can simply open the lower vnode.
    644   1.1  jdolecek 		 */
    645   1.1  jdolecek 		tvp = un->un_lowervp;
    646   1.1  jdolecek 		if ((ap->a_mode & FWRITE) && (tvp->v_type == VREG)) {
    647  1.14  christos 			error = union_copyup(un, (mode&O_TRUNC) == 0, cred, l);
    648   1.1  jdolecek 			if (error == 0)
    649  1.23     pooka 				error = VOP_OPEN(un->un_uppervp, mode, cred);
    650  1.64   hannken 			if (error == 0) {
    651  1.64   hannken 				mutex_enter(un->un_uppervp->v_interlock);
    652  1.64   hannken 				un->un_uppervp->v_writecount++;
    653  1.64   hannken 				mutex_exit(un->un_uppervp->v_interlock);
    654  1.64   hannken 			}
    655   1.1  jdolecek 			return (error);
    656   1.1  jdolecek 		}
    657   1.1  jdolecek 
    658   1.1  jdolecek 		/*
    659   1.1  jdolecek 		 * Just open the lower vnode, but check for nodev mount flag
    660   1.1  jdolecek 		 */
    661   1.1  jdolecek 		if ((tvp->v_type == VBLK || tvp->v_type == VCHR) &&
    662   1.1  jdolecek 		    (ap->a_vp->v_mount->mnt_flag & MNT_NODEV))
    663   1.1  jdolecek 			return ENXIO;
    664   1.1  jdolecek 		un->un_openl++;
    665   1.1  jdolecek 		vn_lock(tvp, LK_EXCLUSIVE | LK_RETRY);
    666  1.23     pooka 		error = VOP_OPEN(tvp, mode, cred);
    667  1.36   hannken 		VOP_UNLOCK(tvp);
    668   1.1  jdolecek 
    669   1.1  jdolecek 		return (error);
    670   1.1  jdolecek 	}
    671   1.1  jdolecek 	/*
    672   1.1  jdolecek 	 * Just open the upper vnode, checking for nodev mount flag first
    673   1.1  jdolecek 	 */
    674   1.1  jdolecek 	if ((tvp->v_type == VBLK || tvp->v_type == VCHR) &&
    675   1.1  jdolecek 	    (ap->a_vp->v_mount->mnt_flag & MNT_NODEV))
    676   1.1  jdolecek 		return ENXIO;
    677   1.1  jdolecek 
    678  1.23     pooka 	error = VOP_OPEN(tvp, mode, cred);
    679  1.64   hannken 	if (error == 0 && (ap->a_mode & FWRITE)) {
    680  1.64   hannken 		mutex_enter(tvp->v_interlock);
    681  1.64   hannken 		tvp->v_writecount++;
    682  1.64   hannken 		mutex_exit(tvp->v_interlock);
    683  1.64   hannken 	}
    684   1.1  jdolecek 
    685   1.1  jdolecek 	return (error);
    686   1.1  jdolecek }
    687   1.1  jdolecek 
    688   1.1  jdolecek int
    689  1.30      matt union_close(void *v)
    690   1.1  jdolecek {
    691   1.1  jdolecek 	struct vop_close_args /* {
    692   1.1  jdolecek 		struct vnode *a_vp;
    693   1.1  jdolecek 		int  a_fflag;
    694  1.16      elad 		kauth_cred_t a_cred;
    695   1.1  jdolecek 	} */ *ap = v;
    696   1.1  jdolecek 	struct union_node *un = VTOUNION(ap->a_vp);
    697   1.1  jdolecek 	struct vnode *vp;
    698  1.44   hannken 	int error;
    699  1.44   hannken 	bool do_lock;
    700   1.1  jdolecek 
    701   1.1  jdolecek 	vp = un->un_uppervp;
    702  1.44   hannken 	if (vp != NULLVP) {
    703  1.44   hannken 		do_lock = false;
    704  1.44   hannken 	} else {
    705  1.44   hannken 		KASSERT(un->un_openl > 0);
    706   1.1  jdolecek 		--un->un_openl;
    707   1.1  jdolecek 		vp = un->un_lowervp;
    708  1.44   hannken 		do_lock = true;
    709   1.1  jdolecek 	}
    710   1.1  jdolecek 
    711  1.44   hannken 	KASSERT(vp != NULLVP);
    712  1.44   hannken 	ap->a_vp = vp;
    713  1.64   hannken 	if ((ap->a_fflag & FWRITE)) {
    714  1.64   hannken 		KASSERT(vp == un->un_uppervp);
    715  1.64   hannken 		mutex_enter(vp->v_interlock);
    716  1.64   hannken 		vp->v_writecount--;
    717  1.64   hannken 		mutex_exit(vp->v_interlock);
    718  1.64   hannken 	}
    719  1.44   hannken 	if (do_lock)
    720  1.44   hannken 		vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
    721  1.44   hannken 	error = VCALL(vp, VOFFSET(vop_close), ap);
    722  1.44   hannken 	if (do_lock)
    723  1.44   hannken 		VOP_UNLOCK(vp);
    724   1.1  jdolecek 
    725  1.44   hannken 	return error;
    726   1.1  jdolecek }
    727   1.1  jdolecek 
    728   1.1  jdolecek /*
    729   1.1  jdolecek  * Check access permission on the union vnode.
    730   1.1  jdolecek  * The access check being enforced is to check
    731   1.1  jdolecek  * against both the underlying vnode, and any
    732   1.1  jdolecek  * copied vnode.  This ensures that no additional
    733   1.1  jdolecek  * file permissions are given away simply because
    734   1.1  jdolecek  * the user caused an implicit file copy.
    735   1.1  jdolecek  */
    736   1.1  jdolecek int
    737  1.30      matt union_access(void *v)
    738   1.1  jdolecek {
    739   1.1  jdolecek 	struct vop_access_args /* {
    740   1.1  jdolecek 		struct vnodeop_desc *a_desc;
    741   1.1  jdolecek 		struct vnode *a_vp;
    742  1.73  christos 		accmode_t a_accmode;
    743  1.16      elad 		kauth_cred_t a_cred;
    744   1.1  jdolecek 	} */ *ap = v;
    745   1.1  jdolecek 	struct vnode *vp = ap->a_vp;
    746   1.1  jdolecek 	struct union_node *un = VTOUNION(vp);
    747   1.1  jdolecek 	int error = EACCES;
    748   1.1  jdolecek 	struct union_mount *um = MOUNTTOUNIONMOUNT(vp->v_mount);
    749   1.1  jdolecek 
    750   1.1  jdolecek 	/*
    751   1.1  jdolecek 	 * Disallow write attempts on read-only file systems;
    752   1.1  jdolecek 	 * unless the file is a socket, fifo, or a block or
    753   1.1  jdolecek 	 * character device resident on the file system.
    754   1.1  jdolecek 	 */
    755  1.73  christos 	if (ap->a_accmode & VWRITE) {
    756   1.1  jdolecek 		switch (vp->v_type) {
    757   1.1  jdolecek 		case VDIR:
    758   1.1  jdolecek 		case VLNK:
    759   1.1  jdolecek 		case VREG:
    760   1.1  jdolecek 			if (vp->v_mount->mnt_flag & MNT_RDONLY)
    761   1.1  jdolecek 				return (EROFS);
    762   1.1  jdolecek 			break;
    763   1.1  jdolecek 		case VBAD:
    764   1.1  jdolecek 		case VBLK:
    765   1.1  jdolecek 		case VCHR:
    766   1.1  jdolecek 		case VSOCK:
    767   1.1  jdolecek 		case VFIFO:
    768   1.1  jdolecek 		case VNON:
    769   1.1  jdolecek 		default:
    770   1.1  jdolecek 			break;
    771   1.1  jdolecek 		}
    772   1.1  jdolecek 	}
    773  1.11     perry 
    774  1.81   hannken 	/*
    775  1.81   hannken 	 * Copy up to prevent checking (and failing) against
    776  1.81   hannken 	 * underlying file system mounted read only.
    777  1.81   hannken 	 * Check for read access first to prevent implicit
    778  1.82    andvar 	 * copy of inaccessible underlying vnode.
    779  1.81   hannken 	 */
    780  1.80   hannken 	if (un->un_uppervp == NULLVP &&
    781  1.80   hannken 	    (un->un_lowervp->v_type == VREG) &&
    782  1.80   hannken 	    (ap->a_accmode & VWRITE)) {
    783  1.81   hannken 		vn_lock(un->un_lowervp, LK_EXCLUSIVE | LK_RETRY);
    784  1.81   hannken 		error = VOP_ACCESS(un->un_lowervp, VREAD, ap->a_cred);
    785  1.81   hannken 		VOP_UNLOCK(un->un_lowervp);
    786  1.81   hannken 		if (error == 0)
    787  1.81   hannken 			error = union_copyup(un, 1, ap->a_cred, curlwp);
    788  1.80   hannken 		if (error)
    789  1.80   hannken 			return error;
    790  1.80   hannken 	}
    791   1.1  jdolecek 
    792   1.1  jdolecek 	if ((vp = un->un_uppervp) != NULLVP) {
    793   1.1  jdolecek 		ap->a_vp = vp;
    794   1.1  jdolecek 		return (VCALL(vp, VOFFSET(vop_access), ap));
    795   1.1  jdolecek 	}
    796   1.1  jdolecek 
    797   1.1  jdolecek 	if ((vp = un->un_lowervp) != NULLVP) {
    798   1.1  jdolecek 		vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
    799   1.1  jdolecek 		ap->a_vp = vp;
    800   1.1  jdolecek 		error = VCALL(vp, VOFFSET(vop_access), ap);
    801   1.1  jdolecek 		if (error == 0) {
    802   1.1  jdolecek 			if (um->um_op == UNMNT_BELOW) {
    803   1.1  jdolecek 				ap->a_cred = um->um_cred;
    804   1.1  jdolecek 				error = VCALL(vp, VOFFSET(vop_access), ap);
    805   1.1  jdolecek 			}
    806   1.1  jdolecek 		}
    807  1.36   hannken 		VOP_UNLOCK(vp);
    808   1.1  jdolecek 		if (error)
    809   1.1  jdolecek 			return (error);
    810   1.1  jdolecek 	}
    811   1.1  jdolecek 
    812   1.1  jdolecek 	return (error);
    813   1.1  jdolecek }
    814   1.1  jdolecek 
    815   1.1  jdolecek /*
    816   1.1  jdolecek  * We handle getattr only to change the fsid and
    817   1.1  jdolecek  * track object sizes
    818   1.1  jdolecek  */
    819   1.1  jdolecek int
    820  1.30      matt union_getattr(void *v)
    821   1.1  jdolecek {
    822   1.1  jdolecek 	struct vop_getattr_args /* {
    823   1.1  jdolecek 		struct vnode *a_vp;
    824   1.1  jdolecek 		struct vattr *a_vap;
    825  1.16      elad 		kauth_cred_t a_cred;
    826   1.1  jdolecek 	} */ *ap = v;
    827   1.1  jdolecek 	int error;
    828   1.1  jdolecek 	struct union_node *un = VTOUNION(ap->a_vp);
    829   1.1  jdolecek 	struct vnode *vp = un->un_uppervp;
    830   1.1  jdolecek 	struct vattr *vap;
    831   1.1  jdolecek 	struct vattr va;
    832   1.1  jdolecek 
    833   1.1  jdolecek 
    834   1.1  jdolecek 	/*
    835   1.1  jdolecek 	 * Some programs walk the filesystem hierarchy by counting
    836   1.1  jdolecek 	 * links to directories to avoid stat'ing all the time.
    837   1.1  jdolecek 	 * This means the link count on directories needs to be "correct".
    838   1.1  jdolecek 	 * The only way to do that is to call getattr on both layers
    839   1.1  jdolecek 	 * and fix up the link count.  The link count will not necessarily
    840   1.1  jdolecek 	 * be accurate but will be large enough to defeat the tree walkers.
    841   1.1  jdolecek 	 *
    842   1.1  jdolecek 	 * To make life more interesting, some filesystems don't keep
    843   1.1  jdolecek 	 * track of link counts in the expected way, and return a
    844   1.1  jdolecek 	 * link count of `1' for those directories; if either of the
    845   1.1  jdolecek 	 * component directories returns a link count of `1', we return a 1.
    846   1.1  jdolecek 	 */
    847   1.1  jdolecek 
    848   1.1  jdolecek 	vap = ap->a_vap;
    849   1.1  jdolecek 
    850   1.1  jdolecek 	vp = un->un_uppervp;
    851   1.1  jdolecek 	if (vp != NULLVP) {
    852  1.23     pooka 		error = VOP_GETATTR(vp, vap, ap->a_cred);
    853   1.1  jdolecek 		if (error)
    854   1.1  jdolecek 			return (error);
    855  1.49   hannken 		mutex_enter(&un->un_lock);
    856   1.1  jdolecek 		union_newsize(ap->a_vp, vap->va_size, VNOVAL);
    857   1.1  jdolecek 	}
    858   1.1  jdolecek 
    859   1.1  jdolecek 	if (vp == NULLVP) {
    860   1.1  jdolecek 		vp = un->un_lowervp;
    861   1.1  jdolecek 	} else if (vp->v_type == VDIR) {
    862   1.1  jdolecek 		vp = un->un_lowervp;
    863   1.1  jdolecek 		if (vp != NULLVP)
    864   1.1  jdolecek 			vap = &va;
    865   1.1  jdolecek 	} else {
    866   1.1  jdolecek 		vp = NULLVP;
    867   1.1  jdolecek 	}
    868   1.1  jdolecek 
    869   1.1  jdolecek 	if (vp != NULLVP) {
    870  1.47   hannken 		if (vp == un->un_lowervp)
    871  1.47   hannken 			vn_lock(vp, LK_SHARED | LK_RETRY);
    872  1.23     pooka 		error = VOP_GETATTR(vp, vap, ap->a_cred);
    873  1.47   hannken 		if (vp == un->un_lowervp)
    874  1.47   hannken 			VOP_UNLOCK(vp);
    875   1.1  jdolecek 		if (error)
    876   1.1  jdolecek 			return (error);
    877  1.49   hannken 		mutex_enter(&un->un_lock);
    878   1.1  jdolecek 		union_newsize(ap->a_vp, VNOVAL, vap->va_size);
    879   1.1  jdolecek 	}
    880   1.1  jdolecek 
    881   1.1  jdolecek 	if ((vap != ap->a_vap) && (vap->va_type == VDIR)) {
    882   1.1  jdolecek 		/*
    883   1.1  jdolecek 		 * Link count manipulation:
    884   1.1  jdolecek 		 *	- If both return "2", return 2 (no subdirs)
    885   1.1  jdolecek 		 *	- If one or the other return "1", return "1" (ENOCLUE)
    886   1.1  jdolecek 		 */
    887   1.1  jdolecek 		if ((ap->a_vap->va_nlink == 2) &&
    888   1.1  jdolecek 		    (vap->va_nlink == 2))
    889   1.1  jdolecek 			;
    890   1.1  jdolecek 		else if (ap->a_vap->va_nlink != 1) {
    891   1.1  jdolecek 			if (vap->va_nlink == 1)
    892   1.1  jdolecek 				ap->a_vap->va_nlink = 1;
    893   1.1  jdolecek 			else
    894   1.1  jdolecek 				ap->a_vap->va_nlink += vap->va_nlink;
    895   1.1  jdolecek 		}
    896   1.1  jdolecek 	}
    897   1.9  christos 	ap->a_vap->va_fsid = ap->a_vp->v_mount->mnt_stat.f_fsidx.__fsid_val[0];
    898   1.1  jdolecek 	return (0);
    899   1.1  jdolecek }
    900   1.1  jdolecek 
    901   1.1  jdolecek int
    902  1.30      matt union_setattr(void *v)
    903   1.1  jdolecek {
    904   1.1  jdolecek 	struct vop_setattr_args /* {
    905   1.1  jdolecek 		struct vnode *a_vp;
    906   1.1  jdolecek 		struct vattr *a_vap;
    907  1.16      elad 		kauth_cred_t a_cred;
    908   1.1  jdolecek 	} */ *ap = v;
    909   1.1  jdolecek 	struct vattr *vap = ap->a_vap;
    910   1.1  jdolecek 	struct vnode *vp = ap->a_vp;
    911   1.1  jdolecek 	struct union_node *un = VTOUNION(vp);
    912  1.43   hannken 	bool size_only;		/* All but va_size are VNOVAL. */
    913   1.1  jdolecek 	int error;
    914   1.1  jdolecek 
    915  1.43   hannken 	size_only = (vap->va_flags == VNOVAL && vap->va_uid == (uid_t)VNOVAL &&
    916  1.43   hannken 	    vap->va_gid == (gid_t)VNOVAL && vap->va_atime.tv_sec == VNOVAL &&
    917  1.43   hannken 	    vap->va_mtime.tv_sec == VNOVAL && vap->va_mode == (mode_t)VNOVAL);
    918  1.43   hannken 
    919  1.43   hannken 	if (!size_only && (vp->v_mount->mnt_flag & MNT_RDONLY))
    920   1.1  jdolecek 		return (EROFS);
    921   1.1  jdolecek 	if (vap->va_size != VNOVAL) {
    922   1.1  jdolecek  		switch (vp->v_type) {
    923   1.1  jdolecek  		case VDIR:
    924   1.1  jdolecek  			return (EISDIR);
    925   1.1  jdolecek  		case VCHR:
    926   1.1  jdolecek  		case VBLK:
    927   1.1  jdolecek  		case VSOCK:
    928   1.1  jdolecek  		case VFIFO:
    929   1.1  jdolecek 			break;
    930   1.1  jdolecek 		case VREG:
    931   1.1  jdolecek 		case VLNK:
    932   1.1  jdolecek  		default:
    933   1.1  jdolecek 			/*
    934   1.1  jdolecek 			 * Disallow write attempts if the filesystem is
    935   1.1  jdolecek 			 * mounted read-only.
    936   1.1  jdolecek 			 */
    937   1.1  jdolecek 			if (vp->v_mount->mnt_flag & MNT_RDONLY)
    938   1.1  jdolecek 				return (EROFS);
    939   1.1  jdolecek 		}
    940   1.1  jdolecek 	}
    941  1.11     perry 
    942   1.1  jdolecek 	/*
    943   1.1  jdolecek 	 * Handle case of truncating lower object to zero size,
    944   1.1  jdolecek 	 * by creating a zero length upper object.  This is to
    945   1.1  jdolecek 	 * handle the case of open with O_TRUNC and O_CREAT.
    946   1.1  jdolecek 	 */
    947   1.1  jdolecek 	if ((un->un_uppervp == NULLVP) &&
    948   1.1  jdolecek 	    /* assert(un->un_lowervp != NULLVP) */
    949   1.1  jdolecek 	    (un->un_lowervp->v_type == VREG)) {
    950   1.1  jdolecek 		error = union_copyup(un, (vap->va_size != 0),
    951  1.23     pooka 						ap->a_cred, curlwp);
    952   1.1  jdolecek 		if (error)
    953   1.1  jdolecek 			return (error);
    954   1.1  jdolecek 	}
    955   1.1  jdolecek 
    956   1.1  jdolecek 	/*
    957  1.43   hannken 	 * Try to set attributes in upper layer, ignore size change to zero
    958  1.43   hannken 	 * for devices to handle O_TRUNC and return read-only filesystem error
    959  1.43   hannken 	 * otherwise.
    960   1.1  jdolecek 	 */
    961   1.1  jdolecek 	if (un->un_uppervp != NULLVP) {
    962  1.23     pooka 		error = VOP_SETATTR(un->un_uppervp, vap, ap->a_cred);
    963  1.49   hannken 		if ((error == 0) && (vap->va_size != VNOVAL)) {
    964  1.49   hannken 			mutex_enter(&un->un_lock);
    965   1.1  jdolecek 			union_newsize(ap->a_vp, vap->va_size, VNOVAL);
    966  1.49   hannken 		}
    967   1.1  jdolecek 	} else {
    968  1.43   hannken 		KASSERT(un->un_lowervp != NULLVP);
    969  1.44   hannken 		if (NODE_IS_SPECIAL(un->un_lowervp)) {
    970  1.43   hannken 			if (size_only &&
    971  1.43   hannken 			    (vap->va_size == 0 || vap->va_size == VNOVAL))
    972  1.43   hannken 				error = 0;
    973  1.43   hannken 			else
    974  1.43   hannken 				error = EROFS;
    975  1.44   hannken 		} else {
    976  1.43   hannken 			error = EROFS;
    977  1.43   hannken 		}
    978   1.1  jdolecek 	}
    979   1.1  jdolecek 
    980   1.1  jdolecek 	return (error);
    981   1.1  jdolecek }
    982   1.1  jdolecek 
    983   1.1  jdolecek int
    984  1.30      matt union_read(void *v)
    985   1.1  jdolecek {
    986   1.1  jdolecek 	struct vop_read_args /* {
    987   1.1  jdolecek 		struct vnode *a_vp;
    988   1.1  jdolecek 		struct uio *a_uio;
    989   1.1  jdolecek 		int  a_ioflag;
    990  1.16      elad 		kauth_cred_t a_cred;
    991   1.1  jdolecek 	} */ *ap = v;
    992   1.1  jdolecek 	int error;
    993   1.1  jdolecek 	struct vnode *vp = OTHERVP(ap->a_vp);
    994   1.1  jdolecek 	int dolock = (vp == LOWERVP(ap->a_vp));
    995   1.1  jdolecek 
    996   1.1  jdolecek 	if (dolock)
    997   1.1  jdolecek 		vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
    998   1.1  jdolecek 	error = VOP_READ(vp, ap->a_uio, ap->a_ioflag, ap->a_cred);
    999   1.1  jdolecek 	if (dolock)
   1000  1.36   hannken 		VOP_UNLOCK(vp);
   1001   1.1  jdolecek 
   1002   1.1  jdolecek 	/*
   1003   1.1  jdolecek 	 * XXX
   1004   1.1  jdolecek 	 * perhaps the size of the underlying object has changed under
   1005   1.1  jdolecek 	 * our feet.  take advantage of the offset information present
   1006   1.1  jdolecek 	 * in the uio structure.
   1007   1.1  jdolecek 	 */
   1008   1.1  jdolecek 	if (error == 0) {
   1009   1.1  jdolecek 		struct union_node *un = VTOUNION(ap->a_vp);
   1010   1.1  jdolecek 		off_t cur = ap->a_uio->uio_offset;
   1011  1.49   hannken 		off_t usz = VNOVAL, lsz = VNOVAL;
   1012   1.1  jdolecek 
   1013  1.49   hannken 		mutex_enter(&un->un_lock);
   1014   1.1  jdolecek 		if (vp == un->un_uppervp) {
   1015   1.1  jdolecek 			if (cur > un->un_uppersz)
   1016  1.49   hannken 				usz = cur;
   1017   1.1  jdolecek 		} else {
   1018   1.1  jdolecek 			if (cur > un->un_lowersz)
   1019  1.49   hannken 				lsz = cur;
   1020   1.1  jdolecek 		}
   1021  1.49   hannken 
   1022  1.49   hannken 		if (usz != VNOVAL || lsz != VNOVAL)
   1023  1.49   hannken 			union_newsize(ap->a_vp, usz, lsz);
   1024  1.49   hannken 		else
   1025  1.49   hannken 			mutex_exit(&un->un_lock);
   1026   1.1  jdolecek 	}
   1027   1.1  jdolecek 
   1028   1.1  jdolecek 	return (error);
   1029   1.1  jdolecek }
   1030   1.1  jdolecek 
   1031   1.1  jdolecek int
   1032  1.30      matt union_write(void *v)
   1033   1.1  jdolecek {
   1034   1.1  jdolecek 	struct vop_read_args /* {
   1035   1.1  jdolecek 		struct vnode *a_vp;
   1036   1.1  jdolecek 		struct uio *a_uio;
   1037   1.1  jdolecek 		int  a_ioflag;
   1038  1.16      elad 		kauth_cred_t a_cred;
   1039   1.1  jdolecek 	} */ *ap = v;
   1040   1.1  jdolecek 	int error;
   1041   1.1  jdolecek 	struct vnode *vp;
   1042   1.1  jdolecek 	struct union_node *un = VTOUNION(ap->a_vp);
   1043   1.1  jdolecek 
   1044   1.1  jdolecek 	vp = UPPERVP(ap->a_vp);
   1045  1.43   hannken 	if (vp == NULLVP) {
   1046  1.43   hannken 		vp = LOWERVP(ap->a_vp);
   1047  1.44   hannken 		if (NODE_IS_SPECIAL(vp)) {
   1048  1.43   hannken 			vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
   1049  1.43   hannken 			error = VOP_WRITE(vp, ap->a_uio, ap->a_ioflag,
   1050  1.43   hannken 			    ap->a_cred);
   1051  1.43   hannken 			VOP_UNLOCK(vp);
   1052  1.43   hannken 			return error;
   1053  1.43   hannken 		}
   1054  1.44   hannken 		panic("union: missing upper layer in write");
   1055  1.43   hannken 	}
   1056   1.1  jdolecek 
   1057   1.1  jdolecek 	error = VOP_WRITE(vp, ap->a_uio, ap->a_ioflag, ap->a_cred);
   1058   1.1  jdolecek 
   1059   1.1  jdolecek 	/*
   1060   1.1  jdolecek 	 * the size of the underlying object may be changed by the
   1061   1.1  jdolecek 	 * write.
   1062   1.1  jdolecek 	 */
   1063   1.1  jdolecek 	if (error == 0) {
   1064   1.1  jdolecek 		off_t cur = ap->a_uio->uio_offset;
   1065   1.1  jdolecek 
   1066  1.49   hannken 		mutex_enter(&un->un_lock);
   1067   1.1  jdolecek 		if (cur > un->un_uppersz)
   1068   1.1  jdolecek 			union_newsize(ap->a_vp, cur, VNOVAL);
   1069  1.49   hannken 		else
   1070  1.49   hannken 			mutex_exit(&un->un_lock);
   1071   1.1  jdolecek 	}
   1072   1.1  jdolecek 
   1073   1.1  jdolecek 	return (error);
   1074   1.1  jdolecek }
   1075   1.1  jdolecek 
   1076   1.1  jdolecek int
   1077  1.30      matt union_ioctl(void *v)
   1078   1.1  jdolecek {
   1079   1.1  jdolecek 	struct vop_ioctl_args /* {
   1080   1.1  jdolecek 		struct vnode *a_vp;
   1081   1.1  jdolecek 		int  a_command;
   1082  1.10       jrf 		void *a_data;
   1083   1.1  jdolecek 		int  a_fflag;
   1084  1.16      elad 		kauth_cred_t a_cred;
   1085   1.1  jdolecek 	} */ *ap = v;
   1086   1.1  jdolecek 	struct vnode *ovp = OTHERVP(ap->a_vp);
   1087   1.1  jdolecek 
   1088   1.1  jdolecek 	ap->a_vp = ovp;
   1089   1.1  jdolecek 	return (VCALL(ovp, VOFFSET(vop_ioctl), ap));
   1090   1.1  jdolecek }
   1091   1.1  jdolecek 
   1092   1.1  jdolecek int
   1093  1.30      matt union_poll(void *v)
   1094   1.1  jdolecek {
   1095   1.1  jdolecek 	struct vop_poll_args /* {
   1096   1.1  jdolecek 		struct vnode *a_vp;
   1097   1.1  jdolecek 		int a_events;
   1098   1.1  jdolecek 	} */ *ap = v;
   1099   1.1  jdolecek 	struct vnode *ovp = OTHERVP(ap->a_vp);
   1100   1.1  jdolecek 
   1101   1.1  jdolecek 	ap->a_vp = ovp;
   1102   1.1  jdolecek 	return (VCALL(ovp, VOFFSET(vop_poll), ap));
   1103   1.1  jdolecek }
   1104   1.1  jdolecek 
   1105   1.1  jdolecek int
   1106  1.30      matt union_revoke(void *v)
   1107   1.1  jdolecek {
   1108   1.1  jdolecek 	struct vop_revoke_args /* {
   1109   1.1  jdolecek 		struct vnode *a_vp;
   1110   1.1  jdolecek 		int a_flags;
   1111   1.6      fvdl 		struct proc *a_p;
   1112   1.1  jdolecek 	} */ *ap = v;
   1113   1.1  jdolecek 	struct vnode *vp = ap->a_vp;
   1114   1.1  jdolecek 
   1115  1.68   hannken 	if (UPPERVP(vp))
   1116   1.1  jdolecek 		VOP_REVOKE(UPPERVP(vp), ap->a_flags);
   1117   1.1  jdolecek 	if (LOWERVP(vp))
   1118   1.1  jdolecek 		VOP_REVOKE(LOWERVP(vp), ap->a_flags);
   1119  1.25        ad 	vgone(vp);	/* XXXAD?? */
   1120   1.1  jdolecek 	return (0);
   1121   1.1  jdolecek }
   1122   1.1  jdolecek 
   1123   1.1  jdolecek int
   1124  1.30      matt union_mmap(void *v)
   1125   1.1  jdolecek {
   1126   1.1  jdolecek 	struct vop_mmap_args /* {
   1127   1.1  jdolecek 		struct vnode *a_vp;
   1128  1.21     pooka 		vm_prot_t a_prot;
   1129  1.16      elad 		kauth_cred_t a_cred;
   1130   1.1  jdolecek 	} */ *ap = v;
   1131   1.1  jdolecek 	struct vnode *ovp = OTHERVP(ap->a_vp);
   1132   1.1  jdolecek 
   1133   1.1  jdolecek 	ap->a_vp = ovp;
   1134   1.1  jdolecek 	return (VCALL(ovp, VOFFSET(vop_mmap), ap));
   1135   1.1  jdolecek }
   1136   1.1  jdolecek 
   1137   1.1  jdolecek int
   1138  1.30      matt union_fsync(void *v)
   1139   1.1  jdolecek {
   1140   1.1  jdolecek 	struct vop_fsync_args /* {
   1141   1.1  jdolecek 		struct vnode *a_vp;
   1142  1.16      elad 		kauth_cred_t a_cred;
   1143   1.1  jdolecek 		int  a_flags;
   1144   1.1  jdolecek 		off_t offhi;
   1145   1.1  jdolecek 		off_t offlo;
   1146   1.1  jdolecek 	} */ *ap = v;
   1147   1.1  jdolecek 	int error = 0;
   1148   1.1  jdolecek 	struct vnode *targetvp;
   1149   1.1  jdolecek 
   1150   1.1  jdolecek 	/*
   1151   1.1  jdolecek 	 * If vinvalbuf is calling us, it's a "shallow fsync" -- don't
   1152   1.1  jdolecek 	 * bother syncing the underlying vnodes, since (a) they'll be
   1153   1.1  jdolecek 	 * fsync'ed when reclaimed and (b) we could deadlock if
   1154   1.1  jdolecek 	 * they're locked; otherwise, pass it through to the
   1155   1.1  jdolecek 	 * underlying layer.
   1156   1.1  jdolecek 	 */
   1157  1.44   hannken 	if (ap->a_vp->v_type == VBLK || ap->a_vp->v_type == VCHR) {
   1158  1.44   hannken 		error = spec_fsync(v);
   1159  1.44   hannken 		if (error)
   1160  1.44   hannken 			return error;
   1161  1.44   hannken 	}
   1162  1.44   hannken 
   1163   1.1  jdolecek 	if (ap->a_flags & FSYNC_RECLAIM)
   1164   1.1  jdolecek 		return 0;
   1165  1.11     perry 
   1166   1.1  jdolecek 	targetvp = OTHERVP(ap->a_vp);
   1167   1.1  jdolecek 	if (targetvp != NULLVP) {
   1168   1.1  jdolecek 		int dolock = (targetvp == LOWERVP(ap->a_vp));
   1169   1.1  jdolecek 
   1170   1.1  jdolecek 		if (dolock)
   1171   1.1  jdolecek 			vn_lock(targetvp, LK_EXCLUSIVE | LK_RETRY);
   1172   1.1  jdolecek 		error = VOP_FSYNC(targetvp, ap->a_cred, ap->a_flags,
   1173  1.23     pooka 			    ap->a_offlo, ap->a_offhi);
   1174   1.1  jdolecek 		if (dolock)
   1175  1.36   hannken 			VOP_UNLOCK(targetvp);
   1176   1.1  jdolecek 	}
   1177   1.1  jdolecek 
   1178   1.1  jdolecek 	return (error);
   1179   1.1  jdolecek }
   1180   1.1  jdolecek 
   1181   1.1  jdolecek int
   1182  1.30      matt union_seek(void *v)
   1183   1.1  jdolecek {
   1184   1.1  jdolecek 	struct vop_seek_args /* {
   1185   1.1  jdolecek 		struct vnode *a_vp;
   1186   1.1  jdolecek 		off_t  a_oldoff;
   1187   1.1  jdolecek 		off_t  a_newoff;
   1188  1.16      elad 		kauth_cred_t a_cred;
   1189   1.1  jdolecek 	} */ *ap = v;
   1190   1.1  jdolecek 	struct vnode *ovp = OTHERVP(ap->a_vp);
   1191   1.1  jdolecek 
   1192   1.1  jdolecek 	ap->a_vp = ovp;
   1193   1.1  jdolecek 	return (VCALL(ovp, VOFFSET(vop_seek), ap));
   1194   1.1  jdolecek }
   1195   1.1  jdolecek 
   1196   1.1  jdolecek int
   1197  1.30      matt union_remove(void *v)
   1198   1.1  jdolecek {
   1199  1.79   thorpej 	struct vop_remove_v3_args /* {
   1200   1.1  jdolecek 		struct vnode *a_dvp;
   1201   1.1  jdolecek 		struct vnode *a_vp;
   1202   1.1  jdolecek 		struct componentname *a_cnp;
   1203  1.79   thorpej 		nlink_t ctx_vp_new_nlink;
   1204   1.1  jdolecek 	} */ *ap = v;
   1205   1.1  jdolecek 	int error;
   1206   1.1  jdolecek 	struct union_node *dun = VTOUNION(ap->a_dvp);
   1207   1.1  jdolecek 	struct union_node *un = VTOUNION(ap->a_vp);
   1208   1.1  jdolecek 	struct componentname *cnp = ap->a_cnp;
   1209   1.1  jdolecek 
   1210   1.1  jdolecek 	if (dun->un_uppervp == NULLVP)
   1211   1.1  jdolecek 		panic("union remove: null upper vnode");
   1212   1.1  jdolecek 
   1213   1.1  jdolecek 	if (un->un_uppervp != NULLVP) {
   1214   1.1  jdolecek 		struct vnode *dvp = dun->un_uppervp;
   1215   1.1  jdolecek 		struct vnode *vp = un->un_uppervp;
   1216   1.1  jdolecek 
   1217  1.67  riastrad 		/* Account for VOP_REMOVE to vrele vp.  */
   1218  1.34     pooka 		vref(vp);
   1219  1.24     pooka 		if (union_dowhiteout(un, cnp->cn_cred))
   1220   1.1  jdolecek 			cnp->cn_flags |= DOWHITEOUT;
   1221   1.1  jdolecek 		error = VOP_REMOVE(dvp, vp, cnp);
   1222   1.1  jdolecek 		if (!error)
   1223   1.1  jdolecek 			union_removed_upper(un);
   1224  1.54   hannken 		vrele(ap->a_vp);
   1225   1.1  jdolecek 	} else {
   1226   1.1  jdolecek 		error = union_mkwhiteout(
   1227   1.1  jdolecek 			MOUNTTOUNIONMOUNT(UNIONTOV(dun)->v_mount),
   1228  1.46   hannken 			dun->un_uppervp, ap->a_cnp, un);
   1229   1.1  jdolecek 		vput(ap->a_vp);
   1230   1.1  jdolecek 	}
   1231   1.1  jdolecek 
   1232   1.1  jdolecek 	return (error);
   1233   1.1  jdolecek }
   1234   1.1  jdolecek 
   1235   1.1  jdolecek int
   1236  1.30      matt union_link(void *v)
   1237   1.1  jdolecek {
   1238  1.63  riastrad 	struct vop_link_v2_args /* {
   1239   1.1  jdolecek 		struct vnode *a_dvp;
   1240   1.1  jdolecek 		struct vnode *a_vp;
   1241   1.1  jdolecek 		struct componentname *a_cnp;
   1242   1.1  jdolecek 	} */ *ap = v;
   1243   1.1  jdolecek 	int error = 0;
   1244   1.1  jdolecek 	struct componentname *cnp = ap->a_cnp;
   1245   1.1  jdolecek 	struct union_node *dun;
   1246   1.1  jdolecek 	struct vnode *vp;
   1247   1.1  jdolecek 	struct vnode *dvp;
   1248   1.1  jdolecek 
   1249   1.1  jdolecek 	dun = VTOUNION(ap->a_dvp);
   1250   1.1  jdolecek 
   1251  1.45   hannken 	KASSERT((ap->a_cnp->cn_flags & LOCKPARENT) != 0);
   1252   1.1  jdolecek 
   1253   1.1  jdolecek 	if (ap->a_dvp->v_op != ap->a_vp->v_op) {
   1254   1.1  jdolecek 		vp = ap->a_vp;
   1255   1.1  jdolecek 	} else {
   1256   1.1  jdolecek 		struct union_node *un = VTOUNION(ap->a_vp);
   1257   1.1  jdolecek 		if (un->un_uppervp == NULLVP) {
   1258  1.49   hannken 			const bool droplock = (dun->un_uppervp == un->un_dirvp);
   1259  1.49   hannken 
   1260   1.1  jdolecek 			/*
   1261   1.1  jdolecek 			 * Needs to be copied before we can link it.
   1262   1.1  jdolecek 			 */
   1263   1.1  jdolecek 			vn_lock(ap->a_vp, LK_EXCLUSIVE | LK_RETRY);
   1264  1.49   hannken 			if (droplock)
   1265  1.36   hannken 				VOP_UNLOCK(dun->un_uppervp);
   1266  1.24     pooka 			error = union_copyup(un, 1, cnp->cn_cred, curlwp);
   1267  1.84  dholland 			/*
   1268  1.84  dholland 			 * Unlock the target vnode again immediately
   1269  1.84  dholland 			 * to avoid deadlocking while relocking or in
   1270  1.84  dholland 			 * relookup. In particular it's common for a
   1271  1.84  dholland 			 * link operation to be entirely in one dir,
   1272  1.84  dholland 			 * where ap->a_dvp and/or dun->un_uppervp are
   1273  1.84  dholland 			 * the parent of ap->a_vp; locking the former
   1274  1.84  dholland 			 * while holding the latter is an order
   1275  1.84  dholland 			 * reversal. It's also possible for the
   1276  1.84  dholland 			 * relookup call to find and lock the same
   1277  1.84  dholland 			 * vnode if another process just did the same
   1278  1.84  dholland 			 * link operation.
   1279  1.84  dholland 			 */
   1280  1.84  dholland 			VOP_UNLOCK(ap->a_vp);
   1281  1.49   hannken 			if (droplock) {
   1282  1.48   hannken 				vn_lock(dun->un_uppervp,
   1283  1.48   hannken 				    LK_EXCLUSIVE | LK_RETRY);
   1284   1.1  jdolecek 				/*
   1285   1.1  jdolecek 				 * During copyup, we dropped the lock on the
   1286   1.1  jdolecek 				 * dir and invalidated any saved namei lookup
   1287   1.1  jdolecek 				 * state for the directory we'll be entering
   1288   1.1  jdolecek 				 * the link in.  We need to re-run the lookup
   1289   1.1  jdolecek 				 * in that directory to reset any state needed
   1290   1.1  jdolecek 				 * for VOP_LINK.
   1291   1.1  jdolecek 				 * Call relookup on the union-layer to reset
   1292   1.1  jdolecek 				 * the state.
   1293   1.1  jdolecek 				 */
   1294   1.1  jdolecek 				vp  = NULLVP;
   1295   1.1  jdolecek 				if (dun->un_uppervp == NULLVP)
   1296   1.1  jdolecek 					 panic("union: null upperdvp?");
   1297  1.39  dholland 				error = relookup(ap->a_dvp, &vp, ap->a_cnp, 0);
   1298   1.1  jdolecek 				if (error) {
   1299   1.1  jdolecek 					return EROFS;	/* ? */
   1300   1.1  jdolecek 				}
   1301   1.1  jdolecek 				if (vp != NULLVP) {
   1302   1.1  jdolecek 					/*
   1303  1.84  dholland 					 * The name we wanted to
   1304  1.84  dholland 					 * create has been created by
   1305  1.84  dholland 					 * another process.
   1306   1.1  jdolecek 					 */
   1307  1.18       chs 					vput(vp);
   1308  1.84  dholland 					return EEXIST;
   1309   1.1  jdolecek 				}
   1310   1.1  jdolecek 			}
   1311   1.1  jdolecek 		}
   1312   1.1  jdolecek 		vp = un->un_uppervp;
   1313   1.1  jdolecek 	}
   1314   1.1  jdolecek 
   1315   1.1  jdolecek 	dvp = dun->un_uppervp;
   1316   1.1  jdolecek 	if (dvp == NULLVP)
   1317   1.1  jdolecek 		error = EROFS;
   1318   1.1  jdolecek 
   1319  1.63  riastrad 	if (error)
   1320   1.1  jdolecek 		return (error);
   1321   1.1  jdolecek 
   1322  1.63  riastrad 	return VOP_LINK(dvp, vp, cnp);
   1323   1.1  jdolecek }
   1324   1.1  jdolecek 
   1325   1.1  jdolecek int
   1326  1.30      matt union_rename(void *v)
   1327   1.1  jdolecek {
   1328  1.79   thorpej 	struct vop_rename_args /* {
   1329   1.1  jdolecek 		struct vnode *a_fdvp;
   1330   1.1  jdolecek 		struct vnode *a_fvp;
   1331   1.1  jdolecek 		struct componentname *a_fcnp;
   1332   1.1  jdolecek 		struct vnode *a_tdvp;
   1333   1.1  jdolecek 		struct vnode *a_tvp;
   1334   1.1  jdolecek 		struct componentname *a_tcnp;
   1335   1.1  jdolecek 	} */ *ap = v;
   1336   1.1  jdolecek 	int error;
   1337   1.1  jdolecek 
   1338   1.1  jdolecek 	struct vnode *fdvp = ap->a_fdvp;
   1339   1.1  jdolecek 	struct vnode *fvp = ap->a_fvp;
   1340   1.1  jdolecek 	struct vnode *tdvp = ap->a_tdvp;
   1341   1.1  jdolecek 	struct vnode *tvp = ap->a_tvp;
   1342   1.1  jdolecek 
   1343  1.54   hannken 	/*
   1344  1.54   hannken 	 * Account for VOP_RENAME to vrele all nodes.
   1345  1.54   hannken 	 * Note: VOP_RENAME will unlock tdvp.
   1346  1.54   hannken 	 */
   1347  1.54   hannken 
   1348   1.1  jdolecek 	if (fdvp->v_op == union_vnodeop_p) {	/* always true */
   1349   1.1  jdolecek 		struct union_node *un = VTOUNION(fdvp);
   1350   1.1  jdolecek 		if (un->un_uppervp == NULLVP) {
   1351   1.1  jdolecek 			/*
   1352   1.1  jdolecek 			 * this should never happen in normal
   1353   1.1  jdolecek 			 * operation but might if there was
   1354   1.1  jdolecek 			 * a problem creating the top-level shadow
   1355   1.1  jdolecek 			 * directory.
   1356   1.1  jdolecek 			 */
   1357   1.1  jdolecek 			error = EXDEV;
   1358   1.1  jdolecek 			goto bad;
   1359   1.1  jdolecek 		}
   1360   1.1  jdolecek 
   1361   1.1  jdolecek 		fdvp = un->un_uppervp;
   1362  1.34     pooka 		vref(fdvp);
   1363   1.1  jdolecek 	}
   1364   1.1  jdolecek 
   1365   1.1  jdolecek 	if (fvp->v_op == union_vnodeop_p) {	/* always true */
   1366   1.1  jdolecek 		struct union_node *un = VTOUNION(fvp);
   1367   1.1  jdolecek 		if (un->un_uppervp == NULLVP) {
   1368   1.1  jdolecek 			/* XXX: should do a copyup */
   1369   1.1  jdolecek 			error = EXDEV;
   1370   1.1  jdolecek 			goto bad;
   1371   1.1  jdolecek 		}
   1372   1.1  jdolecek 
   1373   1.1  jdolecek 		if (un->un_lowervp != NULLVP)
   1374   1.1  jdolecek 			ap->a_fcnp->cn_flags |= DOWHITEOUT;
   1375   1.1  jdolecek 
   1376   1.1  jdolecek 		fvp = un->un_uppervp;
   1377  1.34     pooka 		vref(fvp);
   1378   1.1  jdolecek 	}
   1379   1.1  jdolecek 
   1380   1.1  jdolecek 	if (tdvp->v_op == union_vnodeop_p) {
   1381   1.1  jdolecek 		struct union_node *un = VTOUNION(tdvp);
   1382   1.1  jdolecek 		if (un->un_uppervp == NULLVP) {
   1383   1.1  jdolecek 			/*
   1384   1.1  jdolecek 			 * this should never happen in normal
   1385   1.1  jdolecek 			 * operation but might if there was
   1386   1.1  jdolecek 			 * a problem creating the top-level shadow
   1387   1.1  jdolecek 			 * directory.
   1388   1.1  jdolecek 			 */
   1389   1.1  jdolecek 			error = EXDEV;
   1390   1.1  jdolecek 			goto bad;
   1391   1.1  jdolecek 		}
   1392   1.1  jdolecek 
   1393   1.1  jdolecek 		tdvp = un->un_uppervp;
   1394  1.34     pooka 		vref(tdvp);
   1395   1.1  jdolecek 	}
   1396   1.1  jdolecek 
   1397   1.1  jdolecek 	if (tvp != NULLVP && tvp->v_op == union_vnodeop_p) {
   1398   1.1  jdolecek 		struct union_node *un = VTOUNION(tvp);
   1399   1.1  jdolecek 
   1400   1.1  jdolecek 		tvp = un->un_uppervp;
   1401   1.1  jdolecek 		if (tvp != NULLVP) {
   1402  1.34     pooka 			vref(tvp);
   1403   1.1  jdolecek 		}
   1404   1.1  jdolecek 	}
   1405   1.1  jdolecek 
   1406  1.18       chs 	error = VOP_RENAME(fdvp, fvp, ap->a_fcnp, tdvp, tvp, ap->a_tcnp);
   1407  1.18       chs 	goto out;
   1408   1.1  jdolecek 
   1409   1.1  jdolecek bad:
   1410   1.1  jdolecek 	vput(tdvp);
   1411   1.1  jdolecek 	if (tvp != NULLVP)
   1412   1.1  jdolecek 		vput(tvp);
   1413  1.18       chs 	vrele(fdvp);
   1414  1.18       chs 	vrele(fvp);
   1415   1.1  jdolecek 
   1416  1.18       chs out:
   1417  1.18       chs 	if (fdvp != ap->a_fdvp) {
   1418  1.18       chs 		vrele(ap->a_fdvp);
   1419  1.18       chs 	}
   1420  1.18       chs 	if (fvp != ap->a_fvp) {
   1421  1.18       chs 		vrele(ap->a_fvp);
   1422  1.18       chs 	}
   1423  1.54   hannken 	if (tdvp != ap->a_tdvp) {
   1424  1.54   hannken 		vrele(ap->a_tdvp);
   1425  1.54   hannken 	}
   1426  1.54   hannken 	if (tvp != ap->a_tvp) {
   1427  1.54   hannken 		vrele(ap->a_tvp);
   1428  1.54   hannken 	}
   1429   1.1  jdolecek 	return (error);
   1430   1.1  jdolecek }
   1431   1.1  jdolecek 
   1432   1.1  jdolecek int
   1433  1.30      matt union_mkdir(void *v)
   1434   1.1  jdolecek {
   1435  1.51   hannken 	struct vop_mkdir_v3_args /* {
   1436   1.1  jdolecek 		struct vnode *a_dvp;
   1437   1.1  jdolecek 		struct vnode **a_vpp;
   1438   1.1  jdolecek 		struct componentname *a_cnp;
   1439   1.1  jdolecek 		struct vattr *a_vap;
   1440   1.1  jdolecek 	} */ *ap = v;
   1441   1.1  jdolecek 	struct union_node *un = VTOUNION(ap->a_dvp);
   1442   1.1  jdolecek 	struct vnode *dvp = un->un_uppervp;
   1443   1.1  jdolecek 	struct componentname *cnp = ap->a_cnp;
   1444   1.1  jdolecek 
   1445   1.1  jdolecek 	if (dvp != NULLVP) {
   1446   1.1  jdolecek 		int error;
   1447   1.1  jdolecek 		struct vnode *vp;
   1448   1.1  jdolecek 
   1449  1.61  dholland 		vp = NULL;
   1450   1.1  jdolecek 		error = VOP_MKDIR(dvp, &vp, cnp, ap->a_vap);
   1451   1.1  jdolecek 		if (error) {
   1452   1.1  jdolecek 			vrele(ap->a_dvp);
   1453   1.1  jdolecek 			return (error);
   1454   1.1  jdolecek 		}
   1455   1.1  jdolecek 
   1456   1.1  jdolecek 		error = union_allocvp(ap->a_vpp, ap->a_dvp->v_mount, ap->a_dvp,
   1457   1.5   thorpej 				NULLVP, cnp, vp, NULLVP, 1);
   1458   1.1  jdolecek 		if (error)
   1459  1.51   hannken 			vrele(vp);
   1460   1.1  jdolecek 		return (error);
   1461   1.1  jdolecek 	}
   1462   1.1  jdolecek 
   1463   1.1  jdolecek 	return (EROFS);
   1464   1.1  jdolecek }
   1465   1.1  jdolecek 
   1466   1.1  jdolecek int
   1467  1.30      matt union_rmdir(void *v)
   1468   1.1  jdolecek {
   1469  1.67  riastrad 	struct vop_rmdir_v2_args /* {
   1470   1.1  jdolecek 		struct vnode *a_dvp;
   1471   1.1  jdolecek 		struct vnode *a_vp;
   1472   1.1  jdolecek 		struct componentname *a_cnp;
   1473   1.1  jdolecek 	} */ *ap = v;
   1474   1.1  jdolecek 	int error;
   1475   1.1  jdolecek 	struct union_node *dun = VTOUNION(ap->a_dvp);
   1476   1.1  jdolecek 	struct union_node *un = VTOUNION(ap->a_vp);
   1477   1.1  jdolecek 	struct componentname *cnp = ap->a_cnp;
   1478   1.1  jdolecek 
   1479   1.1  jdolecek 	if (dun->un_uppervp == NULLVP)
   1480   1.1  jdolecek 		panic("union rmdir: null upper vnode");
   1481   1.1  jdolecek 
   1482  1.42   hannken 	error = union_check_rmdir(un, cnp->cn_cred);
   1483  1.42   hannken 	if (error) {
   1484  1.42   hannken 		vput(ap->a_vp);
   1485  1.42   hannken 		return error;
   1486  1.42   hannken 	}
   1487  1.42   hannken 
   1488   1.1  jdolecek 	if (un->un_uppervp != NULLVP) {
   1489   1.1  jdolecek 		struct vnode *dvp = dun->un_uppervp;
   1490   1.1  jdolecek 		struct vnode *vp = un->un_uppervp;
   1491   1.1  jdolecek 
   1492  1.67  riastrad 		/* Account for VOP_RMDIR to vrele vp.  */
   1493  1.34     pooka 		vref(vp);
   1494  1.24     pooka 		if (union_dowhiteout(un, cnp->cn_cred))
   1495   1.1  jdolecek 			cnp->cn_flags |= DOWHITEOUT;
   1496   1.1  jdolecek 		error = VOP_RMDIR(dvp, vp, ap->a_cnp);
   1497   1.1  jdolecek 		if (!error)
   1498   1.1  jdolecek 			union_removed_upper(un);
   1499  1.54   hannken 		vrele(ap->a_vp);
   1500   1.1  jdolecek 	} else {
   1501   1.1  jdolecek 		error = union_mkwhiteout(
   1502   1.1  jdolecek 			MOUNTTOUNIONMOUNT(UNIONTOV(dun)->v_mount),
   1503  1.46   hannken 			dun->un_uppervp, ap->a_cnp, un);
   1504   1.1  jdolecek 		vput(ap->a_vp);
   1505   1.1  jdolecek 	}
   1506   1.1  jdolecek 
   1507   1.1  jdolecek 	return (error);
   1508   1.1  jdolecek }
   1509   1.1  jdolecek 
   1510   1.1  jdolecek int
   1511  1.30      matt union_symlink(void *v)
   1512   1.1  jdolecek {
   1513  1.51   hannken 	struct vop_symlink_v3_args /* {
   1514   1.1  jdolecek 		struct vnode *a_dvp;
   1515   1.1  jdolecek 		struct vnode **a_vpp;
   1516   1.1  jdolecek 		struct componentname *a_cnp;
   1517   1.1  jdolecek 		struct vattr *a_vap;
   1518   1.1  jdolecek 		char *a_target;
   1519   1.1  jdolecek 	} */ *ap = v;
   1520   1.1  jdolecek 	struct union_node *un = VTOUNION(ap->a_dvp);
   1521   1.1  jdolecek 	struct vnode *dvp = un->un_uppervp;
   1522   1.1  jdolecek 	struct componentname *cnp = ap->a_cnp;
   1523   1.1  jdolecek 
   1524   1.1  jdolecek 	if (dvp != NULLVP) {
   1525   1.1  jdolecek 		int error;
   1526   1.1  jdolecek 
   1527   1.1  jdolecek 		error = VOP_SYMLINK(dvp, ap->a_vpp, cnp, ap->a_vap,
   1528   1.1  jdolecek 				    ap->a_target);
   1529   1.1  jdolecek 		return (error);
   1530   1.1  jdolecek 	}
   1531   1.1  jdolecek 
   1532   1.1  jdolecek 	return (EROFS);
   1533   1.1  jdolecek }
   1534   1.1  jdolecek 
   1535   1.1  jdolecek /*
   1536   1.1  jdolecek  * union_readdir works in concert with getdirentries and
   1537   1.1  jdolecek  * readdir(3) to provide a list of entries in the unioned
   1538   1.1  jdolecek  * directories.  getdirentries is responsible for walking
   1539   1.1  jdolecek  * down the union stack.  readdir(3) is responsible for
   1540   1.1  jdolecek  * eliminating duplicate names from the returned data stream.
   1541   1.1  jdolecek  */
   1542   1.1  jdolecek int
   1543  1.30      matt union_readdir(void *v)
   1544   1.1  jdolecek {
   1545   1.1  jdolecek 	struct vop_readdir_args /* {
   1546   1.1  jdolecek 		struct vnodeop_desc *a_desc;
   1547   1.1  jdolecek 		struct vnode *a_vp;
   1548   1.1  jdolecek 		struct uio *a_uio;
   1549  1.16      elad 		kauth_cred_t a_cred;
   1550   1.1  jdolecek 		int *a_eofflag;
   1551   1.1  jdolecek 		u_long *a_cookies;
   1552   1.1  jdolecek 		int a_ncookies;
   1553   1.1  jdolecek 	} */ *ap = v;
   1554   1.1  jdolecek 	struct union_node *un = VTOUNION(ap->a_vp);
   1555  1.74   hannken 	struct vnode *vp;
   1556  1.74   hannken 	int dolock, error;
   1557  1.74   hannken 
   1558  1.74   hannken 	if (un->un_hooknode) {
   1559  1.74   hannken 		KASSERT(un->un_uppervp == NULLVP);
   1560  1.74   hannken 		KASSERT(un->un_lowervp != NULLVP);
   1561  1.74   hannken 		vp = un->un_lowervp;
   1562  1.74   hannken 		dolock = 1;
   1563  1.74   hannken 	} else {
   1564  1.74   hannken 		vp = un->un_uppervp;
   1565  1.74   hannken 		dolock = 0;
   1566  1.74   hannken 	}
   1567  1.74   hannken 	if (vp == NULLVP)
   1568  1.74   hannken 		return 0;
   1569   1.1  jdolecek 
   1570  1.74   hannken 	if (dolock)
   1571  1.74   hannken 		vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
   1572  1.74   hannken 	ap->a_vp = vp;
   1573  1.74   hannken 	error = VCALL(vp, VOFFSET(vop_readdir), ap);
   1574  1.74   hannken 	if (dolock)
   1575  1.74   hannken 		VOP_UNLOCK(vp);
   1576   1.1  jdolecek 
   1577  1.74   hannken 	return error;
   1578   1.1  jdolecek }
   1579   1.1  jdolecek 
   1580   1.1  jdolecek int
   1581  1.30      matt union_readlink(void *v)
   1582   1.1  jdolecek {
   1583   1.1  jdolecek 	struct vop_readlink_args /* {
   1584   1.1  jdolecek 		struct vnode *a_vp;
   1585   1.1  jdolecek 		struct uio *a_uio;
   1586  1.16      elad 		kauth_cred_t a_cred;
   1587   1.1  jdolecek 	} */ *ap = v;
   1588   1.1  jdolecek 	int error;
   1589   1.1  jdolecek 	struct vnode *vp = OTHERVP(ap->a_vp);
   1590   1.1  jdolecek 	int dolock = (vp == LOWERVP(ap->a_vp));
   1591   1.1  jdolecek 
   1592   1.1  jdolecek 	if (dolock)
   1593   1.1  jdolecek 		vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
   1594   1.1  jdolecek 	ap->a_vp = vp;
   1595   1.1  jdolecek 	error = VCALL(vp, VOFFSET(vop_readlink), ap);
   1596   1.1  jdolecek 	if (dolock)
   1597  1.36   hannken 		VOP_UNLOCK(vp);
   1598   1.1  jdolecek 
   1599   1.1  jdolecek 	return (error);
   1600   1.1  jdolecek }
   1601   1.1  jdolecek 
   1602   1.1  jdolecek int
   1603  1.30      matt union_abortop(void *v)
   1604   1.1  jdolecek {
   1605   1.1  jdolecek 	struct vop_abortop_args /* {
   1606   1.1  jdolecek 		struct vnode *a_dvp;
   1607   1.1  jdolecek 		struct componentname *a_cnp;
   1608   1.1  jdolecek 	} */ *ap = v;
   1609   1.1  jdolecek 
   1610  1.48   hannken 	KASSERT(UPPERVP(ap->a_dvp) != NULL);
   1611   1.1  jdolecek 
   1612  1.48   hannken 	ap->a_dvp = UPPERVP(ap->a_dvp);
   1613  1.48   hannken 	return VCALL(ap->a_dvp, VOFFSET(vop_abortop), ap);
   1614   1.1  jdolecek }
   1615   1.1  jdolecek 
   1616   1.1  jdolecek int
   1617  1.30      matt union_inactive(void *v)
   1618   1.1  jdolecek {
   1619  1.65  riastrad 	struct vop_inactive_v2_args /* {
   1620  1.14  christos 		const struct vnodeop_desc *a_desc;
   1621   1.1  jdolecek 		struct vnode *a_vp;
   1622  1.25        ad 		bool *a_recycle;
   1623   1.1  jdolecek 	} */ *ap = v;
   1624   1.1  jdolecek 	struct vnode *vp = ap->a_vp;
   1625   1.1  jdolecek 	struct union_node *un = VTOUNION(vp);
   1626   1.1  jdolecek 	struct vnode **vpp;
   1627   1.1  jdolecek 
   1628   1.1  jdolecek 	/*
   1629   1.1  jdolecek 	 * Do nothing (and _don't_ bypass).
   1630   1.1  jdolecek 	 * Wait to vrele lowervp until reclaim,
   1631   1.1  jdolecek 	 * so that until then our union_node is in the
   1632   1.1  jdolecek 	 * cache and reusable.
   1633   1.1  jdolecek 	 *
   1634   1.1  jdolecek 	 * NEEDSWORK: Someday, consider inactive'ing
   1635   1.1  jdolecek 	 * the lowervp and then trying to reactivate it
   1636   1.1  jdolecek 	 * with capabilities (v_id)
   1637   1.1  jdolecek 	 * like they do in the name lookup cache code.
   1638   1.1  jdolecek 	 * That's too much work for now.
   1639   1.1  jdolecek 	 */
   1640   1.1  jdolecek 
   1641   1.1  jdolecek 	if (un->un_dircache != 0) {
   1642   1.1  jdolecek 		for (vpp = un->un_dircache; *vpp != NULLVP; vpp++)
   1643   1.1  jdolecek 			vrele(*vpp);
   1644   1.1  jdolecek 		free(un->un_dircache, M_TEMP);
   1645   1.1  jdolecek 		un->un_dircache = 0;
   1646   1.1  jdolecek 	}
   1647   1.1  jdolecek 
   1648  1.49   hannken 	*ap->a_recycle = ((un->un_cflags & UN_CACHED) == 0);
   1649   1.1  jdolecek 
   1650   1.1  jdolecek 	return (0);
   1651   1.1  jdolecek }
   1652   1.1  jdolecek 
   1653   1.1  jdolecek int
   1654  1.30      matt union_reclaim(void *v)
   1655   1.1  jdolecek {
   1656  1.70  riastrad 	struct vop_reclaim_v2_args /* {
   1657   1.1  jdolecek 		struct vnode *a_vp;
   1658   1.1  jdolecek 	} */ *ap = v;
   1659  1.68   hannken 	struct vnode *vp = ap->a_vp;
   1660  1.68   hannken 	struct vnode *uvp = UPPERVP(vp);
   1661  1.68   hannken 
   1662  1.70  riastrad 	VOP_UNLOCK(vp);
   1663  1.70  riastrad 
   1664  1.68   hannken 	if (uvp != NULL) {
   1665  1.68   hannken 		mutex_enter(uvp->v_interlock);
   1666  1.68   hannken 		KASSERT(vp->v_interlock == uvp->v_interlock);
   1667  1.68   hannken 		uvp->v_writecount -= vp->v_writecount;
   1668  1.68   hannken 		mutex_exit(uvp->v_interlock);
   1669  1.68   hannken 	}
   1670   1.1  jdolecek 
   1671  1.68   hannken 	union_freevp(vp);
   1672   1.1  jdolecek 
   1673   1.1  jdolecek 	return (0);
   1674   1.1  jdolecek }
   1675   1.1  jdolecek 
   1676  1.58   hannken static int
   1677  1.58   hannken union_lock1(struct vnode *vp, struct vnode *lockvp, int flags)
   1678  1.58   hannken {
   1679  1.58   hannken 	struct vop_lock_args ap;
   1680  1.58   hannken 
   1681  1.69   hannken 	ap.a_desc = VDESC(vop_lock);
   1682  1.69   hannken 	ap.a_vp = lockvp;
   1683  1.69   hannken 	ap.a_flags = flags;
   1684  1.69   hannken 
   1685  1.69   hannken 	if (lockvp == vp)
   1686  1.58   hannken 		return genfs_lock(&ap);
   1687  1.69   hannken 	else
   1688  1.69   hannken 		return VCALL(ap.a_vp, VOFFSET(vop_lock), &ap);
   1689  1.58   hannken }
   1690  1.58   hannken 
   1691  1.58   hannken static int
   1692  1.58   hannken union_unlock1(struct vnode *vp, struct vnode *lockvp)
   1693  1.58   hannken {
   1694  1.58   hannken 	struct vop_unlock_args ap;
   1695  1.58   hannken 
   1696  1.69   hannken 	ap.a_desc = VDESC(vop_unlock);
   1697  1.69   hannken 	ap.a_vp = lockvp;
   1698  1.69   hannken 
   1699  1.69   hannken 	if (lockvp == vp)
   1700  1.58   hannken 		return genfs_unlock(&ap);
   1701  1.69   hannken 	else
   1702  1.69   hannken 		return VCALL(ap.a_vp, VOFFSET(vop_unlock), &ap);
   1703  1.58   hannken }
   1704  1.58   hannken 
   1705   1.1  jdolecek int
   1706  1.30      matt union_lock(void *v)
   1707   1.1  jdolecek {
   1708   1.1  jdolecek 	struct vop_lock_args /* {
   1709   1.1  jdolecek 		struct vnode *a_vp;
   1710   1.1  jdolecek 		int a_flags;
   1711   1.1  jdolecek 	} */ *ap = v;
   1712  1.58   hannken 	struct vnode *vp = ap->a_vp, *lockvp;
   1713  1.58   hannken 	struct union_node *un = VTOUNION(vp);
   1714  1.57   hannken 	int flags = ap->a_flags;
   1715   1.1  jdolecek 	int error;
   1716   1.1  jdolecek 
   1717  1.57   hannken 	if ((flags & LK_NOWAIT) != 0) {
   1718  1.57   hannken 		if (!mutex_tryenter(&un->un_lock))
   1719  1.57   hannken 			return EBUSY;
   1720  1.58   hannken 		lockvp = LOCKVP(vp);
   1721  1.58   hannken 		error = union_lock1(vp, lockvp, flags);
   1722  1.58   hannken 		mutex_exit(&un->un_lock);
   1723  1.57   hannken 		return error;
   1724  1.57   hannken 	}
   1725  1.57   hannken 
   1726  1.49   hannken 	mutex_enter(&un->un_lock);
   1727  1.49   hannken 	for (;;) {
   1728  1.58   hannken 		lockvp = LOCKVP(vp);
   1729  1.49   hannken 		mutex_exit(&un->un_lock);
   1730  1.58   hannken 		error = union_lock1(vp, lockvp, flags);
   1731  1.83   hannken 		if (error != 0 || (flags & (LK_DOWNGRADE | LK_UPGRADE)) != 0)
   1732  1.49   hannken 			return error;
   1733  1.49   hannken 		mutex_enter(&un->un_lock);
   1734  1.58   hannken 		if (lockvp == LOCKVP(vp))
   1735  1.49   hannken 			break;
   1736  1.58   hannken 		union_unlock1(vp, lockvp);
   1737  1.19       chs 	}
   1738  1.58   hannken 	mutex_exit(&un->un_lock);
   1739  1.58   hannken 
   1740  1.59   hannken 	return error;
   1741   1.1  jdolecek }
   1742   1.1  jdolecek 
   1743   1.1  jdolecek int
   1744  1.30      matt union_unlock(void *v)
   1745   1.1  jdolecek {
   1746   1.1  jdolecek 	struct vop_unlock_args /* {
   1747   1.1  jdolecek 		struct vnode *a_vp;
   1748   1.1  jdolecek 		int a_flags;
   1749   1.1  jdolecek 	} */ *ap = v;
   1750  1.58   hannken 	struct vnode *vp = ap->a_vp, *lockvp;
   1751   1.1  jdolecek 
   1752  1.58   hannken 	lockvp = LOCKVP(vp);
   1753  1.58   hannken 	union_unlock1(vp, lockvp);
   1754   1.1  jdolecek 
   1755  1.49   hannken 	return 0;
   1756   1.1  jdolecek }
   1757   1.1  jdolecek 
   1758   1.1  jdolecek int
   1759  1.30      matt union_bmap(void *v)
   1760   1.1  jdolecek {
   1761   1.1  jdolecek 	struct vop_bmap_args /* {
   1762   1.1  jdolecek 		struct vnode *a_vp;
   1763   1.1  jdolecek 		daddr_t  a_bn;
   1764   1.1  jdolecek 		struct vnode **a_vpp;
   1765   1.1  jdolecek 		daddr_t *a_bnp;
   1766   1.1  jdolecek 		int *a_runp;
   1767   1.1  jdolecek 	} */ *ap = v;
   1768   1.1  jdolecek 	int error;
   1769   1.1  jdolecek 	struct vnode *vp = OTHERVP(ap->a_vp);
   1770   1.1  jdolecek 	int dolock = (vp == LOWERVP(ap->a_vp));
   1771   1.1  jdolecek 
   1772   1.1  jdolecek 	if (dolock)
   1773   1.1  jdolecek 		vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
   1774   1.1  jdolecek 	ap->a_vp = vp;
   1775   1.1  jdolecek 	error = VCALL(vp, VOFFSET(vop_bmap), ap);
   1776   1.1  jdolecek 	if (dolock)
   1777  1.36   hannken 		VOP_UNLOCK(vp);
   1778   1.1  jdolecek 
   1779   1.1  jdolecek 	return (error);
   1780   1.1  jdolecek }
   1781   1.1  jdolecek 
   1782   1.1  jdolecek int
   1783  1.30      matt union_print(void *v)
   1784   1.1  jdolecek {
   1785   1.1  jdolecek 	struct vop_print_args /* {
   1786   1.1  jdolecek 		struct vnode *a_vp;
   1787   1.1  jdolecek 	} */ *ap = v;
   1788   1.1  jdolecek 	struct vnode *vp = ap->a_vp;
   1789   1.1  jdolecek 
   1790   1.1  jdolecek 	printf("\ttag VT_UNION, vp=%p, uppervp=%p, lowervp=%p\n",
   1791   1.1  jdolecek 			vp, UPPERVP(vp), LOWERVP(vp));
   1792   1.1  jdolecek 	if (UPPERVP(vp) != NULLVP)
   1793   1.1  jdolecek 		vprint("union: upper", UPPERVP(vp));
   1794   1.1  jdolecek 	if (LOWERVP(vp) != NULLVP)
   1795   1.1  jdolecek 		vprint("union: lower", LOWERVP(vp));
   1796   1.1  jdolecek 	if (VTOUNION(vp)->un_dircache) {
   1797   1.1  jdolecek 		struct vnode **vpp;
   1798   1.1  jdolecek 		for (vpp = VTOUNION(vp)->un_dircache; *vpp != NULLVP; vpp++)
   1799   1.1  jdolecek 			vprint("dircache:", *vpp);
   1800   1.1  jdolecek 	}
   1801   1.1  jdolecek 
   1802   1.1  jdolecek 	return (0);
   1803   1.1  jdolecek }
   1804   1.1  jdolecek 
   1805   1.1  jdolecek int
   1806  1.30      matt union_islocked(void *v)
   1807   1.1  jdolecek {
   1808   1.1  jdolecek 	struct vop_islocked_args /* {
   1809   1.1  jdolecek 		struct vnode *a_vp;
   1810   1.1  jdolecek 	} */ *ap = v;
   1811  1.49   hannken 	struct vnode *vp;
   1812  1.49   hannken 	struct union_node *un;
   1813   1.1  jdolecek 
   1814  1.49   hannken 	un = VTOUNION(ap->a_vp);
   1815  1.49   hannken 	mutex_enter(&un->un_lock);
   1816  1.49   hannken 	vp = LOCKVP(ap->a_vp);
   1817  1.49   hannken 	mutex_exit(&un->un_lock);
   1818  1.49   hannken 
   1819  1.49   hannken 	if (vp == ap->a_vp)
   1820  1.49   hannken 		return genfs_islocked(ap);
   1821  1.49   hannken 	else
   1822  1.49   hannken 		return VOP_ISLOCKED(vp);
   1823   1.1  jdolecek }
   1824   1.1  jdolecek 
   1825   1.1  jdolecek int
   1826  1.30      matt union_pathconf(void *v)
   1827   1.1  jdolecek {
   1828   1.1  jdolecek 	struct vop_pathconf_args /* {
   1829   1.1  jdolecek 		struct vnode *a_vp;
   1830   1.1  jdolecek 		int a_name;
   1831   1.1  jdolecek 		int *a_retval;
   1832   1.1  jdolecek 	} */ *ap = v;
   1833   1.1  jdolecek 	int error;
   1834   1.1  jdolecek 	struct vnode *vp = OTHERVP(ap->a_vp);
   1835   1.1  jdolecek 	int dolock = (vp == LOWERVP(ap->a_vp));
   1836   1.1  jdolecek 
   1837   1.1  jdolecek 	if (dolock)
   1838   1.1  jdolecek 		vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
   1839   1.1  jdolecek 	ap->a_vp = vp;
   1840   1.1  jdolecek 	error = VCALL(vp, VOFFSET(vop_pathconf), ap);
   1841   1.1  jdolecek 	if (dolock)
   1842  1.36   hannken 		VOP_UNLOCK(vp);
   1843   1.1  jdolecek 
   1844   1.1  jdolecek 	return (error);
   1845   1.1  jdolecek }
   1846   1.1  jdolecek 
   1847   1.1  jdolecek int
   1848  1.30      matt union_advlock(void *v)
   1849   1.1  jdolecek {
   1850   1.1  jdolecek 	struct vop_advlock_args /* {
   1851   1.1  jdolecek 		struct vnode *a_vp;
   1852  1.10       jrf 		void *a_id;
   1853   1.1  jdolecek 		int  a_op;
   1854   1.1  jdolecek 		struct flock *a_fl;
   1855   1.1  jdolecek 		int  a_flags;
   1856   1.1  jdolecek 	} */ *ap = v;
   1857   1.1  jdolecek 	struct vnode *ovp = OTHERVP(ap->a_vp);
   1858   1.1  jdolecek 
   1859   1.1  jdolecek 	ap->a_vp = ovp;
   1860   1.1  jdolecek 	return (VCALL(ovp, VOFFSET(vop_advlock), ap));
   1861   1.1  jdolecek }
   1862   1.1  jdolecek 
   1863   1.1  jdolecek int
   1864  1.30      matt union_strategy(void *v)
   1865   1.1  jdolecek {
   1866   1.1  jdolecek 	struct vop_strategy_args /* {
   1867   1.8   hannken 		struct vnode *a_vp;
   1868   1.1  jdolecek 		struct buf *a_bp;
   1869   1.1  jdolecek 	} */ *ap = v;
   1870   1.8   hannken 	struct vnode *ovp = OTHERVP(ap->a_vp);
   1871   1.1  jdolecek 	struct buf *bp = ap->a_bp;
   1872   1.1  jdolecek 
   1873  1.45   hannken 	KASSERT(ovp != NULLVP);
   1874  1.45   hannken 	if (!NODE_IS_SPECIAL(ovp))
   1875  1.45   hannken 		KASSERT((bp->b_flags & B_READ) || ovp != LOWERVP(bp->b_vp));
   1876   1.1  jdolecek 
   1877   1.8   hannken 	return (VOP_STRATEGY(ovp, bp));
   1878   1.1  jdolecek }
   1879   1.1  jdolecek 
   1880   1.1  jdolecek int
   1881  1.44   hannken union_bwrite(void *v)
   1882  1.44   hannken {
   1883  1.44   hannken 	struct vop_bwrite_args /* {
   1884  1.44   hannken 		struct vnode *a_vp;
   1885  1.44   hannken 		struct buf *a_bp;
   1886  1.44   hannken 	} */ *ap = v;
   1887  1.44   hannken 	struct vnode *ovp = OTHERVP(ap->a_vp);
   1888  1.44   hannken 	struct buf *bp = ap->a_bp;
   1889  1.44   hannken 
   1890  1.45   hannken 	KASSERT(ovp != NULLVP);
   1891  1.45   hannken 	if (!NODE_IS_SPECIAL(ovp))
   1892  1.45   hannken 		KASSERT((bp->b_flags & B_READ) || ovp != LOWERVP(bp->b_vp));
   1893  1.44   hannken 
   1894  1.44   hannken 	return (VOP_BWRITE(ovp, bp));
   1895  1.44   hannken }
   1896  1.44   hannken 
   1897  1.44   hannken int
   1898  1.30      matt union_getpages(void *v)
   1899   1.1  jdolecek {
   1900   1.1  jdolecek 	struct vop_getpages_args /* {
   1901   1.1  jdolecek 		struct vnode *a_vp;
   1902   1.1  jdolecek 		voff_t a_offset;
   1903   1.1  jdolecek 		struct vm_page **a_m;
   1904   1.1  jdolecek 		int *a_count;
   1905   1.1  jdolecek 		int a_centeridx;
   1906   1.1  jdolecek 		vm_prot_t a_access_type;
   1907   1.1  jdolecek 		int a_advice;
   1908   1.1  jdolecek 		int a_flags;
   1909   1.1  jdolecek 	} */ *ap = v;
   1910   1.1  jdolecek 	struct vnode *vp = ap->a_vp;
   1911   1.1  jdolecek 
   1912  1.72        ad 	KASSERT(rw_lock_held(vp->v_uobj.vmobjlock));
   1913   1.1  jdolecek 
   1914   1.1  jdolecek 	if (ap->a_flags & PGO_LOCKED) {
   1915   1.1  jdolecek 		return EBUSY;
   1916   1.1  jdolecek 	}
   1917   1.1  jdolecek 	ap->a_vp = OTHERVP(vp);
   1918  1.72        ad 	KASSERT(vp->v_uobj.vmobjlock == ap->a_vp->v_uobj.vmobjlock);
   1919  1.40     rmind 
   1920  1.40     rmind 	/* Just pass the request on to the underlying layer. */
   1921  1.40     rmind 	return VCALL(ap->a_vp, VOFFSET(vop_getpages), ap);
   1922   1.1  jdolecek }
   1923   1.1  jdolecek 
   1924   1.1  jdolecek int
   1925  1.30      matt union_putpages(void *v)
   1926   1.1  jdolecek {
   1927   1.1  jdolecek 	struct vop_putpages_args /* {
   1928   1.1  jdolecek 		struct vnode *a_vp;
   1929   1.1  jdolecek 		voff_t a_offlo;
   1930   1.1  jdolecek 		voff_t a_offhi;
   1931   1.1  jdolecek 		int a_flags;
   1932   1.1  jdolecek 	} */ *ap = v;
   1933   1.1  jdolecek 	struct vnode *vp = ap->a_vp;
   1934   1.1  jdolecek 
   1935  1.72        ad 	KASSERT(rw_lock_held(vp->v_uobj.vmobjlock));
   1936   1.1  jdolecek 
   1937   1.1  jdolecek 	ap->a_vp = OTHERVP(vp);
   1938  1.72        ad 	KASSERT(vp->v_uobj.vmobjlock == ap->a_vp->v_uobj.vmobjlock);
   1939  1.40     rmind 
   1940  1.20       chs 	if (ap->a_flags & PGO_RECLAIM) {
   1941  1.72        ad 		rw_exit(vp->v_uobj.vmobjlock);
   1942  1.20       chs 		return 0;
   1943  1.20       chs 	}
   1944  1.40     rmind 
   1945  1.40     rmind 	/* Just pass the request on to the underlying layer. */
   1946  1.40     rmind 	return VCALL(ap->a_vp, VOFFSET(vop_putpages), ap);
   1947   1.2  jdolecek }
   1948   1.2  jdolecek 
   1949   1.2  jdolecek int
   1950   1.2  jdolecek union_kqfilter(void *v)
   1951   1.2  jdolecek {
   1952   1.2  jdolecek 	struct vop_kqfilter_args /* {
   1953   1.2  jdolecek 		struct vnode	*a_vp;
   1954   1.2  jdolecek 		struct knote	*a_kn;
   1955   1.2  jdolecek 	} */ *ap = v;
   1956   1.2  jdolecek 	int error;
   1957   1.2  jdolecek 
   1958   1.2  jdolecek 	/*
   1959   1.2  jdolecek 	 * We watch either the upper layer file (if it already exists),
   1960   1.2  jdolecek 	 * or the lower layer one. If there is lower layer file only
   1961   1.2  jdolecek 	 * at this moment, we will keep watching that lower layer file
   1962   1.2  jdolecek 	 * even if upper layer file would be created later on.
   1963   1.2  jdolecek 	 */
   1964   1.2  jdolecek 	if (UPPERVP(ap->a_vp))
   1965   1.2  jdolecek 		error = VOP_KQFILTER(UPPERVP(ap->a_vp), ap->a_kn);
   1966   1.2  jdolecek 	else if (LOWERVP(ap->a_vp))
   1967   1.2  jdolecek 		error = VOP_KQFILTER(LOWERVP(ap->a_vp), ap->a_kn);
   1968   1.2  jdolecek 	else {
   1969   1.2  jdolecek 		/* panic? */
   1970   1.2  jdolecek 		error = EOPNOTSUPP;
   1971   1.2  jdolecek 	}
   1972   1.2  jdolecek 
   1973   1.2  jdolecek 	return (error);
   1974   1.1  jdolecek }
   1975