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