![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to union_subr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / miscfs / union|
Return to union_subr.c CVS log | Up to [Apple XNU] / XNU / bsd / miscfs / union |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
23: /*
24: * Copyright (c) 1994 Jan-Simon Pendry
25: * Copyright (c) 1994
26: * The Regents of the University of California. All rights reserved.
27: *
28: * This code is derived from software contributed to Berkeley by
29: * Jan-Simon Pendry.
30: *
31: * Redistribution and use in source and binary forms, with or without
32: * modification, are permitted provided that the following conditions
33: * are met:
34: * 1. Redistributions of source code must retain the above copyright
35: * notice, this list of conditions and the following disclaimer.
36: * 2. Redistributions in binary form must reproduce the above copyright
37: * notice, this list of conditions and the following disclaimer in the
38: * documentation and/or other materials provided with the distribution.
39: * 3. All advertising materials mentioning features or use of this software
40: * must display the following acknowledgement:
41: * This product includes software developed by the University of
42: * California, Berkeley and its contributors.
43: * 4. Neither the name of the University nor the names of its contributors
44: * may be used to endorse or promote products derived from this software
45: * without specific prior written permission.
46: *
47: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
48: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
49: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
50: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
51: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
52: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
53: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
54: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
55: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
56: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
57: * SUCH DAMAGE.
58: *
59: * @(#)union_subr.c 8.20 (Berkeley) 5/20/95
60: */
61:
62: #include <sys/param.h>
63: #include <sys/systm.h>
64: #include <sys/proc.h>
65: #include <sys/time.h>
66: #include <sys/kernel.h>
67: #include <sys/vnode.h>
68: #include <sys/namei.h>
69: #include <sys/malloc.h>
70: #include <sys/file.h>
71: #include <sys/filedesc.h>
72: #include <sys/queue.h>
73: #include <sys/mount.h>
74: #include <sys/stat.h>
75: #include <miscfs/union/union.h>
76:
77: #if DIAGNOSTIC
78: #include <sys/proc.h>
79: #endif
80:
81: /* must be power of two, otherwise change UNION_HASH() */
82: #define NHASH 32
83:
84: /* unsigned int ... */
85: #define UNION_HASH(u, l) \
86: (((((unsigned long) (u)) + ((unsigned long) l)) >> 8) & (NHASH-1))
87:
88: static LIST_HEAD(unhead, union_node) unhead[NHASH];
89: static int unvplock[NHASH];
90:
91: int
92: union_init()
93: {
94: int i;
95:
96: for (i = 0; i < NHASH; i++)
97: LIST_INIT(&unhead[i]);
98: bzero((caddr_t) unvplock, sizeof(unvplock));
99: }
100:
101: static int
102: union_list_lock(ix)
103: int ix;
104: {
105:
106: if (unvplock[ix] & UN_LOCKED) {
107: unvplock[ix] |= UN_WANT;
108: sleep((caddr_t) &unvplock[ix], PINOD);
109: return (1);
110: }
111:
112: unvplock[ix] |= UN_LOCKED;
113:
114: return (0);
115: }
116:
117: static void
118: union_list_unlock(ix)
119: int ix;
120: {
121:
122: unvplock[ix] &= ~UN_LOCKED;
123:
124: if (unvplock[ix] & UN_WANT) {
125: unvplock[ix] &= ~UN_WANT;
126: wakeup((caddr_t) &unvplock[ix]);
127: }
128: }
129:
130: void
131: union_updatevp(un, uppervp, lowervp)
132: struct union_node *un;
133: struct vnode *uppervp;
134: struct vnode *lowervp;
135: {
136: int ohash = UNION_HASH(un->un_uppervp, un->un_lowervp);
137: int nhash = UNION_HASH(uppervp, lowervp);
138: int docache = (lowervp != NULLVP || uppervp != NULLVP);
139: int lhash, hhash, uhash;
140:
141: /*
142: * Ensure locking is ordered from lower to higher
143: * to avoid deadlocks.
144: */
145: if (nhash < ohash) {
146: lhash = nhash;
147: uhash = ohash;
148: } else {
149: lhash = ohash;
150: uhash = nhash;
151: }
152:
153: if (lhash != uhash)
154: while (union_list_lock(lhash))
155: continue;
156:
157: while (union_list_lock(uhash))
158: continue;
159:
160: if (ohash != nhash || !docache) {
161: if (un->un_flags & UN_CACHED) {
162: un->un_flags &= ~UN_CACHED;
163: LIST_REMOVE(un, un_cache);
164: }
165: }
166:
167: if (ohash != nhash)
168: union_list_unlock(ohash);
169:
170: if (un->un_lowervp != lowervp) {
171: if (un->un_lowervp) {
172: vrele(un->un_lowervp);
173: if (un->un_path) {
174: _FREE(un->un_path, M_TEMP);
175: un->un_path = 0;
176: }
177: if (un->un_dirvp) {
178: vrele(un->un_dirvp);
179: un->un_dirvp = NULLVP;
180: }
181: }
182: un->un_lowervp = lowervp;
183: un->un_lowersz = VNOVAL;
184: }
185:
186: if (un->un_uppervp != uppervp) {
187: if (un->un_uppervp)
188: vrele(un->un_uppervp);
189:
190: un->un_uppervp = uppervp;
191: un->un_uppersz = VNOVAL;
192: }
193:
194: if (docache && (ohash != nhash)) {
195: LIST_INSERT_HEAD(&unhead[nhash], un, un_cache);
196: un->un_flags |= UN_CACHED;
197: }
198:
199: union_list_unlock(nhash);
200: }
201:
202: void
203: union_newlower(un, lowervp)
204: struct union_node *un;
205: struct vnode *lowervp;
206: {
207:
208: union_updatevp(un, un->un_uppervp, lowervp);
209: }
210:
211: void
212: union_newupper(un, uppervp)
213: struct union_node *un;
214: struct vnode *uppervp;
215: {
216:
217: union_updatevp(un, uppervp, un->un_lowervp);
218: }
219:
220: /*
221: * Keep track of size changes in the underlying vnodes.
222: * If the size changes, then callback to the vm layer
223: * giving priority to the upper layer size.
224: */
225: void
226: union_newsize(vp, uppersz, lowersz)
227: struct vnode *vp;
228: off_t uppersz, lowersz;
229: {
230: struct union_node *un;
231: off_t sz;
232:
233: /* only interested in regular files */
234: if (vp->v_type != VREG)
235: return;
236:
237: un = VTOUNION(vp);
238: sz = VNOVAL;
239:
240: if ((uppersz != VNOVAL) && (un->un_uppersz != uppersz)) {
241: un->un_uppersz = uppersz;
242: if (sz == VNOVAL)
243: sz = un->un_uppersz;
244: }
245:
246: if ((lowersz != VNOVAL) && (un->un_lowersz != lowersz)) {
247: un->un_lowersz = lowersz;
248: if (sz == VNOVAL)
249: sz = un->un_lowersz;
250: }
251:
252: if (sz != VNOVAL) {
253: #ifdef UNION_DIAGNOSTIC
254: printf("union: %s size now %ld\n",
255: uppersz != VNOVAL ? "upper" : "lower", (long) sz);
256: #endif
257: vnode_pager_setsize(vp, sz);
258: }
259: }
260:
261: /*
262: * allocate a union_node/vnode pair. the vnode is
263: * referenced and locked. the new vnode is returned
264: * via (vpp). (mp) is the mountpoint of the union filesystem,
265: * (dvp) is the parent directory where the upper layer object
266: * should exist (but doesn't) and (cnp) is the componentname
267: * information which is partially copied to allow the upper
268: * layer object to be created at a later time. (uppervp)
269: * and (lowervp) reference the upper and lower layer objects
270: * being mapped. either, but not both, can be nil.
271: * if supplied, (uppervp) is locked.
272: * the reference is either maintained in the new union_node
273: * object which is allocated, or they are vrele'd.
274: *
275: * all union_nodes are maintained on a singly-linked
276: * list. new nodes are only allocated when they cannot
277: * be found on this list. entries on the list are
278: * removed when the vfs reclaim entry is called.
279: *
280: * a single lock is kept for the entire list. this is
281: * needed because the getnewvnode() function can block
282: * waiting for a vnode to become free, in which case there
283: * may be more than one process trying to get the same
284: * vnode. this lock is only taken if we are going to
285: * call getnewvnode, since the kernel itself is single-threaded.
286: *
287: * if an entry is found on the list, then call vget() to
288: * take a reference. this is done because there may be
289: * zero references to it and so it needs to removed from
290: * the vnode free list.
291: */
292: int
293: union_allocvp(vpp, mp, undvp, dvp, cnp, uppervp, lowervp, docache)
294: struct vnode **vpp;
295: struct mount *mp;
296: struct vnode *undvp; /* parent union vnode */
297: struct vnode *dvp; /* may be null */
298: struct componentname *cnp; /* may be null */
299: struct vnode *uppervp; /* may be null */
300: struct vnode *lowervp; /* may be null */
301: int docache;
302: {
303: int error;
304: struct union_node *un;
305: struct union_node **pp;
306: struct vnode *xlowervp = NULLVP;
307: struct union_mount *um = MOUNTTOUNIONMOUNT(mp);
308: int hash;
309: int vflag;
310: int try;
311: struct union_node *unp;
312:
313: if (uppervp == NULLVP && lowervp == NULLVP)
314: panic("union: unidentifiable allocation");
315:
316: if (uppervp && lowervp && (uppervp->v_type != lowervp->v_type)) {
317: xlowervp = lowervp;
318: lowervp = NULLVP;
319: }
320:
321: /* detect the root vnode (and aliases) */
322: vflag = 0;
323: if ((uppervp == um->um_uppervp) &&
324: ((lowervp == NULLVP) || lowervp == um->um_lowervp)) {
325: if (lowervp == NULLVP) {
326: lowervp = um->um_lowervp;
327: if (lowervp != NULLVP)
328: VREF(lowervp);
329: }
330: vflag = VROOT;
331: }
332:
333: loop:
334: if (!docache) {
335: un = 0;
336: } else for (try = 0; try < 3; try++) {
337: switch (try) {
338: case 0:
339: if (lowervp == NULLVP)
340: continue;
341: hash = UNION_HASH(uppervp, lowervp);
342: break;
343:
344: case 1:
345: if (uppervp == NULLVP)
346: continue;
347: hash = UNION_HASH(uppervp, NULLVP);
348: break;
349:
350: case 2:
351: if (lowervp == NULLVP)
352: continue;
353: hash = UNION_HASH(NULLVP, lowervp);
354: break;
355: }
356:
357: while (union_list_lock(hash))
358: continue;
359:
360: for (un = unhead[hash].lh_first; un != 0;
361: un = un->un_cache.le_next) {
362: if ((un->un_lowervp == lowervp ||
363: un->un_lowervp == NULLVP) &&
364: (un->un_uppervp == uppervp ||
365: un->un_uppervp == NULLVP) &&
366: (UNIONTOV(un)->v_mount == mp)) {
367: if (vget(UNIONTOV(un), 0,
368: cnp ? cnp->cn_proc : NULL)) {
369: union_list_unlock(hash);
370: goto loop;
371: }
372: break;
373: }
374: }
375:
376: union_list_unlock(hash);
377:
378: if (un)
379: break;
380: }
381:
382: if (un) {
383: /*
384: * Obtain a lock on the union_node.
385: * uppervp is locked, though un->un_uppervp
386: * may not be. this doesn't break the locking
387: * hierarchy since in the case that un->un_uppervp
388: * is not yet locked it will be vrele'd and replaced
389: * with uppervp.
390: */
391:
392: if ((dvp != NULLVP) && (uppervp == dvp)) {
393: /*
394: * Access ``.'', so (un) will already
395: * be locked. Since this process has
396: * the lock on (uppervp) no other
397: * process can hold the lock on (un).
398: */
399: #if DIAGNOSTIC
400: if ((un->un_flags & UN_LOCKED) == 0)
401: panic("union: . not locked");
402: else if (current_proc() && un->un_pid != current_proc()->p_pid &&
403: un->un_pid > -1 && current_proc()->p_pid > -1)
404: panic("union: allocvp not lock owner");
405: #endif
406: } else {
407: if (un->un_flags & UN_LOCKED) {
408: vrele(UNIONTOV(un));
409: un->un_flags |= UN_WANT;
410: sleep((caddr_t) &un->un_flags, PINOD);
411: goto loop;
412: }
413: un->un_flags |= UN_LOCKED;
414:
415: #if DIAGNOSTIC
416: if (current_proc())
417: un->un_pid = current_proc()->p_pid;
418: else
419: un->un_pid = -1;
420: #endif
421: }
422:
423: /*
424: * At this point, the union_node is locked,
425: * un->un_uppervp may not be locked, and uppervp
426: * is locked or nil.
427: */
428:
429: /*
430: * Save information about the upper layer.
431: */
432: if (uppervp != un->un_uppervp) {
433: union_newupper(un, uppervp);
434: } else if (uppervp) {
435: vrele(uppervp);
436: }
437:
438: if (un->un_uppervp) {
439: un->un_flags |= UN_ULOCK;
440: un->un_flags &= ~UN_KLOCK;
441: }
442:
443: /*
444: * Save information about the lower layer.
445: * This needs to keep track of pathname
446: * and directory information which union_vn_create
447: * might need.
448: */
449: if (lowervp != un->un_lowervp) {
450: union_newlower(un, lowervp);
451: if (cnp && (lowervp != NULLVP)) {
452: un->un_hash = cnp->cn_hash;
453: MALLOC(un->un_path, caddr_t, cnp->cn_namelen+1,
454: M_TEMP, M_WAITOK);
455: bcopy(cnp->cn_nameptr, un->un_path,
456: cnp->cn_namelen);
457: un->un_path[cnp->cn_namelen] = '\0';
458: VREF(dvp);
459: un->un_dirvp = dvp;
460: }
461: } else if (lowervp) {
462: vrele(lowervp);
463: }
464: *vpp = UNIONTOV(un);
465: return (0);
466: }
467:
468: if (docache) {
469: /*
470: * otherwise lock the vp list while we call getnewvnode
471: * since that can block.
472: */
473: hash = UNION_HASH(uppervp, lowervp);
474:
475: if (union_list_lock(hash))
476: goto loop;
477: }
478:
479: MALLOC(unp, void *, sizeof(struct union_node), M_TEMP, M_WAITOK);
480: error = getnewvnode(VT_UNION, mp, union_vnodeop_p, vpp);
481: if (error) {
482: FREE(unp, M_TEMP);
483: if (uppervp) {
484: if (dvp == uppervp)
485: vrele(uppervp);
486: else
487: vput(uppervp);
488: }
489: if (lowervp)
490: vrele(lowervp);
491:
492: goto out;
493: }
494:
495: (*vpp)->v_data = unp;
496: (*vpp)->v_flag |= vflag;
497: if (uppervp)
498: (*vpp)->v_type = uppervp->v_type;
499: else
500: (*vpp)->v_type = lowervp->v_type;
501: un = VTOUNION(*vpp);
502: un->un_vnode = *vpp;
503: un->un_uppervp = uppervp;
504: un->un_uppersz = VNOVAL;
505: un->un_lowervp = lowervp;
506: un->un_lowersz = VNOVAL;
507: un->un_pvp = undvp;
508: if (undvp != NULLVP)
509: VREF(undvp);
510: un->un_dircache = 0;
511: un->un_openl = 0;
512: un->un_flags = UN_LOCKED;
513: if (un->un_uppervp)
514: un->un_flags |= UN_ULOCK;
515: #if DIAGNOSTIC
516: if (current_proc())
517: un->un_pid = current_proc()->p_pid;
518: else
519: un->un_pid = -1;
520: #endif
521: if (cnp && (lowervp != NULLVP)) {
522: un->un_hash = cnp->cn_hash;
523: un->un_path = _MALLOC(cnp->cn_namelen+1, M_TEMP, M_WAITOK);
524: bcopy(cnp->cn_nameptr, un->un_path, cnp->cn_namelen);
525: un->un_path[cnp->cn_namelen] = '\0';
526: VREF(dvp);
527: un->un_dirvp = dvp;
528: } else {
529: un->un_hash = 0;
530: un->un_path = 0;
531: un->un_dirvp = 0;
532: }
533:
534: if (docache) {
535: LIST_INSERT_HEAD(&unhead[hash], un, un_cache);
536: un->un_flags |= UN_CACHED;
537: }
538:
539: if (xlowervp)
540: vrele(xlowervp);
541:
542: out:
543: if (docache)
544: union_list_unlock(hash);
545:
546: return (error);
547: }
548:
549: int
550: union_freevp(vp)
551: struct vnode *vp;
552: {
553: struct union_node *un = VTOUNION(vp);
554:
555: if (un->un_flags & UN_CACHED) {
556: un->un_flags &= ~UN_CACHED;
557: LIST_REMOVE(un, un_cache);
558: }
559:
560: if (un->un_pvp != NULLVP)
561: vrele(un->un_pvp);
562: if (un->un_uppervp != NULLVP)
563: vrele(un->un_uppervp);
564: if (un->un_lowervp != NULLVP)
565: vrele(un->un_lowervp);
566: if (un->un_dirvp != NULLVP)
567: vrele(un->un_dirvp);
568: if (un->un_path)
569: _FREE(un->un_path, M_TEMP);
570:
571: FREE(vp->v_data, M_TEMP);
572: vp->v_data = 0;
573:
574: return (0);
575: }
576:
577: /*
578: * copyfile. copy the vnode (fvp) to the vnode (tvp)
579: * using a sequence of reads and writes. both (fvp)
580: * and (tvp) are locked on entry and exit.
581: */
582: int
583: union_copyfile(fvp, tvp, cred, p)
584: struct vnode *fvp;
585: struct vnode *tvp;
586: struct ucred *cred;
587: struct proc *p;
588: {
589: char *buf;
590: struct uio uio;
591: struct iovec iov;
592: int error = 0;
593:
594: /*
595: * strategy:
596: * allocate a buffer of size MAXPHYSIO.
597: * loop doing reads and writes, keeping track
598: * of the current uio offset.
599: * give up at the first sign of trouble.
600: */
601:
602: uio.uio_procp = p;
603: uio.uio_segflg = UIO_SYSSPACE;
604: uio.uio_offset = 0;
605:
606: VOP_UNLOCK(fvp, 0, p); /* XXX */
607: VOP_LEASE(fvp, p, cred, LEASE_READ);
608: vn_lock(fvp, LK_EXCLUSIVE | LK_RETRY, p); /* XXX */
609: VOP_UNLOCK(tvp, 0, p); /* XXX */
610: VOP_LEASE(tvp, p, cred, LEASE_WRITE);
611: vn_lock(tvp, LK_EXCLUSIVE | LK_RETRY, p); /* XXX */
612:
613: buf = _MALLOC(MAXPHYSIO, M_TEMP, M_WAITOK);
614:
615: /* ugly loop follows... */
616: do {
617: off_t offset = uio.uio_offset;
618:
619: uio.uio_iov = &iov;
620: uio.uio_iovcnt = 1;
621: iov.iov_base = buf;
622: iov.iov_len = MAXPHYSIO;
623: uio.uio_resid = iov.iov_len;
624: uio.uio_rw = UIO_READ;
625: error = VOP_READ(fvp, &uio, 0, cred);
626:
627: if (error == 0) {
628: uio.uio_iov = &iov;
629: uio.uio_iovcnt = 1;
630: iov.iov_base = buf;
631: iov.iov_len = MAXPHYSIO - uio.uio_resid;
632: uio.uio_offset = offset;
633: uio.uio_rw = UIO_WRITE;
634: uio.uio_resid = iov.iov_len;
635:
636: if (uio.uio_resid == 0)
637: break;
638:
639: do {
640: error = VOP_WRITE(tvp, &uio, 0, cred);
641: } while ((uio.uio_resid > 0) && (error == 0));
642: }
643:
644: } while (error == 0);
645:
646: _FREE(buf, M_TEMP);
647: return (error);
648: }
649:
650: /*
651: * (un) is assumed to be locked on entry and remains
652: * locked on exit.
653: */
654: int
655: union_copyup(un, docopy, cred, p)
656: struct union_node *un;
657: int docopy;
658: struct ucred *cred;
659: struct proc *p;
660: {
661: int error;
662: struct vnode *lvp, *uvp;
663:
664: error = union_vn_create(&uvp, un, p);
665: if (error)
666: return (error);
667:
668: /* at this point, uppervp is locked */
669: union_newupper(un, uvp);
670: un->un_flags |= UN_ULOCK;
671:
672: lvp = un->un_lowervp;
673:
674: if (docopy) {
675: /*
676: * XX - should not ignore errors
677: * from VOP_CLOSE
678: */
679: vn_lock(lvp, LK_EXCLUSIVE | LK_RETRY, p);
680: error = VOP_OPEN(lvp, FREAD, cred, p);
681: if (error == 0) {
682: error = union_copyfile(lvp, uvp, cred, p);
683: VOP_UNLOCK(lvp, 0, p);
684: (void) VOP_CLOSE(lvp, FREAD, cred, p);
685: }
686: #ifdef UNION_DIAGNOSTIC
687: if (error == 0)
688: uprintf("union: copied up %s\n", un->un_path);
689: #endif
690:
691: }
692: un->un_flags &= ~UN_ULOCK;
693: VOP_UNLOCK(uvp, 0, p);
694: union_vn_close(uvp, FWRITE, cred, p);
695: vn_lock(uvp, LK_EXCLUSIVE | LK_RETRY, p);
696: un->un_flags |= UN_ULOCK;
697:
698: /*
699: * Subsequent IOs will go to the top layer, so
700: * call close on the lower vnode and open on the
701: * upper vnode to ensure that the filesystem keeps
702: * its references counts right. This doesn't do
703: * the right thing with (cred) and (FREAD) though.
704: * Ignoring error returns is not right, either.
705: */
706: if (error == 0) {
707: int i;
708:
709: for (i = 0; i < un->un_openl; i++) {
710: (void) VOP_CLOSE(lvp, FREAD, cred, p);
711: (void) VOP_OPEN(uvp, FREAD, cred, p);
712: }
713: un->un_openl = 0;
714: }
715:
716: return (error);
717:
718: }
719:
720: static int
721: union_relookup(um, dvp, vpp, cnp, cn, path, pathlen)
722: struct union_mount *um;
723: struct vnode *dvp;
724: struct vnode **vpp;
725: struct componentname *cnp;
726: struct componentname *cn;
727: char *path;
728: int pathlen;
729: {
730: int error;
731:
732: /*
733: * A new componentname structure must be faked up because
734: * there is no way to know where the upper level cnp came
735: * from or what it is being used for. This must duplicate
736: * some of the work done by NDINIT, some of the work done
737: * by namei, some of the work done by lookup and some of
738: * the work done by VOP_LOOKUP when given a CREATE flag.
739: * Conclusion: Horrible.
740: *
741: * The pathname buffer will be FREEed by VOP_MKDIR.
742: */
743: cn->cn_namelen = pathlen;
744: cn->cn_pnbuf = _MALLOC_ZONE(cn->cn_namelen+1, M_NAMEI, M_WAITOK);
745: cn->cn_pnlen = cn->cn_namelen+1;
746: bcopy(path, cn->cn_pnbuf, cn->cn_namelen);
747: cn->cn_pnbuf[cn->cn_namelen] = '\0';
748:
749: cn->cn_nameiop = CREATE;
750: cn->cn_flags = (LOCKPARENT|HASBUF|SAVENAME|SAVESTART|ISLASTCN);
751: cn->cn_proc = cnp->cn_proc;
752: if (um->um_op == UNMNT_ABOVE)
753: cn->cn_cred = cnp->cn_cred;
754: else
755: cn->cn_cred = um->um_cred;
756: cn->cn_nameptr = cn->cn_pnbuf;
757: cn->cn_hash = cnp->cn_hash;
758: cn->cn_consume = cnp->cn_consume;
759:
760: VREF(dvp);
761: error = relookup(dvp, vpp, cn);
762: if (!error)
763: vrele(dvp);
764:
765: return (error);
766: }
767:
768: /*
769: * Create a shadow directory in the upper layer.
770: * The new vnode is returned locked.
771: *
772: * (um) points to the union mount structure for access to the
773: * the mounting process's credentials.
774: * (dvp) is the directory in which to create the shadow directory.
775: * it is unlocked on entry and exit.
776: * (cnp) is the componentname to be created.
777: * (vpp) is the returned newly created shadow directory, which
778: * is returned locked.
779: */
780: int
781: union_mkshadow(um, dvp, cnp, vpp)
782: struct union_mount *um;
783: struct vnode *dvp;
784: struct componentname *cnp;
785: struct vnode **vpp;
786: {
787: int error;
788: struct vattr va;
789: struct proc *p = cnp->cn_proc;
790: struct componentname cn;
791:
792: error = union_relookup(um, dvp, vpp, cnp, &cn,
793: cnp->cn_nameptr, cnp->cn_namelen);
794: if (error)
795: return (error);
796:
797: if (*vpp) {
798: VOP_ABORTOP(dvp, &cn);
799: VOP_UNLOCK(dvp, 0, p);
800: vrele(*vpp);
801: *vpp = NULLVP;
802: return (EEXIST);
803: }
804:
805: /*
806: * policy: when creating the shadow directory in the
807: * upper layer, create it owned by the user who did
808: * the mount, group from parent directory, and mode
809: * 777 modified by umask (ie mostly identical to the
810: * mkdir syscall). (jsp, kb)
811: */
812:
813: VATTR_NULL(&va);
814: va.va_type = VDIR;
815: va.va_mode = um->um_cmode;
816:
817: /* VOP_LEASE: dvp is locked */
818: VOP_LEASE(dvp, p, cn.cn_cred, LEASE_WRITE);
819:
820: error = VOP_MKDIR(dvp, vpp, &cn, &va);
821: return (error);
822: }
823:
824: /*
825: * Create a whiteout entry in the upper layer.
826: *
827: * (um) points to the union mount structure for access to the
828: * the mounting process's credentials.
829: * (dvp) is the directory in which to create the whiteout.
830: * it is locked on entry and exit.
831: * (cnp) is the componentname to be created.
832: */
833: int
834: union_mkwhiteout(um, dvp, cnp, path)
835: struct union_mount *um;
836: struct vnode *dvp;
837: struct componentname *cnp;
838: char *path;
839: {
840: int error;
841: struct vattr va;
842: struct proc *p = cnp->cn_proc;
843: struct vnode *wvp;
844: struct componentname cn;
845:
846: VOP_UNLOCK(dvp, 0, p);
847: error = union_relookup(um, dvp, &wvp, cnp, &cn, path, strlen(path));
848: if (error) {
849: vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY, p);
850: return (error);
851: }
852:
853: if (wvp) {
854: VOP_ABORTOP(dvp, &cn);
855: vrele(dvp);
856: vrele(wvp);
857: return (EEXIST);
858: }
859:
860: /* VOP_LEASE: dvp is locked */
861: VOP_LEASE(dvp, p, p->p_ucred, LEASE_WRITE);
862:
863: error = VOP_WHITEOUT(dvp, &cn, CREATE);
864: if (error)
865: VOP_ABORTOP(dvp, &cn);
866:
867: vrele(dvp);
868:
869: return (error);
870: }
871:
872: /*
873: * union_vn_create: creates and opens a new shadow file
874: * on the upper union layer. this function is similar
875: * in spirit to calling vn_open but it avoids calling namei().
876: * the problem with calling namei is that a) it locks too many
877: * things, and b) it doesn't start at the "right" directory,
878: * whereas relookup is told where to start.
879: */
880: int
881: union_vn_create(vpp, un, p)
882: struct vnode **vpp;
883: struct union_node *un;
884: struct proc *p;
885: {
886: struct vnode *vp;
887: struct ucred *cred = p->p_ucred;
888: struct vattr vat;
889: struct vattr *vap = &vat;
890: int fmode = FFLAGS(O_WRONLY|O_CREAT|O_TRUNC|O_EXCL);
891: int error;
892: int cmode = UN_FILEMODE & ~p->p_fd->fd_cmask;
893: char *cp;
894: struct componentname cn;
895:
896: *vpp = NULLVP;
897:
898: /*
899: * Build a new componentname structure (for the same
900: * reasons outlines in union_mkshadow).
901: * The difference here is that the file is owned by
902: * the current user, rather than by the person who
903: * did the mount, since the current user needs to be
904: * able to write the file (that's why it is being
905: * copied in the first place).
906: */
907: cn.cn_namelen = strlen(un->un_path);
908: cn.cn_pnbuf = (caddr_t) _MALLOC_ZONE(cn.cn_namelen+1,
909: M_NAMEI, M_WAITOK);
910: cn.cn_pnlen = cn.cn_namelen+1;
911: bcopy(un->un_path, cn.cn_pnbuf, cn.cn_namelen+1);
912: cn.cn_nameiop = CREATE;
913: cn.cn_flags = (LOCKPARENT|HASBUF|SAVENAME|SAVESTART|ISLASTCN);
914: cn.cn_proc = p;
915: cn.cn_cred = p->p_ucred;
916: cn.cn_nameptr = cn.cn_pnbuf;
917: cn.cn_hash = un->un_hash;
918: cn.cn_consume = 0;
919:
920: VREF(un->un_dirvp);
921: if (error = relookup(un->un_dirvp, &vp, &cn))
922: return (error);
923: vrele(un->un_dirvp);
924:
925: if (vp) {
926: VOP_ABORTOP(un->un_dirvp, &cn);
927: if (un->un_dirvp == vp)
928: vrele(un->un_dirvp);
929: else
930: vput(un->un_dirvp);
931: vrele(vp);
932: return (EEXIST);
933: }
934:
935: /*
936: * Good - there was no race to create the file
937: * so go ahead and create it. The permissions
938: * on the file will be 0666 modified by the
939: * current user's umask. Access to the file, while
940: * it is unioned, will require access to the top *and*
941: * bottom files. Access when not unioned will simply
942: * require access to the top-level file.
943: * TODO: confirm choice of access permissions.
944: */
945: VATTR_NULL(vap);
946: vap->va_type = VREG;
947: vap->va_mode = cmode;
948: VOP_LEASE(un->un_dirvp, p, cred, LEASE_WRITE);
949: if (error = VOP_CREATE(un->un_dirvp, &vp, &cn, vap))
950: return (error);
951:
952: if (error = VOP_OPEN(vp, fmode, cred, p)) {
953: vput(vp);
954: return (error);
955: }
956:
957: if (++vp->v_writecount <= 0)
958: panic("union: v_writecount");
959: *vpp = vp;
960: return (0);
961: }
962:
963: int
964: union_vn_close(vp, fmode, cred, p)
965: struct vnode *vp;
966: int fmode;
967: struct ucred *cred;
968: struct proc *p;
969: {
970:
971: if (fmode & FWRITE)
972: --vp->v_writecount;
973: return (VOP_CLOSE(vp, fmode, cred, p));
974: }
975:
976: void
977: union_removed_upper(un)
978: struct union_node *un;
979: {
980: struct proc *p = current_proc(); /* XXX */
981:
982: union_newupper(un, NULLVP);
983: if (un->un_flags & UN_CACHED) {
984: un->un_flags &= ~UN_CACHED;
985: LIST_REMOVE(un, un_cache);
986: }
987:
988: if (un->un_flags & UN_ULOCK) {
989: un->un_flags &= ~UN_ULOCK;
990: VOP_UNLOCK(un->un_uppervp, 0, p);
991: }
992: }
993:
994: #if 0
995: struct vnode *
996: union_lowervp(vp)
997: struct vnode *vp;
998: {
999: struct union_node *un = VTOUNION(vp);
1000:
1001: if ((un->un_lowervp != NULLVP) &&
1002: (vp->v_type == un->un_lowervp->v_type)) {
1003: if (vget(un->un_lowervp, 0) == 0)
1004: return (un->un_lowervp);
1005: }
1006:
1007: return (NULLVP);
1008: }
1009: #endif
1010:
1011: /*
1012: * determine whether a whiteout is needed
1013: * during a remove/rmdir operation.
1014: */
1015: int
1016: union_dowhiteout(un, cred, p)
1017: struct union_node *un;
1018: struct ucred *cred;
1019: struct proc *p;
1020: {
1021: struct vattr va;
1022:
1023: if (un->un_lowervp != NULLVP)
1024: return (1);
1025:
1026: if (VOP_GETATTR(un->un_uppervp, &va, cred, p) == 0 &&
1027: (va.va_flags & OPAQUE))
1028: return (1);
1029:
1030: return (0);
1031: }
1032:
1033: static void
1034: union_dircache_r(vp, vppp, cntp)
1035: struct vnode *vp;
1036: struct vnode ***vppp;
1037: int *cntp;
1038: {
1039: struct union_node *un;
1040:
1041: if (vp->v_op != union_vnodeop_p) {
1042: if (vppp) {
1043: VREF(vp);
1044: *(*vppp)++ = vp;
1045: if (--(*cntp) == 0)
1046: panic("union: dircache table too small");
1047: } else {
1048: (*cntp)++;
1049: }
1050:
1051: return;
1052: }
1053:
1054: un = VTOUNION(vp);
1055: if (un->un_uppervp != NULLVP)
1056: union_dircache_r(un->un_uppervp, vppp, cntp);
1057: if (un->un_lowervp != NULLVP)
1058: union_dircache_r(un->un_lowervp, vppp, cntp);
1059: }
1060:
1061: struct vnode *
1062: union_dircache(vp, p)
1063: struct vnode *vp;
1064: struct proc *p;
1065: {
1066: int cnt;
1067: struct vnode *nvp;
1068: struct vnode **vpp;
1069: struct vnode **dircache;
1070: struct union_node *un;
1071: int error;
1072:
1073: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
1074: dircache = VTOUNION(vp)->un_dircache;
1075:
1076: nvp = NULLVP;
1077:
1078: if (dircache == 0) {
1079: cnt = 0;
1080: union_dircache_r(vp, 0, &cnt);
1081: cnt++;
1082: dircache = (struct vnode **)
1083: _MALLOC(cnt * sizeof(struct vnode *),
1084: M_TEMP, M_WAITOK);
1085: vpp = dircache;
1086: union_dircache_r(vp, &vpp, &cnt);
1087: *vpp = NULLVP;
1088: vpp = dircache + 1;
1089: } else {
1090: vpp = dircache;
1091: do {
1092: if (*vpp++ == VTOUNION(vp)->un_uppervp)
1093: break;
1094: } while (*vpp != NULLVP);
1095: }
1096:
1097: if (*vpp == NULLVP)
1098: goto out;
1099:
1100: vn_lock(*vpp, LK_EXCLUSIVE | LK_RETRY, p);
1101: VREF(*vpp);
1102: error = union_allocvp(&nvp, vp->v_mount, NULLVP, NULLVP, 0, *vpp, NULLVP, 0);
1103: if (error)
1104: goto out;
1105:
1106: VTOUNION(vp)->un_dircache = 0;
1107: un = VTOUNION(nvp);
1108: un->un_dircache = dircache;
1109:
1110: out:
1111: VOP_UNLOCK(vp, 0, p);
1112: return (nvp);
1113: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.