xref: /freebsd/sys/ufs/ffs/ffs_vfsops.c (revision cea903627f3979ac9f6a019912169bf5d9b00a94)
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.
13df8bae1dSRodney W. Grimes  * 4. 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 
3580830407SRobert Watson #include "opt_mac.h"
3601733a9bSGarrett Wollman #include "opt_quota.h"
37516081f2SRobert Watson #include "opt_ufs.h"
386e77a041SPoul-Henning Kamp #include "opt_ffs.h"
3901733a9bSGarrett Wollman 
40df8bae1dSRodney W. Grimes #include <sys/param.h>
41df8bae1dSRodney W. Grimes #include <sys/systm.h>
42df8bae1dSRodney W. Grimes #include <sys/namei.h>
43df8bae1dSRodney W. Grimes #include <sys/proc.h>
44df8bae1dSRodney W. Grimes #include <sys/kernel.h>
45763bbd2fSRobert Watson #include <sys/mac.h>
46df8bae1dSRodney W. Grimes #include <sys/vnode.h>
47df8bae1dSRodney W. Grimes #include <sys/mount.h>
489626b608SPoul-Henning Kamp #include <sys/bio.h>
49df8bae1dSRodney W. Grimes #include <sys/buf.h>
5081bca6ddSKATO Takenori #include <sys/conf.h>
513ac4d1efSBruce Evans #include <sys/fcntl.h>
52df8bae1dSRodney W. Grimes #include <sys/malloc.h>
531b367556SJason Evans #include <sys/mutex.h>
54a18b1f1dSJason Evans 
55a64ed089SRobert Watson #include <ufs/ufs/extattr.h>
56df8bae1dSRodney W. Grimes #include <ufs/ufs/quota.h>
57df8bae1dSRodney W. Grimes #include <ufs/ufs/ufsmount.h>
58df8bae1dSRodney W. Grimes #include <ufs/ufs/inode.h>
59df8bae1dSRodney W. Grimes #include <ufs/ufs/ufs_extern.h>
60df8bae1dSRodney W. Grimes 
61df8bae1dSRodney W. Grimes #include <ufs/ffs/fs.h>
62df8bae1dSRodney W. Grimes #include <ufs/ffs/ffs_extern.h>
63df8bae1dSRodney W. Grimes 
64f6b04d2bSDavid Greenman #include <vm/vm.h>
65aa4d7a8aSPoul-Henning Kamp #include <vm/uma.h>
66f6b04d2bSDavid Greenman #include <vm/vm_page.h>
67f6b04d2bSDavid Greenman 
6843920011SPoul-Henning Kamp #include <geom/geom.h>
6943920011SPoul-Henning Kamp #include <geom/geom_vfs.h>
7043920011SPoul-Henning Kamp 
71adf41577SPoul-Henning Kamp static uma_zone_t uma_inode, uma_ufs1, uma_ufs2;
7255166637SPoul-Henning Kamp 
736f1e8551SAlfred Perlstein static int	ffs_sbupdate(struct ufsmount *, int);
745e8c582aSPoul-Henning Kamp static int	ffs_reload(struct mount *, struct thread *);
75975512a9SPoul-Henning Kamp static int	ffs_mountfs(struct vnode *, struct mount *, struct thread *);
761c85e6a3SKirk McKusick static void	ffs_oldfscompat_read(struct fs *, struct ufsmount *,
771c85e6a3SKirk McKusick 		    ufs2_daddr_t);
781c85e6a3SKirk McKusick static void	ffs_oldfscompat_write(struct fs *, struct ufsmount *);
79975512a9SPoul-Henning Kamp static void	ffs_ifree(struct ufsmount *ump, struct inode *ip);
809bf1a756SPoul-Henning Kamp static vfs_init_t ffs_init;
819bf1a756SPoul-Henning Kamp static vfs_uninit_t ffs_uninit;
82d6fe88e4SPoul-Henning Kamp static vfs_extattrctl_t ffs_extattrctl;
8320a92a18SPoul-Henning Kamp static vfs_cmount_t ffs_cmount;
84adf41577SPoul-Henning Kamp static vfs_unmount_t ffs_unmount;
8520a92a18SPoul-Henning Kamp static vfs_mount_t ffs_mount;
86adf41577SPoul-Henning Kamp static vfs_statfs_t ffs_statfs;
87adf41577SPoul-Henning Kamp static vfs_fhtovp_t ffs_fhtovp;
88adf41577SPoul-Henning Kamp static vfs_vptofh_t ffs_vptofh;
89adf41577SPoul-Henning Kamp static vfs_sync_t ffs_sync;
90df8bae1dSRodney W. Grimes 
91303b270bSEivind Eklund static struct vfsops ufs_vfsops = {
927652131bSPoul-Henning Kamp 	.vfs_extattrctl =	ffs_extattrctl,
937652131bSPoul-Henning Kamp 	.vfs_fhtovp =		ffs_fhtovp,
947652131bSPoul-Henning Kamp 	.vfs_init =		ffs_init,
9520a92a18SPoul-Henning Kamp 	.vfs_mount =		ffs_mount,
9620a92a18SPoul-Henning Kamp 	.vfs_cmount =		ffs_cmount,
977652131bSPoul-Henning Kamp 	.vfs_quotactl =		ufs_quotactl,
987652131bSPoul-Henning Kamp 	.vfs_root =		ufs_root,
997652131bSPoul-Henning Kamp 	.vfs_statfs =		ffs_statfs,
1007652131bSPoul-Henning Kamp 	.vfs_sync =		ffs_sync,
1017652131bSPoul-Henning Kamp 	.vfs_uninit =		ffs_uninit,
1027652131bSPoul-Henning Kamp 	.vfs_unmount =		ffs_unmount,
1037652131bSPoul-Henning Kamp 	.vfs_vget =		ffs_vget,
1047652131bSPoul-Henning Kamp 	.vfs_vptofh =		ffs_vptofh,
105df8bae1dSRodney W. Grimes };
106df8bae1dSRodney W. Grimes 
1078994ca3cSBruce Evans VFS_SET(ufs_vfsops, ufs, 0);
108c901836cSGarrett Wollman 
1096e77a041SPoul-Henning Kamp static b_strategy_t ffs_geom_strategy;
110dd19a799SPoul-Henning Kamp static b_write_t ffs_bufwrite;
1116e77a041SPoul-Henning Kamp 
1126e77a041SPoul-Henning Kamp static struct buf_ops ffs_ops = {
1136e77a041SPoul-Henning Kamp 	.bop_name =	"FFS",
114dd19a799SPoul-Henning Kamp 	.bop_write =	ffs_bufwrite,
1156e77a041SPoul-Henning Kamp 	.bop_strategy =	ffs_geom_strategy,
1166ef8480aSPoul-Henning Kamp 	.bop_sync =	bufsync,
1176e77a041SPoul-Henning Kamp };
1186e77a041SPoul-Henning Kamp 
11926f59b64SCraig Rodrigues static const char *ffs_opts[] = { "acls", "async", "errmsg", "export",
120359d4388SCraig Rodrigues     "force", "from", "multilabel", "noasync", "noatime", "noclusterr",
121359d4388SCraig Rodrigues     "noclusterw", "noexec", "nosuid", "nosymfollow", "snapshot", "sync",
122359d4388SCraig Rodrigues     "suiddir", "update", "union", NULL };
12320a92a18SPoul-Henning Kamp 
1245e8c582aSPoul-Henning Kamp static int
12520a92a18SPoul-Henning Kamp ffs_mount(struct mount *mp, struct thread *td)
126df8bae1dSRodney W. Grimes {
12720a92a18SPoul-Henning Kamp 	struct vnode *devvp;
12826f9a767SRodney W. Grimes 	struct ufsmount *ump = 0;
12905f4ff5dSPoul-Henning Kamp 	struct fs *fs;
130f2a2857bSKirk McKusick 	int error, flags;
131c9b99213SBruce Evans 	mode_t accessmode;
1325e8c582aSPoul-Henning Kamp 	struct nameidata ndp;
133f21cc2caSPoul-Henning Kamp 	struct export_args export;
13420a92a18SPoul-Henning Kamp 	char *fspec;
135df8bae1dSRodney W. Grimes 
13620a92a18SPoul-Henning Kamp 	if (vfs_filteropt(mp->mnt_optnew, ffs_opts))
13720a92a18SPoul-Henning Kamp 		return (EINVAL);
138aa4d7a8aSPoul-Henning Kamp 	if (uma_inode == NULL) {
139aa4d7a8aSPoul-Henning Kamp 		uma_inode = uma_zcreate("FFS inode",
140aa4d7a8aSPoul-Henning Kamp 		    sizeof(struct inode), NULL, NULL, NULL, NULL,
141aa4d7a8aSPoul-Henning Kamp 		    UMA_ALIGN_PTR, 0);
142aa4d7a8aSPoul-Henning Kamp 		uma_ufs1 = uma_zcreate("FFS1 dinode",
143aa4d7a8aSPoul-Henning Kamp 		    sizeof(struct ufs1_dinode), NULL, NULL, NULL, NULL,
144aa4d7a8aSPoul-Henning Kamp 		    UMA_ALIGN_PTR, 0);
145aa4d7a8aSPoul-Henning Kamp 		uma_ufs2 = uma_zcreate("FFS2 dinode",
146aa4d7a8aSPoul-Henning Kamp 		    sizeof(struct ufs2_dinode), NULL, NULL, NULL, NULL,
147aa4d7a8aSPoul-Henning Kamp 		    UMA_ALIGN_PTR, 0);
148aa4d7a8aSPoul-Henning Kamp 	}
1498d02a378SPawel Jakub Dawidek 
15020a92a18SPoul-Henning Kamp 	fspec = vfs_getopts(mp->mnt_optnew, "from", &error);
15151ac12abSPoul-Henning Kamp 	if (error)
152f2a2857bSKirk McKusick 		return (error);
1532b14f991SJulian Elischer 
15426f59b64SCraig Rodrigues 	if (vfs_getopt(mp->mnt_optnew, "acls", NULL, NULL) == 0)
15526f59b64SCraig Rodrigues 		mp->mnt_flag |= MNT_ACLS;
15626f59b64SCraig Rodrigues 
15726f59b64SCraig Rodrigues 	if (vfs_getopt(mp->mnt_optnew, "async", NULL, NULL) == 0)
15826f59b64SCraig Rodrigues 		mp->mnt_flag |= MNT_ASYNC;
15926f59b64SCraig Rodrigues 
16026f59b64SCraig Rodrigues 	if (vfs_getopt(mp->mnt_optnew, "force", NULL, NULL) == 0)
16126f59b64SCraig Rodrigues 		mp->mnt_flag |= MNT_FORCE;
16226f59b64SCraig Rodrigues 
16326f59b64SCraig Rodrigues 	if (vfs_getopt(mp->mnt_optnew, "multilabel", NULL, NULL) == 0)
16426f59b64SCraig Rodrigues 		mp->mnt_flag |= MNT_MULTILABEL;
16526f59b64SCraig Rodrigues 
16626f59b64SCraig Rodrigues 	if (vfs_getopt(mp->mnt_optnew, "noasync", NULL, NULL) == 0)
16726f59b64SCraig Rodrigues 		mp->mnt_flag &= ~MNT_ASYNC;
16826f59b64SCraig Rodrigues 
16926f59b64SCraig Rodrigues 	if (vfs_getopt(mp->mnt_optnew, "noatime", NULL, NULL) == 0)
17026f59b64SCraig Rodrigues 		mp->mnt_flag |= MNT_NOATIME;
17126f59b64SCraig Rodrigues 
17226f59b64SCraig Rodrigues 	if (vfs_getopt(mp->mnt_optnew, "noclusterr", NULL, NULL) == 0)
17326f59b64SCraig Rodrigues 		mp->mnt_flag |= MNT_NOCLUSTERR;
17426f59b64SCraig Rodrigues 
17526f59b64SCraig Rodrigues 	if (vfs_getopt(mp->mnt_optnew, "noclusterw", NULL, NULL) == 0)
17626f59b64SCraig Rodrigues 		mp->mnt_flag |= MNT_NOCLUSTERW;
17726f59b64SCraig Rodrigues 
17826f59b64SCraig Rodrigues 	if (vfs_getopt(mp->mnt_optnew, "snapshot", NULL, NULL) == 0)
17926f59b64SCraig Rodrigues 		mp->mnt_flag |= MNT_SNAPSHOT;
18026f59b64SCraig Rodrigues 
18126f59b64SCraig Rodrigues 	if (vfs_getopt(mp->mnt_optnew, "update", NULL, NULL) == 0)
18226f59b64SCraig Rodrigues 		mp->mnt_flag |= MNT_UPDATE;
18326f59b64SCraig Rodrigues 
184cea90362SCraig Rodrigues 	export.ex_root = -2; /* DEFAULT_ROOTID */
185cea90362SCraig Rodrigues 
186cea90362SCraig Rodrigues 	if (mp->mnt_flag & MNT_RDONLY)
187cea90362SCraig Rodrigues 		export.ex_flags = MNT_EXRDONLY;
188cea90362SCraig Rodrigues 	else
189cea90362SCraig Rodrigues 		export.ex_flags = 0;
190cea90362SCraig Rodrigues 
191df8bae1dSRodney W. Grimes 	/*
192df8bae1dSRodney W. Grimes 	 * If updating, check whether changing from read-only to
193df8bae1dSRodney W. Grimes 	 * read/write; if there is no device name, that's all we do.
194df8bae1dSRodney W. Grimes 	 */
195df8bae1dSRodney W. Grimes 	if (mp->mnt_flag & MNT_UPDATE) {
196df8bae1dSRodney W. Grimes 		ump = VFSTOUFS(mp);
197df8bae1dSRodney W. Grimes 		fs = ump->um_fs;
19826cf9c3bSPeter Wemm 		devvp = ump->um_devvp;
19920a92a18SPoul-Henning Kamp 		if (fs->fs_ronly == 0 &&
20020a92a18SPoul-Henning Kamp 		    vfs_flagopt(mp->mnt_optnew, "ro", NULL, 0)) {
201f2a2857bSKirk McKusick 			if ((error = vn_start_write(NULL, &mp, V_WAIT)) != 0)
202f2a2857bSKirk McKusick 				return (error);
203cd600596SKirk McKusick 			/*
204cd600596SKirk McKusick 			 * Flush any dirty data.
205cd600596SKirk McKusick 			 */
206efd6d980SPoul-Henning Kamp 			if ((error = ffs_sync(mp, MNT_WAIT, td)) != 0) {
2079ab73fd1SKirk McKusick 				vn_finished_write(mp);
2089ab73fd1SKirk McKusick 				return (error);
2099ab73fd1SKirk McKusick 			}
210cd600596SKirk McKusick 			/*
211cd600596SKirk McKusick 			 * Check for and optionally get rid of files open
212cd600596SKirk McKusick 			 * for writing.
213cd600596SKirk McKusick 			 */
214df8bae1dSRodney W. Grimes 			flags = WRITECLOSE;
215df8bae1dSRodney W. Grimes 			if (mp->mnt_flag & MNT_FORCE)
216df8bae1dSRodney W. Grimes 				flags |= FORCECLOSE;
217b1897c19SJulian Elischer 			if (mp->mnt_flag & MNT_SOFTDEP) {
218b40ce416SJulian Elischer 				error = softdep_flushfiles(mp, flags, td);
219b1897c19SJulian Elischer 			} else {
220b40ce416SJulian Elischer 				error = ffs_flushfiles(mp, flags, td);
221df8bae1dSRodney W. Grimes 			}
222f2a2857bSKirk McKusick 			if (error) {
223f2a2857bSKirk McKusick 				vn_finished_write(mp);
224f2a2857bSKirk McKusick 				return (error);
225b1897c19SJulian Elischer 			}
2269ccb939eSKirk McKusick 			if (fs->fs_pendingblocks != 0 ||
2279ccb939eSKirk McKusick 			    fs->fs_pendinginodes != 0) {
228cfbf0a46SMaxime Henrion 				printf("%s: %s: blocks %jd files %d\n",
2291c85e6a3SKirk McKusick 				    fs->fs_fsmnt, "update error",
2301c85e6a3SKirk McKusick 				    (intmax_t)fs->fs_pendingblocks,
2319ccb939eSKirk McKusick 				    fs->fs_pendinginodes);
2329ccb939eSKirk McKusick 				fs->fs_pendingblocks = 0;
2339ccb939eSKirk McKusick 				fs->fs_pendinginodes = 0;
2349ccb939eSKirk McKusick 			}
2351a6a6610SKirk McKusick 			if ((fs->fs_flags & (FS_UNCLEAN | FS_NEEDSFSCK)) == 0)
236f2a2857bSKirk McKusick 				fs->fs_clean = 1;
237f2a2857bSKirk McKusick 			if ((error = ffs_sbupdate(ump, MNT_WAIT)) != 0) {
238f2a2857bSKirk McKusick 				fs->fs_ronly = 0;
239f2a2857bSKirk McKusick 				fs->fs_clean = 0;
240f2a2857bSKirk McKusick 				vn_finished_write(mp);
241f2a2857bSKirk McKusick 				return (error);
2422b14f991SJulian Elischer 			}
243f2a2857bSKirk McKusick 			vn_finished_write(mp);
24443920011SPoul-Henning Kamp 			DROP_GIANT();
24543920011SPoul-Henning Kamp 			g_topology_lock();
24643920011SPoul-Henning Kamp 			g_access(ump->um_cp, 0, -1, 0);
24743920011SPoul-Henning Kamp 			g_topology_unlock();
24843920011SPoul-Henning Kamp 			PICKUP_GIANT();
24920a92a18SPoul-Henning Kamp 			fs->fs_ronly = 1;
25020a92a18SPoul-Henning Kamp 			mp->mnt_flag |= MNT_RDONLY;
251f2a2857bSKirk McKusick 		}
252f2a2857bSKirk McKusick 		if ((mp->mnt_flag & MNT_RELOAD) &&
2535e8c582aSPoul-Henning Kamp 		    (error = ffs_reload(mp, td)) != 0)
254f2a2857bSKirk McKusick 			return (error);
25520a92a18SPoul-Henning Kamp 		if (fs->fs_ronly &&
25620a92a18SPoul-Henning Kamp 		    !vfs_flagopt(mp->mnt_optnew, "ro", NULL, 0)) {
257c9b99213SBruce Evans 			/*
258c9b99213SBruce Evans 			 * If upgrade to read-write by non-root, then verify
259c9b99213SBruce Evans 			 * that user has necessary permissions on the device.
260c9b99213SBruce Evans 			 */
26144731cabSJohn Baldwin 			if (suser(td)) {
262b40ce416SJulian Elischer 				vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td);
2638aef1712SMatthew Dillon 				if ((error = VOP_ACCESS(devvp, VREAD | VWRITE,
264a854ed98SJohn Baldwin 				    td->td_ucred, td)) != 0) {
265b40ce416SJulian Elischer 					VOP_UNLOCK(devvp, 0, td);
266c9b99213SBruce Evans 					return (error);
267c9b99213SBruce Evans 				}
268b40ce416SJulian Elischer 				VOP_UNLOCK(devvp, 0, td);
269c9b99213SBruce Evans 			}
2707e58bfacSBruce Evans 			fs->fs_flags &= ~FS_UNCLEAN;
2710922cce6SBruce Evans 			if (fs->fs_clean == 0) {
2727e58bfacSBruce Evans 				fs->fs_flags |= FS_UNCLEAN;
273812b1d41SKirk McKusick 				if ((mp->mnt_flag & MNT_FORCE) ||
2741a6a6610SKirk McKusick 				    ((fs->fs_flags & FS_NEEDSFSCK) == 0 &&
2751a6a6610SKirk McKusick 				     (fs->fs_flags & FS_DOSOFTDEP))) {
276f2a2857bSKirk McKusick 					printf("WARNING: %s was not %s\n",
277f2a2857bSKirk McKusick 					   fs->fs_fsmnt, "properly dismounted");
2780922cce6SBruce Evans 				} else {
2790922cce6SBruce Evans 					printf(
2800922cce6SBruce Evans "WARNING: R/W mount of %s denied.  Filesystem is not clean - run fsck\n",
2810922cce6SBruce Evans 					    fs->fs_fsmnt);
282f2a2857bSKirk McKusick 					return (EPERM);
2830922cce6SBruce Evans 				}
2840922cce6SBruce Evans 			}
28540c340aaSPoul-Henning Kamp 			DROP_GIANT();
28640c340aaSPoul-Henning Kamp 			g_topology_lock();
28740c340aaSPoul-Henning Kamp 			/*
28840c340aaSPoul-Henning Kamp 			 * If we're the root device, we may not have an E count
28940c340aaSPoul-Henning Kamp 			 * yet, get it now.
29040c340aaSPoul-Henning Kamp 			 */
29140c340aaSPoul-Henning Kamp 			if (ump->um_cp->ace == 0)
29240c340aaSPoul-Henning Kamp 				error = g_access(ump->um_cp, 0, 1, 1);
29340c340aaSPoul-Henning Kamp 			else
29440c340aaSPoul-Henning Kamp 				error = g_access(ump->um_cp, 0, 1, 0);
29540c340aaSPoul-Henning Kamp 			g_topology_unlock();
29640c340aaSPoul-Henning Kamp 			PICKUP_GIANT();
29740c340aaSPoul-Henning Kamp 			if (error)
29840c340aaSPoul-Henning Kamp 				return (error);
299f2a2857bSKirk McKusick 			if ((error = vn_start_write(NULL, &mp, V_WAIT)) != 0)
300f2a2857bSKirk McKusick 				return (error);
301f2a2857bSKirk McKusick 			fs->fs_ronly = 0;
30220a92a18SPoul-Henning Kamp 			mp->mnt_flag &= ~MNT_RDONLY;
303f2a2857bSKirk McKusick 			fs->fs_clean = 0;
304f2a2857bSKirk McKusick 			if ((error = ffs_sbupdate(ump, MNT_WAIT)) != 0) {
305f2a2857bSKirk McKusick 				vn_finished_write(mp);
306f2a2857bSKirk McKusick 				return (error);
307f2a2857bSKirk McKusick 			}
30826cf9c3bSPeter Wemm 			/* check to see if we need to start softdep */
309f2a2857bSKirk McKusick 			if ((fs->fs_flags & FS_DOSOFTDEP) &&
310a854ed98SJohn Baldwin 			    (error = softdep_mount(devvp, mp, fs, td->td_ucred))){
311f2a2857bSKirk McKusick 				vn_finished_write(mp);
312f2a2857bSKirk McKusick 				return (error);
31326cf9c3bSPeter Wemm 			}
314f2a2857bSKirk McKusick 			if (fs->fs_snapinum[0] != 0)
315f2a2857bSKirk McKusick 				ffs_snapshot_mount(mp);
316f2a2857bSKirk McKusick 			vn_finished_write(mp);
3171469eec8SDavid Greenman 		}
318c11d2981SJulian Elischer 		/*
319c11d2981SJulian Elischer 		 * Soft updates is incompatible with "async",
320c11d2981SJulian Elischer 		 * so if we are doing softupdates stop the user
321c11d2981SJulian Elischer 		 * from setting the async flag in an update.
322c11d2981SJulian Elischer 		 * Softdep_mount() clears it in an initial mount
323c11d2981SJulian Elischer 		 * or ro->rw remount.
324c11d2981SJulian Elischer 		 */
325f2a2857bSKirk McKusick 		if (mp->mnt_flag & MNT_SOFTDEP)
326c11d2981SJulian Elischer 			mp->mnt_flag &= ~MNT_ASYNC;
327df8bae1dSRodney W. Grimes 		/*
32839cfb239SPawel Jakub Dawidek 		 * Keep MNT_ACLS flag if it is stored in superblock.
32939cfb239SPawel Jakub Dawidek 		 */
33039cfb239SPawel Jakub Dawidek 		if ((fs->fs_flags & FS_ACLS) != 0)
33139cfb239SPawel Jakub Dawidek 			mp->mnt_flag |= MNT_ACLS;
33239cfb239SPawel Jakub Dawidek 		/*
333f2a2857bSKirk McKusick 		 * If not updating name, process export requests.
334df8bae1dSRodney W. Grimes 		 */
335cea90362SCraig Rodrigues 		error = 0;
336cea90362SCraig Rodrigues 		if (vfs_getopt(mp->mnt_optnew, "export", NULL, NULL) == 0) {
337cea90362SCraig Rodrigues 			error = vfs_copyopt(mp->mnt_optnew, "export",
338cea90362SCraig Rodrigues 			    &export, sizeof export);
339cea90362SCraig Rodrigues 		}
340cea90362SCraig Rodrigues 
341f21cc2caSPoul-Henning Kamp 		if (error == 0 && export.ex_flags != 0)
342f21cc2caSPoul-Henning Kamp 			return (vfs_export(mp, &export));
343f2a2857bSKirk McKusick 		/*
344f2a2857bSKirk McKusick 		 * If this is a snapshot request, take the snapshot.
345f2a2857bSKirk McKusick 		 */
346f2a2857bSKirk McKusick 		if (mp->mnt_flag & MNT_SNAPSHOT)
34720a92a18SPoul-Henning Kamp 			return (ffs_snapshot(mp, fspec));
348df8bae1dSRodney W. Grimes 	}
3492b14f991SJulian Elischer 
350df8bae1dSRodney W. Grimes 	/*
351df8bae1dSRodney W. Grimes 	 * Not an update, or updating the name: look up the name
352e9827c6dSBruce Evans 	 * and verify that it refers to a sensible disk device.
353df8bae1dSRodney W. Grimes 	 */
354fdedad76SSuleiman Souhlal 	NDINIT(&ndp, LOOKUP, FOLLOW | LOCKLEAF, UIO_SYSSPACE, fspec, td);
3555e8c582aSPoul-Henning Kamp 	if ((error = namei(&ndp)) != 0)
356f2a2857bSKirk McKusick 		return (error);
3575e8c582aSPoul-Henning Kamp 	NDFREE(&ndp, NDF_ONLY_PNBUF);
3585e8c582aSPoul-Henning Kamp 	devvp = ndp.ni_vp;
359f2a2857bSKirk McKusick 	if (!vn_isdisk(devvp, &error)) {
360fdedad76SSuleiman Souhlal 		vput(devvp);
361f2a2857bSKirk McKusick 		return (error);
362f2a2857bSKirk McKusick 	}
363c9b99213SBruce Evans 
364c9b99213SBruce Evans 	/*
365c9b99213SBruce Evans 	 * If mount by non-root, then verify that user has necessary
366c9b99213SBruce Evans 	 * permissions on the device.
367c9b99213SBruce Evans 	 */
36844731cabSJohn Baldwin 	if (suser(td)) {
369c9b99213SBruce Evans 		accessmode = VREAD;
370c9b99213SBruce Evans 		if ((mp->mnt_flag & MNT_RDONLY) == 0)
371c9b99213SBruce Evans 			accessmode |= VWRITE;
372a854ed98SJohn Baldwin 		if ((error = VOP_ACCESS(devvp, accessmode, td->td_ucred, td))!= 0){
373c9b99213SBruce Evans 			vput(devvp);
374c9b99213SBruce Evans 			return (error);
375c9b99213SBruce Evans 		}
376c9b99213SBruce Evans 	}
377c9b99213SBruce Evans 
3782b14f991SJulian Elischer 	if (mp->mnt_flag & MNT_UPDATE) {
3792b14f991SJulian Elischer 		/*
380f2a2857bSKirk McKusick 		 * Update only
381f2a2857bSKirk McKusick 		 *
3823e425b96SJulian Elischer 		 * If it's not the same vnode, or at least the same device
3833e425b96SJulian Elischer 		 * then it's not correct.
3842b14f991SJulian Elischer 		 */
3852b14f991SJulian Elischer 
38643920011SPoul-Henning Kamp 		if (devvp->v_rdev != ump->um_devvp->v_rdev)
387f2a2857bSKirk McKusick 			error = EINVAL;	/* needs translation */
388fdedad76SSuleiman Souhlal 		vput(devvp);
389f2a2857bSKirk McKusick 		if (error)
390f2a2857bSKirk McKusick 			return (error);
3912b14f991SJulian Elischer 	} else {
3922b14f991SJulian Elischer 		/*
393f2a2857bSKirk McKusick 		 * New mount
3942b14f991SJulian Elischer 		 *
395f2a2857bSKirk McKusick 		 * We need the name for the mount point (also used for
396f2a2857bSKirk McKusick 		 * "last mounted on") copied in. If an error occurs,
397f2a2857bSKirk McKusick 		 * the mount point is discarded by the upper level code.
398f3a90da9SAdrian Chadd 		 * Note that vfs_mount() populates f_mntonname for us.
399f2a2857bSKirk McKusick 		 */
400975512a9SPoul-Henning Kamp 		if ((error = ffs_mountfs(devvp, mp, td)) != 0) {
401f2a2857bSKirk McKusick 			vrele(devvp);
402f2a2857bSKirk McKusick 			return (error);
403f2a2857bSKirk McKusick 		}
404f2a2857bSKirk McKusick 	}
40520a92a18SPoul-Henning Kamp 	vfs_mountedfrom(mp, fspec);
406f2a2857bSKirk McKusick 	return (0);
4072b14f991SJulian Elischer }
4082b14f991SJulian Elischer 
409df8bae1dSRodney W. Grimes /*
41020a92a18SPoul-Henning Kamp  * Compatibility with old mount system call.
41120a92a18SPoul-Henning Kamp  */
41220a92a18SPoul-Henning Kamp 
41320a92a18SPoul-Henning Kamp static int
41420a92a18SPoul-Henning Kamp ffs_cmount(struct mntarg *ma, void *data, int flags, struct thread *td)
41520a92a18SPoul-Henning Kamp {
41620a92a18SPoul-Henning Kamp 	struct ufs_args args;
41720a92a18SPoul-Henning Kamp 	int error;
41820a92a18SPoul-Henning Kamp 
41920a92a18SPoul-Henning Kamp 	if (data == NULL)
42020a92a18SPoul-Henning Kamp 		return (EINVAL);
42120a92a18SPoul-Henning Kamp 	error = copyin(data, &args, sizeof args);
42220a92a18SPoul-Henning Kamp 	if (error)
42320a92a18SPoul-Henning Kamp 		return (error);
42420a92a18SPoul-Henning Kamp 
42520a92a18SPoul-Henning Kamp 	ma = mount_argsu(ma, "from", args.fspec, MAXPATHLEN);
42620a92a18SPoul-Henning Kamp 	ma = mount_arg(ma, "export", &args.export, sizeof args.export);
42720a92a18SPoul-Henning Kamp 	error = kernel_mount(ma, flags);
42820a92a18SPoul-Henning Kamp 
42920a92a18SPoul-Henning Kamp 	return (error);
43020a92a18SPoul-Henning Kamp }
43120a92a18SPoul-Henning Kamp 
43220a92a18SPoul-Henning Kamp /*
433df8bae1dSRodney W. Grimes  * Reload all incore data for a filesystem (used after running fsck on
434df8bae1dSRodney W. Grimes  * the root filesystem and finding things to fix). The filesystem must
435df8bae1dSRodney W. Grimes  * be mounted read-only.
436df8bae1dSRodney W. Grimes  *
437df8bae1dSRodney W. Grimes  * Things to do to update the mount:
438df8bae1dSRodney W. Grimes  *	1) invalidate all cached meta-data.
439df8bae1dSRodney W. Grimes  *	2) re-read superblock from disk.
440df8bae1dSRodney W. Grimes  *	3) re-read summary information from disk.
441df8bae1dSRodney W. Grimes  *	4) invalidate all inactive vnodes.
442df8bae1dSRodney W. Grimes  *	5) invalidate all cached file data.
443df8bae1dSRodney W. Grimes  *	6) re-read inode data for all active vnodes.
444df8bae1dSRodney W. Grimes  */
4455e8c582aSPoul-Henning Kamp static int
4465e8c582aSPoul-Henning Kamp ffs_reload(struct mount *mp, struct thread *td)
447df8bae1dSRodney W. Grimes {
44805f4ff5dSPoul-Henning Kamp 	struct vnode *vp, *nvp, *devvp;
449df8bae1dSRodney W. Grimes 	struct inode *ip;
450f55ff3f3SIan Dowse 	void *space;
451df8bae1dSRodney W. Grimes 	struct buf *bp;
452996c772fSJohn Dyson 	struct fs *fs, *newfs;
4533ba649d7SJeff Roberson 	struct ufsmount *ump;
4541c85e6a3SKirk McKusick 	ufs2_daddr_t sblockloc;
455df8bae1dSRodney W. Grimes 	int i, blks, size, error;
456996c772fSJohn Dyson 	int32_t *lp;
457df8bae1dSRodney W. Grimes 
4582b14f991SJulian Elischer 	if ((mp->mnt_flag & MNT_RDONLY) == 0)
459df8bae1dSRodney W. Grimes 		return (EINVAL);
4603ba649d7SJeff Roberson 	ump = VFSTOUFS(mp);
461df8bae1dSRodney W. Grimes 	/*
462df8bae1dSRodney W. Grimes 	 * Step 1: invalidate all cached meta-data.
463df8bae1dSRodney W. Grimes 	 */
4642b14f991SJulian Elischer 	devvp = VFSTOUFS(mp)->um_devvp;
465b40ce416SJulian Elischer 	vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td);
4667c0745eeSPoul-Henning Kamp 	if (vinvalbuf(devvp, 0, td, 0, 0) != 0)
467df8bae1dSRodney W. Grimes 		panic("ffs_reload: dirty1");
46804a17687SJeff Roberson 	VOP_UNLOCK(devvp, 0, td);
46995e5e988SJohn Dyson 
470df8bae1dSRodney W. Grimes 	/*
471df8bae1dSRodney W. Grimes 	 * Step 2: re-read superblock from disk.
472df8bae1dSRodney W. Grimes 	 */
4731c85e6a3SKirk McKusick 	fs = VFSTOUFS(mp)->um_fs;
474ada981b2SKirk McKusick 	if ((error = bread(devvp, btodb(fs->fs_sblockloc), fs->fs_sbsize,
4751c85e6a3SKirk McKusick 	    NOCRED, &bp)) != 0)
476df8bae1dSRodney W. Grimes 		return (error);
477996c772fSJohn Dyson 	newfs = (struct fs *)bp->b_data;
4781c85e6a3SKirk McKusick 	if ((newfs->fs_magic != FS_UFS1_MAGIC &&
4791c85e6a3SKirk McKusick 	     newfs->fs_magic != FS_UFS2_MAGIC) ||
4801c85e6a3SKirk McKusick 	    newfs->fs_bsize > MAXBSIZE ||
481996c772fSJohn Dyson 	    newfs->fs_bsize < sizeof(struct fs)) {
482df8bae1dSRodney W. Grimes 			brelse(bp);
483df8bae1dSRodney W. Grimes 			return (EIO);		/* XXX needs translation */
484df8bae1dSRodney W. Grimes 	}
485996c772fSJohn Dyson 	/*
486996c772fSJohn Dyson 	 * Copy pointer fields back into superblock before copying in	XXX
487996c772fSJohn Dyson 	 * new superblock. These should really be in the ufsmount.	XXX
488996c772fSJohn Dyson 	 * Note that important parameters (eg fs_ncg) are unchanged.
489996c772fSJohn Dyson 	 */
490f55ff3f3SIan Dowse 	newfs->fs_csp = fs->fs_csp;
491996c772fSJohn Dyson 	newfs->fs_maxcluster = fs->fs_maxcluster;
4925d69bac4SIan Dowse 	newfs->fs_contigdirs = fs->fs_contigdirs;
493143a5346SIan Dowse 	newfs->fs_active = fs->fs_active;
49431c81e4bSDon Lewis 	/* The file system is still read-only. */
49531c81e4bSDon Lewis 	newfs->fs_ronly = 1;
4961c85e6a3SKirk McKusick 	sblockloc = fs->fs_sblockloc;
497996c772fSJohn Dyson 	bcopy(newfs, fs, (u_int)fs->fs_sbsize);
498df8bae1dSRodney W. Grimes 	brelse(bp);
499996c772fSJohn Dyson 	mp->mnt_maxsymlinklen = fs->fs_maxsymlinklen;
5001c85e6a3SKirk McKusick 	ffs_oldfscompat_read(fs, VFSTOUFS(mp), sblockloc);
5013ba649d7SJeff Roberson 	UFS_LOCK(ump);
5029ccb939eSKirk McKusick 	if (fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) {
503cfbf0a46SMaxime Henrion 		printf("%s: reload pending error: blocks %jd files %d\n",
5041c85e6a3SKirk McKusick 		    fs->fs_fsmnt, (intmax_t)fs->fs_pendingblocks,
5051c85e6a3SKirk McKusick 		    fs->fs_pendinginodes);
5069ccb939eSKirk McKusick 		fs->fs_pendingblocks = 0;
5079ccb939eSKirk McKusick 		fs->fs_pendinginodes = 0;
5089ccb939eSKirk McKusick 	}
5093ba649d7SJeff Roberson 	UFS_UNLOCK(ump);
510996c772fSJohn Dyson 
511df8bae1dSRodney W. Grimes 	/*
512df8bae1dSRodney W. Grimes 	 * Step 3: re-read summary information from disk.
513df8bae1dSRodney W. Grimes 	 */
514df8bae1dSRodney W. Grimes 	blks = howmany(fs->fs_cssize, fs->fs_fsize);
515f55ff3f3SIan Dowse 	space = fs->fs_csp;
516df8bae1dSRodney W. Grimes 	for (i = 0; i < blks; i += fs->fs_frag) {
517df8bae1dSRodney W. Grimes 		size = fs->fs_bsize;
518df8bae1dSRodney W. Grimes 		if (i + fs->fs_frag > blks)
519df8bae1dSRodney W. Grimes 			size = (blks - i) * fs->fs_fsize;
520c9671602SPoul-Henning Kamp 		error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + i), size,
521c9671602SPoul-Henning Kamp 		    NOCRED, &bp);
522c9671602SPoul-Henning Kamp 		if (error)
523df8bae1dSRodney W. Grimes 			return (error);
524f55ff3f3SIan Dowse 		bcopy(bp->b_data, space, (u_int)size);
525f55ff3f3SIan Dowse 		space = (char *)space + size;
526df8bae1dSRodney W. Grimes 		brelse(bp);
527df8bae1dSRodney W. Grimes 	}
528996c772fSJohn Dyson 	/*
529996c772fSJohn Dyson 	 * We no longer know anything about clusters per cylinder group.
530996c772fSJohn Dyson 	 */
531996c772fSJohn Dyson 	if (fs->fs_contigsumsize > 0) {
532996c772fSJohn Dyson 		lp = fs->fs_maxcluster;
533996c772fSJohn Dyson 		for (i = 0; i < fs->fs_ncg; i++)
534996c772fSJohn Dyson 			*lp++ = fs->fs_contigsumsize;
535996c772fSJohn Dyson 	}
536996c772fSJohn Dyson 
537df8bae1dSRodney W. Grimes loop:
538ca430f2eSAlexander Kabaev 	MNT_ILOCK(mp);
539e3c5a7a4SPoul-Henning Kamp 	MNT_VNODE_FOREACH(vp, mp, nvp) {
54004a17687SJeff Roberson 		VI_LOCK(vp);
541fe68abe2SJeff Roberson 		if (vp->v_iflag & VI_DOOMED) {
5422f05568aSJeff Roberson 			VI_UNLOCK(vp);
5432f05568aSJeff Roberson 			continue;
5442f05568aSJeff Roberson 		}
545ca430f2eSAlexander Kabaev 		MNT_IUNLOCK(mp);
546df8bae1dSRodney W. Grimes 		/*
547fe68abe2SJeff Roberson 		 * Step 4: invalidate all cached file data.
548df8bae1dSRodney W. Grimes 		 */
549b40ce416SJulian Elischer 		if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, td)) {
550df8bae1dSRodney W. Grimes 			goto loop;
551996c772fSJohn Dyson 		}
5527c0745eeSPoul-Henning Kamp 		if (vinvalbuf(vp, 0, td, 0, 0))
553df8bae1dSRodney W. Grimes 			panic("ffs_reload: dirty2");
554df8bae1dSRodney W. Grimes 		/*
555fe68abe2SJeff Roberson 		 * Step 5: re-read inode data for all active vnodes.
556df8bae1dSRodney W. Grimes 		 */
557df8bae1dSRodney W. Grimes 		ip = VTOI(vp);
558c9671602SPoul-Henning Kamp 		error =
559df8bae1dSRodney W. Grimes 		    bread(devvp, fsbtodb(fs, ino_to_fsba(fs, ip->i_number)),
560c9671602SPoul-Henning Kamp 		    (int)fs->fs_bsize, NOCRED, &bp);
561c9671602SPoul-Henning Kamp 		if (error) {
56245d45c6cSAlexander Kabaev 			VOP_UNLOCK(vp, 0, td);
56345d45c6cSAlexander Kabaev 			vrele(vp);
564df8bae1dSRodney W. Grimes 			return (error);
565df8bae1dSRodney W. Grimes 		}
566de6ba7c0SPoul-Henning Kamp 		ffs_load_inode(bp, ip, fs, ip->i_number);
567b1897c19SJulian Elischer 		ip->i_effnlink = ip->i_nlink;
568df8bae1dSRodney W. Grimes 		brelse(bp);
569cb9ddc80SAlexander Kabaev 		VOP_UNLOCK(vp, 0, td);
570cb9ddc80SAlexander Kabaev 		vrele(vp);
571ca430f2eSAlexander Kabaev 		MNT_ILOCK(mp);
572df8bae1dSRodney W. Grimes 	}
573ca430f2eSAlexander Kabaev 	MNT_IUNLOCK(mp);
574df8bae1dSRodney W. Grimes 	return (0);
575df8bae1dSRodney W. Grimes }
576df8bae1dSRodney W. Grimes 
5771c85e6a3SKirk McKusick /*
5781c85e6a3SKirk McKusick  * Possible superblock locations ordered from most to least likely.
5791c85e6a3SKirk McKusick  */
5801c85e6a3SKirk McKusick static int sblock_try[] = SBLOCKSEARCH;
5815819ab3fSKirk McKusick 
582df8bae1dSRodney W. Grimes /*
583df8bae1dSRodney W. Grimes  * Common code for mount and mountroot
584df8bae1dSRodney W. Grimes  */
585975512a9SPoul-Henning Kamp static int
586975512a9SPoul-Henning Kamp ffs_mountfs(devvp, mp, td)
58705f4ff5dSPoul-Henning Kamp 	struct vnode *devvp;
588df8bae1dSRodney W. Grimes 	struct mount *mp;
589b40ce416SJulian Elischer 	struct thread *td;
590df8bae1dSRodney W. Grimes {
59105f4ff5dSPoul-Henning Kamp 	struct ufsmount *ump;
592df8bae1dSRodney W. Grimes 	struct buf *bp;
59305f4ff5dSPoul-Henning Kamp 	struct fs *fs;
59489c9c53dSPoul-Henning Kamp 	struct cdev *dev;
595f55ff3f3SIan Dowse 	void *space;
5961c85e6a3SKirk McKusick 	ufs2_daddr_t sblockloc;
597f5ef029eSPoul-Henning Kamp 	int error, i, blks, size, ronly;
598996c772fSJohn Dyson 	int32_t *lp;
599996c772fSJohn Dyson 	struct ucred *cred;
60043920011SPoul-Henning Kamp 	struct g_consumer *cp;
601df8bae1dSRodney W. Grimes 
602996c772fSJohn Dyson 	dev = devvp->v_rdev;
603a854ed98SJohn Baldwin 	cred = td ? td->td_ucred : NOCRED;
60443920011SPoul-Henning Kamp 
60543920011SPoul-Henning Kamp 	ronly = (mp->mnt_flag & MNT_RDONLY) != 0;
60643920011SPoul-Henning Kamp 	DROP_GIANT();
60743920011SPoul-Henning Kamp 	g_topology_lock();
60843920011SPoul-Henning Kamp 	error = g_vfs_open(devvp, &cp, "ffs", ronly ? 0 : 1);
60943920011SPoul-Henning Kamp 
61043920011SPoul-Henning Kamp 	/*
61143920011SPoul-Henning Kamp 	 * If we are a root mount, drop the E flag so fsck can do its magic.
61293e0b506SPoul-Henning Kamp 	 * We will pick it up again when we remount R/W.
61343920011SPoul-Henning Kamp 	 */
61443920011SPoul-Henning Kamp 	if (error == 0 && ronly && (mp->mnt_flag & MNT_ROOTFS))
61543920011SPoul-Henning Kamp 		error = g_access(cp, 0, 0, -1);
61643920011SPoul-Henning Kamp 	g_topology_unlock();
61743920011SPoul-Henning Kamp 	PICKUP_GIANT();
618b40ce416SJulian Elischer 	VOP_UNLOCK(devvp, 0, td);
619c9671602SPoul-Henning Kamp 	if (error)
620df8bae1dSRodney W. Grimes 		return (error);
6210508986cSBruce Evans 	if (devvp->v_rdev->si_iosize_max != 0)
6221b5464efSPoul-Henning Kamp 		mp->mnt_iosize_max = devvp->v_rdev->si_iosize_max;
6231b5464efSPoul-Henning Kamp 	if (mp->mnt_iosize_max > MAXPHYS)
6241b5464efSPoul-Henning Kamp 		mp->mnt_iosize_max = MAXPHYS;
62595e5e988SJohn Dyson 
62643920011SPoul-Henning Kamp 	devvp->v_bufobj.bo_private = cp;
6276e77a041SPoul-Henning Kamp 	devvp->v_bufobj.bo_ops = &ffs_ops;
6286e77a041SPoul-Henning Kamp 
629df8bae1dSRodney W. Grimes 	bp = NULL;
630df8bae1dSRodney W. Grimes 	ump = NULL;
6311c85e6a3SKirk McKusick 	fs = NULL;
6321c85e6a3SKirk McKusick 	sblockloc = 0;
6331c85e6a3SKirk McKusick 	/*
6341c85e6a3SKirk McKusick 	 * Try reading the superblock in each of its possible locations.
6351c85e6a3SKirk McKusick 	 */
6361c85e6a3SKirk McKusick 	for (i = 0; sblock_try[i] != -1; i++) {
637b6cef564SKirk McKusick 		if ((error = bread(devvp, sblock_try[i] / DEV_BSIZE, SBLOCKSIZE,
6381c85e6a3SKirk McKusick 		    cred, &bp)) != 0)
639df8bae1dSRodney W. Grimes 			goto out;
640df8bae1dSRodney W. Grimes 		fs = (struct fs *)bp->b_data;
641ada981b2SKirk McKusick 		sblockloc = sblock_try[i];
6421c85e6a3SKirk McKusick 		if ((fs->fs_magic == FS_UFS1_MAGIC ||
6431c85e6a3SKirk McKusick 		     (fs->fs_magic == FS_UFS2_MAGIC &&
644ada981b2SKirk McKusick 		      (fs->fs_sblockloc == sblockloc ||
645ada981b2SKirk McKusick 		       (fs->fs_old_flags & FS_FLAGS_UPDATED) == 0))) &&
6461c85e6a3SKirk McKusick 		    fs->fs_bsize <= MAXBSIZE &&
6471c85e6a3SKirk McKusick 		    fs->fs_bsize >= sizeof(struct fs))
6481c85e6a3SKirk McKusick 			break;
6491c85e6a3SKirk McKusick 		brelse(bp);
6501c85e6a3SKirk McKusick 		bp = NULL;
6511c85e6a3SKirk McKusick 	}
6521c85e6a3SKirk McKusick 	if (sblock_try[i] == -1) {
653df8bae1dSRodney W. Grimes 		error = EINVAL;		/* XXX needs translation */
654df8bae1dSRodney W. Grimes 		goto out;
655df8bae1dSRodney W. Grimes 	}
6563f6f17eeSJulian Elischer 	fs->fs_fmod = 0;
6571c85e6a3SKirk McKusick 	fs->fs_flags &= ~FS_INDEXDIRS;	/* no support for directory indicies */
6580922cce6SBruce Evans 	fs->fs_flags &= ~FS_UNCLEAN;
6590922cce6SBruce Evans 	if (fs->fs_clean == 0) {
6600922cce6SBruce Evans 		fs->fs_flags |= FS_UNCLEAN;
661812b1d41SKirk McKusick 		if (ronly || (mp->mnt_flag & MNT_FORCE) ||
6621a6a6610SKirk McKusick 		    ((fs->fs_flags & FS_NEEDSFSCK) == 0 &&
6631a6a6610SKirk McKusick 		     (fs->fs_flags & FS_DOSOFTDEP))) {
6640922cce6SBruce Evans 			printf(
6650922cce6SBruce Evans "WARNING: %s was not properly dismounted\n",
6660922cce6SBruce Evans 			    fs->fs_fsmnt);
6671469eec8SDavid Greenman 		} else {
6680922cce6SBruce Evans 			printf(
6690922cce6SBruce Evans "WARNING: R/W mount of %s denied.  Filesystem is not clean - run fsck\n",
6700922cce6SBruce Evans 			    fs->fs_fsmnt);
6711469eec8SDavid Greenman 			error = EPERM;
6721469eec8SDavid Greenman 			goto out;
6731469eec8SDavid Greenman 		}
6741c85e6a3SKirk McKusick 		if ((fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) &&
6751c85e6a3SKirk McKusick 		    (mp->mnt_flag & MNT_FORCE)) {
676cfbf0a46SMaxime Henrion 			printf("%s: lost blocks %jd files %d\n", fs->fs_fsmnt,
6771c85e6a3SKirk McKusick 			    (intmax_t)fs->fs_pendingblocks,
6781c85e6a3SKirk McKusick 			    fs->fs_pendinginodes);
6799ccb939eSKirk McKusick 			fs->fs_pendingblocks = 0;
6809ccb939eSKirk McKusick 			fs->fs_pendinginodes = 0;
6819ccb939eSKirk McKusick 		}
6829ccb939eSKirk McKusick 	}
6839ccb939eSKirk McKusick 	if (fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) {
684cfbf0a46SMaxime Henrion 		printf("%s: mount pending error: blocks %jd files %d\n",
6851c85e6a3SKirk McKusick 		    fs->fs_fsmnt, (intmax_t)fs->fs_pendingblocks,
6861c85e6a3SKirk McKusick 		    fs->fs_pendinginodes);
6879ccb939eSKirk McKusick 		fs->fs_pendingblocks = 0;
6889ccb939eSKirk McKusick 		fs->fs_pendinginodes = 0;
6891469eec8SDavid Greenman 	}
690a163d034SWarner Losh 	ump = malloc(sizeof *ump, M_UFSMNT, M_WAITOK | M_ZERO);
69143920011SPoul-Henning Kamp 	ump->um_cp = cp;
69243920011SPoul-Henning Kamp 	ump->um_bo = &devvp->v_bufobj;
6938dd56505SPoul-Henning Kamp 	ump->um_fs = malloc((u_long)fs->fs_sbsize, M_UFSMNT, M_WAITOK);
6941c85e6a3SKirk McKusick 	if (fs->fs_magic == FS_UFS1_MAGIC) {
6951c85e6a3SKirk McKusick 		ump->um_fstype = UFS1;
6961c85e6a3SKirk McKusick 		ump->um_balloc = ffs_balloc_ufs1;
6971c85e6a3SKirk McKusick 	} else {
6981c85e6a3SKirk McKusick 		ump->um_fstype = UFS2;
6991c85e6a3SKirk McKusick 		ump->um_balloc = ffs_balloc_ufs2;
7001c85e6a3SKirk McKusick 	}
701cec0f20cSPoul-Henning Kamp 	ump->um_blkatoff = ffs_blkatoff;
702cec0f20cSPoul-Henning Kamp 	ump->um_truncate = ffs_truncate;
703987f5696SPoul-Henning Kamp 	ump->um_update = ffs_update;
704cec0f20cSPoul-Henning Kamp 	ump->um_valloc = ffs_valloc;
705cec0f20cSPoul-Henning Kamp 	ump->um_vfree = ffs_vfree;
706975512a9SPoul-Henning Kamp 	ump->um_ifree = ffs_ifree;
7073ba649d7SJeff Roberson 	mtx_init(UFS_MTX(ump), "FFS", "FFS Lock", MTX_DEF);
708df8bae1dSRodney W. Grimes 	bcopy(bp->b_data, ump->um_fs, (u_int)fs->fs_sbsize);
7091c85e6a3SKirk McKusick 	if (fs->fs_sbsize < SBLOCKSIZE)
710f2a2857bSKirk McKusick 		bp->b_flags |= B_INVAL | B_NOCACHE;
711df8bae1dSRodney W. Grimes 	brelse(bp);
712df8bae1dSRodney W. Grimes 	bp = NULL;
713df8bae1dSRodney W. Grimes 	fs = ump->um_fs;
7141c85e6a3SKirk McKusick 	ffs_oldfscompat_read(fs, ump, sblockloc);
715df8bae1dSRodney W. Grimes 	fs->fs_ronly = ronly;
716996c772fSJohn Dyson 	size = fs->fs_cssize;
717996c772fSJohn Dyson 	blks = howmany(size, fs->fs_fsize);
718996c772fSJohn Dyson 	if (fs->fs_contigsumsize > 0)
719996c772fSJohn Dyson 		size += fs->fs_ncg * sizeof(int32_t);
720a61ab64aSKirk McKusick 	size += fs->fs_ncg * sizeof(u_int8_t);
721a163d034SWarner Losh 	space = malloc((u_long)size, M_UFSMNT, M_WAITOK);
722f55ff3f3SIan Dowse 	fs->fs_csp = space;
723df8bae1dSRodney W. Grimes 	for (i = 0; i < blks; i += fs->fs_frag) {
724df8bae1dSRodney W. Grimes 		size = fs->fs_bsize;
725df8bae1dSRodney W. Grimes 		if (i + fs->fs_frag > blks)
726df8bae1dSRodney W. Grimes 			size = (blks - i) * fs->fs_fsize;
7278aef1712SMatthew Dillon 		if ((error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + i), size,
7288aef1712SMatthew Dillon 		    cred, &bp)) != 0) {
729f55ff3f3SIan Dowse 			free(fs->fs_csp, M_UFSMNT);
730df8bae1dSRodney W. Grimes 			goto out;
731df8bae1dSRodney W. Grimes 		}
732df8bae1dSRodney W. Grimes 		bcopy(bp->b_data, space, (u_int)size);
733f55ff3f3SIan Dowse 		space = (char *)space + size;
734df8bae1dSRodney W. Grimes 		brelse(bp);
735df8bae1dSRodney W. Grimes 		bp = NULL;
736df8bae1dSRodney W. Grimes 	}
737996c772fSJohn Dyson 	if (fs->fs_contigsumsize > 0) {
738f55ff3f3SIan Dowse 		fs->fs_maxcluster = lp = space;
739996c772fSJohn Dyson 		for (i = 0; i < fs->fs_ncg; i++)
740996c772fSJohn Dyson 			*lp++ = fs->fs_contigsumsize;
7414691e9eaSIan Dowse 		space = lp;
742996c772fSJohn Dyson 	}
743a61ab64aSKirk McKusick 	size = fs->fs_ncg * sizeof(u_int8_t);
744a61ab64aSKirk McKusick 	fs->fs_contigdirs = (u_int8_t *)space;
745a61ab64aSKirk McKusick 	bzero(fs->fs_contigdirs, size);
746143a5346SIan Dowse 	fs->fs_active = NULL;
747df8bae1dSRodney W. Grimes 	mp->mnt_data = (qaddr_t)ump;
74868de329eSPoul-Henning Kamp 	mp->mnt_stat.f_fsid.val[0] = fs->fs_id[0];
7498f89943eSGuido van Rooij 	mp->mnt_stat.f_fsid.val[1] = fs->fs_id[1];
75068de329eSPoul-Henning Kamp 	if (fs->fs_id[0] == 0 || fs->fs_id[1] == 0 ||
75168de329eSPoul-Henning Kamp 	    vfs_getvfs(&mp->mnt_stat.f_fsid))
75268de329eSPoul-Henning Kamp 		vfs_getnewfsid(mp);
753df8bae1dSRodney W. Grimes 	mp->mnt_maxsymlinklen = fs->fs_maxsymlinklen;
754cc9d8990SPeter Wemm 	mp->mnt_flag |= MNT_LOCAL;
75580830407SRobert Watson 	if ((fs->fs_flags & FS_MULTILABEL) != 0)
75680830407SRobert Watson #ifdef MAC
75780830407SRobert Watson 		mp->mnt_flag |= MNT_MULTILABEL;
75880830407SRobert Watson #else
75980830407SRobert Watson 		printf(
76080830407SRobert Watson "WARNING: %s: multilabel flag on fs but no MAC support\n",
76180830407SRobert Watson 		    fs->fs_fsmnt);
76280830407SRobert Watson #endif
76380830407SRobert Watson 	if ((fs->fs_flags & FS_ACLS) != 0)
76480830407SRobert Watson #ifdef UFS_ACL
76580830407SRobert Watson 		mp->mnt_flag |= MNT_ACLS;
76680830407SRobert Watson #else
76780830407SRobert Watson 		printf(
76880830407SRobert Watson "WARNING: %s: ACLs flag on fs but no ACLs support\n",
76980830407SRobert Watson 		    fs->fs_fsmnt);
77080830407SRobert Watson #endif
771df8bae1dSRodney W. Grimes 	ump->um_mountp = mp;
772df8bae1dSRodney W. Grimes 	ump->um_dev = dev;
773df8bae1dSRodney W. Grimes 	ump->um_devvp = devvp;
774df8bae1dSRodney W. Grimes 	ump->um_nindir = fs->fs_nindir;
775df8bae1dSRodney W. Grimes 	ump->um_bptrtodb = fs->fs_fsbtodb;
776df8bae1dSRodney W. Grimes 	ump->um_seqinc = fs->fs_frag;
777df8bae1dSRodney W. Grimes 	for (i = 0; i < MAXQUOTAS; i++)
778df8bae1dSRodney W. Grimes 		ump->um_quotas[i] = NULLVP;
779516081f2SRobert Watson #ifdef UFS_EXTATTR
780a64ed089SRobert Watson 	ufs_extattr_uepm_init(&ump->um_extattr);
781a64ed089SRobert Watson #endif
7822b14f991SJulian Elischer 	/*
7832b14f991SJulian Elischer 	 * Set FS local "last mounted on" information (NULL pad)
7842b14f991SJulian Elischer 	 */
78593373c42SSuleiman Souhlal 	bzero(fs->fs_fsmnt, MAXMNTLEN);
78693373c42SSuleiman Souhlal 	strlcpy(fs->fs_fsmnt, mp->mnt_stat.f_mntonname, MAXMNTLEN);
7872b14f991SJulian Elischer 
7882b14f991SJulian Elischer 	if( mp->mnt_flag & MNT_ROOTFS) {
7892b14f991SJulian Elischer 		/*
7902b14f991SJulian Elischer 		 * Root mount; update timestamp in mount structure.
7912b14f991SJulian Elischer 		 * this will be used by the common root mount code
7922b14f991SJulian Elischer 		 * to update the system clock.
7932b14f991SJulian Elischer 		 */
7942b14f991SJulian Elischer 		mp->mnt_time = fs->fs_time;
7952b14f991SJulian Elischer 	}
796996c772fSJohn Dyson 
797996c772fSJohn Dyson 	if (ronly == 0) {
798b1897c19SJulian Elischer 		if ((fs->fs_flags & FS_DOSOFTDEP) &&
799b1897c19SJulian Elischer 		    (error = softdep_mount(devvp, mp, fs, cred)) != 0) {
800f55ff3f3SIan Dowse 			free(fs->fs_csp, M_UFSMNT);
801b1897c19SJulian Elischer 			goto out;
802b1897c19SJulian Elischer 		}
803f2a2857bSKirk McKusick 		if (fs->fs_snapinum[0] != 0)
804f2a2857bSKirk McKusick 			ffs_snapshot_mount(mp);
805cf60e8e4SKirk McKusick 		fs->fs_fmod = 1;
806996c772fSJohn Dyson 		fs->fs_clean = 0;
807996c772fSJohn Dyson 		(void) ffs_sbupdate(ump, MNT_WAIT);
808996c772fSJohn Dyson 	}
809d8d3d415SPoul-Henning Kamp 	/*
810d8d3d415SPoul-Henning Kamp 	 * Initialize filesystem stat information in mount struct.
811d8d3d415SPoul-Henning Kamp 	 */
812516081f2SRobert Watson #ifdef UFS_EXTATTR
813516081f2SRobert Watson #ifdef UFS_EXTATTR_AUTOSTART
8149de54ba5SRobert Watson 	/*
8159de54ba5SRobert Watson 	 *
816f5161237SRobert Watson 	 * Auto-starting does the following:
8179de54ba5SRobert Watson 	 *	- check for /.attribute in the fs, and extattr_start if so
8189de54ba5SRobert Watson 	 *	- for each file in .attribute, enable that file with
8199de54ba5SRobert Watson 	 * 	  an attribute of the same name.
8209de54ba5SRobert Watson 	 * Not clear how to report errors -- probably eat them.
8219de54ba5SRobert Watson 	 * This would all happen while the filesystem was busy/not
8229de54ba5SRobert Watson 	 * available, so would effectively be "atomic".
8239de54ba5SRobert Watson 	 */
824b40ce416SJulian Elischer 	(void) ufs_extattr_autostart(mp, td);
825516081f2SRobert Watson #endif /* !UFS_EXTATTR_AUTOSTART */
826516081f2SRobert Watson #endif /* !UFS_EXTATTR */
8273ba649d7SJeff Roberson #ifndef QUOTA
8283ba649d7SJeff Roberson 	mp->mnt_kern_flag |= MNTK_MPSAFE;
8293ba649d7SJeff Roberson #endif
830df8bae1dSRodney W. Grimes 	return (0);
831df8bae1dSRodney W. Grimes out:
832df8bae1dSRodney W. Grimes 	if (bp)
833df8bae1dSRodney W. Grimes 		brelse(bp);
83443920011SPoul-Henning Kamp 	if (cp != NULL) {
83543920011SPoul-Henning Kamp 		DROP_GIANT();
83643920011SPoul-Henning Kamp 		g_topology_lock();
83784a69752SPoul-Henning Kamp 		g_vfs_close(cp, td);
83843920011SPoul-Henning Kamp 		g_topology_unlock();
83943920011SPoul-Henning Kamp 		PICKUP_GIANT();
84043920011SPoul-Henning Kamp 	}
841df8bae1dSRodney W. Grimes 	if (ump) {
8423ba649d7SJeff Roberson 		mtx_destroy(UFS_MTX(ump));
843df8bae1dSRodney W. Grimes 		free(ump->um_fs, M_UFSMNT);
844df8bae1dSRodney W. Grimes 		free(ump, M_UFSMNT);
845df8bae1dSRodney W. Grimes 		mp->mnt_data = (qaddr_t)0;
846df8bae1dSRodney W. Grimes 	}
847df8bae1dSRodney W. Grimes 	return (error);
848df8bae1dSRodney W. Grimes }
849df8bae1dSRodney W. Grimes 
8501c85e6a3SKirk McKusick #include <sys/sysctl.h>
851adf41577SPoul-Henning Kamp static int bigcgs = 0;
8521c85e6a3SKirk McKusick SYSCTL_INT(_debug, OID_AUTO, bigcgs, CTLFLAG_RW, &bigcgs, 0, "");
8531c85e6a3SKirk McKusick 
854df8bae1dSRodney W. Grimes /*
8551c85e6a3SKirk McKusick  * Sanity checks for loading old filesystem superblocks.
8561c85e6a3SKirk McKusick  * See ffs_oldfscompat_write below for unwound actions.
857df8bae1dSRodney W. Grimes  *
8581c85e6a3SKirk McKusick  * XXX - Parts get retired eventually.
8591c85e6a3SKirk McKusick  * Unfortunately new bits get added.
860df8bae1dSRodney W. Grimes  */
8611c85e6a3SKirk McKusick static void
8621c85e6a3SKirk McKusick ffs_oldfscompat_read(fs, ump, sblockloc)
863df8bae1dSRodney W. Grimes 	struct fs *fs;
8641c85e6a3SKirk McKusick 	struct ufsmount *ump;
8651c85e6a3SKirk McKusick 	ufs2_daddr_t sblockloc;
8661c85e6a3SKirk McKusick {
8671c85e6a3SKirk McKusick 	off_t maxfilesize;
8681c85e6a3SKirk McKusick 
8691c85e6a3SKirk McKusick 	/*
870ada981b2SKirk McKusick 	 * If not yet done, update fs_flags location and value of fs_sblockloc.
871ada981b2SKirk McKusick 	 */
872ada981b2SKirk McKusick 	if ((fs->fs_old_flags & FS_FLAGS_UPDATED) == 0) {
873ada981b2SKirk McKusick 		fs->fs_flags = fs->fs_old_flags;
874ada981b2SKirk McKusick 		fs->fs_old_flags |= FS_FLAGS_UPDATED;
875ada981b2SKirk McKusick 		fs->fs_sblockloc = sblockloc;
876ada981b2SKirk McKusick 	}
877ada981b2SKirk McKusick 	/*
8781c85e6a3SKirk McKusick 	 * If not yet done, update UFS1 superblock with new wider fields.
8791c85e6a3SKirk McKusick 	 */
88074f3809aSKirk McKusick 	if (fs->fs_magic == FS_UFS1_MAGIC && fs->fs_maxbsize != fs->fs_bsize) {
8811c85e6a3SKirk McKusick 		fs->fs_maxbsize = fs->fs_bsize;
8821c85e6a3SKirk McKusick 		fs->fs_time = fs->fs_old_time;
8831c85e6a3SKirk McKusick 		fs->fs_size = fs->fs_old_size;
8841c85e6a3SKirk McKusick 		fs->fs_dsize = fs->fs_old_dsize;
8851c85e6a3SKirk McKusick 		fs->fs_csaddr = fs->fs_old_csaddr;
8861c85e6a3SKirk McKusick 		fs->fs_cstotal.cs_ndir = fs->fs_old_cstotal.cs_ndir;
8871c85e6a3SKirk McKusick 		fs->fs_cstotal.cs_nbfree = fs->fs_old_cstotal.cs_nbfree;
8881c85e6a3SKirk McKusick 		fs->fs_cstotal.cs_nifree = fs->fs_old_cstotal.cs_nifree;
8891c85e6a3SKirk McKusick 		fs->fs_cstotal.cs_nffree = fs->fs_old_cstotal.cs_nffree;
8901c85e6a3SKirk McKusick 	}
8911c85e6a3SKirk McKusick 	if (fs->fs_magic == FS_UFS1_MAGIC &&
8921c85e6a3SKirk McKusick 	    fs->fs_old_inodefmt < FS_44INODEFMT) {
8938680d698SNate Lawson 		fs->fs_maxfilesize = ((uint64_t)1 << 31) - 1;
8941c85e6a3SKirk McKusick 		fs->fs_qbmask = ~fs->fs_bmask;
8951c85e6a3SKirk McKusick 		fs->fs_qfmask = ~fs->fs_fmask;
8961c85e6a3SKirk McKusick 	}
8978f42fb8fSIan Dowse 	if (fs->fs_magic == FS_UFS1_MAGIC) {
8981c85e6a3SKirk McKusick 		ump->um_savedmaxfilesize = fs->fs_maxfilesize;
8998680d698SNate Lawson 		maxfilesize = (uint64_t)0x80000000 * fs->fs_bsize - 1;
9001c85e6a3SKirk McKusick 		if (fs->fs_maxfilesize > maxfilesize)
9011c85e6a3SKirk McKusick 			fs->fs_maxfilesize = maxfilesize;
9028f42fb8fSIan Dowse 	}
9031c85e6a3SKirk McKusick 	/* Compatibility for old filesystems */
9041c85e6a3SKirk McKusick 	if (fs->fs_avgfilesize <= 0)
9051c85e6a3SKirk McKusick 		fs->fs_avgfilesize = AVFILESIZ;
9061c85e6a3SKirk McKusick 	if (fs->fs_avgfpdir <= 0)
9071c85e6a3SKirk McKusick 		fs->fs_avgfpdir = AFPDIR;
9081c85e6a3SKirk McKusick 	if (bigcgs) {
9091c85e6a3SKirk McKusick 		fs->fs_save_cgsize = fs->fs_cgsize;
9101c85e6a3SKirk McKusick 		fs->fs_cgsize = fs->fs_bsize;
9111c85e6a3SKirk McKusick 	}
9121c85e6a3SKirk McKusick }
9131c85e6a3SKirk McKusick 
9141c85e6a3SKirk McKusick /*
9151c85e6a3SKirk McKusick  * Unwinding superblock updates for old filesystems.
9161c85e6a3SKirk McKusick  * See ffs_oldfscompat_read above for details.
9171c85e6a3SKirk McKusick  *
9181c85e6a3SKirk McKusick  * XXX - Parts get retired eventually.
9191c85e6a3SKirk McKusick  * Unfortunately new bits get added.
9201c85e6a3SKirk McKusick  */
9211c85e6a3SKirk McKusick static void
9221c85e6a3SKirk McKusick ffs_oldfscompat_write(fs, ump)
9231c85e6a3SKirk McKusick 	struct fs *fs;
9241c85e6a3SKirk McKusick 	struct ufsmount *ump;
925df8bae1dSRodney W. Grimes {
926df8bae1dSRodney W. Grimes 
9271c85e6a3SKirk McKusick 	/*
9281c85e6a3SKirk McKusick 	 * Copy back UFS2 updated fields that UFS1 inspects.
9291c85e6a3SKirk McKusick 	 */
9301c85e6a3SKirk McKusick 	if (fs->fs_magic == FS_UFS1_MAGIC) {
9311c85e6a3SKirk McKusick 		fs->fs_old_time = fs->fs_time;
9321c85e6a3SKirk McKusick 		fs->fs_old_cstotal.cs_ndir = fs->fs_cstotal.cs_ndir;
9331c85e6a3SKirk McKusick 		fs->fs_old_cstotal.cs_nbfree = fs->fs_cstotal.cs_nbfree;
9341c85e6a3SKirk McKusick 		fs->fs_old_cstotal.cs_nifree = fs->fs_cstotal.cs_nifree;
9351c85e6a3SKirk McKusick 		fs->fs_old_cstotal.cs_nffree = fs->fs_cstotal.cs_nffree;
9361c85e6a3SKirk McKusick 		fs->fs_maxfilesize = ump->um_savedmaxfilesize;
9378f42fb8fSIan Dowse 	}
9381c85e6a3SKirk McKusick 	if (bigcgs) {
9391c85e6a3SKirk McKusick 		fs->fs_cgsize = fs->fs_save_cgsize;
9401c85e6a3SKirk McKusick 		fs->fs_save_cgsize = 0;
9411c85e6a3SKirk McKusick 	}
942df8bae1dSRodney W. Grimes }
943df8bae1dSRodney W. Grimes 
944df8bae1dSRodney W. Grimes /*
945df8bae1dSRodney W. Grimes  * unmount system call
946df8bae1dSRodney W. Grimes  */
947adf41577SPoul-Henning Kamp static int
948b40ce416SJulian Elischer ffs_unmount(mp, mntflags, td)
949df8bae1dSRodney W. Grimes 	struct mount *mp;
950df8bae1dSRodney W. Grimes 	int mntflags;
951b40ce416SJulian Elischer 	struct thread *td;
952df8bae1dSRodney W. Grimes {
95305f4ff5dSPoul-Henning Kamp 	struct ufsmount *ump = VFSTOUFS(mp);
95405f4ff5dSPoul-Henning Kamp 	struct fs *fs;
955996c772fSJohn Dyson 	int error, flags;
956df8bae1dSRodney W. Grimes 
957df8bae1dSRodney W. Grimes 	flags = 0;
958df8bae1dSRodney W. Grimes 	if (mntflags & MNT_FORCE) {
959df8bae1dSRodney W. Grimes 		flags |= FORCECLOSE;
960df8bae1dSRodney W. Grimes 	}
961516081f2SRobert Watson #ifdef UFS_EXTATTR
962b40ce416SJulian Elischer 	if ((error = ufs_extattr_stop(mp, td))) {
963b2b0497aSRobert Watson 		if (error != EOPNOTSUPP)
964b2b0497aSRobert Watson 			printf("ffs_unmount: ufs_extattr_stop returned %d\n",
965b2b0497aSRobert Watson 			    error);
9667df97b61SRobert Watson 	} else {
9679de54ba5SRobert Watson 		ufs_extattr_uepm_destroy(&ump->um_extattr);
9687df97b61SRobert Watson 	}
969a64ed089SRobert Watson #endif
970b1897c19SJulian Elischer 	if (mp->mnt_flag & MNT_SOFTDEP) {
971b40ce416SJulian Elischer 		if ((error = softdep_flushfiles(mp, flags, td)) != 0)
972df8bae1dSRodney W. Grimes 			return (error);
973b1897c19SJulian Elischer 	} else {
974b40ce416SJulian Elischer 		if ((error = ffs_flushfiles(mp, flags, td)) != 0)
975b1897c19SJulian Elischer 			return (error);
976b1897c19SJulian Elischer 	}
977df8bae1dSRodney W. Grimes 	fs = ump->um_fs;
9783ba649d7SJeff Roberson 	UFS_LOCK(ump);
9799ccb939eSKirk McKusick 	if (fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) {
980cfbf0a46SMaxime Henrion 		printf("%s: unmount pending error: blocks %jd files %d\n",
9811c85e6a3SKirk McKusick 		    fs->fs_fsmnt, (intmax_t)fs->fs_pendingblocks,
9821c85e6a3SKirk McKusick 		    fs->fs_pendinginodes);
9839ccb939eSKirk McKusick 		fs->fs_pendingblocks = 0;
9849ccb939eSKirk McKusick 		fs->fs_pendinginodes = 0;
9859ccb939eSKirk McKusick 	}
9863ba649d7SJeff Roberson 	UFS_UNLOCK(ump);
987996c772fSJohn Dyson 	if (fs->fs_ronly == 0) {
9881a6a6610SKirk McKusick 		fs->fs_clean = fs->fs_flags & (FS_UNCLEAN|FS_NEEDSFSCK) ? 0 : 1;
989996c772fSJohn Dyson 		error = ffs_sbupdate(ump, MNT_WAIT);
990996c772fSJohn Dyson 		if (error) {
991996c772fSJohn Dyson 			fs->fs_clean = 0;
992996c772fSJohn Dyson 			return (error);
993996c772fSJohn Dyson 		}
994e0e9c421SDavid Greenman 	}
99543920011SPoul-Henning Kamp 	DROP_GIANT();
99643920011SPoul-Henning Kamp 	g_topology_lock();
99784a69752SPoul-Henning Kamp 	g_vfs_close(ump->um_cp, td);
99843920011SPoul-Henning Kamp 	g_topology_unlock();
99943920011SPoul-Henning Kamp 	PICKUP_GIANT();
10006476c0d2SJohn Dyson 	vrele(ump->um_devvp);
10013ba649d7SJeff Roberson 	mtx_destroy(UFS_MTX(ump));
1002f55ff3f3SIan Dowse 	free(fs->fs_csp, M_UFSMNT);
1003df8bae1dSRodney W. Grimes 	free(fs, M_UFSMNT);
1004df8bae1dSRodney W. Grimes 	free(ump, M_UFSMNT);
1005df8bae1dSRodney W. Grimes 	mp->mnt_data = (qaddr_t)0;
1006cc9d8990SPeter Wemm 	mp->mnt_flag &= ~MNT_LOCAL;
1007df8bae1dSRodney W. Grimes 	return (error);
1008df8bae1dSRodney W. Grimes }
1009df8bae1dSRodney W. Grimes 
1010df8bae1dSRodney W. Grimes /*
1011df8bae1dSRodney W. Grimes  * Flush out all the files in a filesystem.
1012df8bae1dSRodney W. Grimes  */
101326f9a767SRodney W. Grimes int
1014b40ce416SJulian Elischer ffs_flushfiles(mp, flags, td)
101505f4ff5dSPoul-Henning Kamp 	struct mount *mp;
1016df8bae1dSRodney W. Grimes 	int flags;
1017b40ce416SJulian Elischer 	struct thread *td;
1018df8bae1dSRodney W. Grimes {
101905f4ff5dSPoul-Henning Kamp 	struct ufsmount *ump;
1020c9671602SPoul-Henning Kamp 	int error;
1021df8bae1dSRodney W. Grimes 
1022df8bae1dSRodney W. Grimes 	ump = VFSTOUFS(mp);
1023df8bae1dSRodney W. Grimes #ifdef QUOTA
1024df8bae1dSRodney W. Grimes 	if (mp->mnt_flag & MNT_QUOTA) {
1025c1d9efcbSPoul-Henning Kamp 		int i;
1026f257b7a5SAlfred Perlstein 		error = vflush(mp, 0, SKIPSYSTEM|flags, td);
1027c1d9efcbSPoul-Henning Kamp 		if (error)
1028df8bae1dSRodney W. Grimes 			return (error);
1029df8bae1dSRodney W. Grimes 		for (i = 0; i < MAXQUOTAS; i++) {
1030df8bae1dSRodney W. Grimes 			if (ump->um_quotas[i] == NULLVP)
1031df8bae1dSRodney W. Grimes 				continue;
1032b40ce416SJulian Elischer 			quotaoff(td, mp, i);
1033df8bae1dSRodney W. Grimes 		}
1034df8bae1dSRodney W. Grimes 		/*
1035df8bae1dSRodney W. Grimes 		 * Here we fall through to vflush again to ensure
1036df8bae1dSRodney W. Grimes 		 * that we have gotten rid of all the system vnodes.
1037df8bae1dSRodney W. Grimes 		 */
1038df8bae1dSRodney W. Grimes 	}
1039df8bae1dSRodney W. Grimes #endif
1040e6e370a7SJeff Roberson 	ASSERT_VOP_LOCKED(ump->um_devvp, "ffs_flushfiles");
1041e6e370a7SJeff Roberson 	if (ump->um_devvp->v_vflag & VV_COPYONWRITE) {
1042f257b7a5SAlfred Perlstein 		if ((error = vflush(mp, 0, SKIPSYSTEM | flags, td)) != 0)
1043f2a2857bSKirk McKusick 			return (error);
1044f2a2857bSKirk McKusick 		ffs_snapshot_unmount(mp);
1045f2a2857bSKirk McKusick 		/*
1046f2a2857bSKirk McKusick 		 * Here we fall through to vflush again to ensure
1047f2a2857bSKirk McKusick 		 * that we have gotten rid of all the system vnodes.
1048f2a2857bSKirk McKusick 		 */
1049f2a2857bSKirk McKusick 	}
1050b1897c19SJulian Elischer         /*
1051b1897c19SJulian Elischer 	 * Flush all the files.
1052b1897c19SJulian Elischer 	 */
1053f257b7a5SAlfred Perlstein 	if ((error = vflush(mp, 0, flags, td)) != 0)
1054b1897c19SJulian Elischer 		return (error);
1055b1897c19SJulian Elischer 	/*
1056b1897c19SJulian Elischer 	 * Flush filesystem metadata.
1057b1897c19SJulian Elischer 	 */
1058b40ce416SJulian Elischer 	vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY, td);
10598df6bac4SPoul-Henning Kamp 	error = VOP_FSYNC(ump->um_devvp, MNT_WAIT, td);
1060b40ce416SJulian Elischer 	VOP_UNLOCK(ump->um_devvp, 0, td);
1061df8bae1dSRodney W. Grimes 	return (error);
1062df8bae1dSRodney W. Grimes }
1063df8bae1dSRodney W. Grimes 
1064df8bae1dSRodney W. Grimes /*
1065df8bae1dSRodney W. Grimes  * Get filesystem statistics.
1066df8bae1dSRodney W. Grimes  */
1067adf41577SPoul-Henning Kamp static int
1068b40ce416SJulian Elischer ffs_statfs(mp, sbp, td)
1069df8bae1dSRodney W. Grimes 	struct mount *mp;
107005f4ff5dSPoul-Henning Kamp 	struct statfs *sbp;
1071b40ce416SJulian Elischer 	struct thread *td;
1072df8bae1dSRodney W. Grimes {
107305f4ff5dSPoul-Henning Kamp 	struct ufsmount *ump;
107405f4ff5dSPoul-Henning Kamp 	struct fs *fs;
1075df8bae1dSRodney W. Grimes 
1076df8bae1dSRodney W. Grimes 	ump = VFSTOUFS(mp);
1077df8bae1dSRodney W. Grimes 	fs = ump->um_fs;
10781c85e6a3SKirk McKusick 	if (fs->fs_magic != FS_UFS1_MAGIC && fs->fs_magic != FS_UFS2_MAGIC)
1079df8bae1dSRodney W. Grimes 		panic("ffs_statfs");
1080fde81c7dSKirk McKusick 	sbp->f_version = STATFS_VERSION;
1081df8bae1dSRodney W. Grimes 	sbp->f_bsize = fs->fs_fsize;
1082df8bae1dSRodney W. Grimes 	sbp->f_iosize = fs->fs_bsize;
1083df8bae1dSRodney W. Grimes 	sbp->f_blocks = fs->fs_dsize;
10843ba649d7SJeff Roberson 	UFS_LOCK(ump);
1085df8bae1dSRodney W. Grimes 	sbp->f_bfree = fs->fs_cstotal.cs_nbfree * fs->fs_frag +
10869ccb939eSKirk McKusick 	    fs->fs_cstotal.cs_nffree + dbtofsb(fs, fs->fs_pendingblocks);
10879ccb939eSKirk McKusick 	sbp->f_bavail = freespace(fs, fs->fs_minfree) +
10889ccb939eSKirk McKusick 	    dbtofsb(fs, fs->fs_pendingblocks);
1089df8bae1dSRodney W. Grimes 	sbp->f_files =  fs->fs_ncg * fs->fs_ipg - ROOTINO;
10909ccb939eSKirk McKusick 	sbp->f_ffree = fs->fs_cstotal.cs_nifree + fs->fs_pendinginodes;
10913ba649d7SJeff Roberson 	UFS_UNLOCK(ump);
1092fde81c7dSKirk McKusick 	sbp->f_namemax = NAME_MAX;
1093df8bae1dSRodney W. Grimes 	return (0);
1094df8bae1dSRodney W. Grimes }
1095df8bae1dSRodney W. Grimes 
1096df8bae1dSRodney W. Grimes /*
1097df8bae1dSRodney W. Grimes  * Go through the disk queues to initiate sandbagged IO;
1098df8bae1dSRodney W. Grimes  * go through the inodes to write those that have been modified;
1099df8bae1dSRodney W. Grimes  * initiate the writing of the super block if it has been modified.
1100df8bae1dSRodney W. Grimes  *
1101df8bae1dSRodney W. Grimes  * Note: we are always called with the filesystem marked `MPBUSY'.
1102df8bae1dSRodney W. Grimes  */
1103adf41577SPoul-Henning Kamp static int
11048df6bac4SPoul-Henning Kamp ffs_sync(mp, waitfor, td)
1105df8bae1dSRodney W. Grimes 	struct mount *mp;
1106df8bae1dSRodney W. Grimes 	int waitfor;
1107b40ce416SJulian Elischer 	struct thread *td;
1108df8bae1dSRodney W. Grimes {
1109112f7372SKirk McKusick 	struct vnode *nvp, *vp, *devvp;
1110996c772fSJohn Dyson 	struct inode *ip;
1111996c772fSJohn Dyson 	struct ufsmount *ump = VFSTOUFS(mp);
1112996c772fSJohn Dyson 	struct fs *fs;
11139b971133SKirk McKusick 	int error, count, wait, lockreq, allerror = 0;
1114156cb265SPoul-Henning Kamp 	struct bufobj *bo;
1115df8bae1dSRodney W. Grimes 
1116df8bae1dSRodney W. Grimes 	fs = ump->um_fs;
1117996c772fSJohn Dyson 	if (fs->fs_fmod != 0 && fs->fs_ronly != 0) {		/* XXX */
1118df8bae1dSRodney W. Grimes 		printf("fs = %s\n", fs->fs_fsmnt);
11195ace3b26SMike Pritchard 		panic("ffs_sync: rofs mod");
1120df8bae1dSRodney W. Grimes 	}
1121df8bae1dSRodney W. Grimes 	/*
1122df8bae1dSRodney W. Grimes 	 * Write back each (modified) inode.
1123df8bae1dSRodney W. Grimes 	 */
11249b971133SKirk McKusick 	wait = 0;
1125245df27cSMatthew Dillon 	lockreq = LK_EXCLUSIVE | LK_NOWAIT;
11269b971133SKirk McKusick 	if (waitfor == MNT_WAIT) {
11279b971133SKirk McKusick 		wait = 1;
1128245df27cSMatthew Dillon 		lockreq = LK_EXCLUSIVE;
11299b971133SKirk McKusick 	}
113041d4783dSJeff Roberson 	lockreq |= LK_INTERLOCK | LK_SLEEPFAIL;
1131ca430f2eSAlexander Kabaev 	MNT_ILOCK(mp);
1132df8bae1dSRodney W. Grimes loop:
1133e3c5a7a4SPoul-Henning Kamp 	MNT_VNODE_FOREACH(vp, mp, nvp) {
1134245df27cSMatthew Dillon 		/*
1135245df27cSMatthew Dillon 		 * Depend on the mntvnode_slock to keep things stable enough
1136245df27cSMatthew Dillon 		 * for a quick test.  Since there might be hundreds of
1137245df27cSMatthew Dillon 		 * thousands of vnodes, we cannot afford even a subroutine
1138245df27cSMatthew Dillon 		 * call unless there's a good chance that we have work to do.
1139245df27cSMatthew Dillon 		 */
11402f05568aSJeff Roberson 		VI_LOCK(vp);
1141fe68abe2SJeff Roberson 		if (vp->v_iflag & VI_DOOMED) {
11422f05568aSJeff Roberson 			VI_UNLOCK(vp);
11432f05568aSJeff Roberson 			continue;
11442f05568aSJeff Roberson 		}
1145df8bae1dSRodney W. Grimes 		ip = VTOI(vp);
1146cf60e8e4SKirk McKusick 		if (vp->v_type == VNON || ((ip->i_flag &
1147cf60e8e4SKirk McKusick 		    (IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE)) == 0 &&
1148156cb265SPoul-Henning Kamp 		    vp->v_bufobj.bo_dirty.bv_cnt == 0)) {
11492f05568aSJeff Roberson 			VI_UNLOCK(vp);
1150df8bae1dSRodney W. Grimes 			continue;
1151996c772fSJohn Dyson 		}
1152ca430f2eSAlexander Kabaev 		MNT_IUNLOCK(mp);
1153b40ce416SJulian Elischer 		if ((error = vget(vp, lockreq, td)) != 0) {
1154ca430f2eSAlexander Kabaev 			MNT_ILOCK(mp);
115541d4783dSJeff Roberson 			if (error == ENOENT || error == ENOLCK)
1156df8bae1dSRodney W. Grimes 				goto loop;
11572f05568aSJeff Roberson 			continue;
11582f05568aSJeff Roberson 		}
115940854ff5SPoul-Henning Kamp 		if ((error = ffs_syncvnode(vp, waitfor)) != 0)
1160df8bae1dSRodney W. Grimes 			allerror = error;
116141d4783dSJeff Roberson 		vput(vp);
1162ca430f2eSAlexander Kabaev 		MNT_ILOCK(mp);
1163245df27cSMatthew Dillon 	}
1164ca430f2eSAlexander Kabaev 	MNT_IUNLOCK(mp);
1165df8bae1dSRodney W. Grimes 	/*
1166df8bae1dSRodney W. Grimes 	 * Force stale filesystem control information to be flushed.
1167df8bae1dSRodney W. Grimes 	 */
11689b971133SKirk McKusick 	if (waitfor == MNT_WAIT) {
1169b40ce416SJulian Elischer 		if ((error = softdep_flushworklist(ump->um_mountp, &count, td)))
11709b971133SKirk McKusick 			allerror = error;
11719b971133SKirk McKusick 		/* Flushed work items may create new vnodes to clean */
11729ab73fd1SKirk McKusick 		if (allerror == 0 && count) {
1173ca430f2eSAlexander Kabaev 			MNT_ILOCK(mp);
11749b971133SKirk McKusick 			goto loop;
11759b971133SKirk McKusick 		}
11769b971133SKirk McKusick 	}
1177589c7af9SKirk McKusick #ifdef QUOTA
1178589c7af9SKirk McKusick 	qsync(mp);
1179589c7af9SKirk McKusick #endif
1180112f7372SKirk McKusick 	devvp = ump->um_devvp;
11812ee5711eSJeff Roberson 	VI_LOCK(devvp);
1182156cb265SPoul-Henning Kamp 	bo = &devvp->v_bufobj;
1183112f7372SKirk McKusick 	if (waitfor != MNT_LAZY &&
1184156cb265SPoul-Henning Kamp 	    (bo->bo_numoutput > 0 || bo->bo_dirty.bv_cnt > 0)) {
11852ee5711eSJeff Roberson 		vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY | LK_INTERLOCK, td);
11868df6bac4SPoul-Henning Kamp 		if ((error = VOP_FSYNC(devvp, waitfor, td)) != 0)
1187df8bae1dSRodney W. Grimes 			allerror = error;
1188b40ce416SJulian Elischer 		VOP_UNLOCK(devvp, 0, td);
11899ab73fd1SKirk McKusick 		if (allerror == 0 && waitfor == MNT_WAIT) {
1190ca430f2eSAlexander Kabaev 			MNT_ILOCK(mp);
1191112f7372SKirk McKusick 			goto loop;
1192b1897c19SJulian Elischer 		}
1193112f7372SKirk McKusick 	} else
11942ee5711eSJeff Roberson 		VI_UNLOCK(devvp);
1195996c772fSJohn Dyson 	/*
1196996c772fSJohn Dyson 	 * Write back modified superblock.
1197996c772fSJohn Dyson 	 */
1198b1897c19SJulian Elischer 	if (fs->fs_fmod != 0 && (error = ffs_sbupdate(ump, waitfor)) != 0)
1199996c772fSJohn Dyson 		allerror = error;
1200df8bae1dSRodney W. Grimes 	return (allerror);
1201df8bae1dSRodney W. Grimes }
1202df8bae1dSRodney W. Grimes 
1203df8bae1dSRodney W. Grimes int
1204a0595d02SKirk McKusick ffs_vget(mp, ino, flags, vpp)
1205df8bae1dSRodney W. Grimes 	struct mount *mp;
1206df8bae1dSRodney W. Grimes 	ino_t ino;
1207a0595d02SKirk McKusick 	int flags;
1208df8bae1dSRodney W. Grimes 	struct vnode **vpp;
1209df8bae1dSRodney W. Grimes {
1210996c772fSJohn Dyson 	struct fs *fs;
1211996c772fSJohn Dyson 	struct inode *ip;
1212df8bae1dSRodney W. Grimes 	struct ufsmount *ump;
1213df8bae1dSRodney W. Grimes 	struct buf *bp;
1214df8bae1dSRodney W. Grimes 	struct vnode *vp;
121589c9c53dSPoul-Henning Kamp 	struct cdev *dev;
1216f576a00dSSemen Ustimenko 	int error;
1217df8bae1dSRodney W. Grimes 
121851f5ce0cSPoul-Henning Kamp 	error = vfs_hash_get(mp, ino, flags, curthread, vpp, NULL, NULL);
1219e82ef95cSPoul-Henning Kamp 	if (error || *vpp != NULL)
122014bc0685SPoul-Henning Kamp 		return (error);
1221f576a00dSSemen Ustimenko 
1222f576a00dSSemen Ustimenko 	/*
1223d6919865SJeff Roberson 	 * We must promote to an exclusive lock for vnode creation.  This
1224d6919865SJeff Roberson 	 * can happen if lookup is passed LOCKSHARED.
1225d6919865SJeff Roberson  	 */
1226d6919865SJeff Roberson 	if ((flags & LK_TYPE_MASK) == LK_SHARED) {
1227d6919865SJeff Roberson 		flags &= ~LK_TYPE_MASK;
1228d6919865SJeff Roberson 		flags |= LK_EXCLUSIVE;
1229d6919865SJeff Roberson 	}
1230d6919865SJeff Roberson 
1231d6919865SJeff Roberson 	/*
123213866b3fSSemen Ustimenko 	 * We do not lock vnode creation as it is believed to be too
1233f576a00dSSemen Ustimenko 	 * expensive for such rare case as simultaneous creation of vnode
1234f576a00dSSemen Ustimenko 	 * for same ino by different processes. We just allow them to race
1235f576a00dSSemen Ustimenko 	 * and check later to decide who wins. Let the race begin!
1236f576a00dSSemen Ustimenko 	 */
123714bc0685SPoul-Henning Kamp 
123814bc0685SPoul-Henning Kamp 	ump = VFSTOUFS(mp);
123914bc0685SPoul-Henning Kamp 	dev = ump->um_dev;
124014bc0685SPoul-Henning Kamp 	fs = ump->um_fs;
1241df8bae1dSRodney W. Grimes 
12422094ddb6SDavid Greenman 	/*
12432f9bae59SDavid Greenman 	 * If this MALLOC() is performed after the getnewvnode()
12442f9bae59SDavid Greenman 	 * it might block, leaving a vnode with a NULL v_data to be
12452f9bae59SDavid Greenman 	 * found by ffs_sync() if a sync happens to fire right then,
12462f9bae59SDavid Greenman 	 * which will cause a panic because ffs_sync() blindly
12472f9bae59SDavid Greenman 	 * dereferences vp->v_data (as well it should).
12482f9bae59SDavid Greenman 	 */
124914bc0685SPoul-Henning Kamp 	ip = uma_zalloc(uma_inode, M_WAITOK | M_ZERO);
12502f9bae59SDavid Greenman 
1251df8bae1dSRodney W. Grimes 	/* Allocate a new vnode/inode. */
125202f2c6a9SPoul-Henning Kamp 	if (fs->fs_magic == FS_UFS1_MAGIC)
125302f2c6a9SPoul-Henning Kamp 		error = getnewvnode("ufs", mp, &ffs_vnodeops1, &vp);
125402f2c6a9SPoul-Henning Kamp 	else
125502f2c6a9SPoul-Henning Kamp 		error = getnewvnode("ufs", mp, &ffs_vnodeops2, &vp);
1256c9671602SPoul-Henning Kamp 	if (error) {
1257df8bae1dSRodney W. Grimes 		*vpp = NULL;
1258aa4d7a8aSPoul-Henning Kamp 		uma_zfree(uma_inode, ip);
1259df8bae1dSRodney W. Grimes 		return (error);
1260df8bae1dSRodney W. Grimes 	}
126167e87166SBoris Popov 	/*
1262aa7ba427SJeff Roberson 	 * FFS supports recursive and shared locking.
126367e87166SBoris Popov 	 */
1264a5b65058SKirk McKusick 	vp->v_vnlock->lk_flags |= LK_CANRECURSE;
1265aa7ba427SJeff Roberson 	vp->v_vnlock->lk_flags &= ~LK_NOSHARE;
1266df8bae1dSRodney W. Grimes 	vp->v_data = ip;
12675d9d81e7SPoul-Henning Kamp 	vp->v_bufobj.bo_bsize = fs->fs_bsize;
1268df8bae1dSRodney W. Grimes 	ip->i_vnode = vp;
12691c85e6a3SKirk McKusick 	ip->i_ump = ump;
1270c94cd5fcSPoul-Henning Kamp 	ip->i_fs = fs;
1271df8bae1dSRodney W. Grimes 	ip->i_dev = dev;
1272df8bae1dSRodney W. Grimes 	ip->i_number = ino;
1273df8bae1dSRodney W. Grimes #ifdef QUOTA
1274c1d9efcbSPoul-Henning Kamp 	{
1275c1d9efcbSPoul-Henning Kamp 		int i;
1276df8bae1dSRodney W. Grimes 		for (i = 0; i < MAXQUOTAS; i++)
1277df8bae1dSRodney W. Grimes 			ip->i_dquot[i] = NODQUOT;
1278c1d9efcbSPoul-Henning Kamp 	}
1279df8bae1dSRodney W. Grimes #endif
1280df8bae1dSRodney W. Grimes 
128151f5ce0cSPoul-Henning Kamp 	error = vfs_hash_insert(vp, ino, flags, curthread, vpp, NULL, NULL);
128245c26fa2SPoul-Henning Kamp 	if (error || *vpp != NULL)
1283f576a00dSSemen Ustimenko 		return (error);
1284f576a00dSSemen Ustimenko 
1285df8bae1dSRodney W. Grimes 	/* Read in the disk contents for the inode, copy into the inode. */
1286c9671602SPoul-Henning Kamp 	error = bread(ump->um_devvp, fsbtodb(fs, ino_to_fsba(fs, ino)),
1287c9671602SPoul-Henning Kamp 	    (int)fs->fs_bsize, NOCRED, &bp);
1288c9671602SPoul-Henning Kamp 	if (error) {
1289df8bae1dSRodney W. Grimes 		/*
1290df8bae1dSRodney W. Grimes 		 * The inode does not contain anything useful, so it would
1291df8bae1dSRodney W. Grimes 		 * be misleading to leave it on its hash chain. With mode
1292df8bae1dSRodney W. Grimes 		 * still zero, it will be unlinked and returned to the free
1293df8bae1dSRodney W. Grimes 		 * list by vput().
1294df8bae1dSRodney W. Grimes 		 */
1295df8bae1dSRodney W. Grimes 		brelse(bp);
1296bd7e5f99SJohn Dyson 		vput(vp);
1297df8bae1dSRodney W. Grimes 		*vpp = NULL;
1298df8bae1dSRodney W. Grimes 		return (error);
1299df8bae1dSRodney W. Grimes 	}
1300de6ba7c0SPoul-Henning Kamp 	if (ip->i_ump->um_fstype == UFS1)
1301a163d034SWarner Losh 		ip->i_din1 = uma_zalloc(uma_ufs1, M_WAITOK);
1302de6ba7c0SPoul-Henning Kamp 	else
1303a163d034SWarner Losh 		ip->i_din2 = uma_zalloc(uma_ufs2, M_WAITOK);
1304de6ba7c0SPoul-Henning Kamp 	ffs_load_inode(bp, ip, fs, ino);
1305b1897c19SJulian Elischer 	if (DOINGSOFTDEP(vp))
1306b1897c19SJulian Elischer 		softdep_load_inodeblock(ip);
1307b1897c19SJulian Elischer 	else
1308b1897c19SJulian Elischer 		ip->i_effnlink = ip->i_nlink;
1309bd7e5f99SJohn Dyson 	bqrelse(bp);
1310df8bae1dSRodney W. Grimes 
1311df8bae1dSRodney W. Grimes 	/*
1312df8bae1dSRodney W. Grimes 	 * Initialize the vnode from the inode, check for aliases.
1313df8bae1dSRodney W. Grimes 	 * Note that the underlying vnode may have changed.
1314df8bae1dSRodney W. Grimes 	 */
131502f2c6a9SPoul-Henning Kamp 	if (ip->i_ump->um_fstype == UFS1)
131602f2c6a9SPoul-Henning Kamp 		error = ufs_vinit(mp, &ffs_fifoops1, &vp);
131702f2c6a9SPoul-Henning Kamp 	else
131802f2c6a9SPoul-Henning Kamp 		error = ufs_vinit(mp, &ffs_fifoops2, &vp);
1319c9671602SPoul-Henning Kamp 	if (error) {
1320df8bae1dSRodney W. Grimes 		vput(vp);
1321df8bae1dSRodney W. Grimes 		*vpp = NULL;
1322df8bae1dSRodney W. Grimes 		return (error);
1323df8bae1dSRodney W. Grimes 	}
1324de68347bSPoul-Henning Kamp 
1325df8bae1dSRodney W. Grimes 	/*
13265c24d6eeSPoul-Henning Kamp 	 * Finish inode initialization.
1327df8bae1dSRodney W. Grimes 	 */
1328de68347bSPoul-Henning Kamp 
1329df8bae1dSRodney W. Grimes 	/*
1330df8bae1dSRodney W. Grimes 	 * Set up a generation number for this inode if it does not
1331df8bae1dSRodney W. Grimes 	 * already have one. This should only happen on old filesystems.
1332df8bae1dSRodney W. Grimes 	 */
1333df8bae1dSRodney W. Grimes 	if (ip->i_gen == 0) {
1334aca3e497SKirk McKusick 		ip->i_gen = arc4random() / 2 + 1;
13351c85e6a3SKirk McKusick 		if ((vp->v_mount->mnt_flag & MNT_RDONLY) == 0) {
1336df8bae1dSRodney W. Grimes 			ip->i_flag |= IN_MODIFIED;
1337b403319bSAlexander Kabaev 			DIP_SET(ip, i_gen, ip->i_gen);
13381c85e6a3SKirk McKusick 		}
1339df8bae1dSRodney W. Grimes 	}
1340df8bae1dSRodney W. Grimes 	/*
1341df8bae1dSRodney W. Grimes 	 * Ensure that uid and gid are correct. This is a temporary
1342df8bae1dSRodney W. Grimes 	 * fix until fsck has been changed to do the update.
1343df8bae1dSRodney W. Grimes 	 */
13441c85e6a3SKirk McKusick 	if (fs->fs_magic == FS_UFS1_MAGIC &&		/* XXX */
13451c85e6a3SKirk McKusick 	    fs->fs_old_inodefmt < FS_44INODEFMT) {	/* XXX */
13461c85e6a3SKirk McKusick 		ip->i_uid = ip->i_din1->di_ouid;	/* XXX */
13471c85e6a3SKirk McKusick 		ip->i_gid = ip->i_din1->di_ogid;	/* XXX */
1348df8bae1dSRodney W. Grimes 	}						/* XXX */
1349df8bae1dSRodney W. Grimes 
1350763bbd2fSRobert Watson #ifdef MAC
1351763bbd2fSRobert Watson 	if ((mp->mnt_flag & MNT_MULTILABEL) && ip->i_mode) {
1352763bbd2fSRobert Watson 		/*
1353763bbd2fSRobert Watson 		 * If this vnode is already allocated, and we're running
1354763bbd2fSRobert Watson 		 * multi-label, attempt to perform a label association
1355763bbd2fSRobert Watson 		 * from the extended attributes on the inode.
1356763bbd2fSRobert Watson 		 */
1357763bbd2fSRobert Watson 		error = mac_associate_vnode_extattr(mp, vp);
1358763bbd2fSRobert Watson 		if (error) {
1359763bbd2fSRobert Watson 			/* ufs_inactive will release ip->i_devvp ref. */
1360763bbd2fSRobert Watson 			vput(vp);
1361763bbd2fSRobert Watson 			*vpp = NULL;
1362763bbd2fSRobert Watson 			return (error);
1363763bbd2fSRobert Watson 		}
1364763bbd2fSRobert Watson 	}
1365763bbd2fSRobert Watson #endif
1366763bbd2fSRobert Watson 
1367df8bae1dSRodney W. Grimes 	*vpp = vp;
1368df8bae1dSRodney W. Grimes 	return (0);
1369df8bae1dSRodney W. Grimes }
1370df8bae1dSRodney W. Grimes 
1371df8bae1dSRodney W. Grimes /*
1372df8bae1dSRodney W. Grimes  * File handle to vnode
1373df8bae1dSRodney W. Grimes  *
1374df8bae1dSRodney W. Grimes  * Have to be really careful about stale file handles:
1375df8bae1dSRodney W. Grimes  * - check that the inode number is valid
1376df8bae1dSRodney W. Grimes  * - call ffs_vget() to get the locked inode
1377df8bae1dSRodney W. Grimes  * - check for an unallocated inode (i_mode == 0)
1378df8bae1dSRodney W. Grimes  * - check that the given client host has export rights and return
1379df8bae1dSRodney W. Grimes  *   those rights via. exflagsp and credanonp
1380df8bae1dSRodney W. Grimes  */
1381adf41577SPoul-Henning Kamp static int
1382c24fda81SAlfred Perlstein ffs_fhtovp(mp, fhp, vpp)
138305f4ff5dSPoul-Henning Kamp 	struct mount *mp;
1384df8bae1dSRodney W. Grimes 	struct fid *fhp;
1385df8bae1dSRodney W. Grimes 	struct vnode **vpp;
1386df8bae1dSRodney W. Grimes {
138705f4ff5dSPoul-Henning Kamp 	struct ufid *ufhp;
1388df8bae1dSRodney W. Grimes 	struct fs *fs;
1389df8bae1dSRodney W. Grimes 
1390df8bae1dSRodney W. Grimes 	ufhp = (struct ufid *)fhp;
1391df8bae1dSRodney W. Grimes 	fs = VFSTOUFS(mp)->um_fs;
1392df8bae1dSRodney W. Grimes 	if (ufhp->ufid_ino < ROOTINO ||
1393df8bae1dSRodney W. Grimes 	    ufhp->ufid_ino >= fs->fs_ncg * fs->fs_ipg)
1394df8bae1dSRodney W. Grimes 		return (ESTALE);
1395c24fda81SAlfred Perlstein 	return (ufs_fhtovp(mp, ufhp, vpp));
1396df8bae1dSRodney W. Grimes }
1397df8bae1dSRodney W. Grimes 
1398df8bae1dSRodney W. Grimes /*
1399df8bae1dSRodney W. Grimes  * Vnode pointer to File handle
1400df8bae1dSRodney W. Grimes  */
1401df8bae1dSRodney W. Grimes /* ARGSUSED */
1402adf41577SPoul-Henning Kamp static int
1403df8bae1dSRodney W. Grimes ffs_vptofh(vp, fhp)
1404df8bae1dSRodney W. Grimes 	struct vnode *vp;
1405df8bae1dSRodney W. Grimes 	struct fid *fhp;
1406df8bae1dSRodney W. Grimes {
140705f4ff5dSPoul-Henning Kamp 	struct inode *ip;
140805f4ff5dSPoul-Henning Kamp 	struct ufid *ufhp;
1409df8bae1dSRodney W. Grimes 
1410df8bae1dSRodney W. Grimes 	ip = VTOI(vp);
1411df8bae1dSRodney W. Grimes 	ufhp = (struct ufid *)fhp;
1412df8bae1dSRodney W. Grimes 	ufhp->ufid_len = sizeof(struct ufid);
1413df8bae1dSRodney W. Grimes 	ufhp->ufid_ino = ip->i_number;
1414df8bae1dSRodney W. Grimes 	ufhp->ufid_gen = ip->i_gen;
1415df8bae1dSRodney W. Grimes 	return (0);
1416df8bae1dSRodney W. Grimes }
1417df8bae1dSRodney W. Grimes 
1418df8bae1dSRodney W. Grimes /*
14195346934fSIan Dowse  * Initialize the filesystem.
1420996c772fSJohn Dyson  */
1421996c772fSJohn Dyson static int
1422996c772fSJohn Dyson ffs_init(vfsp)
1423996c772fSJohn Dyson 	struct vfsconf *vfsp;
1424996c772fSJohn Dyson {
1425996c772fSJohn Dyson 
1426b1897c19SJulian Elischer 	softdep_initialize();
1427996c772fSJohn Dyson 	return (ufs_init(vfsp));
1428996c772fSJohn Dyson }
1429996c772fSJohn Dyson 
1430996c772fSJohn Dyson /*
14315346934fSIan Dowse  * Undo the work of ffs_init().
14325346934fSIan Dowse  */
14335346934fSIan Dowse static int
14345346934fSIan Dowse ffs_uninit(vfsp)
14355346934fSIan Dowse 	struct vfsconf *vfsp;
14365346934fSIan Dowse {
14375346934fSIan Dowse 	int ret;
14385346934fSIan Dowse 
14395346934fSIan Dowse 	ret = ufs_uninit(vfsp);
14405346934fSIan Dowse 	softdep_uninitialize();
14415346934fSIan Dowse 	return (ret);
14425346934fSIan Dowse }
14435346934fSIan Dowse 
14445346934fSIan Dowse /*
1445df8bae1dSRodney W. Grimes  * Write a superblock and associated information back to disk.
1446df8bae1dSRodney W. Grimes  */
1447b8dce649SPoul-Henning Kamp static int
1448df8bae1dSRodney W. Grimes ffs_sbupdate(mp, waitfor)
1449df8bae1dSRodney W. Grimes 	struct ufsmount *mp;
1450df8bae1dSRodney W. Grimes 	int waitfor;
1451df8bae1dSRodney W. Grimes {
14521c85e6a3SKirk McKusick 	struct fs *fs = mp->um_fs;
14533ba649d7SJeff Roberson 	struct buf *sbbp;
145405f4ff5dSPoul-Henning Kamp 	struct buf *bp;
1455df8bae1dSRodney W. Grimes 	int blks;
1456f55ff3f3SIan Dowse 	void *space;
1457996c772fSJohn Dyson 	int i, size, error, allerror = 0;
1458df8bae1dSRodney W. Grimes 
145974f3809aSKirk McKusick 	if (fs->fs_ronly == 1 &&
146074f3809aSKirk McKusick 	    (mp->um_mountp->mnt_flag & (MNT_RDONLY | MNT_UPDATE)) !=
146174f3809aSKirk McKusick 	    (MNT_RDONLY | MNT_UPDATE))
146274f3809aSKirk McKusick 		panic("ffs_sbupdate: write read-only filesystem");
1463996c772fSJohn Dyson 	/*
14643ba649d7SJeff Roberson 	 * We use the superblock's buf to serialize calls to ffs_sbupdate().
14653ba649d7SJeff Roberson 	 */
14663ba649d7SJeff Roberson 	sbbp = getblk(mp->um_devvp, btodb(fs->fs_sblockloc), (int)fs->fs_sbsize,
14673ba649d7SJeff Roberson 	    0, 0, 0);
14683ba649d7SJeff Roberson 	/*
1469996c772fSJohn Dyson 	 * First write back the summary information.
1470996c772fSJohn Dyson 	 */
1471df8bae1dSRodney W. Grimes 	blks = howmany(fs->fs_cssize, fs->fs_fsize);
1472f55ff3f3SIan Dowse 	space = fs->fs_csp;
1473df8bae1dSRodney W. Grimes 	for (i = 0; i < blks; i += fs->fs_frag) {
1474df8bae1dSRodney W. Grimes 		size = fs->fs_bsize;
1475df8bae1dSRodney W. Grimes 		if (i + fs->fs_frag > blks)
1476df8bae1dSRodney W. Grimes 			size = (blks - i) * fs->fs_fsize;
1477df8bae1dSRodney W. Grimes 		bp = getblk(mp->um_devvp, fsbtodb(fs, fs->fs_csaddr + i),
14787261f5f6SJeff Roberson 		    size, 0, 0, 0);
1479df8bae1dSRodney W. Grimes 		bcopy(space, bp->b_data, (u_int)size);
1480f55ff3f3SIan Dowse 		space = (char *)space + size;
1481996c772fSJohn Dyson 		if (waitfor != MNT_WAIT)
1482df8bae1dSRodney W. Grimes 			bawrite(bp);
14838aef1712SMatthew Dillon 		else if ((error = bwrite(bp)) != 0)
1484996c772fSJohn Dyson 			allerror = error;
1485df8bae1dSRodney W. Grimes 	}
1486996c772fSJohn Dyson 	/*
1487996c772fSJohn Dyson 	 * Now write back the superblock itself. If any errors occurred
1488996c772fSJohn Dyson 	 * up to this point, then fail so that the superblock avoids
1489996c772fSJohn Dyson 	 * being written out as clean.
1490996c772fSJohn Dyson 	 */
14913ba649d7SJeff Roberson 	if (allerror) {
14923ba649d7SJeff Roberson 		brelse(sbbp);
1493996c772fSJohn Dyson 		return (allerror);
14943ba649d7SJeff Roberson 	}
14953ba649d7SJeff Roberson 	bp = sbbp;
149631574422SKirk McKusick 	if (fs->fs_magic == FS_UFS1_MAGIC && fs->fs_sblockloc != SBLOCK_UFS1 &&
149731574422SKirk McKusick 	    (fs->fs_flags & FS_FLAGS_UPDATED) == 0) {
1498fa5d33e2SKirk McKusick 		printf("%s: correcting fs_sblockloc from %jd to %d\n",
1499fa5d33e2SKirk McKusick 		    fs->fs_fsmnt, fs->fs_sblockloc, SBLOCK_UFS1);
1500fa5d33e2SKirk McKusick 		fs->fs_sblockloc = SBLOCK_UFS1;
1501fa5d33e2SKirk McKusick 	}
150231574422SKirk McKusick 	if (fs->fs_magic == FS_UFS2_MAGIC && fs->fs_sblockloc != SBLOCK_UFS2 &&
150331574422SKirk McKusick 	    (fs->fs_flags & FS_FLAGS_UPDATED) == 0) {
1504fa5d33e2SKirk McKusick 		printf("%s: correcting fs_sblockloc from %jd to %d\n",
1505fa5d33e2SKirk McKusick 		    fs->fs_fsmnt, fs->fs_sblockloc, SBLOCK_UFS2);
1506fa5d33e2SKirk McKusick 		fs->fs_sblockloc = SBLOCK_UFS2;
1507fa5d33e2SKirk McKusick 	}
1508b1897c19SJulian Elischer 	fs->fs_fmod = 0;
1509227ee8a1SPoul-Henning Kamp 	fs->fs_time = time_second;
1510996c772fSJohn Dyson 	bcopy((caddr_t)fs, bp->b_data, (u_int)fs->fs_sbsize);
15111c85e6a3SKirk McKusick 	ffs_oldfscompat_write((struct fs *)bp->b_data, mp);
1512996c772fSJohn Dyson 	if (waitfor != MNT_WAIT)
1513996c772fSJohn Dyson 		bawrite(bp);
15148aef1712SMatthew Dillon 	else if ((error = bwrite(bp)) != 0)
1515996c772fSJohn Dyson 		allerror = error;
1516996c772fSJohn Dyson 	return (allerror);
1517df8bae1dSRodney W. Grimes }
1518d6fe88e4SPoul-Henning Kamp 
1519d6fe88e4SPoul-Henning Kamp static int
1520d6fe88e4SPoul-Henning Kamp ffs_extattrctl(struct mount *mp, int cmd, struct vnode *filename_vp,
1521d6fe88e4SPoul-Henning Kamp 	int attrnamespace, const char *attrname, struct thread *td)
1522d6fe88e4SPoul-Henning Kamp {
1523d6fe88e4SPoul-Henning Kamp 
1524d6fe88e4SPoul-Henning Kamp #ifdef UFS_EXTATTR
1525d6fe88e4SPoul-Henning Kamp 	return (ufs_extattrctl(mp, cmd, filename_vp, attrnamespace,
1526d6fe88e4SPoul-Henning Kamp 	    attrname, td));
1527d6fe88e4SPoul-Henning Kamp #else
1528d6fe88e4SPoul-Henning Kamp 	return (vfs_stdextattrctl(mp, cmd, filename_vp, attrnamespace,
1529d6fe88e4SPoul-Henning Kamp 	    attrname, td));
1530d6fe88e4SPoul-Henning Kamp #endif
1531d6fe88e4SPoul-Henning Kamp }
1532975512a9SPoul-Henning Kamp 
1533975512a9SPoul-Henning Kamp static void
1534975512a9SPoul-Henning Kamp ffs_ifree(struct ufsmount *ump, struct inode *ip)
1535975512a9SPoul-Henning Kamp {
1536975512a9SPoul-Henning Kamp 
153736329289STim J. Robbins 	if (ump->um_fstype == UFS1 && ip->i_din1 != NULL)
1538aa4d7a8aSPoul-Henning Kamp 		uma_zfree(uma_ufs1, ip->i_din1);
153936329289STim J. Robbins 	else if (ip->i_din2 != NULL)
15408d721e87STim J. Robbins 		uma_zfree(uma_ufs2, ip->i_din2);
1541aa4d7a8aSPoul-Henning Kamp 	uma_zfree(uma_inode, ip);
1542975512a9SPoul-Henning Kamp }
15436e77a041SPoul-Henning Kamp 
1544dd19a799SPoul-Henning Kamp static int dobkgrdwrite = 1;
1545dd19a799SPoul-Henning Kamp SYSCTL_INT(_debug, OID_AUTO, dobkgrdwrite, CTLFLAG_RW, &dobkgrdwrite, 0,
1546dd19a799SPoul-Henning Kamp     "Do background writes (honoring the BV_BKGRDWRITE flag)?");
1547dd19a799SPoul-Henning Kamp 
1548dd19a799SPoul-Henning Kamp /*
1549dd19a799SPoul-Henning Kamp  * Complete a background write started from bwrite.
1550dd19a799SPoul-Henning Kamp  */
1551dd19a799SPoul-Henning Kamp static void
1552dd19a799SPoul-Henning Kamp ffs_backgroundwritedone(struct buf *bp)
1553dd19a799SPoul-Henning Kamp {
1554204ec66dSJeff Roberson 	struct bufobj *bufobj;
1555dd19a799SPoul-Henning Kamp 	struct buf *origbp;
1556dd19a799SPoul-Henning Kamp 
1557dd19a799SPoul-Henning Kamp 	/*
1558dd19a799SPoul-Henning Kamp 	 * Find the original buffer that we are writing.
1559dd19a799SPoul-Henning Kamp 	 */
1560204ec66dSJeff Roberson 	bufobj = bp->b_bufobj;
1561204ec66dSJeff Roberson 	BO_LOCK(bufobj);
1562dd19a799SPoul-Henning Kamp 	if ((origbp = gbincore(bp->b_bufobj, bp->b_lblkno)) == NULL)
1563dd19a799SPoul-Henning Kamp 		panic("backgroundwritedone: lost buffer");
1564204ec66dSJeff Roberson 	/* Grab an extra reference to be dropped by the bufdone() below. */
1565204ec66dSJeff Roberson 	bufobj_wrefl(bufobj);
1566204ec66dSJeff Roberson 	BO_UNLOCK(bufobj);
1567dd19a799SPoul-Henning Kamp 	/*
1568dd19a799SPoul-Henning Kamp 	 * Process dependencies then return any unfinished ones.
1569dd19a799SPoul-Henning Kamp 	 */
1570dd19a799SPoul-Henning Kamp 	if (LIST_FIRST(&bp->b_dep) != NULL)
1571dd19a799SPoul-Henning Kamp 		buf_complete(bp);
1572dd19a799SPoul-Henning Kamp #ifdef SOFTUPDATES
1573dd19a799SPoul-Henning Kamp 	if (LIST_FIRST(&bp->b_dep) != NULL)
1574dd19a799SPoul-Henning Kamp 		softdep_move_dependencies(bp, origbp);
1575dd19a799SPoul-Henning Kamp #endif
1576dd19a799SPoul-Henning Kamp 	/*
1577204ec66dSJeff Roberson 	 * This buffer is marked B_NOCACHE so when it is released
1578204ec66dSJeff Roberson 	 * by biodone it will be tossed.
1579dd19a799SPoul-Henning Kamp 	 */
1580dd19a799SPoul-Henning Kamp 	bp->b_flags |= B_NOCACHE;
1581ec9c9e73SAlan Cox 	bp->b_flags &= ~B_CACHE;
1582dd19a799SPoul-Henning Kamp 	bufdone(bp);
1583204ec66dSJeff Roberson 	BO_LOCK(bufobj);
1584dd19a799SPoul-Henning Kamp 	/*
1585dd19a799SPoul-Henning Kamp 	 * Clear the BV_BKGRDINPROG flag in the original buffer
1586dd19a799SPoul-Henning Kamp 	 * and awaken it if it is waiting for the write to complete.
1587dd19a799SPoul-Henning Kamp 	 * If BV_BKGRDINPROG is not set in the original buffer it must
1588dd19a799SPoul-Henning Kamp 	 * have been released and re-instantiated - which is not legal.
1589dd19a799SPoul-Henning Kamp 	 */
1590dd19a799SPoul-Henning Kamp 	KASSERT((origbp->b_vflags & BV_BKGRDINPROG),
1591dd19a799SPoul-Henning Kamp 	    ("backgroundwritedone: lost buffer2"));
1592dd19a799SPoul-Henning Kamp 	origbp->b_vflags &= ~BV_BKGRDINPROG;
1593dd19a799SPoul-Henning Kamp 	if (origbp->b_vflags & BV_BKGRDWAIT) {
1594dd19a799SPoul-Henning Kamp 		origbp->b_vflags &= ~BV_BKGRDWAIT;
1595dd19a799SPoul-Henning Kamp 		wakeup(&origbp->b_xflags);
1596dd19a799SPoul-Henning Kamp 	}
1597204ec66dSJeff Roberson 	BO_UNLOCK(bufobj);
1598dd19a799SPoul-Henning Kamp }
1599dd19a799SPoul-Henning Kamp 
1600dd19a799SPoul-Henning Kamp 
1601dd19a799SPoul-Henning Kamp /*
1602dd19a799SPoul-Henning Kamp  * Write, release buffer on completion.  (Done by iodone
1603dd19a799SPoul-Henning Kamp  * if async).  Do not bother writing anything if the buffer
1604dd19a799SPoul-Henning Kamp  * is invalid.
1605dd19a799SPoul-Henning Kamp  *
1606dd19a799SPoul-Henning Kamp  * Note that we set B_CACHE here, indicating that buffer is
1607dd19a799SPoul-Henning Kamp  * fully valid and thus cacheable.  This is true even of NFS
1608dd19a799SPoul-Henning Kamp  * now so we set it generally.  This could be set either here
1609dd19a799SPoul-Henning Kamp  * or in biodone() since the I/O is synchronous.  We put it
1610dd19a799SPoul-Henning Kamp  * here.
1611dd19a799SPoul-Henning Kamp  */
1612dd19a799SPoul-Henning Kamp static int
1613dd19a799SPoul-Henning Kamp ffs_bufwrite(struct buf *bp)
1614dd19a799SPoul-Henning Kamp {
1615dd19a799SPoul-Henning Kamp 	int oldflags, s;
1616dd19a799SPoul-Henning Kamp 	struct buf *newbp;
1617dd19a799SPoul-Henning Kamp 
1618dd19a799SPoul-Henning Kamp 	CTR3(KTR_BUF, "bufwrite(%p) vp %p flags %X", bp, bp->b_vp, bp->b_flags);
1619dd19a799SPoul-Henning Kamp 	if (bp->b_flags & B_INVAL) {
1620dd19a799SPoul-Henning Kamp 		brelse(bp);
1621dd19a799SPoul-Henning Kamp 		return (0);
1622dd19a799SPoul-Henning Kamp 	}
1623dd19a799SPoul-Henning Kamp 
1624dd19a799SPoul-Henning Kamp 	oldflags = bp->b_flags;
1625dd19a799SPoul-Henning Kamp 
1626dd19a799SPoul-Henning Kamp 	if (BUF_REFCNT(bp) == 0)
1627dd19a799SPoul-Henning Kamp 		panic("bufwrite: buffer is not busy???");
1628dd19a799SPoul-Henning Kamp 	s = splbio();
1629dd19a799SPoul-Henning Kamp 	/*
1630dd19a799SPoul-Henning Kamp 	 * If a background write is already in progress, delay
1631dd19a799SPoul-Henning Kamp 	 * writing this block if it is asynchronous. Otherwise
1632dd19a799SPoul-Henning Kamp 	 * wait for the background write to complete.
1633dd19a799SPoul-Henning Kamp 	 */
1634dd19a799SPoul-Henning Kamp 	BO_LOCK(bp->b_bufobj);
1635dd19a799SPoul-Henning Kamp 	if (bp->b_vflags & BV_BKGRDINPROG) {
1636dd19a799SPoul-Henning Kamp 		if (bp->b_flags & B_ASYNC) {
1637dd19a799SPoul-Henning Kamp 			BO_UNLOCK(bp->b_bufobj);
1638dd19a799SPoul-Henning Kamp 			splx(s);
1639dd19a799SPoul-Henning Kamp 			bdwrite(bp);
1640dd19a799SPoul-Henning Kamp 			return (0);
1641dd19a799SPoul-Henning Kamp 		}
1642dd19a799SPoul-Henning Kamp 		bp->b_vflags |= BV_BKGRDWAIT;
1643dd19a799SPoul-Henning Kamp 		msleep(&bp->b_xflags, BO_MTX(bp->b_bufobj), PRIBIO, "bwrbg", 0);
1644dd19a799SPoul-Henning Kamp 		if (bp->b_vflags & BV_BKGRDINPROG)
1645dd19a799SPoul-Henning Kamp 			panic("bufwrite: still writing");
1646dd19a799SPoul-Henning Kamp 	}
1647dd19a799SPoul-Henning Kamp 	BO_UNLOCK(bp->b_bufobj);
1648dd19a799SPoul-Henning Kamp 
1649dd19a799SPoul-Henning Kamp 	/* Mark the buffer clean */
1650dd19a799SPoul-Henning Kamp 	bundirty(bp);
1651dd19a799SPoul-Henning Kamp 
1652dd19a799SPoul-Henning Kamp 	/*
1653dd19a799SPoul-Henning Kamp 	 * If this buffer is marked for background writing and we
1654dd19a799SPoul-Henning Kamp 	 * do not have to wait for it, make a copy and write the
1655dd19a799SPoul-Henning Kamp 	 * copy so as to leave this buffer ready for further use.
1656dd19a799SPoul-Henning Kamp 	 *
1657dd19a799SPoul-Henning Kamp 	 * This optimization eats a lot of memory.  If we have a page
1658dd19a799SPoul-Henning Kamp 	 * or buffer shortfall we can't do it.
1659dd19a799SPoul-Henning Kamp 	 */
1660dd19a799SPoul-Henning Kamp 	if (dobkgrdwrite && (bp->b_xflags & BX_BKGRDWRITE) &&
1661dd19a799SPoul-Henning Kamp 	    (bp->b_flags & B_ASYNC) &&
1662dd19a799SPoul-Henning Kamp 	    !vm_page_count_severe() &&
1663dd19a799SPoul-Henning Kamp 	    !buf_dirty_count_severe()) {
1664dd19a799SPoul-Henning Kamp 		KASSERT(bp->b_iodone == NULL,
1665dd19a799SPoul-Henning Kamp 		    ("bufwrite: needs chained iodone (%p)", bp->b_iodone));
1666dd19a799SPoul-Henning Kamp 
1667dd19a799SPoul-Henning Kamp 		/* get a new block */
1668dd19a799SPoul-Henning Kamp 		newbp = geteblk(bp->b_bufsize);
1669dd19a799SPoul-Henning Kamp 
1670dd19a799SPoul-Henning Kamp 		/*
1671dd19a799SPoul-Henning Kamp 		 * set it to be identical to the old block.  We have to
1672dd19a799SPoul-Henning Kamp 		 * set b_lblkno and BKGRDMARKER before calling bgetvp()
1673dd19a799SPoul-Henning Kamp 		 * to avoid confusing the splay tree and gbincore().
1674dd19a799SPoul-Henning Kamp 		 */
1675dd19a799SPoul-Henning Kamp 		memcpy(newbp->b_data, bp->b_data, bp->b_bufsize);
1676dd19a799SPoul-Henning Kamp 		newbp->b_lblkno = bp->b_lblkno;
1677dd19a799SPoul-Henning Kamp 		newbp->b_xflags |= BX_BKGRDMARKER;
1678dd19a799SPoul-Henning Kamp 		BO_LOCK(bp->b_bufobj);
1679dd19a799SPoul-Henning Kamp 		bp->b_vflags |= BV_BKGRDINPROG;
1680dd19a799SPoul-Henning Kamp 		bgetvp(bp->b_vp, newbp);
1681dd19a799SPoul-Henning Kamp 		BO_UNLOCK(bp->b_bufobj);
1682dd19a799SPoul-Henning Kamp 		newbp->b_bufobj = &bp->b_vp->v_bufobj;
1683dd19a799SPoul-Henning Kamp 		newbp->b_blkno = bp->b_blkno;
1684dd19a799SPoul-Henning Kamp 		newbp->b_offset = bp->b_offset;
1685dd19a799SPoul-Henning Kamp 		newbp->b_iodone = ffs_backgroundwritedone;
1686dd19a799SPoul-Henning Kamp 		newbp->b_flags |= B_ASYNC;
1687dd19a799SPoul-Henning Kamp 		newbp->b_flags &= ~B_INVAL;
1688dd19a799SPoul-Henning Kamp 
1689dd19a799SPoul-Henning Kamp #ifdef SOFTUPDATES
1690dd19a799SPoul-Henning Kamp 		/* move over the dependencies */
1691dd19a799SPoul-Henning Kamp 		if (LIST_FIRST(&bp->b_dep) != NULL)
1692dd19a799SPoul-Henning Kamp 			softdep_move_dependencies(bp, newbp);
1693dd19a799SPoul-Henning Kamp #endif
1694dd19a799SPoul-Henning Kamp 
1695dd19a799SPoul-Henning Kamp 		/*
1696dd19a799SPoul-Henning Kamp 		 * Initiate write on the copy, release the original to
1697dd19a799SPoul-Henning Kamp 		 * the B_LOCKED queue so that it cannot go away until
1698dd19a799SPoul-Henning Kamp 		 * the background write completes. If not locked it could go
1699dd19a799SPoul-Henning Kamp 		 * away and then be reconstituted while it was being written.
1700dd19a799SPoul-Henning Kamp 		 * If the reconstituted buffer were written, we could end up
1701dd19a799SPoul-Henning Kamp 		 * with two background copies being written at the same time.
1702dd19a799SPoul-Henning Kamp 		 */
1703dd19a799SPoul-Henning Kamp 		bqrelse(bp);
1704dd19a799SPoul-Henning Kamp 		bp = newbp;
1705dd19a799SPoul-Henning Kamp 	}
1706dd19a799SPoul-Henning Kamp 
1707dd19a799SPoul-Henning Kamp 	/* Let the normal bufwrite do the rest for us */
17089248a827STor Egge 	return (bufwrite(bp));
1709dd19a799SPoul-Henning Kamp }
1710dd19a799SPoul-Henning Kamp 
1711dd19a799SPoul-Henning Kamp 
17128dd56505SPoul-Henning Kamp static void
17136e77a041SPoul-Henning Kamp ffs_geom_strategy(struct bufobj *bo, struct buf *bp)
17146e77a041SPoul-Henning Kamp {
1715153910e0SJeff Roberson 	struct vnode *vp;
1716153910e0SJeff Roberson 	int error;
17176e77a041SPoul-Henning Kamp 
1718153910e0SJeff Roberson 	vp = bo->__bo_vnode;
1719153910e0SJeff Roberson 	if (bp->b_iocmd == BIO_WRITE) {
17206e77a041SPoul-Henning Kamp #ifdef SOFTUPDATES
1721153910e0SJeff Roberson 		if (LIST_FIRST(&bp->b_dep) != NULL)
1722153910e0SJeff Roberson 			buf_start(bp);
17236e77a041SPoul-Henning Kamp #endif
1724153910e0SJeff Roberson 		if ((bp->b_flags & B_VALIDSUSPWRT) == 0 &&
1725153910e0SJeff Roberson 		    bp->b_vp != NULL && bp->b_vp->v_mount != NULL &&
1726153910e0SJeff Roberson 		    (bp->b_vp->v_mount->mnt_kern_flag & MNTK_SUSPENDED) != 0)
1727153910e0SJeff Roberson 			panic("ffs_geom_strategy: bad I/O");
1728153910e0SJeff Roberson 		bp->b_flags &= ~B_VALIDSUSPWRT;
1729153910e0SJeff Roberson 		if ((vp->v_vflag & VV_COPYONWRITE) &&
1730153910e0SJeff Roberson 		    vp->v_rdev->si_snapdata != NULL &&
1731153910e0SJeff Roberson 		    (error = (ffs_copyonwrite)(vp, bp)) != 0 &&
1732153910e0SJeff Roberson 		    error != EOPNOTSUPP) {
1733153910e0SJeff Roberson 			bp->b_error = error;
1734153910e0SJeff Roberson 			bp->b_ioflags |= BIO_ERROR;
1735153910e0SJeff Roberson 			bufdone(bp);
1736153910e0SJeff Roberson 			return;
1737153910e0SJeff Roberson 		}
1738153910e0SJeff Roberson 	}
173943920011SPoul-Henning Kamp 	g_vfs_strategy(bo, bp);
17406e77a041SPoul-Henning Kamp }
1741