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