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