Home | History | Annotate | Line # | Download | only in ffs
ffs_vfsops.c revision 1.257.2.3
      1 /*	$NetBSD: ffs_vfsops.c,v 1.257.2.3 2010/03/23 01:58:14 uebayasi Exp $	*/
      2 
      3 /*-
      4  * Copyright (c) 2008, 2009 The NetBSD Foundation, Inc.
      5  * All rights reserved.
      6  *
      7  * This code is derived from software contributed to The NetBSD Foundation
      8  * by Wasabi Systems, Inc, and by Andrew Doran.
      9  *
     10  * Redistribution and use in source and binary forms, with or without
     11  * modification, are permitted provided that the following conditions
     12  * are met:
     13  * 1. Redistributions of source code must retain the above copyright
     14  *    notice, this list of conditions and the following disclaimer.
     15  * 2. Redistributions in binary form must reproduce the above copyright
     16  *    notice, this list of conditions and the following disclaimer in the
     17  *    documentation and/or other materials provided with the distribution.
     18  *
     19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     29  * POSSIBILITY OF SUCH DAMAGE.
     30  */
     31 
     32 /*
     33  * Copyright (c) 1989, 1991, 1993, 1994
     34  *	The Regents of the University of California.  All rights reserved.
     35  *
     36  * Redistribution and use in source and binary forms, with or without
     37  * modification, are permitted provided that the following conditions
     38  * are met:
     39  * 1. Redistributions of source code must retain the above copyright
     40  *    notice, this list of conditions and the following disclaimer.
     41  * 2. Redistributions in binary form must reproduce the above copyright
     42  *    notice, this list of conditions and the following disclaimer in the
     43  *    documentation and/or other materials provided with the distribution.
     44  * 3. Neither the name of the University nor the names of its contributors
     45  *    may be used to endorse or promote products derived from this software
     46  *    without specific prior written permission.
     47  *
     48  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     49  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     50  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     51  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     52  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     53  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     54  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     55  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     56  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     57  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     58  * SUCH DAMAGE.
     59  *
     60  *	@(#)ffs_vfsops.c	8.31 (Berkeley) 5/20/95
     61  */
     62 
     63 #include <sys/cdefs.h>
     64 __KERNEL_RCSID(0, "$NetBSD: ffs_vfsops.c,v 1.257.2.3 2010/03/23 01:58:14 uebayasi Exp $");
     65 
     66 #if defined(_KERNEL_OPT)
     67 #include "opt_ffs.h"
     68 #include "opt_quota.h"
     69 #include "opt_wapbl.h"
     70 #include "opt_xip.h"
     71 #endif
     72 
     73 #include <sys/param.h>
     74 #include <sys/systm.h>
     75 #include <sys/namei.h>
     76 #include <sys/proc.h>
     77 #include <sys/kernel.h>
     78 #include <sys/vnode.h>
     79 #include <sys/socket.h>
     80 #include <sys/mount.h>
     81 #include <sys/buf.h>
     82 #include <sys/device.h>
     83 #include <sys/mbuf.h>
     84 #include <sys/file.h>
     85 #include <sys/disklabel.h>
     86 #include <sys/ioctl.h>
     87 #include <sys/errno.h>
     88 #include <sys/malloc.h>
     89 #include <sys/pool.h>
     90 #include <sys/lock.h>
     91 #include <sys/sysctl.h>
     92 #include <sys/conf.h>
     93 #include <sys/kauth.h>
     94 #include <sys/wapbl.h>
     95 #include <sys/fstrans.h>
     96 #include <sys/module.h>
     97 
     98 #include <miscfs/genfs/genfs.h>
     99 #include <miscfs/specfs/specdev.h>
    100 
    101 #include <ufs/ufs/quota.h>
    102 #include <ufs/ufs/ufsmount.h>
    103 #include <ufs/ufs/inode.h>
    104 #include <ufs/ufs/dir.h>
    105 #include <ufs/ufs/ufs_extern.h>
    106 #include <ufs/ufs/ufs_bswap.h>
    107 #include <ufs/ufs/ufs_wapbl.h>
    108 
    109 #include <ufs/ffs/fs.h>
    110 #include <ufs/ffs/ffs_extern.h>
    111 
    112 MODULE(MODULE_CLASS_VFS, ffs, NULL);
    113 
    114 static int	ffs_vfs_fsync(vnode_t *, int);
    115 
    116 static struct sysctllog *ffs_sysctl_log;
    117 
    118 /* how many times ffs_init() was called */
    119 int ffs_initcount = 0;
    120 
    121 extern const struct vnodeopv_desc ffs_vnodeop_opv_desc;
    122 extern const struct vnodeopv_desc ffs_specop_opv_desc;
    123 extern const struct vnodeopv_desc ffs_fifoop_opv_desc;
    124 
    125 const struct vnodeopv_desc * const ffs_vnodeopv_descs[] = {
    126 	&ffs_vnodeop_opv_desc,
    127 	&ffs_specop_opv_desc,
    128 	&ffs_fifoop_opv_desc,
    129 	NULL,
    130 };
    131 
    132 struct vfsops ffs_vfsops = {
    133 	MOUNT_FFS,
    134 	sizeof (struct ufs_args),
    135 	ffs_mount,
    136 	ufs_start,
    137 	ffs_unmount,
    138 	ufs_root,
    139 	ufs_quotactl,
    140 	ffs_statvfs,
    141 	ffs_sync,
    142 	ffs_vget,
    143 	ffs_fhtovp,
    144 	ffs_vptofh,
    145 	ffs_init,
    146 	ffs_reinit,
    147 	ffs_done,
    148 	ffs_mountroot,
    149 	ffs_snapshot,
    150 	ffs_extattrctl,
    151 	ffs_suspendctl,
    152 	genfs_renamelock_enter,
    153 	genfs_renamelock_exit,
    154 	ffs_vfs_fsync,
    155 	ffs_vnodeopv_descs,
    156 	0,
    157 	{ NULL, NULL },
    158 };
    159 
    160 static const struct genfs_ops ffs_genfsops = {
    161 	.gop_size = ffs_gop_size,
    162 	.gop_alloc = ufs_gop_alloc,
    163 	.gop_write = genfs_gop_write,
    164 	.gop_markupdate = ufs_gop_markupdate,
    165 };
    166 
    167 static const struct ufs_ops ffs_ufsops = {
    168 	.uo_itimes = ffs_itimes,
    169 	.uo_update = ffs_update,
    170 	.uo_truncate = ffs_truncate,
    171 	.uo_valloc = ffs_valloc,
    172 	.uo_vfree = ffs_vfree,
    173 	.uo_balloc = ffs_balloc,
    174 	.uo_unmark_vnode = (void (*)(vnode_t *))nullop,
    175 };
    176 
    177 static int
    178 ffs_modcmd(modcmd_t cmd, void *arg)
    179 {
    180 	int error;
    181 
    182 #if 0
    183 	extern int doasyncfree;
    184 #endif
    185 	extern int ffs_log_changeopt;
    186 
    187 	switch (cmd) {
    188 	case MODULE_CMD_INIT:
    189 		error = vfs_attach(&ffs_vfsops);
    190 		if (error != 0)
    191 			break;
    192 
    193 		sysctl_createv(&ffs_sysctl_log, 0, NULL, NULL,
    194 			       CTLFLAG_PERMANENT,
    195 			       CTLTYPE_NODE, "vfs", NULL,
    196 			       NULL, 0, NULL, 0,
    197 			       CTL_VFS, CTL_EOL);
    198 		sysctl_createv(&ffs_sysctl_log, 0, NULL, NULL,
    199 			       CTLFLAG_PERMANENT,
    200 			       CTLTYPE_NODE, "ffs",
    201 			       SYSCTL_DESCR("Berkeley Fast File System"),
    202 			       NULL, 0, NULL, 0,
    203 			       CTL_VFS, 1, CTL_EOL);
    204 
    205 		/*
    206 		 * @@@ should we even bother with these first three?
    207 		 */
    208 		sysctl_createv(&ffs_sysctl_log, 0, NULL, NULL,
    209 			       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
    210 			       CTLTYPE_INT, "doclusterread", NULL,
    211 			       sysctl_notavail, 0, NULL, 0,
    212 			       CTL_VFS, 1, FFS_CLUSTERREAD, CTL_EOL);
    213 		sysctl_createv(&ffs_sysctl_log, 0, NULL, NULL,
    214 			       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
    215 			       CTLTYPE_INT, "doclusterwrite", NULL,
    216 			       sysctl_notavail, 0, NULL, 0,
    217 			       CTL_VFS, 1, FFS_CLUSTERWRITE, CTL_EOL);
    218 		sysctl_createv(&ffs_sysctl_log, 0, NULL, NULL,
    219 			       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
    220 			       CTLTYPE_INT, "doreallocblks", NULL,
    221 			       sysctl_notavail, 0, NULL, 0,
    222 			       CTL_VFS, 1, FFS_REALLOCBLKS, CTL_EOL);
    223 #if 0
    224 		sysctl_createv(&ffs_sysctl_log, 0, NULL, NULL,
    225 			       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
    226 			       CTLTYPE_INT, "doasyncfree",
    227 			       SYSCTL_DESCR("Release dirty blocks asynchronously"),
    228 			       NULL, 0, &doasyncfree, 0,
    229 			       CTL_VFS, 1, FFS_ASYNCFREE, CTL_EOL);
    230 #endif
    231 		sysctl_createv(&ffs_sysctl_log, 0, NULL, NULL,
    232 			       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
    233 			       CTLTYPE_INT, "log_changeopt",
    234 			       SYSCTL_DESCR("Log changes in optimization strategy"),
    235 			       NULL, 0, &ffs_log_changeopt, 0,
    236 			       CTL_VFS, 1, FFS_LOG_CHANGEOPT, CTL_EOL);
    237 		break;
    238 	case MODULE_CMD_FINI:
    239 		error = vfs_detach(&ffs_vfsops);
    240 		if (error != 0)
    241 			break;
    242 		sysctl_teardown(&ffs_sysctl_log);
    243 		break;
    244 	default:
    245 		error = ENOTTY;
    246 		break;
    247 	}
    248 
    249 	return (error);
    250 }
    251 
    252 pool_cache_t ffs_inode_cache;
    253 pool_cache_t ffs_dinode1_cache;
    254 pool_cache_t ffs_dinode2_cache;
    255 
    256 static void ffs_oldfscompat_read(struct fs *, struct ufsmount *, daddr_t);
    257 static void ffs_oldfscompat_write(struct fs *, struct ufsmount *);
    258 
    259 /*
    260  * Called by main() when ffs is going to be mounted as root.
    261  */
    262 
    263 int
    264 ffs_mountroot(void)
    265 {
    266 	struct fs *fs;
    267 	struct mount *mp;
    268 	struct lwp *l = curlwp;			/* XXX */
    269 	struct ufsmount *ump;
    270 	int error;
    271 
    272 	if (device_class(root_device) != DV_DISK)
    273 		return (ENODEV);
    274 
    275 	if ((error = vfs_rootmountalloc(MOUNT_FFS, "root_device", &mp))) {
    276 		vrele(rootvp);
    277 		return (error);
    278 	}
    279 
    280 	/*
    281 	 * We always need to be able to mount the root file system.
    282 	 */
    283 	mp->mnt_flag |= MNT_FORCE;
    284 	if ((error = ffs_mountfs(rootvp, mp, l)) != 0) {
    285 		vfs_unbusy(mp, false, NULL);
    286 		vfs_destroy(mp);
    287 		return (error);
    288 	}
    289 	mp->mnt_flag &= ~MNT_FORCE;
    290 	mutex_enter(&mountlist_lock);
    291 	CIRCLEQ_INSERT_TAIL(&mountlist, mp, mnt_list);
    292 	mutex_exit(&mountlist_lock);
    293 	ump = VFSTOUFS(mp);
    294 	fs = ump->um_fs;
    295 	memset(fs->fs_fsmnt, 0, sizeof(fs->fs_fsmnt));
    296 	(void)copystr(mp->mnt_stat.f_mntonname, fs->fs_fsmnt, MNAMELEN - 1, 0);
    297 	(void)ffs_statvfs(mp, &mp->mnt_stat);
    298 	vfs_unbusy(mp, false, NULL);
    299 	setrootfstime((time_t)fs->fs_time);
    300 	return (0);
    301 }
    302 
    303 /*
    304  * VFS Operations.
    305  *
    306  * mount system call
    307  */
    308 int
    309 ffs_mount(struct mount *mp, const char *path, void *data, size_t *data_len)
    310 {
    311 	struct lwp *l = curlwp;
    312 	struct vnode *devvp = NULL;
    313 	struct ufs_args *args = data;
    314 	struct ufsmount *ump = NULL;
    315 	struct fs *fs;
    316 	int error = 0, flags, update;
    317 	mode_t accessmode;
    318 
    319 	if (*data_len < sizeof *args)
    320 		return EINVAL;
    321 
    322 	if (mp->mnt_flag & MNT_GETARGS) {
    323 		ump = VFSTOUFS(mp);
    324 		if (ump == NULL)
    325 			return EIO;
    326 		args->fspec = NULL;
    327 		*data_len = sizeof *args;
    328 		return 0;
    329 	}
    330 
    331 	update = mp->mnt_flag & MNT_UPDATE;
    332 
    333 	/* Check arguments */
    334 	if (args->fspec != NULL) {
    335 		/*
    336 		 * Look up the name and verify that it's sane.
    337 		 */
    338 		error = namei_simple_user(args->fspec,
    339 					NSM_FOLLOW_NOEMULROOT, &devvp);
    340 		if (error != 0)
    341 			return (error);
    342 
    343 		if (!update) {
    344 			/*
    345 			 * Be sure this is a valid block device
    346 			 */
    347 			if (devvp->v_type != VBLK)
    348 				error = ENOTBLK;
    349 			else if (bdevsw_lookup(devvp->v_rdev) == NULL)
    350 				error = ENXIO;
    351 		} else {
    352 			/*
    353 			 * Be sure we're still naming the same device
    354 			 * used for our initial mount
    355 			 */
    356 			ump = VFSTOUFS(mp);
    357 			if (devvp != ump->um_devvp) {
    358 				if (devvp->v_rdev != ump->um_devvp->v_rdev)
    359 					error = EINVAL;
    360 				else {
    361 					vrele(devvp);
    362 					devvp = ump->um_devvp;
    363 					vref(devvp);
    364 				}
    365 			}
    366 		}
    367 	} else {
    368 		if (!update) {
    369 			/* New mounts must have a filename for the device */
    370 			return (EINVAL);
    371 		} else {
    372 			/* Use the extant mount */
    373 			ump = VFSTOUFS(mp);
    374 			devvp = ump->um_devvp;
    375 			vref(devvp);
    376 		}
    377 	}
    378 
    379 	/*
    380 	 * If mount by non-root, then verify that user has necessary
    381 	 * permissions on the device.
    382 	 *
    383 	 * Permission to update a mount is checked higher, so here we presume
    384 	 * updating the mount is okay (for example, as far as securelevel goes)
    385 	 * which leaves us with the normal check.
    386 	 */
    387 	if (error == 0) {
    388 		accessmode = VREAD;
    389 		if (update ?
    390 		    (mp->mnt_iflag & IMNT_WANTRDWR) != 0 :
    391 		    (mp->mnt_flag & MNT_RDONLY) == 0)
    392 			accessmode |= VWRITE;
    393 		vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
    394 		error = genfs_can_mount(devvp, accessmode, l->l_cred);
    395 		VOP_UNLOCK(devvp, 0);
    396 	}
    397 
    398 	if (error) {
    399 		vrele(devvp);
    400 		return (error);
    401 	}
    402 
    403 #ifdef WAPBL
    404 	/* WAPBL can only be enabled on a r/w mount. */
    405 	if ((mp->mnt_flag & MNT_RDONLY) && !(mp->mnt_iflag & IMNT_WANTRDWR)) {
    406 		mp->mnt_flag &= ~MNT_LOG;
    407 	}
    408 #else /* !WAPBL */
    409 	mp->mnt_flag &= ~MNT_LOG;
    410 #endif /* !WAPBL */
    411 
    412 	if (!update) {
    413 		int xflags;
    414 
    415 		if (mp->mnt_flag & MNT_RDONLY)
    416 			xflags = FREAD;
    417 		else
    418 			xflags = FREAD | FWRITE;
    419 		error = VOP_OPEN(devvp, xflags, FSCRED);
    420 		if (error)
    421 			goto fail;
    422 		error = ffs_mountfs(devvp, mp, l);
    423 		if (error) {
    424 			vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
    425 			(void)VOP_CLOSE(devvp, xflags, NOCRED);
    426 			VOP_UNLOCK(devvp, 0);
    427 			goto fail;
    428 		}
    429 
    430 		ump = VFSTOUFS(mp);
    431 		fs = ump->um_fs;
    432 	} else {
    433 		/*
    434 		 * Update the mount.
    435 		 */
    436 
    437 		/*
    438 		 * The initial mount got a reference on this
    439 		 * device, so drop the one obtained via
    440 		 * namei(), above.
    441 		 */
    442 		vrele(devvp);
    443 
    444 		ump = VFSTOUFS(mp);
    445 		fs = ump->um_fs;
    446 		if (fs->fs_ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) {
    447 			/*
    448 			 * Changing from r/w to r/o
    449 			 */
    450 			flags = WRITECLOSE;
    451 			if (mp->mnt_flag & MNT_FORCE)
    452 				flags |= FORCECLOSE;
    453 			error = ffs_flushfiles(mp, flags, l);
    454 			if (error == 0)
    455 				error = UFS_WAPBL_BEGIN(mp);
    456 			if (error == 0 &&
    457 			    ffs_cgupdate(ump, MNT_WAIT) == 0 &&
    458 			    fs->fs_clean & FS_WASCLEAN) {
    459 				if (mp->mnt_flag & MNT_SOFTDEP)
    460 					fs->fs_flags &= ~FS_DOSOFTDEP;
    461 				fs->fs_clean = FS_ISCLEAN;
    462 				(void) ffs_sbupdate(ump, MNT_WAIT);
    463 			}
    464 			if (error == 0)
    465 				UFS_WAPBL_END(mp);
    466 			if (error)
    467 				return (error);
    468 		}
    469 
    470 #ifdef WAPBL
    471 		if ((mp->mnt_flag & MNT_LOG) == 0) {
    472 			error = ffs_wapbl_stop(mp, mp->mnt_flag & MNT_FORCE);
    473 			if (error)
    474 				return error;
    475 		}
    476 #endif /* WAPBL */
    477 
    478 		if (fs->fs_ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) {
    479 			/*
    480 			 * Finish change from r/w to r/o
    481 			 */
    482 			fs->fs_ronly = 1;
    483 			fs->fs_fmod = 0;
    484 		}
    485 
    486 		if (mp->mnt_flag & MNT_RELOAD) {
    487 			error = ffs_reload(mp, l->l_cred, l);
    488 			if (error)
    489 				return (error);
    490 		}
    491 
    492 		if (fs->fs_ronly && (mp->mnt_iflag & IMNT_WANTRDWR)) {
    493 			/*
    494 			 * Changing from read-only to read/write
    495 			 */
    496 			fs->fs_ronly = 0;
    497 			fs->fs_clean <<= 1;
    498 			fs->fs_fmod = 1;
    499 #ifdef WAPBL
    500 			if (fs->fs_flags & FS_DOWAPBL) {
    501 				printf("%s: replaying log to disk\n",
    502 				    fs->fs_fsmnt);
    503 				KDASSERT(mp->mnt_wapbl_replay);
    504 				error = wapbl_replay_write(mp->mnt_wapbl_replay,
    505 							   devvp);
    506 				if (error) {
    507 					return error;
    508 				}
    509 				wapbl_replay_stop(mp->mnt_wapbl_replay);
    510 				fs->fs_clean = FS_WASCLEAN;
    511 			}
    512 #endif /* WAPBL */
    513 			if (fs->fs_snapinum[0] != 0)
    514 				ffs_snapshot_mount(mp);
    515 		}
    516 
    517 #ifdef WAPBL
    518 		error = ffs_wapbl_start(mp);
    519 		if (error)
    520 			return error;
    521 #endif /* WAPBL */
    522 
    523 		if (args->fspec == NULL)
    524 			return 0;
    525 	}
    526 
    527 	error = set_statvfs_info(path, UIO_USERSPACE, args->fspec,
    528 	    UIO_USERSPACE, mp->mnt_op->vfs_name, mp, l);
    529 	if (error == 0)
    530 		(void)strncpy(fs->fs_fsmnt, mp->mnt_stat.f_mntonname,
    531 		    sizeof(fs->fs_fsmnt));
    532 	fs->fs_flags &= ~FS_DOSOFTDEP;
    533 	if (fs->fs_fmod != 0) {	/* XXX */
    534 		int err;
    535 
    536 		fs->fs_fmod = 0;
    537 		if (fs->fs_clean & FS_WASCLEAN)
    538 			fs->fs_time = time_second;
    539 		else {
    540 			printf("%s: file system not clean (fs_clean=%#x); "
    541 			    "please fsck(8)\n", mp->mnt_stat.f_mntfromname,
    542 			    fs->fs_clean);
    543 			printf("%s: lost blocks %" PRId64 " files %d\n",
    544 			    mp->mnt_stat.f_mntfromname, fs->fs_pendingblocks,
    545 			    fs->fs_pendinginodes);
    546 		}
    547 		err = UFS_WAPBL_BEGIN(mp);
    548 		if (err == 0) {
    549 			(void) ffs_cgupdate(ump, MNT_WAIT);
    550 			UFS_WAPBL_END(mp);
    551 		}
    552 	}
    553 	if ((mp->mnt_flag & MNT_SOFTDEP) != 0) {
    554 		printf("%s: `-o softdep' is no longer supported, "
    555 		    "consider `-o log'\n", mp->mnt_stat.f_mntfromname);
    556 		mp->mnt_flag &= ~MNT_SOFTDEP;
    557 	}
    558 
    559 	return (error);
    560 
    561 fail:
    562 	vrele(devvp);
    563 	return (error);
    564 }
    565 
    566 /*
    567  * Reload all incore data for a filesystem (used after running fsck on
    568  * the root filesystem and finding things to fix). The filesystem must
    569  * be mounted read-only.
    570  *
    571  * Things to do to update the mount:
    572  *	1) invalidate all cached meta-data.
    573  *	2) re-read superblock from disk.
    574  *	3) re-read summary information from disk.
    575  *	4) invalidate all inactive vnodes.
    576  *	5) invalidate all cached file data.
    577  *	6) re-read inode data for all active vnodes.
    578  */
    579 int
    580 ffs_reload(struct mount *mp, kauth_cred_t cred, struct lwp *l)
    581 {
    582 	struct vnode *vp, *mvp, *devvp;
    583 	struct inode *ip;
    584 	void *space;
    585 	struct buf *bp;
    586 	struct fs *fs, *newfs;
    587 	struct partinfo dpart;
    588 	int i, bsize, blks, error;
    589 	int32_t *lp;
    590 	struct ufsmount *ump;
    591 	daddr_t sblockloc;
    592 
    593 	if ((mp->mnt_flag & MNT_RDONLY) == 0)
    594 		return (EINVAL);
    595 
    596 	ump = VFSTOUFS(mp);
    597 	/*
    598 	 * Step 1: invalidate all cached meta-data.
    599 	 */
    600 	devvp = ump->um_devvp;
    601 	vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
    602 	error = vinvalbuf(devvp, 0, cred, l, 0, 0);
    603 	VOP_UNLOCK(devvp, 0);
    604 	if (error)
    605 		panic("ffs_reload: dirty1");
    606 	/*
    607 	 * Step 2: re-read superblock from disk.
    608 	 */
    609 	fs = ump->um_fs;
    610 
    611 	/* XXX we don't handle possibility that superblock moved. */
    612 	error = bread(devvp, fs->fs_sblockloc / DEV_BSIZE, fs->fs_sbsize,
    613 		      NOCRED, 0, &bp);
    614 	if (error) {
    615 		brelse(bp, 0);
    616 		return (error);
    617 	}
    618 	newfs = malloc(fs->fs_sbsize, M_UFSMNT, M_WAITOK);
    619 	memcpy(newfs, bp->b_data, fs->fs_sbsize);
    620 #ifdef FFS_EI
    621 	if (ump->um_flags & UFS_NEEDSWAP) {
    622 		ffs_sb_swap((struct fs*)bp->b_data, newfs);
    623 		fs->fs_flags |= FS_SWAPPED;
    624 	} else
    625 #endif
    626 		fs->fs_flags &= ~FS_SWAPPED;
    627 	if ((newfs->fs_magic != FS_UFS1_MAGIC &&
    628 	     newfs->fs_magic != FS_UFS2_MAGIC)||
    629 	     newfs->fs_bsize > MAXBSIZE ||
    630 	     newfs->fs_bsize < sizeof(struct fs)) {
    631 		brelse(bp, 0);
    632 		free(newfs, M_UFSMNT);
    633 		return (EIO);		/* XXX needs translation */
    634 	}
    635 	/* Store off old fs_sblockloc for fs_oldfscompat_read. */
    636 	sblockloc = fs->fs_sblockloc;
    637 	/*
    638 	 * Copy pointer fields back into superblock before copying in	XXX
    639 	 * new superblock. These should really be in the ufsmount.	XXX
    640 	 * Note that important parameters (eg fs_ncg) are unchanged.
    641 	 */
    642 	newfs->fs_csp = fs->fs_csp;
    643 	newfs->fs_maxcluster = fs->fs_maxcluster;
    644 	newfs->fs_contigdirs = fs->fs_contigdirs;
    645 	newfs->fs_ronly = fs->fs_ronly;
    646 	newfs->fs_active = fs->fs_active;
    647 	memcpy(fs, newfs, (u_int)fs->fs_sbsize);
    648 	brelse(bp, 0);
    649 	free(newfs, M_UFSMNT);
    650 
    651 	/* Recheck for apple UFS filesystem */
    652 	ump->um_flags &= ~UFS_ISAPPLEUFS;
    653 	/* First check to see if this is tagged as an Apple UFS filesystem
    654 	 * in the disklabel
    655 	 */
    656 	if ((VOP_IOCTL(devvp, DIOCGPART, &dpart, FREAD, cred) == 0) &&
    657 		(dpart.part->p_fstype == FS_APPLEUFS)) {
    658 		ump->um_flags |= UFS_ISAPPLEUFS;
    659 	}
    660 #ifdef APPLE_UFS
    661 	else {
    662 		/* Manually look for an apple ufs label, and if a valid one
    663 		 * is found, then treat it like an Apple UFS filesystem anyway
    664 		 */
    665 		error = bread(devvp, (daddr_t)(APPLEUFS_LABEL_OFFSET / DEV_BSIZE),
    666 			APPLEUFS_LABEL_SIZE, cred, 0, &bp);
    667 		if (error) {
    668 			brelse(bp, 0);
    669 			return (error);
    670 		}
    671 		error = ffs_appleufs_validate(fs->fs_fsmnt,
    672 			(struct appleufslabel *)bp->b_data, NULL);
    673 		if (error == 0)
    674 			ump->um_flags |= UFS_ISAPPLEUFS;
    675 		brelse(bp, 0);
    676 		bp = NULL;
    677 	}
    678 #else
    679 	if (ump->um_flags & UFS_ISAPPLEUFS)
    680 		return (EIO);
    681 #endif
    682 
    683 	if (UFS_MPISAPPLEUFS(ump)) {
    684 		/* see comment about NeXT below */
    685 		ump->um_maxsymlinklen = APPLEUFS_MAXSYMLINKLEN;
    686 		ump->um_dirblksiz = APPLEUFS_DIRBLKSIZ;
    687 		mp->mnt_iflag |= IMNT_DTYPE;
    688 	} else {
    689 		ump->um_maxsymlinklen = fs->fs_maxsymlinklen;
    690 		ump->um_dirblksiz = DIRBLKSIZ;
    691 		if (ump->um_maxsymlinklen > 0)
    692 			mp->mnt_iflag |= IMNT_DTYPE;
    693 		else
    694 			mp->mnt_iflag &= ~IMNT_DTYPE;
    695 	}
    696 	ffs_oldfscompat_read(fs, ump, sblockloc);
    697 
    698 	mutex_enter(&ump->um_lock);
    699 	ump->um_maxfilesize = fs->fs_maxfilesize;
    700 	if (fs->fs_flags & ~(FS_KNOWN_FLAGS | FS_INTERNAL)) {
    701 		uprintf("%s: unknown ufs flags: 0x%08"PRIx32"%s\n",
    702 		    mp->mnt_stat.f_mntonname, fs->fs_flags,
    703 		    (mp->mnt_flag & MNT_FORCE) ? "" : ", not mounting");
    704 		if ((mp->mnt_flag & MNT_FORCE) == 0) {
    705 			mutex_exit(&ump->um_lock);
    706 			return (EINVAL);
    707 		}
    708 	}
    709 	if (fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) {
    710 		fs->fs_pendingblocks = 0;
    711 		fs->fs_pendinginodes = 0;
    712 	}
    713 	mutex_exit(&ump->um_lock);
    714 
    715 	ffs_statvfs(mp, &mp->mnt_stat);
    716 	/*
    717 	 * Step 3: re-read summary information from disk.
    718 	 */
    719 	blks = howmany(fs->fs_cssize, fs->fs_fsize);
    720 	space = fs->fs_csp;
    721 	for (i = 0; i < blks; i += fs->fs_frag) {
    722 		bsize = fs->fs_bsize;
    723 		if (i + fs->fs_frag > blks)
    724 			bsize = (blks - i) * fs->fs_fsize;
    725 		error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + i), bsize,
    726 			      NOCRED, 0, &bp);
    727 		if (error) {
    728 			brelse(bp, 0);
    729 			return (error);
    730 		}
    731 #ifdef FFS_EI
    732 		if (UFS_FSNEEDSWAP(fs))
    733 			ffs_csum_swap((struct csum *)bp->b_data,
    734 			    (struct csum *)space, bsize);
    735 		else
    736 #endif
    737 			memcpy(space, bp->b_data, (size_t)bsize);
    738 		space = (char *)space + bsize;
    739 		brelse(bp, 0);
    740 	}
    741 	if (fs->fs_snapinum[0] != 0)
    742 		ffs_snapshot_mount(mp);
    743 	/*
    744 	 * We no longer know anything about clusters per cylinder group.
    745 	 */
    746 	if (fs->fs_contigsumsize > 0) {
    747 		lp = fs->fs_maxcluster;
    748 		for (i = 0; i < fs->fs_ncg; i++)
    749 			*lp++ = fs->fs_contigsumsize;
    750 	}
    751 
    752 	/* Allocate a marker vnode. */
    753 	if ((mvp = vnalloc(mp)) == NULL)
    754 		return ENOMEM;
    755 	/*
    756 	 * NOTE: not using the TAILQ_FOREACH here since in this loop vgone()
    757 	 * and vclean() can be called indirectly
    758 	 */
    759 	mutex_enter(&mntvnode_lock);
    760  loop:
    761 	for (vp = TAILQ_FIRST(&mp->mnt_vnodelist); vp; vp = vunmark(mvp)) {
    762 		vmark(mvp, vp);
    763 		if (vp->v_mount != mp || vismarker(vp))
    764 			continue;
    765 		/*
    766 		 * Step 4: invalidate all inactive vnodes.
    767 		 */
    768 		if (vrecycle(vp, &mntvnode_lock, l)) {
    769 			mutex_enter(&mntvnode_lock);
    770 			(void)vunmark(mvp);
    771 			goto loop;
    772 		}
    773 		/*
    774 		 * Step 5: invalidate all cached file data.
    775 		 */
    776 		mutex_enter(&vp->v_interlock);
    777 		mutex_exit(&mntvnode_lock);
    778 		if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK)) {
    779 			(void)vunmark(mvp);
    780 			goto loop;
    781 		}
    782 		if (vinvalbuf(vp, 0, cred, l, 0, 0))
    783 			panic("ffs_reload: dirty2");
    784 		/*
    785 		 * Step 6: re-read inode data for all active vnodes.
    786 		 */
    787 		ip = VTOI(vp);
    788 		error = bread(devvp, fsbtodb(fs, ino_to_fsba(fs, ip->i_number)),
    789 			      (int)fs->fs_bsize, NOCRED, 0, &bp);
    790 		if (error) {
    791 			brelse(bp, 0);
    792 			vput(vp);
    793 			(void)vunmark(mvp);
    794 			break;
    795 		}
    796 		ffs_load_inode(bp, ip, fs, ip->i_number);
    797 		brelse(bp, 0);
    798 		vput(vp);
    799 		mutex_enter(&mntvnode_lock);
    800 	}
    801 	mutex_exit(&mntvnode_lock);
    802 	vnfree(mvp);
    803 	return (error);
    804 }
    805 
    806 /*
    807  * Possible superblock locations ordered from most to least likely.
    808  */
    809 static const int sblock_try[] = SBLOCKSEARCH;
    810 
    811 /*
    812  * Common code for mount and mountroot
    813  */
    814 int
    815 ffs_mountfs(struct vnode *devvp, struct mount *mp, struct lwp *l)
    816 {
    817 	struct ufsmount *ump;
    818 	struct buf *bp;
    819 	struct fs *fs;
    820 	dev_t dev;
    821 	struct partinfo dpart;
    822 	void *space;
    823 	daddr_t sblockloc, fsblockloc;
    824 	int blks, fstype;
    825 	int error, i, bsize, ronly, bset = 0;
    826 	uint64_t numsecs;
    827 	unsigned secsize;
    828 #ifdef FFS_EI
    829 	int needswap = 0;		/* keep gcc happy */
    830 #endif
    831 	int32_t *lp;
    832 	kauth_cred_t cred;
    833 	u_int32_t sbsize = 8192;	/* keep gcc happy*/
    834 
    835 	dev = devvp->v_rdev;
    836 	cred = l ? l->l_cred : NOCRED;
    837 
    838 	/* Flush out any old buffers remaining from a previous use. */
    839 	vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
    840 	error = vinvalbuf(devvp, V_SAVE, cred, l, 0, 0);
    841 	VOP_UNLOCK(devvp, 0);
    842 	if (error)
    843 		return (error);
    844 
    845 	ronly = (mp->mnt_flag & MNT_RDONLY) != 0;
    846 	error = getdisksize(devvp, &numsecs, &secsize);
    847 	if (error)
    848 		return (error);
    849 
    850 	bp = NULL;
    851 	ump = NULL;
    852 	fs = NULL;
    853 	sblockloc = 0;
    854 	fstype = 0;
    855 
    856 	error = fstrans_mount(mp);
    857 	if (error)
    858 		return error;
    859 
    860 	ump = malloc(sizeof *ump, M_UFSMNT, M_WAITOK);
    861 	memset(ump, 0, sizeof *ump);
    862 	mutex_init(&ump->um_lock, MUTEX_DEFAULT, IPL_NONE);
    863 	error = ffs_snapshot_init(ump);
    864 	if (error)
    865 		goto out;
    866 	ump->um_ops = &ffs_ufsops;
    867 
    868 #ifdef WAPBL
    869  sbagain:
    870 #endif
    871 	/*
    872 	 * Try reading the superblock in each of its possible locations.
    873 	 */
    874 	for (i = 0; ; i++) {
    875 		if (bp != NULL) {
    876 			brelse(bp, BC_NOCACHE);
    877 			bp = NULL;
    878 		}
    879 		if (sblock_try[i] == -1) {
    880 			error = EINVAL;
    881 			fs = NULL;
    882 			goto out;
    883 		}
    884 		error = bread(devvp, sblock_try[i] / DEV_BSIZE, SBLOCKSIZE, cred,
    885 			      0, &bp);
    886 		if (error) {
    887 			fs = NULL;
    888 			goto out;
    889 		}
    890 		fs = (struct fs*)bp->b_data;
    891 		fsblockloc = sblockloc = sblock_try[i];
    892 		if (fs->fs_magic == FS_UFS1_MAGIC) {
    893 			sbsize = fs->fs_sbsize;
    894 			fstype = UFS1;
    895 #ifdef FFS_EI
    896 			needswap = 0;
    897 		} else if (fs->fs_magic == bswap32(FS_UFS1_MAGIC)) {
    898 			sbsize = bswap32(fs->fs_sbsize);
    899 			fstype = UFS1;
    900 			needswap = 1;
    901 #endif
    902 		} else if (fs->fs_magic == FS_UFS2_MAGIC) {
    903 			sbsize = fs->fs_sbsize;
    904 			fstype = UFS2;
    905 #ifdef FFS_EI
    906 			needswap = 0;
    907 		} else if (fs->fs_magic == bswap32(FS_UFS2_MAGIC)) {
    908 			sbsize = bswap32(fs->fs_sbsize);
    909 			fstype = UFS2;
    910 			needswap = 1;
    911 #endif
    912 		} else
    913 			continue;
    914 
    915 
    916 		/* fs->fs_sblockloc isn't defined for old filesystems */
    917 		if (fstype == UFS1 && !(fs->fs_old_flags & FS_FLAGS_UPDATED)) {
    918 			if (sblockloc == SBLOCK_UFS2)
    919 				/*
    920 				 * This is likely to be the first alternate
    921 				 * in a filesystem with 64k blocks.
    922 				 * Don't use it.
    923 				 */
    924 				continue;
    925 			fsblockloc = sblockloc;
    926 		} else {
    927 			fsblockloc = fs->fs_sblockloc;
    928 #ifdef FFS_EI
    929 			if (needswap)
    930 				fsblockloc = bswap64(fsblockloc);
    931 #endif
    932 		}
    933 
    934 		/* Check we haven't found an alternate superblock */
    935 		if (fsblockloc != sblockloc)
    936 			continue;
    937 
    938 		/* Validate size of superblock */
    939 		if (sbsize > MAXBSIZE || sbsize < sizeof(struct fs))
    940 			continue;
    941 
    942 		/* Ok seems to be a good superblock */
    943 		break;
    944 	}
    945 
    946 	fs = malloc((u_long)sbsize, M_UFSMNT, M_WAITOK);
    947 	memcpy(fs, bp->b_data, sbsize);
    948 	ump->um_fs = fs;
    949 
    950 #ifdef FFS_EI
    951 	if (needswap) {
    952 		ffs_sb_swap((struct fs*)bp->b_data, fs);
    953 		fs->fs_flags |= FS_SWAPPED;
    954 	} else
    955 #endif
    956 		fs->fs_flags &= ~FS_SWAPPED;
    957 
    958 #ifdef WAPBL
    959 	if ((mp->mnt_wapbl_replay == 0) && (fs->fs_flags & FS_DOWAPBL)) {
    960 		error = ffs_wapbl_replay_start(mp, fs, devvp);
    961 		if (error && (mp->mnt_flag & MNT_FORCE) == 0)
    962 			goto out;
    963 		if (!error) {
    964 			if (!ronly) {
    965 				/* XXX fsmnt may be stale. */
    966 				printf("%s: replaying log to disk\n",
    967 				    fs->fs_fsmnt);
    968 				error = wapbl_replay_write(mp->mnt_wapbl_replay,
    969 				    devvp);
    970 				if (error)
    971 					goto out;
    972 				wapbl_replay_stop(mp->mnt_wapbl_replay);
    973 				fs->fs_clean = FS_WASCLEAN;
    974 			} else {
    975 				/* XXX fsmnt may be stale */
    976 				printf("%s: replaying log to memory\n",
    977 				    fs->fs_fsmnt);
    978 			}
    979 
    980 			/* Force a re-read of the superblock */
    981 			brelse(bp, BC_INVAL);
    982 			bp = NULL;
    983 			free(fs, M_UFSMNT);
    984 			fs = NULL;
    985 			goto sbagain;
    986 		}
    987 	}
    988 #else /* !WAPBL */
    989 	if ((fs->fs_flags & FS_DOWAPBL) && (mp->mnt_flag & MNT_FORCE) == 0) {
    990 		error = EPERM;
    991 		goto out;
    992 	}
    993 #endif /* !WAPBL */
    994 
    995 	ffs_oldfscompat_read(fs, ump, sblockloc);
    996 	ump->um_maxfilesize = fs->fs_maxfilesize;
    997 
    998 	if (fs->fs_flags & ~(FS_KNOWN_FLAGS | FS_INTERNAL)) {
    999 		uprintf("%s: unknown ufs flags: 0x%08"PRIx32"%s\n",
   1000 		    mp->mnt_stat.f_mntonname, fs->fs_flags,
   1001 		    (mp->mnt_flag & MNT_FORCE) ? "" : ", not mounting");
   1002 		if ((mp->mnt_flag & MNT_FORCE) == 0) {
   1003 			error = EINVAL;
   1004 			goto out;
   1005 		}
   1006 	}
   1007 
   1008 	if (fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) {
   1009 		fs->fs_pendingblocks = 0;
   1010 		fs->fs_pendinginodes = 0;
   1011 	}
   1012 
   1013 	ump->um_fstype = fstype;
   1014 	if (fs->fs_sbsize < SBLOCKSIZE)
   1015 		brelse(bp, BC_INVAL);
   1016 	else
   1017 		brelse(bp, 0);
   1018 	bp = NULL;
   1019 
   1020 	/* First check to see if this is tagged as an Apple UFS filesystem
   1021 	 * in the disklabel
   1022 	 */
   1023 	if ((VOP_IOCTL(devvp, DIOCGPART, &dpart, FREAD, cred) == 0) &&
   1024 		(dpart.part->p_fstype == FS_APPLEUFS)) {
   1025 		ump->um_flags |= UFS_ISAPPLEUFS;
   1026 	}
   1027 #ifdef APPLE_UFS
   1028 	else {
   1029 		/* Manually look for an apple ufs label, and if a valid one
   1030 		 * is found, then treat it like an Apple UFS filesystem anyway
   1031 		 */
   1032 		error = bread(devvp, (daddr_t)(APPLEUFS_LABEL_OFFSET / DEV_BSIZE),
   1033 			APPLEUFS_LABEL_SIZE, cred, 0, &bp);
   1034 		if (error)
   1035 			goto out;
   1036 		error = ffs_appleufs_validate(fs->fs_fsmnt,
   1037 			(struct appleufslabel *)bp->b_data, NULL);
   1038 		if (error == 0) {
   1039 			ump->um_flags |= UFS_ISAPPLEUFS;
   1040 		}
   1041 		brelse(bp, 0);
   1042 		bp = NULL;
   1043 	}
   1044 #else
   1045 	if (ump->um_flags & UFS_ISAPPLEUFS) {
   1046 		error = EINVAL;
   1047 		goto out;
   1048 	}
   1049 #endif
   1050 
   1051 #if 0
   1052 /*
   1053  * XXX This code changes the behaviour of mounting dirty filesystems, to
   1054  * XXX require "mount -f ..." to mount them.  This doesn't match what
   1055  * XXX mount(8) describes and is disabled for now.
   1056  */
   1057 	/*
   1058 	 * If the file system is not clean, don't allow it to be mounted
   1059 	 * unless MNT_FORCE is specified.  (Note: MNT_FORCE is always set
   1060 	 * for the root file system.)
   1061 	 */
   1062 	if (fs->fs_flags & FS_DOWAPBL) {
   1063 		/*
   1064 		 * wapbl normally expects to be FS_WASCLEAN when the FS_DOWAPBL
   1065 		 * bit is set, although there's a window in unmount where it
   1066 		 * could be FS_ISCLEAN
   1067 		 */
   1068 		if ((mp->mnt_flag & MNT_FORCE) == 0 &&
   1069 		    (fs->fs_clean & (FS_WASCLEAN | FS_ISCLEAN)) == 0) {
   1070 			error = EPERM;
   1071 			goto out;
   1072 		}
   1073 	} else
   1074 		if ((fs->fs_clean & FS_ISCLEAN) == 0 &&
   1075 		    (mp->mnt_flag & MNT_FORCE) == 0) {
   1076 			error = EPERM;
   1077 			goto out;
   1078 		}
   1079 #endif
   1080 
   1081 	/*
   1082 	 * verify that we can access the last block in the fs
   1083 	 * if we're mounting read/write.
   1084 	 */
   1085 
   1086 	if (!ronly) {
   1087 		error = bread(devvp, fsbtodb(fs, fs->fs_size - 1), fs->fs_fsize,
   1088 		    cred, 0, &bp);
   1089 		if (bp->b_bcount != fs->fs_fsize)
   1090 			error = EINVAL;
   1091 		if (error) {
   1092 			bset = BC_INVAL;
   1093 			goto out;
   1094 		}
   1095 		brelse(bp, BC_INVAL);
   1096 		bp = NULL;
   1097 	}
   1098 
   1099 	fs->fs_ronly = ronly;
   1100 	/* Don't bump fs_clean if we're replaying journal */
   1101 	if (!((fs->fs_flags & FS_DOWAPBL) && (fs->fs_clean & FS_WASCLEAN)))
   1102 		if (ronly == 0) {
   1103 			fs->fs_clean <<= 1;
   1104 			fs->fs_fmod = 1;
   1105 		}
   1106 	bsize = fs->fs_cssize;
   1107 	blks = howmany(bsize, fs->fs_fsize);
   1108 	if (fs->fs_contigsumsize > 0)
   1109 		bsize += fs->fs_ncg * sizeof(int32_t);
   1110 	bsize += fs->fs_ncg * sizeof(*fs->fs_contigdirs);
   1111 	space = malloc((u_long)bsize, M_UFSMNT, M_WAITOK);
   1112 	fs->fs_csp = space;
   1113 	for (i = 0; i < blks; i += fs->fs_frag) {
   1114 		bsize = fs->fs_bsize;
   1115 		if (i + fs->fs_frag > blks)
   1116 			bsize = (blks - i) * fs->fs_fsize;
   1117 		error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + i), bsize,
   1118 			      cred, 0, &bp);
   1119 		if (error) {
   1120 			free(fs->fs_csp, M_UFSMNT);
   1121 			goto out;
   1122 		}
   1123 #ifdef FFS_EI
   1124 		if (needswap)
   1125 			ffs_csum_swap((struct csum *)bp->b_data,
   1126 				(struct csum *)space, bsize);
   1127 		else
   1128 #endif
   1129 			memcpy(space, bp->b_data, (u_int)bsize);
   1130 
   1131 		space = (char *)space + bsize;
   1132 		brelse(bp, 0);
   1133 		bp = NULL;
   1134 	}
   1135 	if (fs->fs_contigsumsize > 0) {
   1136 		fs->fs_maxcluster = lp = space;
   1137 		for (i = 0; i < fs->fs_ncg; i++)
   1138 			*lp++ = fs->fs_contigsumsize;
   1139 		space = lp;
   1140 	}
   1141 	bsize = fs->fs_ncg * sizeof(*fs->fs_contigdirs);
   1142 	fs->fs_contigdirs = space;
   1143 	space = (char *)space + bsize;
   1144 	memset(fs->fs_contigdirs, 0, bsize);
   1145 		/* Compatibility for old filesystems - XXX */
   1146 	if (fs->fs_avgfilesize <= 0)
   1147 		fs->fs_avgfilesize = AVFILESIZ;
   1148 	if (fs->fs_avgfpdir <= 0)
   1149 		fs->fs_avgfpdir = AFPDIR;
   1150 	fs->fs_active = NULL;
   1151 	mp->mnt_data = ump;
   1152 	mp->mnt_stat.f_fsidx.__fsid_val[0] = (long)dev;
   1153 	mp->mnt_stat.f_fsidx.__fsid_val[1] = makefstype(MOUNT_FFS);
   1154 	mp->mnt_stat.f_fsid = mp->mnt_stat.f_fsidx.__fsid_val[0];
   1155 	mp->mnt_stat.f_namemax = FFS_MAXNAMLEN;
   1156 	if (UFS_MPISAPPLEUFS(ump)) {
   1157 		/* NeXT used to keep short symlinks in the inode even
   1158 		 * when using FS_42INODEFMT.  In that case fs->fs_maxsymlinklen
   1159 		 * is probably -1, but we still need to be able to identify
   1160 		 * short symlinks.
   1161 		 */
   1162 		ump->um_maxsymlinklen = APPLEUFS_MAXSYMLINKLEN;
   1163 		ump->um_dirblksiz = APPLEUFS_DIRBLKSIZ;
   1164 		mp->mnt_iflag |= IMNT_DTYPE;
   1165 	} else {
   1166 		ump->um_maxsymlinklen = fs->fs_maxsymlinklen;
   1167 		ump->um_dirblksiz = DIRBLKSIZ;
   1168 		if (ump->um_maxsymlinklen > 0)
   1169 			mp->mnt_iflag |= IMNT_DTYPE;
   1170 		else
   1171 			mp->mnt_iflag &= ~IMNT_DTYPE;
   1172 	}
   1173 	mp->mnt_fs_bshift = fs->fs_bshift;
   1174 	mp->mnt_dev_bshift = DEV_BSHIFT;	/* XXX */
   1175 	mp->mnt_flag |= MNT_LOCAL;
   1176 	mp->mnt_iflag |= IMNT_MPSAFE;
   1177 #ifdef XIP
   1178 	paddr_t phys_addr = 0;
   1179 	if (mp->mnt_flag & MNT_XIP) {
   1180 		if ((mp->mnt_flag & MNT_RDONLY) == 0)
   1181 			printf("XIP needs read-only mount\n");
   1182 		else {
   1183 			if ((VOP_IOCTL(devvp, DIOCGPHYSADDR, &phys_addr, FREAD,
   1184 			    cred) == 0) &&
   1185 			    phys_addr != 0) {
   1186 				mp->mnt_iflag |= IMNT_XIP;
   1187 				devvp->v_phys_addr = phys_addr;	/* XXX */
   1188 			} else
   1189 				printf("device doesn't support DIOCGPHYSADDR\n");
   1190 		}
   1191 	}
   1192 #endif
   1193 #ifdef FFS_EI
   1194 	if (needswap)
   1195 		ump->um_flags |= UFS_NEEDSWAP;
   1196 #endif
   1197 	ump->um_mountp = mp;
   1198 	ump->um_dev = dev;
   1199 	ump->um_devvp = devvp;
   1200 	ump->um_nindir = fs->fs_nindir;
   1201 	ump->um_lognindir = ffs(fs->fs_nindir) - 1;
   1202 	ump->um_bptrtodb = fs->fs_fshift - DEV_BSHIFT;
   1203 	ump->um_seqinc = fs->fs_frag;
   1204 	for (i = 0; i < MAXQUOTAS; i++)
   1205 		ump->um_quotas[i] = NULLVP;
   1206 	devvp->v_specmountpoint = mp;
   1207 	if (ronly == 0 && fs->fs_snapinum[0] != 0)
   1208 		ffs_snapshot_mount(mp);
   1209 
   1210 #ifdef WAPBL
   1211 	if (!ronly) {
   1212 		KDASSERT(fs->fs_ronly == 0);
   1213 		/*
   1214 		 * ffs_wapbl_start() needs mp->mnt_stat initialised if it
   1215 		 * needs to create a new log file in-filesystem.
   1216 		 */
   1217 		ffs_statvfs(mp, &mp->mnt_stat);
   1218 
   1219 		error = ffs_wapbl_start(mp);
   1220 		if (error) {
   1221 			free(fs->fs_csp, M_UFSMNT);
   1222 			goto out;
   1223 		}
   1224 	}
   1225 #endif /* WAPBL */
   1226 #ifdef UFS_EXTATTR
   1227 	/*
   1228 	 * Initialize file-backed extended attributes on UFS1 file
   1229 	 * systems.
   1230 	 */
   1231 	if (ump->um_fstype == UFS1) {
   1232 		ufs_extattr_uepm_init(&ump->um_extattr);
   1233 #ifdef UFS_EXTATTR_AUTOSTART
   1234 		/*
   1235 		 * XXX Just ignore errors.  Not clear that we should
   1236 		 * XXX fail the mount in this case.
   1237 		 */
   1238 		(void) ufs_extattr_autostart(mp, l);
   1239 #endif
   1240 	}
   1241 #endif /* UFS_EXTATTR */
   1242 	return (0);
   1243 out:
   1244 #ifdef WAPBL
   1245 	if (mp->mnt_wapbl_replay) {
   1246 		wapbl_replay_stop(mp->mnt_wapbl_replay);
   1247 		wapbl_replay_free(mp->mnt_wapbl_replay);
   1248 		mp->mnt_wapbl_replay = 0;
   1249 	}
   1250 #endif
   1251 
   1252 	fstrans_unmount(mp);
   1253 	if (fs)
   1254 		free(fs, M_UFSMNT);
   1255 	devvp->v_specmountpoint = NULL;
   1256 	if (bp)
   1257 		brelse(bp, bset);
   1258 	if (ump) {
   1259 		if (ump->um_oldfscompat)
   1260 			free(ump->um_oldfscompat, M_UFSMNT);
   1261 		mutex_destroy(&ump->um_lock);
   1262 		free(ump, M_UFSMNT);
   1263 		mp->mnt_data = NULL;
   1264 	}
   1265 	return (error);
   1266 }
   1267 
   1268 /*
   1269  * Sanity checks for loading old filesystem superblocks.
   1270  * See ffs_oldfscompat_write below for unwound actions.
   1271  *
   1272  * XXX - Parts get retired eventually.
   1273  * Unfortunately new bits get added.
   1274  */
   1275 static void
   1276 ffs_oldfscompat_read(struct fs *fs, struct ufsmount *ump, daddr_t sblockloc)
   1277 {
   1278 	off_t maxfilesize;
   1279 	int32_t *extrasave;
   1280 
   1281 	if ((fs->fs_magic != FS_UFS1_MAGIC) ||
   1282 	    (fs->fs_old_flags & FS_FLAGS_UPDATED))
   1283 		return;
   1284 
   1285 	if (!ump->um_oldfscompat)
   1286 		ump->um_oldfscompat = malloc(512 + 3*sizeof(int32_t),
   1287 		    M_UFSMNT, M_WAITOK);
   1288 
   1289 	memcpy(ump->um_oldfscompat, &fs->fs_old_postbl_start, 512);
   1290 	extrasave = ump->um_oldfscompat;
   1291 	extrasave += 512/sizeof(int32_t);
   1292 	extrasave[0] = fs->fs_old_npsect;
   1293 	extrasave[1] = fs->fs_old_interleave;
   1294 	extrasave[2] = fs->fs_old_trackskew;
   1295 
   1296 	/* These fields will be overwritten by their
   1297 	 * original values in fs_oldfscompat_write, so it is harmless
   1298 	 * to modify them here.
   1299 	 */
   1300 	fs->fs_cstotal.cs_ndir = fs->fs_old_cstotal.cs_ndir;
   1301 	fs->fs_cstotal.cs_nbfree = fs->fs_old_cstotal.cs_nbfree;
   1302 	fs->fs_cstotal.cs_nifree = fs->fs_old_cstotal.cs_nifree;
   1303 	fs->fs_cstotal.cs_nffree = fs->fs_old_cstotal.cs_nffree;
   1304 
   1305 	fs->fs_maxbsize = fs->fs_bsize;
   1306 	fs->fs_time = fs->fs_old_time;
   1307 	fs->fs_size = fs->fs_old_size;
   1308 	fs->fs_dsize = fs->fs_old_dsize;
   1309 	fs->fs_csaddr = fs->fs_old_csaddr;
   1310 	fs->fs_sblockloc = sblockloc;
   1311 
   1312 	fs->fs_flags = fs->fs_old_flags | (fs->fs_flags & FS_INTERNAL);
   1313 
   1314 	if (fs->fs_old_postblformat == FS_42POSTBLFMT) {
   1315 		fs->fs_old_nrpos = 8;
   1316 		fs->fs_old_npsect = fs->fs_old_nsect;
   1317 		fs->fs_old_interleave = 1;
   1318 		fs->fs_old_trackskew = 0;
   1319 	}
   1320 
   1321 	if (fs->fs_old_inodefmt < FS_44INODEFMT) {
   1322 		fs->fs_maxfilesize = (u_quad_t) 1LL << 39;
   1323 		fs->fs_qbmask = ~fs->fs_bmask;
   1324 		fs->fs_qfmask = ~fs->fs_fmask;
   1325 	}
   1326 
   1327 	maxfilesize = (u_int64_t)0x80000000 * fs->fs_bsize - 1;
   1328 	if (fs->fs_maxfilesize > maxfilesize)
   1329 		fs->fs_maxfilesize = maxfilesize;
   1330 
   1331 	/* Compatibility for old filesystems */
   1332 	if (fs->fs_avgfilesize <= 0)
   1333 		fs->fs_avgfilesize = AVFILESIZ;
   1334 	if (fs->fs_avgfpdir <= 0)
   1335 		fs->fs_avgfpdir = AFPDIR;
   1336 
   1337 #if 0
   1338 	if (bigcgs) {
   1339 		fs->fs_save_cgsize = fs->fs_cgsize;
   1340 		fs->fs_cgsize = fs->fs_bsize;
   1341 	}
   1342 #endif
   1343 }
   1344 
   1345 /*
   1346  * Unwinding superblock updates for old filesystems.
   1347  * See ffs_oldfscompat_read above for details.
   1348  *
   1349  * XXX - Parts get retired eventually.
   1350  * Unfortunately new bits get added.
   1351  */
   1352 static void
   1353 ffs_oldfscompat_write(struct fs *fs, struct ufsmount *ump)
   1354 {
   1355 	int32_t *extrasave;
   1356 
   1357 	if ((fs->fs_magic != FS_UFS1_MAGIC) ||
   1358 	    (fs->fs_old_flags & FS_FLAGS_UPDATED))
   1359 		return;
   1360 
   1361 	fs->fs_old_time = fs->fs_time;
   1362 	fs->fs_old_cstotal.cs_ndir = fs->fs_cstotal.cs_ndir;
   1363 	fs->fs_old_cstotal.cs_nbfree = fs->fs_cstotal.cs_nbfree;
   1364 	fs->fs_old_cstotal.cs_nifree = fs->fs_cstotal.cs_nifree;
   1365 	fs->fs_old_cstotal.cs_nffree = fs->fs_cstotal.cs_nffree;
   1366 	fs->fs_old_flags = fs->fs_flags;
   1367 
   1368 #if 0
   1369 	if (bigcgs) {
   1370 		fs->fs_cgsize = fs->fs_save_cgsize;
   1371 	}
   1372 #endif
   1373 
   1374 	memcpy(&fs->fs_old_postbl_start, ump->um_oldfscompat, 512);
   1375 	extrasave = ump->um_oldfscompat;
   1376 	extrasave += 512/sizeof(int32_t);
   1377 	fs->fs_old_npsect = extrasave[0];
   1378 	fs->fs_old_interleave = extrasave[1];
   1379 	fs->fs_old_trackskew = extrasave[2];
   1380 
   1381 }
   1382 
   1383 /*
   1384  * unmount vfs operation
   1385  */
   1386 int
   1387 ffs_unmount(struct mount *mp, int mntflags)
   1388 {
   1389 	struct lwp *l = curlwp;
   1390 	struct ufsmount *ump = VFSTOUFS(mp);
   1391 	struct fs *fs = ump->um_fs;
   1392 	int error, flags;
   1393 #ifdef WAPBL
   1394 	extern int doforce;
   1395 #endif
   1396 
   1397 	flags = 0;
   1398 	if (mntflags & MNT_FORCE)
   1399 		flags |= FORCECLOSE;
   1400 	if ((error = ffs_flushfiles(mp, flags, l)) != 0)
   1401 		return (error);
   1402 	error = UFS_WAPBL_BEGIN(mp);
   1403 	if (error == 0)
   1404 		if (fs->fs_ronly == 0 &&
   1405 		    ffs_cgupdate(ump, MNT_WAIT) == 0 &&
   1406 		    fs->fs_clean & FS_WASCLEAN) {
   1407 			fs->fs_clean = FS_ISCLEAN;
   1408 			fs->fs_fmod = 0;
   1409 			(void) ffs_sbupdate(ump, MNT_WAIT);
   1410 		}
   1411 	if (error == 0)
   1412 		UFS_WAPBL_END(mp);
   1413 #ifdef WAPBL
   1414 	KASSERT(!(mp->mnt_wapbl_replay && mp->mnt_wapbl));
   1415 	if (mp->mnt_wapbl_replay) {
   1416 		KDASSERT(fs->fs_ronly);
   1417 		wapbl_replay_stop(mp->mnt_wapbl_replay);
   1418 		wapbl_replay_free(mp->mnt_wapbl_replay);
   1419 		mp->mnt_wapbl_replay = 0;
   1420 	}
   1421 	error = ffs_wapbl_stop(mp, doforce && (mntflags & MNT_FORCE));
   1422 	if (error) {
   1423 		return error;
   1424 	}
   1425 #endif /* WAPBL */
   1426 #ifdef UFS_EXTATTR
   1427 	if (ump->um_fstype == UFS1) {
   1428 		ufs_extattr_stop(mp, l);
   1429 		ufs_extattr_uepm_destroy(&ump->um_extattr);
   1430 	}
   1431 #endif /* UFS_EXTATTR */
   1432 
   1433 	if (ump->um_devvp->v_type != VBAD)
   1434 		ump->um_devvp->v_specmountpoint = NULL;
   1435 	vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY);
   1436 	(void)VOP_CLOSE(ump->um_devvp, fs->fs_ronly ? FREAD : FREAD | FWRITE,
   1437 		NOCRED);
   1438 	vput(ump->um_devvp);
   1439 	free(fs->fs_csp, M_UFSMNT);
   1440 	free(fs, M_UFSMNT);
   1441 	if (ump->um_oldfscompat != NULL)
   1442 		free(ump->um_oldfscompat, M_UFSMNT);
   1443 	mutex_destroy(&ump->um_lock);
   1444 	ffs_snapshot_fini(ump);
   1445 	free(ump, M_UFSMNT);
   1446 	mp->mnt_data = NULL;
   1447 	mp->mnt_flag &= ~MNT_LOCAL;
   1448 	fstrans_unmount(mp);
   1449 	return (0);
   1450 }
   1451 
   1452 /*
   1453  * Flush out all the files in a filesystem.
   1454  */
   1455 int
   1456 ffs_flushfiles(struct mount *mp, int flags, struct lwp *l)
   1457 {
   1458 	extern int doforce;
   1459 	struct ufsmount *ump;
   1460 	int error;
   1461 
   1462 	if (!doforce)
   1463 		flags &= ~FORCECLOSE;
   1464 	ump = VFSTOUFS(mp);
   1465 #ifdef QUOTA
   1466 	if (mp->mnt_flag & MNT_QUOTA) {
   1467 		int i;
   1468 		if ((error = vflush(mp, NULLVP, SKIPSYSTEM | flags)) != 0)
   1469 			return (error);
   1470 		for (i = 0; i < MAXQUOTAS; i++) {
   1471 			if (ump->um_quotas[i] == NULLVP)
   1472 				continue;
   1473 			quotaoff(l, mp, i);
   1474 		}
   1475 		/*
   1476 		 * Here we fall through to vflush again to ensure
   1477 		 * that we have gotten rid of all the system vnodes.
   1478 		 */
   1479 	}
   1480 #endif
   1481 	if ((error = vflush(mp, 0, SKIPSYSTEM | flags)) != 0)
   1482 		return (error);
   1483 	ffs_snapshot_unmount(mp);
   1484 	/*
   1485 	 * Flush all the files.
   1486 	 */
   1487 	error = vflush(mp, NULLVP, flags);
   1488 	if (error)
   1489 		return (error);
   1490 	/*
   1491 	 * Flush filesystem metadata.
   1492 	 */
   1493 	vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY);
   1494 	error = VOP_FSYNC(ump->um_devvp, l->l_cred, FSYNC_WAIT, 0, 0);
   1495 	VOP_UNLOCK(ump->um_devvp, 0);
   1496 	if (flags & FORCECLOSE) /* XXXDBJ */
   1497 		error = 0;
   1498 
   1499 #ifdef WAPBL
   1500 	if (error)
   1501 		return error;
   1502 	if (mp->mnt_wapbl) {
   1503 		error = wapbl_flush(mp->mnt_wapbl, 1);
   1504 		if (flags & FORCECLOSE)
   1505 			error = 0;
   1506 	}
   1507 #endif
   1508 
   1509 	return (error);
   1510 }
   1511 
   1512 /*
   1513  * Get file system statistics.
   1514  */
   1515 int
   1516 ffs_statvfs(struct mount *mp, struct statvfs *sbp)
   1517 {
   1518 	struct ufsmount *ump;
   1519 	struct fs *fs;
   1520 
   1521 	ump = VFSTOUFS(mp);
   1522 	fs = ump->um_fs;
   1523 	mutex_enter(&ump->um_lock);
   1524 	sbp->f_bsize = fs->fs_bsize;
   1525 	sbp->f_frsize = fs->fs_fsize;
   1526 	sbp->f_iosize = fs->fs_bsize;
   1527 	sbp->f_blocks = fs->fs_dsize;
   1528 	sbp->f_bfree = blkstofrags(fs, fs->fs_cstotal.cs_nbfree) +
   1529 	    fs->fs_cstotal.cs_nffree + dbtofsb(fs, fs->fs_pendingblocks);
   1530 	sbp->f_bresvd = ((u_int64_t) fs->fs_dsize * (u_int64_t)
   1531 	    fs->fs_minfree) / (u_int64_t) 100;
   1532 	if (sbp->f_bfree > sbp->f_bresvd)
   1533 		sbp->f_bavail = sbp->f_bfree - sbp->f_bresvd;
   1534 	else
   1535 		sbp->f_bavail = 0;
   1536 	sbp->f_files =  fs->fs_ncg * fs->fs_ipg - ROOTINO;
   1537 	sbp->f_ffree = fs->fs_cstotal.cs_nifree + fs->fs_pendinginodes;
   1538 	sbp->f_favail = sbp->f_ffree;
   1539 	sbp->f_fresvd = 0;
   1540 	mutex_exit(&ump->um_lock);
   1541 	copy_statvfs_info(sbp, mp);
   1542 
   1543 	return (0);
   1544 }
   1545 
   1546 /*
   1547  * Go through the disk queues to initiate sandbagged IO;
   1548  * go through the inodes to write those that have been modified;
   1549  * initiate the writing of the super block if it has been modified.
   1550  *
   1551  * Note: we are always called with the filesystem marked `MPBUSY'.
   1552  */
   1553 int
   1554 ffs_sync(struct mount *mp, int waitfor, kauth_cred_t cred)
   1555 {
   1556 	struct vnode *vp, *mvp, *nvp;
   1557 	struct inode *ip;
   1558 	struct ufsmount *ump = VFSTOUFS(mp);
   1559 	struct fs *fs;
   1560 	int lk_flags, error, allerror = 0;
   1561 	bool is_suspending;
   1562 
   1563 	fs = ump->um_fs;
   1564 	if (fs->fs_fmod != 0 && fs->fs_ronly != 0) {		/* XXX */
   1565 		printf("fs = %s\n", fs->fs_fsmnt);
   1566 		panic("update: rofs mod");
   1567 	}
   1568 
   1569 	/* Allocate a marker vnode. */
   1570 	if ((mvp = vnalloc(mp)) == NULL)
   1571 		return (ENOMEM);
   1572 
   1573 	fstrans_start(mp, FSTRANS_SHARED);
   1574 	is_suspending = (fstrans_getstate(mp) == FSTRANS_SUSPENDING);
   1575 	/*
   1576 	 * We can't lock vnodes while the file system is suspending because
   1577 	 * threads waiting on fstrans may have locked vnodes.
   1578 	 */
   1579 	if (is_suspending)
   1580 		lk_flags = LK_INTERLOCK;
   1581 	else
   1582 		lk_flags = LK_EXCLUSIVE | LK_NOWAIT | LK_INTERLOCK;
   1583 	/*
   1584 	 * Write back each (modified) inode.
   1585 	 */
   1586 	mutex_enter(&mntvnode_lock);
   1587 loop:
   1588 	/*
   1589 	 * NOTE: not using the TAILQ_FOREACH here since in this loop vgone()
   1590 	 * and vclean() can be called indirectly
   1591 	 */
   1592 	for (vp = TAILQ_FIRST(&mp->mnt_vnodelist); vp; vp = nvp) {
   1593 		nvp = TAILQ_NEXT(vp, v_mntvnodes);
   1594 		/*
   1595 		 * If the vnode that we are about to sync is no longer
   1596 		 * associated with this mount point, start over.
   1597 		 */
   1598 		if (vp->v_mount != mp)
   1599 			goto loop;
   1600 		/*
   1601 		 * Don't interfere with concurrent scans of this FS.
   1602 		 */
   1603 		if (vismarker(vp))
   1604 			continue;
   1605 		mutex_enter(&vp->v_interlock);
   1606 		ip = VTOI(vp);
   1607 
   1608 		/*
   1609 		 * Skip the vnode/inode if inaccessible.
   1610 		 */
   1611 		if (ip == NULL || (vp->v_iflag & (VI_XLOCK | VI_CLEAN)) != 0 ||
   1612 		    vp->v_type == VNON) {
   1613 			mutex_exit(&vp->v_interlock);
   1614 			continue;
   1615 		}
   1616 
   1617 		/*
   1618 		 * We deliberately update inode times here.  This will
   1619 		 * prevent a massive queue of updates accumulating, only
   1620 		 * to be handled by a call to unmount.
   1621 		 *
   1622 		 * XXX It would be better to have the syncer trickle these
   1623 		 * out.  Adjustment needed to allow registering vnodes for
   1624 		 * sync when the vnode is clean, but the inode dirty.  Or
   1625 		 * have ufs itself trickle out inode updates.
   1626 		 *
   1627 		 * If doing a lazy sync, we don't care about metadata or
   1628 		 * data updates, because they are handled by each vnode's
   1629 		 * synclist entry.  In this case we are only interested in
   1630 		 * writing back modified inodes.
   1631 		 */
   1632 		if ((ip->i_flag & (IN_ACCESS | IN_CHANGE | IN_UPDATE |
   1633 		    IN_MODIFY | IN_MODIFIED | IN_ACCESSED)) == 0 &&
   1634 		    (waitfor == MNT_LAZY || (LIST_EMPTY(&vp->v_dirtyblkhd) &&
   1635 		    UVM_OBJ_IS_CLEAN(&vp->v_uobj)))) {
   1636 			mutex_exit(&vp->v_interlock);
   1637 			continue;
   1638 		}
   1639 		if (vp->v_type == VBLK && is_suspending) {
   1640 			mutex_exit(&vp->v_interlock);
   1641 			continue;
   1642 		}
   1643 		vmark(mvp, vp);
   1644 		mutex_exit(&mntvnode_lock);
   1645 		error = vget(vp, lk_flags);
   1646 		if (error) {
   1647 			mutex_enter(&mntvnode_lock);
   1648 			nvp = vunmark(mvp);
   1649 			if (error == ENOENT) {
   1650 				goto loop;
   1651 			}
   1652 			continue;
   1653 		}
   1654 		if (waitfor == MNT_LAZY) {
   1655 			error = UFS_WAPBL_BEGIN(vp->v_mount);
   1656 			if (!error) {
   1657 				error = ffs_update(vp, NULL, NULL,
   1658 				    UPDATE_CLOSE);
   1659 				UFS_WAPBL_END(vp->v_mount);
   1660 			}
   1661 		} else {
   1662 			error = VOP_FSYNC(vp, cred, FSYNC_NOLOG |
   1663 			    (waitfor == MNT_WAIT ? FSYNC_WAIT : 0), 0, 0);
   1664 		}
   1665 		if (error)
   1666 			allerror = error;
   1667 		if (is_suspending)
   1668 			vrele(vp);
   1669 		else
   1670 			vput(vp);
   1671 		mutex_enter(&mntvnode_lock);
   1672 		nvp = vunmark(mvp);
   1673 	}
   1674 	mutex_exit(&mntvnode_lock);
   1675 	/*
   1676 	 * Force stale file system control information to be flushed.
   1677 	 */
   1678 	if (waitfor != MNT_LAZY && (ump->um_devvp->v_numoutput > 0 ||
   1679 	    !LIST_EMPTY(&ump->um_devvp->v_dirtyblkhd))) {
   1680 		vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY);
   1681 		if ((error = VOP_FSYNC(ump->um_devvp, cred,
   1682 		    (waitfor == MNT_WAIT ? FSYNC_WAIT : 0) | FSYNC_NOLOG,
   1683 		    0, 0)) != 0)
   1684 			allerror = error;
   1685 		VOP_UNLOCK(ump->um_devvp, 0);
   1686 		if (allerror == 0 && waitfor == MNT_WAIT && !mp->mnt_wapbl) {
   1687 			mutex_enter(&mntvnode_lock);
   1688 			goto loop;
   1689 		}
   1690 	}
   1691 #ifdef QUOTA
   1692 	qsync(mp);
   1693 #endif
   1694 	/*
   1695 	 * Write back modified superblock.
   1696 	 */
   1697 	if (fs->fs_fmod != 0) {
   1698 		fs->fs_fmod = 0;
   1699 		fs->fs_time = time_second;
   1700 		error = UFS_WAPBL_BEGIN(mp);
   1701 		if (error)
   1702 			allerror = error;
   1703 		else {
   1704 			if ((error = ffs_cgupdate(ump, waitfor)))
   1705 				allerror = error;
   1706 			UFS_WAPBL_END(mp);
   1707 		}
   1708 	}
   1709 
   1710 #ifdef WAPBL
   1711 	if (mp->mnt_wapbl) {
   1712 		error = wapbl_flush(mp->mnt_wapbl, 0);
   1713 		if (error)
   1714 			allerror = error;
   1715 	}
   1716 #endif
   1717 
   1718 	fstrans_done(mp);
   1719 	vnfree(mvp);
   1720 	return (allerror);
   1721 }
   1722 
   1723 /*
   1724  * Look up a FFS dinode number to find its incore vnode, otherwise read it
   1725  * in from disk.  If it is in core, wait for the lock bit to clear, then
   1726  * return the inode locked.  Detection and handling of mount points must be
   1727  * done by the calling routine.
   1728  */
   1729 int
   1730 ffs_vget(struct mount *mp, ino_t ino, struct vnode **vpp)
   1731 {
   1732 	struct fs *fs;
   1733 	struct inode *ip;
   1734 	struct ufsmount *ump;
   1735 	struct buf *bp;
   1736 	struct vnode *vp;
   1737 	dev_t dev;
   1738 	int error;
   1739 
   1740 	ump = VFSTOUFS(mp);
   1741 	dev = ump->um_dev;
   1742 
   1743  retry:
   1744 	if ((*vpp = ufs_ihashget(dev, ino, LK_EXCLUSIVE)) != NULL)
   1745 		return (0);
   1746 
   1747 	/* Allocate a new vnode/inode. */
   1748 	if ((error = getnewvnode(VT_UFS, mp, ffs_vnodeop_p, &vp)) != 0) {
   1749 		*vpp = NULL;
   1750 		return (error);
   1751 	}
   1752 	ip = pool_cache_get(ffs_inode_cache, PR_WAITOK);
   1753 
   1754 	/*
   1755 	 * If someone beat us to it, put back the freshly allocated
   1756 	 * vnode/inode pair and retry.
   1757 	 */
   1758 	mutex_enter(&ufs_hashlock);
   1759 	if (ufs_ihashget(dev, ino, 0) != NULL) {
   1760 		mutex_exit(&ufs_hashlock);
   1761 		ungetnewvnode(vp);
   1762 		pool_cache_put(ffs_inode_cache, ip);
   1763 		goto retry;
   1764 	}
   1765 
   1766 	vp->v_vflag |= VV_LOCKSWORK;
   1767 
   1768 #ifdef XIP
   1769 	if ((vp->v_mount->mnt_iflag & IMNT_XIP) != 0) {
   1770 		vp->v_vflag |= VV_XIP;
   1771 	}
   1772 #endif
   1773 
   1774 	/*
   1775 	 * XXX MFS ends up here, too, to allocate an inode.  Should we
   1776 	 * XXX create another pool for MFS inodes?
   1777 	 */
   1778 
   1779 	memset(ip, 0, sizeof(struct inode));
   1780 	vp->v_data = ip;
   1781 	ip->i_vnode = vp;
   1782 	ip->i_ump = ump;
   1783 	ip->i_fs = fs = ump->um_fs;
   1784 	ip->i_dev = dev;
   1785 	ip->i_number = ino;
   1786 #ifdef QUOTA
   1787 	ufsquota_init(ip);
   1788 #endif
   1789 
   1790 	/*
   1791 	 * Initialize genfs node, we might proceed to destroy it in
   1792 	 * error branches.
   1793 	 */
   1794 	genfs_node_init(vp, &ffs_genfsops);
   1795 
   1796 	/*
   1797 	 * Put it onto its hash chain and lock it so that other requests for
   1798 	 * this inode will block if they arrive while we are sleeping waiting
   1799 	 * for old data structures to be purged or for the contents of the
   1800 	 * disk portion of this inode to be read.
   1801 	 */
   1802 
   1803 	ufs_ihashins(ip);
   1804 	mutex_exit(&ufs_hashlock);
   1805 
   1806 	/* Read in the disk contents for the inode, copy into the inode. */
   1807 	error = bread(ump->um_devvp, fsbtodb(fs, ino_to_fsba(fs, ino)),
   1808 		      (int)fs->fs_bsize, NOCRED, 0, &bp);
   1809 	if (error) {
   1810 
   1811 		/*
   1812 		 * The inode does not contain anything useful, so it would
   1813 		 * be misleading to leave it on its hash chain. With mode
   1814 		 * still zero, it will be unlinked and returned to the free
   1815 		 * list by vput().
   1816 		 */
   1817 
   1818 		vput(vp);
   1819 		brelse(bp, 0);
   1820 		*vpp = NULL;
   1821 		return (error);
   1822 	}
   1823 	if (ip->i_ump->um_fstype == UFS1)
   1824 		ip->i_din.ffs1_din = pool_cache_get(ffs_dinode1_cache,
   1825 		    PR_WAITOK);
   1826 	else
   1827 		ip->i_din.ffs2_din = pool_cache_get(ffs_dinode2_cache,
   1828 		    PR_WAITOK);
   1829 	ffs_load_inode(bp, ip, fs, ino);
   1830 	brelse(bp, 0);
   1831 
   1832 	/*
   1833 	 * Initialize the vnode from the inode, check for aliases.
   1834 	 * Note that the underlying vnode may have changed.
   1835 	 */
   1836 
   1837 	ufs_vinit(mp, ffs_specop_p, ffs_fifoop_p, &vp);
   1838 
   1839 	/*
   1840 	 * Finish inode initialization now that aliasing has been resolved.
   1841 	 */
   1842 
   1843 	ip->i_devvp = ump->um_devvp;
   1844 	vref(ip->i_devvp);
   1845 
   1846 	/*
   1847 	 * Ensure that uid and gid are correct. This is a temporary
   1848 	 * fix until fsck has been changed to do the update.
   1849 	 */
   1850 
   1851 	if (fs->fs_old_inodefmt < FS_44INODEFMT) {		/* XXX */
   1852 		ip->i_uid = ip->i_ffs1_ouid;			/* XXX */
   1853 		ip->i_gid = ip->i_ffs1_ogid;			/* XXX */
   1854 	}							/* XXX */
   1855 	uvm_vnp_setsize(vp, ip->i_size);
   1856 	*vpp = vp;
   1857 	return (0);
   1858 }
   1859 
   1860 /*
   1861  * File handle to vnode
   1862  *
   1863  * Have to be really careful about stale file handles:
   1864  * - check that the inode number is valid
   1865  * - call ffs_vget() to get the locked inode
   1866  * - check for an unallocated inode (i_mode == 0)
   1867  * - check that the given client host has export rights and return
   1868  *   those rights via. exflagsp and credanonp
   1869  */
   1870 int
   1871 ffs_fhtovp(struct mount *mp, struct fid *fhp, struct vnode **vpp)
   1872 {
   1873 	struct ufid ufh;
   1874 	struct fs *fs;
   1875 
   1876 	if (fhp->fid_len != sizeof(struct ufid))
   1877 		return EINVAL;
   1878 
   1879 	memcpy(&ufh, fhp, sizeof(ufh));
   1880 	fs = VFSTOUFS(mp)->um_fs;
   1881 	if (ufh.ufid_ino < ROOTINO ||
   1882 	    ufh.ufid_ino >= fs->fs_ncg * fs->fs_ipg)
   1883 		return (ESTALE);
   1884 	return (ufs_fhtovp(mp, &ufh, vpp));
   1885 }
   1886 
   1887 /*
   1888  * Vnode pointer to File handle
   1889  */
   1890 /* ARGSUSED */
   1891 int
   1892 ffs_vptofh(struct vnode *vp, struct fid *fhp, size_t *fh_size)
   1893 {
   1894 	struct inode *ip;
   1895 	struct ufid ufh;
   1896 
   1897 	if (*fh_size < sizeof(struct ufid)) {
   1898 		*fh_size = sizeof(struct ufid);
   1899 		return E2BIG;
   1900 	}
   1901 	ip = VTOI(vp);
   1902 	*fh_size = sizeof(struct ufid);
   1903 	memset(&ufh, 0, sizeof(ufh));
   1904 	ufh.ufid_len = sizeof(struct ufid);
   1905 	ufh.ufid_ino = ip->i_number;
   1906 	ufh.ufid_gen = ip->i_gen;
   1907 	memcpy(fhp, &ufh, sizeof(ufh));
   1908 	return (0);
   1909 }
   1910 
   1911 void
   1912 ffs_init(void)
   1913 {
   1914 	if (ffs_initcount++ > 0)
   1915 		return;
   1916 
   1917 	ffs_inode_cache = pool_cache_init(sizeof(struct inode), 0, 0, 0,
   1918 	    "ffsino", NULL, IPL_NONE, NULL, NULL, NULL);
   1919 	ffs_dinode1_cache = pool_cache_init(sizeof(struct ufs1_dinode), 0, 0, 0,
   1920 	    "ffsdino1", NULL, IPL_NONE, NULL, NULL, NULL);
   1921 	ffs_dinode2_cache = pool_cache_init(sizeof(struct ufs2_dinode), 0, 0, 0,
   1922 	    "ffsdino2", NULL, IPL_NONE, NULL, NULL, NULL);
   1923 	ufs_init();
   1924 }
   1925 
   1926 void
   1927 ffs_reinit(void)
   1928 {
   1929 
   1930 	ufs_reinit();
   1931 }
   1932 
   1933 void
   1934 ffs_done(void)
   1935 {
   1936 	if (--ffs_initcount > 0)
   1937 		return;
   1938 
   1939 	ufs_done();
   1940 	pool_cache_destroy(ffs_dinode2_cache);
   1941 	pool_cache_destroy(ffs_dinode1_cache);
   1942 	pool_cache_destroy(ffs_inode_cache);
   1943 }
   1944 
   1945 /*
   1946  * Write a superblock and associated information back to disk.
   1947  */
   1948 int
   1949 ffs_sbupdate(struct ufsmount *mp, int waitfor)
   1950 {
   1951 	struct fs *fs = mp->um_fs;
   1952 	struct buf *bp;
   1953 	int error = 0;
   1954 	u_int32_t saveflag;
   1955 
   1956 	error = ffs_getblk(mp->um_devvp,
   1957 	    fs->fs_sblockloc / DEV_BSIZE, FFS_NOBLK,
   1958 	    fs->fs_sbsize, false, &bp);
   1959 	if (error)
   1960 		return error;
   1961 	saveflag = fs->fs_flags & FS_INTERNAL;
   1962 	fs->fs_flags &= ~FS_INTERNAL;
   1963 
   1964 	memcpy(bp->b_data, fs, fs->fs_sbsize);
   1965 
   1966 	ffs_oldfscompat_write((struct fs *)bp->b_data, mp);
   1967 #ifdef FFS_EI
   1968 	if (mp->um_flags & UFS_NEEDSWAP)
   1969 		ffs_sb_swap((struct fs *)bp->b_data, (struct fs *)bp->b_data);
   1970 #endif
   1971 	fs->fs_flags |= saveflag;
   1972 
   1973 	if (waitfor == MNT_WAIT)
   1974 		error = bwrite(bp);
   1975 	else
   1976 		bawrite(bp);
   1977 	return (error);
   1978 }
   1979 
   1980 int
   1981 ffs_cgupdate(struct ufsmount *mp, int waitfor)
   1982 {
   1983 	struct fs *fs = mp->um_fs;
   1984 	struct buf *bp;
   1985 	int blks;
   1986 	void *space;
   1987 	int i, size, error = 0, allerror = 0;
   1988 
   1989 	allerror = ffs_sbupdate(mp, waitfor);
   1990 	blks = howmany(fs->fs_cssize, fs->fs_fsize);
   1991 	space = fs->fs_csp;
   1992 	for (i = 0; i < blks; i += fs->fs_frag) {
   1993 		size = fs->fs_bsize;
   1994 		if (i + fs->fs_frag > blks)
   1995 			size = (blks - i) * fs->fs_fsize;
   1996 		error = ffs_getblk(mp->um_devvp, fsbtodb(fs, fs->fs_csaddr + i),
   1997 		    FFS_NOBLK, size, false, &bp);
   1998 		if (error)
   1999 			break;
   2000 #ifdef FFS_EI
   2001 		if (mp->um_flags & UFS_NEEDSWAP)
   2002 			ffs_csum_swap((struct csum*)space,
   2003 			    (struct csum*)bp->b_data, size);
   2004 		else
   2005 #endif
   2006 			memcpy(bp->b_data, space, (u_int)size);
   2007 		space = (char *)space + size;
   2008 		if (waitfor == MNT_WAIT)
   2009 			error = bwrite(bp);
   2010 		else
   2011 			bawrite(bp);
   2012 	}
   2013 	if (!allerror && error)
   2014 		allerror = error;
   2015 	return (allerror);
   2016 }
   2017 
   2018 int
   2019 ffs_extattrctl(struct mount *mp, int cmd, struct vnode *vp,
   2020     int attrnamespace, const char *attrname)
   2021 {
   2022 #ifdef UFS_EXTATTR
   2023 	/*
   2024 	 * File-backed extended attributes are only supported on UFS1.
   2025 	 * UFS2 has native extended attributes.
   2026 	 */
   2027 	if (VFSTOUFS(mp)->um_fstype == UFS1)
   2028 		return (ufs_extattrctl(mp, cmd, vp, attrnamespace, attrname));
   2029 #endif
   2030 	return (vfs_stdextattrctl(mp, cmd, vp, attrnamespace, attrname));
   2031 }
   2032 
   2033 int
   2034 ffs_suspendctl(struct mount *mp, int cmd)
   2035 {
   2036 	int error;
   2037 	struct lwp *l = curlwp;
   2038 
   2039 	switch (cmd) {
   2040 	case SUSPEND_SUSPEND:
   2041 		if ((error = fstrans_setstate(mp, FSTRANS_SUSPENDING)) != 0)
   2042 			return error;
   2043 		error = ffs_sync(mp, MNT_WAIT, l->l_proc->p_cred);
   2044 		if (error == 0)
   2045 			error = fstrans_setstate(mp, FSTRANS_SUSPENDED);
   2046 #ifdef WAPBL
   2047 		if (error == 0 && mp->mnt_wapbl)
   2048 			error = wapbl_flush(mp->mnt_wapbl, 1);
   2049 #endif
   2050 		if (error != 0) {
   2051 			(void) fstrans_setstate(mp, FSTRANS_NORMAL);
   2052 			return error;
   2053 		}
   2054 		return 0;
   2055 
   2056 	case SUSPEND_RESUME:
   2057 		return fstrans_setstate(mp, FSTRANS_NORMAL);
   2058 
   2059 	default:
   2060 		return EINVAL;
   2061 	}
   2062 }
   2063 
   2064 /*
   2065  * Synch vnode for a mounted file system.  This is called for foreign
   2066  * vnodes, i.e. non-ffs.
   2067  */
   2068 static int
   2069 ffs_vfs_fsync(vnode_t *vp, int flags)
   2070 {
   2071 	int error, passes, skipmeta, i, pflags;
   2072 	buf_t *bp, *nbp;
   2073 #ifdef WAPBL
   2074 	struct mount *mp;
   2075 #endif
   2076 
   2077 	KASSERT(vp->v_type == VBLK);
   2078 	KASSERT(vp->v_specmountpoint != NULL);
   2079 
   2080 	/*
   2081 	 * Flush all dirty data associated with the vnode.
   2082 	 */
   2083 	pflags = PGO_ALLPAGES | PGO_CLEANIT;
   2084 	if ((flags & FSYNC_WAIT) != 0)
   2085 		pflags |= PGO_SYNCIO;
   2086 	mutex_enter(&vp->v_interlock);
   2087 	error = VOP_PUTPAGES(vp, 0, 0, pflags);
   2088 	if (error)
   2089 		return error;
   2090 
   2091 #ifdef WAPBL
   2092 	mp = vp->v_specmountpoint;
   2093 	if (mp && mp->mnt_wapbl) {
   2094 		/*
   2095 		 * Don't bother writing out metadata if the syncer is
   2096 		 * making the request.  We will let the sync vnode
   2097 		 * write it out in a single burst through a call to
   2098 		 * VFS_SYNC().
   2099 		 */
   2100 		if ((flags & (FSYNC_DATAONLY | FSYNC_LAZY | FSYNC_NOLOG)) != 0)
   2101 			return 0;
   2102 
   2103 		/*
   2104 		 * Don't flush the log if the vnode being flushed
   2105 		 * contains no dirty buffers that could be in the log.
   2106 		 */
   2107 		if (!LIST_EMPTY(&vp->v_dirtyblkhd)) {
   2108 			error = wapbl_flush(mp->mnt_wapbl, 0);
   2109 			if (error)
   2110 				return error;
   2111 		}
   2112 
   2113 		if ((flags & FSYNC_WAIT) != 0) {
   2114 			mutex_enter(&vp->v_interlock);
   2115 			while (vp->v_numoutput)
   2116 				cv_wait(&vp->v_cv, &vp->v_interlock);
   2117 			mutex_exit(&vp->v_interlock);
   2118 		}
   2119 
   2120 		return 0;
   2121 	}
   2122 #endif /* WAPBL */
   2123 
   2124 	/*
   2125 	 * Write out metadata for non-logging file systems. XXX This block
   2126 	 * should be simplified now that softdep is gone.
   2127 	 */
   2128 	passes = NIADDR + 1;
   2129 	skipmeta = 0;
   2130 	if (flags & FSYNC_WAIT)
   2131 		skipmeta = 1;
   2132 
   2133 loop:
   2134 	mutex_enter(&bufcache_lock);
   2135 	LIST_FOREACH(bp, &vp->v_dirtyblkhd, b_vnbufs) {
   2136 		bp->b_cflags &= ~BC_SCANNED;
   2137 	}
   2138 	for (bp = LIST_FIRST(&vp->v_dirtyblkhd); bp; bp = nbp) {
   2139 		nbp = LIST_NEXT(bp, b_vnbufs);
   2140 		if (bp->b_cflags & (BC_BUSY | BC_SCANNED))
   2141 			continue;
   2142 		if ((bp->b_oflags & BO_DELWRI) == 0)
   2143 			panic("ffs_fsync: not dirty");
   2144 		if (skipmeta && bp->b_lblkno < 0)
   2145 			continue;
   2146 		bp->b_cflags |= BC_BUSY | BC_VFLUSH | BC_SCANNED;
   2147 		mutex_exit(&bufcache_lock);
   2148 		/*
   2149 		 * On our final pass through, do all I/O synchronously
   2150 		 * so that we can find out if our flush is failing
   2151 		 * because of write errors.
   2152 		 */
   2153 		if (passes > 0 || !(flags & FSYNC_WAIT))
   2154 			(void) bawrite(bp);
   2155 		else if ((error = bwrite(bp)) != 0)
   2156 			return (error);
   2157 		/*
   2158 		 * Since we unlocked during the I/O, we need
   2159 		 * to start from a known point.
   2160 		 */
   2161 		mutex_enter(&bufcache_lock);
   2162 		nbp = LIST_FIRST(&vp->v_dirtyblkhd);
   2163 	}
   2164 	mutex_exit(&bufcache_lock);
   2165 	if (skipmeta) {
   2166 		skipmeta = 0;
   2167 		goto loop;
   2168 	}
   2169 
   2170 	if ((flags & FSYNC_WAIT) != 0) {
   2171 		mutex_enter(&vp->v_interlock);
   2172 		while (vp->v_numoutput) {
   2173 			cv_wait(&vp->v_cv, &vp->v_interlock);
   2174 		}
   2175 		mutex_exit(&vp->v_interlock);
   2176 
   2177 		if (!LIST_EMPTY(&vp->v_dirtyblkhd)) {
   2178 			/*
   2179 			* Block devices associated with filesystems may
   2180 			* have new I/O requests posted for them even if
   2181 			* the vnode is locked, so no amount of trying will
   2182 			* get them clean. Thus we give block devices a
   2183 			* good effort, then just give up. For all other file
   2184 			* types, go around and try again until it is clean.
   2185 			*/
   2186 			if (passes > 0) {
   2187 				passes--;
   2188 				goto loop;
   2189 			}
   2190 #ifdef DIAGNOSTIC
   2191 			if (vp->v_type != VBLK)
   2192 				vprint("ffs_fsync: dirty", vp);
   2193 #endif
   2194 		}
   2195 	}
   2196 
   2197 	if (error == 0 && (flags & FSYNC_CACHE) != 0) {
   2198 		(void)VOP_IOCTL(vp, DIOCCACHESYNC, &i, FWRITE,
   2199 		    kauth_cred_get());
   2200 	}
   2201 
   2202 	return error;
   2203 }
   2204