Home | History | Annotate | Line # | Download | only in ffs
ffs_vfsops.c revision 1.118.2.13
      1 /*	$NetBSD: ffs_vfsops.c,v 1.118.2.13 2005/04/01 14:32:11 skrll Exp $	*/
      2 
      3 /*
      4  * Copyright (c) 1989, 1991, 1993, 1994
      5  *	The Regents of the University of California.  All rights reserved.
      6  *
      7  * Redistribution and use in source and binary forms, with or without
      8  * modification, are permitted provided that the following conditions
      9  * are met:
     10  * 1. Redistributions of source code must retain the above copyright
     11  *    notice, this list of conditions and the following disclaimer.
     12  * 2. Redistributions in binary form must reproduce the above copyright
     13  *    notice, this list of conditions and the following disclaimer in the
     14  *    documentation and/or other materials provided with the distribution.
     15  * 3. Neither the name of the University nor the names of its contributors
     16  *    may be used to endorse or promote products derived from this software
     17  *    without specific prior written permission.
     18  *
     19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     29  * SUCH DAMAGE.
     30  *
     31  *	@(#)ffs_vfsops.c	8.31 (Berkeley) 5/20/95
     32  */
     33 
     34 #include <sys/cdefs.h>
     35 __KERNEL_RCSID(0, "$NetBSD: ffs_vfsops.c,v 1.118.2.13 2005/04/01 14:32:11 skrll Exp $");
     36 
     37 #if defined(_KERNEL_OPT)
     38 #include "opt_ffs.h"
     39 #include "opt_quota.h"
     40 #include "opt_softdep.h"
     41 #endif
     42 
     43 #include <sys/param.h>
     44 #include <sys/systm.h>
     45 #include <sys/namei.h>
     46 #include <sys/proc.h>
     47 #include <sys/kernel.h>
     48 #include <sys/vnode.h>
     49 #include <sys/socket.h>
     50 #include <sys/mount.h>
     51 #include <sys/buf.h>
     52 #include <sys/device.h>
     53 #include <sys/mbuf.h>
     54 #include <sys/file.h>
     55 #include <sys/disklabel.h>
     56 #include <sys/ioctl.h>
     57 #include <sys/errno.h>
     58 #include <sys/malloc.h>
     59 #include <sys/pool.h>
     60 #include <sys/lock.h>
     61 #include <sys/sysctl.h>
     62 #include <sys/conf.h>
     63 
     64 #include <miscfs/specfs/specdev.h>
     65 
     66 #include <ufs/ufs/quota.h>
     67 #include <ufs/ufs/ufsmount.h>
     68 #include <ufs/ufs/inode.h>
     69 #include <ufs/ufs/dir.h>
     70 #include <ufs/ufs/ufs_extern.h>
     71 #include <ufs/ufs/ufs_bswap.h>
     72 
     73 #include <ufs/ffs/fs.h>
     74 #include <ufs/ffs/ffs_extern.h>
     75 
     76 /* how many times ffs_init() was called */
     77 int ffs_initcount = 0;
     78 
     79 extern struct lock ufs_hashlock;
     80 
     81 extern const struct vnodeopv_desc ffs_vnodeop_opv_desc;
     82 extern const struct vnodeopv_desc ffs_specop_opv_desc;
     83 extern const struct vnodeopv_desc ffs_fifoop_opv_desc;
     84 
     85 const struct vnodeopv_desc * const ffs_vnodeopv_descs[] = {
     86 	&ffs_vnodeop_opv_desc,
     87 	&ffs_specop_opv_desc,
     88 	&ffs_fifoop_opv_desc,
     89 	NULL,
     90 };
     91 
     92 struct vfsops ffs_vfsops = {
     93 	MOUNT_FFS,
     94 	ffs_mount,
     95 	ufs_start,
     96 	ffs_unmount,
     97 	ufs_root,
     98 	ufs_quotactl,
     99 	ffs_statvfs,
    100 	ffs_sync,
    101 	ffs_vget,
    102 	ffs_fhtovp,
    103 	ffs_vptofh,
    104 	ffs_init,
    105 	ffs_reinit,
    106 	ffs_done,
    107 	NULL,
    108 	ffs_mountroot,
    109 	ufs_check_export,
    110 	ffs_snapshot,
    111 	vfs_stdextattrctl,
    112 	ffs_vnodeopv_descs,
    113 };
    114 VFS_ATTACH(ffs_vfsops);
    115 
    116 struct genfs_ops ffs_genfsops = {
    117 	ffs_gop_size,
    118 	ufs_gop_alloc,
    119 	genfs_gop_write,
    120 };
    121 
    122 POOL_INIT(ffs_inode_pool, sizeof(struct inode), 0, 0, 0, "ffsinopl",
    123     &pool_allocator_nointr);
    124 POOL_INIT(ffs_dinode1_pool, sizeof(struct ufs1_dinode), 0, 0, 0, "dino1pl",
    125     &pool_allocator_nointr);
    126 POOL_INIT(ffs_dinode2_pool, sizeof(struct ufs2_dinode), 0, 0, 0, "dino2pl",
    127     &pool_allocator_nointr);
    128 
    129 static void ffs_oldfscompat_read(struct fs *, struct ufsmount *, daddr_t);
    130 static void ffs_oldfscompat_write(struct fs *, struct ufsmount *);
    131 
    132 /*
    133  * Called by main() when ffs is going to be mounted as root.
    134  */
    135 
    136 int
    137 ffs_mountroot()
    138 {
    139 	struct fs *fs;
    140 	struct mount *mp;
    141 	struct lwp *l = curlwp;			/* XXX */
    142 	struct ufsmount *ump;
    143 	int error;
    144 
    145 	if (root_device->dv_class != DV_DISK)
    146 		return (ENODEV);
    147 
    148 	if ((error = vfs_rootmountalloc(MOUNT_FFS, "root_device", &mp))) {
    149 		vrele(rootvp);
    150 		return (error);
    151 	}
    152 	if ((error = ffs_mountfs(rootvp, mp, l)) != 0) {
    153 		mp->mnt_op->vfs_refcount--;
    154 		vfs_unbusy(mp);
    155 		free(mp, M_MOUNT);
    156 		return (error);
    157 	}
    158 	simple_lock(&mountlist_slock);
    159 	CIRCLEQ_INSERT_TAIL(&mountlist, mp, mnt_list);
    160 	simple_unlock(&mountlist_slock);
    161 	ump = VFSTOUFS(mp);
    162 	fs = ump->um_fs;
    163 	memset(fs->fs_fsmnt, 0, sizeof(fs->fs_fsmnt));
    164 	(void)copystr(mp->mnt_stat.f_mntonname, fs->fs_fsmnt, MNAMELEN - 1, 0);
    165 	(void)ffs_statvfs(mp, &mp->mnt_stat, l);
    166 	vfs_unbusy(mp);
    167 	setrootfstime((time_t)fs->fs_time);
    168 	return (0);
    169 }
    170 
    171 /*
    172  * VFS Operations.
    173  *
    174  * mount system call
    175  */
    176 int
    177 ffs_mount(mp, path, data, ndp, l)
    178 	struct mount *mp;
    179 	const char *path;
    180 	void *data;
    181 	struct nameidata *ndp;
    182 	struct lwp *l;
    183 {
    184 	struct vnode *devvp = NULL;
    185 	struct ufs_args args;
    186 	struct ufsmount *ump = NULL;
    187 	struct proc *p;
    188 	struct fs *fs;
    189 	int error, flags, update;
    190 	mode_t accessmode;
    191 
    192 	p = l->l_proc;
    193 	if (mp->mnt_flag & MNT_GETARGS) {
    194 		ump = VFSTOUFS(mp);
    195 		if (ump == NULL)
    196 			return EIO;
    197 		args.fspec = NULL;
    198 		vfs_showexport(mp, &args.export, &ump->um_export);
    199 		return copyout(&args, data, sizeof(args));
    200 	}
    201 	error = copyin(data, &args, sizeof (struct ufs_args));
    202 	if (error)
    203 		return (error);
    204 
    205 #if !defined(SOFTDEP)
    206 	mp->mnt_flag &= ~MNT_SOFTDEP;
    207 #endif
    208 
    209 	update = mp->mnt_flag & MNT_UPDATE;
    210 
    211 	/* Check arguments */
    212 	if (args.fspec != NULL) {
    213 		/*
    214 		 * Look up the name and verify that it's sane.
    215 		 */
    216 		NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, args.fspec, l);
    217 		if ((error = namei(ndp)) != 0)
    218 			return (error);
    219 		devvp = ndp->ni_vp;
    220 
    221 		if (!update) {
    222 			/*
    223 			 * Be sure this is a valid block device
    224 			 */
    225 			if (devvp->v_type != VBLK)
    226 				error = ENOTBLK;
    227 			else if (bdevsw_lookup(devvp->v_rdev) == NULL)
    228 				error = ENXIO;
    229 		} else {
    230 			/*
    231 			 * Be sure we're still naming the same device
    232 			 * used for our initial mount
    233 			 */
    234 			ump = VFSTOUFS(mp);
    235 			if (devvp != ump->um_devvp)
    236 				error = EINVAL;
    237 		}
    238 	} else {
    239 		if (!update) {
    240 			/* New mounts must have a filename for the device */
    241 			return (EINVAL);
    242 		} else {
    243 			/* Use the extant mount */
    244 			ump = VFSTOUFS(mp);
    245 			devvp = ump->um_devvp;
    246 			vref(devvp);
    247 		}
    248 	}
    249 
    250 	/*
    251 	 * If mount by non-root, then verify that user has necessary
    252 	 * permissions on the device.
    253 	 */
    254 	if (error == 0 && p->p_ucred->cr_uid != 0) {
    255 		accessmode = VREAD;
    256 		if (update ?
    257 		    (mp->mnt_iflag & IMNT_WANTRDWR) != 0 :
    258 		    (mp->mnt_flag & MNT_RDONLY) == 0)
    259 			accessmode |= VWRITE;
    260 		vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
    261 		error = VOP_ACCESS(devvp, accessmode, p->p_ucred, l);
    262 		VOP_UNLOCK(devvp, 0);
    263 	}
    264 
    265 	if (error) {
    266 		vrele(devvp);
    267 		return (error);
    268 	}
    269 
    270 	if (!update) {
    271 		int flags;
    272 
    273 		/*
    274 		 * Disallow multiple mounts of the same device.
    275 		 * Disallow mounting of a device that is currently in use
    276 		 * (except for root, which might share swap device for
    277 		 * miniroot).
    278 		 */
    279 		error = vfs_mountedon(devvp);
    280 		if (error)
    281 			goto fail;
    282 		if (vcount(devvp) > 1 && devvp != rootvp) {
    283 			error = EBUSY;
    284 			goto fail;
    285 		}
    286 		if (mp->mnt_flag & MNT_RDONLY)
    287 			flags = FREAD;
    288 		else
    289 			flags = FREAD|FWRITE;
    290 		error = VOP_OPEN(devvp, flags, FSCRED, l);
    291 		if (error)
    292 			goto fail;
    293 		error = ffs_mountfs(devvp, mp, l);
    294 		if (error) {
    295 			vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
    296 			(void)VOP_CLOSE(devvp, flags, NOCRED, l);
    297 			VOP_UNLOCK(devvp, 0);
    298 			goto fail;
    299 		}
    300 
    301 		ump = VFSTOUFS(mp);
    302 		fs = ump->um_fs;
    303 		if ((mp->mnt_flag & (MNT_SOFTDEP | MNT_ASYNC)) ==
    304 		    (MNT_SOFTDEP | MNT_ASYNC)) {
    305 			printf("%s fs uses soft updates, "
    306 			    "ignoring async mode\n",
    307 			    fs->fs_fsmnt);
    308 			mp->mnt_flag &= ~MNT_ASYNC;
    309 		}
    310 	} else {
    311 		/*
    312 		 * Update the mount.
    313 		 */
    314 
    315 		/*
    316 		 * The initial mount got a reference on this
    317 		 * device, so drop the one obtained via
    318 		 * namei(), above.
    319 		 */
    320 		vrele(devvp);
    321 
    322 		ump = VFSTOUFS(mp);
    323 		fs = ump->um_fs;
    324 		if (fs->fs_ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) {
    325 			/*
    326 			 * Changing from r/w to r/o
    327 			 */
    328 			vn_start_write(NULL, &mp, V_WAIT);
    329 			flags = WRITECLOSE;
    330 			if (mp->mnt_flag & MNT_FORCE)
    331 				flags |= FORCECLOSE;
    332 			if (mp->mnt_flag & MNT_SOFTDEP)
    333 				error = softdep_flushfiles(mp, flags, l);
    334 			else
    335 				error = ffs_flushfiles(mp, flags, l);
    336 			if (fs->fs_pendingblocks != 0 ||
    337 			    fs->fs_pendinginodes != 0) {
    338 				printf("%s: update error: blocks %" PRId64
    339 				       " files %d\n",
    340 				    fs->fs_fsmnt, fs->fs_pendingblocks,
    341 				    fs->fs_pendinginodes);
    342 				fs->fs_pendingblocks = 0;
    343 				fs->fs_pendinginodes = 0;
    344 			}
    345 			if (error == 0 &&
    346 			    ffs_cgupdate(ump, MNT_WAIT) == 0 &&
    347 			    fs->fs_clean & FS_WASCLEAN) {
    348 				if (mp->mnt_flag & MNT_SOFTDEP)
    349 					fs->fs_flags &= ~FS_DOSOFTDEP;
    350 				fs->fs_clean = FS_ISCLEAN;
    351 				(void) ffs_sbupdate(ump, MNT_WAIT);
    352 			}
    353 			vn_finished_write(mp, 0);
    354 			if (error)
    355 				return (error);
    356 			fs->fs_ronly = 1;
    357 			fs->fs_fmod = 0;
    358 		}
    359 
    360 		/*
    361 		 * Flush soft dependencies if disabling it via an update
    362 		 * mount. This may leave some items to be processed,
    363 		 * so don't do this yet XXX.
    364 		 */
    365 		if ((fs->fs_flags & FS_DOSOFTDEP) &&
    366 		    !(mp->mnt_flag & MNT_SOFTDEP) && fs->fs_ronly == 0) {
    367 #ifdef notyet
    368 			vn_start_write(NULL, &mp, V_WAIT);
    369 			flags = WRITECLOSE;
    370 			if (mp->mnt_flag & MNT_FORCE)
    371 				flags |= FORCECLOSE;
    372 			error = softdep_flushfiles(mp, flags, l);
    373 			if (error == 0 && ffs_cgupdate(ump, MNT_WAIT) == 0)
    374 				fs->fs_flags &= ~FS_DOSOFTDEP;
    375 				(void) ffs_sbupdate(ump, MNT_WAIT);
    376 			vn_finished_write(mp);
    377 #elif defined(SOFTDEP)
    378 			mp->mnt_flag |= MNT_SOFTDEP;
    379 #endif
    380 		}
    381 
    382 		/*
    383 		 * When upgrading to a softdep mount, we must first flush
    384 		 * all vnodes. (not done yet -- see above)
    385 		 */
    386 		if (!(fs->fs_flags & FS_DOSOFTDEP) &&
    387 		    (mp->mnt_flag & MNT_SOFTDEP) && fs->fs_ronly == 0) {
    388 #ifdef notyet
    389 			vn_start_write(NULL, &mp, V_WAIT);
    390 			flags = WRITECLOSE;
    391 			if (mp->mnt_flag & MNT_FORCE)
    392 				flags |= FORCECLOSE;
    393 			error = ffs_flushfiles(mp, flags, l);
    394 			vn_finished_write(mp);
    395 #else
    396 			mp->mnt_flag &= ~MNT_SOFTDEP;
    397 #endif
    398 		}
    399 
    400 		if (mp->mnt_flag & MNT_RELOAD) {
    401 			error = ffs_reload(mp, p->p_ucred, l);
    402 			if (error)
    403 				return (error);
    404 		}
    405 
    406 		if (fs->fs_ronly && (mp->mnt_iflag & IMNT_WANTRDWR)) {
    407 			/*
    408 			 * Changing from read-only to read/write
    409 			 */
    410 			fs->fs_ronly = 0;
    411 			fs->fs_clean <<= 1;
    412 			fs->fs_fmod = 1;
    413 			if ((fs->fs_flags & FS_DOSOFTDEP)) {
    414 				error = softdep_mount(devvp, mp, fs,
    415 				    p->p_ucred);
    416 				if (error)
    417 					return (error);
    418 			}
    419 			if (fs->fs_snapinum[0] != 0)
    420 				ffs_snapshot_mount(mp);
    421 		}
    422 		if (args.fspec == 0) {
    423 			/*
    424 			 * Process export requests.
    425 			 */
    426 			return (vfs_export(mp, &ump->um_export, &args.export));
    427 		}
    428 		if ((mp->mnt_flag & (MNT_SOFTDEP | MNT_ASYNC)) ==
    429 		    (MNT_SOFTDEP | MNT_ASYNC)) {
    430 			printf("%s fs uses soft updates, ignoring async mode\n",
    431 			    fs->fs_fsmnt);
    432 			mp->mnt_flag &= ~MNT_ASYNC;
    433 		}
    434 	}
    435 
    436 	error = set_statvfs_info(path, UIO_USERSPACE, args.fspec,
    437 	    UIO_USERSPACE, mp, l);
    438 	if (error == 0)
    439 		(void)strncpy(fs->fs_fsmnt, mp->mnt_stat.f_mntonname,
    440 		    sizeof(fs->fs_fsmnt));
    441 	if (mp->mnt_flag & MNT_SOFTDEP)
    442 		fs->fs_flags |= FS_DOSOFTDEP;
    443 	else
    444 		fs->fs_flags &= ~FS_DOSOFTDEP;
    445 	if (fs->fs_fmod != 0) {	/* XXX */
    446 		fs->fs_fmod = 0;
    447 		if (fs->fs_clean & FS_WASCLEAN)
    448 			fs->fs_time = time.tv_sec;
    449 		else {
    450 			printf("%s: file system not clean (fs_clean=%x); please fsck(8)\n",
    451 			    mp->mnt_stat.f_mntfromname, fs->fs_clean);
    452 			printf("%s: lost blocks %" PRId64 " files %d\n",
    453 			    mp->mnt_stat.f_mntfromname, fs->fs_pendingblocks,
    454 			    fs->fs_pendinginodes);
    455 		}
    456 		(void) ffs_cgupdate(ump, MNT_WAIT);
    457 	}
    458 	return (error);
    459 
    460 fail:
    461 	vrele(devvp);
    462 	return (error);
    463 }
    464 
    465 /*
    466  * Reload all incore data for a filesystem (used after running fsck on
    467  * the root filesystem and finding things to fix). The filesystem must
    468  * be mounted read-only.
    469  *
    470  * Things to do to update the mount:
    471  *	1) invalidate all cached meta-data.
    472  *	2) re-read superblock from disk.
    473  *	3) re-read summary information from disk.
    474  *	4) invalidate all inactive vnodes.
    475  *	5) invalidate all cached file data.
    476  *	6) re-read inode data for all active vnodes.
    477  */
    478 int
    479 ffs_reload(mp, cred, l)
    480 	struct mount *mp;
    481 	struct ucred *cred;
    482 	struct lwp *l;
    483 {
    484 	struct vnode *vp, *nvp, *devvp;
    485 	struct inode *ip;
    486 	void *space;
    487 	struct buf *bp;
    488 	struct fs *fs, *newfs;
    489 	struct partinfo dpart;
    490 	int i, blks, size, error;
    491 	int32_t *lp;
    492 	struct ufsmount *ump;
    493 	daddr_t sblockloc;
    494 
    495 	if ((mp->mnt_flag & MNT_RDONLY) == 0)
    496 		return (EINVAL);
    497 
    498 	ump = VFSTOUFS(mp);
    499 	/*
    500 	 * Step 1: invalidate all cached meta-data.
    501 	 */
    502 	devvp = ump->um_devvp;
    503 	vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
    504 	error = vinvalbuf(devvp, 0, cred, l, 0, 0);
    505 	VOP_UNLOCK(devvp, 0);
    506 	if (error)
    507 		panic("ffs_reload: dirty1");
    508 	/*
    509 	 * Step 2: re-read superblock from disk.
    510 	 */
    511 	fs = ump->um_fs;
    512 	if (VOP_IOCTL(devvp, DIOCGPART, &dpart, FREAD, NOCRED, l) != 0)
    513 		size = DEV_BSIZE;
    514 	else
    515 		size = dpart.disklab->d_secsize;
    516 	/* XXX we don't handle possibility that superblock moved. */
    517 	error = bread(devvp, fs->fs_sblockloc / size, fs->fs_sbsize,
    518 		      NOCRED, &bp);
    519 	if (error) {
    520 		brelse(bp);
    521 		return (error);
    522 	}
    523 	newfs = malloc(fs->fs_sbsize, M_UFSMNT, M_WAITOK);
    524 	memcpy(newfs, bp->b_data, fs->fs_sbsize);
    525 #ifdef FFS_EI
    526 	if (ump->um_flags & UFS_NEEDSWAP) {
    527 		ffs_sb_swap((struct fs*)bp->b_data, newfs);
    528 		fs->fs_flags |= FS_SWAPPED;
    529 	} else
    530 #endif
    531 		fs->fs_flags &= ~FS_SWAPPED;
    532 	if ((newfs->fs_magic != FS_UFS1_MAGIC &&
    533 	     newfs->fs_magic != FS_UFS2_MAGIC)||
    534 	     newfs->fs_bsize > MAXBSIZE ||
    535 	     newfs->fs_bsize < sizeof(struct fs)) {
    536 		brelse(bp);
    537 		free(newfs, M_UFSMNT);
    538 		return (EIO);		/* XXX needs translation */
    539 	}
    540 	/* Store off old fs_sblockloc for fs_oldfscompat_read. */
    541 	sblockloc = fs->fs_sblockloc;
    542 	/*
    543 	 * Copy pointer fields back into superblock before copying in	XXX
    544 	 * new superblock. These should really be in the ufsmount.	XXX
    545 	 * Note that important parameters (eg fs_ncg) are unchanged.
    546 	 */
    547 	newfs->fs_csp = fs->fs_csp;
    548 	newfs->fs_maxcluster = fs->fs_maxcluster;
    549 	newfs->fs_contigdirs = fs->fs_contigdirs;
    550 	newfs->fs_ronly = fs->fs_ronly;
    551 	newfs->fs_active = fs->fs_active;
    552 	memcpy(fs, newfs, (u_int)fs->fs_sbsize);
    553 	brelse(bp);
    554 	free(newfs, M_UFSMNT);
    555 
    556 	/* Recheck for apple UFS filesystem */
    557 	ump->um_flags &= ~UFS_ISAPPLEUFS;
    558 	/* First check to see if this is tagged as an Apple UFS filesystem
    559 	 * in the disklabel
    560 	 */
    561 	if ((VOP_IOCTL(devvp, DIOCGPART, &dpart, FREAD, cred, l) == 0) &&
    562 		(dpart.part->p_fstype == FS_APPLEUFS)) {
    563 		ump->um_flags |= UFS_ISAPPLEUFS;
    564 	}
    565 #ifdef APPLE_UFS
    566 	else {
    567 		/* Manually look for an apple ufs label, and if a valid one
    568 		 * is found, then treat it like an Apple UFS filesystem anyway
    569 		 */
    570 		error = bread(devvp, (daddr_t)(APPLEUFS_LABEL_OFFSET / size),
    571 			APPLEUFS_LABEL_SIZE, cred, &bp);
    572 		if (error) {
    573 			brelse(bp);
    574 			return (error);
    575 		}
    576 		error = ffs_appleufs_validate(fs->fs_fsmnt,
    577 			(struct appleufslabel *)bp->b_data,NULL);
    578 		if (error == 0)
    579 			ump->um_flags |= UFS_ISAPPLEUFS;
    580 		brelse(bp);
    581 		bp = NULL;
    582 	}
    583 #else
    584 	if (ump->um_flags & UFS_ISAPPLEUFS)
    585 		return (EIO);
    586 #endif
    587 
    588 	if (UFS_MPISAPPLEUFS(ump)) {
    589 		/* see comment about NeXT below */
    590 		ump->um_maxsymlinklen = APPLEUFS_MAXSYMLINKLEN;
    591 		ump->um_dirblksiz = APPLEUFS_DIRBLKSIZ;
    592 		mp->mnt_iflag |= IMNT_DTYPE;
    593 	} else {
    594 		ump->um_maxsymlinklen = fs->fs_maxsymlinklen;
    595 		ump->um_dirblksiz = DIRBLKSIZ;
    596 		if (ump->um_maxsymlinklen > 0)
    597 			mp->mnt_iflag |= IMNT_DTYPE;
    598 		else
    599 			mp->mnt_iflag &= ~IMNT_DTYPE;
    600 	}
    601 	ffs_oldfscompat_read(fs, ump, sblockloc);
    602 	ump->um_maxfilesize = fs->fs_maxfilesize;
    603 	if (fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) {
    604 		fs->fs_pendingblocks = 0;
    605 		fs->fs_pendinginodes = 0;
    606 	}
    607 
    608 	ffs_statvfs(mp, &mp->mnt_stat, l);
    609 	/*
    610 	 * Step 3: re-read summary information from disk.
    611 	 */
    612 	blks = howmany(fs->fs_cssize, fs->fs_fsize);
    613 	space = fs->fs_csp;
    614 	for (i = 0; i < blks; i += fs->fs_frag) {
    615 		size = fs->fs_bsize;
    616 		if (i + fs->fs_frag > blks)
    617 			size = (blks - i) * fs->fs_fsize;
    618 		error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + i), size,
    619 			      NOCRED, &bp);
    620 		if (error) {
    621 			brelse(bp);
    622 			return (error);
    623 		}
    624 #ifdef FFS_EI
    625 		if (UFS_FSNEEDSWAP(fs))
    626 			ffs_csum_swap((struct csum *)bp->b_data,
    627 			    (struct csum *)space, size);
    628 		else
    629 #endif
    630 			memcpy(space, bp->b_data, (size_t)size);
    631 		space = (char *)space + size;
    632 		brelse(bp);
    633 	}
    634 	if ((fs->fs_flags & FS_DOSOFTDEP))
    635 		softdep_mount(devvp, mp, fs, cred);
    636 	if (fs->fs_snapinum[0] != 0)
    637 		ffs_snapshot_mount(mp);
    638 	/*
    639 	 * We no longer know anything about clusters per cylinder group.
    640 	 */
    641 	if (fs->fs_contigsumsize > 0) {
    642 		lp = fs->fs_maxcluster;
    643 		for (i = 0; i < fs->fs_ncg; i++)
    644 			*lp++ = fs->fs_contigsumsize;
    645 	}
    646 
    647 loop:
    648 	simple_lock(&mntvnode_slock);
    649 	for (vp = mp->mnt_vnodelist.lh_first; vp != NULL; vp = nvp) {
    650 		if (vp->v_mount != mp) {
    651 			simple_unlock(&mntvnode_slock);
    652 			goto loop;
    653 		}
    654 		nvp = vp->v_mntvnodes.le_next;
    655 		/*
    656 		 * Step 4: invalidate all inactive vnodes.
    657 		 */
    658 		if (vrecycle(vp, &mntvnode_slock, l))
    659 			goto loop;
    660 		/*
    661 		 * Step 5: invalidate all cached file data.
    662 		 */
    663 		simple_lock(&vp->v_interlock);
    664 		simple_unlock(&mntvnode_slock);
    665 		if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK))
    666 			goto loop;
    667 		if (vinvalbuf(vp, 0, cred, l, 0, 0))
    668 			panic("ffs_reload: dirty2");
    669 		/*
    670 		 * Step 6: re-read inode data for all active vnodes.
    671 		 */
    672 		ip = VTOI(vp);
    673 		error = bread(devvp, fsbtodb(fs, ino_to_fsba(fs, ip->i_number)),
    674 			      (int)fs->fs_bsize, NOCRED, &bp);
    675 		if (error) {
    676 			brelse(bp);
    677 			vput(vp);
    678 			return (error);
    679 		}
    680 		ffs_load_inode(bp, ip, fs, ip->i_number);
    681 		ip->i_ffs_effnlink = ip->i_nlink;
    682 		brelse(bp);
    683 		vput(vp);
    684 		simple_lock(&mntvnode_slock);
    685 	}
    686 	simple_unlock(&mntvnode_slock);
    687 	return (0);
    688 }
    689 
    690 /*
    691  * Possible superblock locations ordered from most to least likely.
    692  */
    693 static const int sblock_try[] = SBLOCKSEARCH;
    694 
    695 /*
    696  * Common code for mount and mountroot
    697  */
    698 int
    699 ffs_mountfs(devvp, mp, l)
    700 	struct vnode *devvp;
    701 	struct mount *mp;
    702 	struct lwp *l;
    703 {
    704 	struct ufsmount *ump;
    705 	struct buf *bp;
    706 	struct fs *fs;
    707 	dev_t dev;
    708 	struct partinfo dpart;
    709 	void *space;
    710 	struct proc *p;
    711 	daddr_t sblockloc, fsblockloc;
    712 	int blks, fstype;
    713 	int error, i, size, ronly;
    714 #ifdef FFS_EI
    715 	int needswap = 0;		/* keep gcc happy */
    716 #endif
    717 	int32_t *lp;
    718 	struct ucred *cred;
    719 	u_int32_t sbsize = 8192;	/* keep gcc happy*/
    720 
    721 	dev = devvp->v_rdev;
    722 	p = l ? l->l_proc : NULL;
    723 	cred = p ? p->p_ucred : NOCRED;
    724 
    725 	/* Flush out any old buffers remaining from a previous use. */
    726 	vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
    727 	error = vinvalbuf(devvp, V_SAVE, cred, l, 0, 0);
    728 	VOP_UNLOCK(devvp, 0);
    729 	if (error)
    730 		return (error);
    731 
    732 	ronly = (mp->mnt_flag & MNT_RDONLY) != 0;
    733 	if (VOP_IOCTL(devvp, DIOCGPART, &dpart, FREAD, cred, l) != 0)
    734 		size = DEV_BSIZE;
    735 	else
    736 		size = dpart.disklab->d_secsize;
    737 
    738 	bp = NULL;
    739 	ump = NULL;
    740 	fs = NULL;
    741 	sblockloc = 0;
    742 	fstype = 0;
    743 
    744 	/*
    745 	 * Try reading the superblock in each of its possible locations.		 */
    746 	for (i = 0; ; i++) {
    747 		if (bp != NULL) {
    748 			bp->b_flags |= B_NOCACHE;
    749 			brelse(bp);
    750 			bp = NULL;
    751 		}
    752 		if (sblock_try[i] == -1) {
    753 			error = EINVAL;
    754 			fs = NULL;
    755 			goto out;
    756 		}
    757 		error = bread(devvp, sblock_try[i] / size, SBLOCKSIZE, cred,
    758 			      &bp);
    759 		if (error)
    760 			goto out;
    761 		fs = (struct fs*)bp->b_data;
    762 		fsblockloc = sblockloc = sblock_try[i];
    763 		if (fs->fs_magic == FS_UFS1_MAGIC) {
    764 			sbsize = fs->fs_sbsize;
    765 			fstype = UFS1;
    766 #ifdef FFS_EI
    767 			needswap = 0;
    768 		} else if (fs->fs_magic == bswap32(FS_UFS1_MAGIC)) {
    769 			sbsize = bswap32(fs->fs_sbsize);
    770 			fstype = UFS1;
    771 			needswap = 1;
    772 #endif
    773 		} else if (fs->fs_magic == FS_UFS2_MAGIC) {
    774 			sbsize = fs->fs_sbsize;
    775 			fstype = UFS2;
    776 #ifdef FFS_EI
    777 			needswap = 0;
    778 		} else if (fs->fs_magic == bswap32(FS_UFS2_MAGIC)) {
    779 			sbsize = bswap32(fs->fs_sbsize);
    780 			fstype = UFS2;
    781 			needswap = 1;
    782 #endif
    783 		} else
    784 			continue;
    785 
    786 
    787 		/* fs->fs_sblockloc isn't defined for old filesystems */
    788 		if (fstype == UFS1 && !(fs->fs_old_flags & FS_FLAGS_UPDATED)) {
    789 			if (sblockloc == SBLOCK_UFS2)
    790 				/*
    791 				 * This is likely to be the first alternate
    792 				 * in a filesystem with 64k blocks.
    793 				 * Don't use it.
    794 				 */
    795 				continue;
    796 			fsblockloc = sblockloc;
    797 		} else {
    798 			fsblockloc = fs->fs_sblockloc;
    799 #ifdef FFS_EI
    800 			if (needswap)
    801 				fsblockloc = bswap64(fsblockloc);
    802 #endif
    803 		}
    804 
    805 		/* Check we haven't found an alternate superblock */
    806 		if (fsblockloc != sblockloc)
    807 			continue;
    808 
    809 		/* Validate size of superblock */
    810 		if (sbsize > MAXBSIZE || sbsize < sizeof(struct fs))
    811 			continue;
    812 
    813 		/* Ok seems to be a good superblock */
    814 		break;
    815 	}
    816 
    817 	fs = malloc((u_long)sbsize, M_UFSMNT, M_WAITOK);
    818 	memcpy(fs, bp->b_data, sbsize);
    819 
    820 	ump = malloc(sizeof *ump, M_UFSMNT, M_WAITOK);
    821 	memset(ump, 0, sizeof *ump);
    822 	TAILQ_INIT(&ump->um_snapshots);
    823 	ump->um_fs = fs;
    824 
    825 #ifdef FFS_EI
    826 	if (needswap) {
    827 		ffs_sb_swap((struct fs*)bp->b_data, fs);
    828 		fs->fs_flags |= FS_SWAPPED;
    829 	} else
    830 #endif
    831 		fs->fs_flags &= ~FS_SWAPPED;
    832 
    833 	ffs_oldfscompat_read(fs, ump, sblockloc);
    834 	ump->um_maxfilesize = fs->fs_maxfilesize;
    835 
    836 	if (fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) {
    837 		fs->fs_pendingblocks = 0;
    838 		fs->fs_pendinginodes = 0;
    839 	}
    840 
    841 	ump->um_fstype = fstype;
    842 	if (fs->fs_sbsize < SBLOCKSIZE)
    843 		bp->b_flags |= B_INVAL;
    844 	brelse(bp);
    845 	bp = NULL;
    846 
    847 	/* First check to see if this is tagged as an Apple UFS filesystem
    848 	 * in the disklabel
    849 	 */
    850 	if ((VOP_IOCTL(devvp, DIOCGPART, &dpart, FREAD, cred, l) == 0) &&
    851 		(dpart.part->p_fstype == FS_APPLEUFS)) {
    852 		ump->um_flags |= UFS_ISAPPLEUFS;
    853 	}
    854 #ifdef APPLE_UFS
    855 	else {
    856 		/* Manually look for an apple ufs label, and if a valid one
    857 		 * is found, then treat it like an Apple UFS filesystem anyway
    858 		 */
    859 		error = bread(devvp, (daddr_t)(APPLEUFS_LABEL_OFFSET / size),
    860 			APPLEUFS_LABEL_SIZE, cred, &bp);
    861 		if (error)
    862 			goto out;
    863 		error = ffs_appleufs_validate(fs->fs_fsmnt,
    864 			(struct appleufslabel *)bp->b_data,NULL);
    865 		if (error == 0) {
    866 			ump->um_flags |= UFS_ISAPPLEUFS;
    867 		}
    868 		brelse(bp);
    869 		bp = NULL;
    870 	}
    871 #else
    872 	if (ump->um_flags & UFS_ISAPPLEUFS) {
    873 		error = EINVAL;
    874 		goto out;
    875 	}
    876 #endif
    877 
    878 	/*
    879 	 * verify that we can access the last block in the fs
    880 	 * if we're mounting read/write.
    881 	 */
    882 
    883 	if (!ronly) {
    884 		error = bread(devvp, fsbtodb(fs, fs->fs_size - 1), fs->fs_fsize,
    885 		    cred, &bp);
    886 		if (bp->b_bcount != fs->fs_fsize)
    887 			error = EINVAL;
    888 		bp->b_flags |= B_INVAL;
    889 		if (error)
    890 			goto out;
    891 		brelse(bp);
    892 		bp = NULL;
    893 	}
    894 
    895 	fs->fs_ronly = ronly;
    896 	if (ronly == 0) {
    897 		fs->fs_clean <<= 1;
    898 		fs->fs_fmod = 1;
    899 	}
    900 	size = fs->fs_cssize;
    901 	blks = howmany(size, fs->fs_fsize);
    902 	if (fs->fs_contigsumsize > 0)
    903 		size += fs->fs_ncg * sizeof(int32_t);
    904 	size += fs->fs_ncg * sizeof(*fs->fs_contigdirs);
    905 	space = malloc((u_long)size, M_UFSMNT, M_WAITOK);
    906 	fs->fs_csp = space;
    907 	for (i = 0; i < blks; i += fs->fs_frag) {
    908 		size = fs->fs_bsize;
    909 		if (i + fs->fs_frag > blks)
    910 			size = (blks - i) * fs->fs_fsize;
    911 		error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + i), size,
    912 			      cred, &bp);
    913 		if (error) {
    914 			free(fs->fs_csp, M_UFSMNT);
    915 			goto out;
    916 		}
    917 #ifdef FFS_EI
    918 		if (needswap)
    919 			ffs_csum_swap((struct csum *)bp->b_data,
    920 				(struct csum *)space, size);
    921 		else
    922 #endif
    923 			memcpy(space, bp->b_data, (u_int)size);
    924 
    925 		space = (char *)space + size;
    926 		brelse(bp);
    927 		bp = NULL;
    928 	}
    929 	if (fs->fs_contigsumsize > 0) {
    930 		fs->fs_maxcluster = lp = space;
    931 		for (i = 0; i < fs->fs_ncg; i++)
    932 			*lp++ = fs->fs_contigsumsize;
    933 		space = lp;
    934 	}
    935 	size = fs->fs_ncg * sizeof(*fs->fs_contigdirs);
    936 	fs->fs_contigdirs = space;
    937 	space = (char *)space + size;
    938 	memset(fs->fs_contigdirs, 0, size);
    939 		/* Compatibility for old filesystems - XXX */
    940 	if (fs->fs_avgfilesize <= 0)
    941 		fs->fs_avgfilesize = AVFILESIZ;
    942 	if (fs->fs_avgfpdir <= 0)
    943 		fs->fs_avgfpdir = AFPDIR;
    944 	fs->fs_active = NULL;
    945 	mp->mnt_data = ump;
    946 	mp->mnt_stat.f_fsidx.__fsid_val[0] = (long)dev;
    947 	mp->mnt_stat.f_fsidx.__fsid_val[1] = makefstype(MOUNT_FFS);
    948 	mp->mnt_stat.f_fsid = mp->mnt_stat.f_fsidx.__fsid_val[0];
    949 	mp->mnt_stat.f_namemax = MAXNAMLEN;
    950 	if (UFS_MPISAPPLEUFS(ump)) {
    951 		/* NeXT used to keep short symlinks in the inode even
    952 		 * when using FS_42INODEFMT.  In that case fs->fs_maxsymlinklen
    953 		 * is probably -1, but we still need to be able to identify
    954 		 * short symlinks.
    955 		 */
    956 		ump->um_maxsymlinklen = APPLEUFS_MAXSYMLINKLEN;
    957 		ump->um_dirblksiz = APPLEUFS_DIRBLKSIZ;
    958 		mp->mnt_iflag |= IMNT_DTYPE;
    959 	} else {
    960 		ump->um_maxsymlinklen = fs->fs_maxsymlinklen;
    961 		ump->um_dirblksiz = DIRBLKSIZ;
    962 		if (ump->um_maxsymlinklen > 0)
    963 			mp->mnt_iflag |= IMNT_DTYPE;
    964 		else
    965 			mp->mnt_iflag &= ~IMNT_DTYPE;
    966 	}
    967 	mp->mnt_fs_bshift = fs->fs_bshift;
    968 	mp->mnt_dev_bshift = DEV_BSHIFT;	/* XXX */
    969 	mp->mnt_flag |= MNT_LOCAL;
    970 #ifdef FFS_EI
    971 	if (needswap)
    972 		ump->um_flags |= UFS_NEEDSWAP;
    973 #endif
    974 	ump->um_mountp = mp;
    975 	ump->um_dev = dev;
    976 	ump->um_devvp = devvp;
    977 	ump->um_nindir = fs->fs_nindir;
    978 	ump->um_lognindir = ffs(fs->fs_nindir) - 1;
    979 	ump->um_bptrtodb = fs->fs_fsbtodb;
    980 	ump->um_seqinc = fs->fs_frag;
    981 	for (i = 0; i < MAXQUOTAS; i++)
    982 		ump->um_quotas[i] = NULLVP;
    983 	devvp->v_specmountpoint = mp;
    984 	if (ronly == 0 && (fs->fs_flags & FS_DOSOFTDEP)) {
    985 		error = softdep_mount(devvp, mp, fs, cred);
    986 		if (error) {
    987 			free(fs->fs_csp, M_UFSMNT);
    988 			goto out;
    989 		}
    990 	}
    991 	if (ronly == 0 && fs->fs_snapinum[0] != 0)
    992 		ffs_snapshot_mount(mp);
    993 	return (0);
    994 out:
    995 	if (fs)
    996 		free(fs, M_UFSMNT);
    997 	devvp->v_specmountpoint = NULL;
    998 	if (bp)
    999 		brelse(bp);
   1000 	if (ump) {
   1001 		if (ump->um_oldfscompat)
   1002 			free(ump->um_oldfscompat, M_UFSMNT);
   1003 		free(ump, M_UFSMNT);
   1004 		mp->mnt_data = NULL;
   1005 	}
   1006 	return (error);
   1007 }
   1008 
   1009 /*
   1010  * Sanity checks for loading old filesystem superblocks.
   1011  * See ffs_oldfscompat_write below for unwound actions.
   1012  *
   1013  * XXX - Parts get retired eventually.
   1014  * Unfortunately new bits get added.
   1015  */
   1016 static void
   1017 ffs_oldfscompat_read(fs, ump, sblockloc)
   1018 	struct fs *fs;
   1019 	struct ufsmount *ump;
   1020 	daddr_t sblockloc;
   1021 {
   1022 	off_t maxfilesize;
   1023 	int32_t *extrasave;
   1024 
   1025 	if ((fs->fs_magic != FS_UFS1_MAGIC) ||
   1026 	    (fs->fs_old_flags & FS_FLAGS_UPDATED))
   1027 		return;
   1028 
   1029 	if (!ump->um_oldfscompat)
   1030 		ump->um_oldfscompat = malloc(512 + 3*sizeof(int32_t),
   1031 		    M_UFSMNT, M_WAITOK);
   1032 
   1033 	memcpy(ump->um_oldfscompat, &fs->fs_old_postbl_start, 512);
   1034 	extrasave = ump->um_oldfscompat;
   1035 	extrasave += 512/sizeof(int32_t);
   1036 	extrasave[0] = fs->fs_old_npsect;
   1037 	extrasave[1] = fs->fs_old_interleave;
   1038 	extrasave[2] = fs->fs_old_trackskew;
   1039 
   1040 	/* These fields will be overwritten by their
   1041 	 * original values in fs_oldfscompat_write, so it is harmless
   1042 	 * to modify them here.
   1043 	 */
   1044 	fs->fs_cstotal.cs_ndir = fs->fs_old_cstotal.cs_ndir;
   1045 	fs->fs_cstotal.cs_nbfree = fs->fs_old_cstotal.cs_nbfree;
   1046 	fs->fs_cstotal.cs_nifree = fs->fs_old_cstotal.cs_nifree;
   1047 	fs->fs_cstotal.cs_nffree = fs->fs_old_cstotal.cs_nffree;
   1048 
   1049 	fs->fs_maxbsize = fs->fs_bsize;
   1050 	fs->fs_time = fs->fs_old_time;
   1051 	fs->fs_size = fs->fs_old_size;
   1052 	fs->fs_dsize = fs->fs_old_dsize;
   1053 	fs->fs_csaddr = fs->fs_old_csaddr;
   1054 	fs->fs_sblockloc = sblockloc;
   1055 
   1056         fs->fs_flags = fs->fs_old_flags | (fs->fs_flags & FS_INTERNAL);
   1057 
   1058 	if (fs->fs_old_postblformat == FS_42POSTBLFMT) {
   1059 		fs->fs_old_nrpos = 8;
   1060 		fs->fs_old_npsect = fs->fs_old_nsect;
   1061 		fs->fs_old_interleave = 1;
   1062 		fs->fs_old_trackskew = 0;
   1063 	}
   1064 
   1065 	if (fs->fs_old_inodefmt < FS_44INODEFMT) {
   1066 		ump->um_maxfilesize = (u_quad_t) 1LL << 39;
   1067 		fs->fs_qbmask = ~fs->fs_bmask;
   1068 		fs->fs_qfmask = ~fs->fs_fmask;
   1069 	}
   1070 
   1071 	maxfilesize = (u_int64_t)0x80000000 * fs->fs_bsize - 1;
   1072 	if (ump->um_maxfilesize > maxfilesize)
   1073 		ump->um_maxfilesize = maxfilesize;
   1074 
   1075 	/* Compatibility for old filesystems */
   1076 	if (fs->fs_avgfilesize <= 0)
   1077 		fs->fs_avgfilesize = AVFILESIZ;
   1078 	if (fs->fs_avgfpdir <= 0)
   1079 		fs->fs_avgfpdir = AFPDIR;
   1080 
   1081 #if 0
   1082 	if (bigcgs) {
   1083 		fs->fs_save_cgsize = fs->fs_cgsize;
   1084 		fs->fs_cgsize = fs->fs_bsize;
   1085 	}
   1086 #endif
   1087 }
   1088 
   1089 /*
   1090  * Unwinding superblock updates for old filesystems.
   1091  * See ffs_oldfscompat_read above for details.
   1092  *
   1093  * XXX - Parts get retired eventually.
   1094  * Unfortunately new bits get added.
   1095  */
   1096 static void
   1097 ffs_oldfscompat_write(fs, ump)
   1098 	struct fs *fs;
   1099 	struct ufsmount *ump;
   1100 {
   1101 	int32_t *extrasave;
   1102 
   1103 	if ((fs->fs_magic != FS_UFS1_MAGIC) ||
   1104 	    (fs->fs_old_flags & FS_FLAGS_UPDATED))
   1105 		return;
   1106 
   1107 	fs->fs_old_time = fs->fs_time;
   1108 	fs->fs_old_cstotal.cs_ndir = fs->fs_cstotal.cs_ndir;
   1109 	fs->fs_old_cstotal.cs_nbfree = fs->fs_cstotal.cs_nbfree;
   1110 	fs->fs_old_cstotal.cs_nifree = fs->fs_cstotal.cs_nifree;
   1111 	fs->fs_old_cstotal.cs_nffree = fs->fs_cstotal.cs_nffree;
   1112 	fs->fs_old_flags = fs->fs_flags;
   1113 
   1114 #if 0
   1115 	if (bigcgs) {
   1116 		fs->fs_cgsize = fs->fs_save_cgsize;
   1117 	}
   1118 #endif
   1119 
   1120 	memcpy(&fs->fs_old_postbl_start, ump->um_oldfscompat, 512);
   1121 	extrasave = ump->um_oldfscompat;
   1122 	extrasave += 512/sizeof(int32_t);
   1123 	fs->fs_old_npsect = extrasave[0];
   1124 	fs->fs_old_interleave = extrasave[1];
   1125 	fs->fs_old_trackskew = extrasave[2];
   1126 
   1127 }
   1128 
   1129 /*
   1130  * unmount system call
   1131  */
   1132 int
   1133 ffs_unmount(mp, mntflags, l)
   1134 	struct mount *mp;
   1135 	int mntflags;
   1136 	struct lwp *l;
   1137 {
   1138 	struct ufsmount *ump;
   1139 	struct fs *fs;
   1140 	int error, flags, penderr;
   1141 
   1142 	penderr = 0;
   1143 	flags = 0;
   1144 	if (mntflags & MNT_FORCE)
   1145 		flags |= FORCECLOSE;
   1146 	if (mp->mnt_flag & MNT_SOFTDEP) {
   1147 		if ((error = softdep_flushfiles(mp, flags, l)) != 0)
   1148 			return (error);
   1149 	} else {
   1150 		if ((error = ffs_flushfiles(mp, flags, l)) != 0)
   1151 			return (error);
   1152 	}
   1153 	ump = VFSTOUFS(mp);
   1154 	fs = ump->um_fs;
   1155 	if (fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) {
   1156 		printf("%s: unmount pending error: blocks %" PRId64
   1157 		       " files %d\n",
   1158 		    fs->fs_fsmnt, fs->fs_pendingblocks, fs->fs_pendinginodes);
   1159 		fs->fs_pendingblocks = 0;
   1160 		fs->fs_pendinginodes = 0;
   1161 		penderr = 1;
   1162 	}
   1163 	if (fs->fs_ronly == 0 &&
   1164 	    ffs_cgupdate(ump, MNT_WAIT) == 0 &&
   1165 	    fs->fs_clean & FS_WASCLEAN) {
   1166 		/*
   1167 		 * XXXX don't mark fs clean in the case of softdep
   1168 		 * pending block errors, until they are fixed.
   1169 		 */
   1170 		if (penderr == 0) {
   1171 			if (mp->mnt_flag & MNT_SOFTDEP)
   1172 				fs->fs_flags &= ~FS_DOSOFTDEP;
   1173 			fs->fs_clean = FS_ISCLEAN;
   1174 		}
   1175 		fs->fs_fmod = 0;
   1176 		(void) ffs_sbupdate(ump, MNT_WAIT);
   1177 	}
   1178 	if (ump->um_devvp->v_type != VBAD)
   1179 		ump->um_devvp->v_specmountpoint = NULL;
   1180 	vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY);
   1181 	(void)VOP_CLOSE(ump->um_devvp, fs->fs_ronly ? FREAD : FREAD|FWRITE,
   1182 		NOCRED, l);
   1183 	vput(ump->um_devvp);
   1184 	free(fs->fs_csp, M_UFSMNT);
   1185 	free(fs, M_UFSMNT);
   1186 	if (ump->um_oldfscompat != NULL)
   1187 		free(ump->um_oldfscompat, M_UFSMNT);
   1188 	free(ump, M_UFSMNT);
   1189 	mp->mnt_data = NULL;
   1190 	mp->mnt_flag &= ~MNT_LOCAL;
   1191 	return (0);
   1192 }
   1193 
   1194 /*
   1195  * Flush out all the files in a filesystem.
   1196  */
   1197 int
   1198 ffs_flushfiles(mp, flags, l)
   1199 	struct mount *mp;
   1200 	int flags;
   1201 	struct lwp *l;
   1202 {
   1203 	extern int doforce;
   1204 	struct ufsmount *ump;
   1205 	int error;
   1206 
   1207 	if (!doforce)
   1208 		flags &= ~FORCECLOSE;
   1209 	ump = VFSTOUFS(mp);
   1210 #ifdef QUOTA
   1211 	if (mp->mnt_flag & MNT_QUOTA) {
   1212 		int i;
   1213 		if ((error = vflush(mp, NULLVP, SKIPSYSTEM|flags)) != 0)
   1214 			return (error);
   1215 		for (i = 0; i < MAXQUOTAS; i++) {
   1216 			if (ump->um_quotas[i] == NULLVP)
   1217 				continue;
   1218 			quotaoff(l, mp, i);
   1219 		}
   1220 		/*
   1221 		 * Here we fall through to vflush again to ensure
   1222 		 * that we have gotten rid of all the system vnodes.
   1223 		 */
   1224 	}
   1225 #endif
   1226 	if ((error = vflush(mp, 0, SKIPSYSTEM | flags)) != 0)
   1227 		return (error);
   1228 	ffs_snapshot_unmount(mp);
   1229 	/*
   1230 	 * Flush all the files.
   1231 	 */
   1232 	error = vflush(mp, NULLVP, flags);
   1233 	if (error)
   1234 		return (error);
   1235 	/*
   1236 	 * Flush filesystem metadata.
   1237 	 */
   1238 	vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY);
   1239 	error = VOP_FSYNC(ump->um_devvp, l->l_proc->p_ucred, FSYNC_WAIT, 0, 0, l);
   1240 	VOP_UNLOCK(ump->um_devvp, 0);
   1241 	return (error);
   1242 }
   1243 
   1244 /*
   1245  * Get file system statistics.
   1246  */
   1247 int
   1248 ffs_statvfs(mp, sbp, l)
   1249 	struct mount *mp;
   1250 	struct statvfs *sbp;
   1251 	struct lwp *l;
   1252 {
   1253 	struct ufsmount *ump;
   1254 	struct fs *fs;
   1255 
   1256 	ump = VFSTOUFS(mp);
   1257 	fs = ump->um_fs;
   1258 	sbp->f_bsize = fs->fs_bsize;
   1259 	sbp->f_frsize = fs->fs_fsize;
   1260 	sbp->f_iosize = fs->fs_bsize;
   1261 	sbp->f_blocks = fs->fs_dsize;
   1262 	sbp->f_bfree = blkstofrags(fs, fs->fs_cstotal.cs_nbfree) +
   1263 		fs->fs_cstotal.cs_nffree + dbtofsb(fs, fs->fs_pendingblocks);
   1264 	sbp->f_bresvd = ((u_int64_t) fs->fs_dsize * (u_int64_t)
   1265 	    fs->fs_minfree) / (u_int64_t) 100;
   1266 	if (sbp->f_bfree > sbp->f_bresvd)
   1267 		sbp->f_bavail = sbp->f_bfree - sbp->f_bresvd;
   1268 	else
   1269 		sbp->f_bavail = 0;
   1270 	sbp->f_files =  fs->fs_ncg * fs->fs_ipg - ROOTINO;
   1271 	sbp->f_ffree = fs->fs_cstotal.cs_nifree + fs->fs_pendinginodes;
   1272 	sbp->f_favail = sbp->f_ffree;
   1273 	sbp->f_fresvd = 0;
   1274 	copy_statvfs_info(sbp, mp);
   1275 	return (0);
   1276 }
   1277 
   1278 /*
   1279  * Go through the disk queues to initiate sandbagged IO;
   1280  * go through the inodes to write those that have been modified;
   1281  * initiate the writing of the super block if it has been modified.
   1282  *
   1283  * Note: we are always called with the filesystem marked `MPBUSY'.
   1284  */
   1285 int
   1286 ffs_sync(mp, waitfor, cred, l)
   1287 	struct mount *mp;
   1288 	int waitfor;
   1289 	struct ucred *cred;
   1290 	struct lwp *l;
   1291 {
   1292 	struct vnode *vp, *nvp;
   1293 	struct inode *ip;
   1294 	struct ufsmount *ump = VFSTOUFS(mp);
   1295 	struct fs *fs;
   1296 	int error, count, allerror = 0;
   1297 
   1298 	fs = ump->um_fs;
   1299 	if (fs->fs_fmod != 0 && fs->fs_ronly != 0) {		/* XXX */
   1300 		printf("fs = %s\n", fs->fs_fsmnt);
   1301 		panic("update: rofs mod");
   1302 	}
   1303 	/*
   1304 	 * Write back each (modified) inode.
   1305 	 */
   1306 	simple_lock(&mntvnode_slock);
   1307 loop:
   1308 	for (vp = LIST_FIRST(&mp->mnt_vnodelist); vp != NULL; vp = nvp) {
   1309 		/*
   1310 		 * If the vnode that we are about to sync is no longer
   1311 		 * associated with this mount point, start over.
   1312 		 */
   1313 		if (vp->v_mount != mp)
   1314 			goto loop;
   1315 		simple_lock(&vp->v_interlock);
   1316 		nvp = LIST_NEXT(vp, v_mntvnodes);
   1317 		ip = VTOI(vp);
   1318 		if (vp->v_type == VNON ||
   1319 		    ((ip->i_flag &
   1320 		      (IN_CHANGE | IN_UPDATE | IN_MODIFIED)) == 0 &&
   1321 		     LIST_EMPTY(&vp->v_dirtyblkhd) &&
   1322 		     vp->v_uobj.uo_npages == 0))
   1323 		{
   1324 			simple_unlock(&vp->v_interlock);
   1325 			continue;
   1326 		}
   1327 		simple_unlock(&mntvnode_slock);
   1328 		error = vget(vp, LK_EXCLUSIVE | LK_NOWAIT | LK_INTERLOCK);
   1329 		if (error) {
   1330 			simple_lock(&mntvnode_slock);
   1331 			if (error == ENOENT)
   1332 				goto loop;
   1333 			continue;
   1334 		}
   1335 		if (vp->v_type == VREG && waitfor == MNT_LAZY)
   1336 			error = VOP_UPDATE(vp, NULL, NULL, 0);
   1337 		else
   1338 			error = VOP_FSYNC(vp, cred,
   1339 			    waitfor == MNT_WAIT ? FSYNC_WAIT : 0, 0, 0, l);
   1340 		if (error)
   1341 			allerror = error;
   1342 		vput(vp);
   1343 		simple_lock(&mntvnode_slock);
   1344 	}
   1345 	simple_unlock(&mntvnode_slock);
   1346 	/*
   1347 	 * Force stale file system control information to be flushed.
   1348 	 */
   1349 	if (waitfor == MNT_WAIT && (ump->um_mountp->mnt_flag & MNT_SOFTDEP)) {
   1350 		if ((error = softdep_flushworklist(ump->um_mountp, &count, l)))
   1351 			allerror = error;
   1352 		/* Flushed work items may create new vnodes to clean */
   1353 		if (allerror == 0 && count) {
   1354 			simple_lock(&mntvnode_slock);
   1355 			goto loop;
   1356 		}
   1357 	}
   1358 	if (waitfor != MNT_LAZY && (ump->um_devvp->v_numoutput > 0 ||
   1359 	    !LIST_EMPTY(&ump->um_devvp->v_dirtyblkhd))) {
   1360 		vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY);
   1361 		if ((error = VOP_FSYNC(ump->um_devvp, cred,
   1362 		    waitfor == MNT_WAIT ? FSYNC_WAIT : 0, 0, 0, l)) != 0)
   1363 			allerror = error;
   1364 		VOP_UNLOCK(ump->um_devvp, 0);
   1365 		if (allerror == 0 && waitfor == MNT_WAIT) {
   1366 			simple_lock(&mntvnode_slock);
   1367 			goto loop;
   1368 		}
   1369 	}
   1370 #ifdef QUOTA
   1371 	qsync(mp);
   1372 #endif
   1373 	/*
   1374 	 * Write back modified superblock.
   1375 	 */
   1376 	if (fs->fs_fmod != 0) {
   1377 		fs->fs_fmod = 0;
   1378 		fs->fs_time = time.tv_sec;
   1379 		if ((error = ffs_cgupdate(ump, waitfor)))
   1380 			allerror = error;
   1381 	}
   1382 	return (allerror);
   1383 }
   1384 
   1385 /*
   1386  * Look up a FFS dinode number to find its incore vnode, otherwise read it
   1387  * in from disk.  If it is in core, wait for the lock bit to clear, then
   1388  * return the inode locked.  Detection and handling of mount points must be
   1389  * done by the calling routine.
   1390  */
   1391 int
   1392 ffs_vget(mp, ino, vpp)
   1393 	struct mount *mp;
   1394 	ino_t ino;
   1395 	struct vnode **vpp;
   1396 {
   1397 	struct fs *fs;
   1398 	struct inode *ip;
   1399 	struct ufsmount *ump;
   1400 	struct buf *bp;
   1401 	struct vnode *vp;
   1402 	dev_t dev;
   1403 	int error;
   1404 
   1405 	ump = VFSTOUFS(mp);
   1406 	dev = ump->um_dev;
   1407 
   1408 	if ((*vpp = ufs_ihashget(dev, ino, LK_EXCLUSIVE)) != NULL)
   1409 		return (0);
   1410 
   1411 	/* Allocate a new vnode/inode. */
   1412 	if ((error = getnewvnode(VT_UFS, mp, ffs_vnodeop_p, &vp)) != 0) {
   1413 		*vpp = NULL;
   1414 		return (error);
   1415 	}
   1416 
   1417 	/*
   1418 	 * If someone beat us to it while sleeping in getnewvnode(),
   1419 	 * push back the freshly allocated vnode we don't need, and return.
   1420 	 */
   1421 
   1422 	do {
   1423 		if ((*vpp = ufs_ihashget(dev, ino, LK_EXCLUSIVE)) != NULL) {
   1424 			ungetnewvnode(vp);
   1425 			return (0);
   1426 		}
   1427 	} while (lockmgr(&ufs_hashlock, LK_EXCLUSIVE|LK_SLEEPFAIL, 0));
   1428 
   1429 	vp->v_flag |= VLOCKSWORK;
   1430 
   1431 	/*
   1432 	 * XXX MFS ends up here, too, to allocate an inode.  Should we
   1433 	 * XXX create another pool for MFS inodes?
   1434 	 */
   1435 
   1436 	ip = pool_get(&ffs_inode_pool, PR_WAITOK);
   1437 	memset(ip, 0, sizeof(struct inode));
   1438 	vp->v_data = ip;
   1439 	ip->i_vnode = vp;
   1440 	ip->i_ump = ump;
   1441 	ip->i_fs = fs = ump->um_fs;
   1442 	ip->i_dev = dev;
   1443 	ip->i_number = ino;
   1444 	LIST_INIT(&ip->i_pcbufhd);
   1445 #ifdef QUOTA
   1446 	{
   1447 		int i;
   1448 
   1449 		for (i = 0; i < MAXQUOTAS; i++)
   1450 			ip->i_dquot[i] = NODQUOT;
   1451 	}
   1452 #endif
   1453 
   1454 	/*
   1455 	 * Put it onto its hash chain and lock it so that other requests for
   1456 	 * this inode will block if they arrive while we are sleeping waiting
   1457 	 * for old data structures to be purged or for the contents of the
   1458 	 * disk portion of this inode to be read.
   1459 	 */
   1460 
   1461 	ufs_ihashins(ip);
   1462 	lockmgr(&ufs_hashlock, LK_RELEASE, 0);
   1463 
   1464 	/* Read in the disk contents for the inode, copy into the inode. */
   1465 	error = bread(ump->um_devvp, fsbtodb(fs, ino_to_fsba(fs, ino)),
   1466 		      (int)fs->fs_bsize, NOCRED, &bp);
   1467 	if (error) {
   1468 
   1469 		/*
   1470 		 * The inode does not contain anything useful, so it would
   1471 		 * be misleading to leave it on its hash chain. With mode
   1472 		 * still zero, it will be unlinked and returned to the free
   1473 		 * list by vput().
   1474 		 */
   1475 
   1476 		vput(vp);
   1477 		brelse(bp);
   1478 		*vpp = NULL;
   1479 		return (error);
   1480 	}
   1481 	if (ip->i_ump->um_fstype == UFS1)
   1482 		ip->i_din.ffs1_din = pool_get(&ffs_dinode1_pool, PR_WAITOK);
   1483 	else
   1484 		ip->i_din.ffs2_din = pool_get(&ffs_dinode2_pool, PR_WAITOK);
   1485 	ffs_load_inode(bp, ip, fs, ino);
   1486 	if (DOINGSOFTDEP(vp))
   1487 		softdep_load_inodeblock(ip);
   1488 	else
   1489 		ip->i_ffs_effnlink = ip->i_nlink;
   1490 	brelse(bp);
   1491 
   1492 	/*
   1493 	 * Initialize the vnode from the inode, check for aliases.
   1494 	 * Note that the underlying vnode may have changed.
   1495 	 */
   1496 
   1497 	ufs_vinit(mp, ffs_specop_p, ffs_fifoop_p, &vp);
   1498 
   1499 	/*
   1500 	 * Finish inode initialization now that aliasing has been resolved.
   1501 	 */
   1502 
   1503 	genfs_node_init(vp, &ffs_genfsops);
   1504 	ip->i_devvp = ump->um_devvp;
   1505 	VREF(ip->i_devvp);
   1506 
   1507 	/*
   1508 	 * Ensure that uid and gid are correct. This is a temporary
   1509 	 * fix until fsck has been changed to do the update.
   1510 	 */
   1511 
   1512 	if (fs->fs_old_inodefmt < FS_44INODEFMT) {		/* XXX */
   1513 		ip->i_uid = ip->i_ffs1_ouid;			/* XXX */
   1514 		ip->i_gid = ip->i_ffs1_ogid;			/* XXX */
   1515 	}							/* XXX */
   1516 	uvm_vnp_setsize(vp, ip->i_size);
   1517 	*vpp = vp;
   1518 	return (0);
   1519 }
   1520 
   1521 /*
   1522  * File handle to vnode
   1523  *
   1524  * Have to be really careful about stale file handles:
   1525  * - check that the inode number is valid
   1526  * - call ffs_vget() to get the locked inode
   1527  * - check for an unallocated inode (i_mode == 0)
   1528  * - check that the given client host has export rights and return
   1529  *   those rights via. exflagsp and credanonp
   1530  */
   1531 int
   1532 ffs_fhtovp(mp, fhp, vpp)
   1533 	struct mount *mp;
   1534 	struct fid *fhp;
   1535 	struct vnode **vpp;
   1536 {
   1537 	struct ufid *ufhp;
   1538 	struct fs *fs;
   1539 
   1540 	ufhp = (struct ufid *)fhp;
   1541 	fs = VFSTOUFS(mp)->um_fs;
   1542 	if (ufhp->ufid_ino < ROOTINO ||
   1543 	    ufhp->ufid_ino >= fs->fs_ncg * fs->fs_ipg)
   1544 		return (ESTALE);
   1545 	return (ufs_fhtovp(mp, ufhp, vpp));
   1546 }
   1547 
   1548 /*
   1549  * Vnode pointer to File handle
   1550  */
   1551 /* ARGSUSED */
   1552 int
   1553 ffs_vptofh(vp, fhp)
   1554 	struct vnode *vp;
   1555 	struct fid *fhp;
   1556 {
   1557 	struct inode *ip;
   1558 	struct ufid *ufhp;
   1559 
   1560 	ip = VTOI(vp);
   1561 	ufhp = (struct ufid *)fhp;
   1562 	ufhp->ufid_len = sizeof(struct ufid);
   1563 	ufhp->ufid_ino = ip->i_number;
   1564 	ufhp->ufid_gen = ip->i_gen;
   1565 	return (0);
   1566 }
   1567 
   1568 void
   1569 ffs_init()
   1570 {
   1571 	if (ffs_initcount++ > 0)
   1572 		return;
   1573 
   1574 #ifdef _LKM
   1575 	pool_init(&ffs_inode_pool, sizeof(struct inode), 0, 0, 0,
   1576 		  "ffsinopl", &pool_allocator_nointr);
   1577 	pool_init(&ffs_dinode1_pool, sizeof(struct ufs1_dinode), 0, 0, 0,
   1578 		  "dino1pl", &pool_allocator_nointr);
   1579 	pool_init(&ffs_dinode2_pool, sizeof(struct ufs2_dinode), 0, 0, 0,
   1580 		  "dino2pl", &pool_allocator_nointr);
   1581 #endif
   1582 	softdep_initialize();
   1583 	ufs_init();
   1584 }
   1585 
   1586 void
   1587 ffs_reinit()
   1588 {
   1589 	softdep_reinitialize();
   1590 	ufs_reinit();
   1591 }
   1592 
   1593 void
   1594 ffs_done()
   1595 {
   1596 	if (--ffs_initcount > 0)
   1597 		return;
   1598 
   1599 	/* XXX softdep cleanup ? */
   1600 	ufs_done();
   1601 #ifdef _LKM
   1602 	pool_destroy(&ffs_dinode2_pool);
   1603 	pool_destroy(&ffs_dinode1_pool);
   1604 	pool_destroy(&ffs_inode_pool);
   1605 #endif
   1606 }
   1607 
   1608 SYSCTL_SETUP(sysctl_vfs_ffs_setup, "sysctl vfs.ffs subtree setup")
   1609 {
   1610 	extern int doasyncfree;
   1611 	extern int ffs_log_changeopt;
   1612 
   1613 	sysctl_createv(clog, 0, NULL, NULL,
   1614 		       CTLFLAG_PERMANENT,
   1615 		       CTLTYPE_NODE, "vfs", NULL,
   1616 		       NULL, 0, NULL, 0,
   1617 		       CTL_VFS, CTL_EOL);
   1618 	sysctl_createv(clog, 0, NULL, NULL,
   1619 		       CTLFLAG_PERMANENT,
   1620 		       CTLTYPE_NODE, "ffs",
   1621 		       SYSCTL_DESCR("Berkeley Fast File System"),
   1622 		       NULL, 0, NULL, 0,
   1623 		       CTL_VFS, 1, CTL_EOL);
   1624 
   1625 	/*
   1626 	 * @@@ should we even bother with these first three?
   1627 	 */
   1628 	sysctl_createv(clog, 0, NULL, NULL,
   1629 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   1630 		       CTLTYPE_INT, "doclusterread", NULL,
   1631 		       sysctl_notavail, 0, NULL, 0,
   1632 		       CTL_VFS, 1, FFS_CLUSTERREAD, CTL_EOL);
   1633 	sysctl_createv(clog, 0, NULL, NULL,
   1634 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   1635 		       CTLTYPE_INT, "doclusterwrite", NULL,
   1636 		       sysctl_notavail, 0, NULL, 0,
   1637 		       CTL_VFS, 1, FFS_CLUSTERWRITE, CTL_EOL);
   1638 	sysctl_createv(clog, 0, NULL, NULL,
   1639 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   1640 		       CTLTYPE_INT, "doreallocblks", NULL,
   1641 		       sysctl_notavail, 0, NULL, 0,
   1642 		       CTL_VFS, 1, FFS_REALLOCBLKS, CTL_EOL);
   1643 	sysctl_createv(clog, 0, NULL, NULL,
   1644 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   1645 		       CTLTYPE_INT, "doasyncfree",
   1646 		       SYSCTL_DESCR("Release dirty blocks asynchronously"),
   1647 		       NULL, 0, &doasyncfree, 0,
   1648 		       CTL_VFS, 1, FFS_ASYNCFREE, CTL_EOL);
   1649 	sysctl_createv(clog, 0, NULL, NULL,
   1650 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   1651 		       CTLTYPE_INT, "log_changeopt",
   1652 		       SYSCTL_DESCR("Log changes in optimization strategy"),
   1653 		       NULL, 0, &ffs_log_changeopt, 0,
   1654 		       CTL_VFS, 1, FFS_LOG_CHANGEOPT, CTL_EOL);
   1655 }
   1656 
   1657 /*
   1658  * Write a superblock and associated information back to disk.
   1659  */
   1660 int
   1661 ffs_sbupdate(mp, waitfor)
   1662 	struct ufsmount *mp;
   1663 	int waitfor;
   1664 {
   1665 	struct fs *fs = mp->um_fs;
   1666 	struct buf *bp;
   1667 	int error = 0;
   1668 	u_int32_t saveflag;
   1669 
   1670 	bp = getblk(mp->um_devvp,
   1671 	    fs->fs_sblockloc >> (fs->fs_fshift - fs->fs_fsbtodb),
   1672 	    (int)fs->fs_sbsize, 0, 0);
   1673 	saveflag = fs->fs_flags & FS_INTERNAL;
   1674 	fs->fs_flags &= ~FS_INTERNAL;
   1675 
   1676 	memcpy(bp->b_data, fs, fs->fs_sbsize);
   1677 
   1678 	ffs_oldfscompat_write((struct fs *)bp->b_data, mp);
   1679 #ifdef FFS_EI
   1680 	if (mp->um_flags & UFS_NEEDSWAP)
   1681 		ffs_sb_swap((struct fs *)bp->b_data, (struct fs *)bp->b_data);
   1682 #endif
   1683 	fs->fs_flags |= saveflag;
   1684 
   1685 	if (waitfor == MNT_WAIT)
   1686 		error = bwrite(bp);
   1687 	else
   1688 		bawrite(bp);
   1689 	return (error);
   1690 }
   1691 
   1692 int
   1693 ffs_cgupdate(mp, waitfor)
   1694 	struct ufsmount *mp;
   1695 	int waitfor;
   1696 {
   1697 	struct fs *fs = mp->um_fs;
   1698 	struct buf *bp;
   1699 	int blks;
   1700 	void *space;
   1701 	int i, size, error = 0, allerror = 0;
   1702 
   1703 	allerror = ffs_sbupdate(mp, waitfor);
   1704 	blks = howmany(fs->fs_cssize, fs->fs_fsize);
   1705 	space = fs->fs_csp;
   1706 	for (i = 0; i < blks; i += fs->fs_frag) {
   1707 		size = fs->fs_bsize;
   1708 		if (i + fs->fs_frag > blks)
   1709 			size = (blks - i) * fs->fs_fsize;
   1710 		bp = getblk(mp->um_devvp, fsbtodb(fs, fs->fs_csaddr + i),
   1711 		    size, 0, 0);
   1712 #ifdef FFS_EI
   1713 		if (mp->um_flags & UFS_NEEDSWAP)
   1714 			ffs_csum_swap((struct csum*)space,
   1715 			    (struct csum*)bp->b_data, size);
   1716 		else
   1717 #endif
   1718 			memcpy(bp->b_data, space, (u_int)size);
   1719 		space = (char *)space + size;
   1720 		if (waitfor == MNT_WAIT)
   1721 			error = bwrite(bp);
   1722 		else
   1723 			bawrite(bp);
   1724 	}
   1725 	if (!allerror && error)
   1726 		allerror = error;
   1727 	return (allerror);
   1728 }
   1729