![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ufs_vfsops.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / ufs|
Return to ufs_vfsops.c CVS log | Up to [Net/2] / Net2 / ufs |
1.1 root 1: /*
2: * Copyright (c) 1989, 1991 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: * @(#)ufs_vfsops.c 7.56 (Berkeley) 6/28/91
34: */
35:
36: #include "param.h"
37: #include "systm.h"
38: #include "namei.h"
39: #include "proc.h"
40: #include "kernel.h"
41: #include "vnode.h"
42: #include "specdev.h"
43: #include "mount.h"
44: #include "buf.h"
45: #include "file.h"
46: #include "disklabel.h"
47: #include "ioctl.h"
48: #include "errno.h"
49: #include "malloc.h"
50:
51: #include "quota.h"
52: #include "fs.h"
53: #include "ufsmount.h"
54: #include "inode.h"
55:
56: struct vfsops ufs_vfsops = {
57: ufs_mount,
58: ufs_start,
59: ufs_unmount,
60: ufs_root,
61: ufs_quotactl,
62: ufs_statfs,
63: ufs_sync,
64: ufs_fhtovp,
65: ufs_vptofh,
66: ufs_init
67: };
68:
69: /*
70: * Flag to allow forcible unmounting.
71: */
72: int doforce = 1;
73:
74: /*
75: * Called by vfs_mountroot when ufs is going to be mounted as root.
76: *
77: * Name is updated by mount(8) after booting.
78: */
79: #define ROOTNAME "root_device"
80:
81: ufs_mountroot()
82: {
83: register struct mount *mp;
84: extern struct vnode *rootvp;
85: struct proc *p = curproc; /* XXX */
86: struct ufsmount *ump;
87: register struct fs *fs;
88: u_int size;
89: int error;
90:
91: mp = (struct mount *)malloc((u_long)sizeof(struct mount),
92: M_MOUNT, M_WAITOK);
93: mp->mnt_op = &ufs_vfsops;
94: mp->mnt_flag = MNT_RDONLY;
95: mp->mnt_exroot = 0;
96: mp->mnt_mounth = NULLVP;
97: error = mountfs(rootvp, mp, p);
98: if (error) {
99: free((caddr_t)mp, M_MOUNT);
100: return (error);
101: }
102: if (error = vfs_lock(mp)) {
103: (void)ufs_unmount(mp, 0, p);
104: free((caddr_t)mp, M_MOUNT);
105: return (error);
106: }
107: rootfs = mp;
108: mp->mnt_next = mp;
109: mp->mnt_prev = mp;
110: mp->mnt_vnodecovered = NULLVP;
111: ump = VFSTOUFS(mp);
112: fs = ump->um_fs;
113: bzero(fs->fs_fsmnt, sizeof(fs->fs_fsmnt));
114: fs->fs_fsmnt[0] = '/';
115: bcopy((caddr_t)fs->fs_fsmnt, (caddr_t)mp->mnt_stat.f_mntonname,
116: MNAMELEN);
117: (void) copystr(ROOTNAME, mp->mnt_stat.f_mntfromname, MNAMELEN - 1,
118: &size);
119: bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
120: (void) ufs_statfs(mp, &mp->mnt_stat, p);
121: vfs_unlock(mp);
122: inittodr(fs->fs_time);
123: return (0);
124: }
125:
126: /*
127: * VFS Operations.
128: *
129: * mount system call
130: */
131: ufs_mount(mp, path, data, ndp, p)
132: register struct mount *mp;
133: char *path;
134: caddr_t data;
135: struct nameidata *ndp;
136: struct proc *p;
137: {
138: struct vnode *devvp;
139: struct ufs_args args;
140: struct ufsmount *ump;
141: register struct fs *fs;
142: u_int size;
143: int error;
144:
145: if (error = copyin(data, (caddr_t)&args, sizeof (struct ufs_args)))
146: return (error);
147: /*
148: * Process export requests.
149: */
150: if ((args.exflags & MNT_EXPORTED) || (mp->mnt_flag & MNT_EXPORTED)) {
151: if (args.exflags & MNT_EXPORTED)
152: mp->mnt_flag |= MNT_EXPORTED;
153: else
154: mp->mnt_flag &= ~MNT_EXPORTED;
155: if (args.exflags & MNT_EXRDONLY)
156: mp->mnt_flag |= MNT_EXRDONLY;
157: else
158: mp->mnt_flag &= ~MNT_EXRDONLY;
159: mp->mnt_exroot = args.exroot;
160: }
161: /*
162: * If updating, check whether changing from read-only to
163: * read/write; if there is no device name, that's all we do.
164: */
165: if (mp->mnt_flag & MNT_UPDATE) {
166: ump = VFSTOUFS(mp);
167: fs = ump->um_fs;
168: if (fs->fs_ronly && (mp->mnt_flag & MNT_RDONLY) == 0)
169: fs->fs_ronly = 0;
170: if (args.fspec == 0)
171: return (0);
172: }
173: /*
174: * Not an update, or updating the name: look up the name
175: * and verify that it refers to a sensible block device.
176: */
177: ndp->ni_nameiop = LOOKUP | FOLLOW;
178: ndp->ni_segflg = UIO_USERSPACE;
179: ndp->ni_dirp = args.fspec;
180: if (error = namei(ndp, p))
181: return (error);
182: devvp = ndp->ni_vp;
183: if (devvp->v_type != VBLK) {
184: vrele(devvp);
185: return (ENOTBLK);
186: }
187: if (major(devvp->v_rdev) >= nblkdev) {
188: vrele(devvp);
189: return (ENXIO);
190: }
191: if ((mp->mnt_flag & MNT_UPDATE) == 0)
192: error = mountfs(devvp, mp, p);
193: else {
194: if (devvp != ump->um_devvp)
195: error = EINVAL; /* needs translation */
196: else
197: vrele(devvp);
198: }
199: if (error) {
200: vrele(devvp);
201: return (error);
202: }
203: ump = VFSTOUFS(mp);
204: fs = ump->um_fs;
205: (void) copyinstr(path, fs->fs_fsmnt, sizeof(fs->fs_fsmnt) - 1, &size);
206: bzero(fs->fs_fsmnt + size, sizeof(fs->fs_fsmnt) - size);
207: bcopy((caddr_t)fs->fs_fsmnt, (caddr_t)mp->mnt_stat.f_mntonname,
208: MNAMELEN);
209: (void) copyinstr(args.fspec, mp->mnt_stat.f_mntfromname, MNAMELEN - 1,
210: &size);
211: bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
212: (void) ufs_statfs(mp, &mp->mnt_stat, p);
213: return (0);
214: }
215:
216: /*
217: * Common code for mount and mountroot
218: */
219: mountfs(devvp, mp, p)
220: register struct vnode *devvp;
221: struct mount *mp;
222: struct proc *p;
223: {
224: register struct ufsmount *ump = (struct ufsmount *)0;
225: struct buf *bp = NULL;
226: register struct fs *fs;
227: dev_t dev = devvp->v_rdev;
228: struct partinfo dpart;
229: caddr_t base, space;
230: int havepart = 0, blks;
231: int error, i, size;
232: int needclose = 0;
233: int ronly = (mp->mnt_flag & MNT_RDONLY) != 0;
234: extern struct vnode *rootvp;
235:
236: /*
237: * Disallow multiple mounts of the same device.
238: * Disallow mounting of a device that is currently in use
239: * (except for root, which might share swap device for miniroot).
240: * Flush out any old buffers remaining from a previous use.
241: */
242: if (error = mountedon(devvp))
243: return (error);
244: if (vcount(devvp) > 1 && devvp != rootvp)
245: return (EBUSY);
246: vinvalbuf(devvp, 1);
247: if (error = VOP_OPEN(devvp, ronly ? FREAD : FREAD|FWRITE, NOCRED, p))
248: return (error);
249: needclose = 1;
250: if (VOP_IOCTL(devvp, DIOCGPART, (caddr_t)&dpart, FREAD, NOCRED, p) != 0)
251: size = DEV_BSIZE;
252: else {
253: havepart = 1;
254: size = dpart.disklab->d_secsize;
255: }
256: if (error = bread(devvp, SBLOCK, SBSIZE, NOCRED, &bp))
257: goto out;
258: fs = bp->b_un.b_fs;
259: if (fs->fs_magic != FS_MAGIC || fs->fs_bsize > MAXBSIZE ||
260: fs->fs_bsize < sizeof(struct fs)) {
261: error = EINVAL; /* XXX needs translation */
262: goto out;
263: }
264: ump = (struct ufsmount *)malloc(sizeof *ump, M_UFSMNT, M_WAITOK);
265: ump->um_fs = (struct fs *)malloc((u_long)fs->fs_sbsize, M_SUPERBLK,
266: M_WAITOK);
267: bcopy((caddr_t)bp->b_un.b_addr, (caddr_t)ump->um_fs,
268: (u_int)fs->fs_sbsize);
269: if (fs->fs_sbsize < SBSIZE)
270: bp->b_flags |= B_INVAL;
271: brelse(bp);
272: bp = NULL;
273: fs = ump->um_fs;
274: fs->fs_ronly = ronly;
275: if (ronly == 0)
276: fs->fs_fmod = 1;
277: if (havepart) {
278: dpart.part->p_fstype = FS_BSDFFS;
279: dpart.part->p_fsize = fs->fs_fsize;
280: dpart.part->p_frag = fs->fs_frag;
281: dpart.part->p_cpg = fs->fs_cpg;
282: }
283: blks = howmany(fs->fs_cssize, fs->fs_fsize);
284: base = space = (caddr_t)malloc((u_long)fs->fs_cssize, M_SUPERBLK,
285: M_WAITOK);
286: for (i = 0; i < blks; i += fs->fs_frag) {
287: size = fs->fs_bsize;
288: if (i + fs->fs_frag > blks)
289: size = (blks - i) * fs->fs_fsize;
290: error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + i), size,
291: NOCRED, &bp);
292: if (error) {
293: free((caddr_t)base, M_SUPERBLK);
294: goto out;
295: }
296: bcopy((caddr_t)bp->b_un.b_addr, space, (u_int)size);
297: fs->fs_csp[fragstoblks(fs, i)] = (struct csum *)space;
298: space += size;
299: brelse(bp);
300: bp = NULL;
301: }
302: mp->mnt_data = (qaddr_t)ump;
303: mp->mnt_stat.f_fsid.val[0] = (long)dev;
304: mp->mnt_stat.f_fsid.val[1] = MOUNT_UFS;
305: mp->mnt_flag |= MNT_LOCAL;
306: ump->um_mountp = mp;
307: ump->um_dev = dev;
308: ump->um_devvp = devvp;
309: for (i = 0; i < MAXQUOTAS; i++)
310: ump->um_quotas[i] = NULLVP;
311: devvp->v_specflags |= SI_MOUNTEDON;
312:
313: /* Sanity checks for old file systems. XXX */
314: fs->fs_npsect = MAX(fs->fs_npsect, fs->fs_nsect); /* XXX */
315: fs->fs_interleave = MAX(fs->fs_interleave, 1); /* XXX */
316: if (fs->fs_postblformat == FS_42POSTBLFMT) /* XXX */
317: fs->fs_nrpos = 8; /* XXX */
318: return (0);
319: out:
320: if (bp)
321: brelse(bp);
322: if (needclose)
323: (void)VOP_CLOSE(devvp, ronly ? FREAD : FREAD|FWRITE, NOCRED, p);
324: if (ump) {
325: free((caddr_t)ump->um_fs, M_SUPERBLK);
326: free((caddr_t)ump, M_UFSMNT);
327: mp->mnt_data = (qaddr_t)0;
328: }
329: return (error);
330: }
331:
332: /*
333: * Make a filesystem operational.
334: * Nothing to do at the moment.
335: */
336: /* ARGSUSED */
337: ufs_start(mp, flags, p)
338: struct mount *mp;
339: int flags;
340: struct proc *p;
341: {
342:
343: return (0);
344: }
345:
346: /*
347: * unmount system call
348: */
349: ufs_unmount(mp, mntflags, p)
350: struct mount *mp;
351: int mntflags;
352: struct proc *p;
353: {
354: register struct ufsmount *ump;
355: register struct fs *fs;
356: int i, error, ronly, flags = 0;
357:
358: if (mntflags & MNT_FORCE) {
359: if (!doforce || mp == rootfs)
360: return (EINVAL);
361: flags |= FORCECLOSE;
362: }
363: mntflushbuf(mp, 0);
364: if (mntinvalbuf(mp))
365: return (EBUSY);
366: ump = VFSTOUFS(mp);
367: #ifdef QUOTA
368: if (mp->mnt_flag & MNT_QUOTA) {
369: if (error = vflush(mp, NULLVP, SKIPSYSTEM|flags))
370: return (error);
371: for (i = 0; i < MAXQUOTAS; i++) {
372: if (ump->um_quotas[i] == NULLVP)
373: continue;
374: quotaoff(p, mp, i);
375: }
376: /*
377: * Here we fall through to vflush again to ensure
378: * that we have gotten rid of all the system vnodes.
379: */
380: }
381: #endif
382: if (error = vflush(mp, NULLVP, flags))
383: return (error);
384: fs = ump->um_fs;
385: ronly = !fs->fs_ronly;
386: ump->um_devvp->v_specflags &= ~SI_MOUNTEDON;
387: error = VOP_CLOSE(ump->um_devvp, ronly ? FREAD : FREAD|FWRITE,
388: NOCRED, p);
389: vrele(ump->um_devvp);
390: free((caddr_t)fs->fs_csp[0], M_SUPERBLK);
391: free((caddr_t)fs, M_SUPERBLK);
392: free((caddr_t)ump, M_UFSMNT);
393: mp->mnt_data = (qaddr_t)0;
394: mp->mnt_flag &= ~MNT_LOCAL;
395: return (error);
396: }
397:
398: /*
399: * Check to see if a filesystem is mounted on a block device.
400: */
401: mountedon(vp)
402: register struct vnode *vp;
403: {
404: register struct vnode *vq;
405:
406: if (vp->v_specflags & SI_MOUNTEDON)
407: return (EBUSY);
408: if (vp->v_flag & VALIASED) {
409: for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) {
410: if (vq->v_rdev != vp->v_rdev ||
411: vq->v_type != vp->v_type)
412: continue;
413: if (vq->v_specflags & SI_MOUNTEDON)
414: return (EBUSY);
415: }
416: }
417: return (0);
418: }
419:
420: /*
421: * Return root of a filesystem
422: */
423: ufs_root(mp, vpp)
424: struct mount *mp;
425: struct vnode **vpp;
426: {
427: register struct inode *ip;
428: struct inode *nip;
429: struct vnode tvp;
430: int error;
431:
432: tvp.v_mount = mp;
433: ip = VTOI(&tvp);
434: ip->i_vnode = &tvp;
435: ip->i_dev = VFSTOUFS(mp)->um_dev;
436: error = iget(ip, (ino_t)ROOTINO, &nip);
437: if (error)
438: return (error);
439: *vpp = ITOV(nip);
440: return (0);
441: }
442:
443: /*
444: * Do operations associated with quotas
445: */
446: ufs_quotactl(mp, cmds, uid, arg, p)
447: struct mount *mp;
448: int cmds;
449: uid_t uid;
450: caddr_t arg;
451: struct proc *p;
452: {
453: struct ufsmount *ump = VFSTOUFS(mp);
454: int cmd, type, error;
455:
456: #ifndef QUOTA
457: return (EOPNOTSUPP);
458: #else
459: if (uid == -1)
460: uid = p->p_cred->p_ruid;
461: cmd = cmds >> SUBCMDSHIFT;
462:
463: switch (cmd) {
464: case Q_GETQUOTA:
465: case Q_SYNC:
466: if (uid == p->p_cred->p_ruid)
467: break;
468: /* fall through */
469: default:
470: if (error = suser(p->p_ucred, &p->p_acflag))
471: return (error);
472: }
473:
474: type = cmd & SUBCMDMASK;
475: if ((u_int)type >= MAXQUOTAS)
476: return (EINVAL);
477:
478: switch (cmd) {
479:
480: case Q_QUOTAON:
481: return (quotaon(p, mp, type, arg));
482:
483: case Q_QUOTAOFF:
484: if (vfs_busy(mp))
485: return (0);
486: error = quotaoff(p, mp, type);
487: vfs_unbusy(mp);
488: return (error);
489:
490: case Q_SETQUOTA:
491: return (setquota(mp, uid, type, arg));
492:
493: case Q_SETUSE:
494: return (setuse(mp, uid, type, arg));
495:
496: case Q_GETQUOTA:
497: return (getquota(mp, uid, type, arg));
498:
499: case Q_SYNC:
500: if (vfs_busy(mp))
501: return (0);
502: error = qsync(mp);
503: vfs_unbusy(mp);
504: return (error);
505:
506: default:
507: return (EINVAL);
508: }
509: /* NOTREACHED */
510: #endif
511: }
512:
513: /*
514: * Get file system statistics.
515: */
516: ufs_statfs(mp, sbp, p)
517: struct mount *mp;
518: register struct statfs *sbp;
519: struct proc *p;
520: {
521: register struct ufsmount *ump;
522: register struct fs *fs;
523:
524: ump = VFSTOUFS(mp);
525: fs = ump->um_fs;
526: if (fs->fs_magic != FS_MAGIC)
527: panic("ufs_statfs");
528: sbp->f_type = MOUNT_UFS;
529: sbp->f_fsize = fs->fs_fsize;
530: sbp->f_bsize = fs->fs_bsize;
531: sbp->f_blocks = fs->fs_dsize;
532: sbp->f_bfree = fs->fs_cstotal.cs_nbfree * fs->fs_frag +
533: fs->fs_cstotal.cs_nffree;
534: sbp->f_bavail = (fs->fs_dsize * (100 - fs->fs_minfree) / 100) -
535: (fs->fs_dsize - sbp->f_bfree);
536: sbp->f_files = fs->fs_ncg * fs->fs_ipg - ROOTINO;
537: sbp->f_ffree = fs->fs_cstotal.cs_nifree;
538: if (sbp != &mp->mnt_stat) {
539: bcopy((caddr_t)mp->mnt_stat.f_mntonname,
540: (caddr_t)&sbp->f_mntonname[0], MNAMELEN);
541: bcopy((caddr_t)mp->mnt_stat.f_mntfromname,
542: (caddr_t)&sbp->f_mntfromname[0], MNAMELEN);
543: }
544: return (0);
545: }
546:
547: int syncprt = 0;
548:
549: /*
550: * Go through the disk queues to initiate sandbagged IO;
551: * go through the inodes to write those that have been modified;
552: * initiate the writing of the super block if it has been modified.
553: *
554: * Note: we are always called with the filesystem marked `MPBUSY'.
555: */
556: ufs_sync(mp, waitfor)
557: struct mount *mp;
558: int waitfor;
559: {
560: register struct vnode *vp;
561: register struct inode *ip;
562: register struct ufsmount *ump = VFSTOUFS(mp);
563: register struct fs *fs;
564: int error, allerror = 0;
565:
566: if (syncprt)
567: bufstats();
568: fs = ump->um_fs;
569: /*
570: * Write back modified superblock.
571: * Consistency check that the superblock
572: * is still in the buffer cache.
573: */
574: if (fs->fs_fmod != 0) {
575: if (fs->fs_ronly != 0) { /* XXX */
576: printf("fs = %s\n", fs->fs_fsmnt);
577: panic("update: rofs mod");
578: }
579: fs->fs_fmod = 0;
580: fs->fs_time = time.tv_sec;
581: allerror = sbupdate(ump, waitfor);
582: }
583: /*
584: * Write back each (modified) inode.
585: */
586: loop:
587: for (vp = mp->mnt_mounth; vp; vp = vp->v_mountf) {
588: /*
589: * If the vnode that we are about to sync is no longer
590: * associated with this mount point, start over.
591: */
592: if (vp->v_mount != mp)
593: goto loop;
594: if (VOP_ISLOCKED(vp))
595: continue;
596: ip = VTOI(vp);
597: if ((ip->i_flag & (IMOD|IACC|IUPD|ICHG)) == 0 &&
598: vp->v_dirtyblkhd == NULL)
599: continue;
600: if (vget(vp))
601: goto loop;
602: if (vp->v_dirtyblkhd)
603: vflushbuf(vp, 0);
604: if ((ip->i_flag & (IMOD|IACC|IUPD|ICHG)) &&
605: (error = iupdat(ip, &time, &time, 0)))
606: allerror = error;
607: vput(vp);
608: }
609: /*
610: * Force stale file system control information to be flushed.
611: */
612: vflushbuf(ump->um_devvp, waitfor == MNT_WAIT ? B_SYNC : 0);
613: #ifdef QUOTA
614: qsync(mp);
615: #endif
616: return (allerror);
617: }
618:
619: /*
620: * Write a superblock and associated information back to disk.
621: */
622: sbupdate(mp, waitfor)
623: struct ufsmount *mp;
624: int waitfor;
625: {
626: register struct fs *fs = mp->um_fs;
627: register struct buf *bp;
628: int blks;
629: caddr_t space;
630: int i, size, error = 0;
631:
632: bp = getblk(mp->um_devvp, SBLOCK, (int)fs->fs_sbsize);
633: bcopy((caddr_t)fs, bp->b_un.b_addr, (u_int)fs->fs_sbsize);
634: /* Restore compatibility to old file systems. XXX */
635: if (fs->fs_postblformat == FS_42POSTBLFMT) /* XXX */
636: bp->b_un.b_fs->fs_nrpos = -1; /* XXX */
637: if (waitfor == MNT_WAIT)
638: error = bwrite(bp);
639: else
640: bawrite(bp);
641: blks = howmany(fs->fs_cssize, fs->fs_fsize);
642: space = (caddr_t)fs->fs_csp[0];
643: for (i = 0; i < blks; i += fs->fs_frag) {
644: size = fs->fs_bsize;
645: if (i + fs->fs_frag > blks)
646: size = (blks - i) * fs->fs_fsize;
647: bp = getblk(mp->um_devvp, fsbtodb(fs, fs->fs_csaddr + i), size);
648: bcopy(space, bp->b_un.b_addr, (u_int)size);
649: space += size;
650: if (waitfor == MNT_WAIT)
651: error = bwrite(bp);
652: else
653: bawrite(bp);
654: }
655: return (error);
656: }
657:
658: /*
659: * Print out statistics on the current allocation of the buffer pool.
660: * Can be enabled to print out on every ``sync'' by setting "syncprt"
661: * above.
662: */
663: bufstats()
664: {
665: int s, i, j, count;
666: register struct buf *bp, *dp;
667: int counts[MAXBSIZE/CLBYTES+1];
668: static char *bname[BQUEUES] = { "LOCKED", "LRU", "AGE", "EMPTY" };
669:
670: for (bp = bfreelist, i = 0; bp < &bfreelist[BQUEUES]; bp++, i++) {
671: count = 0;
672: for (j = 0; j <= MAXBSIZE/CLBYTES; j++)
673: counts[j] = 0;
674: s = splbio();
675: for (dp = bp->av_forw; dp != bp; dp = dp->av_forw) {
676: counts[dp->b_bufsize/CLBYTES]++;
677: count++;
678: }
679: splx(s);
680: printf("%s: total-%d", bname[i], count);
681: for (j = 0; j <= MAXBSIZE/CLBYTES; j++)
682: if (counts[j] != 0)
683: printf(", %d-%d", j * CLBYTES, counts[j]);
684: printf("\n");
685: }
686: }
687:
688: /*
689: * File handle to vnode
690: *
691: * Have to be really careful about stale file handles:
692: * - check that the inode number is in range
693: * - call iget() to get the locked inode
694: * - check for an unallocated inode (i_mode == 0)
695: * - check that the generation number matches
696: */
697: ufs_fhtovp(mp, fhp, vpp)
698: register struct mount *mp;
699: struct fid *fhp;
700: struct vnode **vpp;
701: {
702: register struct ufid *ufhp;
703: register struct fs *fs;
704: register struct inode *ip;
705: struct inode *nip;
706: struct vnode tvp;
707: int error;
708:
709: ufhp = (struct ufid *)fhp;
710: fs = VFSTOUFS(mp)->um_fs;
711: if (ufhp->ufid_ino < ROOTINO ||
712: ufhp->ufid_ino >= fs->fs_ncg * fs->fs_ipg) {
713: *vpp = NULLVP;
714: return (EINVAL);
715: }
716: tvp.v_mount = mp;
717: ip = VTOI(&tvp);
718: ip->i_vnode = &tvp;
719: ip->i_dev = VFSTOUFS(mp)->um_dev;
720: if (error = iget(ip, ufhp->ufid_ino, &nip)) {
721: *vpp = NULLVP;
722: return (error);
723: }
724: ip = nip;
725: if (ip->i_mode == 0) {
726: iput(ip);
727: *vpp = NULLVP;
728: return (EINVAL);
729: }
730: if (ip->i_gen != ufhp->ufid_gen) {
731: iput(ip);
732: *vpp = NULLVP;
733: return (EINVAL);
734: }
735: *vpp = ITOV(ip);
736: return (0);
737: }
738:
739: /*
740: * Vnode pointer to File handle
741: */
742: /* ARGSUSED */
743: ufs_vptofh(vp, fhp)
744: struct vnode *vp;
745: struct fid *fhp;
746: {
747: register struct inode *ip = VTOI(vp);
748: register struct ufid *ufhp;
749:
750: ufhp = (struct ufid *)fhp;
751: ufhp->ufid_len = sizeof(struct ufid);
752: ufhp->ufid_ino = ip->i_number;
753: ufhp->ufid_gen = ip->i_gen;
754: return (0);
755: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.