![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vfs_subr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / kern|
Return to vfs_subr.c CVS log | Up to [Net/2] / Net2 / kern |
1.1 root 1: /*
2: * Copyright (c) 1989 The Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms, with or without
6: * modification, are permitted provided that the following conditions
7: * are met:
8: * 1. Redistributions of source code must retain the above copyright
9: * notice, this list of conditions and the following disclaimer.
10: * 2. Redistributions in binary form must reproduce the above copyright
11: * notice, this list of conditions and the following disclaimer in the
12: * documentation and/or other materials provided with the distribution.
13: * 3. All advertising materials mentioning features or use of this software
14: * must display the following acknowledgement:
15: * This product includes software developed by the University of
16: * California, Berkeley and its contributors.
17: * 4. Neither the name of the University nor the names of its contributors
18: * may be used to endorse or promote products derived from this software
19: * without specific prior written permission.
20: *
21: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31: * SUCH DAMAGE.
32: *
33: * @(#)vfs_subr.c 7.60 (Berkeley) 6/21/91
34: */
35:
36: /*
37: * External virtual filesystem routines
38: */
39:
40: #include "param.h"
41: #include "proc.h"
42: #include "mount.h"
43: #include "time.h"
44: #include "vnode.h"
45: #include "specdev.h"
46: #include "namei.h"
47: #include "ucred.h"
48: #include "buf.h"
49: #include "errno.h"
50: #include "malloc.h"
51:
52: /*
53: * Remove a mount point from the list of mounted filesystems.
54: * Unmount of the root is illegal.
55: */
56: void
57: vfs_remove(mp)
58: register struct mount *mp;
59: {
60:
61: if (mp == rootfs)
62: panic("vfs_remove: unmounting root");
63: mp->mnt_prev->mnt_next = mp->mnt_next;
64: mp->mnt_next->mnt_prev = mp->mnt_prev;
65: mp->mnt_vnodecovered->v_mountedhere = (struct mount *)0;
66: vfs_unlock(mp);
67: }
68:
69: /*
70: * Lock a filesystem.
71: * Used to prevent access to it while mounting and unmounting.
72: */
73: vfs_lock(mp)
74: register struct mount *mp;
75: {
76:
77: while(mp->mnt_flag & MNT_MLOCK) {
78: mp->mnt_flag |= MNT_MWAIT;
79: sleep((caddr_t)mp, PVFS);
80: }
81: mp->mnt_flag |= MNT_MLOCK;
82: return (0);
83: }
84:
85: /*
86: * Unlock a locked filesystem.
87: * Panic if filesystem is not locked.
88: */
89: void
90: vfs_unlock(mp)
91: register struct mount *mp;
92: {
93:
94: if ((mp->mnt_flag & MNT_MLOCK) == 0)
95: panic("vfs_unlock: not locked");
96: mp->mnt_flag &= ~MNT_MLOCK;
97: if (mp->mnt_flag & MNT_MWAIT) {
98: mp->mnt_flag &= ~MNT_MWAIT;
99: wakeup((caddr_t)mp);
100: }
101: }
102:
103: /*
104: * Mark a mount point as busy.
105: * Used to synchronize access and to delay unmounting.
106: */
107: vfs_busy(mp)
108: register struct mount *mp;
109: {
110:
111: while(mp->mnt_flag & MNT_MPBUSY) {
112: mp->mnt_flag |= MNT_MPWANT;
113: sleep((caddr_t)&mp->mnt_flag, PVFS);
114: }
115: if (mp->mnt_flag & MNT_UNMOUNT)
116: return (1);
117: mp->mnt_flag |= MNT_MPBUSY;
118: return (0);
119: }
120:
121: /*
122: * Free a busy filesystem.
123: * Panic if filesystem is not busy.
124: */
125: vfs_unbusy(mp)
126: register struct mount *mp;
127: {
128:
129: if ((mp->mnt_flag & MNT_MPBUSY) == 0)
130: panic("vfs_unbusy: not busy");
131: mp->mnt_flag &= ~MNT_MPBUSY;
132: if (mp->mnt_flag & MNT_MPWANT) {
133: mp->mnt_flag &= ~MNT_MPWANT;
134: wakeup((caddr_t)&mp->mnt_flag);
135: }
136: }
137:
138: /*
139: * Lookup a mount point by filesystem identifier.
140: */
141: struct mount *
142: getvfs(fsid)
143: fsid_t *fsid;
144: {
145: register struct mount *mp;
146:
147: mp = rootfs;
148: do {
149: if (mp->mnt_stat.f_fsid.val[0] == fsid->val[0] &&
150: mp->mnt_stat.f_fsid.val[1] == fsid->val[1]) {
151: return (mp);
152: }
153: mp = mp->mnt_next;
154: } while (mp != rootfs);
155: return ((struct mount *)0);
156: }
157:
158: /*
159: * Set vnode attributes to VNOVAL
160: */
161: void vattr_null(vap)
162: register struct vattr *vap;
163: {
164:
165: vap->va_type = VNON;
166: vap->va_mode = vap->va_nlink = vap->va_uid = vap->va_gid =
167: vap->va_fsid = vap->va_fileid = vap->va_size =
168: vap->va_size_rsv = vap->va_blocksize = vap->va_rdev =
169: vap->va_bytes = vap->va_bytes_rsv =
170: vap->va_atime.tv_sec = vap->va_atime.tv_usec =
171: vap->va_mtime.tv_sec = vap->va_mtime.tv_usec =
172: vap->va_ctime.tv_sec = vap->va_ctime.tv_usec =
173: vap->va_flags = vap->va_gen = VNOVAL;
174: }
175:
176: /*
177: * Routines having to do with the management of the vnode table.
178: */
179: struct vnode *vfreeh, **vfreet;
180: extern struct vnodeops dead_vnodeops, spec_vnodeops;
181: extern void vclean();
182: long numvnodes;
183: struct vattr va_null;
184:
185: /*
186: * Initialize the vnode structures and initialize each file system type.
187: */
188: vfsinit()
189: {
190: struct vfsops **vfsp;
191:
192: /*
193: * Initialize the vnode name cache
194: */
195: nchinit();
196: /*
197: * Initialize each file system type.
198: */
199: vattr_null(&va_null);
200: for (vfsp = &vfssw[0]; vfsp <= &vfssw[MOUNT_MAXTYPE]; vfsp++) {
201: if (*vfsp == NULL)
202: continue;
203: (*(*vfsp)->vfs_init)();
204: }
205: }
206:
207: /*
208: * Return the next vnode from the free list.
209: */
210: getnewvnode(tag, mp, vops, vpp)
211: enum vtagtype tag;
212: struct mount *mp;
213: struct vnodeops *vops;
214: struct vnode **vpp;
215: {
216: register struct vnode *vp, *vq;
217:
218: if (numvnodes < desiredvnodes) {
219: vp = (struct vnode *)malloc((u_long)sizeof *vp,
220: M_VNODE, M_WAITOK);
221: bzero((char *)vp, sizeof *vp);
222: numvnodes++;
223: } else {
224: if ((vp = vfreeh) == NULL) {
225: tablefull("vnode");
226: *vpp = 0;
227: return (ENFILE);
228: }
229: if (vp->v_usecount)
230: panic("free vnode isn't");
231: if (vq = vp->v_freef)
232: vq->v_freeb = &vfreeh;
233: else
234: vfreet = &vfreeh;
235: vfreeh = vq;
236: vp->v_freef = NULL;
237: vp->v_freeb = NULL;
238: if (vp->v_type != VBAD)
239: vgone(vp);
240: vp->v_flag = 0;
241: vp->v_lastr = 0;
242: vp->v_socket = 0;
243: }
244: vp->v_type = VNON;
245: cache_purge(vp);
246: vp->v_tag = tag;
247: vp->v_op = vops;
248: insmntque(vp, mp);
249: VREF(vp);
250: *vpp = vp;
251: return (0);
252: }
253:
254: /*
255: * Move a vnode from one mount queue to another.
256: */
257: insmntque(vp, mp)
258: register struct vnode *vp;
259: register struct mount *mp;
260: {
261: register struct vnode *vq;
262:
263: /*
264: * Delete from old mount point vnode list, if on one.
265: */
266: if (vp->v_mountb) {
267: if (vq = vp->v_mountf)
268: vq->v_mountb = vp->v_mountb;
269: *vp->v_mountb = vq;
270: }
271: /*
272: * Insert into list of vnodes for the new mount point, if available.
273: */
274: vp->v_mount = mp;
275: if (mp == NULL) {
276: vp->v_mountf = NULL;
277: vp->v_mountb = NULL;
278: return;
279: }
280: if (vq = mp->mnt_mounth)
281: vq->v_mountb = &vp->v_mountf;
282: vp->v_mountf = vq;
283: vp->v_mountb = &mp->mnt_mounth;
284: mp->mnt_mounth = vp;
285: }
286:
287: /*
288: * Make sure all write-behind blocks associated
289: * with mount point are flushed out (from sync).
290: */
291: mntflushbuf(mountp, flags)
292: struct mount *mountp;
293: int flags;
294: {
295: register struct vnode *vp;
296:
297: if ((mountp->mnt_flag & MNT_MPBUSY) == 0)
298: panic("mntflushbuf: not busy");
299: loop:
300: for (vp = mountp->mnt_mounth; vp; vp = vp->v_mountf) {
301: if (VOP_ISLOCKED(vp))
302: continue;
303: if (vget(vp))
304: goto loop;
305: vflushbuf(vp, flags);
306: vput(vp);
307: if (vp->v_mount != mountp)
308: goto loop;
309: }
310: }
311:
312: /*
313: * Flush all dirty buffers associated with a vnode.
314: */
315: vflushbuf(vp, flags)
316: register struct vnode *vp;
317: int flags;
318: {
319: register struct buf *bp;
320: struct buf *nbp;
321: int s;
322:
323: loop:
324: s = splbio();
325: for (bp = vp->v_dirtyblkhd; bp; bp = nbp) {
326: nbp = bp->b_blockf;
327: if ((bp->b_flags & B_BUSY))
328: continue;
329: if ((bp->b_flags & B_DELWRI) == 0)
330: panic("vflushbuf: not dirty");
331: bremfree(bp);
332: bp->b_flags |= B_BUSY;
333: splx(s);
334: /*
335: * Wait for I/O associated with indirect blocks to complete,
336: * since there is no way to quickly wait for them below.
337: * NB: This is really specific to ufs, but is done here
338: * as it is easier and quicker.
339: */
340: if (bp->b_vp == vp || (flags & B_SYNC) == 0)
341: (void) bawrite(bp);
342: else
343: (void) bwrite(bp);
344: goto loop;
345: }
346: splx(s);
347: if ((flags & B_SYNC) == 0)
348: return;
349: s = splbio();
350: while (vp->v_numoutput) {
351: vp->v_flag |= VBWAIT;
352: sleep((caddr_t)&vp->v_numoutput, PRIBIO + 1);
353: }
354: splx(s);
355: if (vp->v_dirtyblkhd) {
356: vprint("vflushbuf: dirty", vp);
357: goto loop;
358: }
359: }
360:
361: /*
362: * Update outstanding I/O count and do wakeup if requested.
363: */
364: vwakeup(bp)
365: register struct buf *bp;
366: {
367: register struct vnode *vp;
368:
369: bp->b_dirtyoff = bp->b_dirtyend = 0;
370: if (vp = bp->b_vp) {
371: vp->v_numoutput--;
372: if ((vp->v_flag & VBWAIT) && vp->v_numoutput <= 0) {
373: if (vp->v_numoutput < 0)
374: panic("vwakeup: neg numoutput");
375: vp->v_flag &= ~VBWAIT;
376: wakeup((caddr_t)&vp->v_numoutput);
377: }
378: }
379: }
380:
381: /*
382: * Invalidate in core blocks belonging to closed or umounted filesystem
383: *
384: * Go through the list of vnodes associated with the file system;
385: * for each vnode invalidate any buffers that it holds. Normally
386: * this routine is preceeded by a bflush call, so that on a quiescent
387: * filesystem there will be no dirty buffers when we are done. Binval
388: * returns the count of dirty buffers when it is finished.
389: */
390: mntinvalbuf(mountp)
391: struct mount *mountp;
392: {
393: register struct vnode *vp;
394: int dirty = 0;
395:
396: if ((mountp->mnt_flag & MNT_MPBUSY) == 0)
397: panic("mntinvalbuf: not busy");
398: loop:
399: for (vp = mountp->mnt_mounth; vp; vp = vp->v_mountf) {
400: if (vget(vp))
401: goto loop;
402: dirty += vinvalbuf(vp, 1);
403: vput(vp);
404: if (vp->v_mount != mountp)
405: goto loop;
406: }
407: return (dirty);
408: }
409:
410: /*
411: * Flush out and invalidate all buffers associated with a vnode.
412: * Called with the underlying object locked.
413: */
414: vinvalbuf(vp, save)
415: register struct vnode *vp;
416: int save;
417: {
418: register struct buf *bp;
419: struct buf *nbp, *blist;
420: int s, dirty = 0;
421:
422: for (;;) {
423: if (blist = vp->v_dirtyblkhd)
424: /* void */;
425: else if (blist = vp->v_cleanblkhd)
426: /* void */;
427: else
428: break;
429: for (bp = blist; bp; bp = nbp) {
430: nbp = bp->b_blockf;
431: s = splbio();
432: if (bp->b_flags & B_BUSY) {
433: bp->b_flags |= B_WANTED;
434: sleep((caddr_t)bp, PRIBIO + 1);
435: splx(s);
436: break;
437: }
438: bremfree(bp);
439: bp->b_flags |= B_BUSY;
440: splx(s);
441: if (save && (bp->b_flags & B_DELWRI)) {
442: dirty++;
443: (void) bwrite(bp);
444: break;
445: }
446: if (bp->b_vp != vp)
447: reassignbuf(bp, bp->b_vp);
448: else
449: bp->b_flags |= B_INVAL;
450: brelse(bp);
451: }
452: }
453: if (vp->v_dirtyblkhd || vp->v_cleanblkhd)
454: panic("vinvalbuf: flush failed");
455: return (dirty);
456: }
457:
458: /*
459: * Associate a buffer with a vnode.
460: */
461: bgetvp(vp, bp)
462: register struct vnode *vp;
463: register struct buf *bp;
464: {
465: register struct vnode *vq;
466: register struct buf *bq;
467:
468: if (bp->b_vp)
469: panic("bgetvp: not free");
470: VHOLD(vp);
471: bp->b_vp = vp;
472: if (vp->v_type == VBLK || vp->v_type == VCHR)
473: bp->b_dev = vp->v_rdev;
474: else
475: bp->b_dev = NODEV;
476: /*
477: * Insert onto list for new vnode.
478: */
479: if (bq = vp->v_cleanblkhd)
480: bq->b_blockb = &bp->b_blockf;
481: bp->b_blockf = bq;
482: bp->b_blockb = &vp->v_cleanblkhd;
483: vp->v_cleanblkhd = bp;
484: }
485:
486: /*
487: * Disassociate a buffer from a vnode.
488: */
489: brelvp(bp)
490: register struct buf *bp;
491: {
492: struct buf *bq;
493: struct vnode *vp;
494:
495: if (bp->b_vp == (struct vnode *) 0)
496: panic("brelvp: NULL");
497: /*
498: * Delete from old vnode list, if on one.
499: */
500: if (bp->b_blockb) {
501: if (bq = bp->b_blockf)
502: bq->b_blockb = bp->b_blockb;
503: *bp->b_blockb = bq;
504: bp->b_blockf = NULL;
505: bp->b_blockb = NULL;
506: }
507: vp = bp->b_vp;
508: bp->b_vp = (struct vnode *) 0;
509: HOLDRELE(vp);
510: }
511:
512: /*
513: * Reassign a buffer from one vnode to another.
514: * Used to assign file specific control information
515: * (indirect blocks) to the vnode to which they belong.
516: */
517: reassignbuf(bp, newvp)
518: register struct buf *bp;
519: register struct vnode *newvp;
520: {
521: register struct buf *bq, **listheadp;
522:
523: if (newvp == NULL)
524: panic("reassignbuf: NULL");
525: /*
526: * Delete from old vnode list, if on one.
527: */
528: if (bp->b_blockb) {
529: if (bq = bp->b_blockf)
530: bq->b_blockb = bp->b_blockb;
531: *bp->b_blockb = bq;
532: }
533: /*
534: * If dirty, put on list of dirty buffers;
535: * otherwise insert onto list of clean buffers.
536: */
537: if (bp->b_flags & B_DELWRI)
538: listheadp = &newvp->v_dirtyblkhd;
539: else
540: listheadp = &newvp->v_cleanblkhd;
541: if (bq = *listheadp)
542: bq->b_blockb = &bp->b_blockf;
543: bp->b_blockf = bq;
544: bp->b_blockb = listheadp;
545: *listheadp = bp;
546: }
547:
548: /*
549: * Create a vnode for a block device.
550: * Used for root filesystem, argdev, and swap areas.
551: * Also used for memory file system special devices.
552: */
553: bdevvp(dev, vpp)
554: dev_t dev;
555: struct vnode **vpp;
556: {
557: register struct vnode *vp;
558: struct vnode *nvp;
559: int error;
560:
561: if (dev == NODEV)
562: return (0);
563: error = getnewvnode(VT_NON, (struct mount *)0, &spec_vnodeops, &nvp);
564: if (error) {
565: *vpp = 0;
566: return (error);
567: }
568: vp = nvp;
569: vp->v_type = VBLK;
570: if (nvp = checkalias(vp, dev, (struct mount *)0)) {
571: vput(vp);
572: vp = nvp;
573: }
574: *vpp = vp;
575: return (0);
576: }
577:
578: /*
579: * Check to see if the new vnode represents a special device
580: * for which we already have a vnode (either because of
581: * bdevvp() or because of a different vnode representing
582: * the same block device). If such an alias exists, deallocate
583: * the existing contents and return the aliased vnode. The
584: * caller is responsible for filling it with its new contents.
585: */
586: struct vnode *
587: checkalias(nvp, nvp_rdev, mp)
588: register struct vnode *nvp;
589: dev_t nvp_rdev;
590: struct mount *mp;
591: {
592: register struct vnode *vp;
593: struct vnode **vpp;
594:
595: if (nvp->v_type != VBLK && nvp->v_type != VCHR)
596: return (NULLVP);
597:
598: vpp = &speclisth[SPECHASH(nvp_rdev)];
599: loop:
600: for (vp = *vpp; vp; vp = vp->v_specnext) {
601: if (nvp_rdev != vp->v_rdev || nvp->v_type != vp->v_type)
602: continue;
603: /*
604: * Alias, but not in use, so flush it out.
605: */
606: if (vp->v_usecount == 0) {
607: vgone(vp);
608: goto loop;
609: }
610: if (vget(vp))
611: goto loop;
612: break;
613: }
614: if (vp == NULL || vp->v_tag != VT_NON) {
615: MALLOC(nvp->v_specinfo, struct specinfo *,
616: sizeof(struct specinfo), M_VNODE, M_WAITOK);
617: nvp->v_rdev = nvp_rdev;
618: nvp->v_hashchain = vpp;
619: nvp->v_specnext = *vpp;
620: nvp->v_specflags = 0;
621: *vpp = nvp;
622: if (vp != NULL) {
623: nvp->v_flag |= VALIASED;
624: vp->v_flag |= VALIASED;
625: vput(vp);
626: }
627: return (NULLVP);
628: }
629: VOP_UNLOCK(vp);
630: vclean(vp, 0);
631: vp->v_op = nvp->v_op;
632: vp->v_tag = nvp->v_tag;
633: nvp->v_type = VNON;
634: insmntque(vp, mp);
635: return (vp);
636: }
637:
638: /*
639: * Grab a particular vnode from the free list, increment its
640: * reference count and lock it. The vnode lock bit is set the
641: * vnode is being eliminated in vgone. The process is awakened
642: * when the transition is completed, and an error returned to
643: * indicate that the vnode is no longer usable (possibly having
644: * been changed to a new file system type).
645: */
646: vget(vp)
647: register struct vnode *vp;
648: {
649: register struct vnode *vq;
650:
651: if (vp->v_flag & VXLOCK) {
652: vp->v_flag |= VXWANT;
653: sleep((caddr_t)vp, PINOD);
654: return (1);
655: }
656: if (vp->v_usecount == 0) {
657: if (vq = vp->v_freef)
658: vq->v_freeb = vp->v_freeb;
659: else
660: vfreet = vp->v_freeb;
661: *vp->v_freeb = vq;
662: vp->v_freef = NULL;
663: vp->v_freeb = NULL;
664: }
665: VREF(vp);
666: VOP_LOCK(vp);
667: return (0);
668: }
669:
670: /*
671: * Vnode reference, just increment the count
672: */
673: void vref(vp)
674: struct vnode *vp;
675: {
676:
677: vp->v_usecount++;
678: }
679:
680: /*
681: * vput(), just unlock and vrele()
682: */
683: void vput(vp)
684: register struct vnode *vp;
685: {
686: VOP_UNLOCK(vp);
687: vrele(vp);
688: }
689:
690: /*
691: * Vnode release.
692: * If count drops to zero, call inactive routine and return to freelist.
693: */
694: void vrele(vp)
695: register struct vnode *vp;
696: {
697: struct proc *p = curproc; /* XXX */
698:
699: #ifdef DIAGNOSTIC
700: if (vp == NULL)
701: panic("vrele: null vp");
702: #endif
703: vp->v_usecount--;
704: if (vp->v_usecount > 0)
705: return;
706: #ifdef DIAGNOSTIC
707: if (vp->v_usecount != 0 || vp->v_writecount != 0) {
708: vprint("vrele: bad ref count", vp);
709: panic("vrele: ref cnt");
710: }
711: #endif
712: if (vfreeh == NULLVP) {
713: /*
714: * insert into empty list
715: */
716: vfreeh = vp;
717: vp->v_freeb = &vfreeh;
718: } else {
719: /*
720: * insert at tail of list
721: */
722: *vfreet = vp;
723: vp->v_freeb = vfreet;
724: }
725: vp->v_freef = NULL;
726: vfreet = &vp->v_freef;
727: VOP_INACTIVE(vp, p);
728: }
729:
730: /*
731: * Page or buffer structure gets a reference.
732: */
733: vhold(vp)
734: register struct vnode *vp;
735: {
736:
737: vp->v_holdcnt++;
738: }
739:
740: /*
741: * Page or buffer structure frees a reference.
742: */
743: holdrele(vp)
744: register struct vnode *vp;
745: {
746:
747: if (vp->v_holdcnt <= 0)
748: panic("holdrele: holdcnt");
749: vp->v_holdcnt--;
750: }
751:
752: /*
753: * Remove any vnodes in the vnode table belonging to mount point mp.
754: *
755: * If MNT_NOFORCE is specified, there should not be any active ones,
756: * return error if any are found (nb: this is a user error, not a
757: * system error). If MNT_FORCE is specified, detach any active vnodes
758: * that are found.
759: */
760: int busyprt = 0; /* patch to print out busy vnodes */
761:
762: vflush(mp, skipvp, flags)
763: struct mount *mp;
764: struct vnode *skipvp;
765: int flags;
766: {
767: register struct vnode *vp, *nvp;
768: int busy = 0;
769:
770: if ((mp->mnt_flag & MNT_MPBUSY) == 0)
771: panic("vflush: not busy");
772: loop:
773: for (vp = mp->mnt_mounth; vp; vp = nvp) {
774: if (vp->v_mount != mp)
775: goto loop;
776: nvp = vp->v_mountf;
777: /*
778: * Skip over a selected vnode.
779: */
780: if (vp == skipvp)
781: continue;
782: /*
783: * Skip over a vnodes marked VSYSTEM.
784: */
785: if ((flags & SKIPSYSTEM) && (vp->v_flag & VSYSTEM))
786: continue;
787: /*
788: * With v_usecount == 0, all we need to do is clear
789: * out the vnode data structures and we are done.
790: */
791: if (vp->v_usecount == 0) {
792: vgone(vp);
793: continue;
794: }
795: /*
796: * For block or character devices, revert to an
797: * anonymous device. For all other files, just kill them.
798: */
799: if (flags & FORCECLOSE) {
800: if (vp->v_type != VBLK && vp->v_type != VCHR) {
801: vgone(vp);
802: } else {
803: vclean(vp, 0);
804: vp->v_op = &spec_vnodeops;
805: insmntque(vp, (struct mount *)0);
806: }
807: continue;
808: }
809: if (busyprt)
810: vprint("vflush: busy vnode", vp);
811: busy++;
812: }
813: if (busy)
814: return (EBUSY);
815: return (0);
816: }
817:
818: /*
819: * Disassociate the underlying file system from a vnode.
820: */
821: void vclean(vp, flags)
822: register struct vnode *vp;
823: int flags;
824: {
825: struct vnodeops *origops;
826: int active;
827: struct proc *p = curproc; /* XXX */
828:
829: /*
830: * Check to see if the vnode is in use.
831: * If so we have to reference it before we clean it out
832: * so that its count cannot fall to zero and generate a
833: * race against ourselves to recycle it.
834: */
835: if (active = vp->v_usecount)
836: VREF(vp);
837: /*
838: * Prevent the vnode from being recycled or
839: * brought into use while we clean it out.
840: */
841: if (vp->v_flag & VXLOCK)
842: panic("vclean: deadlock");
843: vp->v_flag |= VXLOCK;
844: /*
845: * Even if the count is zero, the VOP_INACTIVE routine may still
846: * have the object locked while it cleans it out. The VOP_LOCK
847: * ensures that the VOP_INACTIVE routine is done with its work.
848: * For active vnodes, it ensures that no other activity can
849: * occur while the buffer list is being cleaned out.
850: */
851: VOP_LOCK(vp);
852: if (flags & DOCLOSE)
853: vinvalbuf(vp, 1);
854: /*
855: * Prevent any further operations on the vnode from
856: * being passed through to the old file system.
857: */
858: origops = vp->v_op;
859: vp->v_op = &dead_vnodeops;
860: vp->v_tag = VT_NON;
861: /*
862: * If purging an active vnode, it must be unlocked, closed,
863: * and deactivated before being reclaimed.
864: */
865: (*(origops->vop_unlock))(vp);
866: if (active) {
867: if (flags & DOCLOSE)
868: (*(origops->vop_close))(vp, IO_NDELAY, NOCRED, p);
869: (*(origops->vop_inactive))(vp, p);
870: }
871: /*
872: * Reclaim the vnode.
873: */
874: if ((*(origops->vop_reclaim))(vp))
875: panic("vclean: cannot reclaim");
876: if (active)
877: vrele(vp);
878: /*
879: * Done with purge, notify sleepers in vget of the grim news.
880: */
881: vp->v_flag &= ~VXLOCK;
882: if (vp->v_flag & VXWANT) {
883: vp->v_flag &= ~VXWANT;
884: wakeup((caddr_t)vp);
885: }
886: }
887:
888: /*
889: * Eliminate all activity associated with the requested vnode
890: * and with all vnodes aliased to the requested vnode.
891: */
892: void vgoneall(vp)
893: register struct vnode *vp;
894: {
895: register struct vnode *vq;
896:
897: if (vp->v_flag & VALIASED) {
898: /*
899: * If a vgone (or vclean) is already in progress,
900: * wait until it is done and return.
901: */
902: if (vp->v_flag & VXLOCK) {
903: vp->v_flag |= VXWANT;
904: sleep((caddr_t)vp, PINOD);
905: return;
906: }
907: /*
908: * Ensure that vp will not be vgone'd while we
909: * are eliminating its aliases.
910: */
911: vp->v_flag |= VXLOCK;
912: while (vp->v_flag & VALIASED) {
913: for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) {
914: if (vq->v_rdev != vp->v_rdev ||
915: vq->v_type != vp->v_type || vp == vq)
916: continue;
917: vgone(vq);
918: break;
919: }
920: }
921: /*
922: * Remove the lock so that vgone below will
923: * really eliminate the vnode after which time
924: * vgone will awaken any sleepers.
925: */
926: vp->v_flag &= ~VXLOCK;
927: }
928: vgone(vp);
929: }
930:
931: /*
932: * Eliminate all activity associated with a vnode
933: * in preparation for reuse.
934: */
935: void vgone(vp)
936: register struct vnode *vp;
937: {
938: register struct vnode *vq;
939: struct vnode *vx;
940: long count;
941:
942: /*
943: * If a vgone (or vclean) is already in progress,
944: * wait until it is done and return.
945: */
946: if (vp->v_flag & VXLOCK) {
947: vp->v_flag |= VXWANT;
948: sleep((caddr_t)vp, PINOD);
949: return;
950: }
951: /*
952: * Clean out the filesystem specific data.
953: */
954: vclean(vp, DOCLOSE);
955: /*
956: * Delete from old mount point vnode list, if on one.
957: */
958: if (vp->v_mountb) {
959: if (vq = vp->v_mountf)
960: vq->v_mountb = vp->v_mountb;
961: *vp->v_mountb = vq;
962: vp->v_mountf = NULL;
963: vp->v_mountb = NULL;
964: }
965: /*
966: * If special device, remove it from special device alias list.
967: */
968: if (vp->v_type == VBLK || vp->v_type == VCHR) {
969: if (*vp->v_hashchain == vp) {
970: *vp->v_hashchain = vp->v_specnext;
971: } else {
972: for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) {
973: if (vq->v_specnext != vp)
974: continue;
975: vq->v_specnext = vp->v_specnext;
976: break;
977: }
978: if (vq == NULL)
979: panic("missing bdev");
980: }
981: if (vp->v_flag & VALIASED) {
982: count = 0;
983: for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) {
984: if (vq->v_rdev != vp->v_rdev ||
985: vq->v_type != vp->v_type)
986: continue;
987: count++;
988: vx = vq;
989: }
990: if (count == 0)
991: panic("missing alias");
992: if (count == 1)
993: vx->v_flag &= ~VALIASED;
994: vp->v_flag &= ~VALIASED;
995: }
996: FREE(vp->v_specinfo, M_VNODE);
997: vp->v_specinfo = NULL;
998: }
999: /*
1000: * If it is on the freelist, move it to the head of the list.
1001: */
1002: if (vp->v_freeb) {
1003: if (vq = vp->v_freef)
1004: vq->v_freeb = vp->v_freeb;
1005: else
1006: vfreet = vp->v_freeb;
1007: *vp->v_freeb = vq;
1008: vp->v_freef = vfreeh;
1009: vp->v_freeb = &vfreeh;
1010: vfreeh->v_freeb = &vp->v_freef;
1011: vfreeh = vp;
1012: }
1013: vp->v_type = VBAD;
1014: }
1015:
1016: /*
1017: * Lookup a vnode by device number.
1018: */
1019: vfinddev(dev, type, vpp)
1020: dev_t dev;
1021: enum vtype type;
1022: struct vnode **vpp;
1023: {
1024: register struct vnode *vp;
1025:
1026: for (vp = speclisth[SPECHASH(dev)]; vp; vp = vp->v_specnext) {
1027: if (dev != vp->v_rdev || type != vp->v_type)
1028: continue;
1029: *vpp = vp;
1030: return (0);
1031: }
1032: return (1);
1033: }
1034:
1035: /*
1036: * Calculate the total number of references to a special device.
1037: */
1038: vcount(vp)
1039: register struct vnode *vp;
1040: {
1041: register struct vnode *vq;
1042: int count;
1043:
1044: if ((vp->v_flag & VALIASED) == 0)
1045: return (vp->v_usecount);
1046: loop:
1047: for (count = 0, vq = *vp->v_hashchain; vq; vq = vq->v_specnext) {
1048: if (vq->v_rdev != vp->v_rdev || vq->v_type != vp->v_type)
1049: continue;
1050: /*
1051: * Alias, but not in use, so flush it out.
1052: */
1053: if (vq->v_usecount == 0) {
1054: vgone(vq);
1055: goto loop;
1056: }
1057: count += vq->v_usecount;
1058: }
1059: return (count);
1060: }
1061:
1062: /*
1063: * Print out a description of a vnode.
1064: */
1065: static char *typename[] =
1066: { "VNON", "VREG", "VDIR", "VBLK", "VCHR", "VLNK", "VSOCK", "VFIFO", "VBAD" };
1067:
1068: vprint(label, vp)
1069: char *label;
1070: register struct vnode *vp;
1071: {
1072: char buf[64];
1073:
1074: if (label != NULL)
1075: printf("%s: ", label);
1076: printf("type %s, usecount %d, writecount %d, refcount %d,",
1077: typename[vp->v_type], vp->v_usecount, vp->v_writecount,
1078: vp->v_holdcnt);
1079: buf[0] = '\0';
1080: if (vp->v_flag & VROOT)
1081: strcat(buf, "|VROOT");
1082: if (vp->v_flag & VTEXT)
1083: strcat(buf, "|VTEXT");
1084: if (vp->v_flag & VSYSTEM)
1085: strcat(buf, "|VSYSTEM");
1086: if (vp->v_flag & VXLOCK)
1087: strcat(buf, "|VXLOCK");
1088: if (vp->v_flag & VXWANT)
1089: strcat(buf, "|VXWANT");
1090: if (vp->v_flag & VBWAIT)
1091: strcat(buf, "|VBWAIT");
1092: if (vp->v_flag & VALIASED)
1093: strcat(buf, "|VALIASED");
1094: if (buf[0] != '\0')
1095: printf(" flags (%s)", &buf[1]);
1096: printf("\n\t");
1097: VOP_PRINT(vp);
1098: }
1099:
1100: #ifdef DEBUG
1101: /*
1102: * List all of the locked vnodes in the system.
1103: * Called when debugging the kernel.
1104: */
1105: printlockedvnodes()
1106: {
1107: register struct mount *mp;
1108: register struct vnode *vp;
1109:
1110: printf("Locked vnodes\n");
1111: mp = rootfs;
1112: do {
1113: for (vp = mp->mnt_mounth; vp; vp = vp->v_mountf)
1114: if (VOP_ISLOCKED(vp))
1115: vprint((char *)0, vp);
1116: mp = mp->mnt_next;
1117: } while (mp != rootfs);
1118: }
1119: #endif
1120:
1121: int kinfo_vdebug = 1;
1122: int kinfo_vgetfailed;
1123: #define KINFO_VNODESLOP 10
1124: /*
1125: * Dump vnode list (via kinfo).
1126: * Copyout address of vnode followed by vnode.
1127: */
1128: /* ARGSUSED */
1129: kinfo_vnode(op, where, acopysize, arg, aneeded)
1130: int op;
1131: char *where;
1132: int *acopysize, arg, *aneeded;
1133: {
1134: register struct mount *mp = rootfs;
1135: struct mount *omp;
1136: struct vnode *vp;
1137: register char *bp = where, *savebp;
1138: char *ewhere = where + *acopysize;
1139: int error;
1140:
1141: #define VPTRSZ sizeof (struct vnode *)
1142: #define VNODESZ sizeof (struct vnode)
1143: if (where == NULL) {
1144: *aneeded = (numvnodes + KINFO_VNODESLOP) * (VPTRSZ + VNODESZ);
1145: return (0);
1146: }
1147:
1148: do {
1149: if (vfs_busy(mp)) {
1150: mp = mp->mnt_next;
1151: continue;
1152: }
1153: savebp = bp;
1154: again:
1155: for (vp = mp->mnt_mounth; vp; vp = vp->v_mountf) {
1156: /*
1157: * Check that the vp is still associated with
1158: * this filesystem. RACE: could have been
1159: * recycled onto the same filesystem.
1160: */
1161: if (vp->v_mount != mp) {
1162: if (kinfo_vdebug)
1163: printf("kinfo: vp changed\n");
1164: bp = savebp;
1165: goto again;
1166: }
1167: if ((bp + VPTRSZ + VNODESZ <= ewhere) &&
1168: ((error = copyout((caddr_t)&vp, bp, VPTRSZ)) ||
1169: (error = copyout((caddr_t)vp, bp + VPTRSZ,
1170: VNODESZ))))
1171: return (error);
1172: bp += VPTRSZ + VNODESZ;
1173: }
1174: omp = mp;
1175: mp = mp->mnt_next;
1176: vfs_unbusy(omp);
1177: } while (mp != rootfs);
1178:
1179: *aneeded = bp - where;
1180: if (bp > ewhere)
1181: *acopysize = ewhere - where;
1182: else
1183: *acopysize = bp - where;
1184: return (0);
1185: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.