__P()!=wanted, remove old style prototypes from the vfs subtree
[dragonfly.git] / sys / vfs / union / union_subr.c
CommitLineData
984263bc
MD
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 $
a6ee311a 39 * $DragonFly: src/sys/vfs/union/union_subr.c,v 1.7 2003/08/20 09:56:34 rob Exp $
984263bc
MD
40 */
41
42#include <sys/param.h>
43#include <sys/systm.h>
44#include <sys/kernel.h>
45#include <sys/vnode.h>
dadab5e9 46#include <sys/proc.h>
984263bc
MD
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 */
1f2de5d4 59#include "union.h"
984263bc 60
a6ee311a 61extern int union_init (void);
984263bc
MD
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
70static LIST_HEAD(unhead, union_node) unhead[NHASH];
71static int unvplock[NHASH];
72
a6ee311a
RG
73static void union_dircache_r (struct vnode *vp, struct vnode ***vppp,
74 int *cntp);
75static int union_list_lock (int ix);
76static void union_list_unlock (int ix);
77static int union_relookup (struct union_mount *um, struct vnode *dvp,
984263bc
MD
78 struct vnode **vpp,
79 struct componentname *cnp,
80 struct componentname *cn, char *path,
a6ee311a
RG
81 int pathlen);
82static void union_updatevp (struct union_node *un,
984263bc 83 struct vnode *uppervp,
a6ee311a
RG
84 struct vnode *lowervp);
85static void union_newlower (struct union_node *, struct vnode *);
86static void union_newupper (struct union_node *, struct vnode *);
87static int union_copyfile (struct vnode *, struct vnode *,
88 struct ucred *, struct thread *);
89static int union_vn_create (struct vnode **, struct union_node *,
90 struct thread *);
91static int union_vn_close (struct vnode *, int, struct ucred *,
92 struct thread *);
984263bc
MD
93
94int
95union_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
105static int
106union_list_lock(ix)
107 int ix;
108{
109 if (unvplock[ix] & UNVP_LOCKED) {
110 unvplock[ix] |= UNVP_WANT;
377d4740 111 (void) tsleep((caddr_t) &unvplock[ix], 0, "unllck", 0);
984263bc
MD
112 return (1);
113 }
114 unvplock[ix] |= UNVP_LOCKED;
115 return (0);
116}
117
118static void
119union_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
141static void
142union_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
214static void
215union_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
228static void
229union_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 */
241void
242union_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
333int
334union_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);
dadab5e9 347 struct thread *td = (cnp) ? cnp->cn_td : curthread; /* XXX */
984263bc
MD
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
372loop:
373 if (!docache) {
374 un = 0;
375 } else for (try = 0; try < 3; try++) {
376 switch (try) {
377 case 0:
378 if (lowervp == NULLVP)
379 continue;
380 hash = UNION_HASH(uppervp, lowervp);
381 break;
382
383 case 1:
384 if (uppervp == NULLVP)
385 continue;
386 hash = UNION_HASH(uppervp, NULLVP);
387 break;
388
389 case 2:
390 if (lowervp == NULLVP)
391 continue;
392 hash = UNION_HASH(NULLVP, lowervp);
393 break;
394 }
395
396 while (union_list_lock(hash))
397 continue;
398
399 for (un = unhead[hash].lh_first; un != 0;
400 un = un->un_cache.le_next) {
401 if ((un->un_lowervp == lowervp ||
402 un->un_lowervp == NULLVP) &&
403 (un->un_uppervp == uppervp ||
404 un->un_uppervp == NULLVP) &&
405 (UNIONTOV(un)->v_mount == mp)) {
406 if (vget(UNIONTOV(un), 0,
dadab5e9 407 cnp ? cnp->cn_td : NULL)) {
984263bc
MD
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);
dadab5e9
MD
447 VOP_UNLOCK(dvp, 0, td);
448 error = vn_lock(un->un_vnode, LK_EXCLUSIVE, td);
449 vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY, td);
984263bc
MD
450 vrele(dvp);
451 } else {
452 /*
453 * our new un is under dvp
454 */
dadab5e9 455 error = vn_lock(un->un_vnode, LK_EXCLUSIVE, td);
984263bc
MD
456 }
457 } else if (dvp == NULLVP) {
458 /*
459 * dvp is NULL, we need to lock un.
460 */
dadab5e9 461 error = vn_lock(un->un_vnode, LK_EXCLUSIVE, td);
984263bc
MD
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
377d4740 569 lockinit(&un->un_lock, 0, "unlock", VLKTIMEOUT, 0);
dadab5e9 570 vn_lock(*vpp, LK_EXCLUSIVE | LK_RETRY, td);
984263bc
MD
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
598out:
599 if (docache)
600 union_list_unlock(hash);
601
602 return (error);
603}
604
605int
606union_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 */
651static int
dadab5e9 652union_copyfile(fvp, tvp, cred, td)
984263bc
MD
653 struct vnode *fvp;
654 struct vnode *tvp;
655 struct ucred *cred;
dadab5e9 656 struct thread *td;
984263bc
MD
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
dadab5e9 673 uio.uio_td = td;
984263bc
MD
674 uio.uio_segflg = UIO_SYSSPACE;
675 uio.uio_offset = 0;
676
dadab5e9
MD
677 VOP_LEASE(fvp, td, cred, LEASE_READ);
678 VOP_LEASE(tvp, td, cred, LEASE_WRITE);
984263bc
MD
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
738int
dadab5e9 739union_copyup(un, docopy, cred, td)
984263bc
MD
740 struct union_node *un;
741 int docopy;
742 struct ucred *cred;
dadab5e9 743 struct thread *td;
984263bc
MD
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 */
dadab5e9
MD
752 vn_lock(un->un_lowervp, LK_EXCLUSIVE | LK_RETRY, td);
753 error = VOP_ACCESS(un->un_lowervp, VREAD, cred, td);
754 VOP_UNLOCK(un->un_lowervp, 0, td);
984263bc
MD
755 if (error)
756 return (error);
757
dadab5e9 758 error = union_vn_create(&uvp, un, td);
984263bc
MD
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 */
dadab5e9
MD
770 vn_lock(lvp, LK_EXCLUSIVE | LK_RETRY, td);
771 error = VOP_OPEN(lvp, FREAD, cred, td);
984263bc 772 if (error == 0 && vn_canvmio(lvp) == TRUE)
3b568787 773 error = vfs_object_create(lvp, td);
984263bc 774 if (error == 0) {
dadab5e9
MD
775 error = union_copyfile(lvp, uvp, cred, td);
776 VOP_UNLOCK(lvp, 0, td);
3b568787 777 (void) VOP_CLOSE(lvp, FREAD, td);
984263bc
MD
778 }
779 if (error == 0)
780 UDEBUG(("union: copied up %s\n", un->un_path));
781
782 }
dadab5e9 783 VOP_UNLOCK(uvp, 0, td);
984263bc
MD
784 union_newupper(un, uvp);
785 KASSERT(uvp->v_usecount > 0, ("copy: uvp refcount 0: %d", uvp->v_usecount));
dadab5e9 786 union_vn_close(uvp, FWRITE, cred, td);
984263bc
MD
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++) {
3b568787 800 (void) VOP_CLOSE(lvp, FREAD, td);
dadab5e9 801 (void) VOP_OPEN(uvp, FREAD, cred, td);
984263bc
MD
802 }
803 if (un->un_openl) {
804 if (vn_canvmio(uvp) == TRUE)
3b568787 805 error = vfs_object_create(uvp, td);
984263bc
MD
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
825static int
826union_relookup(um, dvp, vpp, cnp, cn, path, pathlen)
827 struct union_mount *um;
828 struct vnode *dvp;
829 struct vnode **vpp;
830 struct componentname *cnp;
831 struct componentname *cn;
832 char *path;
833 int pathlen;
834{
835 int error;
836
837 /*
838 * A new componentname structure must be faked up because
839 * there is no way to know where the upper level cnp came
840 * from or what it is being used for. This must duplicate
841 * some of the work done by NDINIT, some of the work done
842 * by namei, some of the work done by lookup and some of
843 * the work done by VOP_LOOKUP when given a CREATE flag.
844 * Conclusion: Horrible.
845 */
846 cn->cn_namelen = pathlen;
847 cn->cn_pnbuf = zalloc(namei_zone);
848 bcopy(path, cn->cn_pnbuf, cn->cn_namelen);
849 cn->cn_pnbuf[cn->cn_namelen] = '\0';
850
851 cn->cn_nameiop = CREATE;
852 cn->cn_flags = (LOCKPARENT|LOCKLEAF|HASBUF|SAVENAME|ISLASTCN);
dadab5e9 853 cn->cn_td = cnp->cn_td;
984263bc
MD
854 if (um->um_op == UNMNT_ABOVE)
855 cn->cn_cred = cnp->cn_cred;
856 else
857 cn->cn_cred = um->um_cred;
858 cn->cn_nameptr = cn->cn_pnbuf;
859 cn->cn_consume = cnp->cn_consume;
860
861 VREF(dvp);
dadab5e9 862 VOP_UNLOCK(dvp, 0, cnp->cn_td);
984263bc
MD
863
864 /*
865 * Pass dvp unlocked and referenced on call to relookup().
866 *
867 * If an error occurs, dvp will be returned unlocked and dereferenced.
868 */
869
870 if ((error = relookup(dvp, vpp, cn)) != 0) {
dadab5e9 871 vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY, cnp->cn_td);
984263bc
MD
872 return(error);
873 }
874
875 /*
876 * If no error occurs, dvp will be returned locked with the reference
877 * left as before, and vpp will be returned referenced and locked.
878 *
879 * We want to return with dvp as it was passed to us, so we get
880 * rid of our reference.
881 */
882 vrele(dvp);
883 return (0);
884}
885
886/*
887 * Create a shadow directory in the upper layer.
888 * The new vnode is returned locked.
889 *
890 * (um) points to the union mount structure for access to the
891 * the mounting process's credentials.
892 * (dvp) is the directory in which to create the shadow directory,
893 * it is locked (but not ref'd) on entry and return.
894 * (cnp) is the componentname to be created.
895 * (vpp) is the returned newly created shadow directory, which
896 * is returned locked and ref'd
897 */
898int
899union_mkshadow(um, dvp, cnp, vpp)
900 struct union_mount *um;
901 struct vnode *dvp;
902 struct componentname *cnp;
903 struct vnode **vpp;
904{
905 int error;
906 struct vattr va;
dadab5e9 907 struct thread *td = cnp->cn_td;
984263bc
MD
908 struct componentname cn;
909
910 error = union_relookup(um, dvp, vpp, cnp, &cn,
911 cnp->cn_nameptr, cnp->cn_namelen);
912 if (error)
913 return (error);
914
915 if (*vpp) {
916 if (cn.cn_flags & HASBUF) {
917 zfree(namei_zone, cn.cn_pnbuf);
918 cn.cn_flags &= ~HASBUF;
919 }
920 if (dvp == *vpp)
921 vrele(*vpp);
922 else
923 vput(*vpp);
924 *vpp = NULLVP;
925 return (EEXIST);
926 }
927
928 /*
929 * policy: when creating the shadow directory in the
930 * upper layer, create it owned by the user who did
931 * the mount, group from parent directory, and mode
932 * 777 modified by umask (ie mostly identical to the
933 * mkdir syscall). (jsp, kb)
934 */
935
936 VATTR_NULL(&va);
937 va.va_type = VDIR;
938 va.va_mode = um->um_cmode;
939
940 /* VOP_LEASE: dvp is locked */
dadab5e9 941 VOP_LEASE(dvp, td, cn.cn_cred, LEASE_WRITE);
984263bc
MD
942
943 error = VOP_MKDIR(dvp, vpp, &cn, &va);
944 if (cn.cn_flags & HASBUF) {
945 zfree(namei_zone, cn.cn_pnbuf);
946 cn.cn_flags &= ~HASBUF;
947 }
948 /*vput(dvp);*/
949 return (error);
950}
951
952/*
953 * Create a whiteout entry in the upper layer.
954 *
955 * (um) points to the union mount structure for access to the
956 * the mounting process's credentials.
957 * (dvp) is the directory in which to create the whiteout.
958 * it is locked on entry and return.
959 * (cnp) is the componentname to be created.
960 */
961int
962union_mkwhiteout(um, dvp, cnp, path)
963 struct union_mount *um;
964 struct vnode *dvp;
965 struct componentname *cnp;
966 char *path;
967{
968 int error;
dadab5e9 969 struct thread *td = cnp->cn_td;
984263bc
MD
970 struct vnode *wvp;
971 struct componentname cn;
dadab5e9
MD
972 struct ucred *cred;
973
974 KKASSERT(td->td_proc);
975 cred = td->td_proc->p_ucred;
984263bc
MD
976
977 error = union_relookup(um, dvp, &wvp, cnp, &cn, path, strlen(path));
978 if (error)
979 return (error);
980
981 if (wvp) {
982 if (cn.cn_flags & HASBUF) {
983 zfree(namei_zone, cn.cn_pnbuf);
984 cn.cn_flags &= ~HASBUF;
985 }
986 if (wvp == dvp)
987 vrele(wvp);
988 else
989 vput(wvp);
990 return (EEXIST);
991 }
992
993 /* VOP_LEASE: dvp is locked */
dadab5e9 994 VOP_LEASE(dvp, td, cred, LEASE_WRITE);
984263bc
MD
995
996 error = VOP_WHITEOUT(dvp, &cn, CREATE);
997 if (cn.cn_flags & HASBUF) {
998 zfree(namei_zone, cn.cn_pnbuf);
999 cn.cn_flags &= ~HASBUF;
1000 }
1001 return (error);
1002}
1003
1004/*
1005 * union_vn_create: creates and opens a new shadow file
1006 * on the upper union layer. this function is similar
1007 * in spirit to calling vn_open but it avoids calling namei().
1008 * the problem with calling namei is that a) it locks too many
1009 * things, and b) it doesn't start at the "right" directory,
1010 * whereas relookup is told where to start.
1011 *
1012 * On entry, the vnode associated with un is locked. It remains locked
1013 * on return.
1014 *
1015 * If no error occurs, *vpp contains a locked referenced vnode for your
1016 * use. If an error occurs *vpp iis undefined.
1017 */
1018static int
dadab5e9 1019union_vn_create(vpp, un, td)
984263bc
MD
1020 struct vnode **vpp;
1021 struct union_node *un;
dadab5e9 1022 struct thread *td;
984263bc
MD
1023{
1024 struct vnode *vp;
dadab5e9 1025 struct ucred *cred;
984263bc
MD
1026 struct vattr vat;
1027 struct vattr *vap = &vat;
1028 int fmode = FFLAGS(O_WRONLY|O_CREAT|O_TRUNC|O_EXCL);
1029 int error;
dadab5e9 1030 int cmode;
984263bc
MD
1031 struct componentname cn;
1032
dadab5e9
MD
1033 KKASSERT(td->td_proc);
1034 cred = td->td_proc->p_ucred;
1035 cmode = UN_FILEMODE & ~td->td_proc->p_fd->fd_cmask;
1036
984263bc
MD
1037 *vpp = NULLVP;
1038
1039 /*
1040 * Build a new componentname structure (for the same
1041 * reasons outlines in union_mkshadow).
1042 * The difference here is that the file is owned by
1043 * the current user, rather than by the person who
1044 * did the mount, since the current user needs to be
1045 * able to write the file (that's why it is being
1046 * copied in the first place).
1047 */
1048 cn.cn_namelen = strlen(un->un_path);
1049 cn.cn_pnbuf = zalloc(namei_zone);
1050 bcopy(un->un_path, cn.cn_pnbuf, cn.cn_namelen+1);
1051 cn.cn_nameiop = CREATE;
1052 cn.cn_flags = (LOCKPARENT|LOCKLEAF|HASBUF|SAVENAME|ISLASTCN);
dadab5e9
MD
1053 cn.cn_td = td;
1054 cn.cn_cred = cred;
984263bc
MD
1055 cn.cn_nameptr = cn.cn_pnbuf;
1056 cn.cn_consume = 0;
1057
1058 /*
1059 * Pass dvp unlocked and referenced on call to relookup().
1060 *
1061 * If an error occurs, dvp will be returned unlocked and dereferenced.
1062 */
1063 VREF(un->un_dirvp);
1064 error = relookup(un->un_dirvp, &vp, &cn);
1065 if (error)
1066 return (error);
1067
1068 /*
1069 * If no error occurs, dvp will be returned locked with the reference
1070 * left as before, and vpp will be returned referenced and locked.
1071 */
1072 if (vp) {
1073 vput(un->un_dirvp);
1074 if (cn.cn_flags & HASBUF) {
1075 zfree(namei_zone, cn.cn_pnbuf);
1076 cn.cn_flags &= ~HASBUF;
1077 }
1078 if (vp == un->un_dirvp)
1079 vrele(vp);
1080 else
1081 vput(vp);
1082 return (EEXIST);
1083 }
1084
1085 /*
1086 * Good - there was no race to create the file
1087 * so go ahead and create it. The permissions
1088 * on the file will be 0666 modified by the
1089 * current user's umask. Access to the file, while
1090 * it is unioned, will require access to the top *and*
1091 * bottom files. Access when not unioned will simply
1092 * require access to the top-level file.
1093 * TODO: confirm choice of access permissions.
1094 */
1095 VATTR_NULL(vap);
1096 vap->va_type = VREG;
1097 vap->va_mode = cmode;
dadab5e9 1098 VOP_LEASE(un->un_dirvp, td, cred, LEASE_WRITE);
984263bc
MD
1099 error = VOP_CREATE(un->un_dirvp, &vp, &cn, vap);
1100 if (cn.cn_flags & HASBUF) {
1101 zfree(namei_zone, cn.cn_pnbuf);
1102 cn.cn_flags &= ~HASBUF;
1103 }
1104 vput(un->un_dirvp);
1105 if (error)
1106 return (error);
1107
dadab5e9 1108 error = VOP_OPEN(vp, fmode, cred, td);
984263bc 1109 if (error == 0 && vn_canvmio(vp) == TRUE)
3b568787 1110 error = vfs_object_create(vp, td);
984263bc
MD
1111 if (error) {
1112 vput(vp);
1113 return (error);
1114 }
1115 vp->v_writecount++;
1116 *vpp = vp;
1117 return (0);
1118}
1119
1120static int
dadab5e9 1121union_vn_close(vp, fmode, cred, td)
984263bc
MD
1122 struct vnode *vp;
1123 int fmode;
1124 struct ucred *cred;
dadab5e9 1125 struct thread *td;
984263bc
MD
1126{
1127
1128 if (fmode & FWRITE)
1129 --vp->v_writecount;
3b568787 1130 return (VOP_CLOSE(vp, fmode, td));
984263bc
MD
1131}
1132
1133#if 0
1134
1135/*
1136 * union_removed_upper:
1137 *
1138 * called with union_node unlocked. XXX
1139 */
1140
1141void
dadab5e9 1142union_removed_upper(struct union_node *un)
984263bc 1143{
dadab5e9 1144 struct thread *td = curthread; /* XXX */
984263bc
MD
1145 struct vnode **vpp;
1146
1147 /*
1148 * Do not set the uppervp to NULLVP. If lowervp is NULLVP,
1149 * union node will have neither uppervp nor lowervp. We remove
1150 * the union node from cache, so that it will not be referrenced.
1151 */
1152 union_newupper(un, NULLVP);
1153 if (un->un_dircache != 0) {
1154 for (vpp = un->un_dircache; *vpp != NULLVP; vpp++)
1155 vrele(*vpp);
1156 free(un->un_dircache, M_TEMP);
1157 un->un_dircache = 0;
1158 }
1159
1160 if (un->un_flags & UN_CACHED) {
1161 un->un_flags &= ~UN_CACHED;
1162 LIST_REMOVE(un, un_cache);
1163 }
1164}
1165
1166#endif
1167
1168/*
1169 * determine whether a whiteout is needed
1170 * during a remove/rmdir operation.
1171 */
1172int
dadab5e9 1173union_dowhiteout(struct union_node *un, struct ucred *cred, struct thread *td)
984263bc
MD
1174{
1175 struct vattr va;
1176
1177 if (un->un_lowervp != NULLVP)
1178 return (1);
1179
3b568787 1180 if (VOP_GETATTR(un->un_uppervp, &va, td) == 0 &&
984263bc
MD
1181 (va.va_flags & OPAQUE))
1182 return (1);
1183
1184 return (0);
1185}
1186
1187static void
1188union_dircache_r(vp, vppp, cntp)
1189 struct vnode *vp;
1190 struct vnode ***vppp;
1191 int *cntp;
1192{
1193 struct union_node *un;
1194
1195 if (vp->v_op != union_vnodeop_p) {
1196 if (vppp) {
1197 VREF(vp);
1198 *(*vppp)++ = vp;
1199 if (--(*cntp) == 0)
1200 panic("union: dircache table too small");
1201 } else {
1202 (*cntp)++;
1203 }
1204
1205 return;
1206 }
1207
1208 un = VTOUNION(vp);
1209 if (un->un_uppervp != NULLVP)
1210 union_dircache_r(un->un_uppervp, vppp, cntp);
1211 if (un->un_lowervp != NULLVP)
1212 union_dircache_r(un->un_lowervp, vppp, cntp);
1213}
1214
1215struct vnode *
dadab5e9 1216union_dircache(struct vnode *vp, struct thread *td)
984263bc
MD
1217{
1218 int cnt;
1219 struct vnode *nvp;
1220 struct vnode **vpp;
1221 struct vnode **dircache;
1222 struct union_node *un;
1223 int error;
1224
dadab5e9 1225 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
984263bc
MD
1226 dircache = VTOUNION(vp)->un_dircache;
1227
1228 nvp = NULLVP;
1229
1230 if (dircache == NULL) {
1231 cnt = 0;
1232 union_dircache_r(vp, 0, &cnt);
1233 cnt++;
1234 dircache = malloc(cnt * sizeof(struct vnode *),
1235 M_TEMP, M_WAITOK);
1236 vpp = dircache;
1237 union_dircache_r(vp, &vpp, &cnt);
1238 *vpp = NULLVP;
1239 vpp = dircache + 1;
1240 } else {
1241 vpp = dircache;
1242 do {
1243 if (*vpp++ == VTOUNION(vp)->un_uppervp)
1244 break;
1245 } while (*vpp != NULLVP);
1246 }
1247
1248 if (*vpp == NULLVP)
1249 goto out;
1250
dadab5e9 1251 /*vn_lock(*vpp, LK_EXCLUSIVE | LK_RETRY, td);*/
984263bc
MD
1252 UDEBUG(("ALLOCVP-3 %p ref %d\n", *vpp, (*vpp ? (*vpp)->v_usecount : -99)));
1253 VREF(*vpp);
1254 error = union_allocvp(&nvp, vp->v_mount, NULLVP, NULLVP, NULL, *vpp, NULLVP, 0);
1255 UDEBUG(("ALLOCVP-3B %p ref %d\n", nvp, (*vpp ? (*vpp)->v_usecount : -99)));
1256 if (error)
1257 goto out;
1258
1259 VTOUNION(vp)->un_dircache = 0;
1260 un = VTOUNION(nvp);
1261 un->un_dircache = dircache;
1262
1263out:
dadab5e9 1264 VOP_UNLOCK(vp, 0, td);
984263bc
MD
1265 return (nvp);
1266}
1267
1268/*
1269 * Guarentee coherency with the VM cache by invalidating any clean VM pages
1270 * associated with this write and updating any dirty VM pages. Since our
1271 * vnode is locked, other processes will not be able to read the pages in
1272 * again until after our write completes.
1273 *
1274 * We also have to be coherent with reads, by flushing any pending dirty
1275 * pages prior to issuing the read.
1276 *
1277 * XXX this is somewhat of a hack at the moment. To support this properly
1278 * we would have to be able to run VOP_READ and VOP_WRITE through the VM
1279 * cache. Then we wouldn't need to worry about coherency.
1280 */
1281
1282void
1283union_vm_coherency(struct vnode *vp, struct uio *uio, int cleanfls)
1284{
1285 vm_object_t object;
1286 vm_pindex_t pstart;
1287 vm_pindex_t pend;
1288 int pgoff;
1289
1290 if ((object = vp->v_object) == NULL)
1291 return;
1292
1293 pgoff = uio->uio_offset & PAGE_MASK;
1294 pstart = uio->uio_offset / PAGE_SIZE;
1295 pend = pstart + (uio->uio_resid + pgoff + PAGE_MASK) / PAGE_SIZE;
1296
1297 vm_object_page_clean(object, pstart, pend, OBJPC_SYNC);
1298 if (cleanfls)
1299 vm_object_page_remove(object, pstart, pend, TRUE);
1300}
1301
1302/*
1303 * Module glue to remove #ifdef UNION from vfs_syscalls.c
1304 */
1305static int
dadab5e9 1306union_dircheck(struct thread *td, struct vnode **vp, struct file *fp)
984263bc
MD
1307{
1308 int error = 0;
1309
1310 if ((*vp)->v_op == union_vnodeop_p) {
1311 struct vnode *lvp;
1312
dadab5e9 1313 lvp = union_dircache(*vp, td);
984263bc
MD
1314 if (lvp != NULLVP) {
1315 struct vattr va;
1316
1317 /*
1318 * If the directory is opaque,
1319 * then don't show lower entries
1320 */
3b568787 1321 error = VOP_GETATTR(*vp, &va, td);
984263bc
MD
1322 if (va.va_flags & OPAQUE) {
1323 vput(lvp);
1324 lvp = NULL;
1325 }
1326 }
1327
1328 if (lvp != NULLVP) {
dadab5e9 1329 error = VOP_OPEN(lvp, FREAD, fp->f_cred, td);
984263bc 1330 if (error == 0 && vn_canvmio(lvp) == TRUE)
3b568787 1331 error = vfs_object_create(lvp, td);
984263bc
MD
1332 if (error) {
1333 vput(lvp);
1334 return (error);
1335 }
dadab5e9 1336 VOP_UNLOCK(lvp, 0, td);
984263bc
MD
1337 fp->f_data = (caddr_t) lvp;
1338 fp->f_offset = 0;
3b568787 1339 error = vn_close(*vp, FREAD, td);
984263bc
MD
1340 if (error)
1341 return (error);
1342 *vp = lvp;
1343 return -1; /* goto unionread */
1344 }
1345 }
1346 return error;
1347}
1348
1349static int
1350union_modevent(module_t mod, int type, void *data)
1351{
1352 switch (type) {
1353 case MOD_LOAD:
1354 union_dircheckp = union_dircheck;
1355 break;
1356 case MOD_UNLOAD:
1357 union_dircheckp = NULL;
1358 break;
1359 default:
1360 break;
1361 }
1362 return 0;
1363}
1364
1365static moduledata_t union_mod = {
1366 "union_dircheck",
1367 union_modevent,
1368 NULL
1369};
1370
1371DECLARE_MODULE(union_dircheck, union_mod, SI_SUB_VFS, SI_ORDER_ANY);