![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ffs_vfsops.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / ufs / ffs|
Return to ffs_vfsops.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / ufs / ffs |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
26: /*
27: * Copyright (c) 1989, 1991, 1993, 1994
28: * The Regents of the University of California. All rights reserved.
29: *
30: * Redistribution and use in source and binary forms, with or without
31: * modification, are permitted provided that the following conditions
32: * are met:
33: * 1. Redistributions of source code must retain the above copyright
34: * notice, this list of conditions and the following disclaimer.
35: * 2. Redistributions in binary form must reproduce the above copyright
36: * notice, this list of conditions and the following disclaimer in the
37: * documentation and/or other materials provided with the distribution.
38: * 3. All advertising materials mentioning features or use of this software
39: * must display the following acknowledgement:
40: * This product includes software developed by the University of
41: * California, Berkeley and its contributors.
42: * 4. Neither the name of the University nor the names of its contributors
43: * may be used to endorse or promote products derived from this software
44: * without specific prior written permission.
45: *
46: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
47: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
48: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
49: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
50: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
51: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
52: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
53: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
54: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
55: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
56: * SUCH DAMAGE.
57: *
58: * @(#)ffs_vfsops.c 8.31 (Berkeley) 5/20/95
59: */
60:
61: #include <rev_endian_fs.h>
62: #include <mach_nbc.h>
63: #include <sys/param.h>
64: #include <sys/systm.h>
65: #include <sys/namei.h>
66: #include <sys/proc.h>
67: #include <sys/kernel.h>
68: #include <sys/vnode.h>
69: #include <sys/socket.h>
70: #include <sys/mount.h>
71: #include <sys/buf.h>
72: #include <sys/mbuf.h>
73: #include <sys/file.h>
74: #ifdef NeXT
75: #include <bsd/dev/disk.h>
76: #else
77: #include <sys/disklabel.h>
78: #endif
79: #include <sys/ioctl.h>
80: #include <sys/errno.h>
81: #include <sys/malloc.h>
82:
83: #include <miscfs/specfs/specdev.h>
84:
85: #include <ufs/ufs/quota.h>
86: #include <ufs/ufs/ufsmount.h>
87: #include <ufs/ufs/inode.h>
88: #include <ufs/ufs/ufs_extern.h>
89:
90: #include <ufs/ffs/fs.h>
91: #include <ufs/ffs/ffs_extern.h>
92: #if REV_ENDIAN_FS
93: #include <ufs/ufs/ufs_byte_order.h>
94: #include <architecture/byte_order.h>
95: #endif /* REV_ENDIAN_FS */
96:
97: int ffs_sbupdate __P((struct ufsmount *, int));
98:
99: struct vfsops ufs_vfsops = {
100: ffs_mount,
101: ufs_start,
102: ffs_unmount,
103: ufs_root,
104: ufs_quotactl,
105: ffs_statfs,
106: ffs_sync,
107: ffs_vget,
108: ffs_fhtovp,
109: ffs_vptofh,
110: ffs_init,
111: ffs_sysctl,
112: };
113:
114: extern u_long nextgennumber;
115:
116: /*
117: * Called by main() when ufs is going to be mounted as root.
118: */
119: ffs_mountroot()
120: {
121: extern struct vnode *rootvp;
122: struct fs *fs;
123: struct mount *mp;
124: struct proc *p = current_proc(); /* XXX */
125: struct ufsmount *ump;
126: u_int size;
127: int error;
128:
129: /*
130: * Get vnode for rootdev.
131: */
132: if (error = bdevvp(rootdev, &rootvp)) {
133: printf("ffs_mountroot: can't setup bdevvp");
134: return (error);
135: }
136: if (error = vfs_rootmountalloc("ufs", "root_device", &mp))
137: return (error);
138: if (error = ffs_mountfs(rootvp, mp, p)) {
139: mp->mnt_vfc->vfc_refcount--;
140: vfs_unbusy(mp, p);
141: _FREE_ZONE(mp, sizeof (struct mount), M_MOUNT);
142: return (error);
143: }
144: simple_lock(&mountlist_slock);
145: CIRCLEQ_INSERT_TAIL(&mountlist, mp, mnt_list);
146: simple_unlock(&mountlist_slock);
147: ump = VFSTOUFS(mp);
148: fs = ump->um_fs;
149: (void) copystr(mp->mnt_stat.f_mntonname, fs->fs_fsmnt, MNAMELEN - 1, 0);
150: (void)ffs_statfs(mp, &mp->mnt_stat, p);
151: vfs_unbusy(mp, p);
152: inittodr(fs->fs_time);
153: return (0);
154: }
155:
156: /*
157: * VFS Operations.
158: *
159: * mount system call
160: */
161: int
162: ffs_mount(mp, path, data, ndp, p)
163: register struct mount *mp;
164: char *path;
165: caddr_t data;
166: struct nameidata *ndp;
167: struct proc *p;
168: {
169: struct vnode *devvp;
170: struct ufs_args args;
171: struct ufsmount *ump;
172: register struct fs *fs;
173: u_int size;
174: int error, flags;
175: mode_t accessmode;
176:
177: if (error = copyin(data, (caddr_t)&args, sizeof (struct ufs_args)))
178: return (error);
179: /*
180: * If updating, check whether changing from read-only to
181: * read/write; if there is no device name, that's all we do.
182: */
183: if (mp->mnt_flag & MNT_UPDATE) {
184: ump = VFSTOUFS(mp);
185: fs = ump->um_fs;
186: if (fs->fs_ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) {
187: flags = WRITECLOSE;
188: if (mp->mnt_flag & MNT_FORCE)
189: flags |= FORCECLOSE;
190: if (error = ffs_flushfiles(mp, flags, p))
191: return (error);
192: fs->fs_clean = 1;
193: fs->fs_ronly = 1;
194: if (error = ffs_sbupdate(ump, MNT_WAIT)) {
195: fs->fs_clean = 0;
196: fs->fs_ronly = 0;
197: return (error);
198: }
199: }
200: if ((mp->mnt_flag & MNT_RELOAD) &&
201: (error = ffs_reload(mp, ndp->ni_cnd.cn_cred, p)))
202: return (error);
203: if (fs->fs_ronly && (mp->mnt_flag & MNT_WANTRDWR)) {
204: /*
205: * If upgrade to read-write by non-root, then verify
206: * that user has necessary permissions on the device.
207: */
208: if (p->p_ucred->cr_uid != 0) {
209: devvp = ump->um_devvp;
210: vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p);
211: if (error = VOP_ACCESS(devvp, VREAD | VWRITE,
212: p->p_ucred, p)) {
213: VOP_UNLOCK(devvp, 0, p);
214: return (error);
215: }
216: VOP_UNLOCK(devvp, 0, p);
217: }
218: fs->fs_ronly = 0;
219: fs->fs_clean = 0;
220: (void) ffs_sbupdate(ump, MNT_WAIT);
221: }
222: if (args.fspec == 0) {
223: /*
224: * Process export requests.
225: */
226: return (vfs_export(mp, &ump->um_export, &args.export));
227: }
228: }
229: /*
230: * Not an update, or updating the name: look up the name
231: * and verify that it refers to a sensible block device.
232: */
233: NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, args.fspec, p);
234: if (error = namei(ndp))
235: return (error);
236: devvp = ndp->ni_vp;
237:
238: if (devvp->v_type != VBLK) {
239: vrele(devvp);
240: return (ENOTBLK);
241: }
242: if (major(devvp->v_rdev) >= nblkdev) {
243: vrele(devvp);
244: return (ENXIO);
245: }
246: /*
247: * If mount by non-root, then verify that user has necessary
248: * permissions on the device.
249: */
250: if (p->p_ucred->cr_uid != 0) {
251: accessmode = VREAD;
252: if ((mp->mnt_flag & MNT_RDONLY) == 0)
253: accessmode |= VWRITE;
254: vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p);
255: if (error = VOP_ACCESS(devvp, accessmode, p->p_ucred, p)) {
256: vput(devvp);
257: return (error);
258: }
259: VOP_UNLOCK(devvp, 0, p);
260: }
261: if ((mp->mnt_flag & MNT_UPDATE) == 0)
262: error = ffs_mountfs(devvp, mp, p);
263: else {
264: if (devvp != ump->um_devvp)
265: error = EINVAL; /* needs translation */
266: else
267: vrele(devvp);
268: }
269: if (error) {
270: vrele(devvp);
271: return (error);
272: }
273: ump = VFSTOUFS(mp);
274: fs = ump->um_fs;
275: (void) copyinstr(path, fs->fs_fsmnt, sizeof(fs->fs_fsmnt) - 1, &size);
276: bzero(fs->fs_fsmnt + size, sizeof(fs->fs_fsmnt) - size);
277: bcopy((caddr_t)fs->fs_fsmnt, (caddr_t)mp->mnt_stat.f_mntonname,
278: MNAMELEN);
279: (void) copyinstr(args.fspec, mp->mnt_stat.f_mntfromname, MNAMELEN - 1,
280: &size);
281: bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
282: (void)ffs_statfs(mp, &mp->mnt_stat, p);
283: return (0);
284: }
285:
286: /*
287: * Reload all incore data for a filesystem (used after running fsck on
288: * the root filesystem and finding things to fix). The filesystem must
289: * be mounted read-only.
290: *
291: * Things to do to update the mount:
292: * 1) invalidate all cached meta-data.
293: * 2) re-read superblock from disk.
294: * 3) re-read summary information from disk.
295: * 4) invalidate all inactive vnodes.
296: * 5) invalidate all cached file data.
297: * 6) re-read inode data for all active vnodes.
298: */
299: ffs_reload(mountp, cred, p)
300: register struct mount *mountp;
301: struct ucred *cred;
302: struct proc *p;
303: {
304: register struct vnode *vp, *nvp, *devvp;
305: struct inode *ip;
306: struct csum *space;
307: struct buf *bp;
308: struct fs *fs, *newfs;
309: #ifndef NeXT
310: struct partinfo dpart;
311: #endif /* NeXT */
312: int i, blks, size, error;
313: int32_t *lp;
314: #if REV_ENDIAN_FS
315: int rev_endian = (mountp->mnt_flag & MNT_REVEND);
316: #endif /* REV_ENDIAN_FS */
317:
318: if ((mountp->mnt_flag & MNT_RDONLY) == 0)
319: return (EINVAL);
320: /*
321: * Step 1: invalidate all cached meta-data.
322: */
323: devvp = VFSTOUFS(mountp)->um_devvp;
324: if (vinvalbuf(devvp, 0, cred, p, 0, 0))
325: panic("ffs_reload: dirty1");
326: /*
327: * Step 2: re-read superblock from disk.
328: */
329: #ifdef NeXT
330: VOP_DEVBLOCKSIZE(devvp,&size);
331: #else
332: if (VOP_IOCTL(devvp, DIOCGPART, (caddr_t)&dpart, FREAD, NOCRED, p) != 0)
333: size = DEV_BSIZE;
334: else
335: size = dpart.disklab->d_secsize;
336: #endif
337: if (error = bread(devvp, (ufs_daddr_t)(SBOFF/size), SBSIZE, NOCRED,&bp))
338: return (error);
339: newfs = (struct fs *)bp->b_data;
340: #if REV_ENDIAN_FS
341: if (rev_endian) {
342: byte_swap_sbin(newfs);
343: }
344: #endif /* REV_ENDIAN_FS */
345: if (newfs->fs_magic != FS_MAGIC || newfs->fs_bsize > MAXBSIZE ||
346: newfs->fs_bsize < sizeof(struct fs)) {
347: #if REV_ENDIAN_FS
348: if (rev_endian)
349: byte_swap_sbout(newfs);
350: #endif /* REV_ENDIAN_FS */
351:
352: brelse(bp);
353: return (EIO); /* XXX needs translation */
354: }
355: fs = VFSTOUFS(mountp)->um_fs;
356: /*
357: * Copy pointer fields back into superblock before copying in XXX
358: * new superblock. These should really be in the ufsmount. XXX
359: * Note that important parameters (eg fs_ncg) are unchanged.
360: */
361: bcopy(&fs->fs_csp[0], &newfs->fs_csp[0], sizeof(fs->fs_csp));
362: newfs->fs_maxcluster = fs->fs_maxcluster;
363: bcopy(newfs, fs, (u_int)fs->fs_sbsize);
364: if (fs->fs_sbsize < SBSIZE)
365: bp->b_flags |= B_INVAL;
366: #if REV_ENDIAN_FS
367: if (rev_endian)
368: byte_swap_sbout(newfs);
369: #endif /* REV_ENDIAN_FS */
370: brelse(bp);
371: mountp->mnt_maxsymlinklen = fs->fs_maxsymlinklen;
372: ffs_oldfscompat(fs);
373: /*
374: * Step 3: re-read summary information from disk.
375: */
376: blks = howmany(fs->fs_cssize, fs->fs_fsize);
377: space = fs->fs_csp[0];
378: for (i = 0; i < blks; i += fs->fs_frag) {
379: size = fs->fs_bsize;
380: if (i + fs->fs_frag > blks)
381: size = (blks - i) * fs->fs_fsize;
382: if (error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + i), size,
383: NOCRED, &bp))
384: return (error);
385: #if REV_ENDIAN_FS
386: if (rev_endian) {
387: /* csum swaps */
388: byte_swap_ints((int *)bp->b_data, size / sizeof(int));
389: }
390: #endif /* REV_ENDIAN_FS */
391: bcopy(bp->b_data, fs->fs_csp[fragstoblks(fs, i)], (u_int)size);
392: #if REV_ENDIAN_FS
393: if (rev_endian) {
394: /* csum swaps */
395: byte_swap_ints((int *)bp->b_data, size / sizeof(int));
396: }
397: #endif /* REV_ENDIAN_FS */
398: brelse(bp);
399: }
400: /*
401: * We no longer know anything about clusters per cylinder group.
402: */
403: if (fs->fs_contigsumsize > 0) {
404: lp = fs->fs_maxcluster;
405: for (i = 0; i < fs->fs_ncg; i++)
406: *lp++ = fs->fs_contigsumsize;
407: }
408:
409: loop:
410: simple_lock(&mntvnode_slock);
411: for (vp = mountp->mnt_vnodelist.lh_first; vp != NULL; vp = nvp) {
412: if (vp->v_mount != mountp) {
413: simple_unlock(&mntvnode_slock);
414: goto loop;
415: }
416: nvp = vp->v_mntvnodes.le_next;
417: /*
418: * Step 4: invalidate all inactive vnodes.
419: */
420: if (vrecycle(vp, &mntvnode_slock, p))
421: goto loop;
422: /*
423: * Step 5: invalidate all cached file data.
424: */
425: simple_lock(&vp->v_interlock);
426: simple_unlock(&mntvnode_slock);
427: if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, p)) {
428: goto loop;
429: }
430: if (vinvalbuf(vp, 0, cred, p, 0, 0))
431: panic("ffs_reload: dirty2");
432: /*
433: * Step 6: re-read inode data for all active vnodes.
434: */
435: ip = VTOI(vp);
436: if (error =
437: bread(devvp, fsbtodb(fs, ino_to_fsba(fs, ip->i_number)),
438: (int)fs->fs_bsize, NOCRED, &bp)) {
439: vput(vp);
440: return (error);
441: }
442: #if REV_ENDIAN_FS
443: if (rev_endian) {
444: byte_swap_inode_in(((struct dinode *)bp->b_data +
445: ino_to_fsbo(fs, ip->i_number)), ip);
446: } else {
447: #endif /* REV_ENDIAN_FS */
448: ip->i_din = *((struct dinode *)bp->b_data +
449: ino_to_fsbo(fs, ip->i_number));
450: #if REV_ENDIAN_FS
451: }
452: #endif /* REV_ENDIAN_FS */
453: brelse(bp);
454: vput(vp);
455: simple_lock(&mntvnode_slock);
456: }
457: simple_unlock(&mntvnode_slock);
458: return (0);
459: }
460:
461: /*
462: * Common code for mount and mountroot
463: */
464: int
465: ffs_mountfs(devvp, mp, p)
466: register struct vnode *devvp;
467: struct mount *mp;
468: struct proc *p;
469: {
470: register struct ufsmount *ump;
471: struct buf *bp;
472: register struct fs *fs;
473: dev_t dev;
474: #ifdef NeXT
475: struct buf *cgbp;
476: struct cg *cgp;
477: int32_t clustersumoff;
478: #else
479: struct partinfo dpart;
480: #endif /* NeXT */
481: caddr_t base, space;
482: int error, i, blks, size, ronly;
483: int32_t *lp;
484: struct ucred *cred;
485: extern struct vnode *rootvp;
486: u_int64_t maxfilesize; /* XXX */
487: #if REV_ENDIAN_FS
488: int rev_endian=0;
489: #endif /* REV_ENDIAN_FS */
490: dev = devvp->v_rdev;
491: cred = p ? p->p_ucred : NOCRED;
492: /*
493: * Disallow multiple mounts of the same device.
494: * Disallow mounting of a device that is currently in use
495: * (except for root, which might share swap device for miniroot).
496: * Flush out any old buffers remaining from a previous use.
497: */
498: if (error = vfs_mountedon(devvp))
499: return (error);
500: if (vcount(devvp) > 1 && devvp != rootvp)
501: return (EBUSY);
502: if (error = vinvalbuf(devvp, V_SAVE, cred, p, 0, 0))
503: return (error);
504:
505: ronly = (mp->mnt_flag & MNT_RDONLY) != 0;
506: if (error = VOP_OPEN(devvp, ronly ? FREAD : FREAD|FWRITE, FSCRED, p))
507: return (error);
508: #ifdef NeXT
509: VOP_DEVBLOCKSIZE(devvp,&size);
510: #else
511: if (VOP_IOCTL(devvp, DIOCGPART, (caddr_t)&dpart, FREAD, NOCRED, p) != 0)
512: size = DEV_BSIZE;
513: else
514: size = dpart.disklab->d_secsize;
515: #endif
516:
517: bp = NULL;
518: ump = NULL;
519: if (error = bread(devvp, (ufs_daddr_t)(SBOFF/size), SBSIZE, cred, &bp))
520: goto out;
521: fs = (struct fs *)bp->b_data;
522: #if REV_ENDIAN_FS
523: if (fs->fs_magic != FS_MAGIC || fs->fs_bsize > MAXBSIZE ||
524: fs->fs_bsize < sizeof(struct fs)) {
525: byte_swap_sbin(fs);
526: if (fs->fs_magic != FS_MAGIC || fs->fs_bsize > MAXBSIZE ||
527: fs->fs_bsize < sizeof(struct fs)) {
528: byte_swap_sbout(fs);
529: error = EINVAL; /* XXX needs translation */
530: goto out;
531: }
532: rev_endian=1;
533: }
534: #endif /* REV_ENDIAN_FS */
535: if (fs->fs_magic != FS_MAGIC || fs->fs_bsize > MAXBSIZE ||
536: fs->fs_bsize < sizeof(struct fs)) {
537: #if REV_ENDIAN_FS
538: if (rev_endian)
539: byte_swap_sbout(fs);
540: #endif /* REV_ENDIAN_FS */
541: error = EINVAL; /* XXX needs translation */
542: goto out;
543: }
544: /* XXX updating 4.2 FFS superblocks trashes rotational layout tables */
545: if (fs->fs_postblformat == FS_42POSTBLFMT && !ronly) {
546: #if REV_ENDIAN_FS
547: if (rev_endian)
548: byte_swap_sbout(fs);
549: #endif /* REV_ENDIAN_FS */
550: error = EROFS; /* needs translation */
551: goto out;
552: }
553:
554: #ifdef NeXT
555: /* If we are not mounting read only, then check for overlap
556: * condition in cylinder group's free block map.
557: * If overlap exists, then force this into a read only mount
558: * to avoid further corruption. PR#2216969
559: */
560: if (ronly == 0){
561: if (error = bread (devvp, fsbtodb(fs, cgtod(fs, 0)),
562: (int)fs->fs_cgsize, NOCRED, &cgbp)) {
563: brelse(cgbp);
564: goto out;
565: }
566: cgp = (struct cg *)cgbp->b_data;
567: #if REV_ENDIAN_FS
568: if (rev_endian)
569: byte_swap_cgin(cgp,fs);
570: #endif /* REV_ENDIAN_FS */
571: if (!cg_chkmagic(cgp)){
572: #if REV_ENDIAN_FS
573: if (rev_endian)
574: byte_swap_cgout(cgp,fs);
575: #endif /* REV_ENDIAN_FS */
576: brelse(cgbp);
577: goto out;
578: }
579: if (cgp->cg_clustersumoff != 0) {
580: /* Check for overlap */
581: clustersumoff = cgp->cg_freeoff +
582: howmany(fs->fs_cpg * fs->fs_spc / NSPF(fs), NBBY);
583: clustersumoff = roundup(clustersumoff, sizeof(long));
584: if (cgp->cg_clustersumoff < clustersumoff) {
585: /* Overlap exists */
586: mp->mnt_flag |= MNT_RDONLY;
587: ronly = 1;
588: }
589: }
590: #if REV_ENDIAN_FS
591: if (rev_endian)
592: byte_swap_cgout(cgp,fs);
593: #endif /* REV_ENDIAN_FS */
594: brelse(cgbp);
595: }
596: #endif /* NeXT */
597:
598: ump = _MALLOC(sizeof *ump, M_UFSMNT, M_WAITOK);
599: bzero((caddr_t)ump, sizeof *ump);
600: ump->um_fs = _MALLOC((u_long)fs->fs_sbsize, M_UFSMNT,
601: M_WAITOK);
602: bcopy(bp->b_data, ump->um_fs, (u_int)fs->fs_sbsize);
603: if (fs->fs_sbsize < SBSIZE)
604: bp->b_flags |= B_INVAL;
605: #if REV_ENDIAN_FS
606: if (rev_endian)
607: byte_swap_sbout(fs);
608: #endif /* REV_ENDIAN_FS */
609: brelse(bp);
610: bp = NULL;
611: fs = ump->um_fs;
612: fs->fs_ronly = ronly;
613: size = fs->fs_cssize;
614: blks = howmany(size, fs->fs_fsize);
615: if (fs->fs_contigsumsize > 0)
616: size += fs->fs_ncg * sizeof(int32_t);
617: base = space = _MALLOC((u_long)size, M_UFSMNT, M_WAITOK);
618: base = space;
619: for (i = 0; i < blks; i += fs->fs_frag) {
620: size = fs->fs_bsize;
621: if (i + fs->fs_frag > blks)
622: size = (blks - i) * fs->fs_fsize;
623: if (error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + i), size,
624: cred, &bp)) {
625: _FREE(base, M_UFSMNT);
626: goto out;
627: }
628: bcopy(bp->b_data, space, (u_int)size);
629: #if REV_ENDIAN_FS
630: if (rev_endian)
631: byte_swap_ints((int *) space, size / sizeof(int));
632: #endif /* REV_ENDIAN_FS */
633: fs->fs_csp[fragstoblks(fs, i)] = (struct csum *)space;
634: space += size;
635: brelse(bp);
636: bp = NULL;
637: }
638: if (fs->fs_contigsumsize > 0) {
639: fs->fs_maxcluster = lp = (int32_t *)space;
640: for (i = 0; i < fs->fs_ncg; i++)
641: *lp++ = fs->fs_contigsumsize;
642: }
643: mp->mnt_data = (qaddr_t)ump;
644: mp->mnt_stat.f_fsid.val[0] = (long)dev;
645: mp->mnt_stat.f_fsid.val[1] = mp->mnt_vfc->vfc_typenum;
646: #ifdef NeXT
647: #warning hardcoded max symlen
648: mp->mnt_maxsymlinklen = 60;
649: #else
650: mp->mnt_maxsymlinklen = fs->fs_maxsymlinklen;
651: #endif
652: #if REV_ENDIAN_FS
653: if (rev_endian)
654: mp->mnt_flag |= MNT_REVEND;
655: #endif /* REV_ENDIAN_FS */
656: ump->um_mountp = mp;
657: ump->um_dev = dev;
658: ump->um_devvp = devvp;
659: ump->um_nindir = fs->fs_nindir;
660: ump->um_bptrtodb = fs->fs_fsbtodb;
661: ump->um_seqinc = fs->fs_frag;
662: for (i = 0; i < MAXQUOTAS; i++)
663: ump->um_quotas[i] = NULLVP;
664: devvp->v_specflags |= SI_MOUNTEDON;
665: ffs_oldfscompat(fs);
666: ump->um_savedmaxfilesize = fs->fs_maxfilesize; /* XXX */
667: #ifdef NeXT
668: maxfilesize = (u_int64_t)0x100000000; /*4giga */
669: #else
670: maxfilesize = (u_int64_t)0x40000000 * fs->fs_bsize - 1; /* XXX */
671: #endif /* NeXT */
672: if (fs->fs_maxfilesize > maxfilesize) /* XXX */
673: fs->fs_maxfilesize = maxfilesize; /* XXX */
674: if (ronly == 0) {
675: fs->fs_clean = 0;
676: (void) ffs_sbupdate(ump, MNT_WAIT);
677: }
678: return (0);
679: out:
680: if (bp)
681: brelse(bp);
682: (void)VOP_CLOSE(devvp, ronly ? FREAD : FREAD|FWRITE, cred, p);
683: if (ump) {
684: _FREE(ump->um_fs, M_UFSMNT);
685: _FREE(ump, M_UFSMNT);
686: mp->mnt_data = (qaddr_t)0;
687: }
688: return (error);
689: }
690:
691: /*
692: * Sanity checks for old file systems.
693: *
694: * XXX - goes away some day.
695: */
696: ffs_oldfscompat(fs)
697: struct fs *fs;
698: {
699: int i;
700:
701: fs->fs_npsect = max(fs->fs_npsect, fs->fs_nsect); /* XXX */
702: fs->fs_interleave = max(fs->fs_interleave, 1); /* XXX */
703: if (fs->fs_postblformat == FS_42POSTBLFMT) /* XXX */
704: fs->fs_nrpos = 8; /* XXX */
705: if (fs->fs_inodefmt < FS_44INODEFMT) { /* XXX */
706: u_int64_t sizepb = fs->fs_bsize; /* XXX */
707: /* XXX */
708: fs->fs_maxfilesize = fs->fs_bsize * NDADDR - 1; /* XXX */
709: for (i = 0; i < NIADDR; i++) { /* XXX */
710: sizepb *= NINDIR(fs); /* XXX */
711: fs->fs_maxfilesize += sizepb; /* XXX */
712: } /* XXX */
713: fs->fs_qbmask = ~fs->fs_bmask; /* XXX */
714: fs->fs_qfmask = ~fs->fs_fmask; /* XXX */
715: } /* XXX */
716: return (0);
717: }
718:
719: /*
720: * unmount system call
721: */
722: int
723: ffs_unmount(mp, mntflags, p)
724: struct mount *mp;
725: int mntflags;
726: struct proc *p;
727: {
728: register struct ufsmount *ump;
729: register struct fs *fs;
730: int error, flags;
731: flags = 0;
732: if (mntflags & MNT_FORCE)
733: flags |= FORCECLOSE;
734: if (error = ffs_flushfiles(mp, flags, p))
735: return (error);
736: ump = VFSTOUFS(mp);
737: fs = ump->um_fs;
738: if (fs->fs_ronly == 0) {
739: fs->fs_clean = 1;
740: if (error = ffs_sbupdate(ump, MNT_WAIT)) {
741: fs->fs_clean = 0;
742: #ifndef NeXT
743: /* we can atleast cleanup ; as the media could be WP */
744: /* & during mount, we do not check for write failures */
745: /* FIXME LATER : the Correct fix would be to have */
746: /* mount detect the WP media and downgrade to readonly mount */
747: /* For now, here it is */
748: return (error);
749: #endif
750: }
751: }
752: ump->um_devvp->v_specflags &= ~SI_MOUNTEDON;
753: error = VOP_CLOSE(ump->um_devvp, fs->fs_ronly ? FREAD : FREAD|FWRITE,
754: NOCRED, p);
755: vrele(ump->um_devvp);
756:
757: _FREE(fs->fs_csp[0], M_UFSMNT);
758: _FREE(fs, M_UFSMNT);
759: _FREE(ump, M_UFSMNT);
760: mp->mnt_data = (qaddr_t)0;
761: #if REV_ENDIAN_FS
762: mp->mnt_flag &= ~MNT_REVEND;
763: #endif /* REV_ENDIAN_FS */
764: return (error);
765: }
766:
767: /*
768: * Flush out all the files in a filesystem.
769: */
770: ffs_flushfiles(mp, flags, p)
771: register struct mount *mp;
772: int flags;
773: struct proc *p;
774: {
775: register struct ufsmount *ump;
776: int i, error;
777:
778: ump = VFSTOUFS(mp);
779: #if QUOTA
780: if (mp->mnt_flag & MNT_QUOTA) {
781: if (error = vflush(mp, NULLVP, SKIPSYSTEM|flags))
782: return (error);
783: for (i = 0; i < MAXQUOTAS; i++) {
784: if (ump->um_quotas[i] == NULLVP)
785: continue;
786: quotaoff(p, mp, i);
787: }
788: /*
789: * Here we fall through to vflush again to ensure
790: * that we have gotten rid of all the system vnodes.
791: */
792: }
793: #endif
794: error = vflush(mp, NULLVP, flags);
795: return (error);
796: }
797:
798: /*
799: * Get file system statistics.
800: */
801: int
802: ffs_statfs(mp, sbp, p)
803: struct mount *mp;
804: register struct statfs *sbp;
805: struct proc *p;
806: {
807: register struct ufsmount *ump;
808: register struct fs *fs;
809:
810: ump = VFSTOUFS(mp);
811: fs = ump->um_fs;
812: if (fs->fs_magic != FS_MAGIC)
813: panic("ffs_statfs");
814: sbp->f_bsize = fs->fs_fsize;
815: sbp->f_iosize = fs->fs_bsize;
816: sbp->f_blocks = fs->fs_dsize;
817: sbp->f_bfree = fs->fs_cstotal.cs_nbfree * fs->fs_frag +
818: fs->fs_cstotal.cs_nffree;
819: sbp->f_bavail = freespace(fs, fs->fs_minfree);
820: sbp->f_files = fs->fs_ncg * fs->fs_ipg - ROOTINO;
821: sbp->f_ffree = fs->fs_cstotal.cs_nifree;
822: if (sbp != &mp->mnt_stat) {
823: sbp->f_type = mp->mnt_vfc->vfc_typenum;
824: bcopy((caddr_t)mp->mnt_stat.f_mntonname,
825: (caddr_t)&sbp->f_mntonname[0], MNAMELEN);
826: bcopy((caddr_t)mp->mnt_stat.f_mntfromname,
827: (caddr_t)&sbp->f_mntfromname[0], MNAMELEN);
828: }
829: return (0);
830: }
831:
832: /*
833: * Go through the disk queues to initiate sandbagged IO;
834: * go through the inodes to write those that have been modified;
835: * initiate the writing of the super block if it has been modified.
836: *
837: * Note: we are always called with the filesystem marked `MPBUSY'.
838: */
839: int
840: ffs_sync(mp, waitfor, cred, p)
841: struct mount *mp;
842: int waitfor;
843: struct ucred *cred;
844: struct proc *p;
845: {
846: struct vnode *nvp, *vp;
847: struct inode *ip;
848: struct ufsmount *ump = VFSTOUFS(mp);
849: struct fs *fs;
850: int error, allerror = 0;
851:
852: fs = ump->um_fs;
853: if (fs->fs_fmod != 0 && fs->fs_ronly != 0) { /* XXX */
854: printf("fs = %s\n", fs->fs_fsmnt);
855: panic("update: rofs mod");
856: }
857: /*
858: * Write back each (modified) inode.
859: */
860: simple_lock(&mntvnode_slock);
861: loop:
862: for (vp = mp->mnt_vnodelist.lh_first;
863: vp != NULL;
864: vp = nvp) {
865: /*
866: * If the vnode that we are about to sync is no longer
867: * associated with this mount point, start over.
868: */
869: if (vp->v_mount != mp)
870: goto loop;
871: simple_lock(&vp->v_interlock);
872: nvp = vp->v_mntvnodes.le_next;
873: ip = VTOI(vp);
874: if ((ip->i_flag &
875: (IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE)) == 0 &&
876: vp->v_dirtyblkhd.lh_first == NULL) {
877: simple_unlock(&vp->v_interlock);
878: continue;
879: }
880: simple_unlock(&mntvnode_slock);
881: error = vget(vp, LK_EXCLUSIVE | LK_NOWAIT | LK_INTERLOCK, p);
882: if (error) {
883: simple_lock(&mntvnode_slock);
884: if (error == ENOENT)
885: goto loop;
886: continue;
887: }
888: if (error = VOP_FSYNC(vp, cred, waitfor, p))
889: allerror = error;
890: VOP_UNLOCK(vp, 0, p);
891: vrele(vp);
892: simple_lock(&mntvnode_slock);
893: }
894: simple_unlock(&mntvnode_slock);
895: /*
896: * Force stale file system control information to be flushed.
897: */
898: if (error = VOP_FSYNC(ump->um_devvp, cred, waitfor, p))
899: allerror = error;
900: #if QUOTA
901: qsync(mp);
902: #endif
903: /*
904: * Write back modified superblock.
905: */
906: if (fs->fs_fmod != 0) {
907: fs->fs_fmod = 0;
908: fs->fs_time = time.tv_sec;
909: if (error = ffs_sbupdate(ump, waitfor))
910: allerror = error;
911: }
912: return (allerror);
913: }
914:
915: /*
916: * Look up a FFS dinode number to find its incore vnode, otherwise read it
917: * in from disk. If it is in core, wait for the lock bit to clear, then
918: * return the inode locked. Detection and handling of mount points must be
919: * done by the calling routine.
920: */
921: int
922: ffs_vget(mp, ino, vpp)
923: struct mount *mp;
924: ino_t ino;
925: struct vnode **vpp;
926: {
927: struct proc *p = current_proc(); /* XXX */
928: struct fs *fs;
929: struct inode *ip;
930: struct ufsmount *ump;
931: struct buf *bp;
932: struct vnode *vp;
933: dev_t dev;
934: int i, type, error;
935:
936: ump = VFSTOUFS(mp);
937: dev = ump->um_dev;
938: if ((*vpp = ufs_ihashget(dev, ino)) != NULL) {
939: #if MACH_NBC
940: vp = *vpp;
941: if ((vp->v_type == VREG) && !(vp->v_vm_info)){
942: vm_info_init(vp);
943: }
944: #endif /* MACH_NBC */
945: return (0);
946: }
947: /* Allocate a new vnode/inode. */
948: if (error = getnewvnode(VT_UFS, mp, ffs_vnodeop_p, &vp)) {
949: *vpp = NULL;
950: return (error);
951: }
952: type = ump->um_devvp->v_tag == VT_MFS ? M_MFSNODE : M_FFSNODE; /* XXX */
953: MALLOC_ZONE(ip, struct inode *, sizeof(struct inode), type, M_WAITOK);
954: bzero((caddr_t)ip, sizeof(struct inode));
955: lockinit(&ip->i_lock, PINOD, "inode", 0, 0);
956: vp->v_data = ip;
957: ip->i_vnode = vp;
958: ip->i_fs = fs = ump->um_fs;
959: ip->i_dev = dev;
960: ip->i_number = ino;
961: #if QUOTA
962: for (i = 0; i < MAXQUOTAS; i++)
963: ip->i_dquot[i] = NODQUOT;
964: #endif
965: /*
966: * Put it onto its hash chain and lock it so that other requests for
967: * this inode will block if they arrive while we are sleeping waiting
968: * for old data structures to be purged or for the contents of the
969: * disk portion of this inode to be read.
970: */
971: ufs_ihashins(ip);
972:
973: /* Read in the disk contents for the inode, copy into the inode. */
974: if (error = bread(ump->um_devvp, fsbtodb(fs, ino_to_fsba(fs, ino)),
975: (int)fs->fs_bsize, NOCRED, &bp)) {
976: /*
977: * The inode does not contain anything useful, so it would
978: * be misleading to leave it on its hash chain. With mode
979: * still zero, it will be unlinked and returned to the free
980: * list by vput().
981: */
982: vput(vp);
983: brelse(bp);
984: *vpp = NULL;
985: return (error);
986: }
987: #if REV_ENDIAN_FS
988: if (mp->mnt_flag & MNT_REVEND) {
989: byte_swap_inode_in(((struct dinode *)bp->b_data + ino_to_fsbo(fs, ino)),ip);
990: } else {
991: #endif /* REV_ENDIAN_FS */
992: ip->i_din = *((struct dinode *)bp->b_data + ino_to_fsbo(fs, ino));
993: #if REV_ENDIAN_FS
994: }
995: #endif /* REV_ENDIAN_FS */
996: brelse(bp);
997:
998: /*
999: * Initialize the vnode from the inode, check for aliases.
1000: * Note that the underlying vnode may have changed.
1001: */
1002: if (error = ufs_vinit(mp, ffs_specop_p, FFS_FIFOOPS, &vp)) {
1003: vput(vp);
1004: *vpp = NULL;
1005: return (error);
1006: }
1007: /*
1008: * Finish inode initialization now that aliasing has been resolved.
1009: */
1010: ip->i_devvp = ump->um_devvp;
1011: VREF(ip->i_devvp);
1012: /*
1013: * Set up a generation number for this inode if it does not
1014: * already have one. This should only happen on old filesystems.
1015: */
1016: if (ip->i_gen == 0) {
1017: if (++nextgennumber < (u_long)time.tv_sec)
1018: nextgennumber = time.tv_sec;
1019: ip->i_gen = nextgennumber;
1020: if ((vp->v_mount->mnt_flag & MNT_RDONLY) == 0)
1021: ip->i_flag |= IN_MODIFIED;
1022: }
1023: /*
1024: * Ensure that uid and gid are correct. This is a temporary
1025: * fix until fsck has been changed to do the update.
1026: */
1027: if (fs->fs_inodefmt < FS_44INODEFMT) { /* XXX */
1028: ip->i_uid = ip->i_din.di_ouid; /* XXX */
1029: ip->i_gid = ip->i_din.di_ogid; /* XXX */
1030: } /* XXX */
1031:
1032: *vpp = vp;
1033: #if MACH_NBC
1034: if ((vp->v_type == VREG) && !(vp->v_vm_info)){
1035: vm_info_init(vp);
1036: }
1037: #endif /* MACH_NBC */
1038: return (0);
1039: }
1040:
1041: /*
1042: * File handle to vnode
1043: *
1044: * Have to be really careful about stale file handles:
1045: * - check that the inode number is valid
1046: * - call ffs_vget() to get the locked inode
1047: * - check for an unallocated inode (i_mode == 0)
1048: * - check that the given client host has export rights and return
1049: * those rights via. exflagsp and credanonp
1050: */
1051: int
1052: ffs_fhtovp(mp, fhp, nam, vpp, exflagsp, credanonp)
1053: register struct mount *mp;
1054: struct fid *fhp;
1055: struct mbuf *nam;
1056: struct vnode **vpp;
1057: int *exflagsp;
1058: struct ucred **credanonp;
1059: {
1060: register struct ufid *ufhp;
1061: struct fs *fs;
1062:
1063: ufhp = (struct ufid *)fhp;
1064: fs = VFSTOUFS(mp)->um_fs;
1065: if (ufhp->ufid_ino < ROOTINO ||
1066: ufhp->ufid_ino >= fs->fs_ncg * fs->fs_ipg)
1067: return (ESTALE);
1068: return (ufs_check_export(mp, ufhp, nam, vpp, exflagsp, credanonp));
1069: }
1070:
1071: /*
1072: * Vnode pointer to File handle
1073: */
1074: /* ARGSUSED */
1075: ffs_vptofh(vp, fhp)
1076: struct vnode *vp;
1077: struct fid *fhp;
1078: {
1079: register struct inode *ip;
1080: register struct ufid *ufhp;
1081:
1082: ip = VTOI(vp);
1083: ufhp = (struct ufid *)fhp;
1084: ufhp->ufid_len = sizeof(struct ufid);
1085: ufhp->ufid_ino = ip->i_number;
1086: ufhp->ufid_gen = ip->i_gen;
1087: return (0);
1088: }
1089:
1090: /*
1091: * Initialize the filesystem; just use ufs_init.
1092: */
1093: int
1094: ffs_init(vfsp)
1095: struct vfsconf *vfsp;
1096: {
1097:
1098: return (ufs_init(vfsp));
1099: }
1100:
1101: /*
1102: * fast filesystem related variables.
1103: */
1104: ffs_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p)
1105: int *name;
1106: u_int namelen;
1107: void *oldp;
1108: size_t *oldlenp;
1109: void *newp;
1110: size_t newlen;
1111: struct proc *p;
1112: {
1113: extern int doclusterread, doclusterwrite, doreallocblks, doasyncfree;
1114:
1115: /* all sysctl names at this level are terminal */
1116: if (namelen != 1)
1117: return (ENOTDIR); /* overloaded */
1118:
1119: switch (name[0]) {
1120: case FFS_CLUSTERREAD:
1121: return (sysctl_int(oldp, oldlenp, newp, newlen,
1122: &doclusterread));
1123: case FFS_CLUSTERWRITE:
1124: return (sysctl_int(oldp, oldlenp, newp, newlen,
1125: &doclusterwrite));
1126: case FFS_REALLOCBLKS:
1127: return (sysctl_int(oldp, oldlenp, newp, newlen,
1128: &doreallocblks));
1129: case FFS_ASYNCFREE:
1130: return (sysctl_int(oldp, oldlenp, newp, newlen, &doasyncfree));
1131: default:
1132: return (EOPNOTSUPP);
1133: }
1134: /* NOTREACHED */
1135: }
1136:
1137: /*
1138: * Write a superblock and associated information back to disk.
1139: */
1140: int
1141: ffs_sbupdate(mp, waitfor)
1142: struct ufsmount *mp;
1143: int waitfor;
1144: {
1145: register struct fs *dfs, *fs = mp->um_fs;
1146: register struct buf *bp;
1147: int blks;
1148: caddr_t space;
1149: int i, size, error, allerror = 0;
1150: #ifdef NeXT
1151: int devBlockSize=0;
1152: #endif /* NeXT */
1153: #if REV_ENDIAN_FS
1154: int rev_endian=(mp->um_mountp->mnt_flag & MNT_REVEND);
1155: #endif /* REV_ENDIAN_FS */
1156:
1157: /*
1158: * First write back the summary information.
1159: */
1160: blks = howmany(fs->fs_cssize, fs->fs_fsize);
1161: space = (caddr_t)fs->fs_csp[0];
1162: for (i = 0; i < blks; i += fs->fs_frag) {
1163: size = fs->fs_bsize;
1164: if (i + fs->fs_frag > blks)
1165: size = (blks - i) * fs->fs_fsize;
1166: bp = getblk(mp->um_devvp, fsbtodb(fs, fs->fs_csaddr + i),
1167: size, 0, 0);
1168: bcopy(space, bp->b_data, (u_int)size);
1169: #if REV_ENDIAN_FS
1170: if (rev_endian) {
1171: byte_swap_ints((int *)bp->b_data, size / sizeof(int));
1172: }
1173: #endif /* REV_ENDIAN_FS */
1174: space += size;
1175: if (waitfor != MNT_WAIT)
1176: bawrite(bp);
1177: else if (error = bwrite(bp))
1178: allerror = error;
1179: }
1180: /*
1181: * Now write back the superblock itself. If any errors occurred
1182: * up to this point, then fail so that the superblock avoids
1183: * being written out as clean.
1184: */
1185: if (allerror)
1186: return (allerror);
1187: #ifdef NeXT
1188: VOP_DEVBLOCKSIZE(mp->um_devvp,&devBlockSize);
1189: bp = getblk(mp->um_devvp, (SBOFF/devBlockSize), (int)fs->fs_sbsize, 0, 0);
1190: #else
1191: bp = getblk(mp->um_devvp, SBLOCK, (int)fs->fs_sbsize, 0, 0);
1192: #endif
1193: bcopy((caddr_t)fs, bp->b_data, (u_int)fs->fs_sbsize);
1194: /* Restore compatibility to old file systems. XXX */
1195: dfs = (struct fs *)bp->b_data; /* XXX */
1196: if (fs->fs_postblformat == FS_42POSTBLFMT) /* XXX */
1197: dfs->fs_nrpos = -1; /* XXX */
1198: #if REV_ENDIAN_FS
1199: /*
1200: * Swapping bytes here ; so that in case
1201: * of inode format < FS_44INODEFMT appropriate
1202: * fields get moved
1203: */
1204: if (rev_endian) {
1205: byte_swap_sbout((struct fs *)bp->b_data);
1206: }
1207: #endif /* REV_ENDIAN_FS */
1208: if (fs->fs_inodefmt < FS_44INODEFMT) { /* XXX */
1209: int32_t *lp, tmp; /* XXX */
1210: /* XXX */
1211: lp = (int32_t *)&dfs->fs_qbmask; /* XXX */
1212: tmp = lp[4]; /* XXX */
1213: for (i = 4; i > 0; i--) /* XXX */
1214: lp[i] = lp[i-1]; /* XXX */
1215: lp[0] = tmp; /* XXX */
1216: } /* XXX */
1217: #if REV_ENDIAN_FS
1218: /* Note that dfs is already swapped so swap the filesize
1219: * before writing
1220: */
1221: if (rev_endian) {
1222: dfs->fs_maxfilesize = NXSwapLongLong(mp->um_savedmaxfilesize); /* XXX */
1223: } else {
1224: #endif /* REV_ENDIAN_FS */
1225: dfs->fs_maxfilesize = mp->um_savedmaxfilesize; /* XXX */
1226: #if REV_ENDIAN_FS
1227: }
1228: #endif /* REV_ENDIAN_FS */
1229: if (waitfor != MNT_WAIT)
1230: bawrite(bp);
1231: else if (error = bwrite(bp))
1232: allerror = error;
1233:
1234: return (allerror);
1235: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.