VFS messaging/interfacing work stage 1/99. This stage replaces the old
[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 $
2d3e977e 39 * $DragonFly: src/sys/vfs/union/union_subr.c,v 1.13 2004/08/13 17:51:14 dillon 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
262679fc 95union_init(void)
984263bc
MD
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
262679fc 106union_list_lock(int ix)
984263bc
MD
107{
108 if (unvplock[ix] & UNVP_LOCKED) {
109 unvplock[ix] |= UNVP_WANT;
377d4740 110 (void) tsleep((caddr_t) &unvplock[ix], 0, "unllck", 0);
984263bc
MD
111 return (1);
112 }
113 unvplock[ix] |= UNVP_LOCKED;
114 return (0);
115}
116
117static void
262679fc 118union_list_unlock(int ix)
984263bc
MD
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
139static void
262679fc
CP
140union_updatevp(struct union_node *un, struct vnode *uppervp,
141 struct vnode *lowervp)
984263bc
MD
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
210static void
262679fc 211union_newlower(struct union_node *un, struct vnode *lowervp)
984263bc
MD
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
222static void
262679fc 223union_newupper(struct union_node *un, struct vnode *uppervp)
984263bc
MD
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 */
233void
262679fc 234union_newsize(struct vnode *vp, off_t uppersz, off_t lowersz)
984263bc
MD
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
323int
262679fc
CP
324union_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)
984263bc
MD
332{
333 int error;
334 struct union_node *un = 0;
335 struct union_mount *um = MOUNTTOUNIONMOUNT(mp);
dadab5e9 336 struct thread *td = (cnp) ? cnp->cn_td : curthread; /* XXX */
984263bc
MD
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)
597aea93 356 vref(lowervp);
984263bc
MD
357 }
358 vflag = VROOT;
359 }
360
361loop:
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)) {
41a01a4d 395 if (vget(UNIONTOV(un), NULL, 0,
dadab5e9 396 cnp ? cnp->cn_td : NULL)) {
984263bc
MD
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 */
597aea93 435 vref(dvp);
41a01a4d
MD
436 VOP_UNLOCK(dvp, NULL, 0, td);
437 error = vn_lock(un->un_vnode, NULL, LK_EXCLUSIVE, td);
438 vn_lock(dvp, NULL, LK_EXCLUSIVE | LK_RETRY, td);
984263bc
MD
439 vrele(dvp);
440 } else {
441 /*
442 * our new un is under dvp
443 */
41a01a4d 444 error = vn_lock(un->un_vnode, NULL, LK_EXCLUSIVE, td);
984263bc
MD
445 }
446 } else if (dvp == NULLVP) {
447 /*
448 * dvp is NULL, we need to lock un.
449 */
41a01a4d 450 error = vn_lock(un->un_vnode, NULL, LK_EXCLUSIVE, td);
984263bc
MD
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
2d3e977e 531 error = getnewvnode(VT_UNION, mp, union_vnode_vops, vpp);
984263bc
MD
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
377d4740 558 lockinit(&un->un_lock, 0, "unlock", VLKTIMEOUT, 0);
41a01a4d 559 vn_lock(*vpp, NULL, LK_EXCLUSIVE | LK_RETRY, td);
984263bc
MD
560
561 un->un_vnode = *vpp;
562 un->un_uppervp = uppervp;
563 un->un_uppersz = VNOVAL;
564 un->un_lowervp = lowervp;
565 un->un_lowersz = VNOVAL;
566 un->un_dirvp = upperdvp;
567 un->un_pvp = dvp; /* only parent dir in new allocation */
568 if (dvp != NULLVP)
597aea93 569 vref(dvp);
984263bc
MD
570 un->un_dircache = 0;
571 un->un_openl = 0;
572
573 if (cnp && (lowervp != NULLVP)) {
574 un->un_path = malloc(cnp->cn_namelen+1, M_TEMP, M_WAITOK);
575 bcopy(cnp->cn_nameptr, un->un_path, cnp->cn_namelen);
576 un->un_path[cnp->cn_namelen] = '\0';
577 } else {
578 un->un_path = 0;
579 un->un_dirvp = NULL;
580 }
581
582 if (docache) {
583 LIST_INSERT_HEAD(&unhead[hash], un, un_cache);
584 un->un_flags |= UN_CACHED;
585 }
586
587out:
588 if (docache)
589 union_list_unlock(hash);
590
591 return (error);
592}
593
594int
262679fc 595union_freevp(struct vnode *vp)
984263bc
MD
596{
597 struct union_node *un = VTOUNION(vp);
598
599 if (un->un_flags & UN_CACHED) {
600 un->un_flags &= ~UN_CACHED;
601 LIST_REMOVE(un, un_cache);
602 }
603
604 if (un->un_pvp != NULLVP) {
605 vrele(un->un_pvp);
606 un->un_pvp = NULL;
607 }
608 if (un->un_uppervp != NULLVP) {
609 vrele(un->un_uppervp);
610 un->un_uppervp = NULL;
611 }
612 if (un->un_lowervp != NULLVP) {
613 vrele(un->un_lowervp);
614 un->un_lowervp = NULL;
615 }
616 if (un->un_dirvp != NULLVP) {
617 vrele(un->un_dirvp);
618 un->un_dirvp = NULL;
619 }
620 if (un->un_path) {
621 free(un->un_path, M_TEMP);
622 un->un_path = NULL;
623 }
624
625 FREE(vp->v_data, M_TEMP);
626 vp->v_data = 0;
627
628 return (0);
629}
630
631/*
632 * copyfile. copy the vnode (fvp) to the vnode (tvp)
633 * using a sequence of reads and writes. both (fvp)
634 * and (tvp) are locked on entry and exit.
635 *
636 * fvp and tvp are both exclusive locked on call, but their refcount's
637 * haven't been bumped at all.
638 */
639static int
262679fc
CP
640union_copyfile(struct vnode *fvp, struct vnode *tvp, struct ucred *cred,
641 struct thread *td)
984263bc
MD
642{
643 char *buf;
644 struct uio uio;
645 struct iovec iov;
646 int error = 0;
647
648 /*
649 * strategy:
650 * allocate a buffer of size MAXBSIZE.
651 * loop doing reads and writes, keeping track
652 * of the current uio offset.
653 * give up at the first sign of trouble.
654 */
655
656 bzero(&uio, sizeof(uio));
657
dadab5e9 658 uio.uio_td = td;
984263bc
MD
659 uio.uio_segflg = UIO_SYSSPACE;
660 uio.uio_offset = 0;
661
dadab5e9
MD
662 VOP_LEASE(fvp, td, cred, LEASE_READ);
663 VOP_LEASE(tvp, td, cred, LEASE_WRITE);
984263bc
MD
664
665 buf = malloc(MAXBSIZE, M_TEMP, M_WAITOK);
666
667 /* ugly loop follows... */
668 do {
669 off_t offset = uio.uio_offset;
670 int count;
671 int bufoffset;
672
673 /*
674 * Setup for big read
675 */
676 uio.uio_iov = &iov;
677 uio.uio_iovcnt = 1;
678 iov.iov_base = buf;
679 iov.iov_len = MAXBSIZE;
680 uio.uio_resid = iov.iov_len;
681 uio.uio_rw = UIO_READ;
682
683 if ((error = VOP_READ(fvp, &uio, 0, cred)) != 0)
684 break;
685
686 /*
687 * Get bytes read, handle read eof case and setup for
688 * write loop
689 */
690 if ((count = MAXBSIZE - uio.uio_resid) == 0)
691 break;
692 bufoffset = 0;
693
694 /*
695 * Write until an error occurs or our buffer has been
696 * exhausted, then update the offset for the next read.
697 */
698 while (bufoffset < count) {
699 uio.uio_iov = &iov;
700 uio.uio_iovcnt = 1;
701 iov.iov_base = buf + bufoffset;
702 iov.iov_len = count - bufoffset;
703 uio.uio_offset = offset + bufoffset;
704 uio.uio_rw = UIO_WRITE;
705 uio.uio_resid = iov.iov_len;
706
707 if ((error = VOP_WRITE(tvp, &uio, 0, cred)) != 0)
708 break;
709 bufoffset += (count - bufoffset) - uio.uio_resid;
710 }
711 uio.uio_offset = offset + bufoffset;
712 } while (error == 0);
713
714 free(buf, M_TEMP);
715 return (error);
716}
717
718/*
719 *
720 * un's vnode is assumed to be locked on entry and remains locked on exit.
721 */
722
723int
262679fc
CP
724union_copyup(struct union_node *un, int docopy, struct ucred *cred,
725 struct thread *td)
984263bc
MD
726{
727 int error;
728 struct vnode *lvp, *uvp;
729
730 /*
731 * If the user does not have read permission, the vnode should not
732 * be copied to upper layer.
733 */
41a01a4d 734 vn_lock(un->un_lowervp, NULL, LK_EXCLUSIVE | LK_RETRY, td);
dadab5e9 735 error = VOP_ACCESS(un->un_lowervp, VREAD, cred, td);
41a01a4d 736 VOP_UNLOCK(un->un_lowervp, NULL, 0, td);
984263bc
MD
737 if (error)
738 return (error);
739
dadab5e9 740 error = union_vn_create(&uvp, un, td);
984263bc
MD
741 if (error)
742 return (error);
743
744 lvp = un->un_lowervp;
745
746 KASSERT(uvp->v_usecount > 0, ("copy: uvp refcount 0: %d", uvp->v_usecount));
747 if (docopy) {
748 /*
749 * XX - should not ignore errors
750 * from VOP_CLOSE
751 */
41a01a4d 752 vn_lock(lvp, NULL, LK_EXCLUSIVE | LK_RETRY, td);
dadab5e9 753 error = VOP_OPEN(lvp, FREAD, cred, td);
984263bc 754 if (error == 0 && vn_canvmio(lvp) == TRUE)
3b568787 755 error = vfs_object_create(lvp, td);
984263bc 756 if (error == 0) {
dadab5e9 757 error = union_copyfile(lvp, uvp, cred, td);
41a01a4d 758 VOP_UNLOCK(lvp, NULL, 0, td);
3b568787 759 (void) VOP_CLOSE(lvp, FREAD, td);
984263bc
MD
760 }
761 if (error == 0)
762 UDEBUG(("union: copied up %s\n", un->un_path));
763
764 }
41a01a4d 765 VOP_UNLOCK(uvp, NULL, 0, td);
984263bc
MD
766 union_newupper(un, uvp);
767 KASSERT(uvp->v_usecount > 0, ("copy: uvp refcount 0: %d", uvp->v_usecount));
dadab5e9 768 union_vn_close(uvp, FWRITE, cred, td);
984263bc
MD
769 KASSERT(uvp->v_usecount > 0, ("copy: uvp refcount 0: %d", uvp->v_usecount));
770 /*
771 * Subsequent IOs will go to the top layer, so
772 * call close on the lower vnode and open on the
773 * upper vnode to ensure that the filesystem keeps
774 * its references counts right. This doesn't do
775 * the right thing with (cred) and (FREAD) though.
776 * Ignoring error returns is not right, either.
777 */
778 if (error == 0) {
779 int i;
780
781 for (i = 0; i < un->un_openl; i++) {
3b568787 782 (void) VOP_CLOSE(lvp, FREAD, td);
dadab5e9 783 (void) VOP_OPEN(uvp, FREAD, cred, td);
984263bc
MD
784 }
785 if (un->un_openl) {
786 if (vn_canvmio(uvp) == TRUE)
3b568787 787 error = vfs_object_create(uvp, td);
984263bc
MD
788 }
789 un->un_openl = 0;
790 }
791
792 return (error);
793
794}
795
796/*
797 * union_relookup:
798 *
799 * dvp should be locked on entry and will be locked on return. No
800 * net change in the ref count will occur.
801 *
802 * If an error is returned, *vpp will be invalid, otherwise it
803 * will hold a locked, referenced vnode. If *vpp == dvp then
804 * remember that only one exclusive lock is held.
805 */
806
807static int
262679fc
CP
808union_relookup(struct union_mount *um, struct vnode *dvp, struct vnode **vpp,
809 struct componentname *cnp, struct componentname *cn, char *path,
810 int pathlen)
984263bc
MD
811{
812 int error;
813
814 /*
815 * A new componentname structure must be faked up because
816 * there is no way to know where the upper level cnp came
817 * from or what it is being used for. This must duplicate
818 * some of the work done by NDINIT, some of the work done
819 * by namei, some of the work done by lookup and some of
820 * the work done by VOP_LOOKUP when given a CREATE flag.
821 * Conclusion: Horrible.
822 */
823 cn->cn_namelen = pathlen;
824 cn->cn_pnbuf = zalloc(namei_zone);
825 bcopy(path, cn->cn_pnbuf, cn->cn_namelen);
826 cn->cn_pnbuf[cn->cn_namelen] = '\0';
827
2b69e610
MD
828 cn->cn_nameiop = NAMEI_CREATE;
829 cn->cn_flags = (CNP_LOCKPARENT | CNP_LOCKLEAF | CNP_HASBUF |
830 CNP_SAVENAME | CNP_ISLASTCN);
dadab5e9 831 cn->cn_td = cnp->cn_td;
984263bc
MD
832 if (um->um_op == UNMNT_ABOVE)
833 cn->cn_cred = cnp->cn_cred;
834 else
835 cn->cn_cred = um->um_cred;
836 cn->cn_nameptr = cn->cn_pnbuf;
837 cn->cn_consume = cnp->cn_consume;
838
597aea93 839 vref(dvp);
41a01a4d 840 VOP_UNLOCK(dvp, NULL, 0, cnp->cn_td);
984263bc
MD
841
842 /*
843 * Pass dvp unlocked and referenced on call to relookup().
844 *
845 * If an error occurs, dvp will be returned unlocked and dereferenced.
846 */
847
848 if ((error = relookup(dvp, vpp, cn)) != 0) {
41a01a4d 849 vn_lock(dvp, NULL, LK_EXCLUSIVE | LK_RETRY, cnp->cn_td);
984263bc
MD
850 return(error);
851 }
852
853 /*
854 * If no error occurs, dvp will be returned locked with the reference
855 * left as before, and vpp will be returned referenced and locked.
856 *
857 * We want to return with dvp as it was passed to us, so we get
858 * rid of our reference.
859 */
860 vrele(dvp);
861 return (0);
862}
863
864/*
865 * Create a shadow directory in the upper layer.
866 * The new vnode is returned locked.
867 *
868 * (um) points to the union mount structure for access to the
869 * the mounting process's credentials.
870 * (dvp) is the directory in which to create the shadow directory,
871 * it is locked (but not ref'd) on entry and return.
872 * (cnp) is the componentname to be created.
873 * (vpp) is the returned newly created shadow directory, which
874 * is returned locked and ref'd
875 */
876int
262679fc
CP
877union_mkshadow(struct union_mount *um, struct vnode *dvp,
878 struct componentname *cnp, struct vnode **vpp)
984263bc
MD
879{
880 int error;
881 struct vattr va;
dadab5e9 882 struct thread *td = cnp->cn_td;
984263bc
MD
883 struct componentname cn;
884
885 error = union_relookup(um, dvp, vpp, cnp, &cn,
886 cnp->cn_nameptr, cnp->cn_namelen);
887 if (error)
888 return (error);
889
890 if (*vpp) {
2b69e610 891 if (cn.cn_flags & CNP_HASBUF) {
984263bc 892 zfree(namei_zone, cn.cn_pnbuf);
2b69e610 893 cn.cn_flags &= ~CNP_HASBUF;
984263bc
MD
894 }
895 if (dvp == *vpp)
896 vrele(*vpp);
897 else
898 vput(*vpp);
899 *vpp = NULLVP;
900 return (EEXIST);
901 }
902
903 /*
904 * policy: when creating the shadow directory in the
905 * upper layer, create it owned by the user who did
906 * the mount, group from parent directory, and mode
907 * 777 modified by umask (ie mostly identical to the
908 * mkdir syscall). (jsp, kb)
909 */
910
911 VATTR_NULL(&va);
912 va.va_type = VDIR;
913 va.va_mode = um->um_cmode;
914
915 /* VOP_LEASE: dvp is locked */
dadab5e9 916 VOP_LEASE(dvp, td, cn.cn_cred, LEASE_WRITE);
984263bc 917
bc0c094e 918 error = VOP_MKDIR(dvp, NCPNULL, vpp, &cn, &va);
2b69e610 919 if (cn.cn_flags & CNP_HASBUF) {
984263bc 920 zfree(namei_zone, cn.cn_pnbuf);
2b69e610 921 cn.cn_flags &= ~CNP_HASBUF;
984263bc
MD
922 }
923 /*vput(dvp);*/
924 return (error);
925}
926
927/*
928 * Create a whiteout entry in the upper layer.
929 *
930 * (um) points to the union mount structure for access to the
931 * the mounting process's credentials.
932 * (dvp) is the directory in which to create the whiteout.
933 * it is locked on entry and return.
934 * (cnp) is the componentname to be created.
935 */
936int
262679fc
CP
937union_mkwhiteout(struct union_mount *um, struct vnode *dvp,
938 struct componentname *cnp, char *path)
984263bc
MD
939{
940 int error;
dadab5e9 941 struct thread *td = cnp->cn_td;
984263bc
MD
942 struct vnode *wvp;
943 struct componentname cn;
dadab5e9
MD
944 struct ucred *cred;
945
946 KKASSERT(td->td_proc);
947 cred = td->td_proc->p_ucred;
984263bc
MD
948
949 error = union_relookup(um, dvp, &wvp, cnp, &cn, path, strlen(path));
950 if (error)
951 return (error);
952
953 if (wvp) {
2b69e610 954 if (cn.cn_flags & CNP_HASBUF) {
984263bc 955 zfree(namei_zone, cn.cn_pnbuf);
2b69e610 956 cn.cn_flags &= ~CNP_HASBUF;
984263bc
MD
957 }
958 if (wvp == dvp)
959 vrele(wvp);
960 else
961 vput(wvp);
962 return (EEXIST);
963 }
964
965 /* VOP_LEASE: dvp is locked */
dadab5e9 966 VOP_LEASE(dvp, td, cred, LEASE_WRITE);
984263bc 967
bc0c094e 968 error = VOP_WHITEOUT(dvp, NCPNULL, &cn, NAMEI_CREATE);
2b69e610 969 if (cn.cn_flags & CNP_HASBUF) {
984263bc 970 zfree(namei_zone, cn.cn_pnbuf);
2b69e610 971 cn.cn_flags &= ~CNP_HASBUF;
984263bc
MD
972 }
973 return (error);
974}
975
976/*
977 * union_vn_create: creates and opens a new shadow file
978 * on the upper union layer. this function is similar
979 * in spirit to calling vn_open but it avoids calling namei().
980 * the problem with calling namei is that a) it locks too many
981 * things, and b) it doesn't start at the "right" directory,
982 * whereas relookup is told where to start.
983 *
984 * On entry, the vnode associated with un is locked. It remains locked
985 * on return.
986 *
987 * If no error occurs, *vpp contains a locked referenced vnode for your
988 * use. If an error occurs *vpp iis undefined.
989 */
990static int
262679fc 991union_vn_create(struct vnode **vpp, struct union_node *un, struct thread *td)
984263bc
MD
992{
993 struct vnode *vp;
dadab5e9 994 struct ucred *cred;
984263bc
MD
995 struct vattr vat;
996 struct vattr *vap = &vat;
997 int fmode = FFLAGS(O_WRONLY|O_CREAT|O_TRUNC|O_EXCL);
998 int error;
dadab5e9 999 int cmode;
984263bc
MD
1000 struct componentname cn;
1001
dadab5e9
MD
1002 KKASSERT(td->td_proc);
1003 cred = td->td_proc->p_ucred;
1004 cmode = UN_FILEMODE & ~td->td_proc->p_fd->fd_cmask;
1005
984263bc
MD
1006 *vpp = NULLVP;
1007
1008 /*
1009 * Build a new componentname structure (for the same
1010 * reasons outlines in union_mkshadow).
1011 * The difference here is that the file is owned by
1012 * the current user, rather than by the person who
1013 * did the mount, since the current user needs to be
1014 * able to write the file (that's why it is being
1015 * copied in the first place).
1016 */
1017 cn.cn_namelen = strlen(un->un_path);
1018 cn.cn_pnbuf = zalloc(namei_zone);
1019 bcopy(un->un_path, cn.cn_pnbuf, cn.cn_namelen+1);
2b69e610
MD
1020 cn.cn_nameiop = NAMEI_CREATE;
1021 cn.cn_flags = (CNP_LOCKPARENT | CNP_LOCKLEAF | CNP_HASBUF |
1022 CNP_SAVENAME | CNP_ISLASTCN);
dadab5e9
MD
1023 cn.cn_td = td;
1024 cn.cn_cred = cred;
984263bc
MD
1025 cn.cn_nameptr = cn.cn_pnbuf;
1026 cn.cn_consume = 0;
1027
1028 /*
1029 * Pass dvp unlocked and referenced on call to relookup().
1030 *
1031 * If an error occurs, dvp will be returned unlocked and dereferenced.
1032 */
597aea93 1033 vref(un->un_dirvp);
984263bc
MD
1034 error = relookup(un->un_dirvp, &vp, &cn);
1035 if (error)
1036 return (error);
1037
1038 /*
1039 * If no error occurs, dvp will be returned locked with the reference
1040 * left as before, and vpp will be returned referenced and locked.
1041 */
1042 if (vp) {
1043 vput(un->un_dirvp);
2b69e610 1044 if (cn.cn_flags & CNP_HASBUF) {
984263bc 1045 zfree(namei_zone, cn.cn_pnbuf);
2b69e610 1046 cn.cn_flags &= ~CNP_HASBUF;
984263bc
MD
1047 }
1048 if (vp == un->un_dirvp)
1049 vrele(vp);
1050 else
1051 vput(vp);
1052 return (EEXIST);
1053 }
1054
1055 /*
1056 * Good - there was no race to create the file
1057 * so go ahead and create it. The permissions
1058 * on the file will be 0666 modified by the
1059 * current user's umask. Access to the file, while
1060 * it is unioned, will require access to the top *and*
1061 * bottom files. Access when not unioned will simply
1062 * require access to the top-level file.
1063 * TODO: confirm choice of access permissions.
1064 */
1065 VATTR_NULL(vap);
1066 vap->va_type = VREG;
1067 vap->va_mode = cmode;
dadab5e9 1068 VOP_LEASE(un->un_dirvp, td, cred, LEASE_WRITE);
bc0c094e 1069 error = VOP_CREATE(un->un_dirvp, NCPNULL, &vp, &cn, vap);
2b69e610 1070 if (cn.cn_flags & CNP_HASBUF) {
984263bc 1071 zfree(namei_zone, cn.cn_pnbuf);
2b69e610 1072 cn.cn_flags &= ~CNP_HASBUF;
984263bc
MD
1073 }
1074 vput(un->un_dirvp);
1075 if (error)
1076 return (error);
1077
dadab5e9 1078 error = VOP_OPEN(vp, fmode, cred, td);
984263bc 1079 if (error == 0 && vn_canvmio(vp) == TRUE)
3b568787 1080 error = vfs_object_create(vp, td);
984263bc
MD
1081 if (error) {
1082 vput(vp);
1083 return (error);
1084 }
1085 vp->v_writecount++;
1086 *vpp = vp;
1087 return (0);
1088}
1089
1090static int
262679fc
CP
1091union_vn_close(struct vnode *vp, int fmode, struct ucred *cred,
1092 struct thread *td)
984263bc 1093{
984263bc
MD
1094 if (fmode & FWRITE)
1095 --vp->v_writecount;
3b568787 1096 return (VOP_CLOSE(vp, fmode, td));
984263bc
MD
1097}
1098
1099#if 0
1100
1101/*
1102 * union_removed_upper:
1103 *
1104 * called with union_node unlocked. XXX
1105 */
1106
1107void
dadab5e9 1108union_removed_upper(struct union_node *un)
984263bc 1109{
dadab5e9 1110 struct thread *td = curthread; /* XXX */
984263bc
MD
1111 struct vnode **vpp;
1112
1113 /*
1114 * Do not set the uppervp to NULLVP. If lowervp is NULLVP,
1115 * union node will have neither uppervp nor lowervp. We remove
1116 * the union node from cache, so that it will not be referrenced.
1117 */
1118 union_newupper(un, NULLVP);
1119 if (un->un_dircache != 0) {
1120 for (vpp = un->un_dircache; *vpp != NULLVP; vpp++)
1121 vrele(*vpp);
1122 free(un->un_dircache, M_TEMP);
1123 un->un_dircache = 0;
1124 }
1125
1126 if (un->un_flags & UN_CACHED) {
1127 un->un_flags &= ~UN_CACHED;
1128 LIST_REMOVE(un, un_cache);
1129 }
1130}
1131
1132#endif
1133
1134/*
1135 * determine whether a whiteout is needed
1136 * during a remove/rmdir operation.
1137 */
1138int
dadab5e9 1139union_dowhiteout(struct union_node *un, struct ucred *cred, struct thread *td)
984263bc
MD
1140{
1141 struct vattr va;
1142
1143 if (un->un_lowervp != NULLVP)
1144 return (1);
1145
3b568787 1146 if (VOP_GETATTR(un->un_uppervp, &va, td) == 0 &&
984263bc
MD
1147 (va.va_flags & OPAQUE))
1148 return (1);
1149
1150 return (0);
1151}
1152
1153static void
262679fc 1154union_dircache_r(struct vnode *vp, struct vnode ***vppp, int *cntp)
984263bc
MD
1155{
1156 struct union_node *un;
1157
2d3e977e 1158 if (vp->v_vops != union_vnode_vops) {
984263bc 1159 if (vppp) {
597aea93 1160 vref(vp);
984263bc
MD
1161 *(*vppp)++ = vp;
1162 if (--(*cntp) == 0)
1163 panic("union: dircache table too small");
1164 } else {
1165 (*cntp)++;
1166 }
1167
1168 return;
1169 }
1170
1171 un = VTOUNION(vp);
1172 if (un->un_uppervp != NULLVP)
1173 union_dircache_r(un->un_uppervp, vppp, cntp);
1174 if (un->un_lowervp != NULLVP)
1175 union_dircache_r(un->un_lowervp, vppp, cntp);
1176}
1177
1178struct vnode *
dadab5e9 1179union_dircache(struct vnode *vp, struct thread *td)
984263bc
MD
1180{
1181 int cnt;
1182 struct vnode *nvp;
1183 struct vnode **vpp;
1184 struct vnode **dircache;
1185 struct union_node *un;
1186 int error;
1187
41a01a4d 1188 vn_lock(vp, NULL, LK_EXCLUSIVE | LK_RETRY, td);
984263bc
MD
1189 dircache = VTOUNION(vp)->un_dircache;
1190
1191 nvp = NULLVP;
1192
1193 if (dircache == NULL) {
1194 cnt = 0;
1195 union_dircache_r(vp, 0, &cnt);
1196 cnt++;
1197 dircache = malloc(cnt * sizeof(struct vnode *),
1198 M_TEMP, M_WAITOK);
1199 vpp = dircache;
1200 union_dircache_r(vp, &vpp, &cnt);
1201 *vpp = NULLVP;
1202 vpp = dircache + 1;
1203 } else {
1204 vpp = dircache;
1205 do {
1206 if (*vpp++ == VTOUNION(vp)->un_uppervp)
1207 break;
1208 } while (*vpp != NULLVP);
1209 }
1210
1211 if (*vpp == NULLVP)
1212 goto out;
1213
41a01a4d 1214 /*vn_lock(*vpp, NULL, LK_EXCLUSIVE | LK_RETRY, td);*/
984263bc 1215 UDEBUG(("ALLOCVP-3 %p ref %d\n", *vpp, (*vpp ? (*vpp)->v_usecount : -99)));
597aea93 1216 vref(*vpp);
984263bc
MD
1217 error = union_allocvp(&nvp, vp->v_mount, NULLVP, NULLVP, NULL, *vpp, NULLVP, 0);
1218 UDEBUG(("ALLOCVP-3B %p ref %d\n", nvp, (*vpp ? (*vpp)->v_usecount : -99)));
1219 if (error)
1220 goto out;
1221
1222 VTOUNION(vp)->un_dircache = 0;
1223 un = VTOUNION(nvp);
1224 un->un_dircache = dircache;
1225
1226out:
41a01a4d 1227 VOP_UNLOCK(vp, NULL, 0, td);
984263bc
MD
1228 return (nvp);
1229}
1230
1231/*
1232 * Guarentee coherency with the VM cache by invalidating any clean VM pages
1233 * associated with this write and updating any dirty VM pages. Since our
1234 * vnode is locked, other processes will not be able to read the pages in
1235 * again until after our write completes.
1236 *
1237 * We also have to be coherent with reads, by flushing any pending dirty
1238 * pages prior to issuing the read.
1239 *
1240 * XXX this is somewhat of a hack at the moment. To support this properly
1241 * we would have to be able to run VOP_READ and VOP_WRITE through the VM
1242 * cache. Then we wouldn't need to worry about coherency.
1243 */
1244
1245void
1246union_vm_coherency(struct vnode *vp, struct uio *uio, int cleanfls)
1247{
1248 vm_object_t object;
1249 vm_pindex_t pstart;
1250 vm_pindex_t pend;
1251 int pgoff;
1252
1253 if ((object = vp->v_object) == NULL)
1254 return;
1255
1256 pgoff = uio->uio_offset & PAGE_MASK;
1257 pstart = uio->uio_offset / PAGE_SIZE;
1258 pend = pstart + (uio->uio_resid + pgoff + PAGE_MASK) / PAGE_SIZE;
1259
1260 vm_object_page_clean(object, pstart, pend, OBJPC_SYNC);
1261 if (cleanfls)
1262 vm_object_page_remove(object, pstart, pend, TRUE);
1263}
1264
1265/*
1266 * Module glue to remove #ifdef UNION from vfs_syscalls.c
1267 */
1268static int
dadab5e9 1269union_dircheck(struct thread *td, struct vnode **vp, struct file *fp)
984263bc
MD
1270{
1271 int error = 0;
1272
2d3e977e 1273 if ((*vp)->v_vops == union_vnode_vops) {
984263bc
MD
1274 struct vnode *lvp;
1275
dadab5e9 1276 lvp = union_dircache(*vp, td);
984263bc
MD
1277 if (lvp != NULLVP) {
1278 struct vattr va;
1279
1280 /*
1281 * If the directory is opaque,
1282 * then don't show lower entries
1283 */
3b568787 1284 error = VOP_GETATTR(*vp, &va, td);
984263bc
MD
1285 if (va.va_flags & OPAQUE) {
1286 vput(lvp);
1287 lvp = NULL;
1288 }
1289 }
1290
1291 if (lvp != NULLVP) {
dadab5e9 1292 error = VOP_OPEN(lvp, FREAD, fp->f_cred, td);
984263bc 1293 if (error == 0 && vn_canvmio(lvp) == TRUE)
3b568787 1294 error = vfs_object_create(lvp, td);
984263bc
MD
1295 if (error) {
1296 vput(lvp);
1297 return (error);
1298 }
41a01a4d 1299 VOP_UNLOCK(lvp, NULL, 0, td);
984263bc
MD
1300 fp->f_data = (caddr_t) lvp;
1301 fp->f_offset = 0;
3b568787 1302 error = vn_close(*vp, FREAD, td);
984263bc
MD
1303 if (error)
1304 return (error);
1305 *vp = lvp;
1306 return -1; /* goto unionread */
1307 }
1308 }
1309 return error;
1310}
1311
1312static int
1313union_modevent(module_t mod, int type, void *data)
1314{
1315 switch (type) {
1316 case MOD_LOAD:
1317 union_dircheckp = union_dircheck;
1318 break;
1319 case MOD_UNLOAD:
1320 union_dircheckp = NULL;
1321 break;
1322 default:
1323 break;
1324 }
1325 return 0;
1326}
1327
1328static moduledata_t union_mod = {
1329 "union_dircheck",
1330 union_modevent,
1331 NULL
1332};
1333
1334DECLARE_MODULE(union_dircheck, union_mod, SI_SUB_VFS, SI_ORDER_ANY);