This is a complete rewrite of vfs_conf.c, which changes the way the root

filesystem is discovered.  Preference is given to using the kernel
environment variable vfs.root.mountfrom, which is set by the loader
according to the contents of /etc/fstab.  Changes in the MD code
provide fallback mechanisms for systems not using the loader.

A more robust fallback path is also provided, with the last recourse
being to prompt on the console for a root device.

These changes drastically simplify the machine-dependant parts of
the root configuration process.  In addition, support for CDROM root
devices has been removed; it was a nasty hack and didn't work.

1 files changed, 270 insertions, 158 deletions

diff --git a/sys/kern/vfs_mount.c b/sys/kern/vfs_mount.c
index 7c11af72172f..2de291fc01de 100644
--- a/sys/kern/vfs_mount.c
+++ b/sys/kern/vfs_mount.c
@@ -1,7 +1,8 @@
-/*
- * Copyright (c) 1989, 1993, 1995
- *	The Regents of the University of California.  All rights reserved.
- * Copyright (c) 1995 Artisoft, Inc.  All Rights Reserved.
+/*-
+ * Copyright (c) 1999 Michael Smith
+ * All rights reserved.
+ * Copyright (c) 1999 Poul-Henning Kamp
+ * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -11,18 +12,11 @@
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
@@ -31,184 +25,302 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- *	@(#)vfs_conf.c	8.8 (Berkeley) 3/31/94
- * $FreeBSD$
+ *	$FreeBSD$
  */
 
 /*
- * PURPOSE:	This file abstracts the root mounting interface from
- *		the per file system semantics for handling mounts,
- *		the overall intent of which is to move the BSD
- *		internals dependence out of the FS code, both to
- *		make the FS code more portable and to free up some
- *		of the BSD internals so that they may more easily
- *		be changed.
+ * Locate and mount the root filesystem.
+ *
+ * The root filesystem is detailed in the kernel environment variable
+ * vfs.root.mountfrom, which is expected to be in the general format
  *
- * NOTE1:	Code is single entry/single exit to aid debugging
- *		and conversion for kernel multithreading.
+ * <vfsname>:[<path>]
+ * vfsname   := the name of a VFS known to the kernel and capable
+ *              of being mounted as root
+ * path      := disk device name or other data used by the filesystem
+ *              to locate its physical store
  *
- * NOTE2:	Code notes lock state in headers on entry and exit
- *		as an aid to conversion for kernel multithreading
- *		on SMP reentrancy
  */
-#include "opt_bootp.h"
 
-#include <sys/param.h>		/* dev_t (types.h)*/
+#include <sys/param.h>
 #include <sys/kernel.h>
-#include <sys/systm.h>		/* rootvp*/
-#include <sys/proc.h>		/* curproc*/
-#include <sys/vnode.h>		/* NULLVP*/
-#include <sys/mount.h>		/* struct mount*/
-#include <sys/malloc.h>		/* M_MOUNT*/
+#include <sys/systm.h>
+#include <sys/proc.h>
+#include <sys/vnode.h>
+#include <sys/mount.h>
+#include <sys/malloc.h>
+#include <sys/reboot.h>
+#include <sys/diskslice.h>
+#include <sys/disklabel.h>
+#include <sys/conf.h>
+#include <sys/cons.h>
 
-/*
- * GLOBALS
- */
+MALLOC_DEFINE(M_MOUNT, "mount", "vfs mount structure");
 
-MALLOC_DEFINE(M_MOUNT, "mount", "vfs mount struct");
+#define ROOTNAME	"root_device"
 
-/*
- *  These define the root filesystem, device, and root filesystem type.
- */
-dev_t rootdevs[] = { NODEV, NODEV };
-char *rootdevnames[2];
-struct vnode *rootvnode;
-char *mountrootfsname;
-#ifdef BOOTP
-extern void bootpc_init __P((void));
-#endif
+struct vnode	*rootvnode;
 
-/*
- * vfs_init() will set maxvfsconf
- * to the highest defined type number.
- */
-int maxvfsconf;
-struct vfsconf *vfsconf;
+static void	vfs_mountroot(void *junk);
+static int	vfs_mountroot_try(char *mountfrom);
+static int	vfs_mountroot_ask(void);
+static void	gets(char *cp);
 
