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