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