xref: /freebsd/sys/ufs/ffs/ffs_vfsops.c (revision d9f0ce31900a48d1a2bfc1c8c86f79d1e831451a)
1 /*-
2  * Copyright (c) 1989, 1991, 1993, 1994
3  *	The Regents of the University of California.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 4. Neither the name of the University nor the names of its contributors
14  *    may be used to endorse or promote products derived from this software
15  *    without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  *
29  *	@(#)ffs_vfsops.c	8.31 (Berkeley) 5/20/95
30  */
31 
32 #include <sys/cdefs.h>
33 __FBSDID("$FreeBSD$");
34 
35 #include "opt_quota.h"
36 #include "opt_ufs.h"
37 #include "opt_ffs.h"
38 #include "opt_ddb.h"
39 
40 #include <sys/param.h>
41 #include <sys/systm.h>
42 #include <sys/namei.h>
43 #include <sys/priv.h>
44 #include <sys/proc.h>
45 #include <sys/taskqueue.h>
46 #include <sys/kernel.h>
47 #include <sys/vnode.h>
48 #include <sys/mount.h>
49 #include <sys/bio.h>
50 #include <sys/buf.h>
51 #include <sys/conf.h>
52 #include <sys/fcntl.h>
53 #include <sys/ioccom.h>
54 #include <sys/malloc.h>
55 #include <sys/mutex.h>
56 #include <sys/rwlock.h>
57 
58 #include <security/mac/mac_framework.h>
59 
60 #include <ufs/ufs/extattr.h>
61 #include <ufs/ufs/gjournal.h>
62 #include <ufs/ufs/quota.h>
63 #include <ufs/ufs/ufsmount.h>
64 #include <ufs/ufs/inode.h>
65 #include <ufs/ufs/ufs_extern.h>
66 
67 #include <ufs/ffs/fs.h>
68 #include <ufs/ffs/ffs_extern.h>
69 
70 #include <vm/vm.h>
71 #include <vm/uma.h>
72 #include <vm/vm_page.h>
73 
74 #include <geom/geom.h>
75 #include <geom/geom_vfs.h>
76 
77 #include <ddb/ddb.h>
78 
79 static uma_zone_t uma_inode, uma_ufs1, uma_ufs2;
80 
81 static int	ffs_mountfs(struct vnode *, struct mount *, struct thread *);
82 static void	ffs_oldfscompat_read(struct fs *, struct ufsmount *,
83 		    ufs2_daddr_t);
84 static void	ffs_ifree(struct ufsmount *ump, struct inode *ip);
85 static int	ffs_sync_lazy(struct mount *mp);
86 
87 static vfs_init_t ffs_init;
88 static vfs_uninit_t ffs_uninit;
89 static vfs_extattrctl_t ffs_extattrctl;
90 static vfs_cmount_t ffs_cmount;
91 static vfs_unmount_t ffs_unmount;
92 static vfs_mount_t ffs_mount;
93 static vfs_statfs_t ffs_statfs;
94 static vfs_fhtovp_t ffs_fhtovp;
95 static vfs_sync_t ffs_sync;
96 
97 static struct vfsops ufs_vfsops = {
98 	.vfs_extattrctl =	ffs_extattrctl,
99 	.vfs_fhtovp =		ffs_fhtovp,
100 	.vfs_init =		ffs_init,
101 	.vfs_mount =		ffs_mount,
102 	.vfs_cmount =		ffs_cmount,
103 	.vfs_quotactl =		ufs_quotactl,
104 	.vfs_root =		ufs_root,
105 	.vfs_statfs =		ffs_statfs,
106 	.vfs_sync =		ffs_sync,
107 	.vfs_uninit =		ffs_uninit,
108 	.vfs_unmount =		ffs_unmount,
109 	.vfs_vget =		ffs_vget,
110 	.vfs_susp_clean =	process_deferred_inactive,
111 };
112 
113 VFS_SET(ufs_vfsops, ufs, 0);
114 MODULE_VERSION(ufs, 1);
115 
116 static b_strategy_t ffs_geom_strategy;
117 static b_write_t ffs_bufwrite;
118 
119 static struct buf_ops ffs_ops = {
120 	.bop_name =	"FFS",
121 	.bop_write =	ffs_bufwrite,
122 	.bop_strategy =	ffs_geom_strategy,
123 	.bop_sync =	bufsync,
124 #ifdef NO_FFS_SNAPSHOT
125 	.bop_bdflush =	bufbdflush,
126 #else
127 	.bop_bdflush =	ffs_bdflush,
128 #endif
129 };
130 
131 /*
132  * Note that userquota and groupquota options are not currently used
133  * by UFS/FFS code and generally mount(8) does not pass those options
134  * from userland, but they can be passed by loader(8) via
135  * vfs.root.mountfrom.options.
136  */
137 static const char *ffs_opts[] = { "acls", "async", "noatime", "noclusterr",
138     "noclusterw", "noexec", "export", "force", "from", "groupquota",
139     "multilabel", "nfsv4acls", "fsckpid", "snapshot", "nosuid", "suiddir",
140     "nosymfollow", "sync", "union", "userquota", NULL };
141 
142 static int
143 ffs_mount(struct mount *mp)
144 {
145 	struct vnode *devvp;
146 	struct thread *td;
147 	struct ufsmount *ump = NULL;
148 	struct fs *fs;
149 	pid_t fsckpid = 0;
150 	int error, flags;
151 	uint64_t mntorflags;
152 	accmode_t accmode;
153 	struct nameidata ndp;
154 	char *fspec;
155 
156 	td = curthread;
157 	if (vfs_filteropt(mp->mnt_optnew, ffs_opts))
158 		return (EINVAL);
159 	if (uma_inode == NULL) {
160 		uma_inode = uma_zcreate("FFS inode",
161 		    sizeof(struct inode), NULL, NULL, NULL, NULL,
162 		    UMA_ALIGN_PTR, 0);
163 		uma_ufs1 = uma_zcreate("FFS1 dinode",
164 		    sizeof(struct ufs1_dinode), NULL, NULL, NULL, NULL,
165 		    UMA_ALIGN_PTR, 0);
166 		uma_ufs2 = uma_zcreate("FFS2 dinode",
167 		    sizeof(struct ufs2_dinode), NULL, NULL, NULL, NULL,
168 		    UMA_ALIGN_PTR, 0);
169 	}
170 
171 	vfs_deleteopt(mp->mnt_optnew, "groupquota");
172 	vfs_deleteopt(mp->mnt_optnew, "userquota");
173 
174 	fspec = vfs_getopts(mp->mnt_optnew, "from", &error);
175 	if (error)
176 		return (error);
177 
178 	mntorflags = 0;
179 	if (vfs_getopt(mp->mnt_optnew, "acls", NULL, NULL) == 0)
180 		mntorflags |= MNT_ACLS;
181 
182 	if (vfs_getopt(mp->mnt_optnew, "snapshot", NULL, NULL) == 0) {
183 		mntorflags |= MNT_SNAPSHOT;
184 		/*
185 		 * Once we have set the MNT_SNAPSHOT flag, do not
186 		 * persist "snapshot" in the options list.
187 		 */
188 		vfs_deleteopt(mp->mnt_optnew, "snapshot");
189 		vfs_deleteopt(mp->mnt_opt, "snapshot");
190 	}
191 
192 	if (vfs_getopt(mp->mnt_optnew, "fsckpid", NULL, NULL) == 0 &&
193 	    vfs_scanopt(mp->mnt_optnew, "fsckpid", "%d", &fsckpid) == 1) {
194 		/*
195 		 * Once we have set the restricted PID, do not
196 		 * persist "fsckpid" in the options list.
197 		 */
198 		vfs_deleteopt(mp->mnt_optnew, "fsckpid");
199 		vfs_deleteopt(mp->mnt_opt, "fsckpid");
200 		if (mp->mnt_flag & MNT_UPDATE) {
201 			if (VFSTOUFS(mp)->um_fs->fs_ronly == 0 &&
202 			     vfs_flagopt(mp->mnt_optnew, "ro", NULL, 0) == 0) {
203 				vfs_mount_error(mp,
204 				    "Checker enable: Must be read-only");
205 				return (EINVAL);
206 			}
207 		} else if (vfs_flagopt(mp->mnt_optnew, "ro", NULL, 0) == 0) {
208 			vfs_mount_error(mp,
209 			    "Checker enable: Must be read-only");
210 			return (EINVAL);
211 		}
212 		/* Set to -1 if we are done */
213 		if (fsckpid == 0)
214 			fsckpid = -1;
215 	}
216 
217 	if (vfs_getopt(mp->mnt_optnew, "nfsv4acls", NULL, NULL) == 0) {
218 		if (mntorflags & MNT_ACLS) {
219 			vfs_mount_error(mp,
220 			    "\"acls\" and \"nfsv4acls\" options "
221 			    "are mutually exclusive");
222 			return (EINVAL);
223 		}
224 		mntorflags |= MNT_NFS4ACLS;
225 	}
226 
227 	MNT_ILOCK(mp);
228 	mp->mnt_flag |= mntorflags;
229 	MNT_IUNLOCK(mp);
230 	/*
231 	 * If updating, check whether changing from read-only to
232 	 * read/write; if there is no device name, that's all we do.
233 	 */
234 	if (mp->mnt_flag & MNT_UPDATE) {
235 		ump = VFSTOUFS(mp);
236 		fs = ump->um_fs;
237 		devvp = ump->um_devvp;
238 		if (fsckpid == -1 && ump->um_fsckpid > 0) {
239 			if ((error = ffs_flushfiles(mp, WRITECLOSE, td)) != 0 ||
240 			    (error = ffs_sbupdate(ump, MNT_WAIT, 0)) != 0)
241 				return (error);
242 			DROP_GIANT();
243 			g_topology_lock();
244 			/*
245 			 * Return to normal read-only mode.
246 			 */
247 			error = g_access(ump->um_cp, 0, -1, 0);
248 			g_topology_unlock();
249 			PICKUP_GIANT();
250 			ump->um_fsckpid = 0;
251 		}
252 		if (fs->fs_ronly == 0 &&
253 		    vfs_flagopt(mp->mnt_optnew, "ro", NULL, 0)) {
254 			/*
255 			 * Flush any dirty data and suspend filesystem.
256 			 */
257 			if ((error = vn_start_write(NULL, &mp, V_WAIT)) != 0)
258 				return (error);
259 			error = vfs_write_suspend_umnt(mp);
260 			if (error != 0)
261 				return (error);
262 			/*
263 			 * Check for and optionally get rid of files open
264 			 * for writing.
265 			 */
266 			flags = WRITECLOSE;
267 			if (mp->mnt_flag & MNT_FORCE)
268 				flags |= FORCECLOSE;
269 			if (MOUNTEDSOFTDEP(mp)) {
270 				error = softdep_flushfiles(mp, flags, td);
271 			} else {
272 				error = ffs_flushfiles(mp, flags, td);
273 			}
274 			if (error) {
275 				vfs_write_resume(mp, 0);
276 				return (error);
277 			}
278 			if (fs->fs_pendingblocks != 0 ||
279 			    fs->fs_pendinginodes != 0) {
280 				printf("WARNING: %s Update error: blocks %jd "
281 				    "files %d\n", fs->fs_fsmnt,
282 				    (intmax_t)fs->fs_pendingblocks,
283 				    fs->fs_pendinginodes);
284 				fs->fs_pendingblocks = 0;
285 				fs->fs_pendinginodes = 0;
286 			}
287 			if ((fs->fs_flags & (FS_UNCLEAN | FS_NEEDSFSCK)) == 0)
288 				fs->fs_clean = 1;
289 			if ((error = ffs_sbupdate(ump, MNT_WAIT, 0)) != 0) {
290 				fs->fs_ronly = 0;
291 				fs->fs_clean = 0;
292 				vfs_write_resume(mp, 0);
293 				return (error);
294 			}
295 			if (MOUNTEDSOFTDEP(mp))
296 				softdep_unmount(mp);
297 			DROP_GIANT();
298 			g_topology_lock();
299 			/*
300 			 * Drop our write and exclusive access.
301 			 */
302 			g_access(ump->um_cp, 0, -1, -1);
303 			g_topology_unlock();
304 			PICKUP_GIANT();
305 			fs->fs_ronly = 1;
306 			MNT_ILOCK(mp);
307 			mp->mnt_flag |= MNT_RDONLY;
308 			MNT_IUNLOCK(mp);
309 			/*
310 			 * Allow the writers to note that filesystem
311 			 * is ro now.
312 			 */
313 			vfs_write_resume(mp, 0);
314 		}
315 		if ((mp->mnt_flag & MNT_RELOAD) &&
316 		    (error = ffs_reload(mp, td, 0)) != 0)
317 			return (error);
318 		if (fs->fs_ronly &&
319 		    !vfs_flagopt(mp->mnt_optnew, "ro", NULL, 0)) {
320 			/*
321 			 * If we are running a checker, do not allow upgrade.
322 			 */
323 			if (ump->um_fsckpid > 0) {
324 				vfs_mount_error(mp,
325 				    "Active checker, cannot upgrade to write");
326 				return (EINVAL);
327 			}
328 			/*
329 			 * If upgrade to read-write by non-root, then verify
330 			 * that user has necessary permissions on the device.
331 			 */
332 			vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
333 			error = VOP_ACCESS(devvp, VREAD | VWRITE,
334 			    td->td_ucred, td);
335 			if (error)
336 				error = priv_check(td, PRIV_VFS_MOUNT_PERM);
337 			if (error) {
338 				VOP_UNLOCK(devvp, 0);
339 				return (error);
340 			}
341 			VOP_UNLOCK(devvp, 0);
342 			fs->fs_flags &= ~FS_UNCLEAN;
343 			if (fs->fs_clean == 0) {
344 				fs->fs_flags |= FS_UNCLEAN;
345 				if ((mp->mnt_flag & MNT_FORCE) ||
346 				    ((fs->fs_flags &
347 				     (FS_SUJ | FS_NEEDSFSCK)) == 0 &&
348 				     (fs->fs_flags & FS_DOSOFTDEP))) {
349 					printf("WARNING: %s was not properly "
350 					   "dismounted\n", fs->fs_fsmnt);
351 				} else {
352 					vfs_mount_error(mp,
353 					   "R/W mount of %s denied. %s.%s",
354 					   fs->fs_fsmnt,
355 					   "Filesystem is not clean - run fsck",
356 					   (fs->fs_flags & FS_SUJ) == 0 ? "" :
357 					   " Forced mount will invalidate"
358 					   " journal contents");
359 					return (EPERM);
360 				}
361 			}
362 			DROP_GIANT();
363 			g_topology_lock();
364 			/*
365 			 * Request exclusive write access.
366 			 */
367 			error = g_access(ump->um_cp, 0, 1, 1);
368 			g_topology_unlock();
369 			PICKUP_GIANT();
370 			if (error)
371 				return (error);
372 			if ((error = vn_start_write(NULL, &mp, V_WAIT)) != 0)
373 				return (error);
374 			fs->fs_ronly = 0;
375 			MNT_ILOCK(mp);
376 			mp->mnt_flag &= ~MNT_RDONLY;
377 			MNT_IUNLOCK(mp);
378 			fs->fs_mtime = time_second;
379 			/* check to see if we need to start softdep */
380 			if ((fs->fs_flags & FS_DOSOFTDEP) &&
381 			    (error = softdep_mount(devvp, mp, fs, td->td_ucred))){
382 				vn_finished_write(mp);
383 				return (error);
384 			}
385 			fs->fs_clean = 0;
386 			if ((error = ffs_sbupdate(ump, MNT_WAIT, 0)) != 0) {
387 				vn_finished_write(mp);
388 				return (error);
389 			}
390 			if (fs->fs_snapinum[0] != 0)
391 				ffs_snapshot_mount(mp);
392 			vn_finished_write(mp);
393 		}
394 		/*
395 		 * Soft updates is incompatible with "async",
396 		 * so if we are doing softupdates stop the user
397 		 * from setting the async flag in an update.
398 		 * Softdep_mount() clears it in an initial mount
399 		 * or ro->rw remount.
400 		 */
401 		if (MOUNTEDSOFTDEP(mp)) {
402 			/* XXX: Reset too late ? */
403 			MNT_ILOCK(mp);
404 			mp->mnt_flag &= ~MNT_ASYNC;
405 			MNT_IUNLOCK(mp);
406 		}
407 		/*
408 		 * Keep MNT_ACLS flag if it is stored in superblock.
409 		 */
410 		if ((fs->fs_flags & FS_ACLS) != 0) {
411 			/* XXX: Set too late ? */
412 			MNT_ILOCK(mp);
413 			mp->mnt_flag |= MNT_ACLS;
414 			MNT_IUNLOCK(mp);
415 		}
416 
417 		if ((fs->fs_flags & FS_NFS4ACLS) != 0) {
418 			/* XXX: Set too late ? */
419 			MNT_ILOCK(mp);
420 			mp->mnt_flag |= MNT_NFS4ACLS;
421 			MNT_IUNLOCK(mp);
422 		}
423 		/*
424 		 * If this is a request from fsck to clean up the filesystem,
425 		 * then allow the specified pid to proceed.
426 		 */
427 		if (fsckpid > 0) {
428 			if (ump->um_fsckpid != 0) {
429 				vfs_mount_error(mp,
430 				    "Active checker already running on %s",
431 				    fs->fs_fsmnt);
432 				return (EINVAL);
433 			}
434 			KASSERT(MOUNTEDSOFTDEP(mp) == 0,
435 			    ("soft updates enabled on read-only file system"));
436 			DROP_GIANT();
437 			g_topology_lock();
438 			/*
439 			 * Request write access.
440 			 */
441 			error = g_access(ump->um_cp, 0, 1, 0);
442 			g_topology_unlock();
443 			PICKUP_GIANT();
444 			if (error) {
445 				vfs_mount_error(mp,
446 				    "Checker activation failed on %s",
447 				    fs->fs_fsmnt);
448 				return (error);
449 			}
450 			ump->um_fsckpid = fsckpid;
451 			if (fs->fs_snapinum[0] != 0)
452 				ffs_snapshot_mount(mp);
453 			fs->fs_mtime = time_second;
454 			fs->fs_fmod = 1;
455 			fs->fs_clean = 0;
456 			(void) ffs_sbupdate(ump, MNT_WAIT, 0);
457 		}
458 
459 		/*
460 		 * If this is a snapshot request, take the snapshot.
461 		 */
462 		if (mp->mnt_flag & MNT_SNAPSHOT)
463 			return (ffs_snapshot(mp, fspec));
464 	}
465 
466 	/*
467 	 * Not an update, or updating the name: look up the name
468 	 * and verify that it refers to a sensible disk device.
469 	 */
470 	NDINIT(&ndp, LOOKUP, FOLLOW | LOCKLEAF, UIO_SYSSPACE, fspec, td);
471 	if ((error = namei(&ndp)) != 0)
472 		return (error);
473 	NDFREE(&ndp, NDF_ONLY_PNBUF);
474 	devvp = ndp.ni_vp;
475 	if (!vn_isdisk(devvp, &error)) {
476 		vput(devvp);
477 		return (error);
478 	}
479 
480 	/*
481 	 * If mount by non-root, then verify that user has necessary
482 	 * permissions on the device.
483 	 */
484 	accmode = VREAD;
485 	if ((mp->mnt_flag & MNT_RDONLY) == 0)
486 		accmode |= VWRITE;
487 	error = VOP_ACCESS(devvp, accmode, td->td_ucred, td);
488 	if (error)
489 		error = priv_check(td, PRIV_VFS_MOUNT_PERM);
490 	if (error) {
491 		vput(devvp);
492 		return (error);
493 	}
494 
495 	if (mp->mnt_flag & MNT_UPDATE) {
496 		/*
497 		 * Update only
498 		 *
499 		 * If it's not the same vnode, or at least the same device
500 		 * then it's not correct.
501 		 */
502 
503 		if (devvp->v_rdev != ump->um_devvp->v_rdev)
504 			error = EINVAL;	/* needs translation */
505 		vput(devvp);
506 		if (error)
507 			return (error);
508 	} else {
509 		/*
510 		 * New mount
511 		 *
512 		 * We need the name for the mount point (also used for
513 		 * "last mounted on") copied in. If an error occurs,
514 		 * the mount point is discarded by the upper level code.
515 		 * Note that vfs_mount() populates f_mntonname for us.
516 		 */
517 		if ((error = ffs_mountfs(devvp, mp, td)) != 0) {
518 			vrele(devvp);
519 			return (error);
520 		}
521 		if (fsckpid > 0) {
522 			KASSERT(MOUNTEDSOFTDEP(mp) == 0,
523 			    ("soft updates enabled on read-only file system"));
524 			ump = VFSTOUFS(mp);
525 			fs = ump->um_fs;
526 			DROP_GIANT();
527 			g_topology_lock();
528 			/*
529 			 * Request write access.
530 			 */
531 			error = g_access(ump->um_cp, 0, 1, 0);
532 			g_topology_unlock();
533 			PICKUP_GIANT();
534 			if (error) {
535 				printf("WARNING: %s: Checker activation "
536 				    "failed\n", fs->fs_fsmnt);
537 			} else {
538 				ump->um_fsckpid = fsckpid;
539 				if (fs->fs_snapinum[0] != 0)
540 					ffs_snapshot_mount(mp);
541 				fs->fs_mtime = time_second;
542 				fs->fs_clean = 0;
543 				(void) ffs_sbupdate(ump, MNT_WAIT, 0);
544 			}
545 		}
546 	}
547 	vfs_mountedfrom(mp, fspec);
548 	return (0);
549 }
550 
551 /*
552  * Compatibility with old mount system call.
553  */
554 
555 static int
556 ffs_cmount(struct mntarg *ma, void *data, uint64_t flags)
557 {
558 	struct ufs_args args;
559 	struct export_args exp;
560 	int error;
561 
562 	if (data == NULL)
563 		return (EINVAL);
564 	error = copyin(data, &args, sizeof args);
565 	if (error)
566 		return (error);
567 	vfs_oexport_conv(&args.export, &exp);
568 
569 	ma = mount_argsu(ma, "from", args.fspec, MAXPATHLEN);
570 	ma = mount_arg(ma, "export", &exp, sizeof(exp));
571 	error = kernel_mount(ma, flags);
572 
573 	return (error);
574 }
575 
576 /*
577  * Reload all incore data for a filesystem (used after running fsck on
578  * the root filesystem and finding things to fix). If the 'force' flag
579  * is 0, the filesystem must be mounted read-only.
580  *
581  * Things to do to update the mount:
582  *	1) invalidate all cached meta-data.
583  *	2) re-read superblock from disk.
584  *	3) re-read summary information from disk.
585  *	4) invalidate all inactive vnodes.
586  *	5) invalidate all cached file data.
587  *	6) re-read inode data for all active vnodes.
588  */
589 int
590 ffs_reload(struct mount *mp, struct thread *td, int force)
591 {
592 	struct vnode *vp, *mvp, *devvp;
593 	struct inode *ip;
594 	void *space;
595 	struct buf *bp;
596 	struct fs *fs, *newfs;
597 	struct ufsmount *ump;
598 	ufs2_daddr_t sblockloc;
599 	int i, blks, size, error;
600 	int32_t *lp;
601 
602 	ump = VFSTOUFS(mp);
603 
604 	MNT_ILOCK(mp);
605 	if ((mp->mnt_flag & MNT_RDONLY) == 0 && force == 0) {
606 		MNT_IUNLOCK(mp);
607 		return (EINVAL);
608 	}
609 	MNT_IUNLOCK(mp);
610 
611 	/*
612 	 * Step 1: invalidate all cached meta-data.
613 	 */
614 	devvp = VFSTOUFS(mp)->um_devvp;
615 	vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
616 	if (vinvalbuf(devvp, 0, 0, 0) != 0)
617 		panic("ffs_reload: dirty1");
618 	VOP_UNLOCK(devvp, 0);
619 
620 	/*
621 	 * Step 2: re-read superblock from disk.
622 	 */
623 	fs = VFSTOUFS(mp)->um_fs;
624 	if ((error = bread(devvp, btodb(fs->fs_sblockloc), fs->fs_sbsize,
625 	    NOCRED, &bp)) != 0)
626 		return (error);
627 	newfs = (struct fs *)bp->b_data;
628 	if ((newfs->fs_magic != FS_UFS1_MAGIC &&
629 	     newfs->fs_magic != FS_UFS2_MAGIC) ||
630 	    newfs->fs_bsize > MAXBSIZE ||
631 	    newfs->fs_bsize < sizeof(struct fs)) {
632 			brelse(bp);
633 			return (EIO);		/* XXX needs translation */
634 	}
635 	/*
636 	 * Copy pointer fields back into superblock before copying in	XXX
637 	 * new superblock. These should really be in the ufsmount.	XXX
638 	 * Note that important parameters (eg fs_ncg) are unchanged.
639 	 */
640 	newfs->fs_csp = fs->fs_csp;
641 	newfs->fs_maxcluster = fs->fs_maxcluster;
642 	newfs->fs_contigdirs = fs->fs_contigdirs;
643 	newfs->fs_active = fs->fs_active;
644 	newfs->fs_ronly = fs->fs_ronly;
645 	sblockloc = fs->fs_sblockloc;
646 	bcopy(newfs, fs, (u_int)fs->fs_sbsize);
647 	brelse(bp);
648 	mp->mnt_maxsymlinklen = fs->fs_maxsymlinklen;
649 	ffs_oldfscompat_read(fs, VFSTOUFS(mp), sblockloc);
650 	UFS_LOCK(ump);
651 	if (fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) {
652 		printf("WARNING: %s: reload pending error: blocks %jd "
653 		    "files %d\n", fs->fs_fsmnt, (intmax_t)fs->fs_pendingblocks,
654 		    fs->fs_pendinginodes);
655 		fs->fs_pendingblocks = 0;
656 		fs->fs_pendinginodes = 0;
657 	}
658 	UFS_UNLOCK(ump);
659 
660 	/*
661 	 * Step 3: re-read summary information from disk.
662 	 */
663 	size = fs->fs_cssize;
664 	blks = howmany(size, fs->fs_fsize);
665 	if (fs->fs_contigsumsize > 0)
666 		size += fs->fs_ncg * sizeof(int32_t);
667 	size += fs->fs_ncg * sizeof(u_int8_t);
668 	free(fs->fs_csp, M_UFSMNT);
669 	space = malloc((u_long)size, M_UFSMNT, M_WAITOK);
670 	fs->fs_csp = space;
671 	for (i = 0; i < blks; i += fs->fs_frag) {
672 		size = fs->fs_bsize;
673 		if (i + fs->fs_frag > blks)
674 			size = (blks - i) * fs->fs_fsize;
675 		error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + i), size,
676 		    NOCRED, &bp);
677 		if (error)
678 			return (error);
679 		bcopy(bp->b_data, space, (u_int)size);
680 		space = (char *)space + size;
681 		brelse(bp);
682 	}
683 	/*
684 	 * We no longer know anything about clusters per cylinder group.
685 	 */
686 	if (fs->fs_contigsumsize > 0) {
687 		fs->fs_maxcluster = lp = space;
688 		for (i = 0; i < fs->fs_ncg; i++)
689 			*lp++ = fs->fs_contigsumsize;
690 		space = lp;
691 	}
692 	size = fs->fs_ncg * sizeof(u_int8_t);
693 	fs->fs_contigdirs = (u_int8_t *)space;
694 	bzero(fs->fs_contigdirs, size);
695 
696 loop:
697 	MNT_VNODE_FOREACH_ALL(vp, mp, mvp) {
698 		/*
699 		 * Skip syncer vnode.
700 		 */
701 		if (vp->v_type == VNON) {
702 			VI_UNLOCK(vp);
703 			continue;
704 		}
705 		/*
706 		 * Step 4: invalidate all cached file data.
707 		 */
708 		if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, td)) {
709 			MNT_VNODE_FOREACH_ALL_ABORT(mp, mvp);
710 			goto loop;
711 		}
712 		if (vinvalbuf(vp, 0, 0, 0))
713 			panic("ffs_reload: dirty2");
714 		/*
715 		 * Step 5: re-read inode data for all active vnodes.
716 		 */
717 		ip = VTOI(vp);
718 		error =
719 		    bread(devvp, fsbtodb(fs, ino_to_fsba(fs, ip->i_number)),
720 		    (int)fs->fs_bsize, NOCRED, &bp);
721 		if (error) {
722 			VOP_UNLOCK(vp, 0);
723 			vrele(vp);
724 			MNT_VNODE_FOREACH_ALL_ABORT(mp, mvp);
725 			return (error);
726 		}
727 		ffs_load_inode(bp, ip, fs, ip->i_number);
728 		ip->i_effnlink = ip->i_nlink;
729 		brelse(bp);
730 		VOP_UNLOCK(vp, 0);
731 		vrele(vp);
732 	}
733 	return (0);
734 }
735 
736 /*
737  * Possible superblock locations ordered from most to least likely.
738  */
739 static int sblock_try[] = SBLOCKSEARCH;
740 
741 /*
742  * Common code for mount and mountroot
743  */
744 static int
745 ffs_mountfs(devvp, mp, td)
746 	struct vnode *devvp;
747 	struct mount *mp;
748 	struct thread *td;
749 {
750 	struct ufsmount *ump;
751 	struct buf *bp;
752 	struct fs *fs;
753 	struct cdev *dev;
754 	void *space;
755 	ufs2_daddr_t sblockloc;
756 	int error, i, blks, size, ronly;
757 	int32_t *lp;
758 	struct ucred *cred;
759 	struct g_consumer *cp;
760 	struct mount *nmp;
761 
762 	bp = NULL;
763 	ump = NULL;
764 	cred = td ? td->td_ucred : NOCRED;
765 	ronly = (mp->mnt_flag & MNT_RDONLY) != 0;
766 
767 	dev = devvp->v_rdev;
768 	dev_ref(dev);
769 	DROP_GIANT();
770 	g_topology_lock();
771 	error = g_vfs_open(devvp, &cp, "ffs", ronly ? 0 : 1);
772 	g_topology_unlock();
773 	PICKUP_GIANT();
774 	VOP_UNLOCK(devvp, 0);
775 	if (error)
776 		goto out;
777 	if (devvp->v_rdev->si_iosize_max != 0)
778 		mp->mnt_iosize_max = devvp->v_rdev->si_iosize_max;
779 	if (mp->mnt_iosize_max > MAXPHYS)
780 		mp->mnt_iosize_max = MAXPHYS;
781 
782 	devvp->v_bufobj.bo_ops = &ffs_ops;
783 
784 	fs = NULL;
785 	sblockloc = 0;
786 	/*
787 	 * Try reading the superblock in each of its possible locations.
788 	 */
789 	for (i = 0; sblock_try[i] != -1; i++) {
790 		if ((SBLOCKSIZE % cp->provider->sectorsize) != 0) {
791 			error = EINVAL;
792 			vfs_mount_error(mp,
793 			    "Invalid sectorsize %d for superblock size %d",
794 			    cp->provider->sectorsize, SBLOCKSIZE);
795 			goto out;
796 		}
797 		if ((error = bread(devvp, btodb(sblock_try[i]), SBLOCKSIZE,
798 		    cred, &bp)) != 0)
799 			goto out;
800 		fs = (struct fs *)bp->b_data;
801 		sblockloc = sblock_try[i];
802 		if ((fs->fs_magic == FS_UFS1_MAGIC ||
803 		     (fs->fs_magic == FS_UFS2_MAGIC &&
804 		      (fs->fs_sblockloc == sblockloc ||
805 		       (fs->fs_old_flags & FS_FLAGS_UPDATED) == 0))) &&
806 		    fs->fs_bsize <= MAXBSIZE &&
807 		    fs->fs_bsize >= sizeof(struct fs))
808 			break;
809 		brelse(bp);
810 		bp = NULL;
811 	}
812 	if (sblock_try[i] == -1) {
813 		error = EINVAL;		/* XXX needs translation */
814 		goto out;
815 	}
816 	fs->fs_fmod = 0;
817 	fs->fs_flags &= ~FS_INDEXDIRS;	/* no support for directory indicies */
818 	fs->fs_flags &= ~FS_UNCLEAN;
819 	if (fs->fs_clean == 0) {
820 		fs->fs_flags |= FS_UNCLEAN;
821 		if (ronly || (mp->mnt_flag & MNT_FORCE) ||
822 		    ((fs->fs_flags & (FS_SUJ | FS_NEEDSFSCK)) == 0 &&
823 		     (fs->fs_flags & FS_DOSOFTDEP))) {
824 			printf("WARNING: %s was not properly dismounted\n",
825 			    fs->fs_fsmnt);
826 		} else {
827 			vfs_mount_error(mp, "R/W mount of %s denied. %s%s",
828 			    fs->fs_fsmnt, "Filesystem is not clean - run fsck.",
829 			    (fs->fs_flags & FS_SUJ) == 0 ? "" :
830 			    " Forced mount will invalidate journal contents");
831 			error = EPERM;
832 			goto out;
833 		}
834 		if ((fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) &&
835 		    (mp->mnt_flag & MNT_FORCE)) {
836 			printf("WARNING: %s: lost blocks %jd files %d\n",
837 			    fs->fs_fsmnt, (intmax_t)fs->fs_pendingblocks,
838 			    fs->fs_pendinginodes);
839 			fs->fs_pendingblocks = 0;
840 			fs->fs_pendinginodes = 0;
841 		}
842 	}
843 	if (fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) {
844 		printf("WARNING: %s: mount pending error: blocks %jd "
845 		    "files %d\n", fs->fs_fsmnt, (intmax_t)fs->fs_pendingblocks,
846 		    fs->fs_pendinginodes);
847 		fs->fs_pendingblocks = 0;
848 		fs->fs_pendinginodes = 0;
849 	}
850 	if ((fs->fs_flags & FS_GJOURNAL) != 0) {
851 #ifdef UFS_GJOURNAL
852 		/*
853 		 * Get journal provider name.
854 		 */
855 		size = 1024;
856 		mp->mnt_gjprovider = malloc(size, M_UFSMNT, M_WAITOK);
857 		if (g_io_getattr("GJOURNAL::provider", cp, &size,
858 		    mp->mnt_gjprovider) == 0) {
859 			mp->mnt_gjprovider = realloc(mp->mnt_gjprovider, size,
860 			    M_UFSMNT, M_WAITOK);
861 			MNT_ILOCK(mp);
862 			mp->mnt_flag |= MNT_GJOURNAL;
863 			MNT_IUNLOCK(mp);
864 		} else {
865 			printf("WARNING: %s: GJOURNAL flag on fs "
866 			    "but no gjournal provider below\n",
867 			    mp->mnt_stat.f_mntonname);
868 			free(mp->mnt_gjprovider, M_UFSMNT);
869 			mp->mnt_gjprovider = NULL;
870 		}
871 #else
872 		printf("WARNING: %s: GJOURNAL flag on fs but no "
873 		    "UFS_GJOURNAL support\n", mp->mnt_stat.f_mntonname);
874 #endif
875 	} else {
876 		mp->mnt_gjprovider = NULL;
877 	}
878 	ump = malloc(sizeof *ump, M_UFSMNT, M_WAITOK | M_ZERO);
879 	ump->um_cp = cp;
880 	ump->um_bo = &devvp->v_bufobj;
881 	ump->um_fs = malloc((u_long)fs->fs_sbsize, M_UFSMNT, M_WAITOK);
882 	if (fs->fs_magic == FS_UFS1_MAGIC) {
883 		ump->um_fstype = UFS1;
884 		ump->um_balloc = ffs_balloc_ufs1;
885 	} else {
886 		ump->um_fstype = UFS2;
887 		ump->um_balloc = ffs_balloc_ufs2;
888 	}
889 	ump->um_blkatoff = ffs_blkatoff;
890 	ump->um_truncate = ffs_truncate;
891 	ump->um_update = ffs_update;
892 	ump->um_valloc = ffs_valloc;
893 	ump->um_vfree = ffs_vfree;
894 	ump->um_ifree = ffs_ifree;
895 	ump->um_rdonly = ffs_rdonly;
896 	ump->um_snapgone = ffs_snapgone;
897 	mtx_init(UFS_MTX(ump), "FFS", "FFS Lock", MTX_DEF);
898 	bcopy(bp->b_data, ump->um_fs, (u_int)fs->fs_sbsize);
899 	if (fs->fs_sbsize < SBLOCKSIZE)
900 		bp->b_flags |= B_INVAL | B_NOCACHE;
901 	brelse(bp);
902 	bp = NULL;
903 	fs = ump->um_fs;
904 	ffs_oldfscompat_read(fs, ump, sblockloc);
905 	fs->fs_ronly = ronly;
906 	size = fs->fs_cssize;
907 	blks = howmany(size, fs->fs_fsize);
908 	if (fs->fs_contigsumsize > 0)
909 		size += fs->fs_ncg * sizeof(int32_t);
910 	size += fs->fs_ncg * sizeof(u_int8_t);
911 	space = malloc((u_long)size, M_UFSMNT, M_WAITOK);
912 	fs->fs_csp = space;
913 	for (i = 0; i < blks; i += fs->fs_frag) {
914 		size = fs->fs_bsize;
915 		if (i + fs->fs_frag > blks)
916 			size = (blks - i) * fs->fs_fsize;
917 		if ((error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + i), size,
918 		    cred, &bp)) != 0) {
919 			free(fs->fs_csp, M_UFSMNT);
920 			goto out;
921 		}
922 		bcopy(bp->b_data, space, (u_int)size);
923 		space = (char *)space + size;
924 		brelse(bp);
925 		bp = NULL;
926 	}
927 	if (fs->fs_contigsumsize > 0) {
928 		fs->fs_maxcluster = lp = space;
929 		for (i = 0; i < fs->fs_ncg; i++)
930 			*lp++ = fs->fs_contigsumsize;
931 		space = lp;
932 	}
933 	size = fs->fs_ncg * sizeof(u_int8_t);
934 	fs->fs_contigdirs = (u_int8_t *)space;
935 	bzero(fs->fs_contigdirs, size);
936 	fs->fs_active = NULL;
937 	mp->mnt_data = ump;
938 	mp->mnt_stat.f_fsid.val[0] = fs->fs_id[0];
939 	mp->mnt_stat.f_fsid.val[1] = fs->fs_id[1];
940 	nmp = NULL;
941 	if (fs->fs_id[0] == 0 || fs->fs_id[1] == 0 ||
942 	    (nmp = vfs_getvfs(&mp->mnt_stat.f_fsid))) {
943 		if (nmp)
944 			vfs_rel(nmp);
945 		vfs_getnewfsid(mp);
946 	}
947 	mp->mnt_maxsymlinklen = fs->fs_maxsymlinklen;
948 	MNT_ILOCK(mp);
949 	mp->mnt_flag |= MNT_LOCAL;
950 	MNT_IUNLOCK(mp);
951 	if ((fs->fs_flags & FS_MULTILABEL) != 0) {
952 #ifdef MAC
953 		MNT_ILOCK(mp);
954 		mp->mnt_flag |= MNT_MULTILABEL;
955 		MNT_IUNLOCK(mp);
956 #else
957 		printf("WARNING: %s: multilabel flag on fs but "
958 		    "no MAC support\n", mp->mnt_stat.f_mntonname);
959 #endif
960 	}
961 	if ((fs->fs_flags & FS_ACLS) != 0) {
962 #ifdef UFS_ACL
963 		MNT_ILOCK(mp);
964 
965 		if (mp->mnt_flag & MNT_NFS4ACLS)
966 			printf("WARNING: %s: ACLs flag on fs conflicts with "
967 			    "\"nfsv4acls\" mount option; option ignored\n",
968 			    mp->mnt_stat.f_mntonname);
969 		mp->mnt_flag &= ~MNT_NFS4ACLS;
970 		mp->mnt_flag |= MNT_ACLS;
971 
972 		MNT_IUNLOCK(mp);
973 #else
974 		printf("WARNING: %s: ACLs flag on fs but no ACLs support\n",
975 		    mp->mnt_stat.f_mntonname);
976 #endif
977 	}
978 	if ((fs->fs_flags & FS_NFS4ACLS) != 0) {
979 #ifdef UFS_ACL
980 		MNT_ILOCK(mp);
981 
982 		if (mp->mnt_flag & MNT_ACLS)
983 			printf("WARNING: %s: NFSv4 ACLs flag on fs conflicts "
984 			    "with \"acls\" mount option; option ignored\n",
985 			    mp->mnt_stat.f_mntonname);
986 		mp->mnt_flag &= ~MNT_ACLS;
987 		mp->mnt_flag |= MNT_NFS4ACLS;
988 
989 		MNT_IUNLOCK(mp);
990 #else
991 		printf("WARNING: %s: NFSv4 ACLs flag on fs but no "
992 		    "ACLs support\n", mp->mnt_stat.f_mntonname);
993 #endif
994 	}
995 	if ((fs->fs_flags & FS_TRIM) != 0) {
996 		size = sizeof(int);
997 		if (g_io_getattr("GEOM::candelete", cp, &size,
998 		    &ump->um_candelete) == 0) {
999 			if (!ump->um_candelete)
1000 				printf("WARNING: %s: TRIM flag on fs but disk "
1001 				    "does not support TRIM\n",
1002 				    mp->mnt_stat.f_mntonname);
1003 		} else {
1004 			printf("WARNING: %s: TRIM flag on fs but disk does "
1005 			    "not confirm that it supports TRIM\n",
1006 			    mp->mnt_stat.f_mntonname);
1007 			ump->um_candelete = 0;
1008 		}
1009 		if (ump->um_candelete) {
1010 			ump->um_trim_tq = taskqueue_create("trim", M_WAITOK,
1011 			    taskqueue_thread_enqueue, &ump->um_trim_tq);
1012 			taskqueue_start_threads(&ump->um_trim_tq, 1, PVFS,
1013 			    "%s trim", mp->mnt_stat.f_mntonname);
1014 		}
1015 	}
1016 
1017 	ump->um_mountp = mp;
1018 	ump->um_dev = dev;
1019 	ump->um_devvp = devvp;
1020 	ump->um_nindir = fs->fs_nindir;
1021 	ump->um_bptrtodb = fs->fs_fsbtodb;
1022 	ump->um_seqinc = fs->fs_frag;
1023 	for (i = 0; i < MAXQUOTAS; i++)
1024 		ump->um_quotas[i] = NULLVP;
1025 #ifdef UFS_EXTATTR
1026 	ufs_extattr_uepm_init(&ump->um_extattr);
1027 #endif
1028 	/*
1029 	 * Set FS local "last mounted on" information (NULL pad)
1030 	 */
1031 	bzero(fs->fs_fsmnt, MAXMNTLEN);
1032 	strlcpy(fs->fs_fsmnt, mp->mnt_stat.f_mntonname, MAXMNTLEN);
1033 	mp->mnt_stat.f_iosize = fs->fs_bsize;
1034 
1035 	if (mp->mnt_flag & MNT_ROOTFS) {
1036 		/*
1037 		 * Root mount; update timestamp in mount structure.
1038 		 * this will be used by the common root mount code
1039 		 * to update the system clock.
1040 		 */
1041 		mp->mnt_time = fs->fs_time;
1042 	}
1043 
1044 	if (ronly == 0) {
1045 		fs->fs_mtime = time_second;
1046 		if ((fs->fs_flags & FS_DOSOFTDEP) &&
1047 		    (error = softdep_mount(devvp, mp, fs, cred)) != 0) {
1048 			free(fs->fs_csp, M_UFSMNT);
1049 			ffs_flushfiles(mp, FORCECLOSE, td);
1050 			goto out;
1051 		}
1052 		if (devvp->v_type == VCHR && devvp->v_rdev != NULL)
1053 			devvp->v_rdev->si_mountpt = mp;
1054 		if (fs->fs_snapinum[0] != 0)
1055 			ffs_snapshot_mount(mp);
1056 		fs->fs_fmod = 1;
1057 		fs->fs_clean = 0;
1058 		(void) ffs_sbupdate(ump, MNT_WAIT, 0);
1059 	}
1060 	/*
1061 	 * Initialize filesystem stat information in mount struct.
1062 	 */
1063 	MNT_ILOCK(mp);
1064 	mp->mnt_kern_flag |= MNTK_LOOKUP_SHARED | MNTK_EXTENDED_SHARED |
1065 	    MNTK_NO_IOPF | MNTK_UNMAPPED_BUFS | MNTK_USES_BCACHE;
1066 	MNT_IUNLOCK(mp);
1067 #ifdef UFS_EXTATTR
1068 #ifdef UFS_EXTATTR_AUTOSTART
1069 	/*
1070 	 *
1071 	 * Auto-starting does the following:
1072 	 *	- check for /.attribute in the fs, and extattr_start if so
1073 	 *	- for each file in .attribute, enable that file with
1074 	 * 	  an attribute of the same name.
1075 	 * Not clear how to report errors -- probably eat them.
1076 	 * This would all happen while the filesystem was busy/not
1077 	 * available, so would effectively be "atomic".
1078 	 */
1079 	(void) ufs_extattr_autostart(mp, td);
1080 #endif /* !UFS_EXTATTR_AUTOSTART */
1081 #endif /* !UFS_EXTATTR */
1082 	return (0);
1083 out:
1084 	if (bp)
1085 		brelse(bp);
1086 	if (cp != NULL) {
1087 		DROP_GIANT();
1088 		g_topology_lock();
1089 		g_vfs_close(cp);
1090 		g_topology_unlock();
1091 		PICKUP_GIANT();
1092 	}
1093 	if (ump) {
1094 		mtx_destroy(UFS_MTX(ump));
1095 		if (mp->mnt_gjprovider != NULL) {
1096 			free(mp->mnt_gjprovider, M_UFSMNT);
1097 			mp->mnt_gjprovider = NULL;
1098 		}
1099 		free(ump->um_fs, M_UFSMNT);
1100 		free(ump, M_UFSMNT);
1101 		mp->mnt_data = NULL;
1102 	}
1103 	dev_rel(dev);
1104 	return (error);
1105 }
1106 
1107 #include <sys/sysctl.h>
1108 static int bigcgs = 0;
1109 SYSCTL_INT(_debug, OID_AUTO, bigcgs, CTLFLAG_RW, &bigcgs, 0, "");
1110 
1111 /*
1112  * Sanity checks for loading old filesystem superblocks.
1113  * See ffs_oldfscompat_write below for unwound actions.
1114  *
1115  * XXX - Parts get retired eventually.
1116  * Unfortunately new bits get added.
1117  */
1118 static void
1119 ffs_oldfscompat_read(fs, ump, sblockloc)
1120 	struct fs *fs;
1121 	struct ufsmount *ump;
1122 	ufs2_daddr_t sblockloc;
1123 {
1124 	off_t maxfilesize;
1125 
1126 	/*
1127 	 * If not yet done, update fs_flags location and value of fs_sblockloc.
1128 	 */
1129 	if ((fs->fs_old_flags & FS_FLAGS_UPDATED) == 0) {
1130 		fs->fs_flags = fs->fs_old_flags;
1131 		fs->fs_old_flags |= FS_FLAGS_UPDATED;
1132 		fs->fs_sblockloc = sblockloc;
1133 	}
1134 	/*
1135 	 * If not yet done, update UFS1 superblock with new wider fields.
1136 	 */
1137 	if (fs->fs_magic == FS_UFS1_MAGIC && fs->fs_maxbsize != fs->fs_bsize) {
1138 		fs->fs_maxbsize = fs->fs_bsize;
1139 		fs->fs_time = fs->fs_old_time;
1140 		fs->fs_size = fs->fs_old_size;
1141 		fs->fs_dsize = fs->fs_old_dsize;
1142 		fs->fs_csaddr = fs->fs_old_csaddr;
1143 		fs->fs_cstotal.cs_ndir = fs->fs_old_cstotal.cs_ndir;
1144 		fs->fs_cstotal.cs_nbfree = fs->fs_old_cstotal.cs_nbfree;
1145 		fs->fs_cstotal.cs_nifree = fs->fs_old_cstotal.cs_nifree;
1146 		fs->fs_cstotal.cs_nffree = fs->fs_old_cstotal.cs_nffree;
1147 	}
1148 	if (fs->fs_magic == FS_UFS1_MAGIC &&
1149 	    fs->fs_old_inodefmt < FS_44INODEFMT) {
1150 		fs->fs_maxfilesize = ((uint64_t)1 << 31) - 1;
1151 		fs->fs_qbmask = ~fs->fs_bmask;
1152 		fs->fs_qfmask = ~fs->fs_fmask;
1153 	}
1154 	if (fs->fs_magic == FS_UFS1_MAGIC) {
1155 		ump->um_savedmaxfilesize = fs->fs_maxfilesize;
1156 		maxfilesize = (uint64_t)0x80000000 * fs->fs_bsize - 1;
1157 		if (fs->fs_maxfilesize > maxfilesize)
1158 			fs->fs_maxfilesize = maxfilesize;
1159 	}
1160 	/* Compatibility for old filesystems */
1161 	if (fs->fs_avgfilesize <= 0)
1162 		fs->fs_avgfilesize = AVFILESIZ;
1163 	if (fs->fs_avgfpdir <= 0)
1164 		fs->fs_avgfpdir = AFPDIR;
1165 	if (bigcgs) {
1166 		fs->fs_save_cgsize = fs->fs_cgsize;
1167 		fs->fs_cgsize = fs->fs_bsize;
1168 	}
1169 }
1170 
1171 /*
1172  * Unwinding superblock updates for old filesystems.
1173  * See ffs_oldfscompat_read above for details.
1174  *
1175  * XXX - Parts get retired eventually.
1176  * Unfortunately new bits get added.
1177  */
1178 void
1179 ffs_oldfscompat_write(fs, ump)
1180 	struct fs *fs;
1181 	struct ufsmount *ump;
1182 {
1183 
1184 	/*
1185 	 * Copy back UFS2 updated fields that UFS1 inspects.
1186 	 */
1187 	if (fs->fs_magic == FS_UFS1_MAGIC) {
1188 		fs->fs_old_time = fs->fs_time;
1189 		fs->fs_old_cstotal.cs_ndir = fs->fs_cstotal.cs_ndir;
1190 		fs->fs_old_cstotal.cs_nbfree = fs->fs_cstotal.cs_nbfree;
1191 		fs->fs_old_cstotal.cs_nifree = fs->fs_cstotal.cs_nifree;
1192 		fs->fs_old_cstotal.cs_nffree = fs->fs_cstotal.cs_nffree;
1193 		fs->fs_maxfilesize = ump->um_savedmaxfilesize;
1194 	}
1195 	if (bigcgs) {
1196 		fs->fs_cgsize = fs->fs_save_cgsize;
1197 		fs->fs_save_cgsize = 0;
1198 	}
1199 }
1200 
1201 /*
1202  * unmount system call
1203  */
1204 static int
1205 ffs_unmount(mp, mntflags)
1206 	struct mount *mp;
1207 	int mntflags;
1208 {
1209 	struct thread *td;
1210 	struct ufsmount *ump = VFSTOUFS(mp);
1211 	struct fs *fs;
1212 	int error, flags, susp;
1213 #ifdef UFS_EXTATTR
1214 	int e_restart;
1215 #endif
1216 
1217 	flags = 0;
1218 	td = curthread;
1219 	fs = ump->um_fs;
1220 	susp = 0;
1221 	if (mntflags & MNT_FORCE) {
1222 		flags |= FORCECLOSE;
1223 		susp = fs->fs_ronly == 0;
1224 	}
1225 #ifdef UFS_EXTATTR
1226 	if ((error = ufs_extattr_stop(mp, td))) {
1227 		if (error != EOPNOTSUPP)
1228 			printf("WARNING: unmount %s: ufs_extattr_stop "
1229 			    "returned errno %d\n", mp->mnt_stat.f_mntonname,
1230 			    error);
1231 		e_restart = 0;
1232 	} else {
1233 		ufs_extattr_uepm_destroy(&ump->um_extattr);
1234 		e_restart = 1;
1235 	}
1236 #endif
1237 	if (susp) {
1238 		error = vfs_write_suspend_umnt(mp);
1239 		if (error != 0)
1240 			goto fail1;
1241 	}
1242 	if (MOUNTEDSOFTDEP(mp))
1243 		error = softdep_flushfiles(mp, flags, td);
1244 	else
1245 		error = ffs_flushfiles(mp, flags, td);
1246 	if (error != 0 && error != ENXIO)
1247 		goto fail;
1248 
1249 	UFS_LOCK(ump);
1250 	if (fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) {
1251 		printf("WARNING: unmount %s: pending error: blocks %jd "
1252 		    "files %d\n", fs->fs_fsmnt, (intmax_t)fs->fs_pendingblocks,
1253 		    fs->fs_pendinginodes);
1254 		fs->fs_pendingblocks = 0;
1255 		fs->fs_pendinginodes = 0;
1256 	}
1257 	UFS_UNLOCK(ump);
1258 	if (MOUNTEDSOFTDEP(mp))
1259 		softdep_unmount(mp);
1260 	if (fs->fs_ronly == 0 || ump->um_fsckpid > 0) {
1261 		fs->fs_clean = fs->fs_flags & (FS_UNCLEAN|FS_NEEDSFSCK) ? 0 : 1;
1262 		error = ffs_sbupdate(ump, MNT_WAIT, 0);
1263 		if (error && error != ENXIO) {
1264 			fs->fs_clean = 0;
1265 			goto fail;
1266 		}
1267 	}
1268 	if (susp)
1269 		vfs_write_resume(mp, VR_START_WRITE);
1270 	if (ump->um_trim_tq != NULL) {
1271 		while (ump->um_trim_inflight != 0)
1272 			pause("ufsutr", hz);
1273 		taskqueue_drain_all(ump->um_trim_tq);
1274 		taskqueue_free(ump->um_trim_tq);
1275 	}
1276 	DROP_GIANT();
1277 	g_topology_lock();
1278 	if (ump->um_fsckpid > 0) {
1279 		/*
1280 		 * Return to normal read-only mode.
1281 		 */
1282 		error = g_access(ump->um_cp, 0, -1, 0);
1283 		ump->um_fsckpid = 0;
1284 	}
1285 	g_vfs_close(ump->um_cp);
1286 	g_topology_unlock();
1287 	PICKUP_GIANT();
1288 	if (ump->um_devvp->v_type == VCHR && ump->um_devvp->v_rdev != NULL)
1289 		ump->um_devvp->v_rdev->si_mountpt = NULL;
1290 	vrele(ump->um_devvp);
1291 	dev_rel(ump->um_dev);
1292 	mtx_destroy(UFS_MTX(ump));
1293 	if (mp->mnt_gjprovider != NULL) {
1294 		free(mp->mnt_gjprovider, M_UFSMNT);
1295 		mp->mnt_gjprovider = NULL;
1296 	}
1297 	free(fs->fs_csp, M_UFSMNT);
1298 	free(fs, M_UFSMNT);
1299 	free(ump, M_UFSMNT);
1300 	mp->mnt_data = NULL;
1301 	MNT_ILOCK(mp);
1302 	mp->mnt_flag &= ~MNT_LOCAL;
1303 	MNT_IUNLOCK(mp);
1304 	return (error);
1305 
1306 fail:
1307 	if (susp)
1308 		vfs_write_resume(mp, VR_START_WRITE);
1309 fail1:
1310 #ifdef UFS_EXTATTR
1311 	if (e_restart) {
1312 		ufs_extattr_uepm_init(&ump->um_extattr);
1313 #ifdef UFS_EXTATTR_AUTOSTART
1314 		(void) ufs_extattr_autostart(mp, td);
1315 #endif
1316 	}
1317 #endif
1318 
1319 	return (error);
1320 }
1321 
1322 /*
1323  * Flush out all the files in a filesystem.
1324  */
1325 int
1326 ffs_flushfiles(mp, flags, td)
1327 	struct mount *mp;
1328 	int flags;
1329 	struct thread *td;
1330 {
1331 	struct ufsmount *ump;
1332 	int qerror, error;
1333 
1334 	ump = VFSTOUFS(mp);
1335 	qerror = 0;
1336 #ifdef QUOTA
1337 	if (mp->mnt_flag & MNT_QUOTA) {
1338 		int i;
1339 		error = vflush(mp, 0, SKIPSYSTEM|flags, td);
1340 		if (error)
1341 			return (error);
1342 		for (i = 0; i < MAXQUOTAS; i++) {
1343 			error = quotaoff(td, mp, i);
1344 			if (error != 0) {
1345 				if ((flags & EARLYFLUSH) == 0)
1346 					return (error);
1347 				else
1348 					qerror = error;
1349 			}
1350 		}
1351 
1352 		/*
1353 		 * Here we fall through to vflush again to ensure that
1354 		 * we have gotten rid of all the system vnodes, unless
1355 		 * quotas must not be closed.
1356 		 */
1357 	}
1358 #endif
1359 	ASSERT_VOP_LOCKED(ump->um_devvp, "ffs_flushfiles");
1360 	if (ump->um_devvp->v_vflag & VV_COPYONWRITE) {
1361 		if ((error = vflush(mp, 0, SKIPSYSTEM | flags, td)) != 0)
1362 			return (error);
1363 		ffs_snapshot_unmount(mp);
1364 		flags |= FORCECLOSE;
1365 		/*
1366 		 * Here we fall through to vflush again to ensure
1367 		 * that we have gotten rid of all the system vnodes.
1368 		 */
1369 	}
1370 
1371 	/*
1372 	 * Do not close system files if quotas were not closed, to be
1373 	 * able to sync the remaining dquots.  The freeblks softupdate
1374 	 * workitems might hold a reference on a dquot, preventing
1375 	 * quotaoff() from completing.  Next round of
1376 	 * softdep_flushworklist() iteration should process the
1377 	 * blockers, allowing the next run of quotaoff() to finally
1378 	 * flush held dquots.
1379 	 *
1380 	 * Otherwise, flush all the files.
1381 	 */
1382 	if (qerror == 0 && (error = vflush(mp, 0, flags, td)) != 0)
1383 		return (error);
1384 
1385 	/*
1386 	 * Flush filesystem metadata.
1387 	 */
1388 	vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY);
1389 	error = VOP_FSYNC(ump->um_devvp, MNT_WAIT, td);
1390 	VOP_UNLOCK(ump->um_devvp, 0);
1391 	return (error);
1392 }
1393 
1394 /*
1395  * Get filesystem statistics.
1396  */
1397 static int
1398 ffs_statfs(mp, sbp)
1399 	struct mount *mp;
1400 	struct statfs *sbp;
1401 {
1402 	struct ufsmount *ump;
1403 	struct fs *fs;
1404 
1405 	ump = VFSTOUFS(mp);
1406 	fs = ump->um_fs;
1407 	if (fs->fs_magic != FS_UFS1_MAGIC && fs->fs_magic != FS_UFS2_MAGIC)
1408 		panic("ffs_statfs");
1409 	sbp->f_version = STATFS_VERSION;
1410 	sbp->f_bsize = fs->fs_fsize;
1411 	sbp->f_iosize = fs->fs_bsize;
1412 	sbp->f_blocks = fs->fs_dsize;
1413 	UFS_LOCK(ump);
1414 	sbp->f_bfree = fs->fs_cstotal.cs_nbfree * fs->fs_frag +
1415 	    fs->fs_cstotal.cs_nffree + dbtofsb(fs, fs->fs_pendingblocks);
1416 	sbp->f_bavail = freespace(fs, fs->fs_minfree) +
1417 	    dbtofsb(fs, fs->fs_pendingblocks);
1418 	sbp->f_files =  fs->fs_ncg * fs->fs_ipg - ROOTINO;
1419 	sbp->f_ffree = fs->fs_cstotal.cs_nifree + fs->fs_pendinginodes;
1420 	UFS_UNLOCK(ump);
1421 	sbp->f_namemax = NAME_MAX;
1422 	return (0);
1423 }
1424 
1425 static bool
1426 sync_doupdate(struct inode *ip)
1427 {
1428 
1429 	return ((ip->i_flag & (IN_ACCESS | IN_CHANGE | IN_MODIFIED |
1430 	    IN_UPDATE)) != 0);
1431 }
1432 
1433 /*
1434  * For a lazy sync, we only care about access times, quotas and the
1435  * superblock.  Other filesystem changes are already converted to
1436  * cylinder group blocks or inode blocks updates and are written to
1437  * disk by syncer.
1438  */
1439 static int
1440 ffs_sync_lazy(mp)
1441      struct mount *mp;
1442 {
1443 	struct vnode *mvp, *vp;
1444 	struct inode *ip;
1445 	struct thread *td;
1446 	int allerror, error;
1447 
1448 	allerror = 0;
1449 	td = curthread;
1450 	if ((mp->mnt_flag & MNT_NOATIME) != 0)
1451 		goto qupdate;
1452 	MNT_VNODE_FOREACH_ACTIVE(vp, mp, mvp) {
1453 		if (vp->v_type == VNON) {
1454 			VI_UNLOCK(vp);
1455 			continue;
1456 		}
1457 		ip = VTOI(vp);
1458 
1459 		/*
1460 		 * The IN_ACCESS flag is converted to IN_MODIFIED by
1461 		 * ufs_close() and ufs_getattr() by the calls to
1462 		 * ufs_itimes_locked(), without subsequent UFS_UPDATE().
1463 		 * Test also all the other timestamp flags too, to pick up
1464 		 * any other cases that could be missed.
1465 		 */
1466 		if (!sync_doupdate(ip) && (vp->v_iflag & VI_OWEINACT) == 0) {
1467 			VI_UNLOCK(vp);
1468 			continue;
1469 		}
1470 		if ((error = vget(vp, LK_EXCLUSIVE | LK_NOWAIT | LK_INTERLOCK,
1471 		    td)) != 0)
1472 			continue;
1473 		if (sync_doupdate(ip))
1474 			error = ffs_update(vp, 0);
1475 		if (error != 0)
1476 			allerror = error;
1477 		vput(vp);
1478 	}
1479 
1480 qupdate:
1481 #ifdef QUOTA
1482 	qsync(mp);
1483 #endif
1484 
1485 	if (VFSTOUFS(mp)->um_fs->fs_fmod != 0 &&
1486 	    (error = ffs_sbupdate(VFSTOUFS(mp), MNT_LAZY, 0)) != 0)
1487 		allerror = error;
1488 	return (allerror);
1489 }
1490 
1491 /*
1492  * Go through the disk queues to initiate sandbagged IO;
1493  * go through the inodes to write those that have been modified;
1494  * initiate the writing of the super block if it has been modified.
1495  *
1496  * Note: we are always called with the filesystem marked busy using
1497  * vfs_busy().
1498  */
1499 static int
1500 ffs_sync(mp, waitfor)
1501 	struct mount *mp;
1502 	int waitfor;
1503 {
1504 	struct vnode *mvp, *vp, *devvp;
1505 	struct thread *td;
1506 	struct inode *ip;
1507 	struct ufsmount *ump = VFSTOUFS(mp);
1508 	struct fs *fs;
1509 	int error, count, lockreq, allerror = 0;
1510 	int suspend;
1511 	int suspended;
1512 	int secondary_writes;
1513 	int secondary_accwrites;
1514 	int softdep_deps;
1515 	int softdep_accdeps;
1516 	struct bufobj *bo;
1517 
1518 	suspend = 0;
1519 	suspended = 0;
1520 	td = curthread;
1521 	fs = ump->um_fs;
1522 	if (fs->fs_fmod != 0 && fs->fs_ronly != 0 && ump->um_fsckpid == 0)
1523 		panic("%s: ffs_sync: modification on read-only filesystem",
1524 		    fs->fs_fsmnt);
1525 	if (waitfor == MNT_LAZY) {
1526 		if (!rebooting)
1527 			return (ffs_sync_lazy(mp));
1528 		waitfor = MNT_NOWAIT;
1529 	}
1530 
1531 	/*
1532 	 * Write back each (modified) inode.
1533 	 */
1534 	lockreq = LK_EXCLUSIVE | LK_NOWAIT;
1535 	if (waitfor == MNT_SUSPEND) {
1536 		suspend = 1;
1537 		waitfor = MNT_WAIT;
1538 	}
1539 	if (waitfor == MNT_WAIT)
1540 		lockreq = LK_EXCLUSIVE;
1541 	lockreq |= LK_INTERLOCK | LK_SLEEPFAIL;
1542 loop:
1543 	/* Grab snapshot of secondary write counts */
1544 	MNT_ILOCK(mp);
1545 	secondary_writes = mp->mnt_secondary_writes;
1546 	secondary_accwrites = mp->mnt_secondary_accwrites;
1547 	MNT_IUNLOCK(mp);
1548 
1549 	/* Grab snapshot of softdep dependency counts */
1550 	softdep_get_depcounts(mp, &softdep_deps, &softdep_accdeps);
1551 
1552 	MNT_VNODE_FOREACH_ALL(vp, mp, mvp) {
1553 		/*
1554 		 * Depend on the vnode interlock to keep things stable enough
1555 		 * for a quick test.  Since there might be hundreds of
1556 		 * thousands of vnodes, we cannot afford even a subroutine
1557 		 * call unless there's a good chance that we have work to do.
1558 		 */
1559 		if (vp->v_type == VNON) {
1560 			VI_UNLOCK(vp);
1561 			continue;
1562 		}
1563 		ip = VTOI(vp);
1564 		if ((ip->i_flag &
1565 		    (IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE)) == 0 &&
1566 		    vp->v_bufobj.bo_dirty.bv_cnt == 0) {
1567 			VI_UNLOCK(vp);
1568 			continue;
1569 		}
1570 		if ((error = vget(vp, lockreq, td)) != 0) {
1571 			if (error == ENOENT || error == ENOLCK) {
1572 				MNT_VNODE_FOREACH_ALL_ABORT(mp, mvp);
1573 				goto loop;
1574 			}
1575 			continue;
1576 		}
1577 		if ((error = ffs_syncvnode(vp, waitfor, 0)) != 0)
1578 			allerror = error;
1579 		vput(vp);
1580 	}
1581 	/*
1582 	 * Force stale filesystem control information to be flushed.
1583 	 */
1584 	if (waitfor == MNT_WAIT || rebooting) {
1585 		if ((error = softdep_flushworklist(ump->um_mountp, &count, td)))
1586 			allerror = error;
1587 		/* Flushed work items may create new vnodes to clean */
1588 		if (allerror == 0 && count)
1589 			goto loop;
1590 	}
1591 #ifdef QUOTA
1592 	qsync(mp);
1593 #endif
1594 
1595 	devvp = ump->um_devvp;
1596 	bo = &devvp->v_bufobj;
1597 	BO_LOCK(bo);
1598 	if (bo->bo_numoutput > 0 || bo->bo_dirty.bv_cnt > 0) {
1599 		BO_UNLOCK(bo);
1600 		vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
1601 		error = VOP_FSYNC(devvp, waitfor, td);
1602 		VOP_UNLOCK(devvp, 0);
1603 		if (MOUNTEDSOFTDEP(mp) && (error == 0 || error == EAGAIN))
1604 			error = ffs_sbupdate(ump, waitfor, 0);
1605 		if (error != 0)
1606 			allerror = error;
1607 		if (allerror == 0 && waitfor == MNT_WAIT)
1608 			goto loop;
1609 	} else if (suspend != 0) {
1610 		if (softdep_check_suspend(mp,
1611 					  devvp,
1612 					  softdep_deps,
1613 					  softdep_accdeps,
1614 					  secondary_writes,
1615 					  secondary_accwrites) != 0) {
1616 			MNT_IUNLOCK(mp);
1617 			goto loop;	/* More work needed */
1618 		}
1619 		mtx_assert(MNT_MTX(mp), MA_OWNED);
1620 		mp->mnt_kern_flag |= MNTK_SUSPEND2 | MNTK_SUSPENDED;
1621 		MNT_IUNLOCK(mp);
1622 		suspended = 1;
1623 	} else
1624 		BO_UNLOCK(bo);
1625 	/*
1626 	 * Write back modified superblock.
1627 	 */
1628 	if (fs->fs_fmod != 0 &&
1629 	    (error = ffs_sbupdate(ump, waitfor, suspended)) != 0)
1630 		allerror = error;
1631 	return (allerror);
1632 }
1633 
1634 int
1635 ffs_vget(mp, ino, flags, vpp)
1636 	struct mount *mp;
1637 	ino_t ino;
1638 	int flags;
1639 	struct vnode **vpp;
1640 {
1641 	return (ffs_vgetf(mp, ino, flags, vpp, 0));
1642 }
1643 
1644 int
1645 ffs_vgetf(mp, ino, flags, vpp, ffs_flags)
1646 	struct mount *mp;
1647 	ino_t ino;
1648 	int flags;
1649 	struct vnode **vpp;
1650 	int ffs_flags;
1651 {
1652 	struct fs *fs;
1653 	struct inode *ip;
1654 	struct ufsmount *ump;
1655 	struct buf *bp;
1656 	struct vnode *vp;
1657 	struct cdev *dev;
1658 	int error;
1659 
1660 	error = vfs_hash_get(mp, ino, flags, curthread, vpp, NULL, NULL);
1661 	if (error || *vpp != NULL)
1662 		return (error);
1663 
1664 	/*
1665 	 * We must promote to an exclusive lock for vnode creation.  This
1666 	 * can happen if lookup is passed LOCKSHARED.
1667 	 */
1668 	if ((flags & LK_TYPE_MASK) == LK_SHARED) {
1669 		flags &= ~LK_TYPE_MASK;
1670 		flags |= LK_EXCLUSIVE;
1671 	}
1672 
1673 	/*
1674 	 * We do not lock vnode creation as it is believed to be too
1675 	 * expensive for such rare case as simultaneous creation of vnode
1676 	 * for same ino by different processes. We just allow them to race
1677 	 * and check later to decide who wins. Let the race begin!
1678 	 */
1679 
1680 	ump = VFSTOUFS(mp);
1681 	dev = ump->um_dev;
1682 	fs = ump->um_fs;
1683 	ip = uma_zalloc(uma_inode, M_WAITOK | M_ZERO);
1684 
1685 	/* Allocate a new vnode/inode. */
1686 	error = getnewvnode("ufs", mp, fs->fs_magic == FS_UFS1_MAGIC ?
1687 	    &ffs_vnodeops1 : &ffs_vnodeops2, &vp);
1688 	if (error) {
1689 		*vpp = NULL;
1690 		uma_zfree(uma_inode, ip);
1691 		return (error);
1692 	}
1693 	/*
1694 	 * FFS supports recursive locking.
1695 	 */
1696 	lockmgr(vp->v_vnlock, LK_EXCLUSIVE, NULL);
1697 	VN_LOCK_AREC(vp);
1698 	vp->v_data = ip;
1699 	vp->v_bufobj.bo_bsize = fs->fs_bsize;
1700 	ip->i_vnode = vp;
1701 	ip->i_ump = ump;
1702 	ip->i_fs = fs;
1703 	ip->i_dev = dev;
1704 	ip->i_number = ino;
1705 	ip->i_ea_refs = 0;
1706 	ip->i_nextclustercg = -1;
1707 #ifdef QUOTA
1708 	{
1709 		int i;
1710 		for (i = 0; i < MAXQUOTAS; i++)
1711 			ip->i_dquot[i] = NODQUOT;
1712 	}
1713 #endif
1714 
1715 	if (ffs_flags & FFSV_FORCEINSMQ)
1716 		vp->v_vflag |= VV_FORCEINSMQ;
1717 	error = insmntque(vp, mp);
1718 	if (error != 0) {
1719 		uma_zfree(uma_inode, ip);
1720 		*vpp = NULL;
1721 		return (error);
1722 	}
1723 	vp->v_vflag &= ~VV_FORCEINSMQ;
1724 	error = vfs_hash_insert(vp, ino, flags, curthread, vpp, NULL, NULL);
1725 	if (error || *vpp != NULL)
1726 		return (error);
1727 
1728 	/* Read in the disk contents for the inode, copy into the inode. */
1729 	error = bread(ump->um_devvp, fsbtodb(fs, ino_to_fsba(fs, ino)),
1730 	    (int)fs->fs_bsize, NOCRED, &bp);
1731 	if (error) {
1732 		/*
1733 		 * The inode does not contain anything useful, so it would
1734 		 * be misleading to leave it on its hash chain. With mode
1735 		 * still zero, it will be unlinked and returned to the free
1736 		 * list by vput().
1737 		 */
1738 		brelse(bp);
1739 		vput(vp);
1740 		*vpp = NULL;
1741 		return (error);
1742 	}
1743 	if (ip->i_ump->um_fstype == UFS1)
1744 		ip->i_din1 = uma_zalloc(uma_ufs1, M_WAITOK);
1745 	else
1746 		ip->i_din2 = uma_zalloc(uma_ufs2, M_WAITOK);
1747 	ffs_load_inode(bp, ip, fs, ino);
1748 	if (DOINGSOFTDEP(vp))
1749 		softdep_load_inodeblock(ip);
1750 	else
1751 		ip->i_effnlink = ip->i_nlink;
1752 	bqrelse(bp);
1753 
1754 	/*
1755 	 * Initialize the vnode from the inode, check for aliases.
1756 	 * Note that the underlying vnode may have changed.
1757 	 */
1758 	if (ip->i_ump->um_fstype == UFS1)
1759 		error = ufs_vinit(mp, &ffs_fifoops1, &vp);
1760 	else
1761 		error = ufs_vinit(mp, &ffs_fifoops2, &vp);
1762 	if (error) {
1763 		vput(vp);
1764 		*vpp = NULL;
1765 		return (error);
1766 	}
1767 
1768 	/*
1769 	 * Finish inode initialization.
1770 	 */
1771 	if (vp->v_type != VFIFO) {
1772 		/* FFS supports shared locking for all files except fifos. */
1773 		VN_LOCK_ASHARE(vp);
1774 	}
1775 
1776 	/*
1777 	 * Set up a generation number for this inode if it does not
1778 	 * already have one. This should only happen on old filesystems.
1779 	 */
1780 	if (ip->i_gen == 0) {
1781 		ip->i_gen = arc4random() / 2 + 1;
1782 		if ((vp->v_mount->mnt_flag & MNT_RDONLY) == 0) {
1783 			ip->i_flag |= IN_MODIFIED;
1784 			DIP_SET(ip, i_gen, ip->i_gen);
1785 		}
1786 	}
1787 #ifdef MAC
1788 	if ((mp->mnt_flag & MNT_MULTILABEL) && ip->i_mode) {
1789 		/*
1790 		 * If this vnode is already allocated, and we're running
1791 		 * multi-label, attempt to perform a label association
1792 		 * from the extended attributes on the inode.
1793 		 */
1794 		error = mac_vnode_associate_extattr(mp, vp);
1795 		if (error) {
1796 			/* ufs_inactive will release ip->i_devvp ref. */
1797 			vput(vp);
1798 			*vpp = NULL;
1799 			return (error);
1800 		}
1801 	}
1802 #endif
1803 
1804 	*vpp = vp;
1805 	return (0);
1806 }
1807 
1808 /*
1809  * File handle to vnode
1810  *
1811  * Have to be really careful about stale file handles:
1812  * - check that the inode number is valid
1813  * - for UFS2 check that the inode number is initialized
1814  * - call ffs_vget() to get the locked inode
1815  * - check for an unallocated inode (i_mode == 0)
1816  * - check that the given client host has export rights and return
1817  *   those rights via. exflagsp and credanonp
1818  */
1819 static int
1820 ffs_fhtovp(mp, fhp, flags, vpp)
1821 	struct mount *mp;
1822 	struct fid *fhp;
1823 	int flags;
1824 	struct vnode **vpp;
1825 {
1826 	struct ufid *ufhp;
1827 	struct ufsmount *ump;
1828 	struct fs *fs;
1829 	struct cg *cgp;
1830 	struct buf *bp;
1831 	ino_t ino;
1832 	u_int cg;
1833 	int error;
1834 
1835 	ufhp = (struct ufid *)fhp;
1836 	ino = ufhp->ufid_ino;
1837 	ump = VFSTOUFS(mp);
1838 	fs = ump->um_fs;
1839 	if (ino < ROOTINO || ino >= fs->fs_ncg * fs->fs_ipg)
1840 		return (ESTALE);
1841 	/*
1842 	 * Need to check if inode is initialized because UFS2 does lazy
1843 	 * initialization and nfs_fhtovp can offer arbitrary inode numbers.
1844 	 */
1845 	if (fs->fs_magic != FS_UFS2_MAGIC)
1846 		return (ufs_fhtovp(mp, ufhp, flags, vpp));
1847 	cg = ino_to_cg(fs, ino);
1848 	error = bread(ump->um_devvp, fsbtodb(fs, cgtod(fs, cg)),
1849 		(int)fs->fs_cgsize, NOCRED, &bp);
1850 	if (error)
1851 		return (error);
1852 	cgp = (struct cg *)bp->b_data;
1853 	if (!cg_chkmagic(cgp) || ino >= cg * fs->fs_ipg + cgp->cg_initediblk) {
1854 		brelse(bp);
1855 		return (ESTALE);
1856 	}
1857 	brelse(bp);
1858 	return (ufs_fhtovp(mp, ufhp, flags, vpp));
1859 }
1860 
1861 /*
1862  * Initialize the filesystem.
1863  */
1864 static int
1865 ffs_init(vfsp)
1866 	struct vfsconf *vfsp;
1867 {
1868 
1869 	ffs_susp_initialize();
1870 	softdep_initialize();
1871 	return (ufs_init(vfsp));
1872 }
1873 
1874 /*
1875  * Undo the work of ffs_init().
1876  */
1877 static int
1878 ffs_uninit(vfsp)
1879 	struct vfsconf *vfsp;
1880 {
1881 	int ret;
1882 
1883 	ret = ufs_uninit(vfsp);
1884 	softdep_uninitialize();
1885 	ffs_susp_uninitialize();
1886 	return (ret);
1887 }
1888 
1889 /*
1890  * Write a superblock and associated information back to disk.
1891  */
1892 int
1893 ffs_sbupdate(ump, waitfor, suspended)
1894 	struct ufsmount *ump;
1895 	int waitfor;
1896 	int suspended;
1897 {
1898 	struct fs *fs = ump->um_fs;
1899 	struct buf *sbbp;
1900 	struct buf *bp;
1901 	int blks;
1902 	void *space;
1903 	int i, size, error, allerror = 0;
1904 
1905 	if (fs->fs_ronly == 1 &&
1906 	    (ump->um_mountp->mnt_flag & (MNT_RDONLY | MNT_UPDATE)) !=
1907 	    (MNT_RDONLY | MNT_UPDATE) && ump->um_fsckpid == 0)
1908 		panic("ffs_sbupdate: write read-only filesystem");
1909 	/*
1910 	 * We use the superblock's buf to serialize calls to ffs_sbupdate().
1911 	 */
1912 	sbbp = getblk(ump->um_devvp, btodb(fs->fs_sblockloc),
1913 	    (int)fs->fs_sbsize, 0, 0, 0);
1914 	/*
1915 	 * First write back the summary information.
1916 	 */
1917 	blks = howmany(fs->fs_cssize, fs->fs_fsize);
1918 	space = fs->fs_csp;
1919 	for (i = 0; i < blks; i += fs->fs_frag) {
1920 		size = fs->fs_bsize;
1921 		if (i + fs->fs_frag > blks)
1922 			size = (blks - i) * fs->fs_fsize;
1923 		bp = getblk(ump->um_devvp, fsbtodb(fs, fs->fs_csaddr + i),
1924 		    size, 0, 0, 0);
1925 		bcopy(space, bp->b_data, (u_int)size);
1926 		space = (char *)space + size;
1927 		if (suspended)
1928 			bp->b_flags |= B_VALIDSUSPWRT;
1929 		if (waitfor != MNT_WAIT)
1930 			bawrite(bp);
1931 		else if ((error = bwrite(bp)) != 0)
1932 			allerror = error;
1933 	}
1934 	/*
1935 	 * Now write back the superblock itself. If any errors occurred
1936 	 * up to this point, then fail so that the superblock avoids
1937 	 * being written out as clean.
1938 	 */
1939 	if (allerror) {
1940 		brelse(sbbp);
1941 		return (allerror);
1942 	}
1943 	bp = sbbp;
1944 	if (fs->fs_magic == FS_UFS1_MAGIC && fs->fs_sblockloc != SBLOCK_UFS1 &&
1945 	    (fs->fs_old_flags & FS_FLAGS_UPDATED) == 0) {
1946 		printf("WARNING: %s: correcting fs_sblockloc from %jd to %d\n",
1947 		    fs->fs_fsmnt, fs->fs_sblockloc, SBLOCK_UFS1);
1948 		fs->fs_sblockloc = SBLOCK_UFS1;
1949 	}
1950 	if (fs->fs_magic == FS_UFS2_MAGIC && fs->fs_sblockloc != SBLOCK_UFS2 &&
1951 	    (fs->fs_old_flags & FS_FLAGS_UPDATED) == 0) {
1952 		printf("WARNING: %s: correcting fs_sblockloc from %jd to %d\n",
1953 		    fs->fs_fsmnt, fs->fs_sblockloc, SBLOCK_UFS2);
1954 		fs->fs_sblockloc = SBLOCK_UFS2;
1955 	}
1956 	fs->fs_fmod = 0;
1957 	fs->fs_time = time_second;
1958 	if (MOUNTEDSOFTDEP(ump->um_mountp))
1959 		softdep_setup_sbupdate(ump, (struct fs *)bp->b_data, bp);
1960 	bcopy((caddr_t)fs, bp->b_data, (u_int)fs->fs_sbsize);
1961 	ffs_oldfscompat_write((struct fs *)bp->b_data, ump);
1962 	if (suspended)
1963 		bp->b_flags |= B_VALIDSUSPWRT;
1964 	if (waitfor != MNT_WAIT)
1965 		bawrite(bp);
1966 	else if ((error = bwrite(bp)) != 0)
1967 		allerror = error;
1968 	return (allerror);
1969 }
1970 
1971 static int
1972 ffs_extattrctl(struct mount *mp, int cmd, struct vnode *filename_vp,
1973 	int attrnamespace, const char *attrname)
1974 {
1975 
1976 #ifdef UFS_EXTATTR
1977 	return (ufs_extattrctl(mp, cmd, filename_vp, attrnamespace,
1978 	    attrname));
1979 #else
1980 	return (vfs_stdextattrctl(mp, cmd, filename_vp, attrnamespace,
1981 	    attrname));
1982 #endif
1983 }
1984 
1985 static void
1986 ffs_ifree(struct ufsmount *ump, struct inode *ip)
1987 {
1988 
1989 	if (ump->um_fstype == UFS1 && ip->i_din1 != NULL)
1990 		uma_zfree(uma_ufs1, ip->i_din1);
1991 	else if (ip->i_din2 != NULL)
1992 		uma_zfree(uma_ufs2, ip->i_din2);
1993 	uma_zfree(uma_inode, ip);
1994 }
1995 
1996 static int dobkgrdwrite = 1;
1997 SYSCTL_INT(_debug, OID_AUTO, dobkgrdwrite, CTLFLAG_RW, &dobkgrdwrite, 0,
1998     "Do background writes (honoring the BV_BKGRDWRITE flag)?");
1999 
2000 /*
2001  * Complete a background write started from bwrite.
2002  */
2003 static void
2004 ffs_backgroundwritedone(struct buf *bp)
2005 {
2006 	struct bufobj *bufobj;
2007 	struct buf *origbp;
2008 
2009 	/*
2010 	 * Find the original buffer that we are writing.
2011 	 */
2012 	bufobj = bp->b_bufobj;
2013 	BO_LOCK(bufobj);
2014 	if ((origbp = gbincore(bp->b_bufobj, bp->b_lblkno)) == NULL)
2015 		panic("backgroundwritedone: lost buffer");
2016 
2017 	/*
2018 	 * We should mark the cylinder group buffer origbp as
2019 	 * dirty, to not loose the failed write.
2020 	 */
2021 	if ((bp->b_ioflags & BIO_ERROR) != 0)
2022 		origbp->b_vflags |= BV_BKGRDERR;
2023 	BO_UNLOCK(bufobj);
2024 	/*
2025 	 * Process dependencies then return any unfinished ones.
2026 	 */
2027 	pbrelvp(bp);
2028 	if (!LIST_EMPTY(&bp->b_dep) && (bp->b_ioflags & BIO_ERROR) == 0)
2029 		buf_complete(bp);
2030 #ifdef SOFTUPDATES
2031 	if (!LIST_EMPTY(&bp->b_dep))
2032 		softdep_move_dependencies(bp, origbp);
2033 #endif
2034 	/*
2035 	 * This buffer is marked B_NOCACHE so when it is released
2036 	 * by biodone it will be tossed.
2037 	 */
2038 	bp->b_flags |= B_NOCACHE;
2039 	bp->b_flags &= ~B_CACHE;
2040 
2041 	/*
2042 	 * Prevent brelse() from trying to keep and re-dirtying bp on
2043 	 * errors. It causes b_bufobj dereference in
2044 	 * bdirty()/reassignbuf(), and b_bufobj was cleared in
2045 	 * pbrelvp() above.
2046 	 */
2047 	if ((bp->b_ioflags & BIO_ERROR) != 0)
2048 		bp->b_flags |= B_INVAL;
2049 	bufdone(bp);
2050 	BO_LOCK(bufobj);
2051 	/*
2052 	 * Clear the BV_BKGRDINPROG flag in the original buffer
2053 	 * and awaken it if it is waiting for the write to complete.
2054 	 * If BV_BKGRDINPROG is not set in the original buffer it must
2055 	 * have been released and re-instantiated - which is not legal.
2056 	 */
2057 	KASSERT((origbp->b_vflags & BV_BKGRDINPROG),
2058 	    ("backgroundwritedone: lost buffer2"));
2059 	origbp->b_vflags &= ~BV_BKGRDINPROG;
2060 	if (origbp->b_vflags & BV_BKGRDWAIT) {
2061 		origbp->b_vflags &= ~BV_BKGRDWAIT;
2062 		wakeup(&origbp->b_xflags);
2063 	}
2064 	BO_UNLOCK(bufobj);
2065 }
2066 
2067 
2068 /*
2069  * Write, release buffer on completion.  (Done by iodone
2070  * if async).  Do not bother writing anything if the buffer
2071  * is invalid.
2072  *
2073  * Note that we set B_CACHE here, indicating that buffer is
2074  * fully valid and thus cacheable.  This is true even of NFS
2075  * now so we set it generally.  This could be set either here
2076  * or in biodone() since the I/O is synchronous.  We put it
2077  * here.
2078  */
2079 static int
2080 ffs_bufwrite(struct buf *bp)
2081 {
2082 	struct buf *newbp;
2083 
2084 	CTR3(KTR_BUF, "bufwrite(%p) vp %p flags %X", bp, bp->b_vp, bp->b_flags);
2085 	if (bp->b_flags & B_INVAL) {
2086 		brelse(bp);
2087 		return (0);
2088 	}
2089 
2090 	if (!BUF_ISLOCKED(bp))
2091 		panic("bufwrite: buffer is not busy???");
2092 	/*
2093 	 * If a background write is already in progress, delay
2094 	 * writing this block if it is asynchronous. Otherwise
2095 	 * wait for the background write to complete.
2096 	 */
2097 	BO_LOCK(bp->b_bufobj);
2098 	if (bp->b_vflags & BV_BKGRDINPROG) {
2099 		if (bp->b_flags & B_ASYNC) {
2100 			BO_UNLOCK(bp->b_bufobj);
2101 			bdwrite(bp);
2102 			return (0);
2103 		}
2104 		bp->b_vflags |= BV_BKGRDWAIT;
2105 		msleep(&bp->b_xflags, BO_LOCKPTR(bp->b_bufobj), PRIBIO,
2106 		    "bwrbg", 0);
2107 		if (bp->b_vflags & BV_BKGRDINPROG)
2108 			panic("bufwrite: still writing");
2109 	}
2110 	bp->b_vflags &= ~BV_BKGRDERR;
2111 	BO_UNLOCK(bp->b_bufobj);
2112 
2113 	/*
2114 	 * If this buffer is marked for background writing and we
2115 	 * do not have to wait for it, make a copy and write the
2116 	 * copy so as to leave this buffer ready for further use.
2117 	 *
2118 	 * This optimization eats a lot of memory.  If we have a page
2119 	 * or buffer shortfall we can't do it.
2120 	 */
2121 	if (dobkgrdwrite && (bp->b_xflags & BX_BKGRDWRITE) &&
2122 	    (bp->b_flags & B_ASYNC) &&
2123 	    !vm_page_count_severe() &&
2124 	    !buf_dirty_count_severe()) {
2125 		KASSERT(bp->b_iodone == NULL,
2126 		    ("bufwrite: needs chained iodone (%p)", bp->b_iodone));
2127 
2128 		/* get a new block */
2129 		newbp = geteblk(bp->b_bufsize, GB_NOWAIT_BD);
2130 		if (newbp == NULL)
2131 			goto normal_write;
2132 
2133 		KASSERT(buf_mapped(bp), ("Unmapped cg"));
2134 		memcpy(newbp->b_data, bp->b_data, bp->b_bufsize);
2135 		BO_LOCK(bp->b_bufobj);
2136 		bp->b_vflags |= BV_BKGRDINPROG;
2137 		BO_UNLOCK(bp->b_bufobj);
2138 		newbp->b_xflags |= BX_BKGRDMARKER;
2139 		newbp->b_lblkno = bp->b_lblkno;
2140 		newbp->b_blkno = bp->b_blkno;
2141 		newbp->b_offset = bp->b_offset;
2142 		newbp->b_iodone = ffs_backgroundwritedone;
2143 		newbp->b_flags |= B_ASYNC;
2144 		newbp->b_flags &= ~B_INVAL;
2145 		pbgetvp(bp->b_vp, newbp);
2146 
2147 #ifdef SOFTUPDATES
2148 		/*
2149 		 * Move over the dependencies.  If there are rollbacks,
2150 		 * leave the parent buffer dirtied as it will need to
2151 		 * be written again.
2152 		 */
2153 		if (LIST_EMPTY(&bp->b_dep) ||
2154 		    softdep_move_dependencies(bp, newbp) == 0)
2155 			bundirty(bp);
2156 #else
2157 		bundirty(bp);
2158 #endif
2159 
2160 		/*
2161 		 * Initiate write on the copy, release the original.  The
2162 		 * BKGRDINPROG flag prevents it from going away until
2163 		 * the background write completes.
2164 		 */
2165 		bqrelse(bp);
2166 		bp = newbp;
2167 	} else
2168 		/* Mark the buffer clean */
2169 		bundirty(bp);
2170 
2171 
2172 	/* Let the normal bufwrite do the rest for us */
2173 normal_write:
2174 	return (bufwrite(bp));
2175 }
2176 
2177 
2178 static void
2179 ffs_geom_strategy(struct bufobj *bo, struct buf *bp)
2180 {
2181 	struct vnode *vp;
2182 	int error;
2183 	struct buf *tbp;
2184 	int nocopy;
2185 
2186 	vp = bo->__bo_vnode;
2187 	if (bp->b_iocmd == BIO_WRITE) {
2188 		if ((bp->b_flags & B_VALIDSUSPWRT) == 0 &&
2189 		    bp->b_vp != NULL && bp->b_vp->v_mount != NULL &&
2190 		    (bp->b_vp->v_mount->mnt_kern_flag & MNTK_SUSPENDED) != 0)
2191 			panic("ffs_geom_strategy: bad I/O");
2192 		nocopy = bp->b_flags & B_NOCOPY;
2193 		bp->b_flags &= ~(B_VALIDSUSPWRT | B_NOCOPY);
2194 		if ((vp->v_vflag & VV_COPYONWRITE) && nocopy == 0 &&
2195 		    vp->v_rdev->si_snapdata != NULL) {
2196 			if ((bp->b_flags & B_CLUSTER) != 0) {
2197 				runningbufwakeup(bp);
2198 				TAILQ_FOREACH(tbp, &bp->b_cluster.cluster_head,
2199 					      b_cluster.cluster_entry) {
2200 					error = ffs_copyonwrite(vp, tbp);
2201 					if (error != 0 &&
2202 					    error != EOPNOTSUPP) {
2203 						bp->b_error = error;
2204 						bp->b_ioflags |= BIO_ERROR;
2205 						bufdone(bp);
2206 						return;
2207 					}
2208 				}
2209 				bp->b_runningbufspace = bp->b_bufsize;
2210 				atomic_add_long(&runningbufspace,
2211 					       bp->b_runningbufspace);
2212 			} else {
2213 				error = ffs_copyonwrite(vp, bp);
2214 				if (error != 0 && error != EOPNOTSUPP) {
2215 					bp->b_error = error;
2216 					bp->b_ioflags |= BIO_ERROR;
2217 					bufdone(bp);
2218 					return;
2219 				}
2220 			}
2221 		}
2222 #ifdef SOFTUPDATES
2223 		if ((bp->b_flags & B_CLUSTER) != 0) {
2224 			TAILQ_FOREACH(tbp, &bp->b_cluster.cluster_head,
2225 				      b_cluster.cluster_entry) {
2226 				if (!LIST_EMPTY(&tbp->b_dep))
2227 					buf_start(tbp);
2228 			}
2229 		} else {
2230 			if (!LIST_EMPTY(&bp->b_dep))
2231 				buf_start(bp);
2232 		}
2233 
2234 #endif
2235 	}
2236 	g_vfs_strategy(bo, bp);
2237 }
2238 
2239 int
2240 ffs_own_mount(const struct mount *mp)
2241 {
2242 
2243 	if (mp->mnt_op == &ufs_vfsops)
2244 		return (1);
2245 	return (0);
2246 }
2247 
2248 #ifdef	DDB
2249 #ifdef SOFTUPDATES
2250 
2251 /* defined in ffs_softdep.c */
2252 extern void db_print_ffs(struct ufsmount *ump);
2253 
2254 DB_SHOW_COMMAND(ffs, db_show_ffs)
2255 {
2256 	struct mount *mp;
2257 	struct ufsmount *ump;
2258 
2259 	if (have_addr) {
2260 		ump = VFSTOUFS((struct mount *)addr);
2261 		db_print_ffs(ump);
2262 		return;
2263 	}
2264 
2265 	TAILQ_FOREACH(mp, &mountlist, mnt_list) {
2266 		if (!strcmp(mp->mnt_stat.f_fstypename, ufs_vfsconf.vfc_name))
2267 			db_print_ffs(VFSTOUFS(mp));
2268 	}
2269 }
2270 
2271 #endif	/* SOFTUPDATES */
2272 #endif	/* DDB */
2273