From 4584f23d75bc93774c878e17bdd3efa07c62b725 Mon Sep 17 00:00:00 2001 From: msmith Date: Mon, 1 Nov 1999 23:51:00 +0000 Subject: 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. --- sys/kern/vfs_mount.c | 428 ++++++++++++++++++++++++++++++++------------------- 1 file changed, 270 insertions(+), 158 deletions(-) (limited to 'sys/kern/vfs_mount.c') diff --git a/sys/kern/vfs_mount.c b/sys/kern/vfs_mount.c index 7c11af7..2de291f 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 := 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 /* dev_t (types.h)*/ +#include #include -#include /* rootvp*/ -#include /* curproc*/ -#include /* NULLVP*/ -#include /* struct mount*/ -#include /* M_MOUNT*/ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include -/* - * 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 - * - * EXIT - * - * - * 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(" : Mount using filesystem \n"); + printf(" eg. ufs:/dev/da0s1a\n"); + printf(" ? List valid disk boot devices\n"); + printf(" 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; +} -- cgit v1.1