Annotation of sys/ufs/ext2fs/ext2fs_vfsops.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: ext2fs_vfsops.c,v 1.48 2007/06/17 20:15:25 jasper Exp $ */
2: /* $NetBSD: ext2fs_vfsops.c,v 1.1 1997/06/11 09:34:07 bouyer Exp $ */
3:
4: /*
5: * Copyright (c) 1997 Manuel Bouyer.
6: * Copyright (c) 1989, 1991, 1993, 1994
7: * The Regents of the University of California. All rights reserved.
8: *
9: * Redistribution and use in source and binary forms, with or without
10: * modification, are permitted provided that the following conditions
11: * are met:
12: * 1. Redistributions of source code must retain the above copyright
13: * notice, this list of conditions and the following disclaimer.
14: * 2. Redistributions in binary form must reproduce the above copyright
15: * notice, this list of conditions and the following disclaimer in the
16: * documentation and/or other materials provided with the distribution.
17: * 3. 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: * @(#)ffs_vfsops.c 8.14 (Berkeley) 11/28/94
34: * Modified for ext2fs by Manuel Bouyer.
35: */
36:
37: #include <sys/param.h>
38: #include <sys/systm.h>
39: #include <sys/namei.h>
40: #include <sys/proc.h>
41: #include <sys/kernel.h>
42: #include <sys/vnode.h>
43: #include <sys/socket.h>
44: #include <sys/mount.h>
45: #include <sys/buf.h>
46: #include <sys/device.h>
47: #include <sys/mbuf.h>
48: #include <sys/file.h>
49: #include <sys/disklabel.h>
50: #include <sys/ioctl.h>
51: #include <sys/errno.h>
52: #include <sys/malloc.h>
53: #include <sys/pool.h>
54: #include <sys/lock.h>
55:
56: #include <miscfs/specfs/specdev.h>
57:
58: #include <ufs/ufs/quota.h>
59: #include <ufs/ufs/ufsmount.h>
60: #include <ufs/ufs/inode.h>
61: #include <ufs/ufs/dir.h>
62: #include <ufs/ufs/ufs_extern.h>
63:
64: #include <ufs/ext2fs/ext2fs.h>
65: #include <ufs/ext2fs/ext2fs_extern.h>
66:
67: extern struct lock ufs_hashlock;
68:
69: int ext2fs_sbupdate(struct ufsmount *, int);
70: static int ext2fs_checksb(struct ext2fs *, int);
71:
72: extern struct vnodeopv_desc ext2fs_vnodeop_opv_desc;
73: extern struct vnodeopv_desc ext2fs_specop_opv_desc;
74: #ifdef FIFO
75: extern struct vnodeopv_desc ext2fs_fifoop_opv_desc;
76: #endif
77:
78: struct vnodeopv_desc *ext2fs_vnodeopv_descs[] = {
79: &ext2fs_vnodeop_opv_desc,
80: &ext2fs_specop_opv_desc,
81: #ifdef FIFO
82: &ext2fs_fifoop_opv_desc,
83: #endif
84: NULL,
85: };
86:
87: const struct vfsops ext2fs_vfsops = {
88: ext2fs_mount,
89: ufs_start,
90: ext2fs_unmount,
91: ufs_root,
92: ufs_quotactl,
93: ext2fs_statfs,
94: ext2fs_sync,
95: ext2fs_vget,
96: ext2fs_fhtovp,
97: ext2fs_vptofh,
98: ext2fs_init,
99: ext2fs_sysctl,
100: ufs_check_export
101: };
102:
103: struct pool ext2fs_inode_pool;
104: struct pool ext2fs_dinode_pool;
105:
106: extern u_long ext2gennumber;
107:
108: int
109: ext2fs_init(struct vfsconf *vfsp)
110: {
111: pool_init(&ext2fs_inode_pool, sizeof(struct inode), 0, 0, 0,
112: "ext2inopl", &pool_allocator_nointr);
113: pool_init(&ext2fs_dinode_pool, sizeof(struct ext2fs_dinode), 0, 0, 0,
114: "ext2dinopl", &pool_allocator_nointr);
115:
116: return (ufs_init(vfsp));
117: }
118:
119: /*
120: * Called by main() when ext2fs is going to be mounted as root.
121: *
122: * Name is updated by mount(8) after booting.
123: */
124: #define ROOTNAME "root_device"
125:
126: int
127: ext2fs_mountroot(void)
128: {
129: struct m_ext2fs *fs;
130: struct mount *mp;
131: struct proc *p = curproc; /* XXX */
132: struct ufsmount *ump;
133: int error;
134:
135: /*
136: * Get vnodes for swapdev and rootdev.
137: */
138: if (bdevvp(swapdev, &swapdev_vp) || bdevvp(rootdev, &rootvp))
139: panic("ext2fs_mountroot: can't setup bdevvp's");
140:
141: if ((error = vfs_rootmountalloc("ext2fs", "root_device", &mp)) != 0) {
142: vrele(rootvp);
143: return (error);
144: }
145:
146: if ((error = ext2fs_mountfs(rootvp, mp, p)) != 0) {
147: mp->mnt_vfc->vfc_refcount--;
148: vfs_unbusy(mp);
149: free(mp, M_MOUNT);
150: vrele(rootvp);
151: return (error);
152: }
153:
154: CIRCLEQ_INSERT_TAIL(&mountlist, mp, mnt_list);
155: ump = VFSTOUFS(mp);
156: fs = ump->um_e2fs;
157: bzero(fs->e2fs_fsmnt, sizeof(fs->e2fs_fsmnt));
158: (void) copystr(mp->mnt_stat.f_mntonname, fs->e2fs_fsmnt,
159: sizeof(fs->e2fs_fsmnt) - 1, 0);
160: if (fs->e2fs.e2fs_rev > E2FS_REV0) {
161: bzero(fs->e2fs.e2fs_fsmnt, sizeof(fs->e2fs.e2fs_fsmnt));
162: (void) copystr(mp->mnt_stat.f_mntonname, fs->e2fs.e2fs_fsmnt,
163: sizeof(fs->e2fs.e2fs_fsmnt) - 1, 0);
164: }
165: (void)ext2fs_statfs(mp, &mp->mnt_stat, p);
166: vfs_unbusy(mp);
167: inittodr(fs->e2fs.e2fs_wtime);
168: return (0);
169: }
170:
171: /*
172: * VFS Operations.
173: *
174: * mount system call
175: */
176: int
177: ext2fs_mount(struct mount *mp, const char *path, void *data,
178: struct nameidata *ndp, struct proc *p)
179: {
180: struct vnode *devvp;
181: struct ufs_args args;
182: struct ufsmount *ump = NULL;
183: struct m_ext2fs *fs;
184: size_t size;
185: int error, flags;
186: mode_t accessmode;
187:
188: error = copyin(data, (caddr_t)&args, sizeof (struct ufs_args));
189: if (error)
190: return (error);
191: /*
192: * If updating, check whether changing from read-only to
193: * read/write; if there is no device name, that's all we do.
194: */
195: if (mp->mnt_flag & MNT_UPDATE) {
196: ump = VFSTOUFS(mp);
197: fs = ump->um_e2fs;
198: if (fs->e2fs_ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) {
199: flags = WRITECLOSE;
200: if (mp->mnt_flag & MNT_FORCE)
201: flags |= FORCECLOSE;
202: error = ext2fs_flushfiles(mp, flags, p);
203: if (error == 0 &&
204: ext2fs_cgupdate(ump, MNT_WAIT) == 0 &&
205: (fs->e2fs.e2fs_state & E2FS_ERRORS) == 0) {
206: fs->e2fs.e2fs_state = E2FS_ISCLEAN;
207: (void) ext2fs_sbupdate(ump, MNT_WAIT);
208: }
209: if (error)
210: return (error);
211: fs->e2fs_ronly = 1;
212: }
213: if (mp->mnt_flag & MNT_RELOAD) {
214: error = ext2fs_reload(mp, ndp->ni_cnd.cn_cred, p);
215: if (error)
216: return (error);
217: }
218: if (fs->e2fs_ronly && (mp->mnt_flag & MNT_WANTRDWR)) {
219: /*
220: * If upgrade to read-write by non-root, then verify
221: * that user has necessary permissions on the device.
222: */
223: if (p->p_ucred->cr_uid != 0) {
224: devvp = ump->um_devvp;
225: vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p);
226: error = VOP_ACCESS(devvp, VREAD | VWRITE,
227: p->p_ucred, p);
228: if (error) {
229: VOP_UNLOCK(devvp, 0, p);
230: return (error);
231: }
232: VOP_UNLOCK(devvp, 0, p);
233: }
234: fs->e2fs_ronly = 0;
235: if (fs->e2fs.e2fs_state == E2FS_ISCLEAN)
236: fs->e2fs.e2fs_state = 0;
237: else
238: fs->e2fs.e2fs_state = E2FS_ERRORS;
239: fs->e2fs_fmod = 1;
240: }
241: if (args.fspec == 0) {
242: /*
243: * Process export requests.
244: */
245: return (vfs_export(mp, &ump->um_export,
246: &args.export_info));
247: }
248: }
249: /*
250: * Not an update, or updating the name: look up the name
251: * and verify that it refers to a sensible block device.
252: */
253: NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, args.fspec, p);
254: if ((error = namei(ndp)) != 0)
255: return (error);
256: devvp = ndp->ni_vp;
257:
258: if (devvp->v_type != VBLK) {
259: vrele(devvp);
260: return (ENOTBLK);
261: }
262: if (major(devvp->v_rdev) >= nblkdev) {
263: vrele(devvp);
264: return (ENXIO);
265: }
266: /*
267: * If mount by non-root, then verify that user has necessary
268: * permissions on the device.
269: */
270: if (p->p_ucred->cr_uid != 0) {
271: accessmode = VREAD;
272: if ((mp->mnt_flag & MNT_RDONLY) == 0)
273: accessmode |= VWRITE;
274: vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p);
275: error = VOP_ACCESS(devvp, accessmode, p->p_ucred, p);
276: if (error) {
277: vput(devvp);
278: return (error);
279: }
280: VOP_UNLOCK(devvp, 0, p);
281: }
282: if ((mp->mnt_flag & MNT_UPDATE) == 0)
283: error = ext2fs_mountfs(devvp, mp, p);
284: else {
285: if (devvp != ump->um_devvp)
286: error = EINVAL; /* XXX needs translation */
287: else
288: vrele(devvp);
289: }
290: if (error) {
291: vrele(devvp);
292: return (error);
293: }
294: ump = VFSTOUFS(mp);
295: fs = ump->um_e2fs;
296: (void) copyinstr(path, fs->e2fs_fsmnt, sizeof(fs->e2fs_fsmnt) - 1,
297: &size);
298: bzero(fs->e2fs_fsmnt + size, sizeof(fs->e2fs_fsmnt) - size);
299: if (fs->e2fs.e2fs_rev > E2FS_REV0) {
300: (void) copystr(mp->mnt_stat.f_mntonname, fs->e2fs.e2fs_fsmnt,
301: sizeof(fs->e2fs.e2fs_fsmnt) - 1, &size);
302: bzero(fs->e2fs.e2fs_fsmnt, sizeof(fs->e2fs.e2fs_fsmnt) - size);
303: }
304: bcopy(fs->e2fs_fsmnt, mp->mnt_stat.f_mntonname, MNAMELEN);
305: (void) copyinstr(args.fspec, mp->mnt_stat.f_mntfromname, MNAMELEN - 1,
306: &size);
307: bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
308: if (fs->e2fs_fmod != 0) { /* XXX */
309: fs->e2fs_fmod = 0;
310: if (fs->e2fs.e2fs_state == 0)
311: fs->e2fs.e2fs_wtime = time_second;
312: else
313: printf("%s: file system not clean; please fsck(8)\n",
314: mp->mnt_stat.f_mntfromname);
315: (void) ext2fs_cgupdate(ump, MNT_WAIT);
316: }
317: return (0);
318: }
319:
320: int ext2fs_reload_vnode(struct vnode *, void *args);
321:
322: struct ext2fs_reload_args {
323: struct m_ext2fs *fs;
324: struct proc *p;
325: struct ucred *cred;
326: struct vnode *devvp;
327: };
328:
329: int
330: ext2fs_reload_vnode(struct vnode *vp, void *args)
331: {
332: struct ext2fs_reload_args *era = args;
333: struct buf *bp;
334: struct inode *ip;
335: int error;
336: caddr_t cp;
337:
338: /*
339: * Step 4: invalidate all inactive vnodes.
340: */
341: if (vp->v_usecount == 0) {
342: vgonel(vp, era->p);
343: return (0);
344: }
345:
346: /*
347: * Step 5: invalidate all cached file data.
348: */
349: if (vget(vp, LK_EXCLUSIVE, era->p))
350: return (0);
351:
352: if (vinvalbuf(vp, 0, era->cred, era->p, 0, 0))
353: panic("ext2fs_reload: dirty2");
354: /*
355: * Step 6: re-read inode data for all active vnodes.
356: */
357: ip = VTOI(vp);
358: error = bread(era->devvp,
359: fsbtodb(era->fs, ino_to_fsba(era->fs, ip->i_number)),
360: (int)era->fs->e2fs_bsize, NOCRED, &bp);
361: if (error) {
362: vput(vp);
363: return (error);
364: }
365: cp = (caddr_t)bp->b_data +
366: (ino_to_fsbo(era->fs, ip->i_number) * EXT2_DINODE_SIZE);
367: e2fs_iload((struct ext2fs_dinode *)cp, ip->i_e2din);
368: brelse(bp);
369: vput(vp);
370: return (0);
371: }
372:
373: /*
374: * Reload all incore data for a filesystem (used after running fsck on
375: * the root filesystem and finding things to fix). The filesystem must
376: * be mounted read-only.
377: *
378: * Things to do to update the mount:
379: * 1) invalidate all cached meta-data.
380: * 2) re-read superblock from disk.
381: * 3) re-read summary information from disk.
382: * 4) invalidate all inactive vnodes.
383: * 5) invalidate all cached file data.
384: * 6) re-read inode data for all active vnodes.
385: */
386: int
387: ext2fs_reload(struct mount *mountp, struct ucred *cred, struct proc *p)
388: {
389: struct vnode *devvp;
390: struct buf *bp;
391: struct m_ext2fs *fs;
392: struct ext2fs *newfs;
393: struct partinfo dpart;
394: int i, size, error;
395: struct ext2fs_reload_args era;
396:
397: if ((mountp->mnt_flag & MNT_RDONLY) == 0)
398: return (EINVAL);
399: /*
400: * Step 1: invalidate all cached meta-data.
401: */
402: devvp = VFSTOUFS(mountp)->um_devvp;
403: if (vinvalbuf(devvp, 0, cred, p, 0, 0))
404: panic("ext2fs_reload: dirty1");
405:
406: /*
407: * Step 2: re-read superblock from disk.
408: */
409: if (VOP_IOCTL(devvp, DIOCGPART, (caddr_t)&dpart, FREAD, NOCRED, p) != 0)
410: size = DEV_BSIZE;
411: else
412: size = dpart.disklab->d_secsize;
413: error = bread(devvp, (int32_t)(SBOFF / size), SBSIZE, NOCRED, &bp);
414: if (error) {
415: brelse(bp);
416: return (error);
417: }
418: newfs = (struct ext2fs *)bp->b_data;
419: error = ext2fs_checksb(newfs, (mountp->mnt_flag & MNT_RDONLY) != 0);
420: if (error) {
421: brelse(bp);
422: return (error);
423: }
424:
425: fs = VFSTOUFS(mountp)->um_e2fs;
426: /*
427: * copy in new superblock, and compute in-memory values
428: */
429: e2fs_sbload(newfs, &fs->e2fs);
430: fs->e2fs_ncg =
431: howmany(fs->e2fs.e2fs_bcount - fs->e2fs.e2fs_first_dblock,
432: fs->e2fs.e2fs_bpg);
433: /* XXX assume hw bsize = 512 */
434: fs->e2fs_fsbtodb = fs->e2fs.e2fs_log_bsize + 1;
435: fs->e2fs_bsize = 1024 << fs->e2fs.e2fs_log_bsize;
436: fs->e2fs_bshift = LOG_MINBSIZE + fs->e2fs.e2fs_log_bsize;
437: fs->e2fs_qbmask = fs->e2fs_bsize - 1;
438: fs->e2fs_bmask = ~fs->e2fs_qbmask;
439: fs->e2fs_ngdb = howmany(fs->e2fs_ncg,
440: fs->e2fs_bsize / sizeof(struct ext2_gd));
441: fs->e2fs_ipb = fs->e2fs_bsize / EXT2_DINODE_SIZE;
442: fs->e2fs_itpg = fs->e2fs.e2fs_ipg/fs->e2fs_ipb;
443:
444: /*
445: * Step 3: re-read summary information from disk.
446: */
447:
448: for (i=0; i < fs->e2fs_ngdb; i++) {
449: error = bread(devvp ,
450: fsbtodb(fs, ((fs->e2fs_bsize>1024)? 0 : 1) + i + 1),
451: fs->e2fs_bsize, NOCRED, &bp);
452: if (error) {
453: brelse(bp);
454: return (error);
455: }
456: e2fs_cgload((struct ext2_gd*)bp->b_data,
457: &fs->e2fs_gd[i* fs->e2fs_bsize / sizeof(struct ext2_gd)],
458: fs->e2fs_bsize);
459: brelse(bp);
460: }
461:
462: era.p = p;
463: era.cred = cred;
464: era.fs = fs;
465: era.devvp = devvp;
466:
467: error = vfs_mount_foreach_vnode(mountp, ext2fs_reload_vnode, &era);
468:
469: return (error);
470: }
471:
472: /*
473: * Common code for mount and mountroot
474: */
475: int
476: ext2fs_mountfs(struct vnode *devvp, struct mount *mp, struct proc *p)
477: {
478: struct ufsmount *ump;
479: struct buf *bp;
480: struct ext2fs *fs;
481: struct m_ext2fs *m_fs;
482: dev_t dev;
483: struct partinfo dpart;
484: int error, i, size, ronly;
485: struct ucred *cred;
486:
487: dev = devvp->v_rdev;
488: cred = p ? p->p_ucred : NOCRED;
489: /*
490: * Disallow multiple mounts of the same device.
491: * Disallow mounting of a device that is currently in use
492: * (except for root, which might share swap device for miniroot).
493: * Flush out any old buffers remaining from a previous use.
494: */
495: if ((error = vfs_mountedon(devvp)) != 0)
496: return (error);
497: if (vcount(devvp) > 1 && devvp != rootvp)
498: return (EBUSY);
499: if ((error = vinvalbuf(devvp, V_SAVE, cred, p, 0, 0)) != 0)
500: return (error);
501:
502: ronly = (mp->mnt_flag & MNT_RDONLY) != 0;
503: error = VOP_OPEN(devvp, ronly ? FREAD : FREAD|FWRITE, FSCRED, p);
504: if (error)
505: return (error);
506: if (VOP_IOCTL(devvp, DIOCGPART, (caddr_t)&dpart, FREAD, cred, p) != 0)
507: size = DEV_BSIZE;
508: else
509: size = dpart.disklab->d_secsize;
510:
511: bp = NULL;
512: ump = NULL;
513:
514: #ifdef DEBUG_EXT2
515: printf("sb size: %d ino size %d\n", sizeof(struct ext2fs),
516: EXT2_DINODE_SIZE);
517: #endif
518: error = bread(devvp, (SBOFF / DEV_BSIZE), SBSIZE, cred, &bp);
519: if (error)
520: goto out;
521: fs = (struct ext2fs *)bp->b_data;
522: error = ext2fs_checksb(fs, ronly);
523: if (error)
524: goto out;
525: ump = malloc(sizeof *ump, M_UFSMNT, M_WAITOK);
526: memset((caddr_t)ump, 0, sizeof *ump);
527: ump->um_e2fs = malloc(sizeof(struct m_ext2fs), M_UFSMNT, M_WAITOK);
528: memset((caddr_t)ump->um_e2fs, 0, sizeof(struct m_ext2fs));
529: e2fs_sbload((struct ext2fs*)bp->b_data, &ump->um_e2fs->e2fs);
530: brelse(bp);
531: bp = NULL;
532: m_fs = ump->um_e2fs;
533: m_fs->e2fs_ronly = ronly;
534: ump->um_fstype = UM_EXT2FS;
535: if (ronly == 0) {
536: if (m_fs->e2fs.e2fs_state == E2FS_ISCLEAN)
537: m_fs->e2fs.e2fs_state = 0;
538: else
539: m_fs->e2fs.e2fs_state = E2FS_ERRORS;
540: m_fs->e2fs_fmod = 1;
541: }
542:
543: /* compute dynamic sb infos */
544: m_fs->e2fs_ncg =
545: howmany(m_fs->e2fs.e2fs_bcount - m_fs->e2fs.e2fs_first_dblock,
546: m_fs->e2fs.e2fs_bpg);
547: /* XXX assume hw bsize = 512 */
548: m_fs->e2fs_fsbtodb = m_fs->e2fs.e2fs_log_bsize + 1;
549: m_fs->e2fs_bsize = 1024 << m_fs->e2fs.e2fs_log_bsize;
550: m_fs->e2fs_bshift = LOG_MINBSIZE + m_fs->e2fs.e2fs_log_bsize;
551: m_fs->e2fs_qbmask = m_fs->e2fs_bsize - 1;
552: m_fs->e2fs_bmask = ~m_fs->e2fs_qbmask;
553: m_fs->e2fs_ngdb = howmany(m_fs->e2fs_ncg,
554: m_fs->e2fs_bsize / sizeof(struct ext2_gd));
555: m_fs->e2fs_ipb = m_fs->e2fs_bsize / EXT2_DINODE_SIZE;
556: m_fs->e2fs_itpg = m_fs->e2fs.e2fs_ipg/m_fs->e2fs_ipb;
557:
558: m_fs->e2fs_gd = malloc(m_fs->e2fs_ngdb * m_fs->e2fs_bsize,
559: M_UFSMNT, M_WAITOK);
560: for (i=0; i < m_fs->e2fs_ngdb; i++) {
561: error = bread(devvp ,
562: fsbtodb(m_fs, ((m_fs->e2fs_bsize>1024)? 0 : 1) + i + 1),
563: m_fs->e2fs_bsize, NOCRED, &bp);
564: if (error) {
565: free(m_fs->e2fs_gd, M_UFSMNT);
566: goto out;
567: }
568: e2fs_cgload((struct ext2_gd*)bp->b_data,
569: &m_fs->e2fs_gd[
570: i * m_fs->e2fs_bsize / sizeof(struct ext2_gd)],
571: m_fs->e2fs_bsize);
572: brelse(bp);
573: bp = NULL;
574: }
575:
576: mp->mnt_data = (qaddr_t)ump;
577: mp->mnt_stat.f_fsid.val[0] = (long)dev;
578: mp->mnt_stat.f_fsid.val[1] = mp->mnt_vfc->vfc_typenum;
579: mp->mnt_maxsymlinklen = EXT2_MAXSYMLINKLEN;
580: mp->mnt_flag |= MNT_LOCAL;
581: ump->um_mountp = mp;
582: ump->um_dev = dev;
583: ump->um_devvp = devvp;
584: ump->um_nindir = NINDIR(m_fs);
585: ump->um_bptrtodb = m_fs->e2fs_fsbtodb;
586: ump->um_seqinc = 1; /* no frags */
587: devvp->v_specmountpoint = mp;
588: return (0);
589: out:
590: if (bp)
591: brelse(bp);
592: vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p);
593: (void)VOP_CLOSE(devvp, ronly ? FREAD : FREAD|FWRITE, cred, p);
594: VOP_UNLOCK(devvp, 0, p);
595: if (ump) {
596: free(ump->um_e2fs, M_UFSMNT);
597: free(ump, M_UFSMNT);
598: mp->mnt_data = (qaddr_t)0;
599: }
600: return (error);
601: }
602:
603: /*
604: * unmount system call
605: */
606: int
607: ext2fs_unmount(struct mount *mp, int mntflags, struct proc *p)
608: {
609: struct ufsmount *ump;
610: struct m_ext2fs *fs;
611: int error, flags;
612:
613: flags = 0;
614: if (mntflags & MNT_FORCE)
615: flags |= FORCECLOSE;
616: if ((error = ext2fs_flushfiles(mp, flags, p)) != 0)
617: return (error);
618: ump = VFSTOUFS(mp);
619: fs = ump->um_e2fs;
620: if (fs->e2fs_ronly == 0 &&
621: ext2fs_cgupdate(ump, MNT_WAIT) == 0 &&
622: (fs->e2fs.e2fs_state & E2FS_ERRORS) == 0) {
623: fs->e2fs.e2fs_state = E2FS_ISCLEAN;
624: (void) ext2fs_sbupdate(ump, MNT_WAIT);
625: }
626:
627: if (ump->um_devvp->v_type != VBAD)
628: ump->um_devvp->v_specmountpoint = NULL;
629: vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY, p);
630: error = VOP_CLOSE(ump->um_devvp, fs->e2fs_ronly ? FREAD : FREAD|FWRITE,
631: NOCRED, p);
632: vput(ump->um_devvp);
633: free(fs->e2fs_gd, M_UFSMNT);
634: free(fs, M_UFSMNT);
635: free(ump, M_UFSMNT);
636: mp->mnt_data = (qaddr_t)0;
637: mp->mnt_flag &= ~MNT_LOCAL;
638: return (error);
639: }
640:
641: /*
642: * Flush out all the files in a filesystem.
643: */
644: int
645: ext2fs_flushfiles(struct mount *mp, int flags, struct proc *p)
646: {
647: struct ufsmount *ump;
648: int error;
649:
650: ump = VFSTOUFS(mp);
651: /*
652: * Flush all the files.
653: */
654: if ((error = vflush(mp, NULL, flags)) != 0)
655: return (error);
656: /*
657: * Flush filesystem metadata.
658: */
659: vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY, p);
660: error = VOP_FSYNC(ump->um_devvp, p->p_ucred, MNT_WAIT, p);
661: VOP_UNLOCK(ump->um_devvp, 0, p);
662: return (error);
663: }
664:
665: /*
666: * Get file system statistics.
667: */
668: int
669: ext2fs_statfs(struct mount *mp, struct statfs *sbp, struct proc *p)
670: {
671: struct ufsmount *ump;
672: struct m_ext2fs *fs;
673: u_int32_t overhead, overhead_per_group;
674: int i, ngroups;
675:
676: ump = VFSTOUFS(mp);
677: fs = ump->um_e2fs;
678: if (fs->e2fs.e2fs_magic != E2FS_MAGIC)
679: panic("ext2fs_statfs");
680:
681: /*
682: * Compute the overhead (FS structures)
683: */
684: overhead_per_group = 1 /* block bitmap */ +
685: 1 /* inode bitmap */ +
686: fs->e2fs_itpg;
687: overhead = fs->e2fs.e2fs_first_dblock +
688: fs->e2fs_ncg * overhead_per_group;
689: if (fs->e2fs.e2fs_rev > E2FS_REV0 &&
690: fs->e2fs.e2fs_features_rocompat & EXT2F_ROCOMPAT_SPARSESUPER) {
691: for (i = 0, ngroups = 0; i < fs->e2fs_ncg; i++) {
692: if (cg_has_sb(i))
693: ngroups++;
694: }
695: } else {
696: ngroups = fs->e2fs_ncg;
697: }
698: overhead += ngroups * (1 + fs->e2fs_ngdb);
699:
700: sbp->f_bsize = fs->e2fs_bsize;
701: sbp->f_iosize = fs->e2fs_bsize;
702: sbp->f_blocks = fs->e2fs.e2fs_bcount - overhead;
703: sbp->f_bfree = fs->e2fs.e2fs_fbcount;
704: sbp->f_bavail = sbp->f_bfree - fs->e2fs.e2fs_rbcount;
705: sbp->f_files = fs->e2fs.e2fs_icount;
706: sbp->f_ffree = fs->e2fs.e2fs_ficount;
707: if (sbp != &mp->mnt_stat) {
708: bcopy(mp->mnt_stat.f_mntonname, sbp->f_mntonname, MNAMELEN);
709: bcopy(mp->mnt_stat.f_mntfromname, sbp->f_mntfromname, MNAMELEN);
710: }
711: strncpy(sbp->f_fstypename, mp->mnt_vfc->vfc_name, MFSNAMELEN);
712: return (0);
713: }
714:
715: int ext2fs_sync_vnode(struct vnode *vp, void *);
716:
717: struct ext2fs_sync_args {
718: int allerror;
719: int waitfor;
720: struct proc *p;
721: struct ucred *cred;
722: };
723:
724: int
725: ext2fs_sync_vnode(struct vnode *vp, void *args)
726: {
727: struct ext2fs_sync_args *esa = args;
728: struct inode *ip;
729: int error;
730:
731: ip = VTOI(vp);
732: if (vp->v_type == VNON ||
733: ((ip->i_flag & (IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE)) == 0 &&
734: LIST_EMPTY(&vp->v_dirtyblkhd)) ||
735: esa->waitfor == MNT_LAZY) {
736: return (0);
737: }
738:
739: if (vget(vp, LK_EXCLUSIVE | LK_NOWAIT, esa->p))
740: return (0);
741:
742: if ((error = VOP_FSYNC(vp, esa->cred, esa->waitfor, esa->p)) != 0)
743: esa->allerror = error;
744: vput(vp);
745: return (0);
746: }
747: /*
748: * Go through the disk queues to initiate sandbagged IO;
749: * go through the inodes to write those that have been modified;
750: * initiate the writing of the super block if it has been modified.
751: *
752: * Should always be called with the mount point locked.
753: */
754: int
755: ext2fs_sync(struct mount *mp, int waitfor, struct ucred *cred, struct proc *p)
756: {
757: struct ufsmount *ump = VFSTOUFS(mp);
758: struct m_ext2fs *fs;
759: int error, allerror = 0;
760: struct ext2fs_sync_args esa;
761:
762: fs = ump->um_e2fs;
763: if (fs->e2fs_ronly != 0) { /* XXX */
764: printf("fs = %s\n", fs->e2fs_fsmnt);
765: panic("update: rofs mod");
766: }
767:
768: /*
769: * Write back each (modified) inode.
770: */
771: esa.p = p;
772: esa.cred = cred;
773: esa.allerror = 0;
774: esa.waitfor = waitfor;
775:
776: vfs_mount_foreach_vnode(mp, ext2fs_sync_vnode, &esa);
777: if (esa.allerror != 0)
778: allerror = esa.allerror;
779:
780: /*
781: * Force stale file system control information to be flushed.
782: */
783: if (waitfor != MNT_LAZY) {
784: vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY, p);
785: if ((error = VOP_FSYNC(ump->um_devvp, cred, waitfor, p)) != 0)
786: allerror = error;
787: VOP_UNLOCK(ump->um_devvp, 0, p);
788: }
789: /*
790: * Write back modified superblock.
791: */
792: if (fs->e2fs_fmod != 0) {
793: fs->e2fs_fmod = 0;
794: fs->e2fs.e2fs_wtime = time_second;
795: if ((error = ext2fs_cgupdate(ump, waitfor)))
796: allerror = error;
797: }
798: return (allerror);
799: }
800:
801: /*
802: * Look up a EXT2FS dinode number to find its incore vnode, otherwise read it
803: * in from disk. If it is in core, wait for the lock bit to clear, then
804: * return the inode locked. Detection and handling of mount points must be
805: * done by the calling routine.
806: */
807: int
808: ext2fs_vget(struct mount *mp, ino_t ino, struct vnode **vpp)
809: {
810: struct m_ext2fs *fs;
811: struct inode *ip;
812: struct ext2fs_dinode *dp;
813: struct ufsmount *ump;
814: struct buf *bp;
815: struct vnode *vp;
816: dev_t dev;
817: int error;
818:
819: ump = VFSTOUFS(mp);
820: dev = ump->um_dev;
821:
822: retry:
823: if ((*vpp = ufs_ihashget(dev, ino)) != NULL)
824: return (0);
825:
826: /* Allocate a new vnode/inode. */
827: if ((error = getnewvnode(VT_EXT2FS, mp, ext2fs_vnodeop_p, &vp)) != 0) {
828: *vpp = NULL;
829: return (error);
830: }
831:
832: ip = pool_get(&ext2fs_inode_pool, PR_WAITOK);
833: memset(ip, 0, sizeof(struct inode));
834: lockinit(&ip->i_lock, PINOD, "inode", 0, 0);
835: vp->v_data = ip;
836: ip->i_vnode = vp;
837: ip->i_ump = ump;
838: ip->i_e2fs = fs = ump->um_e2fs;
839: ip->i_dev = dev;
840: ip->i_number = ino;
841: ip->i_e2fs_last_lblk = 0;
842: ip->i_e2fs_last_blk = 0;
843:
844: /*
845: * Put it onto its hash chain and lock it so that other requests for
846: * this inode will block if they arrive while we are sleeping waiting
847: * for old data structures to be purged or for the contents of the
848: * disk portion of this inode to be read.
849: */
850: error = ufs_ihashins(ip);
851:
852: if (error) {
853: vrele(vp);
854:
855: if (error == EEXIST)
856: goto retry;
857:
858: return (error);
859: }
860:
861: /* Read in the disk contents for the inode, copy into the inode. */
862: error = bread(ump->um_devvp, fsbtodb(fs, ino_to_fsba(fs, ino)),
863: (int)fs->e2fs_bsize, NOCRED, &bp);
864: if (error) {
865: /*
866: * The inode does not contain anything useful, so it would
867: * be misleading to leave it on its hash chain. With mode
868: * still zero, it will be unlinked and returned to the free
869: * list by vput().
870: */
871: vput(vp);
872: brelse(bp);
873: *vpp = NULL;
874: return (error);
875: }
876:
877: dp = (struct ext2fs_dinode *) bp->b_data + ino_to_fsbo(fs, ino);
878: ip->i_e2din = pool_get(&ext2fs_dinode_pool, PR_WAITOK);
879: e2fs_iload(dp, ip->i_e2din);
880: brelse(bp);
881:
882: ip->i_effnlink = ip->i_e2fs_nlink;
883:
884: /*
885: * The fields for storing the UID and GID of an ext2fs inode are
886: * limited to 16 bits. To overcome this limitation, Linux decided to
887: * scatter the highest bits of these values into a previously reserved
888: * area on the disk inode. We deal with this situation by having two
889: * 32-bit fields *out* of the disk inode to hold the complete values.
890: * Now that we are reading in the inode, compute these fields.
891: */
892: ip->i_e2fs_uid = ip->i_e2fs_uid_low | (ip->i_e2fs_uid_high << 16);
893: ip->i_e2fs_gid = ip->i_e2fs_gid_low | (ip->i_e2fs_gid_high << 16);
894:
895: /* If the inode was deleted, reset all fields */
896: if (ip->i_e2fs_dtime != 0) {
897: ip->i_e2fs_mode = ip->i_e2fs_nblock = 0;
898: (void)ext2fs_setsize(ip, 0);
899: }
900:
901: /*
902: * Initialize the vnode from the inode, check for aliases.
903: * Note that the underlying vnode may have changed.
904: */
905: error = ext2fs_vinit(mp, ext2fs_specop_p, EXT2FS_FIFOOPS, &vp);
906: if (error) {
907: vput(vp);
908: *vpp = NULL;
909: return (error);
910: }
911:
912: /*
913: * Finish inode initialization now that aliasing has been resolved.
914: */
915: VREF(ip->i_devvp);
916: /*
917: * Set up a generation number for this inode if it does not
918: * already have one. This should only happen on old filesystems.
919: */
920: if (ip->i_e2fs_gen == 0) {
921: if (++ext2gennumber < (u_long)time_second)
922: ext2gennumber = time_second;
923: ip->i_e2fs_gen = ext2gennumber;
924: if ((vp->v_mount->mnt_flag & MNT_RDONLY) == 0)
925: ip->i_flag |= IN_MODIFIED;
926: }
927:
928: *vpp = vp;
929: return (0);
930: }
931:
932: /*
933: * File handle to vnode
934: *
935: * Have to be really careful about stale file handles:
936: * - check that the inode number is valid
937: * - call ext2fs_vget() to get the locked inode
938: * - check for an unallocated inode (i_mode == 0)
939: * - check that the given client host has export rights and return
940: * those rights via. exflagsp and credanonp
941: */
942: int
943: ext2fs_fhtovp(struct mount *mp, struct fid *fhp, struct vnode **vpp)
944: {
945: struct inode *ip;
946: struct vnode *nvp;
947: int error;
948: struct ufid *ufhp;
949: struct m_ext2fs *fs;
950:
951: ufhp = (struct ufid *)fhp;
952: fs = VFSTOUFS(mp)->um_e2fs;
953: if ((ufhp->ufid_ino < EXT2_FIRSTINO && ufhp->ufid_ino != EXT2_ROOTINO) ||
954: ufhp->ufid_ino > fs->e2fs_ncg * fs->e2fs.e2fs_ipg)
955: return (ESTALE);
956:
957: if ((error = VFS_VGET(mp, ufhp->ufid_ino, &nvp)) != 0) {
958: *vpp = NULLVP;
959: return (error);
960: }
961: ip = VTOI(nvp);
962: if (ip->i_e2fs_mode == 0 || ip->i_e2fs_dtime != 0 ||
963: ip->i_e2fs_gen != ufhp->ufid_gen) {
964: vput(nvp);
965: *vpp = NULLVP;
966: return (ESTALE);
967: }
968: *vpp = nvp;
969: return (0);
970: }
971:
972: /*
973: * Vnode pointer to File handle
974: */
975: /* ARGSUSED */
976: int
977: ext2fs_vptofh(struct vnode *vp, struct fid *fhp)
978: {
979: struct inode *ip;
980: struct ufid *ufhp;
981:
982: ip = VTOI(vp);
983: ufhp = (struct ufid *)fhp;
984: ufhp->ufid_len = sizeof(struct ufid);
985: ufhp->ufid_ino = ip->i_number;
986: ufhp->ufid_gen = ip->i_e2fs_gen;
987: return (0);
988: }
989:
990: /*
991: * no sysctl for ext2fs
992: */
993:
994: int
995: ext2fs_sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp,
996: void *newp, size_t newlen, struct proc *p)
997: {
998: return (EOPNOTSUPP);
999: }
1000:
1001: /*
1002: * Write a superblock and associated information back to disk.
1003: */
1004: int
1005: ext2fs_sbupdate(struct ufsmount *mp, int waitfor)
1006: {
1007: struct m_ext2fs *fs = mp->um_e2fs;
1008: struct buf *bp;
1009: int error = 0;
1010:
1011: bp = getblk(mp->um_devvp, SBLOCK, SBSIZE, 0, 0);
1012: e2fs_sbsave(&fs->e2fs, (struct ext2fs *) bp->b_data);
1013: if (waitfor == MNT_WAIT)
1014: error = bwrite(bp);
1015: else
1016: bawrite(bp);
1017: return (error);
1018: }
1019:
1020: int
1021: ext2fs_cgupdate(struct ufsmount *mp, int waitfor)
1022: {
1023: struct m_ext2fs *fs = mp->um_e2fs;
1024: struct buf *bp;
1025: int i, error = 0, allerror = 0;
1026:
1027: allerror = ext2fs_sbupdate(mp, waitfor);
1028: for (i = 0; i < fs->e2fs_ngdb; i++) {
1029: bp = getblk(mp->um_devvp, fsbtodb(fs, ((fs->e2fs_bsize>1024)?0:1)+i+1),
1030: fs->e2fs_bsize, 0, 0);
1031: e2fs_cgsave(&fs->e2fs_gd[i* fs->e2fs_bsize / sizeof(struct ext2_gd)], (struct ext2_gd*)bp->b_data, fs->e2fs_bsize);
1032: if (waitfor == MNT_WAIT)
1033: error = bwrite(bp);
1034: else
1035: bawrite(bp);
1036: }
1037:
1038: if (!allerror && error)
1039: allerror = error;
1040: return (allerror);
1041: }
1042:
1043: static int
1044: ext2fs_checksb(struct ext2fs *fs, int ronly)
1045: {
1046: if (fs2h16(fs->e2fs_magic) != E2FS_MAGIC) {
1047: return (EIO); /* XXX needs translation */
1048: }
1049: if (fs2h32(fs->e2fs_rev) > E2FS_REV1) {
1050: #ifdef DIAGNOSTIC
1051: printf("Ext2 fs: unsupported revision number: %x\n",
1052: fs2h32(fs->e2fs_rev));
1053: #endif
1054: return (EIO); /* XXX needs translation */
1055: }
1056: if (fs2h32(fs->e2fs_log_bsize) > 2) { /* block size = 1024|2048|4096 */
1057: #ifdef DIAGNOSTIC
1058: printf("Ext2 fs: bad block size: %d (expected <=2 for ext2 fs)\n",
1059: fs2h32(fs->e2fs_log_bsize));
1060: #endif
1061: return (EIO); /* XXX needs translation */
1062: }
1063: if (fs2h32(fs->e2fs_rev) > E2FS_REV0) {
1064: if (fs2h32(fs->e2fs_first_ino) != EXT2_FIRSTINO ||
1065: fs2h16(fs->e2fs_inode_size) != EXT2_DINODE_SIZE) {
1066: printf("Ext2 fs: unsupported inode size\n");
1067: return (EINVAL); /* XXX needs translation */
1068: }
1069: if (fs2h32(fs->e2fs_features_incompat) &
1070: ~EXT2F_INCOMPAT_SUPP) {
1071: printf("Ext2 fs: unsupported optional feature\n");
1072: return (EINVAL); /* XXX needs translation */
1073: }
1074: if (!ronly && fs2h32(fs->e2fs_features_rocompat) &
1075: ~EXT2F_ROCOMPAT_SUPP) {
1076: return (EROFS); /* XXX needs translation */
1077: }
1078: }
1079: return (0);
1080: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to ext2fs_vfsops.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / ufs / ext2fs