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