xref: /freebsd/sys/kern/vfs_mountroot.c (revision e2e050c8ef733138fc6a9e514e4b856fefbc3ff1)
124e01f59SMarcel Moolenaar /*-
251369649SPedro F. Giffuni  * SPDX-License-Identifier: BSD-3-Clause
351369649SPedro F. Giffuni  *
4e25daafbSMarcel Moolenaar  * Copyright (c) 2010 Marcel Moolenaar
524e01f59SMarcel Moolenaar  * Copyright (c) 1999-2004 Poul-Henning Kamp
624e01f59SMarcel Moolenaar  * Copyright (c) 1999 Michael Smith
724e01f59SMarcel Moolenaar  * Copyright (c) 1989, 1993
824e01f59SMarcel Moolenaar  *      The Regents of the University of California.  All rights reserved.
924e01f59SMarcel Moolenaar  * (c) UNIX System Laboratories, Inc.
1024e01f59SMarcel Moolenaar  * All or some portions of this file are derived from material licensed
1124e01f59SMarcel Moolenaar  * to the University of California by American Telephone and Telegraph
1224e01f59SMarcel Moolenaar  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
1324e01f59SMarcel Moolenaar  * the permission of UNIX System Laboratories, Inc.
1424e01f59SMarcel Moolenaar  *
1524e01f59SMarcel Moolenaar  * Redistribution and use in source and binary forms, with or without
1624e01f59SMarcel Moolenaar  * modification, are permitted provided that the following conditions
1724e01f59SMarcel Moolenaar  * are met:
1824e01f59SMarcel Moolenaar  * 1. Redistributions of source code must retain the above copyright
1924e01f59SMarcel Moolenaar  *    notice, this list of conditions and the following disclaimer.
2024e01f59SMarcel Moolenaar  * 2. Redistributions in binary form must reproduce the above copyright
2124e01f59SMarcel Moolenaar  *    notice, this list of conditions and the following disclaimer in the
2224e01f59SMarcel Moolenaar  *    documentation and/or other materials provided with the distribution.
2369a28758SEd Maste  * 3. Neither the name of the University nor the names of its contributors
2424e01f59SMarcel Moolenaar  *    may be used to endorse or promote products derived from this software
2524e01f59SMarcel Moolenaar  *    without specific prior written permission.
2624e01f59SMarcel Moolenaar  *
2724e01f59SMarcel Moolenaar  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
2824e01f59SMarcel Moolenaar  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
2924e01f59SMarcel Moolenaar  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
3024e01f59SMarcel Moolenaar  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
3124e01f59SMarcel Moolenaar  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
3224e01f59SMarcel Moolenaar  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
3324e01f59SMarcel Moolenaar  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
3424e01f59SMarcel Moolenaar  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
3524e01f59SMarcel Moolenaar  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
3624e01f59SMarcel Moolenaar  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
3724e01f59SMarcel Moolenaar  * SUCH DAMAGE.
3824e01f59SMarcel Moolenaar  */
3924e01f59SMarcel Moolenaar 
40e25daafbSMarcel Moolenaar #include "opt_rootdevname.h"
41e25daafbSMarcel Moolenaar 
4224e01f59SMarcel Moolenaar #include <sys/cdefs.h>
4324e01f59SMarcel Moolenaar __FBSDID("$FreeBSD$");
4424e01f59SMarcel Moolenaar 
4524e01f59SMarcel Moolenaar #include <sys/param.h>
4624e01f59SMarcel Moolenaar #include <sys/conf.h>
47f6ce353eSAndriy Gapon #include <sys/cons.h>
48*e2e050c8SConrad Meyer #include <sys/eventhandler.h>
4924e01f59SMarcel Moolenaar #include <sys/fcntl.h>
5024e01f59SMarcel Moolenaar #include <sys/jail.h>
5124e01f59SMarcel Moolenaar #include <sys/kernel.h>
5224e01f59SMarcel Moolenaar #include <sys/malloc.h>
53e25daafbSMarcel Moolenaar #include <sys/mdioctl.h>
5424e01f59SMarcel Moolenaar #include <sys/mount.h>
5524e01f59SMarcel Moolenaar #include <sys/mutex.h>
5624e01f59SMarcel Moolenaar #include <sys/namei.h>
5724e01f59SMarcel Moolenaar #include <sys/priv.h>
5824e01f59SMarcel Moolenaar #include <sys/proc.h>
5924e01f59SMarcel Moolenaar #include <sys/filedesc.h>
6024e01f59SMarcel Moolenaar #include <sys/reboot.h>
61fef7c585SAndrey V. Elsukov #include <sys/sbuf.h>
62e25daafbSMarcel Moolenaar #include <sys/stat.h>
6324e01f59SMarcel Moolenaar #include <sys/syscallsubr.h>
6424e01f59SMarcel Moolenaar #include <sys/sysproto.h>
6524e01f59SMarcel Moolenaar #include <sys/sx.h>
6624e01f59SMarcel Moolenaar #include <sys/sysctl.h>
6724e01f59SMarcel Moolenaar #include <sys/sysent.h>
6824e01f59SMarcel Moolenaar #include <sys/systm.h>
6924e01f59SMarcel Moolenaar #include <sys/vnode.h>
7024e01f59SMarcel Moolenaar 
7124e01f59SMarcel Moolenaar #include <geom/geom.h>
7224e01f59SMarcel Moolenaar 
7324e01f59SMarcel Moolenaar /*
7424e01f59SMarcel Moolenaar  * The root filesystem is detailed in the kernel environment variable
7524e01f59SMarcel Moolenaar  * vfs.root.mountfrom, which is expected to be in the general format
7624e01f59SMarcel Moolenaar  *
7724e01f59SMarcel Moolenaar  * <vfsname>:[<path>][	<vfsname>:[<path>] ...]
7824e01f59SMarcel Moolenaar  * vfsname   := the name of a VFS known to the kernel and capable
7924e01f59SMarcel Moolenaar  *              of being mounted as root
8024e01f59SMarcel Moolenaar  * path      := disk device name or other data used by the filesystem
8124e01f59SMarcel Moolenaar  *              to locate its physical store
8224e01f59SMarcel Moolenaar  *
8324e01f59SMarcel Moolenaar  * If the environment variable vfs.root.mountfrom is a space separated list,
8424e01f59SMarcel Moolenaar  * each list element is tried in turn and the root filesystem will be mounted
85e3043798SPedro F. Giffuni  * from the first one that succeeds.
8624e01f59SMarcel Moolenaar  *
8724e01f59SMarcel Moolenaar  * The environment variable vfs.root.mountfrom.options is a comma delimited
8824e01f59SMarcel Moolenaar  * set of string mount options.  These mount options must be parseable
8924e01f59SMarcel Moolenaar  * by nmount() in the kernel.
9024e01f59SMarcel Moolenaar  */
9124e01f59SMarcel Moolenaar 
92e25daafbSMarcel Moolenaar static int parse_mount(char **);
93e25daafbSMarcel Moolenaar static struct mntarg *parse_mountroot_options(struct mntarg *, const char *);
94665aea93SEdward Tomasz Napierala static int sysctl_vfs_root_mount_hold(SYSCTL_HANDLER_ARGS);
9568d35798SEdward Tomasz Napierala static void vfs_mountroot_wait(void);
96a3ba3d09SEdward Tomasz Napierala static int vfs_mountroot_wait_if_neccessary(const char *fs, const char *dev);
9724e01f59SMarcel Moolenaar 
98e25daafbSMarcel Moolenaar /*
99e25daafbSMarcel Moolenaar  * The vnode of the system's root (/ in the filesystem, without chroot
100e25daafbSMarcel Moolenaar  * active.)
101e25daafbSMarcel Moolenaar  */
102e25daafbSMarcel Moolenaar struct vnode *rootvnode;
103e25daafbSMarcel Moolenaar 
104c9ba6504SEdward Tomasz Napierala /*
105c9ba6504SEdward Tomasz Napierala  * Mount of the system's /dev.
106c9ba6504SEdward Tomasz Napierala  */
107c9ba6504SEdward Tomasz Napierala struct mount *rootdevmp;
108c9ba6504SEdward Tomasz Napierala 
10924e01f59SMarcel Moolenaar char *rootdevnames[2] = {NULL, NULL};
11024e01f59SMarcel Moolenaar 
111eb6d6216SAlexander Motin struct mtx root_holds_mtx;
112eb6d6216SAlexander Motin MTX_SYSINIT(root_holds, &root_holds_mtx, "root_holds", MTX_DEF);
113eb6d6216SAlexander Motin 
11424e01f59SMarcel Moolenaar struct root_hold_token {
11524e01f59SMarcel Moolenaar 	const char			*who;
11624e01f59SMarcel Moolenaar 	LIST_ENTRY(root_hold_token)	list;
11724e01f59SMarcel Moolenaar };
11824e01f59SMarcel Moolenaar 
11924e01f59SMarcel Moolenaar static LIST_HEAD(, root_hold_token)	root_holds =
12024e01f59SMarcel Moolenaar     LIST_HEAD_INITIALIZER(root_holds);
12124e01f59SMarcel Moolenaar 
122e25daafbSMarcel Moolenaar enum action {
123e25daafbSMarcel Moolenaar 	A_CONTINUE,
124e25daafbSMarcel Moolenaar 	A_PANIC,
125e25daafbSMarcel Moolenaar 	A_REBOOT,
126e25daafbSMarcel Moolenaar 	A_RETRY
127e25daafbSMarcel Moolenaar };
128e25daafbSMarcel Moolenaar 
129e25daafbSMarcel Moolenaar static enum action root_mount_onfail = A_CONTINUE;
130e25daafbSMarcel Moolenaar 
131e25daafbSMarcel Moolenaar static int root_mount_mddev;
13224e01f59SMarcel Moolenaar static int root_mount_complete;
13324e01f59SMarcel Moolenaar 
134e25daafbSMarcel Moolenaar /* By default wait up to 3 seconds for devices to appear. */
135e25daafbSMarcel Moolenaar static int root_mount_timeout = 3;
13690aa031bSMarcel Moolenaar TUNABLE_INT("vfs.mountroot.timeout", &root_mount_timeout);
137e25daafbSMarcel Moolenaar 
1384f9d7badSEdward Tomasz Napierala static int root_mount_always_wait = 0;
1394f9d7badSEdward Tomasz Napierala SYSCTL_INT(_vfs, OID_AUTO, root_mount_always_wait, CTLFLAG_RDTUN,
1404f9d7badSEdward Tomasz Napierala     &root_mount_always_wait, 0,
1414f9d7badSEdward Tomasz Napierala     "Wait for root mount holds even if the root device already exists");
1424f9d7badSEdward Tomasz Napierala 
143665aea93SEdward Tomasz Napierala SYSCTL_PROC(_vfs, OID_AUTO, root_mount_hold,
144665aea93SEdward Tomasz Napierala     CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE,
145665aea93SEdward Tomasz Napierala     NULL, 0, sysctl_vfs_root_mount_hold, "A",
146665aea93SEdward Tomasz Napierala     "List of root mount hold tokens");
147665aea93SEdward Tomasz Napierala 
148665aea93SEdward Tomasz Napierala static int
149665aea93SEdward Tomasz Napierala sysctl_vfs_root_mount_hold(SYSCTL_HANDLER_ARGS)
150665aea93SEdward Tomasz Napierala {
151665aea93SEdward Tomasz Napierala 	struct sbuf sb;
152665aea93SEdward Tomasz Napierala 	struct root_hold_token *h;
153665aea93SEdward Tomasz Napierala 	int error;
154665aea93SEdward Tomasz Napierala 
155665aea93SEdward Tomasz Napierala 	sbuf_new(&sb, NULL, 256, SBUF_AUTOEXTEND | SBUF_INCLUDENUL);
156665aea93SEdward Tomasz Napierala 
157665aea93SEdward Tomasz Napierala 	mtx_lock(&root_holds_mtx);
158665aea93SEdward Tomasz Napierala 	LIST_FOREACH(h, &root_holds, list) {
159665aea93SEdward Tomasz Napierala 		if (h != LIST_FIRST(&root_holds))
160665aea93SEdward Tomasz Napierala 			sbuf_putc(&sb, ' ');
161665aea93SEdward Tomasz Napierala 		sbuf_printf(&sb, "%s", h->who);
162665aea93SEdward Tomasz Napierala 	}
163665aea93SEdward Tomasz Napierala 	mtx_unlock(&root_holds_mtx);
164665aea93SEdward Tomasz Napierala 
165665aea93SEdward Tomasz Napierala 	error = sbuf_finish(&sb);
166665aea93SEdward Tomasz Napierala 	if (error == 0)
167665aea93SEdward Tomasz Napierala 		error = SYSCTL_OUT(req, sbuf_data(&sb), sbuf_len(&sb));
168665aea93SEdward Tomasz Napierala 	sbuf_delete(&sb);
169665aea93SEdward Tomasz Napierala 	return (error);
170665aea93SEdward Tomasz Napierala }
171665aea93SEdward Tomasz Napierala 
17224e01f59SMarcel Moolenaar struct root_hold_token *
17324e01f59SMarcel Moolenaar root_mount_hold(const char *identifier)
17424e01f59SMarcel Moolenaar {
17524e01f59SMarcel Moolenaar 	struct root_hold_token *h;
17624e01f59SMarcel Moolenaar 
17724e01f59SMarcel Moolenaar 	h = malloc(sizeof *h, M_DEVBUF, M_ZERO | M_WAITOK);
17824e01f59SMarcel Moolenaar 	h->who = identifier;
179eb6d6216SAlexander Motin 	mtx_lock(&root_holds_mtx);
1808b8a7c43SColin Percival 	TSHOLD("root mount");
18124e01f59SMarcel Moolenaar 	LIST_INSERT_HEAD(&root_holds, h, list);
182eb6d6216SAlexander Motin 	mtx_unlock(&root_holds_mtx);
18324e01f59SMarcel Moolenaar 	return (h);
18424e01f59SMarcel Moolenaar }
18524e01f59SMarcel Moolenaar 
18624e01f59SMarcel Moolenaar void
18724e01f59SMarcel Moolenaar root_mount_rel(struct root_hold_token *h)
18824e01f59SMarcel Moolenaar {
18924e01f59SMarcel Moolenaar 
190b0618cdaSEdward Tomasz Napierala 	if (h == NULL)
191b0618cdaSEdward Tomasz Napierala 		return;
1921110d002SEdward Tomasz Napierala 
193eb6d6216SAlexander Motin 	mtx_lock(&root_holds_mtx);
19424e01f59SMarcel Moolenaar 	LIST_REMOVE(h, list);
1958b8a7c43SColin Percival 	TSRELEASE("root mount");
19624e01f59SMarcel Moolenaar 	wakeup(&root_holds);
197eb6d6216SAlexander Motin 	mtx_unlock(&root_holds_mtx);
19824e01f59SMarcel Moolenaar 	free(h, M_DEVBUF);
19924e01f59SMarcel Moolenaar }
20024e01f59SMarcel Moolenaar 
20124e01f59SMarcel Moolenaar int
20224e01f59SMarcel Moolenaar root_mounted(void)
20324e01f59SMarcel Moolenaar {
20424e01f59SMarcel Moolenaar 
20524e01f59SMarcel Moolenaar 	/* No mutex is acquired here because int stores are atomic. */
20624e01f59SMarcel Moolenaar 	return (root_mount_complete);
20724e01f59SMarcel Moolenaar }
20824e01f59SMarcel Moolenaar 
20924e01f59SMarcel Moolenaar static void
21024e01f59SMarcel Moolenaar set_rootvnode(void)
21124e01f59SMarcel Moolenaar {
21224e01f59SMarcel Moolenaar 	struct proc *p;
21324e01f59SMarcel Moolenaar 
21424e01f59SMarcel Moolenaar 	if (VFS_ROOT(TAILQ_FIRST(&mountlist), LK_EXCLUSIVE, &rootvnode))
21517ca94cfSKirk McKusick 		panic("set_rootvnode: Cannot find root vnode");
21624e01f59SMarcel Moolenaar 
21724e01f59SMarcel Moolenaar 	VOP_UNLOCK(rootvnode, 0);
21824e01f59SMarcel Moolenaar 
21924e01f59SMarcel Moolenaar 	p = curthread->td_proc;
22024e01f59SMarcel Moolenaar 	FILEDESC_XLOCK(p->p_fd);
22124e01f59SMarcel Moolenaar 
22224e01f59SMarcel Moolenaar 	if (p->p_fd->fd_cdir != NULL)
22324e01f59SMarcel Moolenaar 		vrele(p->p_fd->fd_cdir);
22424e01f59SMarcel Moolenaar 	p->p_fd->fd_cdir = rootvnode;
22524e01f59SMarcel Moolenaar 	VREF(rootvnode);
22624e01f59SMarcel Moolenaar 
22724e01f59SMarcel Moolenaar 	if (p->p_fd->fd_rdir != NULL)
22824e01f59SMarcel Moolenaar 		vrele(p->p_fd->fd_rdir);
22924e01f59SMarcel Moolenaar 	p->p_fd->fd_rdir = rootvnode;
23024e01f59SMarcel Moolenaar 	VREF(rootvnode);
23124e01f59SMarcel Moolenaar 
23224e01f59SMarcel Moolenaar 	FILEDESC_XUNLOCK(p->p_fd);
23324e01f59SMarcel Moolenaar }
23424e01f59SMarcel Moolenaar 
235e25daafbSMarcel Moolenaar static int
236e25daafbSMarcel Moolenaar vfs_mountroot_devfs(struct thread *td, struct mount **mpp)
23724e01f59SMarcel Moolenaar {
23824e01f59SMarcel Moolenaar 	struct vfsoptlist *opts;
23924e01f59SMarcel Moolenaar 	struct vfsconf *vfsp;
240e25daafbSMarcel Moolenaar 	struct mount *mp;
24124e01f59SMarcel Moolenaar 	int error;
24224e01f59SMarcel Moolenaar 
243e25daafbSMarcel Moolenaar 	*mpp = NULL;
244e25daafbSMarcel Moolenaar 
2450d3d0cc3SEdward Tomasz Napierala 	if (rootdevmp != NULL) {
2460d3d0cc3SEdward Tomasz Napierala 		/*
2470d3d0cc3SEdward Tomasz Napierala 		 * Already have /dev; this happens during rerooting.
2480d3d0cc3SEdward Tomasz Napierala 		 */
2490d3d0cc3SEdward Tomasz Napierala 		error = vfs_busy(rootdevmp, 0);
2500d3d0cc3SEdward Tomasz Napierala 		if (error != 0)
2510d3d0cc3SEdward Tomasz Napierala 			return (error);
2520d3d0cc3SEdward Tomasz Napierala 		*mpp = rootdevmp;
2530d3d0cc3SEdward Tomasz Napierala 	} else {
25424e01f59SMarcel Moolenaar 		vfsp = vfs_byname("devfs");
25524e01f59SMarcel Moolenaar 		KASSERT(vfsp != NULL, ("Could not find devfs by name"));
25624e01f59SMarcel Moolenaar 		if (vfsp == NULL)
257e25daafbSMarcel Moolenaar 			return (ENOENT);
25824e01f59SMarcel Moolenaar 
25924e01f59SMarcel Moolenaar 		mp = vfs_mount_alloc(NULLVP, vfsp, "/dev", td->td_ucred);
26024e01f59SMarcel Moolenaar 
26124e01f59SMarcel Moolenaar 		error = VFS_MOUNT(mp);
26224e01f59SMarcel Moolenaar 		KASSERT(error == 0, ("VFS_MOUNT(devfs) failed %d", error));
26324e01f59SMarcel Moolenaar 		if (error)
264e25daafbSMarcel Moolenaar 			return (error);
26524e01f59SMarcel Moolenaar 
26624e01f59SMarcel Moolenaar 		opts = malloc(sizeof(struct vfsoptlist), M_MOUNT, M_WAITOK);
26724e01f59SMarcel Moolenaar 		TAILQ_INIT(opts);
26824e01f59SMarcel Moolenaar 		mp->mnt_opt = opts;
26924e01f59SMarcel Moolenaar 
27024e01f59SMarcel Moolenaar 		mtx_lock(&mountlist_mtx);
27124e01f59SMarcel Moolenaar 		TAILQ_INSERT_HEAD(&mountlist, mp, mnt_list);
27224e01f59SMarcel Moolenaar 		mtx_unlock(&mountlist_mtx);
27324e01f59SMarcel Moolenaar 
274e25daafbSMarcel Moolenaar 		*mpp = mp;
275c9ba6504SEdward Tomasz Napierala 		rootdevmp = mp;
2760d3d0cc3SEdward Tomasz Napierala 	}
2770d3d0cc3SEdward Tomasz Napierala 
27824e01f59SMarcel Moolenaar 	set_rootvnode();
27924e01f59SMarcel Moolenaar 
2806e646651SKonstantin Belousov 	error = kern_symlinkat(td, "/", AT_FDCWD, "dev", UIO_SYSSPACE);
28124e01f59SMarcel Moolenaar 	if (error)
28224e01f59SMarcel Moolenaar 		printf("kern_symlink /dev -> / returns %d\n", error);
283e25daafbSMarcel Moolenaar 
284e25daafbSMarcel Moolenaar 	return (error);
28524e01f59SMarcel Moolenaar }
28624e01f59SMarcel Moolenaar 
2876c5c24c9SBryan Drewery static void
288e25daafbSMarcel Moolenaar vfs_mountroot_shuffle(struct thread *td, struct mount *mpdevfs)
28924e01f59SMarcel Moolenaar {
29024e01f59SMarcel Moolenaar 	struct nameidata nd;
291e25daafbSMarcel Moolenaar 	struct mount *mporoot, *mpnroot;
292e25daafbSMarcel Moolenaar 	struct vnode *vp, *vporoot, *vpdevfs;
293e25daafbSMarcel Moolenaar 	char *fspath;
29424e01f59SMarcel Moolenaar 	int error;
29524e01f59SMarcel Moolenaar 
296e25daafbSMarcel Moolenaar 	mpnroot = TAILQ_NEXT(mpdevfs, mnt_list);
297e25daafbSMarcel Moolenaar 
298e25daafbSMarcel Moolenaar 	/* Shuffle the mountlist. */
29924e01f59SMarcel Moolenaar 	mtx_lock(&mountlist_mtx);
300e25daafbSMarcel Moolenaar 	mporoot = TAILQ_FIRST(&mountlist);
301e25daafbSMarcel Moolenaar 	TAILQ_REMOVE(&mountlist, mpdevfs, mnt_list);
302e25daafbSMarcel Moolenaar 	if (mporoot != mpdevfs) {
303e25daafbSMarcel Moolenaar 		TAILQ_REMOVE(&mountlist, mpnroot, mnt_list);
304e25daafbSMarcel Moolenaar 		TAILQ_INSERT_HEAD(&mountlist, mpnroot, mnt_list);
305e25daafbSMarcel Moolenaar 	}
306e25daafbSMarcel Moolenaar 	TAILQ_INSERT_TAIL(&mountlist, mpdevfs, mnt_list);
30724e01f59SMarcel Moolenaar 	mtx_unlock(&mountlist_mtx);
30824e01f59SMarcel Moolenaar 
309f71d0856SKonstantin Belousov 	cache_purgevfs(mporoot, true);
310e25daafbSMarcel Moolenaar 	if (mporoot != mpdevfs)
311f71d0856SKonstantin Belousov 		cache_purgevfs(mpdevfs, true);
31224e01f59SMarcel Moolenaar 
31317ca94cfSKirk McKusick 	if (VFS_ROOT(mporoot, LK_EXCLUSIVE, &vporoot))
31417ca94cfSKirk McKusick 		panic("vfs_mountroot_shuffle: Cannot find root vnode");
315e25daafbSMarcel Moolenaar 
316e25daafbSMarcel Moolenaar 	VI_LOCK(vporoot);
317e25daafbSMarcel Moolenaar 	vporoot->v_iflag &= ~VI_MOUNT;
318e25daafbSMarcel Moolenaar 	VI_UNLOCK(vporoot);
319e25daafbSMarcel Moolenaar 	vporoot->v_mountedhere = NULL;
320e25daafbSMarcel Moolenaar 	mporoot->mnt_flag &= ~MNT_ROOTFS;
321e25daafbSMarcel Moolenaar 	mporoot->mnt_vnodecovered = NULL;
322e25daafbSMarcel Moolenaar 	vput(vporoot);
323e25daafbSMarcel Moolenaar 
324e25daafbSMarcel Moolenaar 	/* Set up the new rootvnode, and purge the cache */
325e25daafbSMarcel Moolenaar 	mpnroot->mnt_vnodecovered = NULL;
32624e01f59SMarcel Moolenaar 	set_rootvnode();
327f71d0856SKonstantin Belousov 	cache_purgevfs(rootvnode->v_mount, true);
32824e01f59SMarcel Moolenaar 
329e25daafbSMarcel Moolenaar 	if (mporoot != mpdevfs) {
330e25daafbSMarcel Moolenaar 		/* Remount old root under /.mount or /mnt */
331e25daafbSMarcel Moolenaar 		fspath = "/.mount";
332e25daafbSMarcel Moolenaar 		NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_SYSSPACE,
333e25daafbSMarcel Moolenaar 		    fspath, td);
33424e01f59SMarcel Moolenaar 		error = namei(&nd);
33524e01f59SMarcel Moolenaar 		if (error) {
336e25daafbSMarcel Moolenaar 			NDFREE(&nd, NDF_ONLY_PNBUF);
337e25daafbSMarcel Moolenaar 			fspath = "/mnt";
338e25daafbSMarcel Moolenaar 			NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_SYSSPACE,
339e25daafbSMarcel Moolenaar 			    fspath, td);
340e25daafbSMarcel Moolenaar 			error = namei(&nd);
341e25daafbSMarcel Moolenaar 		}
342e25daafbSMarcel Moolenaar 		if (!error) {
343e25daafbSMarcel Moolenaar 			vp = nd.ni_vp;
344e25daafbSMarcel Moolenaar 			error = (vp->v_type == VDIR) ? 0 : ENOTDIR;
345e25daafbSMarcel Moolenaar 			if (!error)
346e25daafbSMarcel Moolenaar 				error = vinvalbuf(vp, V_SAVE, 0, 0);
347e25daafbSMarcel Moolenaar 			if (!error) {
348e25daafbSMarcel Moolenaar 				cache_purge(vp);
349e25daafbSMarcel Moolenaar 				mporoot->mnt_vnodecovered = vp;
350e25daafbSMarcel Moolenaar 				vp->v_mountedhere = mporoot;
351e25daafbSMarcel Moolenaar 				strlcpy(mporoot->mnt_stat.f_mntonname,
352e25daafbSMarcel Moolenaar 				    fspath, MNAMELEN);
353e25daafbSMarcel Moolenaar 				VOP_UNLOCK(vp, 0);
354e25daafbSMarcel Moolenaar 			} else
355e25daafbSMarcel Moolenaar 				vput(vp);
35624e01f59SMarcel Moolenaar 		}
35724e01f59SMarcel Moolenaar 		NDFREE(&nd, NDF_ONLY_PNBUF);
35824e01f59SMarcel Moolenaar 
359ebc2f377SEdward Tomasz Napierala 		if (error)
360e25daafbSMarcel Moolenaar 			printf("mountroot: unable to remount previous root "
361ebc2f377SEdward Tomasz Napierala 			    "under /.mount or /mnt (error %d)\n", error);
362e25daafbSMarcel Moolenaar 	}
363e25daafbSMarcel Moolenaar 
364e25daafbSMarcel Moolenaar 	/* Remount devfs under /dev */
365e25daafbSMarcel Moolenaar 	NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_SYSSPACE, "/dev", td);
366e25daafbSMarcel Moolenaar 	error = namei(&nd);
367e25daafbSMarcel Moolenaar 	if (!error) {
368e25daafbSMarcel Moolenaar 		vp = nd.ni_vp;
369e25daafbSMarcel Moolenaar 		error = (vp->v_type == VDIR) ? 0 : ENOTDIR;
370e25daafbSMarcel Moolenaar 		if (!error)
371e25daafbSMarcel Moolenaar 			error = vinvalbuf(vp, V_SAVE, 0, 0);
372e25daafbSMarcel Moolenaar 		if (!error) {
373e25daafbSMarcel Moolenaar 			vpdevfs = mpdevfs->mnt_vnodecovered;
374e25daafbSMarcel Moolenaar 			if (vpdevfs != NULL) {
375e25daafbSMarcel Moolenaar 				cache_purge(vpdevfs);
376e25daafbSMarcel Moolenaar 				vpdevfs->v_mountedhere = NULL;
377e25daafbSMarcel Moolenaar 				vrele(vpdevfs);
378e25daafbSMarcel Moolenaar 			}
379e25daafbSMarcel Moolenaar 			mpdevfs->mnt_vnodecovered = vp;
380e25daafbSMarcel Moolenaar 			vp->v_mountedhere = mpdevfs;
381e25daafbSMarcel Moolenaar 			VOP_UNLOCK(vp, 0);
382e25daafbSMarcel Moolenaar 		} else
383e25daafbSMarcel Moolenaar 			vput(vp);
384e25daafbSMarcel Moolenaar 	}
385ebc2f377SEdward Tomasz Napierala 	if (error)
386e25daafbSMarcel Moolenaar 		printf("mountroot: unable to remount devfs under /dev "
387ebc2f377SEdward Tomasz Napierala 		    "(error %d)\n", error);
388e25daafbSMarcel Moolenaar 	NDFREE(&nd, NDF_ONLY_PNBUF);
389e25daafbSMarcel Moolenaar 
390e25daafbSMarcel Moolenaar 	if (mporoot == mpdevfs) {
391e25daafbSMarcel Moolenaar 		vfs_unbusy(mpdevfs);
39224e01f59SMarcel Moolenaar 		/* Unlink the no longer needed /dev/dev -> / symlink */
393a1304030SMariusz Zaborski 		error = kern_funlinkat(td, AT_FDCWD, "/dev/dev", FD_NONE,
3944f77f488SKonstantin Belousov 		    UIO_SYSSPACE, 0, 0);
395ebc2f377SEdward Tomasz Napierala 		if (error)
396e25daafbSMarcel Moolenaar 			printf("mountroot: unable to unlink /dev/dev "
397e25daafbSMarcel Moolenaar 			    "(error %d)\n", error);
398e25daafbSMarcel Moolenaar 	}
399e25daafbSMarcel Moolenaar }
400e25daafbSMarcel Moolenaar 
401e25daafbSMarcel Moolenaar /*
402e25daafbSMarcel Moolenaar  * Configuration parser.
403e25daafbSMarcel Moolenaar  */
404e25daafbSMarcel Moolenaar 
405e25daafbSMarcel Moolenaar /* Parser character classes. */
406e25daafbSMarcel Moolenaar #define	CC_WHITESPACE		-1
407e25daafbSMarcel Moolenaar #define	CC_NONWHITESPACE	-2
408e25daafbSMarcel Moolenaar 
409e25daafbSMarcel Moolenaar /* Parse errors. */
410e25daafbSMarcel Moolenaar #define	PE_EOF			-1
411e25daafbSMarcel Moolenaar #define	PE_EOL			-2
412e25daafbSMarcel Moolenaar 
413e25daafbSMarcel Moolenaar static __inline int
414e25daafbSMarcel Moolenaar parse_peek(char **conf)
415e25daafbSMarcel Moolenaar {
416e25daafbSMarcel Moolenaar 
417e25daafbSMarcel Moolenaar 	return (**conf);
418e25daafbSMarcel Moolenaar }
419e25daafbSMarcel Moolenaar 
420e25daafbSMarcel Moolenaar static __inline void
421e25daafbSMarcel Moolenaar parse_poke(char **conf, int c)
422e25daafbSMarcel Moolenaar {
423e25daafbSMarcel Moolenaar 
424e25daafbSMarcel Moolenaar 	**conf = c;
425e25daafbSMarcel Moolenaar }
426e25daafbSMarcel Moolenaar 
427e25daafbSMarcel Moolenaar static __inline void
428e25daafbSMarcel Moolenaar parse_advance(char **conf)
429e25daafbSMarcel Moolenaar {
430e25daafbSMarcel Moolenaar 
431e25daafbSMarcel Moolenaar 	(*conf)++;
432e25daafbSMarcel Moolenaar }
433e25daafbSMarcel Moolenaar 
434e25daafbSMarcel Moolenaar static int
435e25daafbSMarcel Moolenaar parse_skipto(char **conf, int mc)
436e25daafbSMarcel Moolenaar {
437e25daafbSMarcel Moolenaar 	int c, match;
438e25daafbSMarcel Moolenaar 
439e25daafbSMarcel Moolenaar 	while (1) {
440e25daafbSMarcel Moolenaar 		c = parse_peek(conf);
441e25daafbSMarcel Moolenaar 		if (c == 0)
442e25daafbSMarcel Moolenaar 			return (PE_EOF);
443e25daafbSMarcel Moolenaar 		switch (mc) {
444e25daafbSMarcel Moolenaar 		case CC_WHITESPACE:
445e25daafbSMarcel Moolenaar 			match = (c == ' ' || c == '\t' || c == '\n') ? 1 : 0;
446e25daafbSMarcel Moolenaar 			break;
447e25daafbSMarcel Moolenaar 		case CC_NONWHITESPACE:
448e25daafbSMarcel Moolenaar 			if (c == '\n')
449e25daafbSMarcel Moolenaar 				return (PE_EOL);
450e25daafbSMarcel Moolenaar 			match = (c != ' ' && c != '\t') ? 1 : 0;
451e25daafbSMarcel Moolenaar 			break;
452e25daafbSMarcel Moolenaar 		default:
453e25daafbSMarcel Moolenaar 			match = (c == mc) ? 1 : 0;
454e25daafbSMarcel Moolenaar 			break;
455e25daafbSMarcel Moolenaar 		}
456e25daafbSMarcel Moolenaar 		if (match)
457e25daafbSMarcel Moolenaar 			break;
458e25daafbSMarcel Moolenaar 		parse_advance(conf);
459e25daafbSMarcel Moolenaar 	}
460e25daafbSMarcel Moolenaar 	return (0);
461e25daafbSMarcel Moolenaar }
462e25daafbSMarcel Moolenaar 
463e25daafbSMarcel Moolenaar static int
464e25daafbSMarcel Moolenaar parse_token(char **conf, char **tok)
465e25daafbSMarcel Moolenaar {
466e25daafbSMarcel Moolenaar 	char *p;
467e25daafbSMarcel Moolenaar 	size_t len;
468e25daafbSMarcel Moolenaar 	int error;
469e25daafbSMarcel Moolenaar 
470e25daafbSMarcel Moolenaar 	*tok = NULL;
471e25daafbSMarcel Moolenaar 	error = parse_skipto(conf, CC_NONWHITESPACE);
47224e01f59SMarcel Moolenaar 	if (error)
473e25daafbSMarcel Moolenaar 		return (error);
474e25daafbSMarcel Moolenaar 	p = *conf;
475e25daafbSMarcel Moolenaar 	error = parse_skipto(conf, CC_WHITESPACE);
476e25daafbSMarcel Moolenaar 	len = *conf - p;
477e25daafbSMarcel Moolenaar 	*tok = malloc(len + 1, M_TEMP, M_WAITOK | M_ZERO);
478e25daafbSMarcel Moolenaar 	bcopy(p, *tok, len);
479e25daafbSMarcel Moolenaar 	return (0);
480e25daafbSMarcel Moolenaar }
481e25daafbSMarcel Moolenaar 
482e25daafbSMarcel Moolenaar static void
483e25daafbSMarcel Moolenaar parse_dir_ask_printenv(const char *var)
484e25daafbSMarcel Moolenaar {
485e25daafbSMarcel Moolenaar 	char *val;
486e25daafbSMarcel Moolenaar 
4872be111bfSDavide Italiano 	val = kern_getenv(var);
488e25daafbSMarcel Moolenaar 	if (val != NULL) {
489e25daafbSMarcel Moolenaar 		printf("  %s=%s\n", var, val);
490e25daafbSMarcel Moolenaar 		freeenv(val);
491e25daafbSMarcel Moolenaar 	}
492e25daafbSMarcel Moolenaar }
493e25daafbSMarcel Moolenaar 
494e25daafbSMarcel Moolenaar static int
495e25daafbSMarcel Moolenaar parse_dir_ask(char **conf)
496e25daafbSMarcel Moolenaar {
497e25daafbSMarcel Moolenaar 	char name[80];
498e25daafbSMarcel Moolenaar 	char *mnt;
499e25daafbSMarcel Moolenaar 	int error;
500e25daafbSMarcel Moolenaar 
50168d35798SEdward Tomasz Napierala 	vfs_mountroot_wait();
50268d35798SEdward Tomasz Napierala 
503e25daafbSMarcel Moolenaar 	printf("\nLoader variables:\n");
504e25daafbSMarcel Moolenaar 	parse_dir_ask_printenv("vfs.root.mountfrom");
505e25daafbSMarcel Moolenaar 	parse_dir_ask_printenv("vfs.root.mountfrom.options");
506e25daafbSMarcel Moolenaar 
507e25daafbSMarcel Moolenaar 	printf("\nManual root filesystem specification:\n");
508e25daafbSMarcel Moolenaar 	printf("  <fstype>:<device> [options]\n");
509e25daafbSMarcel Moolenaar 	printf("      Mount <device> using filesystem <fstype>\n");
510e25daafbSMarcel Moolenaar 	printf("      and with the specified (optional) option list.\n");
511e25daafbSMarcel Moolenaar 	printf("\n");
512e25daafbSMarcel Moolenaar 	printf("    eg. ufs:/dev/da0s1a\n");
513e77b6cfeSEdward Tomasz Napierala 	printf("        zfs:zroot/ROOT/default\n");
5143f18b7faSEnji Cooper 	printf("        cd9660:/dev/cd0 ro\n");
515e25daafbSMarcel Moolenaar 	printf("          (which is equivalent to: ");
5163f18b7faSEnji Cooper 	printf("mount -t cd9660 -o ro /dev/cd0 /)\n");
517e25daafbSMarcel Moolenaar 	printf("\n");
518e25daafbSMarcel Moolenaar 	printf("  ?               List valid disk boot devices\n");
519e25daafbSMarcel Moolenaar 	printf("  .               Yield 1 second (for background tasks)\n");
520e25daafbSMarcel Moolenaar 	printf("  <empty line>    Abort manual input\n");
521e25daafbSMarcel Moolenaar 
522421b7fe5SMarcel Moolenaar 	do {
523421b7fe5SMarcel Moolenaar 		error = EINVAL;
524e25daafbSMarcel Moolenaar 		printf("\nmountroot> ");
525f6ce353eSAndriy Gapon 		cngets(name, sizeof(name), GETS_ECHO);
526e25daafbSMarcel Moolenaar 		if (name[0] == '\0')
527421b7fe5SMarcel Moolenaar 			break;
528421b7fe5SMarcel Moolenaar 		if (name[0] == '?' && name[1] == '\0') {
529e25daafbSMarcel Moolenaar 			printf("\nList of GEOM managed disk devices:\n  ");
530e25daafbSMarcel Moolenaar 			g_dev_print();
531421b7fe5SMarcel Moolenaar 			continue;
532e25daafbSMarcel Moolenaar 		}
533421b7fe5SMarcel Moolenaar 		if (name[0] == '.' && name[1] == '\0') {
534e25daafbSMarcel Moolenaar 			pause("rmask", hz);
535421b7fe5SMarcel Moolenaar 			continue;
536e25daafbSMarcel Moolenaar 		}
537e25daafbSMarcel Moolenaar 		mnt = name;
538e25daafbSMarcel Moolenaar 		error = parse_mount(&mnt);
539421b7fe5SMarcel Moolenaar 		if (error == -1)
540421b7fe5SMarcel Moolenaar 			printf("Invalid file system specification.\n");
541421b7fe5SMarcel Moolenaar 	} while (error != 0);
542421b7fe5SMarcel Moolenaar 
543e25daafbSMarcel Moolenaar 	return (error);
544e25daafbSMarcel Moolenaar }
545e25daafbSMarcel Moolenaar 
546e25daafbSMarcel Moolenaar static int
547e25daafbSMarcel Moolenaar parse_dir_md(char **conf)
548e25daafbSMarcel Moolenaar {
549e25daafbSMarcel Moolenaar 	struct stat sb;
550e25daafbSMarcel Moolenaar 	struct thread *td;
551e25daafbSMarcel Moolenaar 	struct md_ioctl *mdio;
552e25daafbSMarcel Moolenaar 	char *path, *tok;
553e25daafbSMarcel Moolenaar 	int error, fd, len;
554e25daafbSMarcel Moolenaar 
555e25daafbSMarcel Moolenaar 	td = curthread;
556e25daafbSMarcel Moolenaar 
557e25daafbSMarcel Moolenaar 	error = parse_token(conf, &tok);
558e25daafbSMarcel Moolenaar 	if (error)
559e25daafbSMarcel Moolenaar 		return (error);
560e25daafbSMarcel Moolenaar 
561e25daafbSMarcel Moolenaar 	len = strlen(tok);
562e25daafbSMarcel Moolenaar 	mdio = malloc(sizeof(*mdio) + len + 1, M_TEMP, M_WAITOK | M_ZERO);
563e25daafbSMarcel Moolenaar 	path = (void *)(mdio + 1);
564e25daafbSMarcel Moolenaar 	bcopy(tok, path, len);
565e25daafbSMarcel Moolenaar 	free(tok, M_TEMP);
566e25daafbSMarcel Moolenaar 
567e25daafbSMarcel Moolenaar 	/* Get file status. */
5686e646651SKonstantin Belousov 	error = kern_statat(td, 0, AT_FDCWD, path, UIO_SYSSPACE, &sb, NULL);
569e25daafbSMarcel Moolenaar 	if (error)
570e25daafbSMarcel Moolenaar 		goto out;
571e25daafbSMarcel Moolenaar 
572e25daafbSMarcel Moolenaar 	/* Open /dev/mdctl so that we can attach/detach. */
5736e646651SKonstantin Belousov 	error = kern_openat(td, AT_FDCWD, "/dev/" MDCTL_NAME, UIO_SYSSPACE,
5746e646651SKonstantin Belousov 	    O_RDWR, 0);
575e25daafbSMarcel Moolenaar 	if (error)
576e25daafbSMarcel Moolenaar 		goto out;
577e25daafbSMarcel Moolenaar 
578e25daafbSMarcel Moolenaar 	fd = td->td_retval[0];
579e25daafbSMarcel Moolenaar 	mdio->md_version = MDIOVERSION;
580e25daafbSMarcel Moolenaar 	mdio->md_type = MD_VNODE;
581e25daafbSMarcel Moolenaar 
582e25daafbSMarcel Moolenaar 	if (root_mount_mddev != -1) {
583e25daafbSMarcel Moolenaar 		mdio->md_unit = root_mount_mddev;
584ad054101SMark Johnston 		(void)kern_ioctl(td, fd, MDIOCDETACH, (void *)mdio);
585e25daafbSMarcel Moolenaar 		/* Ignore errors. We don't care. */
586e25daafbSMarcel Moolenaar 		root_mount_mddev = -1;
587e25daafbSMarcel Moolenaar 	}
588e25daafbSMarcel Moolenaar 
589e25daafbSMarcel Moolenaar 	mdio->md_file = (void *)(mdio + 1);
590e25daafbSMarcel Moolenaar 	mdio->md_options = MD_AUTOUNIT | MD_READONLY;
591e25daafbSMarcel Moolenaar 	mdio->md_mediasize = sb.st_size;
592e25daafbSMarcel Moolenaar 	mdio->md_unit = 0;
593e25daafbSMarcel Moolenaar 	error = kern_ioctl(td, fd, MDIOCATTACH, (void *)mdio);
594e25daafbSMarcel Moolenaar 	if (error)
595e25daafbSMarcel Moolenaar 		goto out;
596e25daafbSMarcel Moolenaar 
597e25daafbSMarcel Moolenaar 	if (mdio->md_unit > 9) {
598e25daafbSMarcel Moolenaar 		printf("rootmount: too many md units\n");
599e25daafbSMarcel Moolenaar 		mdio->md_file = NULL;
600e25daafbSMarcel Moolenaar 		mdio->md_options = 0;
601e25daafbSMarcel Moolenaar 		mdio->md_mediasize = 0;
602e25daafbSMarcel Moolenaar 		error = kern_ioctl(td, fd, MDIOCDETACH, (void *)mdio);
603e25daafbSMarcel Moolenaar 		/* Ignore errors. We don't care. */
604e25daafbSMarcel Moolenaar 		error = ERANGE;
605e25daafbSMarcel Moolenaar 		goto out;
606e25daafbSMarcel Moolenaar 	}
607e25daafbSMarcel Moolenaar 
608e25daafbSMarcel Moolenaar 	root_mount_mddev = mdio->md_unit;
609e25daafbSMarcel Moolenaar 	printf(MD_NAME "%u attached to %s\n", root_mount_mddev, mdio->md_file);
610e25daafbSMarcel Moolenaar 
611e25daafbSMarcel Moolenaar 	error = kern_close(td, fd);
612e25daafbSMarcel Moolenaar 
613e25daafbSMarcel Moolenaar  out:
614e25daafbSMarcel Moolenaar 	free(mdio, M_TEMP);
615e25daafbSMarcel Moolenaar 	return (error);
616e25daafbSMarcel Moolenaar }
617e25daafbSMarcel Moolenaar 
618e25daafbSMarcel Moolenaar static int
619e25daafbSMarcel Moolenaar parse_dir_onfail(char **conf)
620e25daafbSMarcel Moolenaar {
621e25daafbSMarcel Moolenaar 	char *action;
622e25daafbSMarcel Moolenaar 	int error;
623e25daafbSMarcel Moolenaar 
624e25daafbSMarcel Moolenaar 	error = parse_token(conf, &action);
625e25daafbSMarcel Moolenaar 	if (error)
626e25daafbSMarcel Moolenaar 		return (error);
627e25daafbSMarcel Moolenaar 
628e25daafbSMarcel Moolenaar 	if (!strcmp(action, "continue"))
629e25daafbSMarcel Moolenaar 		root_mount_onfail = A_CONTINUE;
630e25daafbSMarcel Moolenaar 	else if (!strcmp(action, "panic"))
631e25daafbSMarcel Moolenaar 		root_mount_onfail = A_PANIC;
632e25daafbSMarcel Moolenaar 	else if (!strcmp(action, "reboot"))
633e25daafbSMarcel Moolenaar 		root_mount_onfail = A_REBOOT;
634e25daafbSMarcel Moolenaar 	else if (!strcmp(action, "retry"))
635e25daafbSMarcel Moolenaar 		root_mount_onfail = A_RETRY;
636e25daafbSMarcel Moolenaar 	else {
637e25daafbSMarcel Moolenaar 		printf("rootmount: %s: unknown action\n", action);
638e25daafbSMarcel Moolenaar 		error = EINVAL;
639e25daafbSMarcel Moolenaar 	}
640e25daafbSMarcel Moolenaar 
641e25daafbSMarcel Moolenaar 	free(action, M_TEMP);
642e25daafbSMarcel Moolenaar 	return (0);
643e25daafbSMarcel Moolenaar }
644e25daafbSMarcel Moolenaar 
645e25daafbSMarcel Moolenaar static int
646e25daafbSMarcel Moolenaar parse_dir_timeout(char **conf)
647e25daafbSMarcel Moolenaar {
648e25daafbSMarcel Moolenaar 	char *tok, *endtok;
649e25daafbSMarcel Moolenaar 	long secs;
650e25daafbSMarcel Moolenaar 	int error;
651e25daafbSMarcel Moolenaar 
652e25daafbSMarcel Moolenaar 	error = parse_token(conf, &tok);
653e25daafbSMarcel Moolenaar 	if (error)
654e25daafbSMarcel Moolenaar 		return (error);
655e25daafbSMarcel Moolenaar 
656e25daafbSMarcel Moolenaar 	secs = strtol(tok, &endtok, 0);
657e25daafbSMarcel Moolenaar 	error = (secs < 0 || *endtok != '\0') ? EINVAL : 0;
658e25daafbSMarcel Moolenaar 	if (!error)
659e25daafbSMarcel Moolenaar 		root_mount_timeout = secs;
660e25daafbSMarcel Moolenaar 	free(tok, M_TEMP);
661e25daafbSMarcel Moolenaar 	return (error);
662e25daafbSMarcel Moolenaar }
663e25daafbSMarcel Moolenaar 
664e25daafbSMarcel Moolenaar static int
665e25daafbSMarcel Moolenaar parse_directive(char **conf)
666e25daafbSMarcel Moolenaar {
667e25daafbSMarcel Moolenaar 	char *dir;
668e25daafbSMarcel Moolenaar 	int error;
669e25daafbSMarcel Moolenaar 
670e25daafbSMarcel Moolenaar 	error = parse_token(conf, &dir);
671e25daafbSMarcel Moolenaar 	if (error)
672e25daafbSMarcel Moolenaar 		return (error);
673e25daafbSMarcel Moolenaar 
674e25daafbSMarcel Moolenaar 	if (strcmp(dir, ".ask") == 0)
675e25daafbSMarcel Moolenaar 		error = parse_dir_ask(conf);
676e25daafbSMarcel Moolenaar 	else if (strcmp(dir, ".md") == 0)
677e25daafbSMarcel Moolenaar 		error = parse_dir_md(conf);
678e25daafbSMarcel Moolenaar 	else if (strcmp(dir, ".onfail") == 0)
679e25daafbSMarcel Moolenaar 		error = parse_dir_onfail(conf);
680e25daafbSMarcel Moolenaar 	else if (strcmp(dir, ".timeout") == 0)
681e25daafbSMarcel Moolenaar 		error = parse_dir_timeout(conf);
682e25daafbSMarcel Moolenaar 	else {
683e25daafbSMarcel Moolenaar 		printf("mountroot: invalid directive `%s'\n", dir);
684e25daafbSMarcel Moolenaar 		/* Ignore the rest of the line. */
685e25daafbSMarcel Moolenaar 		(void)parse_skipto(conf, '\n');
686e25daafbSMarcel Moolenaar 		error = EINVAL;
687e25daafbSMarcel Moolenaar 	}
688e25daafbSMarcel Moolenaar 	free(dir, M_TEMP);
689e25daafbSMarcel Moolenaar 	return (error);
690e25daafbSMarcel Moolenaar }
691e25daafbSMarcel Moolenaar 
692e25daafbSMarcel Moolenaar static int
693e25daafbSMarcel Moolenaar parse_mount_dev_present(const char *dev)
694e25daafbSMarcel Moolenaar {
695e25daafbSMarcel Moolenaar 	struct nameidata nd;
696e25daafbSMarcel Moolenaar 	int error;
697e25daafbSMarcel Moolenaar 
698e25daafbSMarcel Moolenaar 	NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_SYSSPACE, dev, curthread);
699e25daafbSMarcel Moolenaar 	error = namei(&nd);
700e25daafbSMarcel Moolenaar 	if (!error)
701e25daafbSMarcel Moolenaar 		vput(nd.ni_vp);
702e25daafbSMarcel Moolenaar 	NDFREE(&nd, NDF_ONLY_PNBUF);
703e25daafbSMarcel Moolenaar 	return (error != 0) ? 0 : 1;
704e25daafbSMarcel Moolenaar }
705e25daafbSMarcel Moolenaar 
7069bdf6ccaSKonstantin Belousov #define	ERRMSGL	255
707e25daafbSMarcel Moolenaar static int
708e25daafbSMarcel Moolenaar parse_mount(char **conf)
709e25daafbSMarcel Moolenaar {
7109bdf6ccaSKonstantin Belousov 	char *errmsg;
711e25daafbSMarcel Moolenaar 	struct mntarg *ma;
712e25daafbSMarcel Moolenaar 	char *dev, *fs, *opts, *tok;
71372721cafSIan Lepore 	int delay, error, timeout;
714e25daafbSMarcel Moolenaar 
715e25daafbSMarcel Moolenaar 	error = parse_token(conf, &tok);
716e25daafbSMarcel Moolenaar 	if (error)
717e25daafbSMarcel Moolenaar 		return (error);
718e25daafbSMarcel Moolenaar 	fs = tok;
719e25daafbSMarcel Moolenaar 	error = parse_skipto(&tok, ':');
720e25daafbSMarcel Moolenaar 	if (error) {
721e25daafbSMarcel Moolenaar 		free(fs, M_TEMP);
722e25daafbSMarcel Moolenaar 		return (error);
723e25daafbSMarcel Moolenaar 	}
724e25daafbSMarcel Moolenaar 	parse_poke(&tok, '\0');
725e25daafbSMarcel Moolenaar 	parse_advance(&tok);
726e25daafbSMarcel Moolenaar 	dev = tok;
727e25daafbSMarcel Moolenaar 
728e25daafbSMarcel Moolenaar 	if (root_mount_mddev != -1) {
729e25daafbSMarcel Moolenaar 		/* Handle substitution for the md unit number. */
730e25daafbSMarcel Moolenaar 		tok = strstr(dev, "md#");
731e25daafbSMarcel Moolenaar 		if (tok != NULL)
732e25daafbSMarcel Moolenaar 			tok[2] = '0' + root_mount_mddev;
733e25daafbSMarcel Moolenaar 	}
734e25daafbSMarcel Moolenaar 
735e25daafbSMarcel Moolenaar 	/* Parse options. */
736e25daafbSMarcel Moolenaar 	error = parse_token(conf, &tok);
737e25daafbSMarcel Moolenaar 	opts = (error == 0) ? tok : NULL;
738e25daafbSMarcel Moolenaar 
739e25daafbSMarcel Moolenaar 	printf("Trying to mount root from %s:%s [%s]...\n", fs, dev,
740e25daafbSMarcel Moolenaar 	    (opts != NULL) ? opts : "");
741e25daafbSMarcel Moolenaar 
7429bdf6ccaSKonstantin Belousov 	errmsg = malloc(ERRMSGL, M_TEMP, M_WAITOK | M_ZERO);
743e25daafbSMarcel Moolenaar 
744e25daafbSMarcel Moolenaar 	if (vfs_byname(fs) == NULL) {
74522ecadc0SXin LI 		strlcpy(errmsg, "unknown file system", ERRMSGL);
746e25daafbSMarcel Moolenaar 		error = ENOENT;
747e25daafbSMarcel Moolenaar 		goto out;
748e25daafbSMarcel Moolenaar 	}
749e25daafbSMarcel Moolenaar 
750a3ba3d09SEdward Tomasz Napierala 	error = vfs_mountroot_wait_if_neccessary(fs, dev);
751a3ba3d09SEdward Tomasz Napierala 	if (error != 0)
752e25daafbSMarcel Moolenaar 		goto out;
753e25daafbSMarcel Moolenaar 
75472721cafSIan Lepore 	delay = hz / 10;
75572721cafSIan Lepore 	timeout = root_mount_timeout * hz;
75672721cafSIan Lepore 
75772721cafSIan Lepore 	for (;;) {
758e25daafbSMarcel Moolenaar 		ma = NULL;
759e25daafbSMarcel Moolenaar 		ma = mount_arg(ma, "fstype", fs, -1);
760e25daafbSMarcel Moolenaar 		ma = mount_arg(ma, "fspath", "/", -1);
761e25daafbSMarcel Moolenaar 		ma = mount_arg(ma, "from", dev, -1);
7629bdf6ccaSKonstantin Belousov 		ma = mount_arg(ma, "errmsg", errmsg, ERRMSGL);
763e25daafbSMarcel Moolenaar 		ma = mount_arg(ma, "ro", NULL, 0);
764e25daafbSMarcel Moolenaar 		ma = parse_mountroot_options(ma, opts);
765e25daafbSMarcel Moolenaar 
76672721cafSIan Lepore 		error = kernel_mount(ma, MNT_ROOTFS);
76772721cafSIan Lepore 		if (error == 0 || timeout <= 0)
76872721cafSIan Lepore 			break;
76972721cafSIan Lepore 
77072721cafSIan Lepore 		if (root_mount_timeout * hz == timeout ||
77172721cafSIan Lepore 		    (bootverbose && timeout % hz == 0)) {
77272721cafSIan Lepore 			printf("Mounting from %s:%s failed with error %d; "
77372721cafSIan Lepore 			    "retrying for %d more second%s\n", fs, dev, error,
77472721cafSIan Lepore 			    timeout / hz, (timeout / hz > 1) ? "s" : "");
77572721cafSIan Lepore 		}
77672721cafSIan Lepore 		pause("rmretry", delay);
77772721cafSIan Lepore 		timeout -= delay;
77872721cafSIan Lepore 	}
779e25daafbSMarcel Moolenaar  out:
780e25daafbSMarcel Moolenaar 	if (error) {
781e25daafbSMarcel Moolenaar 		printf("Mounting from %s:%s failed with error %d",
782e25daafbSMarcel Moolenaar 		    fs, dev, error);
783e25daafbSMarcel Moolenaar 		if (errmsg[0] != '\0')
784e25daafbSMarcel Moolenaar 			printf(": %s", errmsg);
785e25daafbSMarcel Moolenaar 		printf(".\n");
786e25daafbSMarcel Moolenaar 	}
787e25daafbSMarcel Moolenaar 	free(fs, M_TEMP);
7889bdf6ccaSKonstantin Belousov 	free(errmsg, M_TEMP);
789e25daafbSMarcel Moolenaar 	if (opts != NULL)
790e25daafbSMarcel Moolenaar 		free(opts, M_TEMP);
791e25daafbSMarcel Moolenaar 	/* kernel_mount can return -1 on error. */
792e25daafbSMarcel Moolenaar 	return ((error < 0) ? EDOOFUS : error);
793e25daafbSMarcel Moolenaar }
7949bdf6ccaSKonstantin Belousov #undef ERRMSGL
795e25daafbSMarcel Moolenaar 
796e25daafbSMarcel Moolenaar static int
797e25daafbSMarcel Moolenaar vfs_mountroot_parse(struct sbuf *sb, struct mount *mpdevfs)
798e25daafbSMarcel Moolenaar {
799e25daafbSMarcel Moolenaar 	struct mount *mp;
800e25daafbSMarcel Moolenaar 	char *conf;
801e25daafbSMarcel Moolenaar 	int error;
802e25daafbSMarcel Moolenaar 
803e25daafbSMarcel Moolenaar 	root_mount_mddev = -1;
804e25daafbSMarcel Moolenaar 
805e25daafbSMarcel Moolenaar retry:
806e25daafbSMarcel Moolenaar 	conf = sbuf_data(sb);
807e25daafbSMarcel Moolenaar 	mp = TAILQ_NEXT(mpdevfs, mnt_list);
808e25daafbSMarcel Moolenaar 	error = (mp == NULL) ? 0 : EDOOFUS;
809e25daafbSMarcel Moolenaar 	root_mount_onfail = A_CONTINUE;
810e25daafbSMarcel Moolenaar 	while (mp == NULL) {
811e25daafbSMarcel Moolenaar 		error = parse_skipto(&conf, CC_NONWHITESPACE);
812e25daafbSMarcel Moolenaar 		if (error == PE_EOL) {
813e25daafbSMarcel Moolenaar 			parse_advance(&conf);
814e25daafbSMarcel Moolenaar 			continue;
815e25daafbSMarcel Moolenaar 		}
816e25daafbSMarcel Moolenaar 		if (error < 0)
817e25daafbSMarcel Moolenaar 			break;
818e25daafbSMarcel Moolenaar 		switch (parse_peek(&conf)) {
819e25daafbSMarcel Moolenaar 		case '#':
820e25daafbSMarcel Moolenaar 			error = parse_skipto(&conf, '\n');
821e25daafbSMarcel Moolenaar 			break;
822e25daafbSMarcel Moolenaar 		case '.':
823e25daafbSMarcel Moolenaar 			error = parse_directive(&conf);
824e25daafbSMarcel Moolenaar 			break;
825e25daafbSMarcel Moolenaar 		default:
826e25daafbSMarcel Moolenaar 			error = parse_mount(&conf);
827898b5104SMarcel Moolenaar 			if (error == -1) {
828898b5104SMarcel Moolenaar 				printf("mountroot: invalid file system "
829898b5104SMarcel Moolenaar 				    "specification.\n");
830898b5104SMarcel Moolenaar 				error = 0;
831898b5104SMarcel Moolenaar 			}
832e25daafbSMarcel Moolenaar 			break;
833e25daafbSMarcel Moolenaar 		}
834e25daafbSMarcel Moolenaar 		if (error < 0)
835e25daafbSMarcel Moolenaar 			break;
836e25daafbSMarcel Moolenaar 		/* Ignore any trailing garbage on the line. */
837e25daafbSMarcel Moolenaar 		if (parse_peek(&conf) != '\n') {
838e25daafbSMarcel Moolenaar 			printf("mountroot: advancing to next directive...\n");
839e25daafbSMarcel Moolenaar 			(void)parse_skipto(&conf, '\n');
840e25daafbSMarcel Moolenaar 		}
841e25daafbSMarcel Moolenaar 		mp = TAILQ_NEXT(mpdevfs, mnt_list);
842e25daafbSMarcel Moolenaar 	}
843e25daafbSMarcel Moolenaar 	if (mp != NULL)
844e25daafbSMarcel Moolenaar 		return (0);
845e25daafbSMarcel Moolenaar 
846e25daafbSMarcel Moolenaar 	/*
847e25daafbSMarcel Moolenaar 	 * We failed to mount (a new) root.
848e25daafbSMarcel Moolenaar 	 */
849e25daafbSMarcel Moolenaar 	switch (root_mount_onfail) {
850e25daafbSMarcel Moolenaar 	case A_CONTINUE:
851e25daafbSMarcel Moolenaar 		break;
852e25daafbSMarcel Moolenaar 	case A_PANIC:
853e25daafbSMarcel Moolenaar 		panic("mountroot: unable to (re-)mount root.");
854e25daafbSMarcel Moolenaar 		/* NOTREACHED */
855e25daafbSMarcel Moolenaar 	case A_RETRY:
856e25daafbSMarcel Moolenaar 		goto retry;
857e25daafbSMarcel Moolenaar 	case A_REBOOT:
858e25daafbSMarcel Moolenaar 		kern_reboot(RB_NOSYNC);
859e25daafbSMarcel Moolenaar 		/* NOTREACHED */
860e25daafbSMarcel Moolenaar 	}
861e25daafbSMarcel Moolenaar 
862e25daafbSMarcel Moolenaar 	return (error);
863e25daafbSMarcel Moolenaar }
864e25daafbSMarcel Moolenaar 
865e25daafbSMarcel Moolenaar static void
866e25daafbSMarcel Moolenaar vfs_mountroot_conf0(struct sbuf *sb)
867e25daafbSMarcel Moolenaar {
868e25daafbSMarcel Moolenaar 	char *s, *tok, *mnt, *opt;
869e25daafbSMarcel Moolenaar 	int error;
870e25daafbSMarcel Moolenaar 
871e25daafbSMarcel Moolenaar 	sbuf_printf(sb, ".onfail panic\n");
872e25daafbSMarcel Moolenaar 	sbuf_printf(sb, ".timeout %d\n", root_mount_timeout);
873e25daafbSMarcel Moolenaar 	if (boothowto & RB_ASKNAME)
874e25daafbSMarcel Moolenaar 		sbuf_printf(sb, ".ask\n");
875e25daafbSMarcel Moolenaar #ifdef ROOTDEVNAME
876e25daafbSMarcel Moolenaar 	if (boothowto & RB_DFLTROOT)
877e25daafbSMarcel Moolenaar 		sbuf_printf(sb, "%s\n", ROOTDEVNAME);
878e25daafbSMarcel Moolenaar #endif
879e25daafbSMarcel Moolenaar 	if (boothowto & RB_CDROM) {
880083cfea1SNathan Whitehorn 		sbuf_printf(sb, "cd9660:/dev/cd0 ro\n");
881e25daafbSMarcel Moolenaar 		sbuf_printf(sb, ".timeout 0\n");
8823f18b7faSEnji Cooper 		sbuf_printf(sb, "cd9660:/dev/cd1 ro\n");
883e25daafbSMarcel Moolenaar 		sbuf_printf(sb, ".timeout %d\n", root_mount_timeout);
884e25daafbSMarcel Moolenaar 	}
8852be111bfSDavide Italiano 	s = kern_getenv("vfs.root.mountfrom");
886e25daafbSMarcel Moolenaar 	if (s != NULL) {
8872be111bfSDavide Italiano 		opt = kern_getenv("vfs.root.mountfrom.options");
888e25daafbSMarcel Moolenaar 		tok = s;
889e25daafbSMarcel Moolenaar 		error = parse_token(&tok, &mnt);
890e25daafbSMarcel Moolenaar 		while (!error) {
891e25daafbSMarcel Moolenaar 			sbuf_printf(sb, "%s %s\n", mnt,
892e25daafbSMarcel Moolenaar 			    (opt != NULL) ? opt : "");
893e25daafbSMarcel Moolenaar 			free(mnt, M_TEMP);
894e25daafbSMarcel Moolenaar 			error = parse_token(&tok, &mnt);
895e25daafbSMarcel Moolenaar 		}
896e25daafbSMarcel Moolenaar 		if (opt != NULL)
897e25daafbSMarcel Moolenaar 			freeenv(opt);
898e25daafbSMarcel Moolenaar 		freeenv(s);
899e25daafbSMarcel Moolenaar 	}
900e25daafbSMarcel Moolenaar 	if (rootdevnames[0] != NULL)
901e25daafbSMarcel Moolenaar 		sbuf_printf(sb, "%s\n", rootdevnames[0]);
902e25daafbSMarcel Moolenaar 	if (rootdevnames[1] != NULL)
903e25daafbSMarcel Moolenaar 		sbuf_printf(sb, "%s\n", rootdevnames[1]);
904e25daafbSMarcel Moolenaar #ifdef ROOTDEVNAME
905e25daafbSMarcel Moolenaar 	if (!(boothowto & RB_DFLTROOT))
906e25daafbSMarcel Moolenaar 		sbuf_printf(sb, "%s\n", ROOTDEVNAME);
907e25daafbSMarcel Moolenaar #endif
908e25daafbSMarcel Moolenaar 	if (!(boothowto & RB_ASKNAME))
909e25daafbSMarcel Moolenaar 		sbuf_printf(sb, ".ask\n");
910e25daafbSMarcel Moolenaar }
911e25daafbSMarcel Moolenaar 
912e25daafbSMarcel Moolenaar static int
913e25daafbSMarcel Moolenaar vfs_mountroot_readconf(struct thread *td, struct sbuf *sb)
914e25daafbSMarcel Moolenaar {
915e25daafbSMarcel Moolenaar 	static char buf[128];
916e25daafbSMarcel Moolenaar 	struct nameidata nd;
917e25daafbSMarcel Moolenaar 	off_t ofs;
918526d0bd5SKonstantin Belousov 	ssize_t resid;
9195050aa86SKonstantin Belousov 	int error, flags, len;
920e25daafbSMarcel Moolenaar 
9215050aa86SKonstantin Belousov 	NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, "/.mount.conf", td);
922e25daafbSMarcel Moolenaar 	flags = FREAD;
923e25daafbSMarcel Moolenaar 	error = vn_open(&nd, &flags, 0, NULL);
924e25daafbSMarcel Moolenaar 	if (error)
925e25daafbSMarcel Moolenaar 		return (error);
926e25daafbSMarcel Moolenaar 
927e25daafbSMarcel Moolenaar 	NDFREE(&nd, NDF_ONLY_PNBUF);
928e25daafbSMarcel Moolenaar 	ofs = 0;
929e25daafbSMarcel Moolenaar 	len = sizeof(buf) - 1;
930e25daafbSMarcel Moolenaar 	while (1) {
931e25daafbSMarcel Moolenaar 		error = vn_rdwr(UIO_READ, nd.ni_vp, buf, len, ofs,
932e25daafbSMarcel Moolenaar 		    UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred,
933e25daafbSMarcel Moolenaar 		    NOCRED, &resid, td);
934e25daafbSMarcel Moolenaar 		if (error)
935e25daafbSMarcel Moolenaar 			break;
936e25daafbSMarcel Moolenaar 		if (resid == len)
937e25daafbSMarcel Moolenaar 			break;
938e25daafbSMarcel Moolenaar 		buf[len - resid] = 0;
939e25daafbSMarcel Moolenaar 		sbuf_printf(sb, "%s", buf);
940e25daafbSMarcel Moolenaar 		ofs += len - resid;
941e25daafbSMarcel Moolenaar 	}
942e25daafbSMarcel Moolenaar 
943e25daafbSMarcel Moolenaar 	VOP_UNLOCK(nd.ni_vp, 0);
944e25daafbSMarcel Moolenaar 	vn_close(nd.ni_vp, FREAD, td->td_ucred, td);
945e25daafbSMarcel Moolenaar 	return (error);
946e25daafbSMarcel Moolenaar }
947e25daafbSMarcel Moolenaar 
948e25daafbSMarcel Moolenaar static void
949e25daafbSMarcel Moolenaar vfs_mountroot_wait(void)
950e25daafbSMarcel Moolenaar {
951e25daafbSMarcel Moolenaar 	struct root_hold_token *h;
952e25daafbSMarcel Moolenaar 	struct timeval lastfail;
953e25daafbSMarcel Moolenaar 	int curfail;
954e25daafbSMarcel Moolenaar 
9556032e088SColin Percival 	TSENTER();
9566032e088SColin Percival 
957e25daafbSMarcel Moolenaar 	curfail = 0;
958e25daafbSMarcel Moolenaar 	while (1) {
959e25daafbSMarcel Moolenaar 		g_waitidle();
960eb6d6216SAlexander Motin 		mtx_lock(&root_holds_mtx);
961e25daafbSMarcel Moolenaar 		if (LIST_EMPTY(&root_holds)) {
962eb6d6216SAlexander Motin 			mtx_unlock(&root_holds_mtx);
963e25daafbSMarcel Moolenaar 			break;
964e25daafbSMarcel Moolenaar 		}
965e25daafbSMarcel Moolenaar 		if (ppsratecheck(&lastfail, &curfail, 1)) {
966e25daafbSMarcel Moolenaar 			printf("Root mount waiting for:");
967e25daafbSMarcel Moolenaar 			LIST_FOREACH(h, &root_holds, list)
968e25daafbSMarcel Moolenaar 				printf(" %s", h->who);
969e25daafbSMarcel Moolenaar 			printf("\n");
970e25daafbSMarcel Moolenaar 		}
9718b8a7c43SColin Percival 		TSWAIT("root mount");
972eb6d6216SAlexander Motin 		msleep(&root_holds, &root_holds_mtx, PZERO | PDROP, "roothold",
973e25daafbSMarcel Moolenaar 		    hz);
9748b8a7c43SColin Percival 		TSUNWAIT("root mount");
975e25daafbSMarcel Moolenaar 	}
9766032e088SColin Percival 
9776032e088SColin Percival 	TSEXIT();
97824e01f59SMarcel Moolenaar }
97924e01f59SMarcel Moolenaar 
980a3ba3d09SEdward Tomasz Napierala static int
981a3ba3d09SEdward Tomasz Napierala vfs_mountroot_wait_if_neccessary(const char *fs, const char *dev)
982a3ba3d09SEdward Tomasz Napierala {
983a3ba3d09SEdward Tomasz Napierala 	int delay, timeout;
984a3ba3d09SEdward Tomasz Napierala 
985a3ba3d09SEdward Tomasz Napierala 	/*
986a3ba3d09SEdward Tomasz Napierala 	 * In case of ZFS and NFS we don't have a way to wait for
9874f9d7badSEdward Tomasz Napierala 	 * specific device.  Also do the wait if the user forced that
9884f9d7badSEdward Tomasz Napierala 	 * behaviour by setting vfs.root_mount_always_wait=1.
989a3ba3d09SEdward Tomasz Napierala 	 */
990a3ba3d09SEdward Tomasz Napierala 	if (strcmp(fs, "zfs") == 0 || strstr(fs, "nfs") != NULL ||
9914f9d7badSEdward Tomasz Napierala 	    dev[0] == '\0' || root_mount_always_wait != 0) {
992a3ba3d09SEdward Tomasz Napierala 		vfs_mountroot_wait();
993a3ba3d09SEdward Tomasz Napierala 		return (0);
994a3ba3d09SEdward Tomasz Napierala 	}
995a3ba3d09SEdward Tomasz Napierala 
996a3ba3d09SEdward Tomasz Napierala 	/*
997a3ba3d09SEdward Tomasz Napierala 	 * Otherwise, no point in waiting if the device is already there.
998a3ba3d09SEdward Tomasz Napierala 	 * Note that we must wait for GEOM to finish reconfiguring itself,
999a3ba3d09SEdward Tomasz Napierala 	 * eg for geom_part(4) to finish tasting.
1000a3ba3d09SEdward Tomasz Napierala 	 */
1001a3ba3d09SEdward Tomasz Napierala 	g_waitidle();
1002a3ba3d09SEdward Tomasz Napierala 	if (parse_mount_dev_present(dev))
1003a3ba3d09SEdward Tomasz Napierala 		return (0);
1004a3ba3d09SEdward Tomasz Napierala 
1005a3ba3d09SEdward Tomasz Napierala 	/*
1006a3ba3d09SEdward Tomasz Napierala 	 * No luck.  Let's wait.  This code looks weird, but it's that way
1007a3ba3d09SEdward Tomasz Napierala 	 * to behave exactly as it used to work before.
1008a3ba3d09SEdward Tomasz Napierala 	 */
1009a3ba3d09SEdward Tomasz Napierala 	vfs_mountroot_wait();
1010a3ba3d09SEdward Tomasz Napierala 	printf("mountroot: waiting for device %s...\n", dev);
1011a3ba3d09SEdward Tomasz Napierala 	delay = hz / 10;
1012a3ba3d09SEdward Tomasz Napierala 	timeout = root_mount_timeout * hz;
1013a3ba3d09SEdward Tomasz Napierala 	do {
1014a3ba3d09SEdward Tomasz Napierala 		pause("rmdev", delay);
1015a3ba3d09SEdward Tomasz Napierala 		timeout -= delay;
1016a3ba3d09SEdward Tomasz Napierala 	} while (timeout > 0 && !parse_mount_dev_present(dev));
1017a3ba3d09SEdward Tomasz Napierala 
1018a3ba3d09SEdward Tomasz Napierala 	if (timeout <= 0)
1019a3ba3d09SEdward Tomasz Napierala 		return (ENODEV);
1020a3ba3d09SEdward Tomasz Napierala 
1021a3ba3d09SEdward Tomasz Napierala 	return (0);
1022a3ba3d09SEdward Tomasz Napierala }
1023a3ba3d09SEdward Tomasz Napierala 
102424e01f59SMarcel Moolenaar void
102524e01f59SMarcel Moolenaar vfs_mountroot(void)
102624e01f59SMarcel Moolenaar {
1027e25daafbSMarcel Moolenaar 	struct mount *mp;
1028e25daafbSMarcel Moolenaar 	struct sbuf *sb;
1029e25daafbSMarcel Moolenaar 	struct thread *td;
1030e25daafbSMarcel Moolenaar 	time_t timebase;
1031e25daafbSMarcel Moolenaar 	int error;
103224e01f59SMarcel Moolenaar 
1033d5292812SWarner Losh 	mtx_assert(&Giant, MA_NOTOWNED);
1034d5292812SWarner Losh 
10356032e088SColin Percival 	TSENTER();
10366032e088SColin Percival 
1037e25daafbSMarcel Moolenaar 	td = curthread;
103824e01f59SMarcel Moolenaar 
1039e25daafbSMarcel Moolenaar 	sb = sbuf_new_auto();
1040e25daafbSMarcel Moolenaar 	vfs_mountroot_conf0(sb);
1041e25daafbSMarcel Moolenaar 	sbuf_finish(sb);
104224e01f59SMarcel Moolenaar 
1043e25daafbSMarcel Moolenaar 	error = vfs_mountroot_devfs(td, &mp);
1044e25daafbSMarcel Moolenaar 	while (!error) {
1045e25daafbSMarcel Moolenaar 		error = vfs_mountroot_parse(sb, mp);
1046e25daafbSMarcel Moolenaar 		if (!error) {
10476c5c24c9SBryan Drewery 			vfs_mountroot_shuffle(td, mp);
1048e25daafbSMarcel Moolenaar 			sbuf_clear(sb);
1049e25daafbSMarcel Moolenaar 			error = vfs_mountroot_readconf(td, sb);
1050e25daafbSMarcel Moolenaar 			sbuf_finish(sb);
105124e01f59SMarcel Moolenaar 		}
105224e01f59SMarcel Moolenaar 	}
105324e01f59SMarcel Moolenaar 
1054e25daafbSMarcel Moolenaar 	sbuf_delete(sb);
1055e25daafbSMarcel Moolenaar 
105624e01f59SMarcel Moolenaar 	/*
1057e25daafbSMarcel Moolenaar 	 * Iterate over all currently mounted file systems and use
1058e25daafbSMarcel Moolenaar 	 * the time stamp found to check and/or initialize the RTC.
1059e25daafbSMarcel Moolenaar 	 * Call inittodr() only once and pass it the largest of the
1060e25daafbSMarcel Moolenaar 	 * timestamps we encounter.
106124e01f59SMarcel Moolenaar 	 */
1062e25daafbSMarcel Moolenaar 	timebase = 0;
1063e25daafbSMarcel Moolenaar 	mtx_lock(&mountlist_mtx);
1064e25daafbSMarcel Moolenaar 	mp = TAILQ_FIRST(&mountlist);
1065e25daafbSMarcel Moolenaar 	while (mp != NULL) {
1066e25daafbSMarcel Moolenaar 		if (mp->mnt_time > timebase)
1067e25daafbSMarcel Moolenaar 			timebase = mp->mnt_time;
1068e25daafbSMarcel Moolenaar 		mp = TAILQ_NEXT(mp, mnt_list);
106924e01f59SMarcel Moolenaar 	}
1070e25daafbSMarcel Moolenaar 	mtx_unlock(&mountlist_mtx);
1071e25daafbSMarcel Moolenaar 	inittodr(timebase);
107224e01f59SMarcel Moolenaar 
1073e25daafbSMarcel Moolenaar 	/* Keep prison0's root in sync with the global rootvnode. */
1074e25daafbSMarcel Moolenaar 	mtx_lock(&prison0.pr_mtx);
1075e25daafbSMarcel Moolenaar 	prison0.pr_root = rootvnode;
1076e25daafbSMarcel Moolenaar 	vref(prison0.pr_root);
1077e25daafbSMarcel Moolenaar 	mtx_unlock(&prison0.pr_mtx);
107824e01f59SMarcel Moolenaar 
1079eb6d6216SAlexander Motin 	mtx_lock(&root_holds_mtx);
1080e25daafbSMarcel Moolenaar 	atomic_store_rel_int(&root_mount_complete, 1);
1081e25daafbSMarcel Moolenaar 	wakeup(&root_mount_complete);
1082eb6d6216SAlexander Motin 	mtx_unlock(&root_holds_mtx);
1083ca84e042SAndriy Gapon 
1084ca84e042SAndriy Gapon 	EVENTHANDLER_INVOKE(mountroot);
10856032e088SColin Percival 
10866032e088SColin Percival 	TSEXIT();
108724e01f59SMarcel Moolenaar }
108824e01f59SMarcel Moolenaar 
108924e01f59SMarcel Moolenaar static struct mntarg *
109024e01f59SMarcel Moolenaar parse_mountroot_options(struct mntarg *ma, const char *options)
109124e01f59SMarcel Moolenaar {
109224e01f59SMarcel Moolenaar 	char *p;
109324e01f59SMarcel Moolenaar 	char *name, *name_arg;
109424e01f59SMarcel Moolenaar 	char *val, *val_arg;
109524e01f59SMarcel Moolenaar 	char *opts;
109624e01f59SMarcel Moolenaar 
109724e01f59SMarcel Moolenaar 	if (options == NULL || options[0] == '\0')
109824e01f59SMarcel Moolenaar 		return (ma);
109924e01f59SMarcel Moolenaar 
110024e01f59SMarcel Moolenaar 	p = opts = strdup(options, M_MOUNT);
110124e01f59SMarcel Moolenaar 	if (opts == NULL) {
110224e01f59SMarcel Moolenaar 		return (ma);
110324e01f59SMarcel Moolenaar 	}
110424e01f59SMarcel Moolenaar 
110524e01f59SMarcel Moolenaar 	while((name = strsep(&p, ",")) != NULL) {
110624e01f59SMarcel Moolenaar 		if (name[0] == '\0')
110724e01f59SMarcel Moolenaar 			break;
110824e01f59SMarcel Moolenaar 
110924e01f59SMarcel Moolenaar 		val = strchr(name, '=');
111024e01f59SMarcel Moolenaar 		if (val != NULL) {
111124e01f59SMarcel Moolenaar 			*val = '\0';
111224e01f59SMarcel Moolenaar 			++val;
111324e01f59SMarcel Moolenaar 		}
111424e01f59SMarcel Moolenaar 		if( strcmp(name, "rw") == 0 ||
111524e01f59SMarcel Moolenaar 		    strcmp(name, "noro") == 0) {
111624e01f59SMarcel Moolenaar 			/*
111724e01f59SMarcel Moolenaar 			 * The first time we mount the root file system,
111824e01f59SMarcel Moolenaar 			 * we need to mount 'ro', so We need to ignore
111924e01f59SMarcel Moolenaar 			 * 'rw' and 'noro' mount options.
112024e01f59SMarcel Moolenaar 			 */
112124e01f59SMarcel Moolenaar 			continue;
112224e01f59SMarcel Moolenaar 		}
112324e01f59SMarcel Moolenaar 		name_arg = strdup(name, M_MOUNT);
112424e01f59SMarcel Moolenaar 		val_arg = NULL;
112524e01f59SMarcel Moolenaar 		if (val != NULL)
112624e01f59SMarcel Moolenaar 			val_arg = strdup(val, M_MOUNT);
112724e01f59SMarcel Moolenaar 
112824e01f59SMarcel Moolenaar 		ma = mount_arg(ma, name_arg, val_arg,
112924e01f59SMarcel Moolenaar 		    (val_arg != NULL ? -1 : 0));
113024e01f59SMarcel Moolenaar 	}
113124e01f59SMarcel Moolenaar 	free(opts, M_MOUNT);
113224e01f59SMarcel Moolenaar 	return (ma);
113324e01f59SMarcel Moolenaar }
1134