-/*
- * Common root mount code shared by all filesystems
- */
-#define ROOTNAME	"root_device"
+/* legacy find-root code */
+char		*rootdevnames[2] = {NULL, NULL};
+static int	setrootbyname(char *name);
 
+SYSINIT(mountroot, SI_SUB_MOUNT_ROOT, SI_ORDER_FIRST, vfs_mountroot, NULL);
+	
 /*
- * vfs_mountrootfs
- *
- * Common entry point for root mounts
- *
- * PARAMETERS:
- * 		NONE
- *
- * RETURNS:	0	Success
- *		!0	error number (errno.h)
- *
- * LOCK STATE:
- *		ENTRY
- *			<no locks held>
- *		EXIT
- *			<no locks held>
- *
- * NOTES:
- *		This code is currently supported only for use for
- *		the FFS file system type.  This is a matter of
- *		fixing the other file systems, not this code!
+ * Find and mount the root filesystem
  */
 static void
-vfs_mountrootfs(void *unused)
+vfs_mountroot(void *junk)
 {
-	struct mount		*mp;
-	int			err;
-	struct proc		*p = curproc;	/* XXX */
-	int			s;
-	int			i;
-	dev_t			orootdev;
-
-#ifdef BOOTP
-	bootpc_init();
+	/* 
+	 * The root filesystem information is compiled in, and we are
+	 * booted with instructions to use it.
+	 */
+#ifdef ROOTDEVNAME
+	if ((boothowto & RB_DFLTROOT) && 
+	    !vfs_mountroot_try(ROOTDEVNAME))
+		return;
 #endif
-	/*
-	 *  New root mount structure
+	/* 
+	 * We are booted with instructions to prompt for the root filesystem,
+	 * or to use the compiled-in default when it doesn't exist.
 	 */
-	if ((err = vfs_rootmountalloc(mountrootfsname, ROOTNAME, &mp))) {
-		printf("rootdev=%p error=%d,  ", (void *)rootdev, err);
-		panic("cannot mount root\n");
-		return ;
+	if (boothowto & (RB_DFLTROOT | RB_ASKNAME)) {
+		if (!vfs_mountroot_ask())
+			return;
 	}
-	mp->mnt_flag		|= MNT_ROOTFS;
 
 	/*
-	 * If we have no idea what the device is because the VFS root mount
-	 * initialization code couldn't figure it out, take a guess by
-	 * assuming that vfs_getnewfsid() will be called when we try the
-	 * mount.  For the moment this is necessary for NFS-baesd BOOTP
-	 * boots.  Ultimately we would like to get rid of 'rootdev' entirely
-	 * and go with a linked list of possible roots and device-specific
-	 * auxillary data that we do not try to interpret ourselves.
+	 * Try to use the value read by the loader from /etc/fstab, or
+	 * supplied via some other means.  This is the preferred 
+	 * mechanism.
 	 */
-	if (rootdev == NODEV && rootdevs[0] == NODEV)
-		rootdev = vfs_getrootfsid(mp);
+	if (!vfs_mountroot_try(getenv("vfs.root.mountfrom")))
+		return;
+
+	/* 
+	 * Try values that may have been computed by the machine-dependant
+	 * legacy code.
+	 */
+	if (!vfs_mountroot_try(rootdevnames[0]))
+		return;
+	if (!vfs_mountroot_try(rootdevnames[1]))
+		return;
 
 	/*
-	 * Attempt the mount.  This is rather messy due to many historical
-	 * layers.  Basically what it comes down to is that 'rootdev' is an
-	 * override to the rootdevs[] array.  The rootdevs[] array itself
-	 * cannot normally be accessed directly by other modules, but FFS
-	 * plays with it.  NFS, on the otherhand, has no clue what the 
-	 * device assignment for a mount will be until it actually does it.
-	 *
-	 * During the loop we set rootdev to rootdevs[i].  This is used
-	 * by FFS and a few other modules.  It is ignored by NFS.
+	 * If we have a compiled-in default, and haven't already tried it, try
+	 * it now.
 	 */
-	err = ENXIO;
-	orootdev = rootdev;
-	if (rootdevs[0] == NODEV)
-		rootdevs[0] = rootdev;
-	for (i = 0; i < sizeof(rootdevs) / sizeof(rootdevs[0]); i++) {
-		if (rootdevs[i] == NODEV)
-			break;
-		rootdev = rootdevs[i];
-		if (rootdev != orootdev) {
-			s = splbio();	/* Overkill, but harmless.. */
-			printf("changing root device to %s\n", rootdevnames[i]);
-			splx(s);
-			orootdev = rootdev;
-		}
-		strncpy(mp->mnt_stat.f_mntfromname,
-		    rootdevnames[i] ? rootdevnames[i] : ROOTNAME, MNAMELEN - 1);
-		err = VFS_MOUNT(mp, NULL, NULL, NULL, p);
-		if (err != ENXIO)
-			break;
-	}
-	if (err) {
-		/*
-		 * XXX should ask the user for the name in some cases.
-		 * Why do we call vfs_unbusy() here and not after ENXIO
-		 * is returned above?
-		 */
-		vfs_unbusy(mp, p);
-		/*
-		 * free mount struct before failing
-		 * (hardly worthwhile with the PANIC eh?)
-		 */
-		free( mp, M_MOUNT);
-		printf("rootdev=%p error=%d,  ", (void *)rootdev, err);
-		panic("cannot mount root (2)\n");
+#ifdef ROOTDEVNAME
+	if (!(boothowto & RB_DFLTROOT))
+	    !vfs_mountroot_try(ROOTDEVNAME))
 		return;
+#endif
+
+	/* 
+	 * Everything so far has failed, prompt on the console if we haven't
+	 * already tried that.
+	 */
+	if (!(boothowto & (RB_DFLTROOT | RB_ASKNAME)) && !vfs_mountroot_ask())
+		return;
+	panic("Root mount failed, startup aborted.");
+}
+
+/*
+ * Mount (mountfrom) as the root filesystem.
+ */
+static int
+vfs_mountroot_try(char *mountfrom)
+{
+	struct mount	*mp;
+	char		*vfsname, *path;
+	int		error;
+	char		patt[16];
+
+	vfsname = path = NULL;
+	error = EINVAL;
+
+	if (mountfrom == NULL)
+		goto done;
+
+	printf("Mounting root from %s\n", mountfrom);
+
+	/* parse vfs name and path */
+	vfsname = malloc(MFSNAMELEN, M_MOUNT, M_WAITOK);
+	path = malloc(MNAMELEN, M_MOUNT, M_WAITOK);
+	sprintf(patt, "%%%d[a-z]:%%%ds", MFSNAMELEN, MNAMELEN);
+	if (sscanf(mountfrom, patt, vfsname, path) != 2)
+		goto done;
+
+	/* allocate a root mount */
+	if ((error = vfs_rootmountalloc(vfsname, ROOTNAME, &mp))) {
+		printf("Can't allocate root mount for filesystem '%s': %d\n",
+		       vfsname, error);
+		goto done;
 	}
+	mp->mnt_flag |= MNT_ROOTFS;
 
-	simple_lock(&mountlist_slock);
+	/* do our best to set rootdev */
+	if (setrootbyname(path))
+		printf("setrootbyname failed\n");
 
-	/*
-	 * Add fs to list of mounted file systems
-	 */
-	CIRCLEQ_INSERT_HEAD(&mountlist, mp, mnt_list);
+	strcpy(mp->mnt_stat.f_mntfromname, path);
+	error = VFS_MOUNT(mp, NULL, NULL, NULL, curproc);
+
+done:
+	free(vfsname, M_MOUNT);
+	free(path, M_MOUNT);
+	if (error != 0) {
+		if (mp != NULL)
+			free(mp, M_MOUNT);
+		printf("Root mount failed: %d\n", error);
+	} else {
+
+		/* register with list of mounted filesystems */
+		simple_lock(&mountlist_slock);
+		CIRCLEQ_INSERT_HEAD(&mountlist, mp, mnt_list);
+		simple_unlock(&mountlist_slock);
+
+		/* sanity check system clock against root filesystem timestamp */
+		inittodr(mp->mnt_time);
+	}
+	vfs_unbusy(mp, curproc);
+	return(error);
+}
+
+/*
+ * Spin prompting on the console for a suitable root filesystem
+ */
+static int
+vfs_mountroot_ask(void)
+{
+	char name[128];
+	int i;
+	dev_t dev;
+
+	for(;;) {
+		printf("\nManual root filesystem specification:\n");
+		printf("  <fstype>:<device>  Mount <device> using filesystem <fstype>\n");
+		printf("                       eg. ufs:/dev/da0s1a\n");
+		printf("  ?                  List valid disk boot devices\n");
+		printf("  <empty line>       Abort manual input\n");
+		printf("\n>>> ");
+		gets(name);
+		if (name[0] == 0)
+			return(1);
+		if (name[0] == '?') {
+			printf("Possibly valid devices for 'ufs' root:\n");
+			for (i = 0; i < NUMCDEVSW; i++) {
+				dev = makebdev(i, 0);
+				if (devsw(dev) != NULL)
+					printf(" \"%s\"", devsw(dev)->d_name);
+			}
+			printf("\n");
+			continue;
+		}
+		if (!vfs_mountroot_try(name))
+			return(0);
+	}
+}
 
-	simple_unlock(&mountlist_slock);
-	vfs_unbusy(mp, p);
+static void
+gets(char *cp)
+{
+	char *lp;
+	int c;
 
-	/* root mount, update system time from FS specific data*/
-	inittodr(mp->mnt_time);
-	return;
+	lp = cp;
+	for (;;) {
+		printf("%c", c = cngetc() & 0177);
+		switch (c) {
+		case -1:
+		case '\n':
+		case '\r':
+			*lp++ = '\0';
+			return;
+		case '\b':
+		case '\177':
+			if (lp > cp) {
+				printf(" \b");
+				lp--;
+			}
+			continue;
+		case '#':
+			lp--;
+			if (lp < cp)
+				lp = cp;
+			continue;
+		case '@':
+		case 'u' & 037:
+			lp = cp;
+			printf("%c", '\n');
+			continue;
+		default:
+			*lp++ = c;
+		}
+	}
 }
 
-SYSINIT(mountroot, SI_SUB_MOUNT_ROOT, SI_ORDER_FIRST, vfs_mountrootfs, NULL)
+/*
+ * Set rootdev to match (name), given that we expect it to
+ * refer to a disk-like device.
+ */
+static int
+setrootbyname(char *name)
+{
+	char *cp;
+	int bd, unit, slice, part;
+	dev_t dev;
+
+	slice = 0;
+	part = 0;
+	cp = rindex(name, '/');
+	if (cp != NULL) {
+		name = cp + 1;
+	}
+	cp = name;
+	while (cp != '\0' && (*cp < '0' || *cp > '9'))
+		cp++;
+	if (cp == name) {
+		printf("missing device name\n");
+		return(1);
+	}
+	if (*cp == '\0') {
+		printf("missing unit number\n");
+		return(1);
+	}
+	unit = *cp - '0';
+	*cp++ = '\0';
+	for (bd = 0; bd < NUMCDEVSW; bd++) {
+		dev = makebdev(bd, 0);
+		if (devsw(dev) != NULL &&
+		    strcmp(devsw(dev)->d_name, name) == 0)
+			goto gotit;
+	}
+	printf("no such device '%s'\n", name);
+	return (2);
+gotit:
+	while (*cp >= '0' && *cp <= '9')
+		unit += 10 * unit + *cp++ - '0';
+	if (*cp == 's' && cp[1] >= '0' && cp[1] <= '9') {
+		slice = cp[1] - '0' + 1;
+		cp += 2;
+	}
+	if (*cp >= 'a' && *cp <= 'h') {
+		part = *cp - 'a';
+		cp++;
+	}
+	if (*cp != '\0') {
+		printf("junk after name\n");
+		return (1);
+	}
+	rootdev = makebdev(bd, dkmakeminor(unit, slice, part));
+	return 0;
+}