![[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 [CSRG BSD Unix] / 43BSDReno / sys / kern|
Return to vfs_subr.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / kern |
1.1 root 1: /*
2: * Copyright (c) 1989 The Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution is only permitted until one year after the first shipment
6: * of 4.4BSD by the Regents. Otherwise, redistribution and use in source and
7: * binary forms are permitted provided that: (1) source distributions retain
8: * this entire copyright notice and comment, and (2) distributions including
9: * binaries display the following acknowledgement: This product includes
10: * software developed by the University of California, Berkeley and its
11: * contributors'' in the documentation or other materials provided with the
12: * distribution and in all advertising materials mentioning features or use
13: * of this software. Neither the name of the University nor the names of
14: * its contributors may be used to endorse or promote products derived from
15: * this software without specific prior written permission.
16: * THIS SOFTWARE IS PROVIDED AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
17: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
18: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
19: *
20: * @(#)vfs_subr.c 7.47 (Berkeley) 6/28/90
21: */
22:
23: /*
24: * External virtual filesystem routines
25: */
26:
27: #include "param.h"
28: #include "mount.h"
29: #include "time.h"
30: #include "vnode.h"
31: #include "specdev.h"
32: #include "namei.h"
33: #include "ucred.h"
34: #include "errno.h"
35: #include "malloc.h"
36:
37: /*
38: * Remove a mount point from the list of mounted filesystems.
39: * Unmount of the root is illegal.
40: */
41: void
42: vfs_remove(mp)
43: register struct mount *mp;
44: {
45:
46: if (mp == rootfs)
47: panic("vfs_remove: unmounting root");
48: mp->mnt_prev->mnt_next = mp->mnt_next;
49: mp->mnt_next->mnt_prev = mp->mnt_prev;
50: mp->mnt_vnodecovered->v_mountedhere = (struct mount *)0;
51: vfs_unlock(mp);
52: }
53:
54: /*
55: * Lock a filesystem.
56: * Used to prevent access to it while mounting and unmounting.
57: */
58: vfs_lock(mp)
59: register struct mount *mp;
60: {
61:
62: while(mp->mnt_flag & MNT_MLOCK) {
63: mp->mnt_flag |= MNT_MWAIT;
64: sleep((caddr_t)mp, PVFS);
65: }
66: mp->mnt_flag |= MNT_MLOCK;
67: return (0);
68: }
69:
70: /*
71: * Unlock a locked filesystem.
72: * Panic if filesystem is not locked.
73: */
74: void
75: vfs_unlock(mp)
76: register struct mount *mp;
77: {
78:
79: if ((mp->mnt_flag & MNT_MLOCK) == 0)
80: panic("vfs_unlock: not locked");
81: mp->mnt_flag &= ~MNT_MLOCK;
82: if (mp->mnt_flag & MNT_MWAIT) {
83: mp->mnt_flag &= ~MNT_MWAIT;
84: wakeup((caddr_t)mp);
85: }
86: }
87:
88: /*
89: * Mark a mount point as busy.
90: * Used to synchronize access and to delay unmounting.
91: */
92: vfs_busy(mp)
93: register struct mount *mp;
94: {
95:
96: while(mp->mnt_flag & MNT_MPBUSY) {
97: mp->mnt_flag |= MNT_MPWANT;
98: sleep((caddr_t)&mp->mnt_flag, PVFS);
99: }
100: if (mp->mnt_flag & MNT_UNMOUNT)
101: return (1);
102: mp->mnt_flag |= MNT_MPBUSY;
103: return (0);
104: }
105:
106: /*
107: * Free a busy filesystem.
108: * Panic if filesystem is not busy.
109: */
110: void
111: vfs_unbusy(mp)
112: register struct mount *mp;
113: {
114:
115: if ((mp->mnt_flag & MNT_MPBUSY) == 0)
116: panic("vfs_unbusy: not busy");
117: mp->mnt_flag &= ~MNT_MPBUSY;
118: if (mp->mnt_flag & MNT_MPWANT) {
119: mp->mnt_flag &= ~MNT_MPWANT;
120: wakeup((caddr_t)&mp->mnt_flag);
121: }
122: }
123:
124: /*
125: * Lookup a mount point by filesystem identifier.
126: */
127: struct mount *
128: getvfs(fsid)
129: fsid_t *fsid;
130: {
131: register struct mount *mp;
132:
133: mp = rootfs;
134: do {
135: if (mp->mnt_stat.f_fsid.val[0] == fsid->val[0] &&
136: mp->mnt_stat.f_fsid.val[1] == fsid->val[1]) {
137: return (mp);
138: }
139: mp = mp->mnt_next;
140: } while (mp != rootfs);
141: return ((struct mount *)0);
142: }
143:
144: /*
145: * Set vnode attributes to VNOVAL
146: */
147: void vattr_null(vap)
148: register struct vattr *vap;
149: {
150:
151: vap->va_type = VNON;
152: vap->va_mode = vap->va_nlink = vap->va_uid = vap->va_gid =
153: vap->va_fsid = vap->va_fileid = vap->va_size =
154: vap->va_size_rsv = vap->va_blocksize = vap->va_rdev =
155: vap->va_bytes = vap->va_bytes_rsv =
156: vap->va_atime.tv_sec = vap->va_atime.tv_usec =
157: vap->va_mtime.tv_sec = vap->va_mtime.tv_usec =
158: vap->va_ctime.tv_sec = vap->va_ctime.tv_usec =
159: vap->va_flags = vap->va_gen = VNOVAL;
160: }
161:
162: /*
163: * Initialize a nameidata structure
164: */
165: ndinit(ndp)
166: register struct nameidata *ndp;
167: {
168:
169: bzero((caddr_t)ndp, sizeof(struct nameidata));
170: ndp->ni_iov = &ndp->ni_nd.nd_iovec;
171: ndp->ni_iovcnt = 1;
172: ndp->ni_base = (caddr_t)&ndp->ni_dent;
173: ndp->ni_rw = UIO_WRITE;
174: ndp->ni_uioseg = UIO_SYSSPACE;
175: }
176:
177: /*
178: * Duplicate a nameidata structure
179: */
180: nddup(ndp, newndp)
181: register struct nameidata *ndp, *newndp;
182: {
183:
184: ndinit(newndp);
185: newndp->ni_cdir = ndp->ni_cdir;
186: VREF(newndp->ni_cdir);
187: newndp->ni_rdir = ndp->ni_rdir;
188: if (newndp->ni_rdir)
189: VREF(newndp->ni_rdir);
190: newndp->ni_cred = ndp->ni_cred;
191: crhold(newndp->ni_cred);
192: }
193:
194: /*
195: * Release a nameidata structure
196: */
197: ndrele(ndp)
198: register struct nameidata *ndp;
199: {
200:
201: vrele(ndp->ni_cdir);
202: if (ndp->ni_rdir)
203: vrele(ndp->ni_rdir);
204: crfree(ndp->ni_cred);
205: }
206:
207: /*
208: * Routines having to do with the management of the vnode table.
209: */
210: struct vnode *vfreeh, **vfreet;
211: extern struct vnodeops dead_vnodeops, spec_vnodeops;
212: extern void vclean();
213: long numvnodes;
214: struct vattr va_null;
215:
216: /*
217: * Initialize the vnode structures and initialize each file system type.
218: */
219: vfsinit()
220: {
221: struct vfsops **vfsp;
222:
223: /*
224: * Initialize the vnode name cache
225: */
226: nchinit();
227: /*
228: * Initialize each file system type.
229: */
230: vattr_null(&va_null);
231: for (vfsp = &vfssw[0]; vfsp <= &vfssw[MOUNT_MAXTYPE]; vfsp++) {
232: if (*vfsp == NULL)
233: continue;
234: (*(*vfsp)->vfs_init)();
235: }
236: }
237:
238: /*
239: * Return the next vnode from the free list.
240: */
241: getnewvnode(tag, mp, vops, vpp)
242: enum vtagtype tag;
243: struct mount *mp;
244: struct vnodeops *vops;
245: struct vnode **vpp;
246: {
247: register struct vnode *vp, *vq;
248:
249: if (numvnodes < desiredvnodes) {
250: vp = (struct vnode *)malloc(sizeof *vp, M_VNODE, M_WAITOK);
251: bzero((char *)vp, sizeof *vp);
252: numvnodes++;
253: } else {
254: if ((vp = vfreeh) == NULL) {
255: tablefull("vnode");
256: *vpp = 0;
257: return (ENFILE);
258: }
259: if (vp->v_usecount)
260: panic("free vnode isn't");
261: if (vq = vp->v_freef)
262: vq->v_freeb = &vfreeh;
263: else
264: vfreet = &vfreeh;
265: vfreeh = vq;
266: vp->v_freef = NULL;
267: vp->v_freeb = NULL;
268: if (vp->v_type != VBAD)
269: vgone(vp);
270: vp->v_flag = 0;
271: vp->v_shlockc = 0;
272: vp->v_exlockc = 0;
273: vp->v_lastr = 0;
274: vp->v_socket = 0;
275: }
276: vp->v_type = VNON;
277: cache_purge(vp);
278: vp->v_tag = tag;
279: vp->v_op = vops;
280: insmntque(vp, mp);
281: VREF(vp);
282: *vpp = vp;
283: return (0);
284: }
285:
286: /*
287: * Move a vnode from one mount queue to another.
288: */
289: insmntque(vp, mp)
290: register struct vnode *vp;
291: register struct mount *mp;
292: {
293: struct vnode *vq;
294:
295: /*
296: * Delete from old mount point vnode list, if on one.
297: */
298: if (vp->v_mountb) {
299: if (vq = vp->v_mountf)
300: vq->v_mountb = vp->v_mountb;
301: *vp->v_mountb = vq;
302: }
303: /*
304: * Insert into list of vnodes for the new mount point, if available.
305: */
306: vp->v_mount = mp;
307: if (mp == NULL) {
308: vp->v_mountf = NULL;
309: vp->v_mountb = NULL;
310: return;
311: }
312: if (mp->mnt_mounth) {
313: vp->v_mountf = mp->mnt_mounth;
314: vp->v_mountb = &mp->mnt_mounth;
315: mp->mnt_mounth->v_mountb = &vp->v_mountf;
316: mp->mnt_mounth = vp;
317: } else {
318: mp->mnt_mounth = vp;
319: vp->v_mountb = &mp->mnt_mounth;
320: vp->v_mountf = NULL;
321: }
322: }
323:
324: /*
325: * Create a vnode for a block device.
326: * Used for root filesystem, argdev, and swap areas.
327: * Also used for memory file system special devices.
328: */
329: bdevvp(dev, vpp)
330: dev_t dev;
331: struct vnode **vpp;
332: {
333: register struct vnode *vp;
334: struct vnode *nvp;
335: int error;
336:
337: error = getnewvnode(VT_NON, (struct mount *)0, &spec_vnodeops, &nvp);
338: if (error) {
339: *vpp = 0;
340: return (error);
341: }
342: vp = nvp;
343: vp->v_type = VBLK;
344: if (nvp = checkalias(vp, dev, (struct mount *)0)) {
345: vput(vp);
346: vp = nvp;
347: }
348: *vpp = vp;
349: return (0);
350: }
351:
352: /*
353: * Check to see if the new vnode represents a special device
354: * for which we already have a vnode (either because of
355: * bdevvp() or because of a different vnode representing
356: * the same block device). If such an alias exists, deallocate
357: * the existing contents and return the aliased vnode. The
358: * caller is responsible for filling it with its new contents.
359: */
360: struct vnode *
361: checkalias(nvp, nvp_rdev, mp)
362: register struct vnode *nvp;
363: dev_t nvp_rdev;
364: struct mount *mp;
365: {
366: register struct vnode *vp;
367: struct vnode **vpp;
368:
369: if (nvp->v_type != VBLK && nvp->v_type != VCHR)
370: return (NULLVP);
371:
372: vpp = &speclisth[SPECHASH(nvp_rdev)];
373: loop:
374: for (vp = *vpp; vp; vp = vp->v_specnext) {
375: if (nvp_rdev != vp->v_rdev || nvp->v_type != vp->v_type)
376: continue;
377: /*
378: * Alias, but not in use, so flush it out.
379: */
380: if (vp->v_usecount == 0) {
381: vgone(vp);
382: goto loop;
383: }
384: if (vget(vp))
385: goto loop;
386: break;
387: }
388: if (vp == NULL || vp->v_tag != VT_NON) {
389: MALLOC(nvp->v_specinfo, struct specinfo *,
390: sizeof(struct specinfo), M_VNODE, M_WAITOK);
391: nvp->v_rdev = nvp_rdev;
392: nvp->v_hashchain = vpp;
393: nvp->v_specnext = *vpp;
394: nvp->v_specflags = 0;
395: *vpp = nvp;
396: if (vp != NULL) {
397: nvp->v_flag |= VALIASED;
398: vp->v_flag |= VALIASED;
399: vput(vp);
400: }
401: return (NULLVP);
402: }
403: VOP_UNLOCK(vp);
404: vclean(vp, 0);
405: vp->v_op = nvp->v_op;
406: vp->v_tag = nvp->v_tag;
407: nvp->v_type = VNON;
408: insmntque(vp, mp);
409: return (vp);
410: }
411:
412: /*
413: * Grab a particular vnode from the free list, increment its
414: * reference count and lock it. The vnode lock bit is set the
415: * vnode is being eliminated in vgone. The process is awakened
416: * when the transition is completed, and an error returned to
417: * indicate that the vnode is no longer usable (possibly having
418: * been changed to a new file system type).
419: */
420: vget(vp)
421: register struct vnode *vp;
422: {
423: register struct vnode *vq;
424:
425: if (vp->v_flag & VXLOCK) {
426: vp->v_flag |= VXWANT;
427: sleep((caddr_t)vp, PINOD);
428: return (1);
429: }
430: if (vp->v_usecount == 0) {
431: if (vq = vp->v_freef)
432: vq->v_freeb = vp->v_freeb;
433: else
434: vfreet = vp->v_freeb;
435: *vp->v_freeb = vq;
436: vp->v_freef = NULL;
437: vp->v_freeb = NULL;
438: }
439: VREF(vp);
440: VOP_LOCK(vp);
441: return (0);
442: }
443:
444: /*
445: * Vnode reference, just increment the count
446: */
447: void vref(vp)
448: struct vnode *vp;
449: {
450:
451: vp->v_usecount++;
452: }
453:
454: /*
455: * vput(), just unlock and vrele()
456: */
457: void vput(vp)
458: register struct vnode *vp;
459: {
460: VOP_UNLOCK(vp);
461: vrele(vp);
462: }
463:
464: /*
465: * Vnode release.
466: * If count drops to zero, call inactive routine and return to freelist.
467: */
468: void vrele(vp)
469: register struct vnode *vp;
470: {
471:
472: if (vp == NULL)
473: panic("vrele: null vp");
474: vp->v_usecount--;
475: if (vp->v_usecount < 0)
476: vprint("vrele: bad ref count", vp);
477: if (vp->v_usecount > 0)
478: return;
479: if (vfreeh == NULLVP) {
480: /*
481: * insert into empty list
482: */
483: vfreeh = vp;
484: vp->v_freeb = &vfreeh;
485: } else {
486: /*
487: * insert at tail of list
488: */
489: *vfreet = vp;
490: vp->v_freeb = vfreet;
491: }
492: vp->v_freef = NULL;
493: vfreet = &vp->v_freef;
494: VOP_INACTIVE(vp);
495: }
496:
497: /*
498: * Page or buffer structure gets a reference.
499: */
500: vhold(vp)
501: register struct vnode *vp;
502: {
503:
504: vp->v_holdcnt++;
505: }
506:
507: /*
508: * Page or buffer structure frees a reference.
509: */
510: holdrele(vp)
511: register struct vnode *vp;
512: {
513:
514: if (vp->v_holdcnt <= 0)
515: panic("holdrele: holdcnt");
516: vp->v_holdcnt--;
517: }
518:
519: /*
520: * Remove any vnodes in the vnode table belonging to mount point mp.
521: *
522: * If MNT_NOFORCE is specified, there should not be any active ones,
523: * return error if any are found (nb: this is a user error, not a
524: * system error). If MNT_FORCE is specified, detach any active vnodes
525: * that are found.
526: */
527: int busyprt = 0; /* patch to print out busy vnodes */
528:
529: vflush(mp, skipvp, flags)
530: struct mount *mp;
531: struct vnode *skipvp;
532: int flags;
533: {
534: register struct vnode *vp, *nvp;
535: int busy = 0;
536:
537: if ((mp->mnt_flag & MNT_MPBUSY) == 0)
538: panic("vflush: not busy");
539: loop:
540: for (vp = mp->mnt_mounth; vp; vp = nvp) {
541: if (vp->v_mount != mp)
542: goto loop;
543: nvp = vp->v_mountf;
544: /*
545: * Skip over a selected vnode.
546: */
547: if (vp == skipvp)
548: continue;
549: /*
550: * Skip over a vnodes marked VSYSTEM.
551: */
552: if ((flags & SKIPSYSTEM) && (vp->v_flag & VSYSTEM))
553: continue;
554: /*
555: * With v_usecount == 0, all we need to do is clear
556: * out the vnode data structures and we are done.
557: */
558: if (vp->v_usecount == 0) {
559: vgone(vp);
560: continue;
561: }
562: /*
563: * For block or character devices, revert to an
564: * anonymous device. For all other files, just kill them.
565: */
566: if (flags & FORCECLOSE) {
567: if (vp->v_type != VBLK && vp->v_type != VCHR) {
568: vgone(vp);
569: } else {
570: vclean(vp, 0);
571: vp->v_op = &spec_vnodeops;
572: insmntque(vp, (struct mount *)0);
573: }
574: continue;
575: }
576: if (busyprt)
577: vprint("vflush: busy vnode", vp);
578: busy++;
579: }
580: if (busy)
581: return (EBUSY);
582: return (0);
583: }
584:
585: /*
586: * Disassociate the underlying file system from a vnode.
587: */
588: void vclean(vp, flags)
589: register struct vnode *vp;
590: long flags;
591: {
592: struct vnodeops *origops;
593: int active;
594:
595: /*
596: * Check to see if the vnode is in use.
597: * If so we have to reference it before we clean it out
598: * so that its count cannot fall to zero and generate a
599: * race against ourselves to recycle it.
600: */
601: if (active = vp->v_usecount)
602: VREF(vp);
603: /*
604: * Prevent the vnode from being recycled or
605: * brought into use while we clean it out.
606: */
607: if (vp->v_flag & VXLOCK)
608: panic("vclean: deadlock");
609: vp->v_flag |= VXLOCK;
610: /*
611: * Even if the count is zero, the VOP_INACTIVE routine may still
612: * have the object locked while it cleans it out. The VOP_LOCK
613: * ensures that the VOP_INACTIVE routine is done with its work.
614: * For active vnodes, it ensures that no other activity can
615: * occur while the buffer list is being cleaned out.
616: */
617: VOP_LOCK(vp);
618: if (flags & DOCLOSE)
619: vinvalbuf(vp, 1);
620: /*
621: * Prevent any further operations on the vnode from
622: * being passed through to the old file system.
623: */
624: origops = vp->v_op;
625: vp->v_op = &dead_vnodeops;
626: vp->v_tag = VT_NON;
627: /*
628: * If purging an active vnode, it must be unlocked, closed,
629: * and deactivated before being reclaimed.
630: */
631: (*(origops->vn_unlock))(vp);
632: if (active) {
633: if (flags & DOCLOSE)
634: (*(origops->vn_close))(vp, 0, NOCRED);
635: (*(origops->vn_inactive))(vp);
636: }
637: /*
638: * Reclaim the vnode.
639: */
640: if ((*(origops->vn_reclaim))(vp))
641: panic("vclean: cannot reclaim");
642: if (active)
643: vrele(vp);
644: /*
645: * Done with purge, notify sleepers in vget of the grim news.
646: */
647: vp->v_flag &= ~VXLOCK;
648: if (vp->v_flag & VXWANT) {
649: vp->v_flag &= ~VXWANT;
650: wakeup((caddr_t)vp);
651: }
652: }
653:
654: /*
655: * Eliminate all activity associated with the requested vnode
656: * and with all vnodes aliased to the requested vnode.
657: */
658: void vgoneall(vp)
659: register struct vnode *vp;
660: {
661: register struct vnode *vq;
662:
663: if (vp->v_flag & VALIASED) {
664: /*
665: * If a vgone (or vclean) is already in progress,
666: * wait until it is done and return.
667: */
668: if (vp->v_flag & VXLOCK) {
669: vp->v_flag |= VXWANT;
670: sleep((caddr_t)vp, PINOD);
671: return;
672: }
673: /*
674: * Ensure that vp will not be vgone'd while we
675: * are eliminating its aliases.
676: */
677: vp->v_flag |= VXLOCK;
678: while (vp->v_flag & VALIASED) {
679: for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) {
680: if (vq->v_rdev != vp->v_rdev ||
681: vq->v_type != vp->v_type || vp == vq)
682: continue;
683: vgone(vq);
684: break;
685: }
686: }
687: /*
688: * Remove the lock so that vgone below will
689: * really eliminate the vnode after which time
690: * vgone will awaken any sleepers.
691: */
692: vp->v_flag &= ~VXLOCK;
693: }
694: vgone(vp);
695: }
696:
697: /*
698: * Eliminate all activity associated with a vnode
699: * in preparation for reuse.
700: */
701: void vgone(vp)
702: register struct vnode *vp;
703: {
704: register struct vnode *vq;
705: struct vnode *vx;
706: long count;
707:
708: /*
709: * If a vgone (or vclean) is already in progress,
710: * wait until it is done and return.
711: */
712: if (vp->v_flag & VXLOCK) {
713: vp->v_flag |= VXWANT;
714: sleep((caddr_t)vp, PINOD);
715: return;
716: }
717: /*
718: * Clean out the filesystem specific data.
719: */
720: vclean(vp, DOCLOSE);
721: /*
722: * Delete from old mount point vnode list, if on one.
723: */
724: if (vp->v_mountb) {
725: if (vq = vp->v_mountf)
726: vq->v_mountb = vp->v_mountb;
727: *vp->v_mountb = vq;
728: vp->v_mountf = NULL;
729: vp->v_mountb = NULL;
730: }
731: /*
732: * If special device, remove it from special device alias list.
733: */
734: if (vp->v_type == VBLK || vp->v_type == VCHR) {
735: if (*vp->v_hashchain == vp) {
736: *vp->v_hashchain = vp->v_specnext;
737: } else {
738: for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) {
739: if (vq->v_specnext != vp)
740: continue;
741: vq->v_specnext = vp->v_specnext;
742: break;
743: }
744: if (vq == NULL)
745: panic("missing bdev");
746: }
747: if (vp->v_flag & VALIASED) {
748: count = 0;
749: for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) {
750: if (vq->v_rdev != vp->v_rdev ||
751: vq->v_type != vp->v_type)
752: continue;
753: count++;
754: vx = vq;
755: }
756: if (count == 0)
757: panic("missing alias");
758: if (count == 1)
759: vx->v_flag &= ~VALIASED;
760: vp->v_flag &= ~VALIASED;
761: }
762: FREE(vp->v_specinfo, M_VNODE);
763: vp->v_specinfo = NULL;
764: }
765: /*
766: * If it is on the freelist, move it to the head of the list.
767: */
768: if (vp->v_freeb) {
769: if (vq = vp->v_freef)
770: vq->v_freeb = vp->v_freeb;
771: else
772: vfreet = vp->v_freeb;
773: *vp->v_freeb = vq;
774: vp->v_freef = vfreeh;
775: vp->v_freeb = &vfreeh;
776: vfreeh->v_freeb = &vp->v_freef;
777: vfreeh = vp;
778: }
779: vp->v_type = VBAD;
780: }
781:
782: /*
783: * Lookup a vnode by device number.
784: */
785: vfinddev(dev, type, vpp)
786: dev_t dev;
787: enum vtype type;
788: struct vnode **vpp;
789: {
790: register struct vnode *vp;
791:
792: for (vp = speclisth[SPECHASH(dev)]; vp; vp = vp->v_specnext) {
793: if (dev != vp->v_rdev || type != vp->v_type)
794: continue;
795: *vpp = vp;
796: return (0);
797: }
798: return (1);
799: }
800:
801: /*
802: * Calculate the total number of references to a special device.
803: */
804: vcount(vp)
805: register struct vnode *vp;
806: {
807: register struct vnode *vq;
808: int count;
809:
810: if ((vp->v_flag & VALIASED) == 0)
811: return (vp->v_usecount);
812: loop:
813: for (count = 0, vq = *vp->v_hashchain; vq; vq = vq->v_specnext) {
814: if (vq->v_rdev != vp->v_rdev || vq->v_type != vp->v_type)
815: continue;
816: /*
817: * Alias, but not in use, so flush it out.
818: */
819: if (vq->v_usecount == 0) {
820: vgone(vq);
821: goto loop;
822: }
823: count += vq->v_usecount;
824: }
825: return (count);
826: }
827:
828: /*
829: * Print out a description of a vnode.
830: */
831: static char *typename[] =
832: { "VNON", "VREG", "VDIR", "VBLK", "VCHR", "VLNK", "VSOCK", "VFIFO", "VBAD" };
833:
834: vprint(label, vp)
835: char *label;
836: register struct vnode *vp;
837: {
838: char buf[64];
839:
840: if (label != NULL)
841: printf("%s: ", label);
842: printf("type %s, usecount %d, refcount %d,", typename[vp->v_type],
843: vp->v_usecount, vp->v_holdcnt);
844: buf[0] = '\0';
845: if (vp->v_flag & VROOT)
846: strcat(buf, "|VROOT");
847: if (vp->v_flag & VTEXT)
848: strcat(buf, "|VTEXT");
849: if (vp->v_flag & VSYSTEM)
850: strcat(buf, "|VSYSTEM");
851: if (vp->v_flag & VEXLOCK)
852: strcat(buf, "|VEXLOCK");
853: if (vp->v_flag & VSHLOCK)
854: strcat(buf, "|VSHLOCK");
855: if (vp->v_flag & VLWAIT)
856: strcat(buf, "|VLWAIT");
857: if (vp->v_flag & VXLOCK)
858: strcat(buf, "|VXLOCK");
859: if (vp->v_flag & VXWANT)
860: strcat(buf, "|VXWANT");
861: if (vp->v_flag & VBWAIT)
862: strcat(buf, "|VBWAIT");
863: if (vp->v_flag & VALIASED)
864: strcat(buf, "|VALIASED");
865: if (buf[0] != '\0')
866: printf(" flags (%s)", &buf[1]);
867: printf("\n\t");
868: VOP_PRINT(vp);
869: }
870:
871: int kinfo_vdebug = 1;
872: int kinfo_vgetfailed;
873: #define KINFO_VNODESLOP 10
874: /*
875: * Dump vnode list (via kinfo).
876: * Copyout address of vnode followed by vnode.
877: */
878: kinfo_vnode(op, where, acopysize, arg, aneeded)
879: char *where;
880: int *acopysize, *aneeded;
881: {
882: register struct mount *mp = rootfs;
883: struct mount *omp;
884: struct vnode *vp;
885: register needed = 0;
886: register char *bp = where, *savebp;
887: char *ewhere = where + *acopysize;
888: int error;
889:
890: #define VPTRSZ sizeof (struct vnode *)
891: #define VNODESZ sizeof (struct vnode)
892: if (where == NULL) {
893: *aneeded = (numvnodes + KINFO_VNODESLOP) * (VPTRSZ + VNODESZ);
894: return (0);
895: }
896:
897: do {
898: if (vfs_busy(mp)) {
899: mp = mp->mnt_next;
900: continue;
901: }
902: savebp = bp;
903: again:
904: for (vp = mp->mnt_mounth; vp; vp = vp->v_mountf) {
905: /*
906: * Check that the vp is still associated with
907: * this filesystem. RACE: could have been
908: * recycled onto the same filesystem.
909: */
910: if (vp->v_mount != mp) {
911: if (kinfo_vdebug)
912: printf("kinfo: vp changed\n");
913: bp = savebp;
914: goto again;
915: }
916: if ((bp + VPTRSZ + VNODESZ <= ewhere) &&
917: ((error = copyout((caddr_t)&vp, bp, VPTRSZ)) ||
918: (error = copyout((caddr_t)vp, bp + VPTRSZ,
919: VNODESZ))))
920: return (error);
921: bp += VPTRSZ + VNODESZ;
922: }
923: omp = mp;
924: mp = mp->mnt_next;
925: vfs_unbusy(omp);
926: } while (mp != rootfs);
927:
928: *aneeded = bp - where;
929: if (bp > ewhere)
930: *acopysize = ewhere - where;
931: else
932: *acopysize = bp - where;
933: return (0);
934: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.