sys/vfs/union/union_subr.c

   1 /*
   2  * Copyright (c) 1994 Jan-Simon Pendry
   3  * Copyright (c) 1994
   4  *      The Regents of the University of California.  All rights reserved.
   5  *
   6  * This code is derived from software contributed to Berkeley by
   7  * Jan-Simon Pendry.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  * 3. All advertising materials mentioning features or use of this software
  18  *    must display the following acknowledgement:
  19  *      This product includes software developed by the University of
  20  *      California, Berkeley and its contributors.
  21  * 4. Neither the name of the University nor the names of its contributors
  22  *    may be used to endorse or promote products derived from this software
  23  *    without specific prior written permission.
  24  *
  25  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  27  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  28  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  29  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  30  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  31  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  32  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  33  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  34  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  35  * SUCH DAMAGE.
  36  *
  37  *      @(#)union_subr.c        8.20 (Berkeley) 5/20/95
  38  * $FreeBSD: src/sys/miscfs/union/union_subr.c,v 1.43.2.2 2001/12/25 01:44:45 dillon Exp $
  39  * $DragonFly: src/sys/vfs/union/union_subr.c,v 1.6 2003/08/07 21:17:44 dillon Exp $
  40  */
  41
  42 #include <sys/param.h>
  43 #include <sys/systm.h>
  44 #include <sys/kernel.h>
  45 #include <sys/vnode.h>
  46 #include <sys/proc.h>
  47 #include <sys/namei.h>
  48 #include <sys/malloc.h>
  49 #include <sys/fcntl.h>
  50 #include <sys/file.h>
  51 #include <sys/filedesc.h>
  52 #include <sys/module.h>
  53 #include <sys/mount.h>
  54 #include <sys/stat.h>
  55 #include <vm/vm.h>
  56 #include <vm/vm_extern.h>       /* for vnode_pager_setsize */
  57 #include <vm/vm_zone.h>
  58 #include <vm/vm_object.h>       /* for vm cache coherency */
  59 #include "union.h"
  60
  61 extern int      union_init __P((void));
  62
  63 /* must be power of two, otherwise change UNION_HASH() */
  64 #define NHASH 32
  65
  66 /* unsigned int ... */
  67 #define UNION_HASH(u, l) \
  68         (((((uintptr_t) (u)) + ((uintptr_t) l)) >> 8) & (NHASH-1))
  69
  70 static LIST_HEAD(unhead, union_node) unhead[NHASH];
  71 static int unvplock[NHASH];
  72
  73 static void     union_dircache_r __P((struct vnode *vp, struct vnode ***vppp,
  74                                       int *cntp));
  75 static int      union_list_lock __P((int ix));
  76 static void     union_list_unlock __P((int ix));
  77 static int      union_relookup __P((struct union_mount *um, struct vnode *dvp,
  78                                     struct vnode **vpp,
  79                                     struct componentname *cnp,
  80                                     struct componentname *cn, char *path,
  81                                     int pathlen));
  82 static void     union_updatevp __P((struct union_node *un,
  83                                     struct vnode *uppervp,
  84                                     struct vnode *lowervp));
  85 static void union_newlower __P((struct union_node *, struct vnode *));
  86 static void union_newupper __P((struct union_node *, struct vnode *));
  87 static int union_copyfile __P((struct vnode *, struct vnode *,
  88                                         struct ucred *, struct thread *));
  89 static int union_vn_create __P((struct vnode **, struct union_node *,
  90                                 struct thread *));
  91 static int union_vn_close __P((struct vnode *, int, struct ucred *,
  92                                 struct thread *));
  93
  94 int
  95 union_init()
  96 {
  97         int i;
  98
  99         for (i = 0; i < NHASH; i++)
 100                 LIST_INIT(&unhead[i]);
 101         bzero((caddr_t)unvplock, sizeof(unvplock));
 102         return (0);
 103 }
 104
 105 static int
 106 union_list_lock(ix)
 107         int ix;
 108 {
 109         if (unvplock[ix] & UNVP_LOCKED) {
 110                 unvplock[ix] |= UNVP_WANT;
 111                 (void) tsleep((caddr_t) &unvplock[ix], 0, "unllck", 0);
 112                 return (1);
 113         }
 114         unvplock[ix] |= UNVP_LOCKED;
 115         return (0);
 116 }
 117
 118 static void
 119 union_list_unlock(ix)
 120         int ix;
 121 {
 122         unvplock[ix] &= ~UNVP_LOCKED;
 123
 124         if (unvplock[ix] & UNVP_WANT) {
 125                 unvplock[ix] &= ~UNVP_WANT;
 126                 wakeup((caddr_t) &unvplock[ix]);
 127         }
 128 }
 129
 130 /*
 131  *      union_updatevp:
 132  *
 133  *      The uppervp, if not NULL, must be referenced and not locked by us
 134  *      The lowervp, if not NULL, must be referenced.
 135  *
 136  *      if uppervp and lowervp match pointers already installed, nothing
 137  *      happens. The passed vp's (when matching) are not adjusted.  This
 138  *      routine may only be called by union_newupper() and union_newlower().
 139  */
 140
 141 static void
 142 union_updatevp(un, uppervp, lowervp)
 143         struct union_node *un;
 144         struct vnode *uppervp;
 145         struct vnode *lowervp;
 146 {
 147         int ohash = UNION_HASH(un->un_uppervp, un->un_lowervp);
 148         int nhash = UNION_HASH(uppervp, lowervp);
 149         int docache = (lowervp != NULLVP || uppervp != NULLVP);
 150         int lhash, uhash;
 151
 152         /*
 153          * Ensure locking is ordered from lower to higher
 154          * to avoid deadlocks.
 155          */
 156         if (nhash < ohash) {
 157                 lhash = nhash;
 158                 uhash = ohash;
 159         } else {
 160                 lhash = ohash;
 161                 uhash = nhash;
 162         }
 163
 164         if (lhash != uhash) {
 165                 while (union_list_lock(lhash))
 166                         continue;
 167         }
 168
 169         while (union_list_lock(uhash))
 170                 continue;
 171
 172         if (ohash != nhash || !docache) {
 173                 if (un->un_flags & UN_CACHED) {
 174                         un->un_flags &= ~UN_CACHED;
 175                         LIST_REMOVE(un, un_cache);
 176                 }
 177         }
 178
 179         if (ohash != nhash)
 180                 union_list_unlock(ohash);
 181
 182         if (un->un_lowervp != lowervp) {
 183                 if (un->un_lowervp) {
 184                         vrele(un->un_lowervp);
 185                         if (un->un_path) {
 186                                 free(un->un_path, M_TEMP);
 187                                 un->un_path = 0;
 188                         }
 189                 }
 190                 un->un_lowervp = lowervp;
 191                 un->un_lowersz = VNOVAL;
 192         }
 193
 194         if (un->un_uppervp != uppervp) {
 195                 if (un->un_uppervp)
 196                         vrele(un->un_uppervp);
 197                 un->un_uppervp = uppervp;
 198                 un->un_uppersz = VNOVAL;
 199         }
 200
 201         if (docache && (ohash != nhash)) {
 202                 LIST_INSERT_HEAD(&unhead[nhash], un, un_cache);
 203                 un->un_flags |= UN_CACHED;
 204         }
 205
 206         union_list_unlock(nhash);
 207 }
 208
 209 /*
 210  * Set a new lowervp.  The passed lowervp must be referenced and will be
 211  * stored in the vp in a referenced state.
 212  */
 213
 214 static void
 215 union_newlower(un, lowervp)
 216         struct union_node *un;
 217         struct vnode *lowervp;
 218 {
 219         union_updatevp(un, un->un_uppervp, lowervp);
 220 }
 221
 222 /*
 223  * Set a new uppervp.  The passed uppervp must be locked and will be
 224  * stored in the vp in a locked state.  The caller should not unlock
 225  * uppervp.
 226  */
 227
 228 static void
 229 union_newupper(un, uppervp)
 230         struct union_node *un;
 231         struct vnode *uppervp;
 232 {
 233         union_updatevp(un, uppervp, un->un_lowervp);
 234 }
 235
 236 /*
 237  * Keep track of size changes in the underlying vnodes.
 238  * If the size changes, then callback to the vm layer
 239  * giving priority to the upper layer size.
 240  */
 241 void
 242 union_newsize(vp, uppersz, lowersz)
 243         struct vnode *vp;
 244         off_t uppersz, lowersz;
 245 {
 246         struct union_node *un;
 247         off_t sz;
 248
 249         /* only interested in regular files */
 250         if (vp->v_type != VREG)
 251                 return;
 252
 253         un = VTOUNION(vp);
 254         sz = VNOVAL;
 255
 256         if ((uppersz != VNOVAL) && (un->un_uppersz != uppersz)) {
 257                 un->un_uppersz = uppersz;
 258                 if (sz == VNOVAL)
 259                         sz = un->un_uppersz;
 260         }
 261
 262         if ((lowersz != VNOVAL) && (un->un_lowersz != lowersz)) {
 263                 un->un_lowersz = lowersz;
 264                 if (sz == VNOVAL)
 265                         sz = un->un_lowersz;
 266         }
 267
 268         if (sz != VNOVAL) {
 269                 UDEBUG(("union: %s size now %ld\n",
 270                         (uppersz != VNOVAL ? "upper" : "lower"), (long)sz));
 271                 vnode_pager_setsize(vp, sz);
 272         }
 273 }
 274
 275 /*
 276  *      union_allocvp:  allocate a union_node and associate it with a
 277  *                      parent union_node and one or two vnodes.
 278  *
 279  *      vpp     Holds the returned vnode locked and referenced if no
 280  *              error occurs.
 281  *
 282  *      mp      Holds the mount point.  mp may or may not be busied.
 283  *              allocvp makes no changes to mp.
 284  *
 285  *      dvp     Holds the parent union_node to the one we wish to create.
 286  *              XXX may only be used to traverse an uncopied lowervp-based
 287  *              tree?  XXX
 288  *
 289  *              dvp may or may not be locked.  allocvp makes no changes
 290  *              to dvp.
 291  *
 292  *      upperdvp Holds the parent vnode to uppervp, generally used along
 293  *              with path component information to create a shadow of
 294  *              lowervp when uppervp does not exist.
 295  *
 296  *              upperdvp is referenced but unlocked on entry, and will be
 297  *              dereferenced on return.
 298  *
 299  *      uppervp Holds the new uppervp vnode to be stored in the
 300  *              union_node we are allocating.  uppervp is referenced but
 301  *              not locked, and will be dereferenced on return.
 302  *
 303  *      lowervp Holds the new lowervp vnode to be stored in the
 304  *              union_node we are allocating.  lowervp is referenced but
 305  *              not locked, and will be dereferenced on return.
 306  *
 307  *      cnp     Holds path component information to be coupled with
 308  *              lowervp and upperdvp to allow unionfs to create an uppervp
 309  *              later on.  Only used if lowervp is valid.  The conents
 310  *              of cnp is only valid for the duration of the call.
 311  *
 312  *      docache Determine whether this node should be entered in the
 313  *              cache or whether it should be destroyed as soon as possible.
 314  *
 315  * all union_nodes are maintained on a singly-linked
 316  * list.  new nodes are only allocated when they cannot
 317  * be found on this list.  entries on the list are
 318  * removed when the vfs reclaim entry is called.
 319  *
 320  * a single lock is kept for the entire list.  this is
 321  * needed because the getnewvnode() function can block
 322  * waiting for a vnode to become free, in which case there
 323  * may be more than one process trying to get the same
 324  * vnode.  this lock is only taken if we are going to
 325  * call getnewvnode, since the kernel itself is single-threaded.
 326  *
 327  * if an entry is found on the list, then call vget() to
 328  * take a reference.  this is done because there may be
 329  * zero references to it and so it needs to removed from
 330  * the vnode free list.
 331  */
 332
 333 int
 334 union_allocvp(vpp, mp, dvp, upperdvp, cnp, uppervp, lowervp, docache)
 335         struct vnode **vpp;
 336         struct mount *mp;
 337         struct vnode *dvp;              /* parent union vnode */
 338         struct vnode *upperdvp;         /* parent vnode of uppervp */
 339         struct componentname *cnp;      /* may be null */
 340         struct vnode *uppervp;          /* may be null */
 341         struct vnode *lowervp;          /* may be null */
 342         int docache;
 343 {
 344         int error;
 345         struct union_node *un = 0;
 346         struct union_mount *um = MOUNTTOUNIONMOUNT(mp);
 347         struct thread *td = (cnp) ? cnp->cn_td : curthread; /* XXX */
 348         int hash = 0;
 349         int vflag;
 350         int try;
 351
 352         if (uppervp == NULLVP && lowervp == NULLVP)
 353                 panic("union: unidentifiable allocation");
 354
 355         if (uppervp && lowervp && (uppervp->v_type != lowervp->v_type)) {
 356                 vrele(lowervp);
 357                 lowervp = NULLVP;
 358         }
 359
 360         /* detect the root vnode (and aliases) */
 361         vflag = 0;
 362         if ((uppervp == um->um_uppervp) &&
 363             ((lowervp == NULLVP) || lowervp == um->um_lowervp)) {
 364                 if (lowervp == NULLVP) {
 365                         lowervp = um->um_lowervp;
 366                         if (lowervp != NULLVP)
 367                                 VREF(lowervp);
 368                 }
 369                 vflag = VROOT;
 370         }
 371
 372 loop:
 373         if (!docache) {
 374                 un = 0;
 375         } else for (try = 0; try < 3; try++) {
 376                 switch (try) {
 377                 case 0:
 378                         if (lowervp == NULLVP)
 379                                 continue;
 380                         hash = UNION_HASH(uppervp, lowervp);
 381                         break;
 382
 383                 case 1:
 384                         if (uppervp == NULLVP)
 385                                 continue;
 386                         hash = UNION_HASH(uppervp, NULLVP);
 387                         break;
 388
 389                 case 2:
 390                         if (lowervp == NULLVP)
 391                                 continue;
 392                         hash = UNION_HASH(NULLVP, lowervp);
 393                         break;
 394                 }
 395
 396                 while (union_list_lock(hash))
 397                         continue;
 398
 399                 for (un = unhead[hash].lh_first; un != 0;
 400                                         un = un->un_cache.le_next) {
 401                         if ((un->un_lowervp == lowervp ||
 402                              un->un_lowervp == NULLVP) &&
 403                             (un->un_uppervp == uppervp ||
 404                              un->un_uppervp == NULLVP) &&
 405                             (UNIONTOV(un)->v_mount == mp)) {
 406                                 if (vget(UNIONTOV(un), 0,
 407                                     cnp ? cnp->cn_td : NULL)) {
 408                                         union_list_unlock(hash);
 409                                         goto loop;
 410                                 }
 411                                 break;
 412                         }
 413                 }
 414
 415                 union_list_unlock(hash);
 416
 417                 if (un)
 418                         break;
 419         }
 420
 421         if (un) {
 422                 /*
 423                  * Obtain a lock on the union_node.  Everything is unlocked
 424                  * except for dvp, so check that case.  If they match, our
 425                  * new un is already locked.  Otherwise we have to lock our
 426                  * new un.
 427                  *
 428                  * A potential deadlock situation occurs when we are holding
 429                  * one lock while trying to get another.  We must follow
 430                  * strict ordering rules to avoid it.  We try to locate dvp
 431                  * by scanning up from un_vnode, since the most likely
 432                  * scenario is un being under dvp.
 433                  */
 434
 435                 if (dvp && un->un_vnode != dvp) {
 436                         struct vnode *scan = un->un_vnode;
 437
 438                         do {
 439                                 scan = VTOUNION(scan)->un_pvp;
 440                         } while (scan && scan->v_tag == VT_UNION && scan != dvp);
 441                         if (scan != dvp) {
 442                                 /*
 443                                  * our new un is above dvp (we never saw dvp
 444                                  * while moving up the tree).
 445                                  */
 446                                 VREF(dvp);
 447                                 VOP_UNLOCK(dvp, 0, td);
 448                                 error = vn_lock(un->un_vnode, LK_EXCLUSIVE, td);
 449                                 vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY, td);
 450                                 vrele(dvp);
 451                         } else {
 452                                 /*
 453                                  * our new un is under dvp
 454                                  */
 455                                 error = vn_lock(un->un_vnode, LK_EXCLUSIVE, td);
 456                         }
 457                 } else if (dvp == NULLVP) {
 458                         /*
 459                          * dvp is NULL, we need to lock un.
 460                          */
 461                         error = vn_lock(un->un_vnode, LK_EXCLUSIVE, td);
 462                 } else {
 463                         /*
 464                          * dvp == un->un_vnode, we are already locked.
 465                          */
 466                         error = 0;
 467                 }
 468
 469                 if (error)
 470                         goto loop;
 471
 472                 /*
 473                  * At this point, the union_node is locked and referenced.
 474                  *
 475                  * uppervp is locked and referenced or NULL, lowervp is
 476                  * referenced or NULL.
 477                  */
 478                 UDEBUG(("Modify existing un %p vn %p upper %p(refs %d) -> %p(refs %d)\n",
 479                         un, un->un_vnode, un->un_uppervp,
 480                         (un->un_uppervp ? un->un_uppervp->v_usecount : -99),
 481                         uppervp,
 482                         (uppervp ? uppervp->v_usecount : -99)
 483                 ));
 484
 485                 if (uppervp != un->un_uppervp) {
 486                         KASSERT(uppervp == NULL || uppervp->v_usecount > 0, ("union_allocvp: too few refs %d (at least 1 required) on uppervp", uppervp->v_usecount));
 487                         union_newupper(un, uppervp);
 488                 } else if (uppervp) {
 489                         KASSERT(uppervp->v_usecount > 1, ("union_allocvp: too few refs %d (at least 2 required) on uppervp", uppervp->v_usecount));
 490                         vrele(uppervp);
 491                 }
 492
 493                 /*
 494                  * Save information about the lower layer.
 495                  * This needs to keep track of pathname
 496                  * and directory information which union_vn_create
 497                  * might need.
 498                  */
 499                 if (lowervp != un->un_lowervp) {
 500                         union_newlower(un, lowervp);
 501                         if (cnp && (lowervp != NULLVP)) {
 502                                 un->un_path = malloc(cnp->cn_namelen+1,
 503                                                 M_TEMP, M_WAITOK);
 504                                 bcopy(cnp->cn_nameptr, un->un_path,
 505                                                 cnp->cn_namelen);
 506                                 un->un_path[cnp->cn_namelen] = '\0';
 507                         }
 508                 } else if (lowervp) {
 509                         vrele(lowervp);
 510                 }
 511
 512                 /*
 513                  * and upperdvp
 514                  */
 515                 if (upperdvp != un->un_dirvp) {
 516                         if (un->un_dirvp)
 517                                 vrele(un->un_dirvp);
 518                         un->un_dirvp = upperdvp;
 519                 } else if (upperdvp) {
 520                         vrele(upperdvp);
 521                 }
 522
 523                 *vpp = UNIONTOV(un);
 524                 return (0);
 525         }
 526
 527         if (docache) {
 528                 /*
 529                  * otherwise lock the vp list while we call getnewvnode
 530                  * since that can block.
 531                  */
 532                 hash = UNION_HASH(uppervp, lowervp);
 533
 534                 if (union_list_lock(hash))
 535                         goto loop;
 536         }
 537
 538         /*
 539          * Create new node rather then replace old node
 540          */
 541
 542         error = getnewvnode(VT_UNION, mp, union_vnodeop_p, vpp);
 543         if (error) {
 544                 /*
 545                  * If an error occurs clear out vnodes.
 546                  */
 547                 if (lowervp)
 548                         vrele(lowervp);
 549                 if (uppervp)
 550                         vrele(uppervp);
 551                 if (upperdvp)
 552                         vrele(upperdvp);
 553                 *vpp = NULL;
 554                 goto out;
 555         }
 556
 557         MALLOC((*vpp)->v_data, void *, sizeof(struct union_node),
 558                 M_TEMP, M_WAITOK);
 559
 560         (*vpp)->v_flag |= vflag;
 561         if (uppervp)
 562                 (*vpp)->v_type = uppervp->v_type;
 563         else
 564                 (*vpp)->v_type = lowervp->v_type;
 565
 566         un = VTOUNION(*vpp);
 567         bzero(un, sizeof(*un));
 568
 569         lockinit(&un->un_lock, 0, "unlock", VLKTIMEOUT, 0);
 570         vn_lock(*vpp, LK_EXCLUSIVE | LK_RETRY, td);
 571
 572         un->un_vnode = *vpp;
 573         un->un_uppervp = uppervp;
 574         un->un_uppersz = VNOVAL;
 575         un->un_lowervp = lowervp;
 576         un->un_lowersz = VNOVAL;
 577         un->un_dirvp = upperdvp;
 578         un->un_pvp = dvp;               /* only parent dir in new allocation */
 579         if (dvp != NULLVP)
 580                 VREF(dvp);
 581         un->un_dircache = 0;
 582         un->un_openl = 0;
 583
 584         if (cnp && (lowervp != NULLVP)) {
 585                 un->un_path = malloc(cnp->cn_namelen+1, M_TEMP, M_WAITOK);
 586                 bcopy(cnp->cn_nameptr, un->un_path, cnp->cn_namelen);
 587                 un->un_path[cnp->cn_namelen] = '\0';
 588         } else {
 589                 un->un_path = 0;
 590                 un->un_dirvp = NULL;
 591         }
 592
 593         if (docache) {
 594                 LIST_INSERT_HEAD(&unhead[hash], un, un_cache);
 595                 un->un_flags |= UN_CACHED;
 596         }
 597
 598 out:
 599         if (docache)
 600                 union_list_unlock(hash);
 601
 602         return (error);
 603 }
 604
 605 int
 606 union_freevp(vp)
 607         struct vnode *vp;
 608 {
 609         struct union_node *un = VTOUNION(vp);
 610
 611         if (un->un_flags & UN_CACHED) {
 612                 un->un_flags &= ~UN_CACHED;
 613                 LIST_REMOVE(un, un_cache);
 614         }
 615
 616         if (un->un_pvp != NULLVP) {
 617                 vrele(un->un_pvp);
 618                 un->un_pvp = NULL;
 619         }
 620         if (un->un_uppervp != NULLVP) {
 621                 vrele(un->un_uppervp);
 622                 un->un_uppervp = NULL;
 623         }
 624         if (un->un_lowervp != NULLVP) {
 625                 vrele(un->un_lowervp);
 626                 un->un_lowervp = NULL;
 627         }
 628         if (un->un_dirvp != NULLVP) {
 629                 vrele(un->un_dirvp);
 630                 un->un_dirvp = NULL;
 631         }
 632         if (un->un_path) {
 633                 free(un->un_path, M_TEMP);
 634                 un->un_path = NULL;
 635         }
 636
 637         FREE(vp->v_data, M_TEMP);
 638         vp->v_data = 0;
 639
 640         return (0);
 641 }
 642
 643 /*
 644  * copyfile.  copy the vnode (fvp) to the vnode (tvp)
 645  * using a sequence of reads and writes.  both (fvp)
 646  * and (tvp) are locked on entry and exit.
 647  *
 648  * fvp and tvp are both exclusive locked on call, but their refcount's
 649  * haven't been bumped at all.
 650  */
 651 static int
 652 union_copyfile(fvp, tvp, cred, td)
 653         struct vnode *fvp;
 654         struct vnode *tvp;
 655         struct ucred *cred;
 656         struct thread *td;
 657 {
 658         char *buf;
 659         struct uio uio;
 660         struct iovec iov;
 661         int error = 0;
 662
 663         /*
 664          * strategy:
 665          * allocate a buffer of size MAXBSIZE.
 666          * loop doing reads and writes, keeping track
 667          * of the current uio offset.
 668          * give up at the first sign of trouble.
 669          */
 670
 671         bzero(&uio, sizeof(uio));
 672
 673         uio.uio_td = td;
 674         uio.uio_segflg = UIO_SYSSPACE;
 675         uio.uio_offset = 0;
 676
 677         VOP_LEASE(fvp, td, cred, LEASE_READ);
 678         VOP_LEASE(tvp, td, cred, LEASE_WRITE);
 679
 680         buf = malloc(MAXBSIZE, M_TEMP, M_WAITOK);
 681
 682         /* ugly loop follows... */
 683         do {
 684                 off_t offset = uio.uio_offset;
 685                 int count;
 686                 int bufoffset;
 687
 688                 /*
 689                  * Setup for big read
 690                  */
 691                 uio.uio_iov = &iov;
 692                 uio.uio_iovcnt = 1;
 693                 iov.iov_base = buf;
 694                 iov.iov_len = MAXBSIZE;
 695                 uio.uio_resid = iov.iov_len;
 696                 uio.uio_rw = UIO_READ;
 697
 698                 if ((error = VOP_READ(fvp, &uio, 0, cred)) != 0)
 699                         break;
 700
 701                 /*
 702                  * Get bytes read, handle read eof case and setup for
 703                  * write loop
 704                  */
 705                 if ((count = MAXBSIZE - uio.uio_resid) == 0)
 706                         break;
 707                 bufoffset = 0;
 708
 709                 /*
 710                  * Write until an error occurs or our buffer has been
 711                  * exhausted, then update the offset for the next read.
 712                  */
 713                 while (bufoffset < count) {
 714                         uio.uio_iov = &iov;
 715                         uio.uio_iovcnt = 1;
 716                         iov.iov_base = buf + bufoffset;
 717                         iov.iov_len = count - bufoffset;
 718                         uio.uio_offset = offset + bufoffset;
 719                         uio.uio_rw = UIO_WRITE;
 720                         uio.uio_resid = iov.iov_len;
 721
 722                         if ((error = VOP_WRITE(tvp, &uio, 0, cred)) != 0)
 723                                 break;
 724                         bufoffset += (count - bufoffset) - uio.uio_resid;
 725                 }
 726                 uio.uio_offset = offset + bufoffset;
 727         } while (error == 0);
 728
 729         free(buf, M_TEMP);
 730         return (error);
 731 }
 732
 733 /*
 734  *
 735  * un's vnode is assumed to be locked on entry and remains locked on exit.
 736  */
 737
 738 int
 739 union_copyup(un, docopy, cred, td)
 740         struct union_node *un;
 741         int docopy;
 742         struct ucred *cred;
 743         struct thread *td;
 744 {
 745         int error;
 746         struct vnode *lvp, *uvp;
 747
 748         /*
 749          * If the user does not have read permission, the vnode should not
 750          * be copied to upper layer.
 751          */
 752         vn_lock(un->un_lowervp, LK_EXCLUSIVE | LK_RETRY, td);
 753         error = VOP_ACCESS(un->un_lowervp, VREAD, cred, td);
 754         VOP_UNLOCK(un->un_lowervp, 0, td);
 755         if (error)
 756                 return (error);
 757
 758         error = union_vn_create(&uvp, un, td);
 759         if (error)
 760                 return (error);
 761
 762         lvp = un->un_lowervp;
 763
 764         KASSERT(uvp->v_usecount > 0, ("copy: uvp refcount 0: %d", uvp->v_usecount));
 765         if (docopy) {
 766                 /*
 767                  * XX - should not ignore errors
 768                  * from VOP_CLOSE
 769                  */
 770                 vn_lock(lvp, LK_EXCLUSIVE | LK_RETRY, td);
 771                 error = VOP_OPEN(lvp, FREAD, cred, td);
 772                 if (error == 0 && vn_canvmio(lvp) == TRUE)
 773                         error = vfs_object_create(lvp, td);
 774                 if (error == 0) {
 775                         error = union_copyfile(lvp, uvp, cred, td);
 776                         VOP_UNLOCK(lvp, 0, td);
 777                         (void) VOP_CLOSE(lvp, FREAD, td);
 778                 }
 779                 if (error == 0)
 780                         UDEBUG(("union: copied up %s\n", un->un_path));
 781
 782         }
 783         VOP_UNLOCK(uvp, 0, td);
 784         union_newupper(un, uvp);
 785         KASSERT(uvp->v_usecount > 0, ("copy: uvp refcount 0: %d", uvp->v_usecount));
 786         union_vn_close(uvp, FWRITE, cred, td);
 787         KASSERT(uvp->v_usecount > 0, ("copy: uvp refcount 0: %d", uvp->v_usecount));
 788         /*
 789          * Subsequent IOs will go to the top layer, so
 790          * call close on the lower vnode and open on the
 791          * upper vnode to ensure that the filesystem keeps
 792          * its references counts right.  This doesn't do
 793          * the right thing with (cred) and (FREAD) though.
 794          * Ignoring error returns is not right, either.
 795          */
 796         if (error == 0) {
 797                 int i;
 798
 799                 for (i = 0; i < un->un_openl; i++) {
 800                         (void) VOP_CLOSE(lvp, FREAD, td);
 801                         (void) VOP_OPEN(uvp, FREAD, cred, td);
 802                 }
 803                 if (un->un_openl) {
 804                         if (vn_canvmio(uvp) == TRUE)
 805                                 error = vfs_object_create(uvp, td);
 806                 }
 807                 un->un_openl = 0;
 808         }
 809
 810         return (error);
 811
 812 }
 813
 814 /*
 815  *      union_relookup:
 816  *
 817  *      dvp should be locked on entry and will be locked on return.  No
 818  *      net change in the ref count will occur.
 819  *
 820  *      If an error is returned, *vpp will be invalid, otherwise it
 821  *      will hold a locked, referenced vnode.  If *vpp == dvp then
 822  *      remember that only one exclusive lock is held.
 823  */
 824
 825 static int
 826 union_relookup(um, dvp, vpp, cnp, cn, path, pathlen)
 827         struct union_mount *um;
 828         struct vnode *dvp;
 829         struct vnode **vpp;
 830         struct componentname *cnp;
 831         struct componentname *cn;
 832         char *path;
 833         int pathlen;
 834 {
 835         int error;
 836
 837         /*
 838          * A new componentname structure must be faked up because
 839          * there is no way to know where the upper level cnp came
 840          * from or what it is being used for.  This must duplicate
 841          * some of the work done by NDINIT, some of the work done
 842          * by namei, some of the work done by lookup and some of
 843          * the work done by VOP_LOOKUP when given a CREATE flag.
 844          * Conclusion: Horrible.
 845          */
 846         cn->cn_namelen = pathlen;
 847         cn->cn_pnbuf = zalloc(namei_zone);
 848         bcopy(path, cn->cn_pnbuf, cn->cn_namelen);
 849         cn->cn_pnbuf[cn->cn_namelen] = '\0';
 850
 851         cn->cn_nameiop = CREATE;
 852         cn->cn_flags = (LOCKPARENT|LOCKLEAF|HASBUF|SAVENAME|ISLASTCN);
 853         cn->cn_td = cnp->cn_td;
 854         if (um->um_op == UNMNT_ABOVE)
 855                 cn->cn_cred = cnp->cn_cred;
 856         else
 857                 cn->cn_cred = um->um_cred;
 858         cn->cn_nameptr = cn->cn_pnbuf;
 859         cn->cn_consume = cnp->cn_consume;
 860
 861         VREF(dvp);
 862         VOP_UNLOCK(dvp, 0, cnp->cn_td);
 863
 864         /*
 865          * Pass dvp unlocked and referenced on call to relookup().
 866          *
 867          * If an error occurs, dvp will be returned unlocked and dereferenced.
 868          */
 869
 870         if ((error = relookup(dvp, vpp, cn)) != 0) {
 871                 vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY, cnp->cn_td);
 872                 return(error);
 873         }
 874
 875         /*
 876          * If no error occurs, dvp will be returned locked with the reference
 877          * left as before, and vpp will be returned referenced and locked.
 878          *
 879          * We want to return with dvp as it was passed to us, so we get
 880          * rid of our reference.
 881          */
 882         vrele(dvp);
 883         return (0);
 884 }
 885
 886 /*
 887  * Create a shadow directory in the upper layer.
 888  * The new vnode is returned locked.
 889  *
 890  * (um) points to the union mount structure for access to the
 891  * the mounting process's credentials.
 892  * (dvp) is the directory in which to create the shadow directory,
 893  * it is locked (but not ref'd) on entry and return.
 894  * (cnp) is the componentname to be created.
 895  * (vpp) is the returned newly created shadow directory, which
 896  * is returned locked and ref'd
 897  */
 898 int
 899 union_mkshadow(um, dvp, cnp, vpp)
 900         struct union_mount *um;
 901         struct vnode *dvp;
 902         struct componentname *cnp;
 903         struct vnode **vpp;
 904 {
 905         int error;
 906         struct vattr va;
 907         struct thread *td = cnp->cn_td;
 908         struct componentname cn;
 909
 910         error = union_relookup(um, dvp, vpp, cnp, &cn,
 911                         cnp->cn_nameptr, cnp->cn_namelen);
 912         if (error)
 913                 return (error);
 914
 915         if (*vpp) {
 916                 if (cn.cn_flags & HASBUF) {
 917                         zfree(namei_zone, cn.cn_pnbuf);
 918                         cn.cn_flags &= ~HASBUF;
 919                 }
 920                 if (dvp == *vpp)
 921                         vrele(*vpp);
 922                 else
 923                         vput(*vpp);
 924                 *vpp = NULLVP;
 925                 return (EEXIST);
 926         }
 927
 928         /*
 929          * policy: when creating the shadow directory in the
 930          * upper layer, create it owned by the user who did
 931          * the mount, group from parent directory, and mode
 932          * 777 modified by umask (ie mostly identical to the
 933          * mkdir syscall).  (jsp, kb)
 934          */
 935
 936         VATTR_NULL(&va);
 937         va.va_type = VDIR;
 938         va.va_mode = um->um_cmode;
 939
 940         /* VOP_LEASE: dvp is locked */
 941         VOP_LEASE(dvp, td, cn.cn_cred, LEASE_WRITE);
 942
 943         error = VOP_MKDIR(dvp, vpp, &cn, &va);
 944         if (cn.cn_flags & HASBUF) {
 945                 zfree(namei_zone, cn.cn_pnbuf);
 946                 cn.cn_flags &= ~HASBUF;
 947         }
 948         /*vput(dvp);*/
 949         return (error);
 950 }
 951
 952 /*
 953  * Create a whiteout entry in the upper layer.
 954  *
 955  * (um) points to the union mount structure for access to the
 956  * the mounting process's credentials.
 957  * (dvp) is the directory in which to create the whiteout.
 958  * it is locked on entry and return.
 959  * (cnp) is the componentname to be created.
 960  */
 961 int
 962 union_mkwhiteout(um, dvp, cnp, path)
 963         struct union_mount *um;
 964         struct vnode *dvp;
 965         struct componentname *cnp;
 966         char *path;
 967 {
 968         int error;
 969         struct thread *td = cnp->cn_td;
 970         struct vnode *wvp;
 971         struct componentname cn;
 972         struct ucred *cred;
 973
 974         KKASSERT(td->td_proc);
 975         cred = td->td_proc->p_ucred;
 976
 977         error = union_relookup(um, dvp, &wvp, cnp, &cn, path, strlen(path));
 978         if (error)
 979                 return (error);
 980
 981         if (wvp) {
 982                 if (cn.cn_flags & HASBUF) {
 983                         zfree(namei_zone, cn.cn_pnbuf);
 984                         cn.cn_flags &= ~HASBUF;
 985                 }
 986                 if (wvp == dvp)
 987                         vrele(wvp);
 988                 else
 989                         vput(wvp);
 990                 return (EEXIST);
 991         }
 992
 993         /* VOP_LEASE: dvp is locked */
 994         VOP_LEASE(dvp, td, cred, LEASE_WRITE);
 995
 996         error = VOP_WHITEOUT(dvp, &cn, CREATE);
 997         if (cn.cn_flags & HASBUF) {
 998                 zfree(namei_zone, cn.cn_pnbuf);
 999                 cn.cn_flags &= ~HASBUF;
1000         }
1001         return (error);
1002 }
1003
1004 /*
1005  * union_vn_create: creates and opens a new shadow file
1006  * on the upper union layer.  this function is similar
1007  * in spirit to calling vn_open but it avoids calling namei().
1008  * the problem with calling namei is that a) it locks too many
1009  * things, and b) it doesn't start at the "right" directory,
1010  * whereas relookup is told where to start.
1011  *
1012  * On entry, the vnode associated with un is locked.  It remains locked
1013  * on return.
1014  *
1015  * If no error occurs, *vpp contains a locked referenced vnode for your
1016  * use.  If an error occurs *vpp iis undefined.
1017  */
1018 static int
1019 union_vn_create(vpp, un, td)
1020         struct vnode **vpp;
1021         struct union_node *un;
1022         struct thread *td;
1023 {
1024         struct vnode *vp;
1025         struct ucred *cred;
1026         struct vattr vat;
1027         struct vattr *vap = &vat;
1028         int fmode = FFLAGS(O_WRONLY|O_CREAT|O_TRUNC|O_EXCL);
1029         int error;
1030         int cmode;
1031         struct componentname cn;
1032
1033         KKASSERT(td->td_proc);
1034         cred = td->td_proc->p_ucred;
1035         cmode = UN_FILEMODE & ~td->td_proc->p_fd->fd_cmask;
1036
1037         *vpp = NULLVP;
1038
1039         /*
1040          * Build a new componentname structure (for the same
1041          * reasons outlines in union_mkshadow).
1042          * The difference here is that the file is owned by
1043          * the current user, rather than by the person who
1044          * did the mount, since the current user needs to be
1045          * able to write the file (that's why it is being
1046          * copied in the first place).
1047          */
1048         cn.cn_namelen = strlen(un->un_path);
1049         cn.cn_pnbuf = zalloc(namei_zone);
1050         bcopy(un->un_path, cn.cn_pnbuf, cn.cn_namelen+1);
1051         cn.cn_nameiop = CREATE;
1052         cn.cn_flags = (LOCKPARENT|LOCKLEAF|HASBUF|SAVENAME|ISLASTCN);
1053         cn.cn_td = td;
1054         cn.cn_cred = cred;
1055         cn.cn_nameptr = cn.cn_pnbuf;
1056         cn.cn_consume = 0;
1057
1058         /*
1059          * Pass dvp unlocked and referenced on call to relookup().
1060          *
1061          * If an error occurs, dvp will be returned unlocked and dereferenced.
1062          */
1063         VREF(un->un_dirvp);
1064         error = relookup(un->un_dirvp, &vp, &cn);
1065         if (error)
1066                 return (error);
1067
1068         /*
1069          * If no error occurs, dvp will be returned locked with the reference
1070          * left as before, and vpp will be returned referenced and locked.
1071          */
1072         if (vp) {
1073                 vput(un->un_dirvp);
1074                 if (cn.cn_flags & HASBUF) {
1075                         zfree(namei_zone, cn.cn_pnbuf);
1076                         cn.cn_flags &= ~HASBUF;
1077                 }
1078                 if (vp == un->un_dirvp)
1079                         vrele(vp);
1080                 else
1081                         vput(vp);
1082                 return (EEXIST);
1083         }
1084
1085         /*
1086          * Good - there was no race to create the file
1087          * so go ahead and create it.  The permissions
1088          * on the file will be 0666 modified by the
1089          * current user's umask.  Access to the file, while
1090          * it is unioned, will require access to the top *and*
1091          * bottom files.  Access when not unioned will simply
1092          * require access to the top-level file.
1093          * TODO: confirm choice of access permissions.
1094          */
1095         VATTR_NULL(vap);
1096         vap->va_type = VREG;
1097         vap->va_mode = cmode;
1098         VOP_LEASE(un->un_dirvp, td, cred, LEASE_WRITE);
1099         error = VOP_CREATE(un->un_dirvp, &vp, &cn, vap);
1100         if (cn.cn_flags & HASBUF) {
1101                 zfree(namei_zone, cn.cn_pnbuf);
1102                 cn.cn_flags &= ~HASBUF;
1103         }
1104         vput(un->un_dirvp);
1105         if (error)
1106                 return (error);
1107
1108         error = VOP_OPEN(vp, fmode, cred, td);
1109         if (error == 0 && vn_canvmio(vp) == TRUE)
1110                 error = vfs_object_create(vp, td);
1111         if (error) {
1112                 vput(vp);
1113                 return (error);
1114         }
1115         vp->v_writecount++;
1116         *vpp = vp;
1117         return (0);
1118 }
1119
1120 static int
1121 union_vn_close(vp, fmode, cred, td)
1122         struct vnode *vp;
1123         int fmode;
1124         struct ucred *cred;
1125         struct thread *td;
1126 {
1127
1128         if (fmode & FWRITE)
1129                 --vp->v_writecount;
1130         return (VOP_CLOSE(vp, fmode, td));
1131 }
1132
1133 #if 0
1134
1135 /*
1136  *      union_removed_upper:
1137  *
1138  *      called with union_node unlocked. XXX
1139  */
1140
1141 void
1142 union_removed_upper(struct union_node *un)
1143 {
1144         struct thread *td = curthread;  /* XXX */
1145         struct vnode **vpp;
1146
1147         /*
1148          * Do not set the uppervp to NULLVP.  If lowervp is NULLVP,
1149          * union node will have neither uppervp nor lowervp.  We remove
1150          * the union node from cache, so that it will not be referrenced.
1151          */
1152         union_newupper(un, NULLVP);
1153         if (un->un_dircache != 0) {
1154                 for (vpp = un->un_dircache; *vpp != NULLVP; vpp++)
1155                         vrele(*vpp);
1156                 free(un->un_dircache, M_TEMP);
1157                 un->un_dircache = 0;
1158         }
1159
1160         if (un->un_flags & UN_CACHED) {
1161                 un->un_flags &= ~UN_CACHED;
1162                 LIST_REMOVE(un, un_cache);
1163         }
1164 }
1165
1166 #endif
1167
1168 /*
1169  * determine whether a whiteout is needed
1170  * during a remove/rmdir operation.
1171  */
1172 int
1173 union_dowhiteout(struct union_node *un, struct ucred *cred, struct thread *td)
1174 {
1175         struct vattr va;
1176
1177         if (un->un_lowervp != NULLVP)
1178                 return (1);
1179
1180         if (VOP_GETATTR(un->un_uppervp, &va, td) == 0 &&
1181             (va.va_flags & OPAQUE))
1182                 return (1);
1183
1184         return (0);
1185 }
1186
1187 static void
1188 union_dircache_r(vp, vppp, cntp)
1189         struct vnode *vp;
1190         struct vnode ***vppp;
1191         int *cntp;
1192 {
1193         struct union_node *un;
1194
1195         if (vp->v_op != union_vnodeop_p) {
1196                 if (vppp) {
1197                         VREF(vp);
1198                         *(*vppp)++ = vp;
1199                         if (--(*cntp) == 0)
1200                                 panic("union: dircache table too small");
1201                 } else {
1202                         (*cntp)++;
1203                 }
1204
1205                 return;
1206         }
1207
1208         un = VTOUNION(vp);
1209         if (un->un_uppervp != NULLVP)
1210                 union_dircache_r(un->un_uppervp, vppp, cntp);
1211         if (un->un_lowervp != NULLVP)
1212                 union_dircache_r(un->un_lowervp, vppp, cntp);
1213 }
1214
1215 struct vnode *
1216 union_dircache(struct vnode *vp, struct thread *td)
1217 {
1218         int cnt;
1219         struct vnode *nvp;
1220         struct vnode **vpp;
1221         struct vnode **dircache;
1222         struct union_node *un;
1223         int error;
1224
1225         vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
1226         dircache = VTOUNION(vp)->un_dircache;
1227
1228         nvp = NULLVP;
1229
1230         if (dircache == NULL) {
1231                 cnt = 0;
1232                 union_dircache_r(vp, 0, &cnt);
1233                 cnt++;
1234                 dircache = malloc(cnt * sizeof(struct vnode *),
1235                                 M_TEMP, M_WAITOK);
1236                 vpp = dircache;
1237                 union_dircache_r(vp, &vpp, &cnt);
1238                 *vpp = NULLVP;
1239                 vpp = dircache + 1;
1240         } else {
1241                 vpp = dircache;
1242                 do {
1243                         if (*vpp++ == VTOUNION(vp)->un_uppervp)
1244                                 break;
1245                 } while (*vpp != NULLVP);
1246         }
1247
1248         if (*vpp == NULLVP)
1249                 goto out;
1250
1251         /*vn_lock(*vpp, LK_EXCLUSIVE | LK_RETRY, td);*/
1252         UDEBUG(("ALLOCVP-3 %p ref %d\n", *vpp, (*vpp ? (*vpp)->v_usecount : -99)));
1253         VREF(*vpp);
1254         error = union_allocvp(&nvp, vp->v_mount, NULLVP, NULLVP, NULL, *vpp, NULLVP, 0);
1255         UDEBUG(("ALLOCVP-3B %p ref %d\n", nvp, (*vpp ? (*vpp)->v_usecount : -99)));
1256         if (error)
1257                 goto out;
1258
1259         VTOUNION(vp)->un_dircache = 0;
1260         un = VTOUNION(nvp);
1261         un->un_dircache = dircache;
1262
1263 out:
1264         VOP_UNLOCK(vp, 0, td);
1265         return (nvp);
1266 }
1267
1268 /*
1269  * Guarentee coherency with the VM cache by invalidating any clean VM pages
1270  * associated with this write and updating any dirty VM pages.  Since our
1271  * vnode is locked, other processes will not be able to read the pages in
1272  * again until after our write completes.
1273  *
1274  * We also have to be coherent with reads, by flushing any pending dirty
1275  * pages prior to issuing the read.
1276  *
1277  * XXX this is somewhat of a hack at the moment.  To support this properly
1278  * we would have to be able to run VOP_READ and VOP_WRITE through the VM
1279  * cache.  Then we wouldn't need to worry about coherency.
1280  */
1281
1282 void
1283 union_vm_coherency(struct vnode *vp, struct uio *uio, int cleanfls)
1284 {
1285         vm_object_t object;
1286         vm_pindex_t pstart;
1287         vm_pindex_t pend;
1288         int pgoff;
1289
1290         if ((object = vp->v_object) == NULL)
1291             return;
1292
1293         pgoff = uio->uio_offset & PAGE_MASK;
1294         pstart = uio->uio_offset / PAGE_SIZE;
1295         pend = pstart + (uio->uio_resid + pgoff + PAGE_MASK) / PAGE_SIZE;
1296
1297         vm_object_page_clean(object, pstart, pend, OBJPC_SYNC);
1298         if (cleanfls)
1299                 vm_object_page_remove(object, pstart, pend, TRUE);
1300 }
1301
1302 /*
1303  * Module glue to remove #ifdef UNION from vfs_syscalls.c
1304  */
1305 static int
1306 union_dircheck(struct thread *td, struct vnode **vp, struct file *fp)
1307 {
1308         int error = 0;
1309
1310         if ((*vp)->v_op == union_vnodeop_p) {
1311                 struct vnode *lvp;
1312
1313                 lvp = union_dircache(*vp, td);
1314                 if (lvp != NULLVP) {
1315                         struct vattr va;
1316
1317                         /*
1318                          * If the directory is opaque,
1319                          * then don't show lower entries
1320                          */
1321                         error = VOP_GETATTR(*vp, &va, td);
1322                         if (va.va_flags & OPAQUE) {
1323                                 vput(lvp);
1324                                 lvp = NULL;
1325                         }
1326                 }
1327
1328                 if (lvp != NULLVP) {
1329                         error = VOP_OPEN(lvp, FREAD, fp->f_cred, td);
1330                         if (error == 0 && vn_canvmio(lvp) == TRUE)
1331                                 error = vfs_object_create(lvp, td);
1332                         if (error) {
1333                                 vput(lvp);
1334                                 return (error);
1335                         }
1336                         VOP_UNLOCK(lvp, 0, td);
1337                         fp->f_data = (caddr_t) lvp;
1338                         fp->f_offset = 0;
1339                         error = vn_close(*vp, FREAD, td);
1340                         if (error)
1341                                 return (error);
1342                         *vp = lvp;
1343                         return -1;      /* goto unionread */
1344                 }
1345         }
1346         return error;
1347 }
1348
1349 static int
1350 union_modevent(module_t mod, int type, void *data)
1351 {
1352         switch (type) {
1353         case MOD_LOAD:
1354                 union_dircheckp = union_dircheck;
1355                 break;
1356         case MOD_UNLOAD:
1357                 union_dircheckp = NULL;
1358                 break;
1359         default:
1360                 break;
1361         }
1362         return 0;
1363 }
1364
1365 static moduledata_t union_mod = {
1366         "union_dircheck",
1367         union_modevent,
1368         NULL
1369 };
1370
1371 DECLARE_MODULE(union_dircheck, union_mod, SI_SUB_VFS, SI_ORDER_ANY);