1/*- 2 * SPDX-License-Identifier: BSD-3-Clause 3 * 4 * Copyright (c) 1992, 1993, 1994, 1995 Jan-Simon Pendry. 5 * Copyright (c) 1992, 1993, 1994, 1995 6 * The Regents of the University of California. 7 * Copyright (c) 2005, 2006, 2012 Masanori Ozawa <ozawa@ongs.co.jp>, ONGS Inc. 8 * Copyright (c) 2006, 2012 Daichi Goto <daichi@freebsd.org> 9 * All rights reserved. 10 * 11 * This code is derived from software contributed to Berkeley by 12 * Jan-Simon Pendry. 13 * 14 * Redistribution and use in source and binary forms, with or without 15 * modification, are permitted provided that the following conditions 16 * are met: 17 * 1. Redistributions of source code must retain the above copyright 18 * notice, this list of conditions and the following disclaimer. 19 * 2. Redistributions in binary form must reproduce the above copyright 20 * notice, this list of conditions and the following disclaimer in the 21 * documentation and/or other materials provided with the distribution. 22 * 3. Neither the name of the University nor the names of its contributors 23 * may be used to endorse or promote products derived from this software 24 * without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 27 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 28 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 29 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 30 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 31 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 32 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 33 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 34 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 35 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 36 * SUCH DAMAGE. 37 * 38 * @(#)union_vnops.c 8.32 (Berkeley) 6/23/95 39 * $FreeBSD$ 40 * 41 */ 42 43#include <sys/param.h> 44#include <sys/systm.h> 45#include <sys/conf.h> 46#include <sys/kernel.h> 47#include <sys/lock.h> 48#include <sys/malloc.h> 49#include <sys/mount.h> 50#include <sys/mutex.h> 51#include <sys/namei.h> 52#include <sys/sysctl.h> 53#include <sys/vnode.h> 54#include <sys/kdb.h> 55#include <sys/fcntl.h> 56#include <sys/stat.h> 57#include <sys/dirent.h> 58#include <sys/proc.h> 59#include <sys/bio.h> 60#include <sys/buf.h> 61 62#include <fs/unionfs/union.h> 63 64#include <vm/vm.h> 65#include <vm/vm_extern.h> 66#include <vm/vm_object.h> 67#include <vm/vnode_pager.h> 68 69#if 0 70#define UNIONFS_INTERNAL_DEBUG(msg, args...) printf(msg, ## args) 71#define UNIONFS_IDBG_RENAME 72#else 73#define UNIONFS_INTERNAL_DEBUG(msg, args...) 74#endif 75 76#define KASSERT_UNIONFS_VNODE(vp) \ 77 KASSERT(((vp)->v_op == &unionfs_vnodeops), \ 78 ("unionfs: it is not unionfs-vnode")) 79 80static int 81unionfs_lookup(struct vop_cachedlookup_args *ap) 82{ 83 int iswhiteout; 84 int lockflag; 85 int error , uerror, lerror; 86 u_long nameiop; 87 u_long cnflags, cnflagsbk; 88 struct unionfs_node *dunp; 89 struct vnode *dvp, *udvp, *ldvp, *vp, *uvp, *lvp, *dtmpvp; 90 struct vattr va; 91 struct componentname *cnp; 92 struct thread *td; 93 94 iswhiteout = 0; 95 lockflag = 0; 96 error = uerror = lerror = ENOENT; 97 cnp = ap->a_cnp; 98 nameiop = cnp->cn_nameiop; 99 cnflags = cnp->cn_flags; 100 dvp = ap->a_dvp; 101 dunp = VTOUNIONFS(dvp); 102 udvp = dunp->un_uppervp; 103 ldvp = dunp->un_lowervp; 104 vp = uvp = lvp = NULLVP; 105 td = curthread; 106 *(ap->a_vpp) = NULLVP; 107 108 UNIONFS_INTERNAL_DEBUG("unionfs_lookup: enter: nameiop=%ld, flags=%lx, path=%s\n", nameiop, cnflags, cnp->cn_nameptr); 109 110 if (dvp->v_type != VDIR) 111 return (ENOTDIR); 112 113 /* 114 * If read-only and op is not LOOKUP, will return EROFS. 115 */ 116 if ((cnflags & ISLASTCN) && 117 (dvp->v_mount->mnt_flag & MNT_RDONLY) && 118 LOOKUP != nameiop) 119 return (EROFS); 120 121 /* 122 * lookup dotdot 123 */ 124 if (cnflags & ISDOTDOT) { 125 if (LOOKUP != nameiop && udvp == NULLVP) 126 return (EROFS); 127 128 if (udvp != NULLVP) { 129 dtmpvp = udvp; 130 if (ldvp != NULLVP) 131 VOP_UNLOCK(ldvp, LK_RELEASE); 132 } 133 else 134 dtmpvp = ldvp; 135 136 error = VOP_LOOKUP(dtmpvp, &vp, cnp); 137 138 if (dtmpvp == udvp && ldvp != NULLVP) { 139 VOP_UNLOCK(udvp, LK_RELEASE); 140 vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY); 141 } 142 143 if (error == 0) { 144 /* 145 * Exchange lock and reference from vp to 146 * dunp->un_dvp. vp is upper/lower vnode, but it 147 * will need to return the unionfs vnode. 148 */ 149 if (nameiop == DELETE || nameiop == RENAME || 150 (cnp->cn_lkflags & LK_TYPE_MASK)) 151 VOP_UNLOCK(vp, LK_RELEASE); 152 vrele(vp); 153 154 VOP_UNLOCK(dvp, LK_RELEASE); 155 *(ap->a_vpp) = dunp->un_dvp; 156 vref(dunp->un_dvp); 157 158 if (nameiop == DELETE || nameiop == RENAME) 159 vn_lock(dunp->un_dvp, LK_EXCLUSIVE | LK_RETRY); 160 else if (cnp->cn_lkflags & LK_TYPE_MASK) 161 vn_lock(dunp->un_dvp, cnp->cn_lkflags | 162 LK_RETRY); 163 164 vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY); 165 } else if (error == ENOENT && (cnflags & MAKEENTRY) != 0) 166 cache_enter(dvp, NULLVP, cnp); 167 168 UNIONFS_INTERNAL_DEBUG("unionfs_lookup: leave (%d)\n", error); 169 170 return (error); 171 } 172 173 /* 174 * lookup upper layer 175 */ 176 if (udvp != NULLVP) { 177 uerror = VOP_LOOKUP(udvp, &uvp, cnp); 178 179 if (uerror == 0) { 180 if (udvp == uvp) { /* is dot */ 181 vrele(uvp); 182 *(ap->a_vpp) = dvp; 183 vref(dvp); 184 185 UNIONFS_INTERNAL_DEBUG("unionfs_lookup: leave (%d)\n", uerror); 186 187 return (uerror); 188 } 189 if (nameiop == DELETE || nameiop == RENAME || 190 (cnp->cn_lkflags & LK_TYPE_MASK)) 191 VOP_UNLOCK(uvp, LK_RELEASE); 192 } 193 194 /* check whiteout */ 195 if (uerror == ENOENT || uerror == EJUSTRETURN) 196 if (cnp->cn_flags & ISWHITEOUT) 197 iswhiteout = 1; /* don't lookup lower */ 198 if (iswhiteout == 0 && ldvp != NULLVP) 199 if (!VOP_GETATTR(udvp, &va, cnp->cn_cred) && 200 (va.va_flags & OPAQUE)) 201 iswhiteout = 1; /* don't lookup lower */ 202#if 0 203 UNIONFS_INTERNAL_DEBUG("unionfs_lookup: debug: whiteout=%d, path=%s\n", iswhiteout, cnp->cn_nameptr); 204#endif 205 } 206 207 /* 208 * lookup lower layer 209 */ 210 if (ldvp != NULLVP && !(cnflags & DOWHITEOUT) && iswhiteout == 0) { 211 /* always op is LOOKUP */ 212 cnp->cn_nameiop = LOOKUP; 213 cnflagsbk = cnp->cn_flags; 214 cnp->cn_flags = cnflags; 215 216 lerror = VOP_LOOKUP(ldvp, &lvp, cnp); 217 218 cnp->cn_nameiop = nameiop; 219 if (udvp != NULLVP && (uerror == 0 || uerror == EJUSTRETURN)) 220 cnp->cn_flags = cnflagsbk; 221 222 if (lerror == 0) { 223 if (ldvp == lvp) { /* is dot */ 224 if (uvp != NULLVP) 225 vrele(uvp); /* no need? */ 226 vrele(lvp); 227 *(ap->a_vpp) = dvp; 228 vref(dvp); 229 230 UNIONFS_INTERNAL_DEBUG("unionfs_lookup: leave (%d)\n", lerror); 231 232 return (lerror); 233 } 234 if (cnp->cn_lkflags & LK_TYPE_MASK) 235 VOP_UNLOCK(lvp, LK_RELEASE); 236 } 237 } 238 239 /* 240 * check lookup result 241 */ 242 if (uvp == NULLVP && lvp == NULLVP) { 243 UNIONFS_INTERNAL_DEBUG("unionfs_lookup: leave (%d)\n", 244 (udvp != NULLVP ? uerror : lerror)); 245 return (udvp != NULLVP ? uerror : lerror); 246 } 247 248 /* 249 * check vnode type 250 */ 251 if (uvp != NULLVP && lvp != NULLVP && uvp->v_type != lvp->v_type) { 252 vrele(lvp); 253 lvp = NULLVP; 254 } 255 256 /* 257 * check shadow dir 258 */ 259 if (uerror != 0 && uerror != EJUSTRETURN && udvp != NULLVP && 260 lerror == 0 && lvp != NULLVP && lvp->v_type == VDIR && 261 !(dvp->v_mount->mnt_flag & MNT_RDONLY) && 262 (1 < cnp->cn_namelen || '.' != *(cnp->cn_nameptr))) { 263 /* get unionfs vnode in order to create a new shadow dir. */ 264 error = unionfs_nodeget(dvp->v_mount, NULLVP, lvp, dvp, &vp, 265 cnp, td); 266 if (error != 0) 267 goto unionfs_lookup_out; 268 269 if (LK_SHARED == (cnp->cn_lkflags & LK_TYPE_MASK)) 270 VOP_UNLOCK(vp, LK_RELEASE); 271 if (LK_EXCLUSIVE != VOP_ISLOCKED(vp)) { 272 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 273 lockflag = 1; 274 } 275 error = unionfs_mkshadowdir(MOUNTTOUNIONFSMOUNT(dvp->v_mount), 276 udvp, VTOUNIONFS(vp), cnp, td); 277 if (lockflag != 0) 278 VOP_UNLOCK(vp, LK_RELEASE); 279 if (error != 0) { 280 UNIONFSDEBUG("unionfs_lookup: Unable to create shadow dir."); 281 if ((cnp->cn_lkflags & LK_TYPE_MASK) == LK_EXCLUSIVE) 282 vput(vp); 283 else 284 vrele(vp); 285 goto unionfs_lookup_out; 286 } 287 if ((cnp->cn_lkflags & LK_TYPE_MASK) == LK_SHARED) 288 vn_lock(vp, LK_SHARED | LK_RETRY); 289 } 290 /* 291 * get unionfs vnode. 292 */ 293 else { 294 if (uvp != NULLVP) 295 error = uerror; 296 else 297 error = lerror; 298 if (error != 0) 299 goto unionfs_lookup_out; 300 /* 301 * get socket vnode. 302 */ 303 if (uvp != NULLVP && uvp->v_type == VSOCK) { 304 vp = uvp; 305 vref(vp); 306 if (cnp->cn_lkflags & LK_TYPE_MASK) 307 vn_lock(vp, cnp->cn_lkflags | LK_RETRY); 308 } 309 else if (lvp != NULLVP && lvp->v_type == VSOCK) { 310 vp = lvp; 311 vref(vp); 312 if (cnp->cn_lkflags & LK_TYPE_MASK) 313 vn_lock(vp, cnp->cn_lkflags | LK_RETRY); 314 } 315 /* 316 * get unionfs vnode. 317 */ 318 else 319 error = unionfs_nodeget(dvp->v_mount, uvp, lvp, 320 dvp, &vp, cnp, td); 321 if (error != 0) { 322 UNIONFSDEBUG("unionfs_lookup: Unable to create unionfs vnode."); 323 goto unionfs_lookup_out; 324 } 325 if ((nameiop == DELETE || nameiop == RENAME) && 326 (cnp->cn_lkflags & LK_TYPE_MASK) == 0) 327 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 328 } 329 330 *(ap->a_vpp) = vp; 331 332 if ((cnflags & MAKEENTRY) && vp->v_type != VSOCK) 333 cache_enter(dvp, vp, cnp); 334 335unionfs_lookup_out: 336 if (uvp != NULLVP) 337 vrele(uvp); 338 if (lvp != NULLVP) 339 vrele(lvp); 340 341 if (error == ENOENT && (cnflags & MAKEENTRY) != 0) 342 cache_enter(dvp, NULLVP, cnp); 343 344 UNIONFS_INTERNAL_DEBUG("unionfs_lookup: leave (%d)\n", error); 345 346 return (error); 347} 348 349static int 350unionfs_create(struct vop_create_args *ap) 351{ 352 struct unionfs_node *dunp; 353 struct componentname *cnp; 354 struct vnode *udvp; 355 struct vnode *vp; 356 int error; 357 358 UNIONFS_INTERNAL_DEBUG("unionfs_create: enter\n"); 359 360 KASSERT_UNIONFS_VNODE(ap->a_dvp); 361 362 dunp = VTOUNIONFS(ap->a_dvp); 363 cnp = ap->a_cnp; 364 udvp = dunp->un_uppervp; 365 error = EROFS; 366 367 if (udvp != NULLVP) { 368 error = VOP_CREATE(udvp, &vp, cnp, ap->a_vap); 369 if (error != 0) 370 goto unionfs_create_abort; 371 372 if (vp->v_type == VSOCK) 373 *(ap->a_vpp) = vp; 374 else { 375 VOP_UNLOCK(vp, LK_RELEASE); 376 error = unionfs_nodeget(ap->a_dvp->v_mount, vp, NULLVP, 377 ap->a_dvp, ap->a_vpp, cnp, curthread); 378 vrele(vp); 379 } 380 } 381 382unionfs_create_abort: 383 UNIONFS_INTERNAL_DEBUG("unionfs_create: leave (%d)\n", error); 384 385 return (error); 386} 387 388static int 389unionfs_whiteout(struct vop_whiteout_args *ap) 390{ 391 struct unionfs_node *dunp; 392 struct componentname *cnp; 393 struct vnode *udvp; 394 int error; 395 396 UNIONFS_INTERNAL_DEBUG("unionfs_whiteout: enter\n"); 397 398 KASSERT_UNIONFS_VNODE(ap->a_dvp); 399 400 dunp = VTOUNIONFS(ap->a_dvp); 401 cnp = ap->a_cnp; 402 udvp = dunp->un_uppervp; 403 error = EOPNOTSUPP; 404 405 if (udvp != NULLVP) { 406 switch (ap->a_flags) { 407 case CREATE: 408 case DELETE: 409 case LOOKUP: 410 error = VOP_WHITEOUT(udvp, cnp, ap->a_flags); 411 break; 412 default: 413 error = EINVAL; 414 break; 415 } 416 } 417 418 UNIONFS_INTERNAL_DEBUG("unionfs_whiteout: leave (%d)\n", error); 419 420 return (error); 421} 422 423static int 424unionfs_mknod(struct vop_mknod_args *ap) 425{ 426 struct unionfs_node *dunp; 427 struct componentname *cnp; 428 struct vnode *udvp; 429 struct vnode *vp; 430 int error; 431 432 UNIONFS_INTERNAL_DEBUG("unionfs_mknod: enter\n"); 433 434 KASSERT_UNIONFS_VNODE(ap->a_dvp); 435 436 dunp = VTOUNIONFS(ap->a_dvp); 437 cnp = ap->a_cnp; 438 udvp = dunp->un_uppervp; 439 error = EROFS; 440 441 if (udvp != NULLVP) { 442 error = VOP_MKNOD(udvp, &vp, cnp, ap->a_vap); 443 if (error != 0) 444 goto unionfs_mknod_abort; 445 446 if (vp->v_type == VSOCK) 447 *(ap->a_vpp) = vp; 448 else { 449 VOP_UNLOCK(vp, LK_RELEASE); 450 error = unionfs_nodeget(ap->a_dvp->v_mount, vp, NULLVP, 451 ap->a_dvp, ap->a_vpp, cnp, curthread); 452 vrele(vp); 453 } 454 } 455 456unionfs_mknod_abort: 457 UNIONFS_INTERNAL_DEBUG("unionfs_mknod: leave (%d)\n", error); 458 459 return (error); 460} 461 462static int 463unionfs_open(struct vop_open_args *ap) 464{ 465 int error; 466 struct unionfs_node *unp; 467 struct unionfs_node_status *unsp; 468 struct vnode *uvp; 469 struct vnode *lvp; 470 struct vnode *targetvp; 471 struct ucred *cred; 472 struct thread *td; 473 474 UNIONFS_INTERNAL_DEBUG("unionfs_open: enter\n"); 475 476 KASSERT_UNIONFS_VNODE(ap->a_vp); 477 478 error = 0; 479 unp = VTOUNIONFS(ap->a_vp); 480 uvp = unp->un_uppervp; 481 lvp = unp->un_lowervp; 482 targetvp = NULLVP; 483 cred = ap->a_cred; 484 td = ap->a_td; 485 486 unionfs_get_node_status(unp, td, &unsp); 487 488 if (unsp->uns_lower_opencnt > 0 || unsp->uns_upper_opencnt > 0) { 489 /* vnode is already opend. */ 490 if (unsp->uns_upper_opencnt > 0) 491 targetvp = uvp; 492 else 493 targetvp = lvp; 494 495 if (targetvp == lvp && 496 (ap->a_mode & FWRITE) && lvp->v_type == VREG) 497 targetvp = NULLVP; 498 } 499 if (targetvp == NULLVP) { 500 if (uvp == NULLVP) { 501 if ((ap->a_mode & FWRITE) && lvp->v_type == VREG) { 502 error = unionfs_copyfile(unp, 503 !(ap->a_mode & O_TRUNC), cred, td); 504 if (error != 0) 505 goto unionfs_open_abort; 506 targetvp = uvp = unp->un_uppervp; 507 } else 508 targetvp = lvp; 509 } else 510 targetvp = uvp; 511 } 512 513 error = VOP_OPEN(targetvp, ap->a_mode, cred, td, ap->a_fp); 514 if (error == 0) { 515 if (targetvp == uvp) { 516 if (uvp->v_type == VDIR && lvp != NULLVP && 517 unsp->uns_lower_opencnt <= 0) { 518 /* open lower for readdir */ 519 error = VOP_OPEN(lvp, FREAD, cred, td, NULL); 520 if (error != 0) { 521 VOP_CLOSE(uvp, ap->a_mode, cred, td); 522 goto unionfs_open_abort; 523 } 524 unsp->uns_node_flag |= UNS_OPENL_4_READDIR; 525 unsp->uns_lower_opencnt++; 526 } 527 unsp->uns_upper_opencnt++; 528 } else { 529 unsp->uns_lower_opencnt++; 530 unsp->uns_lower_openmode = ap->a_mode; 531 } 532 ap->a_vp->v_object = targetvp->v_object; 533 } 534 535unionfs_open_abort: 536 if (error != 0) 537 unionfs_tryrem_node_status(unp, unsp); 538 539 UNIONFS_INTERNAL_DEBUG("unionfs_open: leave (%d)\n", error); 540 541 return (error); 542} 543 544static int 545unionfs_close(struct vop_close_args *ap) 546{ 547 int error; 548 int locked; 549 struct unionfs_node *unp; 550 struct unionfs_node_status *unsp; 551 struct ucred *cred; 552 struct thread *td; 553 struct vnode *vp; 554 struct vnode *ovp; 555 556 UNIONFS_INTERNAL_DEBUG("unionfs_close: enter\n"); 557 558 KASSERT_UNIONFS_VNODE(ap->a_vp); 559 560 locked = 0; 561 vp = ap->a_vp; 562 unp = VTOUNIONFS(vp); 563 cred = ap->a_cred; 564 td = ap->a_td; 565 566 if (VOP_ISLOCKED(vp) != LK_EXCLUSIVE) { 567 if (vn_lock(vp, LK_UPGRADE) != 0) 568 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 569 locked = 1; 570 } 571 unionfs_get_node_status(unp, td, &unsp); 572 573 if (unsp->uns_lower_opencnt <= 0 && unsp->uns_upper_opencnt <= 0) { 574#ifdef DIAGNOSTIC 575 printf("unionfs_close: warning: open count is 0\n"); 576#endif 577 if (unp->un_uppervp != NULLVP) 578 ovp = unp->un_uppervp; 579 else 580 ovp = unp->un_lowervp; 581 } else if (unsp->uns_upper_opencnt > 0) 582 ovp = unp->un_uppervp; 583 else 584 ovp = unp->un_lowervp; 585 586 error = VOP_CLOSE(ovp, ap->a_fflag, cred, td); 587 588 if (error != 0) 589 goto unionfs_close_abort; 590 591 vp->v_object = ovp->v_object; 592 593 if (ovp == unp->un_uppervp) { 594 unsp->uns_upper_opencnt--; 595 if (unsp->uns_upper_opencnt == 0) { 596 if (unsp->uns_node_flag & UNS_OPENL_4_READDIR) { 597 VOP_CLOSE(unp->un_lowervp, FREAD, cred, td); 598 unsp->uns_node_flag &= ~UNS_OPENL_4_READDIR; 599 unsp->uns_lower_opencnt--; 600 } 601 if (unsp->uns_lower_opencnt > 0) 602 vp->v_object = unp->un_lowervp->v_object; 603 } 604 } else 605 unsp->uns_lower_opencnt--; 606 607unionfs_close_abort: 608 unionfs_tryrem_node_status(unp, unsp); 609 610 if (locked != 0) 611 vn_lock(vp, LK_DOWNGRADE | LK_RETRY); 612 613 UNIONFS_INTERNAL_DEBUG("unionfs_close: leave (%d)\n", error); 614 615 return (error); 616} 617 618/* 619 * Check the access mode toward shadow file/dir. 620 */ 621static int 622unionfs_check_corrected_access(accmode_t accmode, 623 struct vattr *va, 624 struct ucred *cred) 625{ 626 int count; 627 uid_t uid; /* upper side vnode's uid */ 628 gid_t gid; /* upper side vnode's gid */ 629 u_short vmode; /* upper side vnode's mode */ 630 u_short mask; 631 632 mask = 0; 633 uid = va->va_uid; 634 gid = va->va_gid; 635 vmode = va->va_mode; 636 637 /* check owner */ 638 if (cred->cr_uid == uid) { 639 if (accmode & VEXEC) 640 mask |= S_IXUSR; 641 if (accmode & VREAD) 642 mask |= S_IRUSR; 643 if (accmode & VWRITE) 644 mask |= S_IWUSR; 645 return ((vmode & mask) == mask ? 0 : EACCES); 646 } 647 648 /* check group */ 649 count = 0; 650 if (groupmember(gid, cred)) { 651 if (accmode & VEXEC) 652 mask |= S_IXGRP; 653 if (accmode & VREAD) 654 mask |= S_IRGRP; 655 if (accmode & VWRITE) 656 mask |= S_IWGRP; 657 return ((vmode & mask) == mask ? 0 : EACCES); 658 } 659 660 /* check other */ 661 if (accmode & VEXEC) 662 mask |= S_IXOTH; 663 if (accmode & VREAD) 664 mask |= S_IROTH; 665 if (accmode & VWRITE) 666 mask |= S_IWOTH; 667 668 return ((vmode & mask) == mask ? 0 : EACCES); 669} 670 671static int 672unionfs_access(struct vop_access_args *ap) 673{ 674 struct unionfs_mount *ump; 675 struct unionfs_node *unp; 676 struct vnode *uvp; 677 struct vnode *lvp; 678 struct thread *td; 679 struct vattr va; 680 accmode_t accmode; 681 int error; 682 683 UNIONFS_INTERNAL_DEBUG("unionfs_access: enter\n"); 684 685 KASSERT_UNIONFS_VNODE(ap->a_vp); 686 687 ump = MOUNTTOUNIONFSMOUNT(ap->a_vp->v_mount); 688 unp = VTOUNIONFS(ap->a_vp); 689 uvp = unp->un_uppervp; 690 lvp = unp->un_lowervp; 691 td = ap->a_td; 692 accmode = ap->a_accmode; 693 error = EACCES; 694 695 if ((accmode & VWRITE) && 696 (ap->a_vp->v_mount->mnt_flag & MNT_RDONLY)) { 697 switch (ap->a_vp->v_type) { 698 case VREG: 699 case VDIR: 700 case VLNK: 701 return (EROFS); 702 default: 703 break; 704 } 705 } 706 707 if (uvp != NULLVP) { 708 error = VOP_ACCESS(uvp, accmode, ap->a_cred, td); 709 710 UNIONFS_INTERNAL_DEBUG("unionfs_access: leave (%d)\n", error); 711 712 return (error); 713 } 714 715 if (lvp != NULLVP) { 716 if (accmode & VWRITE) { 717 if (ump->um_uppervp->v_mount->mnt_flag & MNT_RDONLY) { 718 switch (ap->a_vp->v_type) { 719 case VREG: 720 case VDIR: 721 case VLNK: 722 return (EROFS); 723 default: 724 break; 725 } 726 } else if (ap->a_vp->v_type == VREG || ap->a_vp->v_type == VDIR) { 727 /* check shadow file/dir */ 728 if (ump->um_copymode != UNIONFS_TRANSPARENT) { 729 error = unionfs_create_uppervattr(ump, 730 lvp, &va, ap->a_cred, td); 731 if (error != 0) 732 return (error); 733 734 error = unionfs_check_corrected_access( 735 accmode, &va, ap->a_cred); 736 if (error != 0) 737 return (error); 738 } 739 } 740 accmode &= ~(VWRITE | VAPPEND); 741 accmode |= VREAD; /* will copy to upper */ 742 } 743 error = VOP_ACCESS(lvp, accmode, ap->a_cred, td); 744 } 745 746 UNIONFS_INTERNAL_DEBUG("unionfs_access: leave (%d)\n", error); 747 748 return (error); 749} 750 751static int 752unionfs_getattr(struct vop_getattr_args *ap) 753{ 754 int error; 755 struct unionfs_node *unp; 756 struct unionfs_mount *ump; 757 struct vnode *uvp; 758 struct vnode *lvp; 759 struct thread *td; 760 struct vattr va; 761 762 UNIONFS_INTERNAL_DEBUG("unionfs_getattr: enter\n"); 763 764 KASSERT_UNIONFS_VNODE(ap->a_vp); 765 766 unp = VTOUNIONFS(ap->a_vp); 767 ump = MOUNTTOUNIONFSMOUNT(ap->a_vp->v_mount); 768 uvp = unp->un_uppervp; 769 lvp = unp->un_lowervp; 770 td = curthread; 771 772 if (uvp != NULLVP) { 773 if ((error = VOP_GETATTR(uvp, ap->a_vap, ap->a_cred)) == 0) 774 ap->a_vap->va_fsid = ap->a_vp->v_mount->mnt_stat.f_fsid.val[0]; 775 776 UNIONFS_INTERNAL_DEBUG("unionfs_getattr: leave mode=%o, uid=%d, gid=%d (%d)\n", 777 ap->a_vap->va_mode, ap->a_vap->va_uid, 778 ap->a_vap->va_gid, error); 779 780 return (error); 781 } 782 783 error = VOP_GETATTR(lvp, ap->a_vap, ap->a_cred); 784 785 if (error == 0 && !(ump->um_uppervp->v_mount->mnt_flag & MNT_RDONLY)) { 786 /* correct the attr toward shadow file/dir. */ 787 if (ap->a_vp->v_type == VREG || ap->a_vp->v_type == VDIR) { 788 unionfs_create_uppervattr_core(ump, ap->a_vap, &va, td); 789 ap->a_vap->va_mode = va.va_mode; 790 ap->a_vap->va_uid = va.va_uid; 791 ap->a_vap->va_gid = va.va_gid; 792 } 793 } 794 795 if (error == 0) 796 ap->a_vap->va_fsid = ap->a_vp->v_mount->mnt_stat.f_fsid.val[0]; 797 798 UNIONFS_INTERNAL_DEBUG("unionfs_getattr: leave mode=%o, uid=%d, gid=%d (%d)\n", 799 ap->a_vap->va_mode, ap->a_vap->va_uid, ap->a_vap->va_gid, error); 800 801 return (error); 802} 803 804static int 805unionfs_setattr(struct vop_setattr_args *ap) 806{ 807 int error; 808 struct unionfs_node *unp; 809 struct vnode *uvp; 810 struct vnode *lvp; 811 struct thread *td; 812 struct vattr *vap; 813 814 UNIONFS_INTERNAL_DEBUG("unionfs_setattr: enter\n"); 815 816 KASSERT_UNIONFS_VNODE(ap->a_vp); 817 818 error = EROFS; 819 unp = VTOUNIONFS(ap->a_vp); 820 uvp = unp->un_uppervp; 821 lvp = unp->un_lowervp; 822 td = curthread; 823 vap = ap->a_vap; 824 825 if ((ap->a_vp->v_mount->mnt_flag & MNT_RDONLY) && 826 (vap->va_flags != VNOVAL || vap->va_uid != (uid_t)VNOVAL || 827 vap->va_gid != (gid_t)VNOVAL || vap->va_atime.tv_sec != VNOVAL || 828 vap->va_mtime.tv_sec != VNOVAL || vap->va_mode != (mode_t)VNOVAL)) 829 return (EROFS); 830 831 if (uvp == NULLVP && lvp->v_type == VREG) { 832 error = unionfs_copyfile(unp, (vap->va_size != 0), 833 ap->a_cred, td); 834 if (error != 0) 835 return (error); 836 uvp = unp->un_uppervp; 837 } 838 839 if (uvp != NULLVP) 840 error = VOP_SETATTR(uvp, vap, ap->a_cred); 841 842 UNIONFS_INTERNAL_DEBUG("unionfs_setattr: leave (%d)\n", error); 843 844 return (error); 845} 846 847static int 848unionfs_read(struct vop_read_args *ap) 849{ 850 int error; 851 struct unionfs_node *unp; 852 struct vnode *tvp; 853 854 /* UNIONFS_INTERNAL_DEBUG("unionfs_read: enter\n"); */ 855 856 KASSERT_UNIONFS_VNODE(ap->a_vp); 857 858 unp = VTOUNIONFS(ap->a_vp); 859 tvp = (unp->un_uppervp != NULLVP ? unp->un_uppervp : unp->un_lowervp); 860 861 error = VOP_READ(tvp, ap->a_uio, ap->a_ioflag, ap->a_cred); 862 863 /* UNIONFS_INTERNAL_DEBUG("unionfs_read: leave (%d)\n", error); */ 864 865 return (error); 866} 867 868static int 869unionfs_write(struct vop_write_args *ap) 870{ 871 int error; 872 struct unionfs_node *unp; 873 struct vnode *tvp; 874 875 /* UNIONFS_INTERNAL_DEBUG("unionfs_write: enter\n"); */ 876 877 KASSERT_UNIONFS_VNODE(ap->a_vp); 878 879 unp = VTOUNIONFS(ap->a_vp); 880 tvp = (unp->un_uppervp != NULLVP ? unp->un_uppervp : unp->un_lowervp); 881 882 error = VOP_WRITE(tvp, ap->a_uio, ap->a_ioflag, ap->a_cred); 883 884 /* UNIONFS_INTERNAL_DEBUG("unionfs_write: leave (%d)\n", error); */ 885 886 return (error); 887} 888 889static int 890unionfs_ioctl(struct vop_ioctl_args *ap) 891{ 892 int error; 893 struct unionfs_node *unp; 894 struct unionfs_node_status *unsp; 895 struct vnode *ovp; 896 897 UNIONFS_INTERNAL_DEBUG("unionfs_ioctl: enter\n"); 898 899 KASSERT_UNIONFS_VNODE(ap->a_vp); 900 901 vn_lock(ap->a_vp, LK_EXCLUSIVE | LK_RETRY); 902 unp = VTOUNIONFS(ap->a_vp); 903 unionfs_get_node_status(unp, ap->a_td, &unsp); 904 ovp = (unsp->uns_upper_opencnt ? unp->un_uppervp : unp->un_lowervp); 905 unionfs_tryrem_node_status(unp, unsp); 906 VOP_UNLOCK(ap->a_vp, LK_RELEASE); 907 908 if (ovp == NULLVP) 909 return (EBADF); 910 911 error = VOP_IOCTL(ovp, ap->a_command, ap->a_data, ap->a_fflag, 912 ap->a_cred, ap->a_td); 913 914 UNIONFS_INTERNAL_DEBUG("unionfs_ioctl: leave (%d)\n", error); 915 916 return (error); 917} 918 919static int 920unionfs_poll(struct vop_poll_args *ap) 921{ 922 struct unionfs_node *unp; 923 struct unionfs_node_status *unsp; 924 struct vnode *ovp; 925 926 KASSERT_UNIONFS_VNODE(ap->a_vp); 927 928 vn_lock(ap->a_vp, LK_EXCLUSIVE | LK_RETRY); 929 unp = VTOUNIONFS(ap->a_vp); 930 unionfs_get_node_status(unp, ap->a_td, &unsp); 931 ovp = (unsp->uns_upper_opencnt ? unp->un_uppervp : unp->un_lowervp); 932 unionfs_tryrem_node_status(unp, unsp); 933 VOP_UNLOCK(ap->a_vp, LK_RELEASE); 934 935 if (ovp == NULLVP) 936 return (EBADF); 937 938 return (VOP_POLL(ovp, ap->a_events, ap->a_cred, ap->a_td)); 939} 940 941static int 942unionfs_fsync(struct vop_fsync_args *ap) 943{ 944 struct unionfs_node *unp; 945 struct unionfs_node_status *unsp; 946 struct vnode *ovp; 947 948 KASSERT_UNIONFS_VNODE(ap->a_vp); 949 950 unp = VTOUNIONFS(ap->a_vp); 951 unionfs_get_node_status(unp, ap->a_td, &unsp); 952 ovp = (unsp->uns_upper_opencnt ? unp->un_uppervp : unp->un_lowervp); 953 unionfs_tryrem_node_status(unp, unsp); 954 955 if (ovp == NULLVP) 956 return (EBADF); 957 958 return (VOP_FSYNC(ovp, ap->a_waitfor, ap->a_td)); 959} 960 961static int 962unionfs_remove(struct vop_remove_args *ap) 963{ 964 int error; 965 char *path; 966 struct unionfs_node *dunp; 967 struct unionfs_node *unp; 968 struct unionfs_mount *ump; 969 struct vnode *udvp; 970 struct vnode *uvp; 971 struct vnode *lvp; 972 struct vnode *vp; 973 struct componentname *cnp; 974 struct componentname cn; 975 struct thread *td; 976 977 UNIONFS_INTERNAL_DEBUG("unionfs_remove: enter\n"); 978 979 KASSERT_UNIONFS_VNODE(ap->a_dvp); 980 981 error = 0; 982 dunp = VTOUNIONFS(ap->a_dvp); 983 udvp = dunp->un_uppervp; 984 cnp = ap->a_cnp; 985 td = curthread; 986 987 if (ap->a_vp->v_op != &unionfs_vnodeops) { 988 if (ap->a_vp->v_type != VSOCK) 989 return (EINVAL); 990 ump = NULL; 991 vp = uvp = lvp = NULLVP; 992 /* search vnode */ 993 VOP_UNLOCK(ap->a_vp, LK_RELEASE); 994 error = unionfs_relookup(udvp, &vp, cnp, &cn, td, 995 cnp->cn_nameptr, strlen(cnp->cn_nameptr), DELETE); 996 if (error != 0 && error != ENOENT) { 997 vn_lock(ap->a_vp, LK_EXCLUSIVE | LK_RETRY); 998 return (error); 999 } 1000 1001 if (error == 0 && vp == ap->a_vp) { 1002 /* target vnode in upper */ 1003 uvp = vp; 1004 vrele(vp); 1005 path = NULL; 1006 } else { 1007 /* target vnode in lower */ 1008 if (vp != NULLVP) { 1009 if (udvp == vp) 1010 vrele(vp); 1011 else 1012 vput(vp); 1013 } 1014 vn_lock(ap->a_vp, LK_EXCLUSIVE | LK_RETRY); 1015 lvp = ap->a_vp; 1016 path = ap->a_cnp->cn_nameptr; 1017 } 1018 } else { 1019 ump = MOUNTTOUNIONFSMOUNT(ap->a_vp->v_mount); 1020 unp = VTOUNIONFS(ap->a_vp); 1021 uvp = unp->un_uppervp; 1022 lvp = unp->un_lowervp; 1023 path = unp->un_path; 1024 } 1025 1026 if (udvp == NULLVP) 1027 return (EROFS); 1028 1029 if (uvp != NULLVP) { 1030 /* 1031 * XXX: if the vnode type is VSOCK, it will create whiteout 1032 * after remove. 1033 */ 1034 if (ump == NULL || ump->um_whitemode == UNIONFS_WHITE_ALWAYS || 1035 lvp != NULLVP) 1036 cnp->cn_flags |= DOWHITEOUT; 1037 error = VOP_REMOVE(udvp, uvp, cnp); 1038 } else if (lvp != NULLVP) 1039 error = unionfs_mkwhiteout(udvp, cnp, td, path); 1040 1041 UNIONFS_INTERNAL_DEBUG("unionfs_remove: leave (%d)\n", error); 1042 1043 return (error); 1044} 1045 1046static int 1047unionfs_link(struct vop_link_args *ap) 1048{ 1049 int error; 1050 int needrelookup; 1051 struct unionfs_node *dunp; 1052 struct unionfs_node *unp; 1053 struct vnode *udvp; 1054 struct vnode *uvp; 1055 struct componentname *cnp; 1056 struct thread *td; 1057 1058 UNIONFS_INTERNAL_DEBUG("unionfs_link: enter\n"); 1059 1060 KASSERT_UNIONFS_VNODE(ap->a_tdvp); 1061 KASSERT_UNIONFS_VNODE(ap->a_vp); 1062 1063 error = 0; 1064 needrelookup = 0; 1065 dunp = VTOUNIONFS(ap->a_tdvp); 1066 unp = NULL; 1067 udvp = dunp->un_uppervp; 1068 uvp = NULLVP; 1069 cnp = ap->a_cnp; 1070 td = curthread; 1071 1072 if (udvp == NULLVP) 1073 return (EROFS); 1074 1075 if (ap->a_vp->v_op != &unionfs_vnodeops) 1076 uvp = ap->a_vp; 1077 else { 1078 unp = VTOUNIONFS(ap->a_vp); 1079 1080 if (unp->un_uppervp == NULLVP) { 1081 if (ap->a_vp->v_type != VREG) 1082 return (EOPNOTSUPP); 1083 1084 error = unionfs_copyfile(unp, 1, cnp->cn_cred, td); 1085 if (error != 0) 1086 return (error); 1087 needrelookup = 1; 1088 } 1089 uvp = unp->un_uppervp; 1090 } 1091 1092 if (needrelookup != 0) 1093 error = unionfs_relookup_for_create(ap->a_tdvp, cnp, td); 1094 1095 if (error == 0) 1096 error = VOP_LINK(udvp, uvp, cnp); 1097 1098 UNIONFS_INTERNAL_DEBUG("unionfs_link: leave (%d)\n", error); 1099 1100 return (error); 1101} 1102 1103static int 1104unionfs_rename(struct vop_rename_args *ap) 1105{ 1106 int error; 1107 struct vnode *fdvp; 1108 struct vnode *fvp; 1109 struct componentname *fcnp; 1110 struct vnode *tdvp; 1111 struct vnode *tvp; 1112 struct componentname *tcnp; 1113 struct vnode *ltdvp; 1114 struct vnode *ltvp; 1115 struct thread *td; 1116 1117 /* rename target vnodes */ 1118 struct vnode *rfdvp; 1119 struct vnode *rfvp; 1120 struct vnode *rtdvp; 1121 struct vnode *rtvp; 1122 1123 int needrelookup; 1124 struct unionfs_mount *ump; 1125 struct unionfs_node *unp; 1126 1127 UNIONFS_INTERNAL_DEBUG("unionfs_rename: enter\n"); 1128 1129 error = 0; 1130 fdvp = ap->a_fdvp; 1131 fvp = ap->a_fvp; 1132 fcnp = ap->a_fcnp; 1133 tdvp = ap->a_tdvp; 1134 tvp = ap->a_tvp; 1135 tcnp = ap->a_tcnp; 1136 ltdvp = NULLVP; 1137 ltvp = NULLVP; 1138 td = curthread; 1139 rfdvp = fdvp; 1140 rfvp = fvp; 1141 rtdvp = tdvp; 1142 rtvp = tvp; 1143 needrelookup = 0; 1144 1145#ifdef DIAGNOSTIC 1146 if (!(fcnp->cn_flags & HASBUF) || !(tcnp->cn_flags & HASBUF)) 1147 panic("unionfs_rename: no name"); 1148#endif 1149 1150 /* check for cross device rename */ 1151 if (fvp->v_mount != tdvp->v_mount || 1152 (tvp != NULLVP && fvp->v_mount != tvp->v_mount)) { 1153 if (fvp->v_op != &unionfs_vnodeops) 1154 error = ENODEV; 1155 else 1156 error = EXDEV; 1157 goto unionfs_rename_abort; 1158 } 1159 1160 /* Renaming a file to itself has no effect. */ 1161 if (fvp == tvp) 1162 goto unionfs_rename_abort; 1163 1164 /* 1165 * from/to vnode is unionfs node. 1166 */ 1167 1168 KASSERT_UNIONFS_VNODE(fdvp); 1169 KASSERT_UNIONFS_VNODE(fvp); 1170 KASSERT_UNIONFS_VNODE(tdvp); 1171 if (tvp != NULLVP) 1172 KASSERT_UNIONFS_VNODE(tvp); 1173 1174 unp = VTOUNIONFS(fdvp); 1175#ifdef UNIONFS_IDBG_RENAME 1176 UNIONFS_INTERNAL_DEBUG("fdvp=%p, ufdvp=%p, lfdvp=%p\n", fdvp, unp->un_uppervp, unp->un_lowervp); 1177#endif 1178 if (unp->un_uppervp == NULLVP) { 1179 error = ENODEV; 1180 goto unionfs_rename_abort; 1181 } 1182 rfdvp = unp->un_uppervp; 1183 vref(rfdvp); 1184 1185 unp = VTOUNIONFS(fvp); 1186#ifdef UNIONFS_IDBG_RENAME 1187 UNIONFS_INTERNAL_DEBUG("fvp=%p, ufvp=%p, lfvp=%p\n", fvp, unp->un_uppervp, unp->un_lowervp); 1188#endif 1189 ump = MOUNTTOUNIONFSMOUNT(fvp->v_mount); 1190 if (unp->un_uppervp == NULLVP) { 1191 switch (fvp->v_type) { 1192 case VREG: 1193 if ((error = vn_lock(fvp, LK_EXCLUSIVE)) != 0) 1194 goto unionfs_rename_abort; 1195 error = unionfs_copyfile(unp, 1, fcnp->cn_cred, td); 1196 VOP_UNLOCK(fvp, LK_RELEASE); 1197 if (error != 0) 1198 goto unionfs_rename_abort; 1199 break; 1200 case VDIR: 1201 if ((error = vn_lock(fvp, LK_EXCLUSIVE)) != 0) 1202 goto unionfs_rename_abort; 1203 error = unionfs_mkshadowdir(ump, rfdvp, unp, fcnp, td); 1204 VOP_UNLOCK(fvp, LK_RELEASE); 1205 if (error != 0) 1206 goto unionfs_rename_abort; 1207 break; 1208 default: 1209 error = ENODEV; 1210 goto unionfs_rename_abort; 1211 } 1212 1213 needrelookup = 1; 1214 } 1215 1216 if (unp->un_lowervp != NULLVP) 1217 fcnp->cn_flags |= DOWHITEOUT; 1218 rfvp = unp->un_uppervp; 1219 vref(rfvp); 1220 1221 unp = VTOUNIONFS(tdvp); 1222#ifdef UNIONFS_IDBG_RENAME 1223 UNIONFS_INTERNAL_DEBUG("tdvp=%p, utdvp=%p, ltdvp=%p\n", tdvp, unp->un_uppervp, unp->un_lowervp); 1224#endif 1225 if (unp->un_uppervp == NULLVP) { 1226 error = ENODEV; 1227 goto unionfs_rename_abort; 1228 } 1229 rtdvp = unp->un_uppervp; 1230 ltdvp = unp->un_lowervp; 1231 vref(rtdvp); 1232 1233 if (tdvp == tvp) { 1234 rtvp = rtdvp; 1235 vref(rtvp); 1236 } else if (tvp != NULLVP) { 1237 unp = VTOUNIONFS(tvp); 1238#ifdef UNIONFS_IDBG_RENAME 1239 UNIONFS_INTERNAL_DEBUG("tvp=%p, utvp=%p, ltvp=%p\n", tvp, unp->un_uppervp, unp->un_lowervp); 1240#endif 1241 if (unp->un_uppervp == NULLVP) 1242 rtvp = NULLVP; 1243 else { 1244 if (tvp->v_type == VDIR) { 1245 error = EINVAL; 1246 goto unionfs_rename_abort; 1247 } 1248 rtvp = unp->un_uppervp; 1249 ltvp = unp->un_lowervp; 1250 vref(rtvp); 1251 } 1252 } 1253 1254 if (rfvp == rtvp) 1255 goto unionfs_rename_abort; 1256 1257 if (needrelookup != 0) { 1258 if ((error = vn_lock(fdvp, LK_EXCLUSIVE)) != 0) 1259 goto unionfs_rename_abort; 1260 error = unionfs_relookup_for_delete(fdvp, fcnp, td); 1261 VOP_UNLOCK(fdvp, LK_RELEASE); 1262 if (error != 0) 1263 goto unionfs_rename_abort; 1264 1265 /* Locke of tvp is canceled in order to avoid recursive lock. */ 1266 if (tvp != NULLVP && tvp != tdvp) 1267 VOP_UNLOCK(tvp, LK_RELEASE); 1268 error = unionfs_relookup_for_rename(tdvp, tcnp, td); 1269 if (tvp != NULLVP && tvp != tdvp) 1270 vn_lock(tvp, LK_EXCLUSIVE | LK_RETRY); 1271 if (error != 0) 1272 goto unionfs_rename_abort; 1273 } 1274 1275 error = VOP_RENAME(rfdvp, rfvp, fcnp, rtdvp, rtvp, tcnp); 1276 1277 if (error == 0) { 1278 if (rtvp != NULLVP && rtvp->v_type == VDIR) 1279 cache_purge(tdvp); 1280 if (fvp->v_type == VDIR && fdvp != tdvp) 1281 cache_purge(fdvp); 1282 } 1283 1284 if (ltdvp != NULLVP) 1285 VOP_UNLOCK(ltdvp, LK_RELEASE); 1286 if (tdvp != rtdvp) 1287 vrele(tdvp); 1288 if (ltvp != NULLVP) 1289 VOP_UNLOCK(ltvp, LK_RELEASE); 1290 if (tvp != rtvp && tvp != NULLVP) { 1291 if (rtvp == NULLVP) 1292 vput(tvp); 1293 else 1294 vrele(tvp); 1295 } 1296 if (fdvp != rfdvp) 1297 vrele(fdvp); 1298 if (fvp != rfvp) 1299 vrele(fvp); 1300 1301 UNIONFS_INTERNAL_DEBUG("unionfs_rename: leave (%d)\n", error); 1302 1303 return (error); 1304 1305unionfs_rename_abort: 1306 vput(tdvp); 1307 if (tdvp != rtdvp) 1308 vrele(rtdvp); 1309 if (tvp != NULLVP) { 1310 if (tdvp != tvp) 1311 vput(tvp); 1312 else 1313 vrele(tvp); 1314 } 1315 if (tvp != rtvp && rtvp != NULLVP) 1316 vrele(rtvp); 1317 if (fdvp != rfdvp) 1318 vrele(rfdvp); 1319 if (fvp != rfvp) 1320 vrele(rfvp); 1321 vrele(fdvp); 1322 vrele(fvp); 1323 1324 UNIONFS_INTERNAL_DEBUG("unionfs_rename: leave (%d)\n", error); 1325 1326 return (error); 1327} 1328 1329static int 1330unionfs_mkdir(struct vop_mkdir_args *ap) 1331{ 1332 int error; 1333 int lkflags; 1334 struct unionfs_node *dunp; 1335 struct componentname *cnp; 1336 struct thread *td; 1337 struct vnode *udvp; 1338 struct vnode *uvp; 1339 struct vattr va; 1340 1341 UNIONFS_INTERNAL_DEBUG("unionfs_mkdir: enter\n"); 1342 1343 KASSERT_UNIONFS_VNODE(ap->a_dvp); 1344 1345 error = EROFS; 1346 dunp = VTOUNIONFS(ap->a_dvp); 1347 cnp = ap->a_cnp; 1348 lkflags = cnp->cn_lkflags; 1349 td = curthread; 1350 udvp = dunp->un_uppervp; 1351 1352 if (udvp != NULLVP) { 1353 /* check opaque */ 1354 if (!(cnp->cn_flags & ISWHITEOUT)) { 1355 error = VOP_GETATTR(udvp, &va, cnp->cn_cred); 1356 if (error != 0) 1357 return (error); 1358 if (va.va_flags & OPAQUE) 1359 cnp->cn_flags |= ISWHITEOUT; 1360 } 1361 1362 if ((error = VOP_MKDIR(udvp, &uvp, cnp, ap->a_vap)) == 0) { 1363 VOP_UNLOCK(uvp, LK_RELEASE); 1364 cnp->cn_lkflags = LK_EXCLUSIVE; 1365 error = unionfs_nodeget(ap->a_dvp->v_mount, uvp, NULLVP, 1366 ap->a_dvp, ap->a_vpp, cnp, td); 1367 cnp->cn_lkflags = lkflags; 1368 vrele(uvp); 1369 } 1370 } 1371 1372 UNIONFS_INTERNAL_DEBUG("unionfs_mkdir: leave (%d)\n", error); 1373 1374 return (error); 1375} 1376 1377static int 1378unionfs_rmdir(struct vop_rmdir_args *ap) 1379{ 1380 int error; 1381 struct unionfs_node *dunp; 1382 struct unionfs_node *unp; 1383 struct unionfs_mount *ump; 1384 struct componentname *cnp; 1385 struct thread *td; 1386 struct vnode *udvp; 1387 struct vnode *uvp; 1388 struct vnode *lvp; 1389 1390 UNIONFS_INTERNAL_DEBUG("unionfs_rmdir: enter\n"); 1391 1392 KASSERT_UNIONFS_VNODE(ap->a_dvp); 1393 KASSERT_UNIONFS_VNODE(ap->a_vp); 1394 1395 error = 0; 1396 dunp = VTOUNIONFS(ap->a_dvp); 1397 unp = VTOUNIONFS(ap->a_vp); 1398 cnp = ap->a_cnp; 1399 td = curthread; 1400 udvp = dunp->un_uppervp; 1401 uvp = unp->un_uppervp; 1402 lvp = unp->un_lowervp; 1403 1404 if (udvp == NULLVP) 1405 return (EROFS); 1406 1407 if (udvp == uvp) 1408 return (EOPNOTSUPP); 1409 1410 if (uvp != NULLVP) { 1411 if (lvp != NULLVP) { 1412 error = unionfs_check_rmdir(ap->a_vp, cnp->cn_cred, td); 1413 if (error != 0) 1414 return (error); 1415 } 1416 ump = MOUNTTOUNIONFSMOUNT(ap->a_vp->v_mount); 1417 if (ump->um_whitemode == UNIONFS_WHITE_ALWAYS || lvp != NULLVP) 1418 cnp->cn_flags |= DOWHITEOUT; 1419 error = unionfs_relookup_for_delete(ap->a_dvp, cnp, td); 1420 if (!error) 1421 error = VOP_RMDIR(udvp, uvp, cnp); 1422 } 1423 else if (lvp != NULLVP) 1424 error = unionfs_mkwhiteout(udvp, cnp, td, unp->un_path); 1425 1426 if (error == 0) { 1427 cache_purge(ap->a_dvp); 1428 cache_purge(ap->a_vp); 1429 } 1430 1431 UNIONFS_INTERNAL_DEBUG("unionfs_rmdir: leave (%d)\n", error); 1432 1433 return (error); 1434} 1435 1436static int 1437unionfs_symlink(struct vop_symlink_args *ap) 1438{ 1439 int error; 1440 int lkflags; 1441 struct unionfs_node *dunp; 1442 struct componentname *cnp; 1443 struct thread *td; 1444 struct vnode *udvp; 1445 struct vnode *uvp; 1446 1447 UNIONFS_INTERNAL_DEBUG("unionfs_symlink: enter\n"); 1448 1449 KASSERT_UNIONFS_VNODE(ap->a_dvp); 1450 1451 error = EROFS; 1452 dunp = VTOUNIONFS(ap->a_dvp); 1453 cnp = ap->a_cnp; 1454 lkflags = cnp->cn_lkflags; 1455 td = curthread; 1456 udvp = dunp->un_uppervp; 1457 1458 if (udvp != NULLVP) { 1459 error = VOP_SYMLINK(udvp, &uvp, cnp, ap->a_vap, ap->a_target); 1460 if (error == 0) { 1461 VOP_UNLOCK(uvp, LK_RELEASE); 1462 cnp->cn_lkflags = LK_EXCLUSIVE; 1463 error = unionfs_nodeget(ap->a_dvp->v_mount, uvp, NULLVP, 1464 ap->a_dvp, ap->a_vpp, cnp, td); 1465 cnp->cn_lkflags = lkflags; 1466 vrele(uvp); 1467 } 1468 } 1469 1470 UNIONFS_INTERNAL_DEBUG("unionfs_symlink: leave (%d)\n", error); 1471 1472 return (error); 1473} 1474 1475static int 1476unionfs_readdir(struct vop_readdir_args *ap) 1477{ 1478 int error; 1479 int eofflag; 1480 int locked; 1481 int uio_offset_bk; 1482 struct unionfs_node *unp; 1483 struct unionfs_node_status *unsp; 1484 struct uio *uio; 1485 struct vnode *vp; 1486 struct vnode *uvp; 1487 struct vnode *lvp; 1488 struct thread *td; 1489 struct vattr va; 1490 1491 int ncookies_bk; 1492 u_long *cookies_bk; 1493 1494 UNIONFS_INTERNAL_DEBUG("unionfs_readdir: enter\n"); 1495 1496 KASSERT_UNIONFS_VNODE(ap->a_vp); 1497 1498 error = 0; 1499 eofflag = 0; 1500 locked = 0; 1501 uio_offset_bk = 0; 1502 uio = ap->a_uio; 1503 uvp = NULLVP; 1504 lvp = NULLVP; 1505 td = uio->uio_td; 1506 ncookies_bk = 0; 1507 cookies_bk = NULL; 1508 1509 vp = ap->a_vp; 1510 if (vp->v_type != VDIR) 1511 return (ENOTDIR); 1512 1513 /* check the open count. unionfs needs to open before readdir. */ 1514 if (VOP_ISLOCKED(vp) != LK_EXCLUSIVE) { 1515 if (vn_lock(vp, LK_UPGRADE) != 0) 1516 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 1517 locked = 1; 1518 } 1519 unp = VTOUNIONFS(vp); 1520 if (unp == NULL) 1521 error = EBADF; 1522 else { 1523 uvp = unp->un_uppervp; 1524 lvp = unp->un_lowervp; 1525 unionfs_get_node_status(unp, td, &unsp); 1526 if ((uvp != NULLVP && unsp->uns_upper_opencnt <= 0) || 1527 (lvp != NULLVP && unsp->uns_lower_opencnt <= 0)) { 1528 unionfs_tryrem_node_status(unp, unsp); 1529 error = EBADF; 1530 } 1531 } 1532 if (locked) 1533 vn_lock(vp, LK_DOWNGRADE | LK_RETRY); 1534 if (error != 0) 1535 goto unionfs_readdir_exit; 1536 1537 /* check opaque */ 1538 if (uvp != NULLVP && lvp != NULLVP) { 1539 if ((error = VOP_GETATTR(uvp, &va, ap->a_cred)) != 0) 1540 goto unionfs_readdir_exit; 1541 if (va.va_flags & OPAQUE) 1542 lvp = NULLVP; 1543 } 1544 1545 /* upper only */ 1546 if (uvp != NULLVP && lvp == NULLVP) { 1547 error = VOP_READDIR(uvp, uio, ap->a_cred, ap->a_eofflag, 1548 ap->a_ncookies, ap->a_cookies); 1549 unsp->uns_readdir_status = 0; 1550 1551 goto unionfs_readdir_exit; 1552 } 1553 1554 /* lower only */ 1555 if (uvp == NULLVP && lvp != NULLVP) { 1556 error = VOP_READDIR(lvp, uio, ap->a_cred, ap->a_eofflag, 1557 ap->a_ncookies, ap->a_cookies); 1558 unsp->uns_readdir_status = 2; 1559 1560 goto unionfs_readdir_exit; 1561 } 1562 1563 /* 1564 * readdir upper and lower 1565 */ 1566 KASSERT(uvp != NULLVP, ("unionfs_readdir: null upper vp")); 1567 KASSERT(lvp != NULLVP, ("unionfs_readdir: null lower vp")); 1568 if (uio->uio_offset == 0) 1569 unsp->uns_readdir_status = 0; 1570 1571 if (unsp->uns_readdir_status == 0) { 1572 /* read upper */ 1573 error = VOP_READDIR(uvp, uio, ap->a_cred, &eofflag, 1574 ap->a_ncookies, ap->a_cookies); 1575 1576 if (error != 0 || eofflag == 0) 1577 goto unionfs_readdir_exit; 1578 unsp->uns_readdir_status = 1; 1579 1580 /* 1581 * UFS(and other FS) needs size of uio_resid larger than 1582 * DIRBLKSIZ. 1583 * size of DIRBLKSIZ equals DEV_BSIZE. 1584 * (see: ufs/ufs/ufs_vnops.c ufs_readdir func , ufs/ufs/dir.h) 1585 */ 1586 if (uio->uio_resid <= (uio->uio_resid & (DEV_BSIZE -1))) 1587 goto unionfs_readdir_exit; 1588 1589 /* 1590 * Backup cookies. 1591 * It prepares to readdir in lower. 1592 */ 1593 if (ap->a_ncookies != NULL) { 1594 ncookies_bk = *(ap->a_ncookies); 1595 *(ap->a_ncookies) = 0; 1596 } 1597 if (ap->a_cookies != NULL) { 1598 cookies_bk = *(ap->a_cookies); 1599 *(ap->a_cookies) = NULL; 1600 } 1601 } 1602 1603 /* initialize for readdir in lower */ 1604 if (unsp->uns_readdir_status == 1) { 1605 unsp->uns_readdir_status = 2; 1606 /* 1607 * Backup uio_offset. See the comment after the 1608 * VOP_READDIR call on the lower layer. 1609 */ 1610 uio_offset_bk = uio->uio_offset; 1611 uio->uio_offset = 0; 1612 } 1613 1614 if (lvp == NULLVP) { 1615 error = EBADF; 1616 goto unionfs_readdir_exit; 1617 } 1618 /* read lower */ 1619 error = VOP_READDIR(lvp, uio, ap->a_cred, ap->a_eofflag, 1620 ap->a_ncookies, ap->a_cookies); 1621 1622 /* 1623 * We can't return an uio_offset of 0: this would trigger an 1624 * infinite loop, because the next call to unionfs_readdir would 1625 * always restart with the upper layer (uio_offset == 0) and 1626 * always return some data. 1627 * 1628 * This happens when the lower layer root directory is removed. 1629 * (A root directory deleting of unionfs should not be permitted. 1630 * But current VFS can not do it.) 1631 */ 1632 if (uio->uio_offset == 0) 1633 uio->uio_offset = uio_offset_bk; 1634 1635 if (cookies_bk != NULL) { 1636 /* merge cookies */ 1637 int size; 1638 u_long *newcookies, *pos; 1639 1640 size = *(ap->a_ncookies) + ncookies_bk; 1641 newcookies = (u_long *) malloc(size * sizeof(u_long), 1642 M_TEMP, M_WAITOK); 1643 pos = newcookies; 1644 1645 memcpy(pos, cookies_bk, ncookies_bk * sizeof(u_long)); 1646 pos += ncookies_bk; 1647 memcpy(pos, *(ap->a_cookies), *(ap->a_ncookies) * sizeof(u_long)); 1648 free(cookies_bk, M_TEMP); 1649 free(*(ap->a_cookies), M_TEMP); 1650 *(ap->a_ncookies) = size; 1651 *(ap->a_cookies) = newcookies; 1652 } 1653 1654unionfs_readdir_exit: 1655 if (error != 0 && ap->a_eofflag != NULL) 1656 *(ap->a_eofflag) = 1; 1657 1658 UNIONFS_INTERNAL_DEBUG("unionfs_readdir: leave (%d)\n", error); 1659 1660 return (error); 1661} 1662 1663static int 1664unionfs_readlink(struct vop_readlink_args *ap) 1665{ 1666 int error; 1667 struct unionfs_node *unp; 1668 struct vnode *vp; 1669 1670 UNIONFS_INTERNAL_DEBUG("unionfs_readlink: enter\n"); 1671 1672 KASSERT_UNIONFS_VNODE(ap->a_vp); 1673 1674 unp = VTOUNIONFS(ap->a_vp); 1675 vp = (unp->un_uppervp != NULLVP ? unp->un_uppervp : unp->un_lowervp); 1676 1677 error = VOP_READLINK(vp, ap->a_uio, ap->a_cred); 1678 1679 UNIONFS_INTERNAL_DEBUG("unionfs_readlink: leave (%d)\n", error); 1680 1681 return (error); 1682} 1683 1684static int 1685unionfs_getwritemount(struct vop_getwritemount_args *ap) 1686{ 1687 int error; 1688 struct vnode *uvp; 1689 struct vnode *vp; 1690 1691 UNIONFS_INTERNAL_DEBUG("unionfs_getwritemount: enter\n"); 1692 1693 error = 0; 1694 vp = ap->a_vp; 1695 1696 if (vp == NULLVP || (vp->v_mount->mnt_flag & MNT_RDONLY)) 1697 return (EACCES); 1698 1699 KASSERT_UNIONFS_VNODE(vp); 1700 1701 uvp = UNIONFSVPTOUPPERVP(vp); 1702 if (uvp == NULLVP && VREG == vp->v_type) 1703 uvp = UNIONFSVPTOUPPERVP(VTOUNIONFS(vp)->un_dvp); 1704 1705 if (uvp != NULLVP) 1706 error = VOP_GETWRITEMOUNT(uvp, ap->a_mpp); 1707 else { 1708 VI_LOCK(vp); 1709 if (vp->v_iflag & VI_FREE) 1710 error = EOPNOTSUPP; 1711 else 1712 error = EACCES; 1713 VI_UNLOCK(vp); 1714 } 1715 1716 UNIONFS_INTERNAL_DEBUG("unionfs_getwritemount: leave (%d)\n", error); 1717 1718 return (error); 1719} 1720 1721static int 1722unionfs_inactive(struct vop_inactive_args *ap) 1723{ 1724 ap->a_vp->v_object = NULL; 1725 vrecycle(ap->a_vp); 1726 return (0); 1727} 1728 1729static int 1730unionfs_reclaim(struct vop_reclaim_args *ap) 1731{ 1732 /* UNIONFS_INTERNAL_DEBUG("unionfs_reclaim: enter\n"); */ 1733 1734 unionfs_noderem(ap->a_vp, ap->a_td); 1735 1736 /* UNIONFS_INTERNAL_DEBUG("unionfs_reclaim: leave\n"); */ 1737 1738 return (0); 1739} 1740 1741static int 1742unionfs_print(struct vop_print_args *ap) 1743{ 1744 struct unionfs_node *unp; 1745 /* struct unionfs_node_status *unsp; */ 1746 1747 unp = VTOUNIONFS(ap->a_vp); 1748 /* unionfs_get_node_status(unp, curthread, &unsp); */ 1749 1750 printf("unionfs_vp=%p, uppervp=%p, lowervp=%p\n", 1751 ap->a_vp, unp->un_uppervp, unp->un_lowervp); 1752 /* 1753 printf("unionfs opencnt: uppervp=%d, lowervp=%d\n", 1754 unsp->uns_upper_opencnt, unsp->uns_lower_opencnt); 1755 */ 1756 1757 if (unp->un_uppervp != NULLVP) 1758 vn_printf(unp->un_uppervp, "unionfs: upper "); 1759 if (unp->un_lowervp != NULLVP) 1760 vn_printf(unp->un_lowervp, "unionfs: lower "); 1761 1762 return (0); 1763} 1764 1765static int 1766unionfs_islocked(struct vop_islocked_args *ap) 1767{ 1768 struct unionfs_node *unp; 1769 1770 KASSERT_UNIONFS_VNODE(ap->a_vp); 1771 1772 unp = VTOUNIONFS(ap->a_vp); 1773 if (unp == NULL) 1774 return (vop_stdislocked(ap)); 1775 1776 if (unp->un_uppervp != NULLVP) 1777 return (VOP_ISLOCKED(unp->un_uppervp)); 1778 if (unp->un_lowervp != NULLVP) 1779 return (VOP_ISLOCKED(unp->un_lowervp)); 1780 return (vop_stdislocked(ap)); 1781} 1782 1783static int 1784unionfs_get_llt_revlock(struct vnode *vp, int flags) 1785{ 1786 int revlock; 1787 1788 revlock = 0; 1789 1790 switch (flags & LK_TYPE_MASK) { 1791 case LK_SHARED: 1792 if (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) 1793 revlock = LK_UPGRADE; 1794 else 1795 revlock = LK_RELEASE; 1796 break; 1797 case LK_EXCLUSIVE: 1798 case LK_UPGRADE: 1799 revlock = LK_RELEASE; 1800 break; 1801 case LK_DOWNGRADE: 1802 revlock = LK_UPGRADE; 1803 break; 1804 default: 1805 break; 1806 } 1807 1808 return (revlock); 1809} 1810 1811/* 1812 * The state of an acquired lock is adjusted similarly to 1813 * the time of error generating. 1814 * flags: LK_RELEASE or LK_UPGRADE 1815 */ 1816static void 1817unionfs_revlock(struct vnode *vp, int flags) 1818{ 1819 if (flags & LK_RELEASE) 1820 VOP_UNLOCK(vp, flags); 1821 else { 1822 /* UPGRADE */ 1823 if (vn_lock(vp, flags) != 0) 1824 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 1825 } 1826} 1827 1828static int 1829unionfs_lock(struct vop_lock1_args *ap) 1830{ 1831 int error; 1832 int flags; 1833 int revlock; 1834 int interlock; 1835 int uhold; 1836 struct mount *mp; 1837 struct unionfs_mount *ump; 1838 struct unionfs_node *unp; 1839 struct vnode *vp; 1840 struct vnode *uvp; 1841 struct vnode *lvp; 1842 1843 KASSERT_UNIONFS_VNODE(ap->a_vp); 1844 1845 error = 0; 1846 interlock = 1; 1847 uhold = 0; 1848 flags = ap->a_flags; 1849 vp = ap->a_vp; 1850 1851 if (LK_RELEASE == (flags & LK_TYPE_MASK) || !(flags & LK_TYPE_MASK)) 1852 return (VOP_UNLOCK(vp, flags | LK_RELEASE)); 1853 1854 if ((flags & LK_INTERLOCK) == 0) 1855 VI_LOCK(vp); 1856 1857 mp = vp->v_mount; 1858 if (mp == NULL) 1859 goto unionfs_lock_null_vnode; 1860 1861 ump = MOUNTTOUNIONFSMOUNT(mp); 1862 unp = VTOUNIONFS(vp); 1863 if (ump == NULL || unp == NULL) 1864 goto unionfs_lock_null_vnode; 1865 lvp = unp->un_lowervp; 1866 uvp = unp->un_uppervp; 1867 1868 if ((revlock = unionfs_get_llt_revlock(vp, flags)) == 0) 1869 panic("unknown lock type: 0x%x", flags & LK_TYPE_MASK); 1870 1871 if ((vp->v_iflag & VI_OWEINACT) != 0) 1872 flags |= LK_NOWAIT; 1873 1874 /* 1875 * Sometimes, lower or upper is already exclusive locked. 1876 * (ex. vfs_domount: mounted vnode is already locked.) 1877 */ 1878 if ((flags & LK_TYPE_MASK) == LK_EXCLUSIVE && 1879 vp == ump->um_rootvp) 1880 flags |= LK_CANRECURSE; 1881 1882 if (lvp != NULLVP) { 1883 if (uvp != NULLVP && flags & LK_UPGRADE) { 1884 /* Share Lock is once released and a deadlock is avoided. */ 1885 VI_LOCK_FLAGS(uvp, MTX_DUPOK); 1886 vholdl(uvp); 1887 uhold = 1; 1888 VI_UNLOCK(vp); 1889 VOP_UNLOCK(uvp, LK_RELEASE | LK_INTERLOCK); 1890 VI_LOCK(vp); 1891 unp = VTOUNIONFS(vp); 1892 if (unp == NULL) { 1893 /* vnode is released. */ 1894 VI_UNLOCK(vp); 1895 VOP_UNLOCK(lvp, LK_RELEASE); 1896 vdrop(uvp); 1897 return (EBUSY); 1898 } 1899 } 1900 VI_LOCK_FLAGS(lvp, MTX_DUPOK); 1901 flags |= LK_INTERLOCK; 1902 vholdl(lvp); 1903 1904 VI_UNLOCK(vp); 1905 ap->a_flags &= ~LK_INTERLOCK; 1906 1907 error = VOP_LOCK(lvp, flags); 1908 1909 VI_LOCK(vp); 1910 unp = VTOUNIONFS(vp); 1911 if (unp == NULL) { 1912 /* vnode is released. */ 1913 VI_UNLOCK(vp); 1914 if (error == 0) 1915 VOP_UNLOCK(lvp, LK_RELEASE); 1916 vdrop(lvp); 1917 if (uhold != 0) 1918 vdrop(uvp); 1919 return (vop_stdlock(ap)); 1920 } 1921 } 1922 1923 if (error == 0 && uvp != NULLVP) { 1924 if (uhold && flags & LK_UPGRADE) { 1925 flags &= ~LK_TYPE_MASK; 1926 flags |= LK_EXCLUSIVE; 1927 } 1928 VI_LOCK_FLAGS(uvp, MTX_DUPOK); 1929 flags |= LK_INTERLOCK; 1930 if (uhold == 0) { 1931 vholdl(uvp); 1932 uhold = 1; 1933 } 1934 1935 VI_UNLOCK(vp); 1936 ap->a_flags &= ~LK_INTERLOCK; 1937 1938 error = VOP_LOCK(uvp, flags); 1939 1940 VI_LOCK(vp); 1941 unp = VTOUNIONFS(vp); 1942 if (unp == NULL) { 1943 /* vnode is released. */ 1944 VI_UNLOCK(vp); 1945 if (error == 0) 1946 VOP_UNLOCK(uvp, LK_RELEASE); 1947 vdrop(uvp); 1948 if (lvp != NULLVP) { 1949 VOP_UNLOCK(lvp, LK_RELEASE); 1950 vdrop(lvp); 1951 } 1952 return (vop_stdlock(ap)); 1953 } 1954 if (error != 0 && lvp != NULLVP) { 1955 /* rollback */ 1956 VI_UNLOCK(vp); 1957 unionfs_revlock(lvp, revlock); 1958 interlock = 0; 1959 } 1960 } 1961 1962 if (interlock) 1963 VI_UNLOCK(vp); 1964 if (lvp != NULLVP) 1965 vdrop(lvp); 1966 if (uhold != 0) 1967 vdrop(uvp); 1968 1969 return (error); 1970 1971unionfs_lock_null_vnode: 1972 ap->a_flags |= LK_INTERLOCK; 1973 return (vop_stdlock(ap)); 1974} 1975 1976static int 1977unionfs_unlock(struct vop_unlock_args *ap) 1978{ 1979 int error; 1980 int flags; 1981 int mtxlkflag; 1982 int uhold; 1983 struct vnode *vp; 1984 struct vnode *lvp; 1985 struct vnode *uvp; 1986 struct unionfs_node *unp; 1987 1988 KASSERT_UNIONFS_VNODE(ap->a_vp); 1989 1990 error = 0; 1991 mtxlkflag = 0; 1992 uhold = 0; 1993 flags = ap->a_flags | LK_RELEASE; 1994 vp = ap->a_vp; 1995 1996 if ((flags & LK_INTERLOCK) != 0) 1997 mtxlkflag = 1; 1998 else if (mtx_owned(VI_MTX(vp)) == 0) { 1999 VI_LOCK(vp); 2000 mtxlkflag = 2; 2001 } 2002 2003 unp = VTOUNIONFS(vp); 2004 if (unp == NULL) 2005 goto unionfs_unlock_null_vnode; 2006 lvp = unp->un_lowervp; 2007 uvp = unp->un_uppervp; 2008 2009 if (lvp != NULLVP) { 2010 VI_LOCK_FLAGS(lvp, MTX_DUPOK); 2011 flags |= LK_INTERLOCK; 2012 vholdl(lvp); 2013 2014 VI_UNLOCK(vp); 2015 ap->a_flags &= ~LK_INTERLOCK; 2016 2017 error = VOP_UNLOCK(lvp, flags); 2018 2019 VI_LOCK(vp); 2020 } 2021 2022 if (error == 0 && uvp != NULLVP) { 2023 VI_LOCK_FLAGS(uvp, MTX_DUPOK); 2024 flags |= LK_INTERLOCK; 2025 vholdl(uvp); 2026 uhold = 1; 2027 2028 VI_UNLOCK(vp); 2029 ap->a_flags &= ~LK_INTERLOCK; 2030 2031 error = VOP_UNLOCK(uvp, flags); 2032 2033 VI_LOCK(vp); 2034 } 2035 2036 VI_UNLOCK(vp); 2037 if (lvp != NULLVP) 2038 vdrop(lvp); 2039 if (uhold != 0) 2040 vdrop(uvp); 2041 if (mtxlkflag == 0) 2042 VI_LOCK(vp); 2043 2044 return error; 2045 2046unionfs_unlock_null_vnode: 2047 if (mtxlkflag == 2) 2048 VI_UNLOCK(vp); 2049 return (vop_stdunlock(ap)); 2050} 2051 2052static int 2053unionfs_pathconf(struct vop_pathconf_args *ap) 2054{ 2055 struct unionfs_node *unp; 2056 struct vnode *vp; 2057 2058 KASSERT_UNIONFS_VNODE(ap->a_vp); 2059 2060 unp = VTOUNIONFS(ap->a_vp); 2061 vp = (unp->un_uppervp != NULLVP ? unp->un_uppervp : unp->un_lowervp); 2062 2063 return (VOP_PATHCONF(vp, ap->a_name, ap->a_retval)); 2064} 2065 2066static int 2067unionfs_advlock(struct vop_advlock_args *ap) 2068{ 2069 int error; 2070 struct unionfs_node *unp; 2071 struct unionfs_node_status *unsp; 2072 struct vnode *vp; 2073 struct vnode *uvp; 2074 struct thread *td; 2075 2076 UNIONFS_INTERNAL_DEBUG("unionfs_advlock: enter\n"); 2077 2078 KASSERT_UNIONFS_VNODE(ap->a_vp); 2079 2080 vp = ap->a_vp; 2081 td = curthread; 2082 2083 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 2084 2085 unp = VTOUNIONFS(ap->a_vp); 2086 uvp = unp->un_uppervp; 2087 2088 if (uvp == NULLVP) { 2089 error = unionfs_copyfile(unp, 1, td->td_ucred, td); 2090 if (error != 0) 2091 goto unionfs_advlock_abort; 2092 uvp = unp->un_uppervp; 2093 2094 unionfs_get_node_status(unp, td, &unsp); 2095 if (unsp->uns_lower_opencnt > 0) { 2096 /* try reopen the vnode */ 2097 error = VOP_OPEN(uvp, unsp->uns_lower_openmode, 2098 td->td_ucred, td, NULL); 2099 if (error) 2100 goto unionfs_advlock_abort; 2101 unsp->uns_upper_opencnt++; 2102 VOP_CLOSE(unp->un_lowervp, unsp->uns_lower_openmode, td->td_ucred, td); 2103 unsp->uns_lower_opencnt--; 2104 } else 2105 unionfs_tryrem_node_status(unp, unsp); 2106 } 2107 2108 VOP_UNLOCK(vp, LK_RELEASE); 2109 2110 error = VOP_ADVLOCK(uvp, ap->a_id, ap->a_op, ap->a_fl, ap->a_flags); 2111 2112 UNIONFS_INTERNAL_DEBUG("unionfs_advlock: leave (%d)\n", error); 2113 2114 return error; 2115 2116unionfs_advlock_abort: 2117 VOP_UNLOCK(vp, LK_RELEASE); 2118 2119 UNIONFS_INTERNAL_DEBUG("unionfs_advlock: leave (%d)\n", error); 2120 2121 return error; 2122} 2123 2124static int 2125unionfs_strategy(struct vop_strategy_args *ap) 2126{ 2127 struct unionfs_node *unp; 2128 struct vnode *vp; 2129 2130 KASSERT_UNIONFS_VNODE(ap->a_vp); 2131 2132 unp = VTOUNIONFS(ap->a_vp); 2133 vp = (unp->un_uppervp != NULLVP ? unp->un_uppervp : unp->un_lowervp); 2134 2135#ifdef DIAGNOSTIC 2136 if (vp == NULLVP) 2137 panic("unionfs_strategy: nullvp"); 2138 2139 if (ap->a_bp->b_iocmd == BIO_WRITE && vp == unp->un_lowervp) 2140 panic("unionfs_strategy: writing to lowervp"); 2141#endif 2142 2143 return (VOP_STRATEGY(vp, ap->a_bp)); 2144} 2145 2146static int 2147unionfs_getacl(struct vop_getacl_args *ap) 2148{ 2149 int error; 2150 struct unionfs_node *unp; 2151 struct vnode *vp; 2152 2153 KASSERT_UNIONFS_VNODE(ap->a_vp); 2154 2155 unp = VTOUNIONFS(ap->a_vp); 2156 vp = (unp->un_uppervp != NULLVP ? unp->un_uppervp : unp->un_lowervp); 2157 2158 UNIONFS_INTERNAL_DEBUG("unionfs_getacl: enter\n"); 2159 2160 error = VOP_GETACL(vp, ap->a_type, ap->a_aclp, ap->a_cred, ap->a_td); 2161 2162 UNIONFS_INTERNAL_DEBUG("unionfs_getacl: leave (%d)\n", error); 2163 2164 return (error); 2165} 2166 2167static int 2168unionfs_setacl(struct vop_setacl_args *ap) 2169{ 2170 int error; 2171 struct unionfs_node *unp; 2172 struct vnode *uvp; 2173 struct vnode *lvp; 2174 struct thread *td; 2175 2176 UNIONFS_INTERNAL_DEBUG("unionfs_setacl: enter\n"); 2177 2178 KASSERT_UNIONFS_VNODE(ap->a_vp); 2179 2180 error = EROFS; 2181 unp = VTOUNIONFS(ap->a_vp); 2182 uvp = unp->un_uppervp; 2183 lvp = unp->un_lowervp; 2184 td = ap->a_td; 2185 2186 if (ap->a_vp->v_mount->mnt_flag & MNT_RDONLY) 2187 return (EROFS); 2188 2189 if (uvp == NULLVP && lvp->v_type == VREG) { 2190 if ((error = unionfs_copyfile(unp, 1, ap->a_cred, td)) != 0) 2191 return (error); 2192 uvp = unp->un_uppervp; 2193 } 2194 2195 if (uvp != NULLVP) 2196 error = VOP_SETACL(uvp, ap->a_type, ap->a_aclp, ap->a_cred, td); 2197 2198 UNIONFS_INTERNAL_DEBUG("unionfs_setacl: leave (%d)\n", error); 2199 2200 return (error); 2201} 2202 2203static int 2204unionfs_aclcheck(struct vop_aclcheck_args *ap) 2205{ 2206 int error; 2207 struct unionfs_node *unp; 2208 struct vnode *vp; 2209 2210 UNIONFS_INTERNAL_DEBUG("unionfs_aclcheck: enter\n"); 2211 2212 KASSERT_UNIONFS_VNODE(ap->a_vp); 2213 2214 unp = VTOUNIONFS(ap->a_vp); 2215 vp = (unp->un_uppervp != NULLVP ? unp->un_uppervp : unp->un_lowervp); 2216 2217 error = VOP_ACLCHECK(vp, ap->a_type, ap->a_aclp, ap->a_cred, ap->a_td); 2218 2219 UNIONFS_INTERNAL_DEBUG("unionfs_aclcheck: leave (%d)\n", error); 2220 2221 return (error); 2222} 2223 2224static int 2225unionfs_openextattr(struct vop_openextattr_args *ap) 2226{ 2227 int error; 2228 struct unionfs_node *unp; 2229 struct vnode *vp; 2230 struct vnode *tvp; 2231 2232 KASSERT_UNIONFS_VNODE(ap->a_vp); 2233 2234 vp = ap->a_vp; 2235 unp = VTOUNIONFS(vp); 2236 tvp = (unp->un_uppervp != NULLVP ? unp->un_uppervp : unp->un_lowervp); 2237 2238 if ((tvp == unp->un_uppervp && (unp->un_flag & UNIONFS_OPENEXTU)) || 2239 (tvp == unp->un_lowervp && (unp->un_flag & UNIONFS_OPENEXTL))) 2240 return (EBUSY); 2241 2242 error = VOP_OPENEXTATTR(tvp, ap->a_cred, ap->a_td); 2243 2244 if (error == 0) { 2245 if (vn_lock(vp, LK_UPGRADE) != 0) 2246 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 2247 if (tvp == unp->un_uppervp) 2248 unp->un_flag |= UNIONFS_OPENEXTU; 2249 else 2250 unp->un_flag |= UNIONFS_OPENEXTL; 2251 vn_lock(vp, LK_DOWNGRADE | LK_RETRY); 2252 } 2253 2254 return (error); 2255} 2256 2257static int 2258unionfs_closeextattr(struct vop_closeextattr_args *ap) 2259{ 2260 int error; 2261 struct unionfs_node *unp; 2262 struct vnode *vp; 2263 struct vnode *tvp; 2264 2265 KASSERT_UNIONFS_VNODE(ap->a_vp); 2266 2267 vp = ap->a_vp; 2268 unp = VTOUNIONFS(vp); 2269 tvp = NULLVP; 2270 2271 if (unp->un_flag & UNIONFS_OPENEXTU) 2272 tvp = unp->un_uppervp; 2273 else if (unp->un_flag & UNIONFS_OPENEXTL) 2274 tvp = unp->un_lowervp; 2275 2276 if (tvp == NULLVP) 2277 return (EOPNOTSUPP); 2278 2279 error = VOP_CLOSEEXTATTR(tvp, ap->a_commit, ap->a_cred, ap->a_td); 2280 2281 if (error == 0) { 2282 if (vn_lock(vp, LK_UPGRADE) != 0) 2283 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 2284 if (tvp == unp->un_uppervp) 2285 unp->un_flag &= ~UNIONFS_OPENEXTU; 2286 else 2287 unp->un_flag &= ~UNIONFS_OPENEXTL; 2288 vn_lock(vp, LK_DOWNGRADE | LK_RETRY); 2289 } 2290 2291 return (error); 2292} 2293 2294static int 2295unionfs_getextattr(struct vop_getextattr_args *ap) 2296{ 2297 struct unionfs_node *unp; 2298 struct vnode *vp; 2299 2300 KASSERT_UNIONFS_VNODE(ap->a_vp); 2301 2302 unp = VTOUNIONFS(ap->a_vp); 2303 vp = NULLVP; 2304 2305 if (unp->un_flag & UNIONFS_OPENEXTU) 2306 vp = unp->un_uppervp; 2307 else if (unp->un_flag & UNIONFS_OPENEXTL) 2308 vp = unp->un_lowervp; 2309 2310 if (vp == NULLVP) 2311 return (EOPNOTSUPP); 2312 2313 return (VOP_GETEXTATTR(vp, ap->a_attrnamespace, ap->a_name, 2314 ap->a_uio, ap->a_size, ap->a_cred, ap->a_td)); 2315} 2316 2317static int 2318unionfs_setextattr(struct vop_setextattr_args *ap) 2319{ 2320 int error; 2321 struct unionfs_node *unp; 2322 struct vnode *uvp; 2323 struct vnode *lvp; 2324 struct vnode *ovp; 2325 struct ucred *cred; 2326 struct thread *td; 2327 2328 KASSERT_UNIONFS_VNODE(ap->a_vp); 2329 2330 error = EROFS; 2331 unp = VTOUNIONFS(ap->a_vp); 2332 uvp = unp->un_uppervp; 2333 lvp = unp->un_lowervp; 2334 ovp = NULLVP; 2335 cred = ap->a_cred; 2336 td = ap->a_td; 2337 2338 UNIONFS_INTERNAL_DEBUG("unionfs_setextattr: enter (un_flag=%x)\n", unp->un_flag); 2339 2340 if (ap->a_vp->v_mount->mnt_flag & MNT_RDONLY) 2341 return (EROFS); 2342 2343 if (unp->un_flag & UNIONFS_OPENEXTU) 2344 ovp = unp->un_uppervp; 2345 else if (unp->un_flag & UNIONFS_OPENEXTL) 2346 ovp = unp->un_lowervp; 2347 2348 if (ovp == NULLVP) 2349 return (EOPNOTSUPP); 2350 2351 if (ovp == lvp && lvp->v_type == VREG) { 2352 VOP_CLOSEEXTATTR(lvp, 0, cred, td); 2353 if (uvp == NULLVP && 2354 (error = unionfs_copyfile(unp, 1, cred, td)) != 0) { 2355unionfs_setextattr_reopen: 2356 if ((unp->un_flag & UNIONFS_OPENEXTL) && 2357 VOP_OPENEXTATTR(lvp, cred, td)) { 2358#ifdef DIAGNOSTIC 2359 panic("unionfs: VOP_OPENEXTATTR failed"); 2360#endif 2361 unp->un_flag &= ~UNIONFS_OPENEXTL; 2362 } 2363 goto unionfs_setextattr_abort; 2364 } 2365 uvp = unp->un_uppervp; 2366 if ((error = VOP_OPENEXTATTR(uvp, cred, td)) != 0) 2367 goto unionfs_setextattr_reopen; 2368 unp->un_flag &= ~UNIONFS_OPENEXTL; 2369 unp->un_flag |= UNIONFS_OPENEXTU; 2370 ovp = uvp; 2371 } 2372 2373 if (ovp == uvp) 2374 error = VOP_SETEXTATTR(ovp, ap->a_attrnamespace, ap->a_name, 2375 ap->a_uio, cred, td); 2376 2377unionfs_setextattr_abort: 2378 UNIONFS_INTERNAL_DEBUG("unionfs_setextattr: leave (%d)\n", error); 2379 2380 return (error); 2381} 2382 2383static int 2384unionfs_listextattr(struct vop_listextattr_args *ap) 2385{ 2386 struct unionfs_node *unp; 2387 struct vnode *vp; 2388 2389 KASSERT_UNIONFS_VNODE(ap->a_vp); 2390 2391 unp = VTOUNIONFS(ap->a_vp); 2392 vp = NULLVP; 2393 2394 if (unp->un_flag & UNIONFS_OPENEXTU) 2395 vp = unp->un_uppervp; 2396 else if (unp->un_flag & UNIONFS_OPENEXTL) 2397 vp = unp->un_lowervp; 2398 2399 if (vp == NULLVP) 2400 return (EOPNOTSUPP); 2401 2402 return (VOP_LISTEXTATTR(vp, ap->a_attrnamespace, ap->a_uio, 2403 ap->a_size, ap->a_cred, ap->a_td)); 2404} 2405 2406static int 2407unionfs_deleteextattr(struct vop_deleteextattr_args *ap) 2408{ 2409 int error; 2410 struct unionfs_node *unp; 2411 struct vnode *uvp; 2412 struct vnode *lvp; 2413 struct vnode *ovp; 2414 struct ucred *cred; 2415 struct thread *td; 2416 2417 KASSERT_UNIONFS_VNODE(ap->a_vp); 2418 2419 error = EROFS; 2420 unp = VTOUNIONFS(ap->a_vp); 2421 uvp = unp->un_uppervp; 2422 lvp = unp->un_lowervp; 2423 ovp = NULLVP; 2424 cred = ap->a_cred; 2425 td = ap->a_td; 2426 2427 UNIONFS_INTERNAL_DEBUG("unionfs_deleteextattr: enter (un_flag=%x)\n", unp->un_flag); 2428 2429 if (ap->a_vp->v_mount->mnt_flag & MNT_RDONLY) 2430 return (EROFS); 2431 2432 if (unp->un_flag & UNIONFS_OPENEXTU) 2433 ovp = unp->un_uppervp; 2434 else if (unp->un_flag & UNIONFS_OPENEXTL) 2435 ovp = unp->un_lowervp; 2436 2437 if (ovp == NULLVP) 2438 return (EOPNOTSUPP); 2439 2440 if (ovp == lvp && lvp->v_type == VREG) { 2441 VOP_CLOSEEXTATTR(lvp, 0, cred, td); 2442 if (uvp == NULLVP && 2443 (error = unionfs_copyfile(unp, 1, cred, td)) != 0) { 2444unionfs_deleteextattr_reopen: 2445 if ((unp->un_flag & UNIONFS_OPENEXTL) && 2446 VOP_OPENEXTATTR(lvp, cred, td)) { 2447#ifdef DIAGNOSTIC 2448 panic("unionfs: VOP_OPENEXTATTR failed"); 2449#endif 2450 unp->un_flag &= ~UNIONFS_OPENEXTL; 2451 } 2452 goto unionfs_deleteextattr_abort; 2453 } 2454 uvp = unp->un_uppervp; 2455 if ((error = VOP_OPENEXTATTR(uvp, cred, td)) != 0) 2456 goto unionfs_deleteextattr_reopen; 2457 unp->un_flag &= ~UNIONFS_OPENEXTL; 2458 unp->un_flag |= UNIONFS_OPENEXTU; 2459 ovp = uvp; 2460 } 2461 2462 if (ovp == uvp) 2463 error = VOP_DELETEEXTATTR(ovp, ap->a_attrnamespace, ap->a_name, 2464 ap->a_cred, ap->a_td); 2465 2466unionfs_deleteextattr_abort: 2467 UNIONFS_INTERNAL_DEBUG("unionfs_deleteextattr: leave (%d)\n", error); 2468 2469 return (error); 2470} 2471 2472static int 2473unionfs_setlabel(struct vop_setlabel_args *ap) 2474{ 2475 int error; 2476 struct unionfs_node *unp; 2477 struct vnode *uvp; 2478 struct vnode *lvp; 2479 struct thread *td; 2480 2481 UNIONFS_INTERNAL_DEBUG("unionfs_setlabel: enter\n"); 2482 2483 KASSERT_UNIONFS_VNODE(ap->a_vp); 2484 2485 error = EROFS; 2486 unp = VTOUNIONFS(ap->a_vp); 2487 uvp = unp->un_uppervp; 2488 lvp = unp->un_lowervp; 2489 td = ap->a_td; 2490 2491 if (ap->a_vp->v_mount->mnt_flag & MNT_RDONLY) 2492 return (EROFS); 2493 2494 if (uvp == NULLVP && lvp->v_type == VREG) { 2495 if ((error = unionfs_copyfile(unp, 1, ap->a_cred, td)) != 0) 2496 return (error); 2497 uvp = unp->un_uppervp; 2498 } 2499 2500 if (uvp != NULLVP) 2501 error = VOP_SETLABEL(uvp, ap->a_label, ap->a_cred, td); 2502 2503 UNIONFS_INTERNAL_DEBUG("unionfs_setlabel: leave (%d)\n", error); 2504 2505 return (error); 2506} 2507 2508static int 2509unionfs_vptofh(struct vop_vptofh_args *ap) 2510{ 2511 return (EOPNOTSUPP); 2512} 2513 2514static int 2515unionfs_add_writecount(struct vop_add_writecount_args *ap) 2516{ 2517 struct vnode *tvp, *vp; 2518 struct unionfs_node *unp; 2519 int error; 2520 2521 vp = ap->a_vp; 2522 unp = VTOUNIONFS(vp); 2523 tvp = unp->un_uppervp != NULL ? unp->un_uppervp : unp->un_lowervp; 2524 VI_LOCK(vp); 2525 /* text refs are bypassed to lowervp */ 2526 VNASSERT(vp->v_writecount >= 0, vp, ("wrong null writecount")); 2527 VNASSERT(vp->v_writecount + ap->a_inc >= 0, vp, 2528 ("wrong writecount inc %d", ap->a_inc)); 2529 if (tvp != NULL) 2530 error = VOP_ADD_WRITECOUNT(tvp, ap->a_inc); 2531 else if (vp->v_writecount < 0) 2532 error = ETXTBSY; 2533 else 2534 error = 0; 2535 if (error == 0) 2536 vp->v_writecount += ap->a_inc; 2537 VI_UNLOCK(vp); 2538 return (error); 2539} 2540 2541struct vop_vector unionfs_vnodeops = { 2542 .vop_default = &default_vnodeops, 2543 2544 .vop_access = unionfs_access, 2545 .vop_aclcheck = unionfs_aclcheck, 2546 .vop_advlock = unionfs_advlock, 2547 .vop_bmap = VOP_EOPNOTSUPP, 2548 .vop_cachedlookup = unionfs_lookup, 2549 .vop_close = unionfs_close, 2550 .vop_closeextattr = unionfs_closeextattr, 2551 .vop_create = unionfs_create, 2552 .vop_deleteextattr = unionfs_deleteextattr, 2553 .vop_fsync = unionfs_fsync, 2554 .vop_getacl = unionfs_getacl, 2555 .vop_getattr = unionfs_getattr, 2556 .vop_getextattr = unionfs_getextattr, 2557 .vop_getwritemount = unionfs_getwritemount, 2558 .vop_inactive = unionfs_inactive, 2559 .vop_islocked = unionfs_islocked, 2560 .vop_ioctl = unionfs_ioctl, 2561 .vop_link = unionfs_link, 2562 .vop_listextattr = unionfs_listextattr, 2563 .vop_lock1 = unionfs_lock, 2564 .vop_lookup = vfs_cache_lookup, 2565 .vop_mkdir = unionfs_mkdir, 2566 .vop_mknod = unionfs_mknod, 2567 .vop_open = unionfs_open, 2568 .vop_openextattr = unionfs_openextattr, 2569 .vop_pathconf = unionfs_pathconf, 2570 .vop_poll = unionfs_poll, 2571 .vop_print = unionfs_print, 2572 .vop_read = unionfs_read, 2573 .vop_readdir = unionfs_readdir, 2574 .vop_readlink = unionfs_readlink, 2575 .vop_reclaim = unionfs_reclaim, 2576 .vop_remove = unionfs_remove, 2577 .vop_rename = unionfs_rename, 2578 .vop_rmdir = unionfs_rmdir, 2579 .vop_setacl = unionfs_setacl, 2580 .vop_setattr = unionfs_setattr, 2581 .vop_setextattr = unionfs_setextattr, 2582 .vop_setlabel = unionfs_setlabel, 2583 .vop_strategy = unionfs_strategy, 2584 .vop_symlink = unionfs_symlink, 2585 .vop_unlock = unionfs_unlock, 2586 .vop_whiteout = unionfs_whiteout, 2587 .vop_write = unionfs_write, 2588 .vop_vptofh = unionfs_vptofh, 2589 .vop_add_writecount = unionfs_add_writecount, 2590}; 2591