xref: /freebsd/sys/ufs/ffs/ffs_vfsops.c (revision 9ed01c32e069e448db5ce095761cc7d2c0c845fb)
160727d8bSWarner Losh /*-
2df8bae1dSRodney W. Grimes  * Copyright (c) 1989, 1991, 1993, 1994
3df8bae1dSRodney W. Grimes  *	The Regents of the University of California.  All rights reserved.
4df8bae1dSRodney W. Grimes  *
5df8bae1dSRodney W. Grimes  * Redistribution and use in source and binary forms, with or without
6df8bae1dSRodney W. Grimes  * modification, are permitted provided that the following conditions
7df8bae1dSRodney W. Grimes  * are met:
8df8bae1dSRodney W. Grimes  * 1. Redistributions of source code must retain the above copyright
9df8bae1dSRodney W. Grimes  *    notice, this list of conditions and the following disclaimer.
10df8bae1dSRodney W. Grimes  * 2. Redistributions in binary form must reproduce the above copyright
11df8bae1dSRodney W. Grimes  *    notice, this list of conditions and the following disclaimer in the
12df8bae1dSRodney W. Grimes  *    documentation and/or other materials provided with the distribution.
13fbbd9655SWarner Losh  * 3. Neither the name of the University nor the names of its contributors
14df8bae1dSRodney W. Grimes  *    may be used to endorse or promote products derived from this software
15df8bae1dSRodney W. Grimes  *    without specific prior written permission.
16df8bae1dSRodney W. Grimes  *
17df8bae1dSRodney W. Grimes  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18df8bae1dSRodney W. Grimes  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19df8bae1dSRodney W. Grimes  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20df8bae1dSRodney W. Grimes  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21df8bae1dSRodney W. Grimes  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22df8bae1dSRodney W. Grimes  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23df8bae1dSRodney W. Grimes  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24df8bae1dSRodney W. Grimes  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25df8bae1dSRodney W. Grimes  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26df8bae1dSRodney W. Grimes  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27df8bae1dSRodney W. Grimes  * SUCH DAMAGE.
28df8bae1dSRodney W. Grimes  *
29996c772fSJohn Dyson  *	@(#)ffs_vfsops.c	8.31 (Berkeley) 5/20/95
30df8bae1dSRodney W. Grimes  */
31df8bae1dSRodney W. Grimes 
32f4636c59SDavid E. O'Brien #include <sys/cdefs.h>
33f4636c59SDavid E. O'Brien __FBSDID("$FreeBSD$");
34f4636c59SDavid E. O'Brien 
3501733a9bSGarrett Wollman #include "opt_quota.h"
36516081f2SRobert Watson #include "opt_ufs.h"
376e77a041SPoul-Henning Kamp #include "opt_ffs.h"
3852dfc8d7SKonstantin Belousov #include "opt_ddb.h"
3901733a9bSGarrett Wollman 
40df8bae1dSRodney W. Grimes #include <sys/param.h>
41df8bae1dSRodney W. Grimes #include <sys/systm.h>
42df8bae1dSRodney W. Grimes #include <sys/namei.h>
43acd3428bSRobert Watson #include <sys/priv.h>
44df8bae1dSRodney W. Grimes #include <sys/proc.h>
45c79dff0fSKonstantin Belousov #include <sys/taskqueue.h>
46df8bae1dSRodney W. Grimes #include <sys/kernel.h>
47df8bae1dSRodney W. Grimes #include <sys/vnode.h>
48df8bae1dSRodney W. Grimes #include <sys/mount.h>
499626b608SPoul-Henning Kamp #include <sys/bio.h>
50df8bae1dSRodney W. Grimes #include <sys/buf.h>
5181bca6ddSKATO Takenori #include <sys/conf.h>
523ac4d1efSBruce Evans #include <sys/fcntl.h>
531848286aSEdward Tomasz Napierala #include <sys/ioccom.h>
54df8bae1dSRodney W. Grimes #include <sys/malloc.h>
551b367556SJason Evans #include <sys/mutex.h>
5622a72260SJeff Roberson #include <sys/rwlock.h>
57*9ed01c32SGleb Smirnoff #include <sys/vmmeter.h>
58a18b1f1dSJason Evans 
59aed55708SRobert Watson #include <security/mac/mac_framework.h>
60aed55708SRobert Watson 
61a96da1c3SConrad Meyer #include <ufs/ufs/dir.h>
62a64ed089SRobert Watson #include <ufs/ufs/extattr.h>
631a60c7fcSPawel Jakub Dawidek #include <ufs/ufs/gjournal.h>
64df8bae1dSRodney W. Grimes #include <ufs/ufs/quota.h>
65df8bae1dSRodney W. Grimes #include <ufs/ufs/ufsmount.h>
66df8bae1dSRodney W. Grimes #include <ufs/ufs/inode.h>
67df8bae1dSRodney W. Grimes #include <ufs/ufs/ufs_extern.h>
68df8bae1dSRodney W. Grimes 
69df8bae1dSRodney W. Grimes #include <ufs/ffs/fs.h>
70df8bae1dSRodney W. Grimes #include <ufs/ffs/ffs_extern.h>
71df8bae1dSRodney W. Grimes 
72f6b04d2bSDavid Greenman #include <vm/vm.h>
73aa4d7a8aSPoul-Henning Kamp #include <vm/uma.h>
74f6b04d2bSDavid Greenman #include <vm/vm_page.h>
75f6b04d2bSDavid Greenman 
7643920011SPoul-Henning Kamp #include <geom/geom.h>
7743920011SPoul-Henning Kamp #include <geom/geom_vfs.h>
7843920011SPoul-Henning Kamp 
7952dfc8d7SKonstantin Belousov #include <ddb/ddb.h>
8052dfc8d7SKonstantin Belousov 
81adf41577SPoul-Henning Kamp static uma_zone_t uma_inode, uma_ufs1, uma_ufs2;
8255166637SPoul-Henning Kamp 
83975512a9SPoul-Henning Kamp static int	ffs_mountfs(struct vnode *, struct mount *, struct thread *);
841c85e6a3SKirk McKusick static void	ffs_oldfscompat_read(struct fs *, struct ufsmount *,
851c85e6a3SKirk McKusick 		    ufs2_daddr_t);
86975512a9SPoul-Henning Kamp static void	ffs_ifree(struct ufsmount *ump, struct inode *ip);
87a988a5c6SKonstantin Belousov static int	ffs_sync_lazy(struct mount *mp);
88a988a5c6SKonstantin Belousov 
899bf1a756SPoul-Henning Kamp static vfs_init_t ffs_init;
909bf1a756SPoul-Henning Kamp static vfs_uninit_t ffs_uninit;
91d6fe88e4SPoul-Henning Kamp static vfs_extattrctl_t ffs_extattrctl;
9220a92a18SPoul-Henning Kamp static vfs_cmount_t ffs_cmount;
93adf41577SPoul-Henning Kamp static vfs_unmount_t ffs_unmount;
9420a92a18SPoul-Henning Kamp static vfs_mount_t ffs_mount;
95adf41577SPoul-Henning Kamp static vfs_statfs_t ffs_statfs;
96adf41577SPoul-Henning Kamp static vfs_fhtovp_t ffs_fhtovp;
97adf41577SPoul-Henning Kamp static vfs_sync_t ffs_sync;
98df8bae1dSRodney W. Grimes 
99303b270bSEivind Eklund static struct vfsops ufs_vfsops = {
1007652131bSPoul-Henning Kamp 	.vfs_extattrctl =	ffs_extattrctl,
1017652131bSPoul-Henning Kamp 	.vfs_fhtovp =		ffs_fhtovp,
1027652131bSPoul-Henning Kamp 	.vfs_init =		ffs_init,
10320a92a18SPoul-Henning Kamp 	.vfs_mount =		ffs_mount,
10420a92a18SPoul-Henning Kamp 	.vfs_cmount =		ffs_cmount,
1057652131bSPoul-Henning Kamp 	.vfs_quotactl =		ufs_quotactl,
1067652131bSPoul-Henning Kamp 	.vfs_root =		ufs_root,
1077652131bSPoul-Henning Kamp 	.vfs_statfs =		ffs_statfs,
1087652131bSPoul-Henning Kamp 	.vfs_sync =		ffs_sync,
1097652131bSPoul-Henning Kamp 	.vfs_uninit =		ffs_uninit,
1107652131bSPoul-Henning Kamp 	.vfs_unmount =		ffs_unmount,
1117652131bSPoul-Henning Kamp 	.vfs_vget =		ffs_vget,
1122814d5baSKonstantin Belousov 	.vfs_susp_clean =	process_deferred_inactive,
113df8bae1dSRodney W. Grimes };
114df8bae1dSRodney W. Grimes 
1158994ca3cSBruce Evans VFS_SET(ufs_vfsops, ufs, 0);
1165fe6d2beSPawel Jakub Dawidek MODULE_VERSION(ufs, 1);
117c901836cSGarrett Wollman 
1186e77a041SPoul-Henning Kamp static b_strategy_t ffs_geom_strategy;
119dd19a799SPoul-Henning Kamp static b_write_t ffs_bufwrite;
1206e77a041SPoul-Henning Kamp 
1216e77a041SPoul-Henning Kamp static struct buf_ops ffs_ops = {
1226e77a041SPoul-Henning Kamp 	.bop_name =	"FFS",
123dd19a799SPoul-Henning Kamp 	.bop_write =	ffs_bufwrite,
1246e77a041SPoul-Henning Kamp 	.bop_strategy =	ffs_geom_strategy,
1256ef8480aSPoul-Henning Kamp 	.bop_sync =	bufsync,
1262cc7d26fSKonstantin Belousov #ifdef NO_FFS_SNAPSHOT
1272cc7d26fSKonstantin Belousov 	.bop_bdflush =	bufbdflush,
1282cc7d26fSKonstantin Belousov #else
1292cc7d26fSKonstantin Belousov 	.bop_bdflush =	ffs_bdflush,
1302cc7d26fSKonstantin Belousov #endif
1316e77a041SPoul-Henning Kamp };
1326e77a041SPoul-Henning Kamp 
1330b962648SAndriy Gapon /*
1340b962648SAndriy Gapon  * Note that userquota and groupquota options are not currently used
1350b962648SAndriy Gapon  * by UFS/FFS code and generally mount(8) does not pass those options
1360b962648SAndriy Gapon  * from userland, but they can be passed by loader(8) via
1370b962648SAndriy Gapon  * vfs.root.mountfrom.options.
1380b962648SAndriy Gapon  */
139d952ba1bSJohn Baldwin static const char *ffs_opts[] = { "acls", "async", "noatime", "noclusterr",
1400b962648SAndriy Gapon     "noclusterw", "noexec", "export", "force", "from", "groupquota",
141927a12aeSKirk McKusick     "multilabel", "nfsv4acls", "fsckpid", "snapshot", "nosuid", "suiddir",
142927a12aeSKirk McKusick     "nosymfollow", "sync", "union", "userquota", NULL };
14320a92a18SPoul-Henning Kamp 
1445e8c582aSPoul-Henning Kamp static int
145dfd233edSAttilio Rao ffs_mount(struct mount *mp)
146df8bae1dSRodney W. Grimes {
14720a92a18SPoul-Henning Kamp 	struct vnode *devvp;
148dfd233edSAttilio Rao 	struct thread *td;
149f7a3729cSKevin Lo 	struct ufsmount *ump = NULL;
15005f4ff5dSPoul-Henning Kamp 	struct fs *fs;
151927a12aeSKirk McKusick 	pid_t fsckpid = 0;
152714b7df5SKonstantin Belousov 	int error, error1, flags;
153cc672d35SKirk McKusick 	uint64_t mntorflags;
15415bc6b2bSEdward Tomasz Napierala 	accmode_t accmode;
1555e8c582aSPoul-Henning Kamp 	struct nameidata ndp;
15620a92a18SPoul-Henning Kamp 	char *fspec;
157df8bae1dSRodney W. Grimes 
158dfd233edSAttilio Rao 	td = curthread;
15920a92a18SPoul-Henning Kamp 	if (vfs_filteropt(mp->mnt_optnew, ffs_opts))
16020a92a18SPoul-Henning Kamp 		return (EINVAL);
161aa4d7a8aSPoul-Henning Kamp 	if (uma_inode == NULL) {
162aa4d7a8aSPoul-Henning Kamp 		uma_inode = uma_zcreate("FFS inode",
163aa4d7a8aSPoul-Henning Kamp 		    sizeof(struct inode), NULL, NULL, NULL, NULL,
164aa4d7a8aSPoul-Henning Kamp 		    UMA_ALIGN_PTR, 0);
165aa4d7a8aSPoul-Henning Kamp 		uma_ufs1 = uma_zcreate("FFS1 dinode",
166aa4d7a8aSPoul-Henning Kamp 		    sizeof(struct ufs1_dinode), NULL, NULL, NULL, NULL,
167aa4d7a8aSPoul-Henning Kamp 		    UMA_ALIGN_PTR, 0);
168aa4d7a8aSPoul-Henning Kamp 		uma_ufs2 = uma_zcreate("FFS2 dinode",
169aa4d7a8aSPoul-Henning Kamp 		    sizeof(struct ufs2_dinode), NULL, NULL, NULL, NULL,
170aa4d7a8aSPoul-Henning Kamp 		    UMA_ALIGN_PTR, 0);
171aa4d7a8aSPoul-Henning Kamp 	}
1728d02a378SPawel Jakub Dawidek 
1730b962648SAndriy Gapon 	vfs_deleteopt(mp->mnt_optnew, "groupquota");
1740b962648SAndriy Gapon 	vfs_deleteopt(mp->mnt_optnew, "userquota");
1750b962648SAndriy Gapon 
17620a92a18SPoul-Henning Kamp 	fspec = vfs_getopts(mp->mnt_optnew, "from", &error);
17751ac12abSPoul-Henning Kamp 	if (error)
178f2a2857bSKirk McKusick 		return (error);
1792b14f991SJulian Elischer 
1805da56ddbSTor Egge 	mntorflags = 0;
18126f59b64SCraig Rodrigues 	if (vfs_getopt(mp->mnt_optnew, "acls", NULL, NULL) == 0)
1825da56ddbSTor Egge 		mntorflags |= MNT_ACLS;
18326f59b64SCraig Rodrigues 
184fb77e0afSCraig Rodrigues 	if (vfs_getopt(mp->mnt_optnew, "snapshot", NULL, NULL) == 0) {
1855da56ddbSTor Egge 		mntorflags |= MNT_SNAPSHOT;
186fb77e0afSCraig Rodrigues 		/*
187fb77e0afSCraig Rodrigues 		 * Once we have set the MNT_SNAPSHOT flag, do not
188fb77e0afSCraig Rodrigues 		 * persist "snapshot" in the options list.
189fb77e0afSCraig Rodrigues 		 */
190fb77e0afSCraig Rodrigues 		vfs_deleteopt(mp->mnt_optnew, "snapshot");
191fb77e0afSCraig Rodrigues 		vfs_deleteopt(mp->mnt_opt, "snapshot");
192fb77e0afSCraig Rodrigues 	}
19326f59b64SCraig Rodrigues 
194927a12aeSKirk McKusick 	if (vfs_getopt(mp->mnt_optnew, "fsckpid", NULL, NULL) == 0 &&
195927a12aeSKirk McKusick 	    vfs_scanopt(mp->mnt_optnew, "fsckpid", "%d", &fsckpid) == 1) {
196927a12aeSKirk McKusick 		/*
197927a12aeSKirk McKusick 		 * Once we have set the restricted PID, do not
198927a12aeSKirk McKusick 		 * persist "fsckpid" in the options list.
199927a12aeSKirk McKusick 		 */
200927a12aeSKirk McKusick 		vfs_deleteopt(mp->mnt_optnew, "fsckpid");
201927a12aeSKirk McKusick 		vfs_deleteopt(mp->mnt_opt, "fsckpid");
202927a12aeSKirk McKusick 		if (mp->mnt_flag & MNT_UPDATE) {
203927a12aeSKirk McKusick 			if (VFSTOUFS(mp)->um_fs->fs_ronly == 0 &&
204927a12aeSKirk McKusick 			     vfs_flagopt(mp->mnt_optnew, "ro", NULL, 0) == 0) {
205b60ee81eSKirk McKusick 				vfs_mount_error(mp,
206b60ee81eSKirk McKusick 				    "Checker enable: Must be read-only");
207927a12aeSKirk McKusick 				return (EINVAL);
208927a12aeSKirk McKusick 			}
209927a12aeSKirk McKusick 		} else if (vfs_flagopt(mp->mnt_optnew, "ro", NULL, 0) == 0) {
210b60ee81eSKirk McKusick 			vfs_mount_error(mp,
211b60ee81eSKirk McKusick 			    "Checker enable: Must be read-only");
212927a12aeSKirk McKusick 			return (EINVAL);
213927a12aeSKirk McKusick 		}
214927a12aeSKirk McKusick 		/* Set to -1 if we are done */
215927a12aeSKirk McKusick 		if (fsckpid == 0)
216927a12aeSKirk McKusick 			fsckpid = -1;
217927a12aeSKirk McKusick 	}
218927a12aeSKirk McKusick 
2199340fc72SEdward Tomasz Napierala 	if (vfs_getopt(mp->mnt_optnew, "nfsv4acls", NULL, NULL) == 0) {
2209340fc72SEdward Tomasz Napierala 		if (mntorflags & MNT_ACLS) {
221b60ee81eSKirk McKusick 			vfs_mount_error(mp,
222b60ee81eSKirk McKusick 			    "\"acls\" and \"nfsv4acls\" options "
223b60ee81eSKirk McKusick 			    "are mutually exclusive");
2249340fc72SEdward Tomasz Napierala 			return (EINVAL);
2259340fc72SEdward Tomasz Napierala 		}
2269340fc72SEdward Tomasz Napierala 		mntorflags |= MNT_NFS4ACLS;
2279340fc72SEdward Tomasz Napierala 	}
2289340fc72SEdward Tomasz Napierala 
2295da56ddbSTor Egge 	MNT_ILOCK(mp);
23061996181SEdward Tomasz Napierala 	mp->mnt_flag |= mntorflags;
2315da56ddbSTor Egge 	MNT_IUNLOCK(mp);
232df8bae1dSRodney W. Grimes 	/*
233df8bae1dSRodney W. Grimes 	 * If updating, check whether changing from read-only to
234df8bae1dSRodney W. Grimes 	 * read/write; if there is no device name, that's all we do.
235df8bae1dSRodney W. Grimes 	 */
236df8bae1dSRodney W. Grimes 	if (mp->mnt_flag & MNT_UPDATE) {
237df8bae1dSRodney W. Grimes 		ump = VFSTOUFS(mp);
238df8bae1dSRodney W. Grimes 		fs = ump->um_fs;
23926cf9c3bSPeter Wemm 		devvp = ump->um_devvp;
240927a12aeSKirk McKusick 		if (fsckpid == -1 && ump->um_fsckpid > 0) {
241927a12aeSKirk McKusick 			if ((error = ffs_flushfiles(mp, WRITECLOSE, td)) != 0 ||
242927a12aeSKirk McKusick 			    (error = ffs_sbupdate(ump, MNT_WAIT, 0)) != 0)
243927a12aeSKirk McKusick 				return (error);
244927a12aeSKirk McKusick 			g_topology_lock();
245927a12aeSKirk McKusick 			/*
246927a12aeSKirk McKusick 			 * Return to normal read-only mode.
247927a12aeSKirk McKusick 			 */
248927a12aeSKirk McKusick 			error = g_access(ump->um_cp, 0, -1, 0);
249927a12aeSKirk McKusick 			g_topology_unlock();
250927a12aeSKirk McKusick 			ump->um_fsckpid = 0;
251927a12aeSKirk McKusick 		}
25220a92a18SPoul-Henning Kamp 		if (fs->fs_ronly == 0 &&
25320a92a18SPoul-Henning Kamp 		    vfs_flagopt(mp->mnt_optnew, "ro", NULL, 0)) {
2546fecb4e4SKonstantin Belousov 			/*
2556fecb4e4SKonstantin Belousov 			 * Flush any dirty data and suspend filesystem.
2566fecb4e4SKonstantin Belousov 			 */
257f2a2857bSKirk McKusick 			if ((error = vn_start_write(NULL, &mp, V_WAIT)) != 0)
258f2a2857bSKirk McKusick 				return (error);
259895b3782SKonstantin Belousov 			error = vfs_write_suspend_umnt(mp);
260895b3782SKonstantin Belousov 			if (error != 0)
2619ab73fd1SKirk McKusick 				return (error);
262cd600596SKirk McKusick 			/*
263cd600596SKirk McKusick 			 * Check for and optionally get rid of files open
264cd600596SKirk McKusick 			 * for writing.
265cd600596SKirk McKusick 			 */
266df8bae1dSRodney W. Grimes 			flags = WRITECLOSE;
267df8bae1dSRodney W. Grimes 			if (mp->mnt_flag & MNT_FORCE)
268df8bae1dSRodney W. Grimes 				flags |= FORCECLOSE;
269fddf7baeSKirk McKusick 			if (MOUNTEDSOFTDEP(mp)) {
270b40ce416SJulian Elischer 				error = softdep_flushfiles(mp, flags, td);
271b1897c19SJulian Elischer 			} else {
272b40ce416SJulian Elischer 				error = ffs_flushfiles(mp, flags, td);
273df8bae1dSRodney W. Grimes 			}
274f2a2857bSKirk McKusick 			if (error) {
275ddd6b3fcSKonstantin Belousov 				vfs_write_resume(mp, 0);
276f2a2857bSKirk McKusick 				return (error);
277b1897c19SJulian Elischer 			}
2789ccb939eSKirk McKusick 			if (fs->fs_pendingblocks != 0 ||
2799ccb939eSKirk McKusick 			    fs->fs_pendinginodes != 0) {
280b60ee81eSKirk McKusick 				printf("WARNING: %s Update error: blocks %jd "
281b60ee81eSKirk McKusick 				    "files %d\n", fs->fs_fsmnt,
2821c85e6a3SKirk McKusick 				    (intmax_t)fs->fs_pendingblocks,
2839ccb939eSKirk McKusick 				    fs->fs_pendinginodes);
2849ccb939eSKirk McKusick 				fs->fs_pendingblocks = 0;
2859ccb939eSKirk McKusick 				fs->fs_pendinginodes = 0;
2869ccb939eSKirk McKusick 			}
2871a6a6610SKirk McKusick 			if ((fs->fs_flags & (FS_UNCLEAN | FS_NEEDSFSCK)) == 0)
288f2a2857bSKirk McKusick 				fs->fs_clean = 1;
289791dd2faSTor Egge 			if ((error = ffs_sbupdate(ump, MNT_WAIT, 0)) != 0) {
290f2a2857bSKirk McKusick 				fs->fs_ronly = 0;
291f2a2857bSKirk McKusick 				fs->fs_clean = 0;
292ddd6b3fcSKonstantin Belousov 				vfs_write_resume(mp, 0);
293f2a2857bSKirk McKusick 				return (error);
2942b14f991SJulian Elischer 			}
295fddf7baeSKirk McKusick 			if (MOUNTEDSOFTDEP(mp))
2969420dc62SKirk McKusick 				softdep_unmount(mp);
29743920011SPoul-Henning Kamp 			g_topology_lock();
2988795189cSKirk McKusick 			/*
2998795189cSKirk McKusick 			 * Drop our write and exclusive access.
3008795189cSKirk McKusick 			 */
3018795189cSKirk McKusick 			g_access(ump->um_cp, 0, -1, -1);
30243920011SPoul-Henning Kamp 			g_topology_unlock();
30320a92a18SPoul-Henning Kamp 			fs->fs_ronly = 1;
3045da56ddbSTor Egge 			MNT_ILOCK(mp);
30520a92a18SPoul-Henning Kamp 			mp->mnt_flag |= MNT_RDONLY;
3065da56ddbSTor Egge 			MNT_IUNLOCK(mp);
3076fecb4e4SKonstantin Belousov 			/*
3086fecb4e4SKonstantin Belousov 			 * Allow the writers to note that filesystem
3096fecb4e4SKonstantin Belousov 			 * is ro now.
3106fecb4e4SKonstantin Belousov 			 */
311ddd6b3fcSKonstantin Belousov 			vfs_write_resume(mp, 0);
312f2a2857bSKirk McKusick 		}
313f2a2857bSKirk McKusick 		if ((mp->mnt_flag & MNT_RELOAD) &&
3141848286aSEdward Tomasz Napierala 		    (error = ffs_reload(mp, td, 0)) != 0)
315f2a2857bSKirk McKusick 			return (error);
31620a92a18SPoul-Henning Kamp 		if (fs->fs_ronly &&
31720a92a18SPoul-Henning Kamp 		    !vfs_flagopt(mp->mnt_optnew, "ro", NULL, 0)) {
318c9b99213SBruce Evans 			/*
319927a12aeSKirk McKusick 			 * If we are running a checker, do not allow upgrade.
320927a12aeSKirk McKusick 			 */
321927a12aeSKirk McKusick 			if (ump->um_fsckpid > 0) {
322b60ee81eSKirk McKusick 				vfs_mount_error(mp,
323b60ee81eSKirk McKusick 				    "Active checker, cannot upgrade to write");
324927a12aeSKirk McKusick 				return (EINVAL);
325927a12aeSKirk McKusick 			}
326927a12aeSKirk McKusick 			/*
327c9b99213SBruce Evans 			 * If upgrade to read-write by non-root, then verify
328c9b99213SBruce Evans 			 * that user has necessary permissions on the device.
329c9b99213SBruce Evans 			 */
330cb05b60aSAttilio Rao 			vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
331acd3428bSRobert Watson 			error = VOP_ACCESS(devvp, VREAD | VWRITE,
332acd3428bSRobert Watson 			    td->td_ucred, td);
333acd3428bSRobert Watson 			if (error)
334acd3428bSRobert Watson 				error = priv_check(td, PRIV_VFS_MOUNT_PERM);
335acd3428bSRobert Watson 			if (error) {
33622db15c0SAttilio Rao 				VOP_UNLOCK(devvp, 0);
337c9b99213SBruce Evans 				return (error);
338c9b99213SBruce Evans 			}
33922db15c0SAttilio Rao 			VOP_UNLOCK(devvp, 0);
3407e58bfacSBruce Evans 			fs->fs_flags &= ~FS_UNCLEAN;
3410922cce6SBruce Evans 			if (fs->fs_clean == 0) {
3427e58bfacSBruce Evans 				fs->fs_flags |= FS_UNCLEAN;
343812b1d41SKirk McKusick 				if ((mp->mnt_flag & MNT_FORCE) ||
344113db2ddSJeff Roberson 				    ((fs->fs_flags &
345113db2ddSJeff Roberson 				     (FS_SUJ | FS_NEEDSFSCK)) == 0 &&
3461a6a6610SKirk McKusick 				     (fs->fs_flags & FS_DOSOFTDEP))) {
347b60ee81eSKirk McKusick 					printf("WARNING: %s was not properly "
348b60ee81eSKirk McKusick 					   "dismounted\n", fs->fs_fsmnt);
3490922cce6SBruce Evans 				} else {
350b60ee81eSKirk McKusick 					vfs_mount_error(mp,
351b60ee81eSKirk McKusick 					   "R/W mount of %s denied. %s.%s",
352b60ee81eSKirk McKusick 					   fs->fs_fsmnt,
353b60ee81eSKirk McKusick 					   "Filesystem is not clean - run fsck",
354b60ee81eSKirk McKusick 					   (fs->fs_flags & FS_SUJ) == 0 ? "" :
355b60ee81eSKirk McKusick 					   " Forced mount will invalidate"
356b60ee81eSKirk McKusick 					   " journal contents");
357f2a2857bSKirk McKusick 					return (EPERM);
3580922cce6SBruce Evans 				}
3590922cce6SBruce Evans 			}
36040c340aaSPoul-Henning Kamp 			g_topology_lock();
36140c340aaSPoul-Henning Kamp 			/*
3628795189cSKirk McKusick 			 * Request exclusive write access.
36340c340aaSPoul-Henning Kamp 			 */
36440c340aaSPoul-Henning Kamp 			error = g_access(ump->um_cp, 0, 1, 1);
36540c340aaSPoul-Henning Kamp 			g_topology_unlock();
36640c340aaSPoul-Henning Kamp 			if (error)
36740c340aaSPoul-Henning Kamp 				return (error);
368f2a2857bSKirk McKusick 			if ((error = vn_start_write(NULL, &mp, V_WAIT)) != 0)
369f2a2857bSKirk McKusick 				return (error);
370f2a2857bSKirk McKusick 			fs->fs_ronly = 0;
3715da56ddbSTor Egge 			MNT_ILOCK(mp);
37220a92a18SPoul-Henning Kamp 			mp->mnt_flag &= ~MNT_RDONLY;
3735da56ddbSTor Egge 			MNT_IUNLOCK(mp);
374113db2ddSJeff Roberson 			fs->fs_mtime = time_second;
37526cf9c3bSPeter Wemm 			/* check to see if we need to start softdep */
376f2a2857bSKirk McKusick 			if ((fs->fs_flags & FS_DOSOFTDEP) &&
377a854ed98SJohn Baldwin 			    (error = softdep_mount(devvp, mp, fs, td->td_ucred))){
378f2a2857bSKirk McKusick 				vn_finished_write(mp);
379f2a2857bSKirk McKusick 				return (error);
38026cf9c3bSPeter Wemm 			}
381113db2ddSJeff Roberson 			fs->fs_clean = 0;
382113db2ddSJeff Roberson 			if ((error = ffs_sbupdate(ump, MNT_WAIT, 0)) != 0) {
383113db2ddSJeff Roberson 				vn_finished_write(mp);
384113db2ddSJeff Roberson 				return (error);
385113db2ddSJeff Roberson 			}
386f2a2857bSKirk McKusick 			if (fs->fs_snapinum[0] != 0)
387f2a2857bSKirk McKusick 				ffs_snapshot_mount(mp);
388f2a2857bSKirk McKusick 			vn_finished_write(mp);
3891469eec8SDavid Greenman 		}
390c11d2981SJulian Elischer 		/*
391c11d2981SJulian Elischer 		 * Soft updates is incompatible with "async",
392c11d2981SJulian Elischer 		 * so if we are doing softupdates stop the user
393c11d2981SJulian Elischer 		 * from setting the async flag in an update.
394c11d2981SJulian Elischer 		 * Softdep_mount() clears it in an initial mount
395c11d2981SJulian Elischer 		 * or ro->rw remount.
396c11d2981SJulian Elischer 		 */
397fddf7baeSKirk McKusick 		if (MOUNTEDSOFTDEP(mp)) {
3985da56ddbSTor Egge 			/* XXX: Reset too late ? */
3995da56ddbSTor Egge 			MNT_ILOCK(mp);
400c11d2981SJulian Elischer 			mp->mnt_flag &= ~MNT_ASYNC;
4015da56ddbSTor Egge 			MNT_IUNLOCK(mp);
4025da56ddbSTor Egge 		}
403df8bae1dSRodney W. Grimes 		/*
40439cfb239SPawel Jakub Dawidek 		 * Keep MNT_ACLS flag if it is stored in superblock.
40539cfb239SPawel Jakub Dawidek 		 */
4065da56ddbSTor Egge 		if ((fs->fs_flags & FS_ACLS) != 0) {
4075da56ddbSTor Egge 			/* XXX: Set too late ? */
4085da56ddbSTor Egge 			MNT_ILOCK(mp);
40939cfb239SPawel Jakub Dawidek 			mp->mnt_flag |= MNT_ACLS;
4105da56ddbSTor Egge 			MNT_IUNLOCK(mp);
4115da56ddbSTor Egge 		}
412cea90362SCraig Rodrigues 
4139340fc72SEdward Tomasz Napierala 		if ((fs->fs_flags & FS_NFS4ACLS) != 0) {
4149340fc72SEdward Tomasz Napierala 			/* XXX: Set too late ? */
4159340fc72SEdward Tomasz Napierala 			MNT_ILOCK(mp);
4169340fc72SEdward Tomasz Napierala 			mp->mnt_flag |= MNT_NFS4ACLS;
4179340fc72SEdward Tomasz Napierala 			MNT_IUNLOCK(mp);
4189340fc72SEdward Tomasz Napierala 		}
419927a12aeSKirk McKusick 		/*
420927a12aeSKirk McKusick 		 * If this is a request from fsck to clean up the filesystem,
421927a12aeSKirk McKusick 		 * then allow the specified pid to proceed.
422927a12aeSKirk McKusick 		 */
423927a12aeSKirk McKusick 		if (fsckpid > 0) {
424927a12aeSKirk McKusick 			if (ump->um_fsckpid != 0) {
425b60ee81eSKirk McKusick 				vfs_mount_error(mp,
426b60ee81eSKirk McKusick 				    "Active checker already running on %s",
427927a12aeSKirk McKusick 				    fs->fs_fsmnt);
428927a12aeSKirk McKusick 				return (EINVAL);
429927a12aeSKirk McKusick 			}
430fddf7baeSKirk McKusick 			KASSERT(MOUNTEDSOFTDEP(mp) == 0,
431927a12aeSKirk McKusick 			    ("soft updates enabled on read-only file system"));
432927a12aeSKirk McKusick 			g_topology_lock();
433927a12aeSKirk McKusick 			/*
434927a12aeSKirk McKusick 			 * Request write access.
435927a12aeSKirk McKusick 			 */
436927a12aeSKirk McKusick 			error = g_access(ump->um_cp, 0, 1, 0);
437927a12aeSKirk McKusick 			g_topology_unlock();
438927a12aeSKirk McKusick 			if (error) {
439b60ee81eSKirk McKusick 				vfs_mount_error(mp,
440b60ee81eSKirk McKusick 				    "Checker activation failed on %s",
441927a12aeSKirk McKusick 				    fs->fs_fsmnt);
442927a12aeSKirk McKusick 				return (error);
443927a12aeSKirk McKusick 			}
444927a12aeSKirk McKusick 			ump->um_fsckpid = fsckpid;
445927a12aeSKirk McKusick 			if (fs->fs_snapinum[0] != 0)
446927a12aeSKirk McKusick 				ffs_snapshot_mount(mp);
447927a12aeSKirk McKusick 			fs->fs_mtime = time_second;
448927a12aeSKirk McKusick 			fs->fs_fmod = 1;
449927a12aeSKirk McKusick 			fs->fs_clean = 0;
450927a12aeSKirk McKusick 			(void) ffs_sbupdate(ump, MNT_WAIT, 0);
451927a12aeSKirk McKusick 		}
4529340fc72SEdward Tomasz Napierala 
453f2a2857bSKirk McKusick 		/*
454f2a2857bSKirk McKusick 		 * If this is a snapshot request, take the snapshot.
455f2a2857bSKirk McKusick 		 */
456f2a2857bSKirk McKusick 		if (mp->mnt_flag & MNT_SNAPSHOT)
45720a92a18SPoul-Henning Kamp 			return (ffs_snapshot(mp, fspec));
458714b7df5SKonstantin Belousov 
459714b7df5SKonstantin Belousov 		/*
460714b7df5SKonstantin Belousov 		 * Must not call namei() while owning busy ref.
461714b7df5SKonstantin Belousov 		 */
462714b7df5SKonstantin Belousov 		vfs_unbusy(mp);
463df8bae1dSRodney W. Grimes 	}
4642b14f991SJulian Elischer 
465df8bae1dSRodney W. Grimes 	/*
466df8bae1dSRodney W. Grimes 	 * Not an update, or updating the name: look up the name
467e9827c6dSBruce Evans 	 * and verify that it refers to a sensible disk device.
468df8bae1dSRodney W. Grimes 	 */
469fdedad76SSuleiman Souhlal 	NDINIT(&ndp, LOOKUP, FOLLOW | LOCKLEAF, UIO_SYSSPACE, fspec, td);
470714b7df5SKonstantin Belousov 	error = namei(&ndp);
471714b7df5SKonstantin Belousov 	if ((mp->mnt_flag & MNT_UPDATE) != 0) {
472714b7df5SKonstantin Belousov 		/*
473714b7df5SKonstantin Belousov 		 * Unmount does not start if MNT_UPDATE is set.  Mount
474714b7df5SKonstantin Belousov 		 * update busies mp before setting MNT_UPDATE.  We
475714b7df5SKonstantin Belousov 		 * must be able to retain our busy ref succesfully,
476714b7df5SKonstantin Belousov 		 * without sleep.
477714b7df5SKonstantin Belousov 		 */
478714b7df5SKonstantin Belousov 		error1 = vfs_busy(mp, MBF_NOWAIT);
479714b7df5SKonstantin Belousov 		MPASS(error1 == 0);
480714b7df5SKonstantin Belousov 	}
481714b7df5SKonstantin Belousov 	if (error != 0)
482f2a2857bSKirk McKusick 		return (error);
4835e8c582aSPoul-Henning Kamp 	NDFREE(&ndp, NDF_ONLY_PNBUF);
4845e8c582aSPoul-Henning Kamp 	devvp = ndp.ni_vp;
485f2a2857bSKirk McKusick 	if (!vn_isdisk(devvp, &error)) {
486fdedad76SSuleiman Souhlal 		vput(devvp);
487f2a2857bSKirk McKusick 		return (error);
488f2a2857bSKirk McKusick 	}
489c9b99213SBruce Evans 
490c9b99213SBruce Evans 	/*
491c9b99213SBruce Evans 	 * If mount by non-root, then verify that user has necessary
492c9b99213SBruce Evans 	 * permissions on the device.
493c9b99213SBruce Evans 	 */
49415bc6b2bSEdward Tomasz Napierala 	accmode = VREAD;
495c9b99213SBruce Evans 	if ((mp->mnt_flag & MNT_RDONLY) == 0)
49615bc6b2bSEdward Tomasz Napierala 		accmode |= VWRITE;
49715bc6b2bSEdward Tomasz Napierala 	error = VOP_ACCESS(devvp, accmode, td->td_ucred, td);
498acd3428bSRobert Watson 	if (error)
499acd3428bSRobert Watson 		error = priv_check(td, PRIV_VFS_MOUNT_PERM);
500acd3428bSRobert Watson 	if (error) {
501c9b99213SBruce Evans 		vput(devvp);
502c9b99213SBruce Evans 		return (error);
503c9b99213SBruce Evans 	}
504c9b99213SBruce Evans 
5052b14f991SJulian Elischer 	if (mp->mnt_flag & MNT_UPDATE) {
5062b14f991SJulian Elischer 		/*
507f2a2857bSKirk McKusick 		 * Update only
508f2a2857bSKirk McKusick 		 *
5093e425b96SJulian Elischer 		 * If it's not the same vnode, or at least the same device
5103e425b96SJulian Elischer 		 * then it's not correct.
5112b14f991SJulian Elischer 		 */
5122b14f991SJulian Elischer 
51343920011SPoul-Henning Kamp 		if (devvp->v_rdev != ump->um_devvp->v_rdev)
514f2a2857bSKirk McKusick 			error = EINVAL;	/* needs translation */
515fdedad76SSuleiman Souhlal 		vput(devvp);
516f2a2857bSKirk McKusick 		if (error)
517f2a2857bSKirk McKusick 			return (error);
5182b14f991SJulian Elischer 	} else {
5192b14f991SJulian Elischer 		/*
520f2a2857bSKirk McKusick 		 * New mount
5212b14f991SJulian Elischer 		 *
522f2a2857bSKirk McKusick 		 * We need the name for the mount point (also used for
523f2a2857bSKirk McKusick 		 * "last mounted on") copied in. If an error occurs,
524f2a2857bSKirk McKusick 		 * the mount point is discarded by the upper level code.
52598cbffd7SKonstantin Belousov 		 * Note that vfs_mount_alloc() populates f_mntonname for us.
526f2a2857bSKirk McKusick 		 */
527975512a9SPoul-Henning Kamp 		if ((error = ffs_mountfs(devvp, mp, td)) != 0) {
528f2a2857bSKirk McKusick 			vrele(devvp);
529f2a2857bSKirk McKusick 			return (error);
530f2a2857bSKirk McKusick 		}
531927a12aeSKirk McKusick 		if (fsckpid > 0) {
532fddf7baeSKirk McKusick 			KASSERT(MOUNTEDSOFTDEP(mp) == 0,
533927a12aeSKirk McKusick 			    ("soft updates enabled on read-only file system"));
534927a12aeSKirk McKusick 			ump = VFSTOUFS(mp);
535927a12aeSKirk McKusick 			fs = ump->um_fs;
536927a12aeSKirk McKusick 			g_topology_lock();
537927a12aeSKirk McKusick 			/*
538927a12aeSKirk McKusick 			 * Request write access.
539927a12aeSKirk McKusick 			 */
540927a12aeSKirk McKusick 			error = g_access(ump->um_cp, 0, 1, 0);
541927a12aeSKirk McKusick 			g_topology_unlock();
542927a12aeSKirk McKusick 			if (error) {
543b60ee81eSKirk McKusick 				printf("WARNING: %s: Checker activation "
544b60ee81eSKirk McKusick 				    "failed\n", fs->fs_fsmnt);
545927a12aeSKirk McKusick 			} else {
546927a12aeSKirk McKusick 				ump->um_fsckpid = fsckpid;
547927a12aeSKirk McKusick 				if (fs->fs_snapinum[0] != 0)
548927a12aeSKirk McKusick 					ffs_snapshot_mount(mp);
549927a12aeSKirk McKusick 				fs->fs_mtime = time_second;
550927a12aeSKirk McKusick 				fs->fs_clean = 0;
551927a12aeSKirk McKusick 				(void) ffs_sbupdate(ump, MNT_WAIT, 0);
552927a12aeSKirk McKusick 			}
553927a12aeSKirk McKusick 		}
554f2a2857bSKirk McKusick 	}
55520a92a18SPoul-Henning Kamp 	vfs_mountedfrom(mp, fspec);
556f2a2857bSKirk McKusick 	return (0);
5572b14f991SJulian Elischer }
5582b14f991SJulian Elischer 
559df8bae1dSRodney W. Grimes /*
56020a92a18SPoul-Henning Kamp  * Compatibility with old mount system call.
56120a92a18SPoul-Henning Kamp  */
56220a92a18SPoul-Henning Kamp 
56320a92a18SPoul-Henning Kamp static int
564cc672d35SKirk McKusick ffs_cmount(struct mntarg *ma, void *data, uint64_t flags)
56520a92a18SPoul-Henning Kamp {
56620a92a18SPoul-Henning Kamp 	struct ufs_args args;
567d0cc54f3SKonstantin Belousov 	struct export_args exp;
56820a92a18SPoul-Henning Kamp 	int error;
56920a92a18SPoul-Henning Kamp 
57020a92a18SPoul-Henning Kamp 	if (data == NULL)
57120a92a18SPoul-Henning Kamp 		return (EINVAL);
57220a92a18SPoul-Henning Kamp 	error = copyin(data, &args, sizeof args);
57320a92a18SPoul-Henning Kamp 	if (error)
57420a92a18SPoul-Henning Kamp 		return (error);
575d0cc54f3SKonstantin Belousov 	vfs_oexport_conv(&args.export, &exp);
57620a92a18SPoul-Henning Kamp 
57720a92a18SPoul-Henning Kamp 	ma = mount_argsu(ma, "from", args.fspec, MAXPATHLEN);
578d0cc54f3SKonstantin Belousov 	ma = mount_arg(ma, "export", &exp, sizeof(exp));
57920a92a18SPoul-Henning Kamp 	error = kernel_mount(ma, flags);
58020a92a18SPoul-Henning Kamp 
58120a92a18SPoul-Henning Kamp 	return (error);
58220a92a18SPoul-Henning Kamp }
58320a92a18SPoul-Henning Kamp 
58420a92a18SPoul-Henning Kamp /*
585df8bae1dSRodney W. Grimes  * Reload all incore data for a filesystem (used after running fsck on
5861848286aSEdward Tomasz Napierala  * the root filesystem and finding things to fix). If the 'force' flag
5871848286aSEdward Tomasz Napierala  * is 0, the filesystem must be mounted read-only.
588df8bae1dSRodney W. Grimes  *
589df8bae1dSRodney W. Grimes  * Things to do to update the mount:
590df8bae1dSRodney W. Grimes  *	1) invalidate all cached meta-data.
591df8bae1dSRodney W. Grimes  *	2) re-read superblock from disk.
592df8bae1dSRodney W. Grimes  *	3) re-read summary information from disk.
593df8bae1dSRodney W. Grimes  *	4) invalidate all inactive vnodes.
594df426577SKonstantin Belousov  *	5) clear MNTK_SUSPEND2 and MNTK_SUSPENDED flags, allowing secondary
595df426577SKonstantin Belousov  *	   writers, if requested.
596df426577SKonstantin Belousov  *	6) invalidate all cached file data.
597df426577SKonstantin Belousov  *	7) re-read inode data for all active vnodes.
598df8bae1dSRodney W. Grimes  */
5991848286aSEdward Tomasz Napierala int
600df426577SKonstantin Belousov ffs_reload(struct mount *mp, struct thread *td, int flags)
601df8bae1dSRodney W. Grimes {
60282be0a5aSTor Egge 	struct vnode *vp, *mvp, *devvp;
603df8bae1dSRodney W. Grimes 	struct inode *ip;
604f55ff3f3SIan Dowse 	void *space;
605df8bae1dSRodney W. Grimes 	struct buf *bp;
606996c772fSJohn Dyson 	struct fs *fs, *newfs;
6073ba649d7SJeff Roberson 	struct ufsmount *ump;
6081c85e6a3SKirk McKusick 	ufs2_daddr_t sblockloc;
609ad544726SKirk McKusick 	int i, blks, error;
610ad544726SKirk McKusick 	u_long size;
611996c772fSJohn Dyson 	int32_t *lp;
612df8bae1dSRodney W. Grimes 
6133ba649d7SJeff Roberson 	ump = VFSTOUFS(mp);
6141848286aSEdward Tomasz Napierala 
6151848286aSEdward Tomasz Napierala 	MNT_ILOCK(mp);
616df426577SKonstantin Belousov 	if ((mp->mnt_flag & MNT_RDONLY) == 0 && (flags & FFSR_FORCE) == 0) {
6171848286aSEdward Tomasz Napierala 		MNT_IUNLOCK(mp);
6181848286aSEdward Tomasz Napierala 		return (EINVAL);
6191848286aSEdward Tomasz Napierala 	}
6201848286aSEdward Tomasz Napierala 	MNT_IUNLOCK(mp);
6211848286aSEdward Tomasz Napierala 
622df8bae1dSRodney W. Grimes 	/*
623df8bae1dSRodney W. Grimes 	 * Step 1: invalidate all cached meta-data.
624df8bae1dSRodney W. Grimes 	 */
6252b14f991SJulian Elischer 	devvp = VFSTOUFS(mp)->um_devvp;
626cb05b60aSAttilio Rao 	vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
6270d7935fdSAttilio Rao 	if (vinvalbuf(devvp, 0, 0, 0) != 0)
628df8bae1dSRodney W. Grimes 		panic("ffs_reload: dirty1");
62922db15c0SAttilio Rao 	VOP_UNLOCK(devvp, 0);
63095e5e988SJohn Dyson 
631df8bae1dSRodney W. Grimes 	/*
632df8bae1dSRodney W. Grimes 	 * Step 2: re-read superblock from disk.
633df8bae1dSRodney W. Grimes 	 */
6341c85e6a3SKirk McKusick 	fs = VFSTOUFS(mp)->um_fs;
635ada981b2SKirk McKusick 	if ((error = bread(devvp, btodb(fs->fs_sblockloc), fs->fs_sbsize,
6361c85e6a3SKirk McKusick 	    NOCRED, &bp)) != 0)
637df8bae1dSRodney W. Grimes 		return (error);
638996c772fSJohn Dyson 	newfs = (struct fs *)bp->b_data;
6391c85e6a3SKirk McKusick 	if ((newfs->fs_magic != FS_UFS1_MAGIC &&
6401c85e6a3SKirk McKusick 	     newfs->fs_magic != FS_UFS2_MAGIC) ||
6411c85e6a3SKirk McKusick 	    newfs->fs_bsize > MAXBSIZE ||
642996c772fSJohn Dyson 	    newfs->fs_bsize < sizeof(struct fs)) {
643df8bae1dSRodney W. Grimes 			brelse(bp);
644df8bae1dSRodney W. Grimes 			return (EIO);		/* XXX needs translation */
645df8bae1dSRodney W. Grimes 	}
646996c772fSJohn Dyson 	/*
647996c772fSJohn Dyson 	 * Copy pointer fields back into superblock before copying in	XXX
648996c772fSJohn Dyson 	 * new superblock. These should really be in the ufsmount.	XXX
649996c772fSJohn Dyson 	 * Note that important parameters (eg fs_ncg) are unchanged.
650996c772fSJohn Dyson 	 */
651f55ff3f3SIan Dowse 	newfs->fs_csp = fs->fs_csp;
652996c772fSJohn Dyson 	newfs->fs_maxcluster = fs->fs_maxcluster;
6535d69bac4SIan Dowse 	newfs->fs_contigdirs = fs->fs_contigdirs;
654143a5346SIan Dowse 	newfs->fs_active = fs->fs_active;
6551848286aSEdward Tomasz Napierala 	newfs->fs_ronly = fs->fs_ronly;
6561c85e6a3SKirk McKusick 	sblockloc = fs->fs_sblockloc;
657996c772fSJohn Dyson 	bcopy(newfs, fs, (u_int)fs->fs_sbsize);
658df8bae1dSRodney W. Grimes 	brelse(bp);
659996c772fSJohn Dyson 	mp->mnt_maxsymlinklen = fs->fs_maxsymlinklen;
6601c85e6a3SKirk McKusick 	ffs_oldfscompat_read(fs, VFSTOUFS(mp), sblockloc);
6613ba649d7SJeff Roberson 	UFS_LOCK(ump);
6629ccb939eSKirk McKusick 	if (fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) {
663b60ee81eSKirk McKusick 		printf("WARNING: %s: reload pending error: blocks %jd "
664b60ee81eSKirk McKusick 		    "files %d\n", fs->fs_fsmnt, (intmax_t)fs->fs_pendingblocks,
6651c85e6a3SKirk McKusick 		    fs->fs_pendinginodes);
6669ccb939eSKirk McKusick 		fs->fs_pendingblocks = 0;
6679ccb939eSKirk McKusick 		fs->fs_pendinginodes = 0;
6689ccb939eSKirk McKusick 	}
6693ba649d7SJeff Roberson 	UFS_UNLOCK(ump);
670996c772fSJohn Dyson 
671df8bae1dSRodney W. Grimes 	/*
672df8bae1dSRodney W. Grimes 	 * Step 3: re-read summary information from disk.
673df8bae1dSRodney W. Grimes 	 */
6742b028c25SEdward Tomasz Napierala 	size = fs->fs_cssize;
6752b028c25SEdward Tomasz Napierala 	blks = howmany(size, fs->fs_fsize);
6762b028c25SEdward Tomasz Napierala 	if (fs->fs_contigsumsize > 0)
6772b028c25SEdward Tomasz Napierala 		size += fs->fs_ncg * sizeof(int32_t);
6782b028c25SEdward Tomasz Napierala 	size += fs->fs_ncg * sizeof(u_int8_t);
6792b028c25SEdward Tomasz Napierala 	free(fs->fs_csp, M_UFSMNT);
680ad544726SKirk McKusick 	space = malloc(size, M_UFSMNT, M_WAITOK);
6812b028c25SEdward Tomasz Napierala 	fs->fs_csp = space;
682df8bae1dSRodney W. Grimes 	for (i = 0; i < blks; i += fs->fs_frag) {
683df8bae1dSRodney W. Grimes 		size = fs->fs_bsize;
684df8bae1dSRodney W. Grimes 		if (i + fs->fs_frag > blks)
685df8bae1dSRodney W. Grimes 			size = (blks - i) * fs->fs_fsize;
686c9671602SPoul-Henning Kamp 		error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + i), size,
687c9671602SPoul-Henning Kamp 		    NOCRED, &bp);
688c9671602SPoul-Henning Kamp 		if (error)
689df8bae1dSRodney W. Grimes 			return (error);
690f55ff3f3SIan Dowse 		bcopy(bp->b_data, space, (u_int)size);
691f55ff3f3SIan Dowse 		space = (char *)space + size;
692df8bae1dSRodney W. Grimes 		brelse(bp);
693df8bae1dSRodney W. Grimes 	}
694996c772fSJohn Dyson 	/*
695996c772fSJohn Dyson 	 * We no longer know anything about clusters per cylinder group.
696996c772fSJohn Dyson 	 */
697996c772fSJohn Dyson 	if (fs->fs_contigsumsize > 0) {
69872b8ff1cSEdward Tomasz Napierala 		fs->fs_maxcluster = lp = space;
699996c772fSJohn Dyson 		for (i = 0; i < fs->fs_ncg; i++)
700996c772fSJohn Dyson 			*lp++ = fs->fs_contigsumsize;
70172b8ff1cSEdward Tomasz Napierala 		space = lp;
702996c772fSJohn Dyson 	}
70372b8ff1cSEdward Tomasz Napierala 	size = fs->fs_ncg * sizeof(u_int8_t);
70472b8ff1cSEdward Tomasz Napierala 	fs->fs_contigdirs = (u_int8_t *)space;
70572b8ff1cSEdward Tomasz Napierala 	bzero(fs->fs_contigdirs, size);
706df426577SKonstantin Belousov 	if ((flags & FFSR_UNSUSPEND) != 0) {
707df426577SKonstantin Belousov 		MNT_ILOCK(mp);
708df426577SKonstantin Belousov 		mp->mnt_kern_flag &= ~(MNTK_SUSPENDED | MNTK_SUSPEND2);
709df426577SKonstantin Belousov 		wakeup(&mp->mnt_flag);
710df426577SKonstantin Belousov 		MNT_IUNLOCK(mp);
711df426577SKonstantin Belousov 	}
712996c772fSJohn Dyson 
713df8bae1dSRodney W. Grimes loop:
71471469bb3SKirk McKusick 	MNT_VNODE_FOREACH_ALL(vp, mp, mvp) {
715df8bae1dSRodney W. Grimes 		/*
7161848286aSEdward Tomasz Napierala 		 * Skip syncer vnode.
7171848286aSEdward Tomasz Napierala 		 */
7181848286aSEdward Tomasz Napierala 		if (vp->v_type == VNON) {
7191848286aSEdward Tomasz Napierala 			VI_UNLOCK(vp);
7201848286aSEdward Tomasz Napierala 			continue;
7211848286aSEdward Tomasz Napierala 		}
7221848286aSEdward Tomasz Napierala 		/*
723fe68abe2SJeff Roberson 		 * Step 4: invalidate all cached file data.
724df8bae1dSRodney W. Grimes 		 */
725b40ce416SJulian Elischer 		if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, td)) {
72671469bb3SKirk McKusick 			MNT_VNODE_FOREACH_ALL_ABORT(mp, mvp);
727df8bae1dSRodney W. Grimes 			goto loop;
728996c772fSJohn Dyson 		}
7290d7935fdSAttilio Rao 		if (vinvalbuf(vp, 0, 0, 0))
730df8bae1dSRodney W. Grimes 			panic("ffs_reload: dirty2");
731df8bae1dSRodney W. Grimes 		/*
732fe68abe2SJeff Roberson 		 * Step 5: re-read inode data for all active vnodes.
733df8bae1dSRodney W. Grimes 		 */
734df8bae1dSRodney W. Grimes 		ip = VTOI(vp);
735c9671602SPoul-Henning Kamp 		error =
736df8bae1dSRodney W. Grimes 		    bread(devvp, fsbtodb(fs, ino_to_fsba(fs, ip->i_number)),
737c9671602SPoul-Henning Kamp 		    (int)fs->fs_bsize, NOCRED, &bp);
738c9671602SPoul-Henning Kamp 		if (error) {
73922db15c0SAttilio Rao 			VOP_UNLOCK(vp, 0);
74045d45c6cSAlexander Kabaev 			vrele(vp);
74171469bb3SKirk McKusick 			MNT_VNODE_FOREACH_ALL_ABORT(mp, mvp);
742df8bae1dSRodney W. Grimes 			return (error);
743df8bae1dSRodney W. Grimes 		}
744de6ba7c0SPoul-Henning Kamp 		ffs_load_inode(bp, ip, fs, ip->i_number);
745b1897c19SJulian Elischer 		ip->i_effnlink = ip->i_nlink;
746df8bae1dSRodney W. Grimes 		brelse(bp);
74722db15c0SAttilio Rao 		VOP_UNLOCK(vp, 0);
748cb9ddc80SAlexander Kabaev 		vrele(vp);
749df8bae1dSRodney W. Grimes 	}
750df8bae1dSRodney W. Grimes 	return (0);
751df8bae1dSRodney W. Grimes }
752df8bae1dSRodney W. Grimes 
7531c85e6a3SKirk McKusick /*
7541c85e6a3SKirk McKusick  * Possible superblock locations ordered from most to least likely.
7551c85e6a3SKirk McKusick  */
7561c85e6a3SKirk McKusick static int sblock_try[] = SBLOCKSEARCH;
7575819ab3fSKirk McKusick 
758df8bae1dSRodney W. Grimes /*
759df8bae1dSRodney W. Grimes  * Common code for mount and mountroot
760df8bae1dSRodney W. Grimes  */
761975512a9SPoul-Henning Kamp static int
762975512a9SPoul-Henning Kamp ffs_mountfs(devvp, mp, td)
76305f4ff5dSPoul-Henning Kamp 	struct vnode *devvp;
764df8bae1dSRodney W. Grimes 	struct mount *mp;
765b40ce416SJulian Elischer 	struct thread *td;
766df8bae1dSRodney W. Grimes {
76705f4ff5dSPoul-Henning Kamp 	struct ufsmount *ump;
768df8bae1dSRodney W. Grimes 	struct buf *bp;
76905f4ff5dSPoul-Henning Kamp 	struct fs *fs;
77089c9c53dSPoul-Henning Kamp 	struct cdev *dev;
771f55ff3f3SIan Dowse 	void *space;
7721c85e6a3SKirk McKusick 	ufs2_daddr_t sblockloc;
773ad544726SKirk McKusick 	int error, i, blks, len, ronly;
774ad544726SKirk McKusick 	u_long size;
775996c772fSJohn Dyson 	int32_t *lp;
776996c772fSJohn Dyson 	struct ucred *cred;
77743920011SPoul-Henning Kamp 	struct g_consumer *cp;
7783bbd6d8aSJeff Roberson 	struct mount *nmp;
779df8bae1dSRodney W. Grimes 
780ee445a69SJohn Baldwin 	bp = NULL;
781ee445a69SJohn Baldwin 	ump = NULL;
782a854ed98SJohn Baldwin 	cred = td ? td->td_ucred : NOCRED;
78343920011SPoul-Henning Kamp 	ronly = (mp->mnt_flag & MNT_RDONLY) != 0;
784ee445a69SJohn Baldwin 
785c70b3cd2SKonstantin Belousov 	KASSERT(devvp->v_type == VCHR, ("reclaimed devvp"));
786ee445a69SJohn Baldwin 	dev = devvp->v_rdev;
787c70b3cd2SKonstantin Belousov 	if (atomic_cmpset_acq_ptr((uintptr_t *)&dev->si_mountpt, 0,
788c70b3cd2SKonstantin Belousov 	    (uintptr_t)mp) == 0) {
789c70b3cd2SKonstantin Belousov 		VOP_UNLOCK(devvp, 0);
790c70b3cd2SKonstantin Belousov 		return (EBUSY);
791c70b3cd2SKonstantin Belousov 	}
79243920011SPoul-Henning Kamp 	g_topology_lock();
79343920011SPoul-Henning Kamp 	error = g_vfs_open(devvp, &cp, "ffs", ronly ? 0 : 1);
79443920011SPoul-Henning Kamp 	g_topology_unlock();
795c70b3cd2SKonstantin Belousov 	if (error != 0) {
796c70b3cd2SKonstantin Belousov 		atomic_store_rel_ptr((uintptr_t *)&dev->si_mountpt, 0);
79722db15c0SAttilio Rao 		VOP_UNLOCK(devvp, 0);
798c70b3cd2SKonstantin Belousov 		return (error);
799c70b3cd2SKonstantin Belousov 	}
800c70b3cd2SKonstantin Belousov 	dev_ref(dev);
801c70b3cd2SKonstantin Belousov 	devvp->v_bufobj.bo_ops = &ffs_ops;
802c70b3cd2SKonstantin Belousov 	VOP_UNLOCK(devvp, 0);
803c70b3cd2SKonstantin Belousov 	if (dev->si_iosize_max != 0)
804c70b3cd2SKonstantin Belousov 		mp->mnt_iosize_max = dev->si_iosize_max;
8051b5464efSPoul-Henning Kamp 	if (mp->mnt_iosize_max > MAXPHYS)
8061b5464efSPoul-Henning Kamp 		mp->mnt_iosize_max = MAXPHYS;
80795e5e988SJohn Dyson 
8081c85e6a3SKirk McKusick 	fs = NULL;
8091c85e6a3SKirk McKusick 	sblockloc = 0;
8101c85e6a3SKirk McKusick 	/*
8111c85e6a3SKirk McKusick 	 * Try reading the superblock in each of its possible locations.
8121c85e6a3SKirk McKusick 	 */
8131c85e6a3SKirk McKusick 	for (i = 0; sblock_try[i] != -1; i++) {
81471ac2d7cSCraig Rodrigues 		if ((SBLOCKSIZE % cp->provider->sectorsize) != 0) {
81571ac2d7cSCraig Rodrigues 			error = EINVAL;
81671ac2d7cSCraig Rodrigues 			vfs_mount_error(mp,
81771ac2d7cSCraig Rodrigues 			    "Invalid sectorsize %d for superblock size %d",
81871ac2d7cSCraig Rodrigues 			    cp->provider->sectorsize, SBLOCKSIZE);
81971ac2d7cSCraig Rodrigues 			goto out;
82071ac2d7cSCraig Rodrigues 		}
82171ac2d7cSCraig Rodrigues 		if ((error = bread(devvp, btodb(sblock_try[i]), SBLOCKSIZE,
8221c85e6a3SKirk McKusick 		    cred, &bp)) != 0)
823df8bae1dSRodney W. Grimes 			goto out;
824df8bae1dSRodney W. Grimes 		fs = (struct fs *)bp->b_data;
825ada981b2SKirk McKusick 		sblockloc = sblock_try[i];
8261c85e6a3SKirk McKusick 		if ((fs->fs_magic == FS_UFS1_MAGIC ||
8271c85e6a3SKirk McKusick 		     (fs->fs_magic == FS_UFS2_MAGIC &&
828ada981b2SKirk McKusick 		      (fs->fs_sblockloc == sblockloc ||
829ada981b2SKirk McKusick 		       (fs->fs_old_flags & FS_FLAGS_UPDATED) == 0))) &&
8301c85e6a3SKirk McKusick 		    fs->fs_bsize <= MAXBSIZE &&
8311c85e6a3SKirk McKusick 		    fs->fs_bsize >= sizeof(struct fs))
8321c85e6a3SKirk McKusick 			break;
8331c85e6a3SKirk McKusick 		brelse(bp);
8341c85e6a3SKirk McKusick 		bp = NULL;
8351c85e6a3SKirk McKusick 	}
8361c85e6a3SKirk McKusick 	if (sblock_try[i] == -1) {
837df8bae1dSRodney W. Grimes 		error = EINVAL;		/* XXX needs translation */
838df8bae1dSRodney W. Grimes 		goto out;
839df8bae1dSRodney W. Grimes 	}
8403f6f17eeSJulian Elischer 	fs->fs_fmod = 0;
84108e94183SPedro F. Giffuni 	fs->fs_flags &= ~FS_INDEXDIRS;	/* no support for directory indices */
8420922cce6SBruce Evans 	fs->fs_flags &= ~FS_UNCLEAN;
8430922cce6SBruce Evans 	if (fs->fs_clean == 0) {
8440922cce6SBruce Evans 		fs->fs_flags |= FS_UNCLEAN;
845812b1d41SKirk McKusick 		if (ronly || (mp->mnt_flag & MNT_FORCE) ||
846113db2ddSJeff Roberson 		    ((fs->fs_flags & (FS_SUJ | FS_NEEDSFSCK)) == 0 &&
8471a6a6610SKirk McKusick 		     (fs->fs_flags & FS_DOSOFTDEP))) {
84859b3a4ebSDavid E. O'Brien 			printf("WARNING: %s was not properly dismounted\n",
8490922cce6SBruce Evans 			    fs->fs_fsmnt);
8501469eec8SDavid Greenman 		} else {
851b60ee81eSKirk McKusick 			vfs_mount_error(mp, "R/W mount of %s denied. %s%s",
852b60ee81eSKirk McKusick 			    fs->fs_fsmnt, "Filesystem is not clean - run fsck.",
853b60ee81eSKirk McKusick 			    (fs->fs_flags & FS_SUJ) == 0 ? "" :
854b60ee81eSKirk McKusick 			    " Forced mount will invalidate journal contents");
8551469eec8SDavid Greenman 			error = EPERM;
8561469eec8SDavid Greenman 			goto out;
8571469eec8SDavid Greenman 		}
8581c85e6a3SKirk McKusick 		if ((fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) &&
8591c85e6a3SKirk McKusick 		    (mp->mnt_flag & MNT_FORCE)) {
860b60ee81eSKirk McKusick 			printf("WARNING: %s: lost blocks %jd files %d\n",
861b60ee81eSKirk McKusick 			    fs->fs_fsmnt, (intmax_t)fs->fs_pendingblocks,
8621c85e6a3SKirk McKusick 			    fs->fs_pendinginodes);
8639ccb939eSKirk McKusick 			fs->fs_pendingblocks = 0;
8649ccb939eSKirk McKusick 			fs->fs_pendinginodes = 0;
8659ccb939eSKirk McKusick 		}
8669ccb939eSKirk McKusick 	}
8679ccb939eSKirk McKusick 	if (fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) {
868b60ee81eSKirk McKusick 		printf("WARNING: %s: mount pending error: blocks %jd "
869b60ee81eSKirk McKusick 		    "files %d\n", fs->fs_fsmnt, (intmax_t)fs->fs_pendingblocks,
8701c85e6a3SKirk McKusick 		    fs->fs_pendinginodes);
8719ccb939eSKirk McKusick 		fs->fs_pendingblocks = 0;
8729ccb939eSKirk McKusick 		fs->fs_pendinginodes = 0;
8731469eec8SDavid Greenman 	}
8741a60c7fcSPawel Jakub Dawidek 	if ((fs->fs_flags & FS_GJOURNAL) != 0) {
8751a60c7fcSPawel Jakub Dawidek #ifdef UFS_GJOURNAL
8761a60c7fcSPawel Jakub Dawidek 		/*
8771a60c7fcSPawel Jakub Dawidek 		 * Get journal provider name.
8781a60c7fcSPawel Jakub Dawidek 		 */
879ad544726SKirk McKusick 		len = 1024;
880ad544726SKirk McKusick 		mp->mnt_gjprovider = malloc((u_long)len, M_UFSMNT, M_WAITOK);
881ad544726SKirk McKusick 		if (g_io_getattr("GJOURNAL::provider", cp, &len,
8821a60c7fcSPawel Jakub Dawidek 		    mp->mnt_gjprovider) == 0) {
883ad544726SKirk McKusick 			mp->mnt_gjprovider = realloc(mp->mnt_gjprovider, len,
8841a60c7fcSPawel Jakub Dawidek 			    M_UFSMNT, M_WAITOK);
8851a60c7fcSPawel Jakub Dawidek 			MNT_ILOCK(mp);
8861a60c7fcSPawel Jakub Dawidek 			mp->mnt_flag |= MNT_GJOURNAL;
8871a60c7fcSPawel Jakub Dawidek 			MNT_IUNLOCK(mp);
8881a60c7fcSPawel Jakub Dawidek 		} else {
889b60ee81eSKirk McKusick 			printf("WARNING: %s: GJOURNAL flag on fs "
890b60ee81eSKirk McKusick 			    "but no gjournal provider below\n",
8911a60c7fcSPawel Jakub Dawidek 			    mp->mnt_stat.f_mntonname);
8921a60c7fcSPawel Jakub Dawidek 			free(mp->mnt_gjprovider, M_UFSMNT);
8931a60c7fcSPawel Jakub Dawidek 			mp->mnt_gjprovider = NULL;
8941a60c7fcSPawel Jakub Dawidek 		}
8951a60c7fcSPawel Jakub Dawidek #else
896b60ee81eSKirk McKusick 		printf("WARNING: %s: GJOURNAL flag on fs but no "
897b60ee81eSKirk McKusick 		    "UFS_GJOURNAL support\n", mp->mnt_stat.f_mntonname);
8981a60c7fcSPawel Jakub Dawidek #endif
8991a60c7fcSPawel Jakub Dawidek 	} else {
9001a60c7fcSPawel Jakub Dawidek 		mp->mnt_gjprovider = NULL;
9011a60c7fcSPawel Jakub Dawidek 	}
902a163d034SWarner Losh 	ump = malloc(sizeof *ump, M_UFSMNT, M_WAITOK | M_ZERO);
90343920011SPoul-Henning Kamp 	ump->um_cp = cp;
90443920011SPoul-Henning Kamp 	ump->um_bo = &devvp->v_bufobj;
9058dd56505SPoul-Henning Kamp 	ump->um_fs = malloc((u_long)fs->fs_sbsize, M_UFSMNT, M_WAITOK);
9061c85e6a3SKirk McKusick 	if (fs->fs_magic == FS_UFS1_MAGIC) {
9071c85e6a3SKirk McKusick 		ump->um_fstype = UFS1;
9081c85e6a3SKirk McKusick 		ump->um_balloc = ffs_balloc_ufs1;
9091c85e6a3SKirk McKusick 	} else {
9101c85e6a3SKirk McKusick 		ump->um_fstype = UFS2;
9111c85e6a3SKirk McKusick 		ump->um_balloc = ffs_balloc_ufs2;
9121c85e6a3SKirk McKusick 	}
913cec0f20cSPoul-Henning Kamp 	ump->um_blkatoff = ffs_blkatoff;
914cec0f20cSPoul-Henning Kamp 	ump->um_truncate = ffs_truncate;
915987f5696SPoul-Henning Kamp 	ump->um_update = ffs_update;
916cec0f20cSPoul-Henning Kamp 	ump->um_valloc = ffs_valloc;
917cec0f20cSPoul-Henning Kamp 	ump->um_vfree = ffs_vfree;
918975512a9SPoul-Henning Kamp 	ump->um_ifree = ffs_ifree;
91990446e36SKonstantin Belousov 	ump->um_rdonly = ffs_rdonly;
92016b1f68dSKonstantin Belousov 	ump->um_snapgone = ffs_snapgone;
9213ba649d7SJeff Roberson 	mtx_init(UFS_MTX(ump), "FFS", "FFS Lock", MTX_DEF);
922df8bae1dSRodney W. Grimes 	bcopy(bp->b_data, ump->um_fs, (u_int)fs->fs_sbsize);
9231c85e6a3SKirk McKusick 	if (fs->fs_sbsize < SBLOCKSIZE)
924f2a2857bSKirk McKusick 		bp->b_flags |= B_INVAL | B_NOCACHE;
925df8bae1dSRodney W. Grimes 	brelse(bp);
926df8bae1dSRodney W. Grimes 	bp = NULL;
927df8bae1dSRodney W. Grimes 	fs = ump->um_fs;
9281c85e6a3SKirk McKusick 	ffs_oldfscompat_read(fs, ump, sblockloc);
929df8bae1dSRodney W. Grimes 	fs->fs_ronly = ronly;
930996c772fSJohn Dyson 	size = fs->fs_cssize;
931996c772fSJohn Dyson 	blks = howmany(size, fs->fs_fsize);
932996c772fSJohn Dyson 	if (fs->fs_contigsumsize > 0)
933996c772fSJohn Dyson 		size += fs->fs_ncg * sizeof(int32_t);
934a61ab64aSKirk McKusick 	size += fs->fs_ncg * sizeof(u_int8_t);
935ad544726SKirk McKusick 	space = malloc(size, M_UFSMNT, M_WAITOK);
936f55ff3f3SIan Dowse 	fs->fs_csp = space;
937df8bae1dSRodney W. Grimes 	for (i = 0; i < blks; i += fs->fs_frag) {
938df8bae1dSRodney W. Grimes 		size = fs->fs_bsize;
939df8bae1dSRodney W. Grimes 		if (i + fs->fs_frag > blks)
940df8bae1dSRodney W. Grimes 			size = (blks - i) * fs->fs_fsize;
9418aef1712SMatthew Dillon 		if ((error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + i), size,
9428aef1712SMatthew Dillon 		    cred, &bp)) != 0) {
943f55ff3f3SIan Dowse 			free(fs->fs_csp, M_UFSMNT);
944df8bae1dSRodney W. Grimes 			goto out;
945df8bae1dSRodney W. Grimes 		}
946df8bae1dSRodney W. Grimes 		bcopy(bp->b_data, space, (u_int)size);
947f55ff3f3SIan Dowse 		space = (char *)space + size;
948df8bae1dSRodney W. Grimes 		brelse(bp);
949df8bae1dSRodney W. Grimes 		bp = NULL;
950df8bae1dSRodney W. Grimes 	}
951996c772fSJohn Dyson 	if (fs->fs_contigsumsize > 0) {
952f55ff3f3SIan Dowse 		fs->fs_maxcluster = lp = space;
953996c772fSJohn Dyson 		for (i = 0; i < fs->fs_ncg; i++)
954996c772fSJohn Dyson 			*lp++ = fs->fs_contigsumsize;
9554691e9eaSIan Dowse 		space = lp;
956996c772fSJohn Dyson 	}
957a61ab64aSKirk McKusick 	size = fs->fs_ncg * sizeof(u_int8_t);
958a61ab64aSKirk McKusick 	fs->fs_contigdirs = (u_int8_t *)space;
959a61ab64aSKirk McKusick 	bzero(fs->fs_contigdirs, size);
960143a5346SIan Dowse 	fs->fs_active = NULL;
96177465d93SAlfred Perlstein 	mp->mnt_data = ump;
96268de329eSPoul-Henning Kamp 	mp->mnt_stat.f_fsid.val[0] = fs->fs_id[0];
9638f89943eSGuido van Rooij 	mp->mnt_stat.f_fsid.val[1] = fs->fs_id[1];
9643bbd6d8aSJeff Roberson 	nmp = NULL;
96568de329eSPoul-Henning Kamp 	if (fs->fs_id[0] == 0 || fs->fs_id[1] == 0 ||
9663bbd6d8aSJeff Roberson 	    (nmp = vfs_getvfs(&mp->mnt_stat.f_fsid))) {
9673bbd6d8aSJeff Roberson 		if (nmp)
9683bbd6d8aSJeff Roberson 			vfs_rel(nmp);
96968de329eSPoul-Henning Kamp 		vfs_getnewfsid(mp);
9703bbd6d8aSJeff Roberson 	}
971df8bae1dSRodney W. Grimes 	mp->mnt_maxsymlinklen = fs->fs_maxsymlinklen;
9725da56ddbSTor Egge 	MNT_ILOCK(mp);
973cc9d8990SPeter Wemm 	mp->mnt_flag |= MNT_LOCAL;
9745da56ddbSTor Egge 	MNT_IUNLOCK(mp);
9755da56ddbSTor Egge 	if ((fs->fs_flags & FS_MULTILABEL) != 0) {
9767b3f1bbdSTom Rhodes #ifdef MAC
9775da56ddbSTor Egge 		MNT_ILOCK(mp);
97880830407SRobert Watson 		mp->mnt_flag |= MNT_MULTILABEL;
9795da56ddbSTor Egge 		MNT_IUNLOCK(mp);
9807b3f1bbdSTom Rhodes #else
981b60ee81eSKirk McKusick 		printf("WARNING: %s: multilabel flag on fs but "
982b60ee81eSKirk McKusick 		    "no MAC support\n", mp->mnt_stat.f_mntonname);
9837b3f1bbdSTom Rhodes #endif
9845da56ddbSTor Egge 	}
9855da56ddbSTor Egge 	if ((fs->fs_flags & FS_ACLS) != 0) {
9867b3f1bbdSTom Rhodes #ifdef UFS_ACL
9875da56ddbSTor Egge 		MNT_ILOCK(mp);
9889340fc72SEdward Tomasz Napierala 
9899340fc72SEdward Tomasz Napierala 		if (mp->mnt_flag & MNT_NFS4ACLS)
990b60ee81eSKirk McKusick 			printf("WARNING: %s: ACLs flag on fs conflicts with "
991b60ee81eSKirk McKusick 			    "\"nfsv4acls\" mount option; option ignored\n",
992b60ee81eSKirk McKusick 			    mp->mnt_stat.f_mntonname);
9939340fc72SEdward Tomasz Napierala 		mp->mnt_flag &= ~MNT_NFS4ACLS;
99480830407SRobert Watson 		mp->mnt_flag |= MNT_ACLS;
9959340fc72SEdward Tomasz Napierala 
9965da56ddbSTor Egge 		MNT_IUNLOCK(mp);
9977b3f1bbdSTom Rhodes #else
99859b3a4ebSDavid E. O'Brien 		printf("WARNING: %s: ACLs flag on fs but no ACLs support\n",
999946478fcSPawel Jakub Dawidek 		    mp->mnt_stat.f_mntonname);
10007b3f1bbdSTom Rhodes #endif
10015da56ddbSTor Egge 	}
10029340fc72SEdward Tomasz Napierala 	if ((fs->fs_flags & FS_NFS4ACLS) != 0) {
10039340fc72SEdward Tomasz Napierala #ifdef UFS_ACL
10049340fc72SEdward Tomasz Napierala 		MNT_ILOCK(mp);
10059340fc72SEdward Tomasz Napierala 
10069340fc72SEdward Tomasz Napierala 		if (mp->mnt_flag & MNT_ACLS)
1007b60ee81eSKirk McKusick 			printf("WARNING: %s: NFSv4 ACLs flag on fs conflicts "
1008b60ee81eSKirk McKusick 			    "with \"acls\" mount option; option ignored\n",
1009b60ee81eSKirk McKusick 			    mp->mnt_stat.f_mntonname);
10109340fc72SEdward Tomasz Napierala 		mp->mnt_flag &= ~MNT_ACLS;
10119340fc72SEdward Tomasz Napierala 		mp->mnt_flag |= MNT_NFS4ACLS;
10129340fc72SEdward Tomasz Napierala 
10139340fc72SEdward Tomasz Napierala 		MNT_IUNLOCK(mp);
10149340fc72SEdward Tomasz Napierala #else
1015b60ee81eSKirk McKusick 		printf("WARNING: %s: NFSv4 ACLs flag on fs but no "
1016b60ee81eSKirk McKusick 		    "ACLs support\n", mp->mnt_stat.f_mntonname);
10179340fc72SEdward Tomasz Napierala #endif
10189340fc72SEdward Tomasz Napierala 	}
10198c2a54deSKonstantin Belousov 	if ((fs->fs_flags & FS_TRIM) != 0) {
1020ad544726SKirk McKusick 		len = sizeof(int);
1021ad544726SKirk McKusick 		if (g_io_getattr("GEOM::candelete", cp, &len,
10228c2a54deSKonstantin Belousov 		    &ump->um_candelete) == 0) {
10238c2a54deSKonstantin Belousov 			if (!ump->um_candelete)
1024b60ee81eSKirk McKusick 				printf("WARNING: %s: TRIM flag on fs but disk "
1025b60ee81eSKirk McKusick 				    "does not support TRIM\n",
10268c2a54deSKonstantin Belousov 				    mp->mnt_stat.f_mntonname);
10278c2a54deSKonstantin Belousov 		} else {
1028b60ee81eSKirk McKusick 			printf("WARNING: %s: TRIM flag on fs but disk does "
1029b60ee81eSKirk McKusick 			    "not confirm that it supports TRIM\n",
10308c2a54deSKonstantin Belousov 			    mp->mnt_stat.f_mntonname);
10318c2a54deSKonstantin Belousov 			ump->um_candelete = 0;
10328c2a54deSKonstantin Belousov 		}
1033c79dff0fSKonstantin Belousov 		if (ump->um_candelete) {
1034c79dff0fSKonstantin Belousov 			ump->um_trim_tq = taskqueue_create("trim", M_WAITOK,
1035c79dff0fSKonstantin Belousov 			    taskqueue_thread_enqueue, &ump->um_trim_tq);
1036c79dff0fSKonstantin Belousov 			taskqueue_start_threads(&ump->um_trim_tq, 1, PVFS,
1037c79dff0fSKonstantin Belousov 			    "%s trim", mp->mnt_stat.f_mntonname);
1038c79dff0fSKonstantin Belousov 		}
10398c2a54deSKonstantin Belousov 	}
10409340fc72SEdward Tomasz Napierala 
1041df8bae1dSRodney W. Grimes 	ump->um_mountp = mp;
1042df8bae1dSRodney W. Grimes 	ump->um_dev = dev;
1043df8bae1dSRodney W. Grimes 	ump->um_devvp = devvp;
1044df8bae1dSRodney W. Grimes 	ump->um_nindir = fs->fs_nindir;
1045df8bae1dSRodney W. Grimes 	ump->um_bptrtodb = fs->fs_fsbtodb;
1046df8bae1dSRodney W. Grimes 	ump->um_seqinc = fs->fs_frag;
1047df8bae1dSRodney W. Grimes 	for (i = 0; i < MAXQUOTAS; i++)
1048df8bae1dSRodney W. Grimes 		ump->um_quotas[i] = NULLVP;
1049516081f2SRobert Watson #ifdef UFS_EXTATTR
1050a64ed089SRobert Watson 	ufs_extattr_uepm_init(&ump->um_extattr);
1051a64ed089SRobert Watson #endif
10522b14f991SJulian Elischer 	/*
10532b14f991SJulian Elischer 	 * Set FS local "last mounted on" information (NULL pad)
10542b14f991SJulian Elischer 	 */
105593373c42SSuleiman Souhlal 	bzero(fs->fs_fsmnt, MAXMNTLEN);
105693373c42SSuleiman Souhlal 	strlcpy(fs->fs_fsmnt, mp->mnt_stat.f_mntonname, MAXMNTLEN);
1057113db2ddSJeff Roberson 	mp->mnt_stat.f_iosize = fs->fs_bsize;
10582b14f991SJulian Elischer 
10592b14f991SJulian Elischer 	if (mp->mnt_flag & MNT_ROOTFS) {
10602b14f991SJulian Elischer 		/*
10612b14f991SJulian Elischer 		 * Root mount; update timestamp in mount structure.
10622b14f991SJulian Elischer 		 * this will be used by the common root mount code
10632b14f991SJulian Elischer 		 * to update the system clock.
10642b14f991SJulian Elischer 		 */
10652b14f991SJulian Elischer 		mp->mnt_time = fs->fs_time;
10662b14f991SJulian Elischer 	}
1067996c772fSJohn Dyson 
1068996c772fSJohn Dyson 	if (ronly == 0) {
1069113db2ddSJeff Roberson 		fs->fs_mtime = time_second;
1070b1897c19SJulian Elischer 		if ((fs->fs_flags & FS_DOSOFTDEP) &&
1071b1897c19SJulian Elischer 		    (error = softdep_mount(devvp, mp, fs, cred)) != 0) {
1072f55ff3f3SIan Dowse 			free(fs->fs_csp, M_UFSMNT);
1073fddd463dSKonstantin Belousov 			ffs_flushfiles(mp, FORCECLOSE, td);
1074b1897c19SJulian Elischer 			goto out;
1075b1897c19SJulian Elischer 		}
1076f2a2857bSKirk McKusick 		if (fs->fs_snapinum[0] != 0)
1077f2a2857bSKirk McKusick 			ffs_snapshot_mount(mp);
1078cf60e8e4SKirk McKusick 		fs->fs_fmod = 1;
1079996c772fSJohn Dyson 		fs->fs_clean = 0;
1080791dd2faSTor Egge 		(void) ffs_sbupdate(ump, MNT_WAIT, 0);
1081996c772fSJohn Dyson 	}
1082d8d3d415SPoul-Henning Kamp 	/*
108398cbffd7SKonstantin Belousov 	 * Initialize filesystem state information in mount struct.
1084d8d3d415SPoul-Henning Kamp 	 */
10856cf7bc60SRobert Watson 	MNT_ILOCK(mp);
1086bc2258daSAttilio Rao 	mp->mnt_kern_flag |= MNTK_LOOKUP_SHARED | MNTK_EXTENDED_SHARED |
10875f34e93cSMark Johnston 	    MNTK_NO_IOPF | MNTK_UNMAPPED_BUFS | MNTK_USES_BCACHE;
10886cf7bc60SRobert Watson 	MNT_IUNLOCK(mp);
1089516081f2SRobert Watson #ifdef UFS_EXTATTR
1090516081f2SRobert Watson #ifdef UFS_EXTATTR_AUTOSTART
10919de54ba5SRobert Watson 	/*
10929de54ba5SRobert Watson 	 *
1093f5161237SRobert Watson 	 * Auto-starting does the following:
10949de54ba5SRobert Watson 	 *	- check for /.attribute in the fs, and extattr_start if so
10959de54ba5SRobert Watson 	 *	- for each file in .attribute, enable that file with
10969de54ba5SRobert Watson 	 * 	  an attribute of the same name.
10979de54ba5SRobert Watson 	 * Not clear how to report errors -- probably eat them.
10989de54ba5SRobert Watson 	 * This would all happen while the filesystem was busy/not
10999de54ba5SRobert Watson 	 * available, so would effectively be "atomic".
11009de54ba5SRobert Watson 	 */
1101b40ce416SJulian Elischer 	(void) ufs_extattr_autostart(mp, td);
1102516081f2SRobert Watson #endif /* !UFS_EXTATTR_AUTOSTART */
1103516081f2SRobert Watson #endif /* !UFS_EXTATTR */
1104df8bae1dSRodney W. Grimes 	return (0);
1105df8bae1dSRodney W. Grimes out:
1106df8bae1dSRodney W. Grimes 	if (bp)
1107df8bae1dSRodney W. Grimes 		brelse(bp);
110843920011SPoul-Henning Kamp 	if (cp != NULL) {
110943920011SPoul-Henning Kamp 		g_topology_lock();
11100d7935fdSAttilio Rao 		g_vfs_close(cp);
111143920011SPoul-Henning Kamp 		g_topology_unlock();
111243920011SPoul-Henning Kamp 	}
1113df8bae1dSRodney W. Grimes 	if (ump) {
11143ba649d7SJeff Roberson 		mtx_destroy(UFS_MTX(ump));
11151a60c7fcSPawel Jakub Dawidek 		if (mp->mnt_gjprovider != NULL) {
11161a60c7fcSPawel Jakub Dawidek 			free(mp->mnt_gjprovider, M_UFSMNT);
11171a60c7fcSPawel Jakub Dawidek 			mp->mnt_gjprovider = NULL;
11181a60c7fcSPawel Jakub Dawidek 		}
1119df8bae1dSRodney W. Grimes 		free(ump->um_fs, M_UFSMNT);
1120df8bae1dSRodney W. Grimes 		free(ump, M_UFSMNT);
112177465d93SAlfred Perlstein 		mp->mnt_data = NULL;
1122df8bae1dSRodney W. Grimes 	}
1123c70b3cd2SKonstantin Belousov 	atomic_store_rel_ptr((uintptr_t *)&dev->si_mountpt, 0);
112449c4791cSEdward Tomasz Napierala 	dev_rel(dev);
1125df8bae1dSRodney W. Grimes 	return (error);
1126df8bae1dSRodney W. Grimes }
1127df8bae1dSRodney W. Grimes 
11281c85e6a3SKirk McKusick #include <sys/sysctl.h>
1129adf41577SPoul-Henning Kamp static int bigcgs = 0;
11301c85e6a3SKirk McKusick SYSCTL_INT(_debug, OID_AUTO, bigcgs, CTLFLAG_RW, &bigcgs, 0, "");
11311c85e6a3SKirk McKusick 
1132df8bae1dSRodney W. Grimes /*
11331c85e6a3SKirk McKusick  * Sanity checks for loading old filesystem superblocks.
11341c85e6a3SKirk McKusick  * See ffs_oldfscompat_write below for unwound actions.
1135df8bae1dSRodney W. Grimes  *
11361c85e6a3SKirk McKusick  * XXX - Parts get retired eventually.
11371c85e6a3SKirk McKusick  * Unfortunately new bits get added.
1138df8bae1dSRodney W. Grimes  */
11391c85e6a3SKirk McKusick static void
11401c85e6a3SKirk McKusick ffs_oldfscompat_read(fs, ump, sblockloc)
1141df8bae1dSRodney W. Grimes 	struct fs *fs;
11421c85e6a3SKirk McKusick 	struct ufsmount *ump;
11431c85e6a3SKirk McKusick 	ufs2_daddr_t sblockloc;
11441c85e6a3SKirk McKusick {
11451c85e6a3SKirk McKusick 	off_t maxfilesize;
11461c85e6a3SKirk McKusick 
11471c85e6a3SKirk McKusick 	/*
1148ada981b2SKirk McKusick 	 * If not yet done, update fs_flags location and value of fs_sblockloc.
1149ada981b2SKirk McKusick 	 */
1150ada981b2SKirk McKusick 	if ((fs->fs_old_flags & FS_FLAGS_UPDATED) == 0) {
1151ada981b2SKirk McKusick 		fs->fs_flags = fs->fs_old_flags;
1152ada981b2SKirk McKusick 		fs->fs_old_flags |= FS_FLAGS_UPDATED;
1153ada981b2SKirk McKusick 		fs->fs_sblockloc = sblockloc;
1154ada981b2SKirk McKusick 	}
1155ada981b2SKirk McKusick 	/*
11561c85e6a3SKirk McKusick 	 * If not yet done, update UFS1 superblock with new wider fields.
11571c85e6a3SKirk McKusick 	 */
115874f3809aSKirk McKusick 	if (fs->fs_magic == FS_UFS1_MAGIC && fs->fs_maxbsize != fs->fs_bsize) {
11591c85e6a3SKirk McKusick 		fs->fs_maxbsize = fs->fs_bsize;
11601c85e6a3SKirk McKusick 		fs->fs_time = fs->fs_old_time;
11611c85e6a3SKirk McKusick 		fs->fs_size = fs->fs_old_size;
11621c85e6a3SKirk McKusick 		fs->fs_dsize = fs->fs_old_dsize;
11631c85e6a3SKirk McKusick 		fs->fs_csaddr = fs->fs_old_csaddr;
11641c85e6a3SKirk McKusick 		fs->fs_cstotal.cs_ndir = fs->fs_old_cstotal.cs_ndir;
11651c85e6a3SKirk McKusick 		fs->fs_cstotal.cs_nbfree = fs->fs_old_cstotal.cs_nbfree;
11661c85e6a3SKirk McKusick 		fs->fs_cstotal.cs_nifree = fs->fs_old_cstotal.cs_nifree;
11671c85e6a3SKirk McKusick 		fs->fs_cstotal.cs_nffree = fs->fs_old_cstotal.cs_nffree;
11681c85e6a3SKirk McKusick 	}
11691c85e6a3SKirk McKusick 	if (fs->fs_magic == FS_UFS1_MAGIC &&
11701c85e6a3SKirk McKusick 	    fs->fs_old_inodefmt < FS_44INODEFMT) {
11718680d698SNate Lawson 		fs->fs_maxfilesize = ((uint64_t)1 << 31) - 1;
11721c85e6a3SKirk McKusick 		fs->fs_qbmask = ~fs->fs_bmask;
11731c85e6a3SKirk McKusick 		fs->fs_qfmask = ~fs->fs_fmask;
11741c85e6a3SKirk McKusick 	}
11758f42fb8fSIan Dowse 	if (fs->fs_magic == FS_UFS1_MAGIC) {
11761c85e6a3SKirk McKusick 		ump->um_savedmaxfilesize = fs->fs_maxfilesize;
11778680d698SNate Lawson 		maxfilesize = (uint64_t)0x80000000 * fs->fs_bsize - 1;
11781c85e6a3SKirk McKusick 		if (fs->fs_maxfilesize > maxfilesize)
11791c85e6a3SKirk McKusick 			fs->fs_maxfilesize = maxfilesize;
11808f42fb8fSIan Dowse 	}
11811c85e6a3SKirk McKusick 	/* Compatibility for old filesystems */
11821c85e6a3SKirk McKusick 	if (fs->fs_avgfilesize <= 0)
11831c85e6a3SKirk McKusick 		fs->fs_avgfilesize = AVFILESIZ;
11841c85e6a3SKirk McKusick 	if (fs->fs_avgfpdir <= 0)
11851c85e6a3SKirk McKusick 		fs->fs_avgfpdir = AFPDIR;
11861c85e6a3SKirk McKusick 	if (bigcgs) {
11871c85e6a3SKirk McKusick 		fs->fs_save_cgsize = fs->fs_cgsize;
11881c85e6a3SKirk McKusick 		fs->fs_cgsize = fs->fs_bsize;
11891c85e6a3SKirk McKusick 	}
11901c85e6a3SKirk McKusick }
11911c85e6a3SKirk McKusick 
11921c85e6a3SKirk McKusick /*
11931c85e6a3SKirk McKusick  * Unwinding superblock updates for old filesystems.
11941c85e6a3SKirk McKusick  * See ffs_oldfscompat_read above for details.
11951c85e6a3SKirk McKusick  *
11961c85e6a3SKirk McKusick  * XXX - Parts get retired eventually.
11971c85e6a3SKirk McKusick  * Unfortunately new bits get added.
11981c85e6a3SKirk McKusick  */
1199113db2ddSJeff Roberson void
12001c85e6a3SKirk McKusick ffs_oldfscompat_write(fs, ump)
12011c85e6a3SKirk McKusick 	struct fs *fs;
12021c85e6a3SKirk McKusick 	struct ufsmount *ump;
1203df8bae1dSRodney W. Grimes {
1204df8bae1dSRodney W. Grimes 
12051c85e6a3SKirk McKusick 	/*
12061c85e6a3SKirk McKusick 	 * Copy back UFS2 updated fields that UFS1 inspects.
12071c85e6a3SKirk McKusick 	 */
12081c85e6a3SKirk McKusick 	if (fs->fs_magic == FS_UFS1_MAGIC) {
12091c85e6a3SKirk McKusick 		fs->fs_old_time = fs->fs_time;
12101c85e6a3SKirk McKusick 		fs->fs_old_cstotal.cs_ndir = fs->fs_cstotal.cs_ndir;
12111c85e6a3SKirk McKusick 		fs->fs_old_cstotal.cs_nbfree = fs->fs_cstotal.cs_nbfree;
12121c85e6a3SKirk McKusick 		fs->fs_old_cstotal.cs_nifree = fs->fs_cstotal.cs_nifree;
12131c85e6a3SKirk McKusick 		fs->fs_old_cstotal.cs_nffree = fs->fs_cstotal.cs_nffree;
12141c85e6a3SKirk McKusick 		fs->fs_maxfilesize = ump->um_savedmaxfilesize;
12158f42fb8fSIan Dowse 	}
12161c85e6a3SKirk McKusick 	if (bigcgs) {
12171c85e6a3SKirk McKusick 		fs->fs_cgsize = fs->fs_save_cgsize;
12181c85e6a3SKirk McKusick 		fs->fs_save_cgsize = 0;
12191c85e6a3SKirk McKusick 	}
1220df8bae1dSRodney W. Grimes }
1221df8bae1dSRodney W. Grimes 
1222df8bae1dSRodney W. Grimes /*
1223df8bae1dSRodney W. Grimes  * unmount system call
1224df8bae1dSRodney W. Grimes  */
1225adf41577SPoul-Henning Kamp static int
1226dfd233edSAttilio Rao ffs_unmount(mp, mntflags)
1227df8bae1dSRodney W. Grimes 	struct mount *mp;
1228df8bae1dSRodney W. Grimes 	int mntflags;
1229df8bae1dSRodney W. Grimes {
1230dfd233edSAttilio Rao 	struct thread *td;
123105f4ff5dSPoul-Henning Kamp 	struct ufsmount *ump = VFSTOUFS(mp);
123205f4ff5dSPoul-Henning Kamp 	struct fs *fs;
12336fecb4e4SKonstantin Belousov 	int error, flags, susp;
1234df86ccf6SKonstantin Belousov #ifdef UFS_EXTATTR
1235df86ccf6SKonstantin Belousov 	int e_restart;
1236df86ccf6SKonstantin Belousov #endif
1237df8bae1dSRodney W. Grimes 
1238df8bae1dSRodney W. Grimes 	flags = 0;
1239dfd233edSAttilio Rao 	td = curthread;
12406fecb4e4SKonstantin Belousov 	fs = ump->um_fs;
1241b60ee81eSKirk McKusick 	susp = 0;
1242df8bae1dSRodney W. Grimes 	if (mntflags & MNT_FORCE) {
1243df8bae1dSRodney W. Grimes 		flags |= FORCECLOSE;
12444ce90426SKonstantin Belousov 		susp = fs->fs_ronly == 0;
1245b60ee81eSKirk McKusick 	}
1246516081f2SRobert Watson #ifdef UFS_EXTATTR
1247b40ce416SJulian Elischer 	if ((error = ufs_extattr_stop(mp, td))) {
1248b2b0497aSRobert Watson 		if (error != EOPNOTSUPP)
1249b60ee81eSKirk McKusick 			printf("WARNING: unmount %s: ufs_extattr_stop "
1250b60ee81eSKirk McKusick 			    "returned errno %d\n", mp->mnt_stat.f_mntonname,
1251b2b0497aSRobert Watson 			    error);
1252df86ccf6SKonstantin Belousov 		e_restart = 0;
12537df97b61SRobert Watson 	} else {
12549de54ba5SRobert Watson 		ufs_extattr_uepm_destroy(&ump->um_extattr);
1255df86ccf6SKonstantin Belousov 		e_restart = 1;
12567df97b61SRobert Watson 	}
1257a64ed089SRobert Watson #endif
12586fecb4e4SKonstantin Belousov 	if (susp) {
1259895b3782SKonstantin Belousov 		error = vfs_write_suspend_umnt(mp);
1260895b3782SKonstantin Belousov 		if (error != 0)
1261895b3782SKonstantin Belousov 			goto fail1;
12626fecb4e4SKonstantin Belousov 	}
1263fddf7baeSKirk McKusick 	if (MOUNTEDSOFTDEP(mp))
12643c140b2dSEdward Tomasz Napierala 		error = softdep_flushfiles(mp, flags, td);
12653c140b2dSEdward Tomasz Napierala 	else
12663c140b2dSEdward Tomasz Napierala 		error = ffs_flushfiles(mp, flags, td);
12674f560d75SEdward Tomasz Napierala 	if (error != 0 && error != ENXIO)
12686fecb4e4SKonstantin Belousov 		goto fail;
12693c140b2dSEdward Tomasz Napierala 
12703ba649d7SJeff Roberson 	UFS_LOCK(ump);
12719ccb939eSKirk McKusick 	if (fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) {
1272b60ee81eSKirk McKusick 		printf("WARNING: unmount %s: pending error: blocks %jd "
1273b60ee81eSKirk McKusick 		    "files %d\n", fs->fs_fsmnt, (intmax_t)fs->fs_pendingblocks,
12741c85e6a3SKirk McKusick 		    fs->fs_pendinginodes);
12759ccb939eSKirk McKusick 		fs->fs_pendingblocks = 0;
12769ccb939eSKirk McKusick 		fs->fs_pendinginodes = 0;
12779ccb939eSKirk McKusick 	}
12783ba649d7SJeff Roberson 	UFS_UNLOCK(ump);
1279519e3c3bSKirk McKusick 	if (MOUNTEDSOFTDEP(mp))
1280113db2ddSJeff Roberson 		softdep_unmount(mp);
1281927a12aeSKirk McKusick 	if (fs->fs_ronly == 0 || ump->um_fsckpid > 0) {
12821a6a6610SKirk McKusick 		fs->fs_clean = fs->fs_flags & (FS_UNCLEAN|FS_NEEDSFSCK) ? 0 : 1;
1283791dd2faSTor Egge 		error = ffs_sbupdate(ump, MNT_WAIT, 0);
12844f560d75SEdward Tomasz Napierala 		if (error && error != ENXIO) {
1285996c772fSJohn Dyson 			fs->fs_clean = 0;
12866fecb4e4SKonstantin Belousov 			goto fail;
1287996c772fSJohn Dyson 		}
1288e0e9c421SDavid Greenman 	}
1289ddd6b3fcSKonstantin Belousov 	if (susp)
1290ddd6b3fcSKonstantin Belousov 		vfs_write_resume(mp, VR_START_WRITE);
1291c79dff0fSKonstantin Belousov 	if (ump->um_trim_tq != NULL) {
1292c79dff0fSKonstantin Belousov 		while (ump->um_trim_inflight != 0)
1293c79dff0fSKonstantin Belousov 			pause("ufsutr", hz);
1294c79dff0fSKonstantin Belousov 		taskqueue_drain_all(ump->um_trim_tq);
1295c79dff0fSKonstantin Belousov 		taskqueue_free(ump->um_trim_tq);
1296c79dff0fSKonstantin Belousov 	}
129743920011SPoul-Henning Kamp 	g_topology_lock();
1298927a12aeSKirk McKusick 	if (ump->um_fsckpid > 0) {
1299927a12aeSKirk McKusick 		/*
1300927a12aeSKirk McKusick 		 * Return to normal read-only mode.
1301927a12aeSKirk McKusick 		 */
1302927a12aeSKirk McKusick 		error = g_access(ump->um_cp, 0, -1, 0);
1303927a12aeSKirk McKusick 		ump->um_fsckpid = 0;
1304927a12aeSKirk McKusick 	}
13050d7935fdSAttilio Rao 	g_vfs_close(ump->um_cp);
130643920011SPoul-Henning Kamp 	g_topology_unlock();
1307c70b3cd2SKonstantin Belousov 	atomic_store_rel_ptr((uintptr_t *)&ump->um_dev->si_mountpt, 0);
13086476c0d2SJohn Dyson 	vrele(ump->um_devvp);
130949c4791cSEdward Tomasz Napierala 	dev_rel(ump->um_dev);
13103ba649d7SJeff Roberson 	mtx_destroy(UFS_MTX(ump));
13111a60c7fcSPawel Jakub Dawidek 	if (mp->mnt_gjprovider != NULL) {
13121a60c7fcSPawel Jakub Dawidek 		free(mp->mnt_gjprovider, M_UFSMNT);
13131a60c7fcSPawel Jakub Dawidek 		mp->mnt_gjprovider = NULL;
13141a60c7fcSPawel Jakub Dawidek 	}
1315f55ff3f3SIan Dowse 	free(fs->fs_csp, M_UFSMNT);
1316df8bae1dSRodney W. Grimes 	free(fs, M_UFSMNT);
1317df8bae1dSRodney W. Grimes 	free(ump, M_UFSMNT);
131877465d93SAlfred Perlstein 	mp->mnt_data = NULL;
13195da56ddbSTor Egge 	MNT_ILOCK(mp);
1320cc9d8990SPeter Wemm 	mp->mnt_flag &= ~MNT_LOCAL;
13215da56ddbSTor Egge 	MNT_IUNLOCK(mp);
1322df8bae1dSRodney W. Grimes 	return (error);
13236fecb4e4SKonstantin Belousov 
13246fecb4e4SKonstantin Belousov fail:
1325ddd6b3fcSKonstantin Belousov 	if (susp)
1326ddd6b3fcSKonstantin Belousov 		vfs_write_resume(mp, VR_START_WRITE);
1327895b3782SKonstantin Belousov fail1:
1328df86ccf6SKonstantin Belousov #ifdef UFS_EXTATTR
1329df86ccf6SKonstantin Belousov 	if (e_restart) {
1330df86ccf6SKonstantin Belousov 		ufs_extattr_uepm_init(&ump->um_extattr);
1331df86ccf6SKonstantin Belousov #ifdef UFS_EXTATTR_AUTOSTART
1332df86ccf6SKonstantin Belousov 		(void) ufs_extattr_autostart(mp, td);
1333df86ccf6SKonstantin Belousov #endif
1334df86ccf6SKonstantin Belousov 	}
1335df86ccf6SKonstantin Belousov #endif
1336df86ccf6SKonstantin Belousov 
13376fecb4e4SKonstantin Belousov 	return (error);
1338df8bae1dSRodney W. Grimes }
1339df8bae1dSRodney W. Grimes 
1340df8bae1dSRodney W. Grimes /*
1341df8bae1dSRodney W. Grimes  * Flush out all the files in a filesystem.
1342df8bae1dSRodney W. Grimes  */
134326f9a767SRodney W. Grimes int
1344b40ce416SJulian Elischer ffs_flushfiles(mp, flags, td)
134505f4ff5dSPoul-Henning Kamp 	struct mount *mp;
1346df8bae1dSRodney W. Grimes 	int flags;
1347b40ce416SJulian Elischer 	struct thread *td;
1348df8bae1dSRodney W. Grimes {
134905f4ff5dSPoul-Henning Kamp 	struct ufsmount *ump;
1350ba05dec5SKonstantin Belousov 	int qerror, error;
1351df8bae1dSRodney W. Grimes 
1352df8bae1dSRodney W. Grimes 	ump = VFSTOUFS(mp);
1353ba05dec5SKonstantin Belousov 	qerror = 0;
1354df8bae1dSRodney W. Grimes #ifdef QUOTA
1355df8bae1dSRodney W. Grimes 	if (mp->mnt_flag & MNT_QUOTA) {
1356c1d9efcbSPoul-Henning Kamp 		int i;
1357f257b7a5SAlfred Perlstein 		error = vflush(mp, 0, SKIPSYSTEM|flags, td);
1358c1d9efcbSPoul-Henning Kamp 		if (error)
1359df8bae1dSRodney W. Grimes 			return (error);
1360df8bae1dSRodney W. Grimes 		for (i = 0; i < MAXQUOTAS; i++) {
1361ba05dec5SKonstantin Belousov 			error = quotaoff(td, mp, i);
1362ba05dec5SKonstantin Belousov 			if (error != 0) {
1363ba05dec5SKonstantin Belousov 				if ((flags & EARLYFLUSH) == 0)
1364ba05dec5SKonstantin Belousov 					return (error);
1365ba05dec5SKonstantin Belousov 				else
1366ba05dec5SKonstantin Belousov 					qerror = error;
1367df8bae1dSRodney W. Grimes 			}
1368ba05dec5SKonstantin Belousov 		}
1369ba05dec5SKonstantin Belousov 
1370df8bae1dSRodney W. Grimes 		/*
1371ba05dec5SKonstantin Belousov 		 * Here we fall through to vflush again to ensure that
1372ba05dec5SKonstantin Belousov 		 * we have gotten rid of all the system vnodes, unless
1373ba05dec5SKonstantin Belousov 		 * quotas must not be closed.
1374df8bae1dSRodney W. Grimes 		 */
1375df8bae1dSRodney W. Grimes 	}
1376df8bae1dSRodney W. Grimes #endif
1377e6e370a7SJeff Roberson 	ASSERT_VOP_LOCKED(ump->um_devvp, "ffs_flushfiles");
1378e6e370a7SJeff Roberson 	if (ump->um_devvp->v_vflag & VV_COPYONWRITE) {
1379f257b7a5SAlfred Perlstein 		if ((error = vflush(mp, 0, SKIPSYSTEM | flags, td)) != 0)
1380f2a2857bSKirk McKusick 			return (error);
1381f2a2857bSKirk McKusick 		ffs_snapshot_unmount(mp);
138295e7a3c3STor Egge 		flags |= FORCECLOSE;
1383f2a2857bSKirk McKusick 		/*
1384f2a2857bSKirk McKusick 		 * Here we fall through to vflush again to ensure
1385f2a2857bSKirk McKusick 		 * that we have gotten rid of all the system vnodes.
1386f2a2857bSKirk McKusick 		 */
1387f2a2857bSKirk McKusick 	}
1388ba05dec5SKonstantin Belousov 
1389b1897c19SJulian Elischer 	/*
1390ba05dec5SKonstantin Belousov 	 * Do not close system files if quotas were not closed, to be
1391ba05dec5SKonstantin Belousov 	 * able to sync the remaining dquots.  The freeblks softupdate
1392ba05dec5SKonstantin Belousov 	 * workitems might hold a reference on a dquot, preventing
1393ba05dec5SKonstantin Belousov 	 * quotaoff() from completing.  Next round of
1394ba05dec5SKonstantin Belousov 	 * softdep_flushworklist() iteration should process the
1395ba05dec5SKonstantin Belousov 	 * blockers, allowing the next run of quotaoff() to finally
1396ba05dec5SKonstantin Belousov 	 * flush held dquots.
1397ba05dec5SKonstantin Belousov 	 *
1398ba05dec5SKonstantin Belousov 	 * Otherwise, flush all the files.
1399b1897c19SJulian Elischer 	 */
1400ba05dec5SKonstantin Belousov 	if (qerror == 0 && (error = vflush(mp, 0, flags, td)) != 0)
1401b1897c19SJulian Elischer 		return (error);
1402ba05dec5SKonstantin Belousov 
1403b1897c19SJulian Elischer 	/*
1404b1897c19SJulian Elischer 	 * Flush filesystem metadata.
1405b1897c19SJulian Elischer 	 */
1406cb05b60aSAttilio Rao 	vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY);
14078df6bac4SPoul-Henning Kamp 	error = VOP_FSYNC(ump->um_devvp, MNT_WAIT, td);
140822db15c0SAttilio Rao 	VOP_UNLOCK(ump->um_devvp, 0);
1409df8bae1dSRodney W. Grimes 	return (error);
1410df8bae1dSRodney W. Grimes }
1411df8bae1dSRodney W. Grimes 
1412df8bae1dSRodney W. Grimes /*
1413df8bae1dSRodney W. Grimes  * Get filesystem statistics.
1414df8bae1dSRodney W. Grimes  */
1415adf41577SPoul-Henning Kamp static int
1416dfd233edSAttilio Rao ffs_statfs(mp, sbp)
1417df8bae1dSRodney W. Grimes 	struct mount *mp;
141805f4ff5dSPoul-Henning Kamp 	struct statfs *sbp;
1419df8bae1dSRodney W. Grimes {
142005f4ff5dSPoul-Henning Kamp 	struct ufsmount *ump;
142105f4ff5dSPoul-Henning Kamp 	struct fs *fs;
1422df8bae1dSRodney W. Grimes 
1423df8bae1dSRodney W. Grimes 	ump = VFSTOUFS(mp);
1424df8bae1dSRodney W. Grimes 	fs = ump->um_fs;
14251c85e6a3SKirk McKusick 	if (fs->fs_magic != FS_UFS1_MAGIC && fs->fs_magic != FS_UFS2_MAGIC)
1426df8bae1dSRodney W. Grimes 		panic("ffs_statfs");
1427fde81c7dSKirk McKusick 	sbp->f_version = STATFS_VERSION;
1428df8bae1dSRodney W. Grimes 	sbp->f_bsize = fs->fs_fsize;
1429df8bae1dSRodney W. Grimes 	sbp->f_iosize = fs->fs_bsize;
1430df8bae1dSRodney W. Grimes 	sbp->f_blocks = fs->fs_dsize;
14313ba649d7SJeff Roberson 	UFS_LOCK(ump);
1432df8bae1dSRodney W. Grimes 	sbp->f_bfree = fs->fs_cstotal.cs_nbfree * fs->fs_frag +
14339ccb939eSKirk McKusick 	    fs->fs_cstotal.cs_nffree + dbtofsb(fs, fs->fs_pendingblocks);
14349ccb939eSKirk McKusick 	sbp->f_bavail = freespace(fs, fs->fs_minfree) +
14359ccb939eSKirk McKusick 	    dbtofsb(fs, fs->fs_pendingblocks);
14361dc349abSEd Maste 	sbp->f_files =  fs->fs_ncg * fs->fs_ipg - UFS_ROOTINO;
14379ccb939eSKirk McKusick 	sbp->f_ffree = fs->fs_cstotal.cs_nifree + fs->fs_pendinginodes;
14383ba649d7SJeff Roberson 	UFS_UNLOCK(ump);
1439a96da1c3SConrad Meyer 	sbp->f_namemax = UFS_MAXNAMLEN;
1440df8bae1dSRodney W. Grimes 	return (0);
1441df8bae1dSRodney W. Grimes }
1442df8bae1dSRodney W. Grimes 
14431eabd967SKonstantin Belousov static bool
14441eabd967SKonstantin Belousov sync_doupdate(struct inode *ip)
14451eabd967SKonstantin Belousov {
14461eabd967SKonstantin Belousov 
14471eabd967SKonstantin Belousov 	return ((ip->i_flag & (IN_ACCESS | IN_CHANGE | IN_MODIFIED |
14481eabd967SKonstantin Belousov 	    IN_UPDATE)) != 0);
14491eabd967SKonstantin Belousov }
14501eabd967SKonstantin Belousov 
1451df8bae1dSRodney W. Grimes /*
1452a988a5c6SKonstantin Belousov  * For a lazy sync, we only care about access times, quotas and the
1453a988a5c6SKonstantin Belousov  * superblock.  Other filesystem changes are already converted to
1454a988a5c6SKonstantin Belousov  * cylinder group blocks or inode blocks updates and are written to
1455a988a5c6SKonstantin Belousov  * disk by syncer.
1456a988a5c6SKonstantin Belousov  */
1457a988a5c6SKonstantin Belousov static int
1458a988a5c6SKonstantin Belousov ffs_sync_lazy(mp)
1459a988a5c6SKonstantin Belousov      struct mount *mp;
1460a988a5c6SKonstantin Belousov {
1461a988a5c6SKonstantin Belousov 	struct vnode *mvp, *vp;
1462a988a5c6SKonstantin Belousov 	struct inode *ip;
1463a988a5c6SKonstantin Belousov 	struct thread *td;
1464a988a5c6SKonstantin Belousov 	int allerror, error;
1465a988a5c6SKonstantin Belousov 
1466a988a5c6SKonstantin Belousov 	allerror = 0;
1467a988a5c6SKonstantin Belousov 	td = curthread;
1468a988a5c6SKonstantin Belousov 	if ((mp->mnt_flag & MNT_NOATIME) != 0)
1469a988a5c6SKonstantin Belousov 		goto qupdate;
1470dca5e0ecSKirk McKusick 	MNT_VNODE_FOREACH_ACTIVE(vp, mp, mvp) {
147171469bb3SKirk McKusick 		if (vp->v_type == VNON) {
1472a988a5c6SKonstantin Belousov 			VI_UNLOCK(vp);
1473a988a5c6SKonstantin Belousov 			continue;
1474a988a5c6SKonstantin Belousov 		}
1475a988a5c6SKonstantin Belousov 		ip = VTOI(vp);
1476a988a5c6SKonstantin Belousov 
1477a988a5c6SKonstantin Belousov 		/*
1478a988a5c6SKonstantin Belousov 		 * The IN_ACCESS flag is converted to IN_MODIFIED by
1479a988a5c6SKonstantin Belousov 		 * ufs_close() and ufs_getattr() by the calls to
1480ea573a50SKonstantin Belousov 		 * ufs_itimes_locked(), without subsequent UFS_UPDATE().
1481ea573a50SKonstantin Belousov 		 * Test also all the other timestamp flags too, to pick up
1482ea573a50SKonstantin Belousov 		 * any other cases that could be missed.
1483a988a5c6SKonstantin Belousov 		 */
14841eabd967SKonstantin Belousov 		if (!sync_doupdate(ip) && (vp->v_iflag & VI_OWEINACT) == 0) {
1485a988a5c6SKonstantin Belousov 			VI_UNLOCK(vp);
1486a988a5c6SKonstantin Belousov 			continue;
1487a988a5c6SKonstantin Belousov 		}
1488a988a5c6SKonstantin Belousov 		if ((error = vget(vp, LK_EXCLUSIVE | LK_NOWAIT | LK_INTERLOCK,
148971469bb3SKirk McKusick 		    td)) != 0)
1490a988a5c6SKonstantin Belousov 			continue;
14911eabd967SKonstantin Belousov 		if (sync_doupdate(ip))
1492a988a5c6SKonstantin Belousov 			error = ffs_update(vp, 0);
1493a988a5c6SKonstantin Belousov 		if (error != 0)
1494a988a5c6SKonstantin Belousov 			allerror = error;
1495a988a5c6SKonstantin Belousov 		vput(vp);
1496a988a5c6SKonstantin Belousov 	}
1497a988a5c6SKonstantin Belousov 
1498a988a5c6SKonstantin Belousov qupdate:
1499a988a5c6SKonstantin Belousov #ifdef QUOTA
1500a988a5c6SKonstantin Belousov 	qsync(mp);
1501a988a5c6SKonstantin Belousov #endif
1502a988a5c6SKonstantin Belousov 
1503a988a5c6SKonstantin Belousov 	if (VFSTOUFS(mp)->um_fs->fs_fmod != 0 &&
1504a988a5c6SKonstantin Belousov 	    (error = ffs_sbupdate(VFSTOUFS(mp), MNT_LAZY, 0)) != 0)
1505a988a5c6SKonstantin Belousov 		allerror = error;
1506a988a5c6SKonstantin Belousov 	return (allerror);
1507a988a5c6SKonstantin Belousov }
1508a988a5c6SKonstantin Belousov 
1509a988a5c6SKonstantin Belousov /*
1510df8bae1dSRodney W. Grimes  * Go through the disk queues to initiate sandbagged IO;
1511df8bae1dSRodney W. Grimes  * go through the inodes to write those that have been modified;
1512df8bae1dSRodney W. Grimes  * initiate the writing of the super block if it has been modified.
1513df8bae1dSRodney W. Grimes  *
1514a988a5c6SKonstantin Belousov  * Note: we are always called with the filesystem marked busy using
1515a988a5c6SKonstantin Belousov  * vfs_busy().
1516df8bae1dSRodney W. Grimes  */
1517adf41577SPoul-Henning Kamp static int
1518dfd233edSAttilio Rao ffs_sync(mp, waitfor)
1519df8bae1dSRodney W. Grimes 	struct mount *mp;
1520df8bae1dSRodney W. Grimes 	int waitfor;
1521df8bae1dSRodney W. Grimes {
152282be0a5aSTor Egge 	struct vnode *mvp, *vp, *devvp;
1523dfd233edSAttilio Rao 	struct thread *td;
1524996c772fSJohn Dyson 	struct inode *ip;
1525996c772fSJohn Dyson 	struct ufsmount *ump = VFSTOUFS(mp);
1526996c772fSJohn Dyson 	struct fs *fs;
152769baeadcSKonstantin Belousov 	int error, count, lockreq, allerror = 0;
1528791dd2faSTor Egge 	int suspend;
1529791dd2faSTor Egge 	int suspended;
1530791dd2faSTor Egge 	int secondary_writes;
1531791dd2faSTor Egge 	int secondary_accwrites;
1532791dd2faSTor Egge 	int softdep_deps;
1533791dd2faSTor Egge 	int softdep_accdeps;
1534156cb265SPoul-Henning Kamp 	struct bufobj *bo;
1535df8bae1dSRodney W. Grimes 
153619c87af0SKirk McKusick 	suspend = 0;
153719c87af0SKirk McKusick 	suspended = 0;
1538dfd233edSAttilio Rao 	td = curthread;
1539df8bae1dSRodney W. Grimes 	fs = ump->um_fs;
1540b60ee81eSKirk McKusick 	if (fs->fs_fmod != 0 && fs->fs_ronly != 0 && ump->um_fsckpid == 0)
1541b60ee81eSKirk McKusick 		panic("%s: ffs_sync: modification on read-only filesystem",
1542b60ee81eSKirk McKusick 		    fs->fs_fsmnt);
15434af9f77eSKonstantin Belousov 	if (waitfor == MNT_LAZY) {
15444af9f77eSKonstantin Belousov 		if (!rebooting)
1545a988a5c6SKonstantin Belousov 			return (ffs_sync_lazy(mp));
15464af9f77eSKonstantin Belousov 		waitfor = MNT_NOWAIT;
15474af9f77eSKonstantin Belousov 	}
1548a988a5c6SKonstantin Belousov 
154919c87af0SKirk McKusick 	/*
1550df8bae1dSRodney W. Grimes 	 * Write back each (modified) inode.
1551df8bae1dSRodney W. Grimes 	 */
1552245df27cSMatthew Dillon 	lockreq = LK_EXCLUSIVE | LK_NOWAIT;
1553791dd2faSTor Egge 	if (waitfor == MNT_SUSPEND) {
1554791dd2faSTor Egge 		suspend = 1;
1555791dd2faSTor Egge 		waitfor = MNT_WAIT;
1556791dd2faSTor Egge 	}
155769baeadcSKonstantin Belousov 	if (waitfor == MNT_WAIT)
1558245df27cSMatthew Dillon 		lockreq = LK_EXCLUSIVE;
155941d4783dSJeff Roberson 	lockreq |= LK_INTERLOCK | LK_SLEEPFAIL;
1560df8bae1dSRodney W. Grimes loop:
1561791dd2faSTor Egge 	/* Grab snapshot of secondary write counts */
156271469bb3SKirk McKusick 	MNT_ILOCK(mp);
1563791dd2faSTor Egge 	secondary_writes = mp->mnt_secondary_writes;
1564791dd2faSTor Egge 	secondary_accwrites = mp->mnt_secondary_accwrites;
156571469bb3SKirk McKusick 	MNT_IUNLOCK(mp);
1566791dd2faSTor Egge 
1567791dd2faSTor Egge 	/* Grab snapshot of softdep dependency counts */
1568791dd2faSTor Egge 	softdep_get_depcounts(mp, &softdep_deps, &softdep_accdeps);
1569791dd2faSTor Egge 
157071469bb3SKirk McKusick 	MNT_VNODE_FOREACH_ALL(vp, mp, mvp) {
1571245df27cSMatthew Dillon 		/*
1572e0c17408SKonstantin Belousov 		 * Depend on the vnode interlock to keep things stable enough
1573245df27cSMatthew Dillon 		 * for a quick test.  Since there might be hundreds of
1574245df27cSMatthew Dillon 		 * thousands of vnodes, we cannot afford even a subroutine
1575245df27cSMatthew Dillon 		 * call unless there's a good chance that we have work to do.
1576245df27cSMatthew Dillon 		 */
157771469bb3SKirk McKusick 		if (vp->v_type == VNON) {
15782f05568aSJeff Roberson 			VI_UNLOCK(vp);
15792f05568aSJeff Roberson 			continue;
15802f05568aSJeff Roberson 		}
1581df8bae1dSRodney W. Grimes 		ip = VTOI(vp);
158271469bb3SKirk McKusick 		if ((ip->i_flag &
1583cf60e8e4SKirk McKusick 		    (IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE)) == 0 &&
158471469bb3SKirk McKusick 		    vp->v_bufobj.bo_dirty.bv_cnt == 0) {
15852f05568aSJeff Roberson 			VI_UNLOCK(vp);
1586df8bae1dSRodney W. Grimes 			continue;
1587996c772fSJohn Dyson 		}
1588b40ce416SJulian Elischer 		if ((error = vget(vp, lockreq, td)) != 0) {
158982be0a5aSTor Egge 			if (error == ENOENT || error == ENOLCK) {
159071469bb3SKirk McKusick 				MNT_VNODE_FOREACH_ALL_ABORT(mp, mvp);
1591df8bae1dSRodney W. Grimes 				goto loop;
159282be0a5aSTor Egge 			}
15932f05568aSJeff Roberson 			continue;
15942f05568aSJeff Roberson 		}
159575a58389SKirk McKusick 		if ((error = ffs_syncvnode(vp, waitfor, 0)) != 0)
1596df8bae1dSRodney W. Grimes 			allerror = error;
159741d4783dSJeff Roberson 		vput(vp);
1598245df27cSMatthew Dillon 	}
1599df8bae1dSRodney W. Grimes 	/*
1600df8bae1dSRodney W. Grimes 	 * Force stale filesystem control information to be flushed.
1601df8bae1dSRodney W. Grimes 	 */
16024af9f77eSKonstantin Belousov 	if (waitfor == MNT_WAIT || rebooting) {
1603b40ce416SJulian Elischer 		if ((error = softdep_flushworklist(ump->um_mountp, &count, td)))
16049b971133SKirk McKusick 			allerror = error;
16059b971133SKirk McKusick 		/* Flushed work items may create new vnodes to clean */
160671469bb3SKirk McKusick 		if (allerror == 0 && count)
16079b971133SKirk McKusick 			goto loop;
16089b971133SKirk McKusick 	}
1609589c7af9SKirk McKusick #ifdef QUOTA
1610589c7af9SKirk McKusick 	qsync(mp);
1611589c7af9SKirk McKusick #endif
161219c87af0SKirk McKusick 
1613112f7372SKirk McKusick 	devvp = ump->um_devvp;
1614156cb265SPoul-Henning Kamp 	bo = &devvp->v_bufobj;
1615698b1a66SJeff Roberson 	BO_LOCK(bo);
161619c87af0SKirk McKusick 	if (bo->bo_numoutput > 0 || bo->bo_dirty.bv_cnt > 0) {
1617698b1a66SJeff Roberson 		BO_UNLOCK(bo);
1618698b1a66SJeff Roberson 		vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
16194af9f77eSKonstantin Belousov 		error = VOP_FSYNC(devvp, waitfor, td);
162022db15c0SAttilio Rao 		VOP_UNLOCK(devvp, 0);
16214af9f77eSKonstantin Belousov 		if (MOUNTEDSOFTDEP(mp) && (error == 0 || error == EAGAIN))
16224af9f77eSKonstantin Belousov 			error = ffs_sbupdate(ump, waitfor, 0);
16234af9f77eSKonstantin Belousov 		if (error != 0)
16244af9f77eSKonstantin Belousov 			allerror = error;
162571469bb3SKirk McKusick 		if (allerror == 0 && waitfor == MNT_WAIT)
1626112f7372SKirk McKusick 			goto loop;
1627791dd2faSTor Egge 	} else if (suspend != 0) {
1628791dd2faSTor Egge 		if (softdep_check_suspend(mp,
1629791dd2faSTor Egge 					  devvp,
1630791dd2faSTor Egge 					  softdep_deps,
1631791dd2faSTor Egge 					  softdep_accdeps,
1632791dd2faSTor Egge 					  secondary_writes,
163371469bb3SKirk McKusick 					  secondary_accwrites) != 0) {
163471469bb3SKirk McKusick 			MNT_IUNLOCK(mp);
1635791dd2faSTor Egge 			goto loop;	/* More work needed */
163671469bb3SKirk McKusick 		}
1637791dd2faSTor Egge 		mtx_assert(MNT_MTX(mp), MA_OWNED);
1638ca2fa807STor Egge 		mp->mnt_kern_flag |= MNTK_SUSPEND2 | MNTK_SUSPENDED;
1639791dd2faSTor Egge 		MNT_IUNLOCK(mp);
1640791dd2faSTor Egge 		suspended = 1;
1641112f7372SKirk McKusick 	} else
1642698b1a66SJeff Roberson 		BO_UNLOCK(bo);
1643996c772fSJohn Dyson 	/*
1644996c772fSJohn Dyson 	 * Write back modified superblock.
1645996c772fSJohn Dyson 	 */
1646791dd2faSTor Egge 	if (fs->fs_fmod != 0 &&
1647791dd2faSTor Egge 	    (error = ffs_sbupdate(ump, waitfor, suspended)) != 0)
1648996c772fSJohn Dyson 		allerror = error;
1649df8bae1dSRodney W. Grimes 	return (allerror);
1650df8bae1dSRodney W. Grimes }
1651df8bae1dSRodney W. Grimes 
1652df8bae1dSRodney W. Grimes int
1653a0595d02SKirk McKusick ffs_vget(mp, ino, flags, vpp)
1654df8bae1dSRodney W. Grimes 	struct mount *mp;
1655df8bae1dSRodney W. Grimes 	ino_t ino;
1656a0595d02SKirk McKusick 	int flags;
1657df8bae1dSRodney W. Grimes 	struct vnode **vpp;
1658df8bae1dSRodney W. Grimes {
16597b7ed832SKonstantin Belousov 	return (ffs_vgetf(mp, ino, flags, vpp, 0));
16607b7ed832SKonstantin Belousov }
16617b7ed832SKonstantin Belousov 
16627b7ed832SKonstantin Belousov int
16637b7ed832SKonstantin Belousov ffs_vgetf(mp, ino, flags, vpp, ffs_flags)
16647b7ed832SKonstantin Belousov 	struct mount *mp;
16657b7ed832SKonstantin Belousov 	ino_t ino;
16667b7ed832SKonstantin Belousov 	int flags;
16677b7ed832SKonstantin Belousov 	struct vnode **vpp;
16687b7ed832SKonstantin Belousov 	int ffs_flags;
16697b7ed832SKonstantin Belousov {
1670996c772fSJohn Dyson 	struct fs *fs;
1671996c772fSJohn Dyson 	struct inode *ip;
1672df8bae1dSRodney W. Grimes 	struct ufsmount *ump;
1673df8bae1dSRodney W. Grimes 	struct buf *bp;
1674df8bae1dSRodney W. Grimes 	struct vnode *vp;
1675f576a00dSSemen Ustimenko 	int error;
1676df8bae1dSRodney W. Grimes 
167751f5ce0cSPoul-Henning Kamp 	error = vfs_hash_get(mp, ino, flags, curthread, vpp, NULL, NULL);
1678e82ef95cSPoul-Henning Kamp 	if (error || *vpp != NULL)
167914bc0685SPoul-Henning Kamp 		return (error);
1680f576a00dSSemen Ustimenko 
1681f576a00dSSemen Ustimenko 	/*
1682d6919865SJeff Roberson 	 * We must promote to an exclusive lock for vnode creation.  This
1683d6919865SJeff Roberson 	 * can happen if lookup is passed LOCKSHARED.
1684d6919865SJeff Roberson 	 */
1685d6919865SJeff Roberson 	if ((flags & LK_TYPE_MASK) == LK_SHARED) {
1686d6919865SJeff Roberson 		flags &= ~LK_TYPE_MASK;
1687d6919865SJeff Roberson 		flags |= LK_EXCLUSIVE;
1688d6919865SJeff Roberson 	}
1689d6919865SJeff Roberson 
1690d6919865SJeff Roberson 	/*
169113866b3fSSemen Ustimenko 	 * We do not lock vnode creation as it is believed to be too
1692f576a00dSSemen Ustimenko 	 * expensive for such rare case as simultaneous creation of vnode
1693f576a00dSSemen Ustimenko 	 * for same ino by different processes. We just allow them to race
1694f576a00dSSemen Ustimenko 	 * and check later to decide who wins. Let the race begin!
1695f576a00dSSemen Ustimenko 	 */
169614bc0685SPoul-Henning Kamp 
169714bc0685SPoul-Henning Kamp 	ump = VFSTOUFS(mp);
169814bc0685SPoul-Henning Kamp 	fs = ump->um_fs;
169914bc0685SPoul-Henning Kamp 	ip = uma_zalloc(uma_inode, M_WAITOK | M_ZERO);
17002f9bae59SDavid Greenman 
1701df8bae1dSRodney W. Grimes 	/* Allocate a new vnode/inode. */
170243a993bbSKirk McKusick 	error = getnewvnode("ufs", mp, fs->fs_magic == FS_UFS1_MAGIC ?
170343a993bbSKirk McKusick 	    &ffs_vnodeops1 : &ffs_vnodeops2, &vp);
1704c9671602SPoul-Henning Kamp 	if (error) {
1705df8bae1dSRodney W. Grimes 		*vpp = NULL;
1706aa4d7a8aSPoul-Henning Kamp 		uma_zfree(uma_inode, ip);
1707df8bae1dSRodney W. Grimes 		return (error);
1708df8bae1dSRodney W. Grimes 	}
170967e87166SBoris Popov 	/*
171033fc3625SJohn Baldwin 	 * FFS supports recursive locking.
171167e87166SBoris Popov 	 */
17123634d5b2SJohn Baldwin 	lockmgr(vp->v_vnlock, LK_EXCLUSIVE, NULL);
1713628f51d2SAttilio Rao 	VN_LOCK_AREC(vp);
1714df8bae1dSRodney W. Grimes 	vp->v_data = ip;
17155d9d81e7SPoul-Henning Kamp 	vp->v_bufobj.bo_bsize = fs->fs_bsize;
1716df8bae1dSRodney W. Grimes 	ip->i_vnode = vp;
17171c85e6a3SKirk McKusick 	ip->i_ump = ump;
1718df8bae1dSRodney W. Grimes 	ip->i_number = ino;
1719e65f5a4eSKonstantin Belousov 	ip->i_ea_refs = 0;
172074a87c38SKirk McKusick 	ip->i_nextclustercg = -1;
1721e1db6897SKonstantin Belousov 	ip->i_flag = fs->fs_magic == FS_UFS1_MAGIC ? 0 : IN_UFS2;
1722df8bae1dSRodney W. Grimes #ifdef QUOTA
1723c1d9efcbSPoul-Henning Kamp 	{
1724c1d9efcbSPoul-Henning Kamp 		int i;
1725df8bae1dSRodney W. Grimes 		for (i = 0; i < MAXQUOTAS; i++)
1726df8bae1dSRodney W. Grimes 			ip->i_dquot[i] = NODQUOT;
1727c1d9efcbSPoul-Henning Kamp 	}
1728df8bae1dSRodney W. Grimes #endif
1729df8bae1dSRodney W. Grimes 
17307b7ed832SKonstantin Belousov 	if (ffs_flags & FFSV_FORCEINSMQ)
17317b7ed832SKonstantin Belousov 		vp->v_vflag |= VV_FORCEINSMQ;
173261b9d89fSTor Egge 	error = insmntque(vp, mp);
173361b9d89fSTor Egge 	if (error != 0) {
17346cc745d2SKonstantin Belousov 		uma_zfree(uma_inode, ip);
173561b9d89fSTor Egge 		*vpp = NULL;
173661b9d89fSTor Egge 		return (error);
173761b9d89fSTor Egge 	}
17387b7ed832SKonstantin Belousov 	vp->v_vflag &= ~VV_FORCEINSMQ;
1739a80d8caaSPawel Jakub Dawidek 	error = vfs_hash_insert(vp, ino, flags, curthread, vpp, NULL, NULL);
174045c26fa2SPoul-Henning Kamp 	if (error || *vpp != NULL)
1741f576a00dSSemen Ustimenko 		return (error);
1742f576a00dSSemen Ustimenko 
1743df8bae1dSRodney W. Grimes 	/* Read in the disk contents for the inode, copy into the inode. */
1744c9671602SPoul-Henning Kamp 	error = bread(ump->um_devvp, fsbtodb(fs, ino_to_fsba(fs, ino)),
1745c9671602SPoul-Henning Kamp 	    (int)fs->fs_bsize, NOCRED, &bp);
1746c9671602SPoul-Henning Kamp 	if (error) {
1747df8bae1dSRodney W. Grimes 		/*
1748df8bae1dSRodney W. Grimes 		 * The inode does not contain anything useful, so it would
1749df8bae1dSRodney W. Grimes 		 * be misleading to leave it on its hash chain. With mode
1750df8bae1dSRodney W. Grimes 		 * still zero, it will be unlinked and returned to the free
1751df8bae1dSRodney W. Grimes 		 * list by vput().
1752df8bae1dSRodney W. Grimes 		 */
1753df8bae1dSRodney W. Grimes 		brelse(bp);
1754bd7e5f99SJohn Dyson 		vput(vp);
1755df8bae1dSRodney W. Grimes 		*vpp = NULL;
1756df8bae1dSRodney W. Grimes 		return (error);
1757df8bae1dSRodney W. Grimes 	}
1758e1db6897SKonstantin Belousov 	if (I_IS_UFS1(ip))
1759a163d034SWarner Losh 		ip->i_din1 = uma_zalloc(uma_ufs1, M_WAITOK);
1760de6ba7c0SPoul-Henning Kamp 	else
1761a163d034SWarner Losh 		ip->i_din2 = uma_zalloc(uma_ufs2, M_WAITOK);
1762de6ba7c0SPoul-Henning Kamp 	ffs_load_inode(bp, ip, fs, ino);
1763b1897c19SJulian Elischer 	if (DOINGSOFTDEP(vp))
1764b1897c19SJulian Elischer 		softdep_load_inodeblock(ip);
1765b1897c19SJulian Elischer 	else
1766b1897c19SJulian Elischer 		ip->i_effnlink = ip->i_nlink;
1767bd7e5f99SJohn Dyson 	bqrelse(bp);
1768df8bae1dSRodney W. Grimes 
1769df8bae1dSRodney W. Grimes 	/*
1770df8bae1dSRodney W. Grimes 	 * Initialize the vnode from the inode, check for aliases.
1771df8bae1dSRodney W. Grimes 	 * Note that the underlying vnode may have changed.
1772df8bae1dSRodney W. Grimes 	 */
1773e1db6897SKonstantin Belousov 	error = ufs_vinit(mp, I_IS_UFS1(ip) ? &ffs_fifoops1 : &ffs_fifoops2,
1774e1db6897SKonstantin Belousov 	    &vp);
1775c9671602SPoul-Henning Kamp 	if (error) {
1776df8bae1dSRodney W. Grimes 		vput(vp);
1777df8bae1dSRodney W. Grimes 		*vpp = NULL;
1778df8bae1dSRodney W. Grimes 		return (error);
1779df8bae1dSRodney W. Grimes 	}
1780de68347bSPoul-Henning Kamp 
1781df8bae1dSRodney W. Grimes 	/*
17825c24d6eeSPoul-Henning Kamp 	 * Finish inode initialization.
1783df8bae1dSRodney W. Grimes 	 */
178433fc3625SJohn Baldwin 	if (vp->v_type != VFIFO) {
178533fc3625SJohn Baldwin 		/* FFS supports shared locking for all files except fifos. */
178633fc3625SJohn Baldwin 		VN_LOCK_ASHARE(vp);
178733fc3625SJohn Baldwin 	}
1788de68347bSPoul-Henning Kamp 
1789df8bae1dSRodney W. Grimes 	/*
1790df8bae1dSRodney W. Grimes 	 * Set up a generation number for this inode if it does not
1791df8bae1dSRodney W. Grimes 	 * already have one. This should only happen on old filesystems.
1792df8bae1dSRodney W. Grimes 	 */
1793df8bae1dSRodney W. Grimes 	if (ip->i_gen == 0) {
179457d2ac2fSKevin Lo 		while (ip->i_gen == 0)
179557d2ac2fSKevin Lo 			ip->i_gen = arc4random();
17961c85e6a3SKirk McKusick 		if ((vp->v_mount->mnt_flag & MNT_RDONLY) == 0) {
1797df8bae1dSRodney W. Grimes 			ip->i_flag |= IN_MODIFIED;
1798b403319bSAlexander Kabaev 			DIP_SET(ip, i_gen, ip->i_gen);
17991c85e6a3SKirk McKusick 		}
1800df8bae1dSRodney W. Grimes 	}
1801763bbd2fSRobert Watson #ifdef MAC
1802763bbd2fSRobert Watson 	if ((mp->mnt_flag & MNT_MULTILABEL) && ip->i_mode) {
1803763bbd2fSRobert Watson 		/*
1804763bbd2fSRobert Watson 		 * If this vnode is already allocated, and we're running
1805763bbd2fSRobert Watson 		 * multi-label, attempt to perform a label association
1806763bbd2fSRobert Watson 		 * from the extended attributes on the inode.
1807763bbd2fSRobert Watson 		 */
180830d239bcSRobert Watson 		error = mac_vnode_associate_extattr(mp, vp);
1809763bbd2fSRobert Watson 		if (error) {
1810763bbd2fSRobert Watson 			/* ufs_inactive will release ip->i_devvp ref. */
1811763bbd2fSRobert Watson 			vput(vp);
1812763bbd2fSRobert Watson 			*vpp = NULL;
1813763bbd2fSRobert Watson 			return (error);
1814763bbd2fSRobert Watson 		}
1815763bbd2fSRobert Watson 	}
1816763bbd2fSRobert Watson #endif
1817763bbd2fSRobert Watson 
1818df8bae1dSRodney W. Grimes 	*vpp = vp;
1819df8bae1dSRodney W. Grimes 	return (0);
1820df8bae1dSRodney W. Grimes }
1821df8bae1dSRodney W. Grimes 
1822df8bae1dSRodney W. Grimes /*
1823df8bae1dSRodney W. Grimes  * File handle to vnode
1824df8bae1dSRodney W. Grimes  *
1825df8bae1dSRodney W. Grimes  * Have to be really careful about stale file handles:
1826df8bae1dSRodney W. Grimes  * - check that the inode number is valid
1827abe53f7eSKirk McKusick  * - for UFS2 check that the inode number is initialized
1828df8bae1dSRodney W. Grimes  * - call ffs_vget() to get the locked inode
1829df8bae1dSRodney W. Grimes  * - check for an unallocated inode (i_mode == 0)
1830df8bae1dSRodney W. Grimes  * - check that the given client host has export rights and return
1831df8bae1dSRodney W. Grimes  *   those rights via. exflagsp and credanonp
1832df8bae1dSRodney W. Grimes  */
1833adf41577SPoul-Henning Kamp static int
1834694a586aSRick Macklem ffs_fhtovp(mp, fhp, flags, vpp)
183505f4ff5dSPoul-Henning Kamp 	struct mount *mp;
1836df8bae1dSRodney W. Grimes 	struct fid *fhp;
1837694a586aSRick Macklem 	int flags;
1838df8bae1dSRodney W. Grimes 	struct vnode **vpp;
1839df8bae1dSRodney W. Grimes {
184005f4ff5dSPoul-Henning Kamp 	struct ufid *ufhp;
1841abe53f7eSKirk McKusick 	struct ufsmount *ump;
1842df8bae1dSRodney W. Grimes 	struct fs *fs;
1843abe53f7eSKirk McKusick 	struct cg *cgp;
1844abe53f7eSKirk McKusick 	struct buf *bp;
1845abe53f7eSKirk McKusick 	ino_t ino;
1846abe53f7eSKirk McKusick 	u_int cg;
1847abe53f7eSKirk McKusick 	int error;
1848df8bae1dSRodney W. Grimes 
1849df8bae1dSRodney W. Grimes 	ufhp = (struct ufid *)fhp;
1850abe53f7eSKirk McKusick 	ino = ufhp->ufid_ino;
1851abe53f7eSKirk McKusick 	ump = VFSTOUFS(mp);
1852abe53f7eSKirk McKusick 	fs = ump->um_fs;
18531dc349abSEd Maste 	if (ino < UFS_ROOTINO || ino >= fs->fs_ncg * fs->fs_ipg)
1854df8bae1dSRodney W. Grimes 		return (ESTALE);
1855abe53f7eSKirk McKusick 	/*
1856abe53f7eSKirk McKusick 	 * Need to check if inode is initialized because UFS2 does lazy
1857abe53f7eSKirk McKusick 	 * initialization and nfs_fhtovp can offer arbitrary inode numbers.
1858abe53f7eSKirk McKusick 	 */
1859abe53f7eSKirk McKusick 	if (fs->fs_magic != FS_UFS2_MAGIC)
1860abe53f7eSKirk McKusick 		return (ufs_fhtovp(mp, ufhp, flags, vpp));
1861abe53f7eSKirk McKusick 	cg = ino_to_cg(fs, ino);
1862abe53f7eSKirk McKusick 	error = bread(ump->um_devvp, fsbtodb(fs, cgtod(fs, cg)),
1863abe53f7eSKirk McKusick 		(int)fs->fs_cgsize, NOCRED, &bp);
1864abe53f7eSKirk McKusick 	if (error)
1865abe53f7eSKirk McKusick 		return (error);
1866abe53f7eSKirk McKusick 	cgp = (struct cg *)bp->b_data;
1867abe53f7eSKirk McKusick 	if (!cg_chkmagic(cgp) || ino >= cg * fs->fs_ipg + cgp->cg_initediblk) {
1868abe53f7eSKirk McKusick 		brelse(bp);
1869abe53f7eSKirk McKusick 		return (ESTALE);
1870abe53f7eSKirk McKusick 	}
1871abe53f7eSKirk McKusick 	brelse(bp);
1872694a586aSRick Macklem 	return (ufs_fhtovp(mp, ufhp, flags, vpp));
1873df8bae1dSRodney W. Grimes }
1874df8bae1dSRodney W. Grimes 
1875df8bae1dSRodney W. Grimes /*
18765346934fSIan Dowse  * Initialize the filesystem.
1877996c772fSJohn Dyson  */
1878996c772fSJohn Dyson static int
1879996c772fSJohn Dyson ffs_init(vfsp)
1880996c772fSJohn Dyson 	struct vfsconf *vfsp;
1881996c772fSJohn Dyson {
1882996c772fSJohn Dyson 
18831848286aSEdward Tomasz Napierala 	ffs_susp_initialize();
1884b1897c19SJulian Elischer 	softdep_initialize();
1885996c772fSJohn Dyson 	return (ufs_init(vfsp));
1886996c772fSJohn Dyson }
1887996c772fSJohn Dyson 
1888996c772fSJohn Dyson /*
18895346934fSIan Dowse  * Undo the work of ffs_init().
18905346934fSIan Dowse  */
18915346934fSIan Dowse static int
18925346934fSIan Dowse ffs_uninit(vfsp)
18935346934fSIan Dowse 	struct vfsconf *vfsp;
18945346934fSIan Dowse {
18955346934fSIan Dowse 	int ret;
18965346934fSIan Dowse 
18975346934fSIan Dowse 	ret = ufs_uninit(vfsp);
18985346934fSIan Dowse 	softdep_uninitialize();
18991848286aSEdward Tomasz Napierala 	ffs_susp_uninitialize();
19005346934fSIan Dowse 	return (ret);
19015346934fSIan Dowse }
19025346934fSIan Dowse 
19035346934fSIan Dowse /*
1904df8bae1dSRodney W. Grimes  * Write a superblock and associated information back to disk.
1905df8bae1dSRodney W. Grimes  */
19061a60c7fcSPawel Jakub Dawidek int
1907927a12aeSKirk McKusick ffs_sbupdate(ump, waitfor, suspended)
1908927a12aeSKirk McKusick 	struct ufsmount *ump;
1909df8bae1dSRodney W. Grimes 	int waitfor;
1910791dd2faSTor Egge 	int suspended;
1911df8bae1dSRodney W. Grimes {
1912927a12aeSKirk McKusick 	struct fs *fs = ump->um_fs;
19133ba649d7SJeff Roberson 	struct buf *sbbp;
191405f4ff5dSPoul-Henning Kamp 	struct buf *bp;
1915df8bae1dSRodney W. Grimes 	int blks;
1916f55ff3f3SIan Dowse 	void *space;
1917996c772fSJohn Dyson 	int i, size, error, allerror = 0;
1918df8bae1dSRodney W. Grimes 
191974f3809aSKirk McKusick 	if (fs->fs_ronly == 1 &&
1920927a12aeSKirk McKusick 	    (ump->um_mountp->mnt_flag & (MNT_RDONLY | MNT_UPDATE)) !=
1921927a12aeSKirk McKusick 	    (MNT_RDONLY | MNT_UPDATE) && ump->um_fsckpid == 0)
192274f3809aSKirk McKusick 		panic("ffs_sbupdate: write read-only filesystem");
1923996c772fSJohn Dyson 	/*
19243ba649d7SJeff Roberson 	 * We use the superblock's buf to serialize calls to ffs_sbupdate().
19253ba649d7SJeff Roberson 	 */
1926927a12aeSKirk McKusick 	sbbp = getblk(ump->um_devvp, btodb(fs->fs_sblockloc),
1927927a12aeSKirk McKusick 	    (int)fs->fs_sbsize, 0, 0, 0);
19283ba649d7SJeff Roberson 	/*
1929996c772fSJohn Dyson 	 * First write back the summary information.
1930996c772fSJohn Dyson 	 */
1931df8bae1dSRodney W. Grimes 	blks = howmany(fs->fs_cssize, fs->fs_fsize);
1932f55ff3f3SIan Dowse 	space = fs->fs_csp;
1933df8bae1dSRodney W. Grimes 	for (i = 0; i < blks; i += fs->fs_frag) {
1934df8bae1dSRodney W. Grimes 		size = fs->fs_bsize;
1935df8bae1dSRodney W. Grimes 		if (i + fs->fs_frag > blks)
1936df8bae1dSRodney W. Grimes 			size = (blks - i) * fs->fs_fsize;
1937927a12aeSKirk McKusick 		bp = getblk(ump->um_devvp, fsbtodb(fs, fs->fs_csaddr + i),
19387261f5f6SJeff Roberson 		    size, 0, 0, 0);
1939df8bae1dSRodney W. Grimes 		bcopy(space, bp->b_data, (u_int)size);
1940f55ff3f3SIan Dowse 		space = (char *)space + size;
1941791dd2faSTor Egge 		if (suspended)
1942791dd2faSTor Egge 			bp->b_flags |= B_VALIDSUSPWRT;
1943996c772fSJohn Dyson 		if (waitfor != MNT_WAIT)
1944df8bae1dSRodney W. Grimes 			bawrite(bp);
19458aef1712SMatthew Dillon 		else if ((error = bwrite(bp)) != 0)
1946996c772fSJohn Dyson 			allerror = error;
1947df8bae1dSRodney W. Grimes 	}
1948996c772fSJohn Dyson 	/*
1949996c772fSJohn Dyson 	 * Now write back the superblock itself. If any errors occurred
1950996c772fSJohn Dyson 	 * up to this point, then fail so that the superblock avoids
1951996c772fSJohn Dyson 	 * being written out as clean.
1952996c772fSJohn Dyson 	 */
19533ba649d7SJeff Roberson 	if (allerror) {
19543ba649d7SJeff Roberson 		brelse(sbbp);
1955996c772fSJohn Dyson 		return (allerror);
19563ba649d7SJeff Roberson 	}
19573ba649d7SJeff Roberson 	bp = sbbp;
195831574422SKirk McKusick 	if (fs->fs_magic == FS_UFS1_MAGIC && fs->fs_sblockloc != SBLOCK_UFS1 &&
1959e9838c11SJohn-Mark Gurney 	    (fs->fs_old_flags & FS_FLAGS_UPDATED) == 0) {
1960b60ee81eSKirk McKusick 		printf("WARNING: %s: correcting fs_sblockloc from %jd to %d\n",
1961fa5d33e2SKirk McKusick 		    fs->fs_fsmnt, fs->fs_sblockloc, SBLOCK_UFS1);
1962fa5d33e2SKirk McKusick 		fs->fs_sblockloc = SBLOCK_UFS1;
1963fa5d33e2SKirk McKusick 	}
196431574422SKirk McKusick 	if (fs->fs_magic == FS_UFS2_MAGIC && fs->fs_sblockloc != SBLOCK_UFS2 &&
1965e9838c11SJohn-Mark Gurney 	    (fs->fs_old_flags & FS_FLAGS_UPDATED) == 0) {
1966b60ee81eSKirk McKusick 		printf("WARNING: %s: correcting fs_sblockloc from %jd to %d\n",
1967fa5d33e2SKirk McKusick 		    fs->fs_fsmnt, fs->fs_sblockloc, SBLOCK_UFS2);
1968fa5d33e2SKirk McKusick 		fs->fs_sblockloc = SBLOCK_UFS2;
1969fa5d33e2SKirk McKusick 	}
1970b1897c19SJulian Elischer 	fs->fs_fmod = 0;
1971227ee8a1SPoul-Henning Kamp 	fs->fs_time = time_second;
1972519e3c3bSKirk McKusick 	if (MOUNTEDSOFTDEP(ump->um_mountp))
1973927a12aeSKirk McKusick 		softdep_setup_sbupdate(ump, (struct fs *)bp->b_data, bp);
1974996c772fSJohn Dyson 	bcopy((caddr_t)fs, bp->b_data, (u_int)fs->fs_sbsize);
1975927a12aeSKirk McKusick 	ffs_oldfscompat_write((struct fs *)bp->b_data, ump);
1976791dd2faSTor Egge 	if (suspended)
1977791dd2faSTor Egge 		bp->b_flags |= B_VALIDSUSPWRT;
1978996c772fSJohn Dyson 	if (waitfor != MNT_WAIT)
1979996c772fSJohn Dyson 		bawrite(bp);
19808aef1712SMatthew Dillon 	else if ((error = bwrite(bp)) != 0)
1981996c772fSJohn Dyson 		allerror = error;
1982996c772fSJohn Dyson 	return (allerror);
1983df8bae1dSRodney W. Grimes }
1984d6fe88e4SPoul-Henning Kamp 
1985d6fe88e4SPoul-Henning Kamp static int
1986d6fe88e4SPoul-Henning Kamp ffs_extattrctl(struct mount *mp, int cmd, struct vnode *filename_vp,
1987dfd233edSAttilio Rao 	int attrnamespace, const char *attrname)
1988d6fe88e4SPoul-Henning Kamp {
1989d6fe88e4SPoul-Henning Kamp 
1990d6fe88e4SPoul-Henning Kamp #ifdef UFS_EXTATTR
1991d6fe88e4SPoul-Henning Kamp 	return (ufs_extattrctl(mp, cmd, filename_vp, attrnamespace,
1992dfd233edSAttilio Rao 	    attrname));
1993d6fe88e4SPoul-Henning Kamp #else
1994d6fe88e4SPoul-Henning Kamp 	return (vfs_stdextattrctl(mp, cmd, filename_vp, attrnamespace,
1995dfd233edSAttilio Rao 	    attrname));
1996d6fe88e4SPoul-Henning Kamp #endif
1997d6fe88e4SPoul-Henning Kamp }
1998975512a9SPoul-Henning Kamp 
1999975512a9SPoul-Henning Kamp static void
2000975512a9SPoul-Henning Kamp ffs_ifree(struct ufsmount *ump, struct inode *ip)
2001975512a9SPoul-Henning Kamp {
2002975512a9SPoul-Henning Kamp 
200336329289STim J. Robbins 	if (ump->um_fstype == UFS1 && ip->i_din1 != NULL)
2004aa4d7a8aSPoul-Henning Kamp 		uma_zfree(uma_ufs1, ip->i_din1);
200536329289STim J. Robbins 	else if (ip->i_din2 != NULL)
20068d721e87STim J. Robbins 		uma_zfree(uma_ufs2, ip->i_din2);
2007aa4d7a8aSPoul-Henning Kamp 	uma_zfree(uma_inode, ip);
2008975512a9SPoul-Henning Kamp }
20096e77a041SPoul-Henning Kamp 
2010dd19a799SPoul-Henning Kamp static int dobkgrdwrite = 1;
2011dd19a799SPoul-Henning Kamp SYSCTL_INT(_debug, OID_AUTO, dobkgrdwrite, CTLFLAG_RW, &dobkgrdwrite, 0,
2012dd19a799SPoul-Henning Kamp     "Do background writes (honoring the BV_BKGRDWRITE flag)?");
2013dd19a799SPoul-Henning Kamp 
2014dd19a799SPoul-Henning Kamp /*
2015dd19a799SPoul-Henning Kamp  * Complete a background write started from bwrite.
2016dd19a799SPoul-Henning Kamp  */
2017dd19a799SPoul-Henning Kamp static void
2018dd19a799SPoul-Henning Kamp ffs_backgroundwritedone(struct buf *bp)
2019dd19a799SPoul-Henning Kamp {
2020204ec66dSJeff Roberson 	struct bufobj *bufobj;
2021dd19a799SPoul-Henning Kamp 	struct buf *origbp;
2022dd19a799SPoul-Henning Kamp 
2023dd19a799SPoul-Henning Kamp 	/*
2024dd19a799SPoul-Henning Kamp 	 * Find the original buffer that we are writing.
2025dd19a799SPoul-Henning Kamp 	 */
2026204ec66dSJeff Roberson 	bufobj = bp->b_bufobj;
2027204ec66dSJeff Roberson 	BO_LOCK(bufobj);
2028dd19a799SPoul-Henning Kamp 	if ((origbp = gbincore(bp->b_bufobj, bp->b_lblkno)) == NULL)
2029dd19a799SPoul-Henning Kamp 		panic("backgroundwritedone: lost buffer");
2030b2c3df84SKonstantin Belousov 
2031b2c3df84SKonstantin Belousov 	/*
2032b2c3df84SKonstantin Belousov 	 * We should mark the cylinder group buffer origbp as
2033b2c3df84SKonstantin Belousov 	 * dirty, to not loose the failed write.
2034b2c3df84SKonstantin Belousov 	 */
2035b2c3df84SKonstantin Belousov 	if ((bp->b_ioflags & BIO_ERROR) != 0)
2036b2c3df84SKonstantin Belousov 		origbp->b_vflags |= BV_BKGRDERR;
2037204ec66dSJeff Roberson 	BO_UNLOCK(bufobj);
2038dd19a799SPoul-Henning Kamp 	/*
2039dd19a799SPoul-Henning Kamp 	 * Process dependencies then return any unfinished ones.
2040dd19a799SPoul-Henning Kamp 	 */
204126089666SJeff Roberson 	pbrelvp(bp);
2042b2c3df84SKonstantin Belousov 	if (!LIST_EMPTY(&bp->b_dep) && (bp->b_ioflags & BIO_ERROR) == 0)
2043dd19a799SPoul-Henning Kamp 		buf_complete(bp);
2044dd19a799SPoul-Henning Kamp #ifdef SOFTUPDATES
204504533fc6SXin LI 	if (!LIST_EMPTY(&bp->b_dep))
2046dd19a799SPoul-Henning Kamp 		softdep_move_dependencies(bp, origbp);
2047dd19a799SPoul-Henning Kamp #endif
2048dd19a799SPoul-Henning Kamp 	/*
2049204ec66dSJeff Roberson 	 * This buffer is marked B_NOCACHE so when it is released
2050204ec66dSJeff Roberson 	 * by biodone it will be tossed.
2051dd19a799SPoul-Henning Kamp 	 */
2052dd19a799SPoul-Henning Kamp 	bp->b_flags |= B_NOCACHE;
2053ec9c9e73SAlan Cox 	bp->b_flags &= ~B_CACHE;
2054b2c3df84SKonstantin Belousov 
2055b2c3df84SKonstantin Belousov 	/*
2056b2c3df84SKonstantin Belousov 	 * Prevent brelse() from trying to keep and re-dirtying bp on
2057b2c3df84SKonstantin Belousov 	 * errors. It causes b_bufobj dereference in
2058b2c3df84SKonstantin Belousov 	 * bdirty()/reassignbuf(), and b_bufobj was cleared in
2059b2c3df84SKonstantin Belousov 	 * pbrelvp() above.
2060b2c3df84SKonstantin Belousov 	 */
2061b2c3df84SKonstantin Belousov 	if ((bp->b_ioflags & BIO_ERROR) != 0)
2062b2c3df84SKonstantin Belousov 		bp->b_flags |= B_INVAL;
2063dd19a799SPoul-Henning Kamp 	bufdone(bp);
2064204ec66dSJeff Roberson 	BO_LOCK(bufobj);
2065dd19a799SPoul-Henning Kamp 	/*
2066dd19a799SPoul-Henning Kamp 	 * Clear the BV_BKGRDINPROG flag in the original buffer
2067dd19a799SPoul-Henning Kamp 	 * and awaken it if it is waiting for the write to complete.
2068dd19a799SPoul-Henning Kamp 	 * If BV_BKGRDINPROG is not set in the original buffer it must
2069dd19a799SPoul-Henning Kamp 	 * have been released and re-instantiated - which is not legal.
2070dd19a799SPoul-Henning Kamp 	 */
2071dd19a799SPoul-Henning Kamp 	KASSERT((origbp->b_vflags & BV_BKGRDINPROG),
2072dd19a799SPoul-Henning Kamp 	    ("backgroundwritedone: lost buffer2"));
2073dd19a799SPoul-Henning Kamp 	origbp->b_vflags &= ~BV_BKGRDINPROG;
2074dd19a799SPoul-Henning Kamp 	if (origbp->b_vflags & BV_BKGRDWAIT) {
2075dd19a799SPoul-Henning Kamp 		origbp->b_vflags &= ~BV_BKGRDWAIT;
2076dd19a799SPoul-Henning Kamp 		wakeup(&origbp->b_xflags);
2077dd19a799SPoul-Henning Kamp 	}
2078204ec66dSJeff Roberson 	BO_UNLOCK(bufobj);
2079dd19a799SPoul-Henning Kamp }
2080dd19a799SPoul-Henning Kamp 
2081dd19a799SPoul-Henning Kamp 
2082dd19a799SPoul-Henning Kamp /*
2083dd19a799SPoul-Henning Kamp  * Write, release buffer on completion.  (Done by iodone
2084dd19a799SPoul-Henning Kamp  * if async).  Do not bother writing anything if the buffer
2085dd19a799SPoul-Henning Kamp  * is invalid.
2086dd19a799SPoul-Henning Kamp  *
2087dd19a799SPoul-Henning Kamp  * Note that we set B_CACHE here, indicating that buffer is
2088dd19a799SPoul-Henning Kamp  * fully valid and thus cacheable.  This is true even of NFS
2089dd19a799SPoul-Henning Kamp  * now so we set it generally.  This could be set either here
2090dd19a799SPoul-Henning Kamp  * or in biodone() since the I/O is synchronous.  We put it
2091dd19a799SPoul-Henning Kamp  * here.
2092dd19a799SPoul-Henning Kamp  */
2093dd19a799SPoul-Henning Kamp static int
2094dd19a799SPoul-Henning Kamp ffs_bufwrite(struct buf *bp)
2095dd19a799SPoul-Henning Kamp {
2096dd19a799SPoul-Henning Kamp 	struct buf *newbp;
2097dd19a799SPoul-Henning Kamp 
2098dd19a799SPoul-Henning Kamp 	CTR3(KTR_BUF, "bufwrite(%p) vp %p flags %X", bp, bp->b_vp, bp->b_flags);
2099dd19a799SPoul-Henning Kamp 	if (bp->b_flags & B_INVAL) {
2100dd19a799SPoul-Henning Kamp 		brelse(bp);
2101dd19a799SPoul-Henning Kamp 		return (0);
2102dd19a799SPoul-Henning Kamp 	}
2103dd19a799SPoul-Henning Kamp 
2104d638e093SAttilio Rao 	if (!BUF_ISLOCKED(bp))
2105dd19a799SPoul-Henning Kamp 		panic("bufwrite: buffer is not busy???");
2106dd19a799SPoul-Henning Kamp 	/*
2107dd19a799SPoul-Henning Kamp 	 * If a background write is already in progress, delay
2108dd19a799SPoul-Henning Kamp 	 * writing this block if it is asynchronous. Otherwise
2109dd19a799SPoul-Henning Kamp 	 * wait for the background write to complete.
2110dd19a799SPoul-Henning Kamp 	 */
2111dd19a799SPoul-Henning Kamp 	BO_LOCK(bp->b_bufobj);
2112dd19a799SPoul-Henning Kamp 	if (bp->b_vflags & BV_BKGRDINPROG) {
2113dd19a799SPoul-Henning Kamp 		if (bp->b_flags & B_ASYNC) {
2114dd19a799SPoul-Henning Kamp 			BO_UNLOCK(bp->b_bufobj);
2115dd19a799SPoul-Henning Kamp 			bdwrite(bp);
2116dd19a799SPoul-Henning Kamp 			return (0);
2117dd19a799SPoul-Henning Kamp 		}
2118dd19a799SPoul-Henning Kamp 		bp->b_vflags |= BV_BKGRDWAIT;
211922a72260SJeff Roberson 		msleep(&bp->b_xflags, BO_LOCKPTR(bp->b_bufobj), PRIBIO,
212022a72260SJeff Roberson 		    "bwrbg", 0);
2121dd19a799SPoul-Henning Kamp 		if (bp->b_vflags & BV_BKGRDINPROG)
2122dd19a799SPoul-Henning Kamp 			panic("bufwrite: still writing");
2123dd19a799SPoul-Henning Kamp 	}
2124b2c3df84SKonstantin Belousov 	bp->b_vflags &= ~BV_BKGRDERR;
2125dd19a799SPoul-Henning Kamp 	BO_UNLOCK(bp->b_bufobj);
2126dd19a799SPoul-Henning Kamp 
2127dd19a799SPoul-Henning Kamp 	/*
2128dd19a799SPoul-Henning Kamp 	 * If this buffer is marked for background writing and we
2129dd19a799SPoul-Henning Kamp 	 * do not have to wait for it, make a copy and write the
2130dd19a799SPoul-Henning Kamp 	 * copy so as to leave this buffer ready for further use.
2131dd19a799SPoul-Henning Kamp 	 *
2132dd19a799SPoul-Henning Kamp 	 * This optimization eats a lot of memory.  If we have a page
2133dd19a799SPoul-Henning Kamp 	 * or buffer shortfall we can't do it.
2134dd19a799SPoul-Henning Kamp 	 */
2135dd19a799SPoul-Henning Kamp 	if (dobkgrdwrite && (bp->b_xflags & BX_BKGRDWRITE) &&
2136dd19a799SPoul-Henning Kamp 	    (bp->b_flags & B_ASYNC) &&
2137dd19a799SPoul-Henning Kamp 	    !vm_page_count_severe() &&
2138dd19a799SPoul-Henning Kamp 	    !buf_dirty_count_severe()) {
2139dd19a799SPoul-Henning Kamp 		KASSERT(bp->b_iodone == NULL,
2140dd19a799SPoul-Henning Kamp 		    ("bufwrite: needs chained iodone (%p)", bp->b_iodone));
2141dd19a799SPoul-Henning Kamp 
2142dd19a799SPoul-Henning Kamp 		/* get a new block */
2143c1d8b5e8SKonstantin Belousov 		newbp = geteblk(bp->b_bufsize, GB_NOWAIT_BD);
2144c1d8b5e8SKonstantin Belousov 		if (newbp == NULL)
2145c1d8b5e8SKonstantin Belousov 			goto normal_write;
2146dd19a799SPoul-Henning Kamp 
2147fade8dd7SJeff Roberson 		KASSERT(buf_mapped(bp), ("Unmapped cg"));
2148dd19a799SPoul-Henning Kamp 		memcpy(newbp->b_data, bp->b_data, bp->b_bufsize);
2149dd19a799SPoul-Henning Kamp 		BO_LOCK(bp->b_bufobj);
2150dd19a799SPoul-Henning Kamp 		bp->b_vflags |= BV_BKGRDINPROG;
2151dd19a799SPoul-Henning Kamp 		BO_UNLOCK(bp->b_bufobj);
215226089666SJeff Roberson 		newbp->b_xflags |= BX_BKGRDMARKER;
215326089666SJeff Roberson 		newbp->b_lblkno = bp->b_lblkno;
2154dd19a799SPoul-Henning Kamp 		newbp->b_blkno = bp->b_blkno;
2155dd19a799SPoul-Henning Kamp 		newbp->b_offset = bp->b_offset;
2156dd19a799SPoul-Henning Kamp 		newbp->b_iodone = ffs_backgroundwritedone;
2157dd19a799SPoul-Henning Kamp 		newbp->b_flags |= B_ASYNC;
2158dd19a799SPoul-Henning Kamp 		newbp->b_flags &= ~B_INVAL;
215926089666SJeff Roberson 		pbgetvp(bp->b_vp, newbp);
2160dd19a799SPoul-Henning Kamp 
2161dd19a799SPoul-Henning Kamp #ifdef SOFTUPDATES
2162113db2ddSJeff Roberson 		/*
2163113db2ddSJeff Roberson 		 * Move over the dependencies.  If there are rollbacks,
2164113db2ddSJeff Roberson 		 * leave the parent buffer dirtied as it will need to
2165113db2ddSJeff Roberson 		 * be written again.
2166113db2ddSJeff Roberson 		 */
2167113db2ddSJeff Roberson 		if (LIST_EMPTY(&bp->b_dep) ||
2168113db2ddSJeff Roberson 		    softdep_move_dependencies(bp, newbp) == 0)
2169113db2ddSJeff Roberson 			bundirty(bp);
2170113db2ddSJeff Roberson #else
2171113db2ddSJeff Roberson 		bundirty(bp);
2172dd19a799SPoul-Henning Kamp #endif
2173dd19a799SPoul-Henning Kamp 
2174dd19a799SPoul-Henning Kamp 		/*
217526089666SJeff Roberson 		 * Initiate write on the copy, release the original.  The
217626089666SJeff Roberson 		 * BKGRDINPROG flag prevents it from going away until
217726089666SJeff Roberson 		 * the background write completes.
2178dd19a799SPoul-Henning Kamp 		 */
2179dd19a799SPoul-Henning Kamp 		bqrelse(bp);
2180dd19a799SPoul-Henning Kamp 		bp = newbp;
2181113db2ddSJeff Roberson 	} else
2182113db2ddSJeff Roberson 		/* Mark the buffer clean */
2183113db2ddSJeff Roberson 		bundirty(bp);
2184113db2ddSJeff Roberson 
2185dd19a799SPoul-Henning Kamp 
2186dd19a799SPoul-Henning Kamp 	/* Let the normal bufwrite do the rest for us */
2187c1d8b5e8SKonstantin Belousov normal_write:
21889248a827STor Egge 	return (bufwrite(bp));
2189dd19a799SPoul-Henning Kamp }
2190dd19a799SPoul-Henning Kamp 
2191dd19a799SPoul-Henning Kamp 
21928dd56505SPoul-Henning Kamp static void
21936e77a041SPoul-Henning Kamp ffs_geom_strategy(struct bufobj *bo, struct buf *bp)
21946e77a041SPoul-Henning Kamp {
2195153910e0SJeff Roberson 	struct vnode *vp;
2196153910e0SJeff Roberson 	int error;
21977de3839dSTor Egge 	struct buf *tbp;
2198113db2ddSJeff Roberson 	int nocopy;
21996e77a041SPoul-Henning Kamp 
22008660b707SMateusz Guzik 	vp = bo2vnode(bo);
2201153910e0SJeff Roberson 	if (bp->b_iocmd == BIO_WRITE) {
2202153910e0SJeff Roberson 		if ((bp->b_flags & B_VALIDSUSPWRT) == 0 &&
2203153910e0SJeff Roberson 		    bp->b_vp != NULL && bp->b_vp->v_mount != NULL &&
2204153910e0SJeff Roberson 		    (bp->b_vp->v_mount->mnt_kern_flag & MNTK_SUSPENDED) != 0)
2205153910e0SJeff Roberson 			panic("ffs_geom_strategy: bad I/O");
2206113db2ddSJeff Roberson 		nocopy = bp->b_flags & B_NOCOPY;
2207113db2ddSJeff Roberson 		bp->b_flags &= ~(B_VALIDSUSPWRT | B_NOCOPY);
2208113db2ddSJeff Roberson 		if ((vp->v_vflag & VV_COPYONWRITE) && nocopy == 0 &&
22097de3839dSTor Egge 		    vp->v_rdev->si_snapdata != NULL) {
22107de3839dSTor Egge 			if ((bp->b_flags & B_CLUSTER) != 0) {
2211868bb88fSTor Egge 				runningbufwakeup(bp);
22127de3839dSTor Egge 				TAILQ_FOREACH(tbp, &bp->b_cluster.cluster_head,
22137de3839dSTor Egge 					      b_cluster.cluster_entry) {
22147de3839dSTor Egge 					error = ffs_copyonwrite(vp, tbp);
22157de3839dSTor Egge 					if (error != 0 &&
2216153910e0SJeff Roberson 					    error != EOPNOTSUPP) {
2217153910e0SJeff Roberson 						bp->b_error = error;
2218153910e0SJeff Roberson 						bp->b_ioflags |= BIO_ERROR;
2219153910e0SJeff Roberson 						bufdone(bp);
2220153910e0SJeff Roberson 						return;
2221153910e0SJeff Roberson 					}
2222153910e0SJeff Roberson 				}
2223868bb88fSTor Egge 				bp->b_runningbufspace = bp->b_bufsize;
22245bd65606SJohn Baldwin 				atomic_add_long(&runningbufspace,
2225868bb88fSTor Egge 					       bp->b_runningbufspace);
22267de3839dSTor Egge 			} else {
22277de3839dSTor Egge 				error = ffs_copyonwrite(vp, bp);
22287de3839dSTor Egge 				if (error != 0 && error != EOPNOTSUPP) {
22297de3839dSTor Egge 					bp->b_error = error;
22307de3839dSTor Egge 					bp->b_ioflags |= BIO_ERROR;
22317de3839dSTor Egge 					bufdone(bp);
22327de3839dSTor Egge 					return;
22337de3839dSTor Egge 				}
22347de3839dSTor Egge 			}
22357de3839dSTor Egge 		}
22367de3839dSTor Egge #ifdef SOFTUPDATES
22377de3839dSTor Egge 		if ((bp->b_flags & B_CLUSTER) != 0) {
22387de3839dSTor Egge 			TAILQ_FOREACH(tbp, &bp->b_cluster.cluster_head,
22397de3839dSTor Egge 				      b_cluster.cluster_entry) {
224004533fc6SXin LI 				if (!LIST_EMPTY(&tbp->b_dep))
22417de3839dSTor Egge 					buf_start(tbp);
22427de3839dSTor Egge 			}
22437de3839dSTor Egge 		} else {
224404533fc6SXin LI 			if (!LIST_EMPTY(&bp->b_dep))
22457de3839dSTor Egge 				buf_start(bp);
22467de3839dSTor Egge 		}
22477de3839dSTor Egge 
22487de3839dSTor Egge #endif
22497de3839dSTor Egge 	}
225043920011SPoul-Henning Kamp 	g_vfs_strategy(bo, bp);
22516e77a041SPoul-Henning Kamp }
225252dfc8d7SKonstantin Belousov 
22531848286aSEdward Tomasz Napierala int
22541848286aSEdward Tomasz Napierala ffs_own_mount(const struct mount *mp)
22551848286aSEdward Tomasz Napierala {
22561848286aSEdward Tomasz Napierala 
22571848286aSEdward Tomasz Napierala 	if (mp->mnt_op == &ufs_vfsops)
22581848286aSEdward Tomasz Napierala 		return (1);
22591848286aSEdward Tomasz Napierala 	return (0);
22601848286aSEdward Tomasz Napierala }
22611848286aSEdward Tomasz Napierala 
226252dfc8d7SKonstantin Belousov #ifdef	DDB
2263cf058082SBrooks Davis #ifdef SOFTUPDATES
226452dfc8d7SKonstantin Belousov 
2265519e3c3bSKirk McKusick /* defined in ffs_softdep.c */
2266519e3c3bSKirk McKusick extern void db_print_ffs(struct ufsmount *ump);
226752dfc8d7SKonstantin Belousov 
226852dfc8d7SKonstantin Belousov DB_SHOW_COMMAND(ffs, db_show_ffs)
226952dfc8d7SKonstantin Belousov {
227052dfc8d7SKonstantin Belousov 	struct mount *mp;
227152dfc8d7SKonstantin Belousov 	struct ufsmount *ump;
227252dfc8d7SKonstantin Belousov 
227352dfc8d7SKonstantin Belousov 	if (have_addr) {
227452dfc8d7SKonstantin Belousov 		ump = VFSTOUFS((struct mount *)addr);
227552dfc8d7SKonstantin Belousov 		db_print_ffs(ump);
227652dfc8d7SKonstantin Belousov 		return;
227752dfc8d7SKonstantin Belousov 	}
227852dfc8d7SKonstantin Belousov 
227952dfc8d7SKonstantin Belousov 	TAILQ_FOREACH(mp, &mountlist, mnt_list) {
228052dfc8d7SKonstantin Belousov 		if (!strcmp(mp->mnt_stat.f_fstypename, ufs_vfsconf.vfc_name))
228152dfc8d7SKonstantin Belousov 			db_print_ffs(VFSTOUFS(mp));
228252dfc8d7SKonstantin Belousov 	}
228352dfc8d7SKonstantin Belousov }
228452dfc8d7SKonstantin Belousov 
2285cf058082SBrooks Davis #endif	/* SOFTUPDATES */
228652dfc8d7SKonstantin Belousov #endif	/* DDB */
2287