7f562b6673
be booted. Due to a bug, this wasn't happening. There is still a lesser bug in that the loader decides which file to boot after the 10sec count down. This means the bootfile listed in the count down in is wrong in the case where the loader will boot /kernel.old.
341 lines
8.2 KiB
C
341 lines
8.2 KiB
C
/*-
|
|
* Copyright (c) 1998 Michael Smith <msmith@freebsd.org>
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 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.
|
|
*
|
|
* 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 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)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*
|
|
* $FreeBSD$
|
|
*/
|
|
|
|
/*
|
|
* Loading modules, booting the system
|
|
*/
|
|
|
|
#include <stand.h>
|
|
#include <string.h>
|
|
|
|
#include "bootstrap.h"
|
|
|
|
static char *getbootfile(int try);
|
|
|
|
/* List of kernel names to try (may be overwritten by boot.config) XXX should move from here? */
|
|
static char *default_bootfiles = "kernel;kernel.old";
|
|
|
|
static int autoboot_tried;
|
|
|
|
/*
|
|
* The user wants us to boot.
|
|
*/
|
|
COMMAND_SET(boot, "boot", "boot a file or loaded kernel", command_boot);
|
|
|
|
static int
|
|
command_boot(int argc, char *argv[])
|
|
{
|
|
struct preloaded_file *fp;
|
|
char *cp;
|
|
int try;
|
|
int i;
|
|
|
|
/*
|
|
* See if the user has specified an explicit kernel to boot.
|
|
*/
|
|
if ((argc > 1) && (argv[1][0] != '-')) {
|
|
|
|
/* XXX maybe we should discard everything and start again? */
|
|
if (file_findfile(NULL, NULL) != NULL) {
|
|
sprintf(command_errbuf, "can't boot '%s', kernel module already loaded", argv[1]);
|
|
return(CMD_ERROR);
|
|
}
|
|
|
|
/* find/load the kernel module */
|
|
if (mod_load(argv[1], argc - 2, argv + 2) != 0)
|
|
return(CMD_ERROR);
|
|
/* we have consumed all arguments */
|
|
argc = 1;
|
|
}
|
|
|
|
/*
|
|
* See if there is a kernel module already loaded
|
|
*/
|
|
if (file_findfile(NULL, NULL) == NULL) {
|
|
for (try = 0; (cp = getbootfile(try)) != NULL; try++) {
|
|
if (mod_load(cp, argc - 1, argv + 1) != 0) {
|
|
printf("can't load '%s'\n", cp);
|
|
} else {
|
|
/* we have consumed all arguments */
|
|
argc = 1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Loaded anything yet?
|
|
*/
|
|
if ((fp = file_findfile(NULL, NULL)) == NULL) {
|
|
command_errmsg = "no bootable kernel";
|
|
return(CMD_ERROR);
|
|
}
|
|
|
|
/*
|
|
* If we were given arguments, discard any previous.
|
|
* XXX should we merge arguments? Hard to DWIM.
|
|
*/
|
|
if (argc > 1) {
|
|
if (fp->f_args != NULL)
|
|
free(fp->f_args);
|
|
fp->f_args = unargv(argc - 1, argv + 1);
|
|
}
|
|
|
|
/* Hook for platform-specific autoloading of modules */
|
|
if (archsw.arch_autoload() != 0)
|
|
return(CMD_ERROR);
|
|
|
|
/* Call cleanup routines */
|
|
for (i = 0; devsw[i] != NULL; ++i)
|
|
if (devsw[i]->dv_cleanup != NULL)
|
|
(devsw[i]->dv_cleanup)();
|
|
|
|
/* Call the exec handler from the loader matching the kernel */
|
|
file_formats[fp->f_loader]->l_exec(fp);
|
|
return(CMD_ERROR);
|
|
}
|
|
|
|
|
|
/*
|
|
* Autoboot after a delay
|
|
*/
|
|
|
|
COMMAND_SET(autoboot, "autoboot", "boot automatically after a delay", command_autoboot);
|
|
|
|
static int
|
|
command_autoboot(int argc, char *argv[])
|
|
{
|
|
int howlong;
|
|
char *cp, *prompt;
|
|
|
|
prompt = NULL;
|
|
howlong = -1;
|
|
switch(argc) {
|
|
case 3:
|
|
prompt = argv[2];
|
|
/* FALLTHROUGH */
|
|
case 2:
|
|
howlong = strtol(argv[1], &cp, 0);
|
|
if (*cp != 0) {
|
|
sprintf(command_errbuf, "bad delay '%s'", argv[1]);
|
|
return(CMD_ERROR);
|
|
}
|
|
/* FALLTHROUGH */
|
|
case 1:
|
|
return(autoboot(howlong, prompt));
|
|
}
|
|
|
|
command_errmsg = "too many arguments";
|
|
return(CMD_ERROR);
|
|
}
|
|
|
|
/*
|
|
* Called before we go interactive. If we think we can autoboot, and
|
|
* we haven't tried already, try now.
|
|
*/
|
|
void
|
|
autoboot_maybe()
|
|
{
|
|
char *cp;
|
|
|
|
cp = getenv("autoboot_delay");
|
|
if ((autoboot_tried == 0) && ((cp == NULL) || strcasecmp(cp, "NO")))
|
|
autoboot(-1, NULL); /* try to boot automatically */
|
|
}
|
|
|
|
int
|
|
autoboot(int delay, char *prompt)
|
|
{
|
|
time_t when, otime, ntime;
|
|
int c, yes;
|
|
char *argv[2], *cp, *ep;
|
|
|
|
autoboot_tried = 1;
|
|
|
|
if (delay == -1) {
|
|
/* try to get a delay from the environment */
|
|
if ((cp = getenv("autoboot_delay"))) {
|
|
delay = strtol(cp, &ep, 0);
|
|
if (cp == ep)
|
|
delay = -1;
|
|
}
|
|
}
|
|
if (delay == -1) /* all else fails */
|
|
delay = 10;
|
|
|
|
otime = time(NULL);
|
|
when = otime + delay; /* when to boot */
|
|
yes = 0;
|
|
|
|
/* XXX could try to work out what we might boot */
|
|
printf("%s\n", (prompt == NULL) ? "Hit [Enter] to boot immediately, or any other key for command prompt." : prompt);
|
|
|
|
for (;;) {
|
|
if (ischar()) {
|
|
c = getchar();
|
|
if ((c == '\r') || (c == '\n'))
|
|
yes = 1;
|
|
break;
|
|
}
|
|
ntime = time(NULL);
|
|
if (ntime >= when) {
|
|
yes = 1;
|
|
break;
|
|
}
|
|
if (ntime != otime) {
|
|
printf("\rBooting [%s] in %d second%s... ",
|
|
getbootfile(0), (int)(when - ntime),
|
|
(when-ntime)==1?"":"s");
|
|
otime = ntime;
|
|
}
|
|
}
|
|
if (yes)
|
|
printf("\rBooting [%s]... ", getbootfile(0));
|
|
putchar('\n');
|
|
if (yes) {
|
|
argv[0] = "boot";
|
|
argv[1] = NULL;
|
|
return(command_boot(1, argv));
|
|
}
|
|
return(CMD_OK);
|
|
}
|
|
|
|
/*
|
|
* Scrounge for the name of the (try)'th file we will try to boot.
|
|
*/
|
|
static char *
|
|
getbootfile(int try)
|
|
{
|
|
static char *name = NULL;
|
|
char *spec, *ep;
|
|
int len;
|
|
|
|
/* we use dynamic storage */
|
|
if (name != NULL) {
|
|
free(name);
|
|
name = NULL;
|
|
}
|
|
|
|
/*
|
|
* Try $bootfile, then try our builtin default
|
|
*/
|
|
if ((spec = getenv("bootfile")) == NULL)
|
|
spec = default_bootfiles;
|
|
|
|
while ((try > 0) && (spec != NULL)) {
|
|
spec = strchr(spec, ';');
|
|
if (spec)
|
|
spec++; /* skip over the leading ';' */
|
|
try--;
|
|
}
|
|
if (spec != NULL) {
|
|
if ((ep = strchr(spec, ';')) != NULL) {
|
|
len = ep - spec;
|
|
} else {
|
|
len = strlen(spec);
|
|
}
|
|
name = malloc(len + 1);
|
|
strncpy(name, spec, len);
|
|
name[len] = 0;
|
|
}
|
|
if (name[0] == 0) {
|
|
free(name);
|
|
name = NULL;
|
|
}
|
|
return(name);
|
|
}
|
|
|
|
/*
|
|
* Try to find the /etc/fstab file on the filesystem (rootdev),
|
|
* which should be be the root filesystem, and parse it to find
|
|
* out what the kernel ought to think the root filesystem is.
|
|
*
|
|
* If we're successful, set vfs.root.mountfrom to <vfstype>:<path>
|
|
* so that the kernel can tell both which VFS and which node to use
|
|
* to mount the device. If this variable's already set, don't
|
|
* overwrite it.
|
|
*/
|
|
int
|
|
getrootmount(char *rootdev)
|
|
{
|
|
char lbuf[128], *cp, *ep, *dev, *fstyp;
|
|
int fd, error;
|
|
|
|
if (getenv("vfs.root.mountfrom") != NULL)
|
|
return(0);
|
|
|
|
sprintf(lbuf, "%s/etc/fstab", rootdev);
|
|
if ((fd = open(lbuf, O_RDONLY)) < 0)
|
|
return(1);
|
|
|
|
/* loop reading lines from /etc/fstab What was that about sscanf again? */
|
|
error = 1;
|
|
while (fgetstr(lbuf, sizeof(lbuf), fd) >= 0) {
|
|
if ((lbuf[0] == 0) || (lbuf[0] == '#'))
|
|
continue;
|
|
|
|
/* skip device name */
|
|
for (cp = lbuf; (*cp != 0) && !isspace(*cp); cp++)
|
|
;
|
|
if (*cp == 0) /* misformatted */
|
|
continue;
|
|
/* delimit and save */
|
|
*cp++ = 0;
|
|
dev = strdup(lbuf);
|
|
|
|
/* skip whitespace up to mountpoint */
|
|
while ((*cp != 0) && isspace(*cp))
|
|
cp++;
|
|
/* must have /<space> to be root */
|
|
if ((*cp == 0) || (*cp != '/') || !isspace(*(cp + 1)))
|
|
continue;
|
|
/* skip whitespace up to fstype */
|
|
cp += 2;
|
|
while ((*cp != 0) && isspace(*cp))
|
|
cp++;
|
|
if (*cp == 0) /* misformatted */
|
|
continue;
|
|
/* skip text to end of fstype and delimit */
|
|
ep = cp;
|
|
while ((*cp != 0) && !isspace(*cp))
|
|
cp++;
|
|
*cp = 0;
|
|
fstyp = strdup(ep);
|
|
|
|
/* build the final result and save it */
|
|
sprintf(lbuf, "%s:%s", fstyp, dev);
|
|
free(dev);
|
|
free(fstyp);
|
|
setenv("vfs.root.mountfrom", lbuf, 0);
|
|
error = 0;
|
|
break;
|
|
}
|
|
close(fd);
|
|
return(error);
|
|
}
|