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