sys/fs/unionfs/union_vnops.c

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