#include "efiboot.h"
#include <sys/bootblock.h>
#include <sys/boot_flag.h>
#include <machine/limits.h>
#include "bootcfg.h"
#include "bootmod.h"
#include "bootmenu.h"
#include "biosdisk.h"
#include "devopen.h"
#ifdef _STANDALONE
#include <bootinfo.h>
#endif
int errno;
int boot_biosdev;
daddr_t boot_biossector;
extern const char bootprog_name[], bootprog_rev[], bootprog_kernrev[];
extern struct x86_boot_params boot_params;
extern char twiddle_toggle;
static const char * const names[][2] = {
{ "netbsd", "netbsd.gz" },
{ "onetbsd", "onetbsd.gz" },
{ "netbsd.old", "netbsd.old.gz" },
{ "netbsd/kernel", "netbsd/kernel.gz" },
{ "onetbsd/kernel", "onetbsd/kernel.gz" },
{ "netbsd.old/kernel", "netbsd.old/kernel.gz" },
};
#define NUMNAMES __arraycount(names)
#define DEFFILENAME names[0][0]
#ifndef EFIBOOTCFG_FILENAME
#define EFIBOOTCFG_FILENAME "esp:/EFI/NetBSD/boot.cfg"
#endif
void command_help(char *);
void command_quit(char *);
void command_boot(char *);
void command_pkboot(char *);
void command_consdev_subr(char *, bool);
void command_consdev(char *);
void command_kconsdev(char *);
void command_root(char *);
void command_dev(char *);
void command_devpath(char *);
void command_efivar(char *);
void command_gop(char *);
#if LIBSA_ENABLE_LS_OP
void command_ls(char *);
#endif
void command_memmap(char *);
#ifndef SMALL
void command_menu(char *);
#endif
void command_modules(char *);
void command_multiboot(char *);
void command_reloc(char *);
void command_text(char *);
void command_version(char *);
const struct bootblk_command commands[] = {
{ "help", command_help },
{ "?", command_help },
{ "quit", command_quit },
{ "boot", command_boot },
{ "pkboot", command_pkboot },
{ "consdev", command_consdev },
{ "kconsdev", command_kconsdev },
{ "root", command_root },
{ "dev", command_dev },
{ "devpath", command_devpath },
{ "efivar", command_efivar },
{ "fs", fs_add },
{ "gop", command_gop },
{ "load", module_add },
#if LIBSA_ENABLE_LS_OP
{ "ls", command_ls },
#endif
{ "memmap", command_memmap },
#ifndef SMALL
{ "menu", command_menu },
#endif
{ "modules", command_modules },
{ "multiboot", command_multiboot },
{ "reloc", command_reloc },
{ "rndseed", rnd_add },
{ "splash", splash_add },
{ "text", command_text },
{ "userconf", userconf_add },
{ "version", command_version },
{ NULL, NULL },
};
static char *default_fsname;
static char *default_devname;
static int default_unit, default_partition;
static const char *default_filename;
static const char *default_part_name;
static char *sprint_bootsel(const char *);
static void bootit(const char *, int);
static void bootit2(char *, size_t, int);
int
parsebootfile(const char *fname, char **fsname, char **devname, int *unit,
int *partition, const char **file)
{
const char *col;
static char savedevname[MAXDEVNAME+1];
#if defined(SUPPORT_NFS) || defined(SUPPORT_TFTP)
const struct netboot_fstab *nf;
#endif
*fsname = default_fsname;
if (default_part_name == NULL) {
*devname = default_devname;
} else {
snprintf(savedevname, sizeof(savedevname),
"NAME=%s", default_part_name);
*devname = savedevname;
}
*unit = default_unit;
*partition = default_partition;
*file = default_filename;
if (fname == NULL)
return 0;
if ((col = strchr(fname, ':')) != NULL) {
int devlen;
int u = 0, p = 0;
int i = 0;
devlen = col - fname;
if (devlen > MAXDEVNAME)
return EINVAL;
if (strstr(fname, "NAME=") == fname) {
strlcpy(savedevname, fname, devlen + 1);
*fsname = "ufs";
*devname = savedevname;
*unit = -1;
*partition = -1;
fname = col + 1;
goto out;
}
#define isvalidname(c) ((c) >= 'a' && (c) <= 'z')
if (!isvalidname(fname[i]))
return EINVAL;
do {
savedevname[i] = fname[i];
i++;
} while (isvalidname(fname[i]));
savedevname[i] = '\0';
#define isnum(c) ((c) >= '0' && (c) <= '9')
if (i < devlen) {
if (!isnum(fname[i]))
return EUNIT;
do {
u *= 10;
u += fname[i++] - '0';
} while (isnum(fname[i]));
}
#define isvalidpart(c) ((c) >= 'a' && (c) <= 'z')
if (i < devlen) {
if (!isvalidpart(fname[i]))
return EPART;
p = fname[i++] - 'a';
}
if (i != devlen)
return ENXIO;
#if defined(SUPPORT_NFS) || defined(SUPPORT_TFTP)
nf = netboot_fstab_find(savedevname);
if (nf != NULL)
*fsname = (char *)nf->name;
else
#endif
*fsname = "ufs";
*devname = savedevname;
*unit = u;
*partition = p;
fname = col + 1;
}
out:
if (*fname)
*file = fname;
return 0;
}
static char *
snprint_bootdev(char *buf, size_t bufsize, const char *devname, int unit,
int partition)
{
static const char *no_partition_devs[] = { "esp", "net", "nfs", "tftp" };
int i;
for (i = 0; i < __arraycount(no_partition_devs); i++)
if (strcmp(devname, no_partition_devs[i]) == 0)
break;
if (strstr(devname, "NAME=") == devname)
strlcpy(buf, devname, bufsize);
else
snprintf(buf, bufsize, "%s%d%c", devname, unit,
i < __arraycount(no_partition_devs) ? '\0' : 'a' + partition);
return buf;
}
static char *
sprint_bootsel(const char *filename)
{
char *fsname, *devname;
int unit, partition;
const char *file;
static char buf[80];
if (parsebootfile(filename, &fsname, &devname, &unit,
&partition, &file) == 0) {
snprintf(buf, sizeof(buf), "%s:%s", snprint_bootdev(buf,
sizeof(buf), devname, unit, partition), file);
return buf;
}
return "(invalid)";
}
void
clearit(void)
{
if (bootcfg_info.clear)
clear_pc_screen();
}
static void
bootit(const char *filename, int howto)
{
if (howto & AB_VERBOSE)
printf("booting %s (howto 0x%x)\n", sprint_bootsel(filename),
howto);
if (exec_netbsd(filename, efi_loadaddr, howto, 0, efi_cleanup) < 0)
printf("boot: %s: %s\n", sprint_bootsel(filename),
strerror(errno));
else
printf("boot returned\n");
}
void
boot(void)
{
int currname;
int c;
#if defined(SUPPORT_NFS) || defined(SUPPORT_TFTP)
const struct netboot_fstab *nf;
#endif
boot_modules_enabled = !(boot_params.bp_flags & X86_BP_FLAGS_NOMODULES);
bios2dev(boot_biosdev, boot_biossector, &default_devname, &default_unit,
&default_partition, &default_part_name);
default_filename = DEFFILENAME;
#if defined(SUPPORT_NFS) || defined(SUPPORT_TFTP)
nf = netboot_fstab_find(default_devname);
if (nf != NULL)
default_fsname = (char *)nf->name;
else
#endif
default_fsname = "ufs";
if (!(boot_params.bp_flags & X86_BP_FLAGS_NOBOOTCONF)) {
#ifdef EFIBOOTCFG_FILENAME
int rv = EINVAL;
if (efi_bootdp_type != BOOT_DEVICE_TYPE_NET)
rv = parsebootconf(EFIBOOTCFG_FILENAME);
if (rv)
#endif
parsebootconf(BOOTCFG_FILENAME);
} else {
bootcfg_info.timeout = boot_params.bp_timeout;
}
if (bootcfg_info.consdev) {
command_consdev(bootcfg_info.consdev);
} else {
clearit();
print_bootcfg_banner(bootprog_name, bootprog_rev);
}
twiddle_toggle = 0;
if (bootcfg_info.nummenu > 0) {
doboottypemenu();
}
printf("Press return to boot now, any other key for boot menu\n");
for (currname = 0; currname < NUMNAMES; currname++) {
printf("booting %s - starting in ",
sprint_bootsel(names[currname][0]));
c = awaitkey((bootcfg_info.timeout < 0) ? 0
: bootcfg_info.timeout, 1);
if ((c != '\r') && (c != '\n') && (c != '\0')) {
if ((boot_params.bp_flags & X86_BP_FLAGS_PASSWORD) == 0) {
bootmenu();
} else {
if (check_password((char *)boot_params.bp_password)) {
printf("type \"?\" or \"help\" for help.\n");
bootmenu();
} else {
printf("Wrong password.\n");
currname = 0;
continue;
}
}
}
bootit(names[currname][0], 0);
bootit(names[currname][1], AB_VERBOSE);
}
bootmenu();
}
void
command_help(char *arg)
{
printf("commands are:\n"
"boot [dev:][filename] [-12acdqsvxz]\n"
#ifndef NO_RAIDFRAME
" dev syntax is (hd|fd|cd|raid)[N[x]]\n"
#else
" dev syntax is (hd|fd|cd)[N[x]]\n"
#endif
#ifndef NO_GPT
" or NAME=gpt_label\n"
#endif
" (ex. \"hd0a:netbsd.old -s\")\n"
"pkboot [dev:][filename] [-12acdqsvxz]\n"
"dev [dev:]\n"
"consdev {cons_spec}\n"
"kconsdev {cons_spec}\n"
" cons_spec can be\n"
" pc for keyboard and monitor\n"
" com[0123][,{speed}\n"
" com[,{addr}[,{speed}]] for EISA serial port\n"
" com{unit}[,{speed}]] for other serial port\n"
" ucom{unit}[,{speed}] for USB-to-serial adapter\n"
"root {root_spec}\n"
" root_spec can be disk, e.g. wd0, sd0\n"
" or string like wedge:name\n"
"devpath\n"
"efivar\n"
"gop [{modenum|list}]\n"
"load {path_to_module}\n"
#if LIBSA_ENABLE_LS_OP
"ls [dev:][path]\n"
#endif
"memmap [{sorted|unsorted|compact}]\n"
#ifndef SMALL
"menu (reenters boot menu, if defined in boot.cfg)\n"
#endif
"modules {on|off|enabled|disabled}\n"
"multiboot [dev:][filename] [<args>]\n"
"reloc {address|none|default}\n"
"rndseed {path_to_rndseed_file}\n"
"splash {path_to_image_file}\n"
"text [{modenum|list}]\n"
"userconf {command}\n"
"version\n"
"help|?\n"
"quit\n");
}
#if LIBSA_ENABLE_LS_OP
void
command_ls(char *arg)
{
const char *save = default_filename;
default_filename = "/";
ls(arg);
default_filename = save;
}
#endif
void
command_quit(char *arg)
{
printf("Exiting...\n");
delay(1 * 1000 * 1000);
reboot();
panic("Could not reboot!");
}
static void
bootit2(char *path, size_t plen, int howto)
{
bootit(path, howto);
snprintf(path, plen, "%s.gz", path);
bootit(path, howto | AB_VERBOSE);
}
void
command_boot(char *arg)
{
char *filename;
char path[512];
int howto;
if (!parseboot(arg, &filename, &howto))
return;
if (filename != NULL && filename[0] != '\0') {
snprintf(path, sizeof(path) - 4, "%s", filename);
bootit2(path, sizeof(path), howto);
if (strchr(filename + 1, '/') == NULL) {
snprintf(path, sizeof(path) - 4, "%s/kernel",
filename);
bootit2(path, sizeof(path), howto);
}
} else {
int i;
for (i = 0; i < NUMNAMES; i++) {
bootit(names[i][0], howto);
bootit(names[i][1], howto);
}
}
}
void
command_pkboot(char *arg)
{
extern int has_prekern;
has_prekern = 1;
command_boot(arg);
has_prekern = 0;
}
void
command_dev(char *arg)
{
static char savedevname[MAXDEVNAME + 1];
char buf[80];
char *devname;
const char *file;
if (*arg == '\0') {
efi_disk_show();
efi_net_show();
if (default_part_name != NULL)
printf("default NAME=%s\n", default_part_name);
else
printf("default %s\n",
snprint_bootdev(buf, sizeof(buf),
default_devname, default_unit,
default_partition));
return;
}
if (strchr(arg, ':') == NULL ||
parsebootfile(arg, &default_fsname, &devname, &default_unit,
&default_partition, &file)) {
command_help(NULL);
return;
}
strncpy(savedevname, devname, MAXDEVNAME + 1);
default_devname = savedevname;
if (strstr(devname, "NAME=") == devname)
default_part_name = default_devname + 5;
}
static const struct cons_devs {
const char *name;
u_int tag;
int ioport;
bool parse_unit;
} cons_devs[] = {
{ "pc", CONSDEV_PC, 0, false },
{ "com0", CONSDEV_COM0, 0, false },
{ "com1", CONSDEV_COM1, 0, false },
{ "com2", CONSDEV_COM2, 0, false },
{ "com3", CONSDEV_COM3, 0, false },
{ "com0kbd", CONSDEV_COM0KBD, 0, false },
{ "com1kbd", CONSDEV_COM1KBD, 0, false },
{ "com2kbd", CONSDEV_COM2KBD, 0, false },
{ "com3kbd", CONSDEV_COM3KBD, 0, false },
{ "ucom", CONSDEV_UCOM, 0, true },
{ "com", CONSDEV_COM0, -1, false },
{ "com", CONSDEV_COM, 0, true },
{ "auto", CONSDEV_AUTO, 0, false },
{ NULL, 0, 0, false }
};
void
command_consdev(char *arg)
{
return command_consdev_subr(arg, true);
}
void
command_kconsdev(char *arg)
{
return command_consdev_subr(arg, false);
}
void
command_consdev_subr(char *arg, bool switchcons)
{
const struct cons_devs *cdp;
char *sep, *sep2 = NULL;
int ioport, speed = 0;
int unit;
size_t xname_len;
size_t devname_len;
char *cp;
if (*arg == '\0') {
efi_cons_show();
return;
}
sep = strchr(arg, ',');
if (sep != NULL) {
*sep++ = '\0';
sep2 = strchr(sep, ',');
if (sep2 != NULL)
*sep2++ = '\0';
}
xname_len = strlen(arg);
devname_len = xname_len;
unit = -1;
cp = strchr(arg, (int)',');
if (cp == NULL)
cp = arg + xname_len;
while (--cp >= arg) {
if (!isdigit((int)*cp)) {
if (cp - arg > 1) {
devname_len = cp + 1 - arg;
unit = (int)strtoul(cp + 1, NULL, 10);
break;
}
}
}
for (cdp = cons_devs; cdp->name; cdp++) {
bool match;
if (cdp->parse_unit)
match = (strncmp(arg, cdp->name, devname_len) == 0);
else
match = (strcmp(arg, cdp->name) == 0);
if (match) {
ioport = cdp->ioport;
if (cdp->tag == CONSDEV_PC || cdp->tag == CONSDEV_AUTO) {
if (sep != NULL || sep2 != NULL)
goto error;
} else {
if (ioport == -1) {
if (sep != NULL) {
u_long t = strtoul(sep, NULL, 0);
if (t > INT_MAX)
goto error;
ioport = (int)t;
}
if (sep2 != NULL) {
speed = atoi(sep2);
if (speed < 0)
goto error;
}
} else {
if (sep != NULL) {
speed = atoi(sep);
if (speed < 0)
goto error;
}
if (sep2 != NULL)
goto error;
}
}
efi_consinit(cdp->tag, ioport, unit, speed, switchcons);
if (switchcons) {
clearit();
print_bootcfg_banner(bootprog_name,
bootprog_rev);
}
return;
}
}
error:
printf("invalid console device.\n");
}
void
command_root(char *arg)
{
struct btinfo_rootdevice *biv = &bi_root;
strncpy(biv->devname, arg, sizeof(biv->devname));
if (biv->devname[sizeof(biv->devname)-1] != '\0') {
biv->devname[sizeof(biv->devname)-1] = '\0';
printf("truncated to %s\n",biv->devname);
}
}
#ifndef SMALL
void
command_menu(char *arg)
{
if (bootcfg_info.nummenu > 0) {
doboottypemenu();
} else
printf("No menu defined in boot.cfg\n");
}
#endif
void
command_modules(char *arg)
{
if (strcmp(arg, "enabled") == 0 ||
strcmp(arg, "on") == 0)
boot_modules_enabled = true;
else if (strcmp(arg, "disabled") == 0 ||
strcmp(arg, "off") == 0)
boot_modules_enabled = false;
else
printf("invalid flag, must be 'enabled' or 'disabled'.\n");
}
void
command_multiboot(char *arg)
{
char *filename;
filename = arg;
if (exec_multiboot(filename, gettrailer(arg)) < 0)
printf("multiboot: %s: %s\n", sprint_bootsel(filename),
strerror(errno));
else
printf("boot returned\n");
}
void
command_reloc(char *arg)
{
char *ep;
if (*arg == '\0') {
switch (efi_reloc_type) {
case RELOC_NONE:
printf("reloc: none\n");
break;
case RELOC_ADDR:
printf("reloc: %p\n", (void *)efi_kernel_reloc);
break;
case RELOC_DEFAULT:
default:
printf("reloc: default\n");
break;
}
goto out;
}
if (strcmp(arg, "default") == 0) {
efi_reloc_type = RELOC_DEFAULT;
goto out;
}
if (strcmp(arg, "none") == 0) {
efi_reloc_type = RELOC_NONE;
goto out;
}
errno = 0;
efi_kernel_reloc = strtoul(arg, &ep, 0);
if (ep == arg || *ep != '\0' || errno)
printf("could not parse address \"%s\"\n", arg);
else
efi_reloc_type = RELOC_ADDR;
out:
return;
}
void
command_version(char *arg)
{
CHAR16 *path;
char *upath, *ufirmware;
int rv;
if (strcmp(arg, "full") == 0) {
printf("ImageBase: 0x%" PRIxPTR "\n",
(uintptr_t)efi_li->ImageBase);
printf("Stack: 0x%" PRIxPTR "\n", efi_main_sp);
printf("EFI version: %d.%02d\n",
ST->Hdr.Revision >> 16, ST->Hdr.Revision & 0xffff);
ufirmware = NULL;
rv = ucs2_to_utf8(ST->FirmwareVendor, &ufirmware);
if (rv == 0) {
printf("EFI Firmware: %s (rev %d.%02d)\n", ufirmware,
ST->FirmwareRevision >> 16,
ST->FirmwareRevision & 0xffff);
FreePool(ufirmware);
}
path = DevicePathToStr(efi_bootdp);
upath = NULL;
rv = ucs2_to_utf8(path, &upath);
FreePool(path);
if (rv == 0) {
printf("Boot DevicePath: %d:%d:%s\n",
DevicePathType(efi_bootdp),
DevicePathSubType(efi_bootdp), upath);
FreePool(upath);
}
}
printf("\n"
">> %s, Revision %s (from NetBSD %s)\n"
">> Memory: %d/%d k\n",
bootprog_name, bootprog_rev, bootprog_kernrev,
getbasemem(), getextmem());
}
void
command_memmap(char *arg)
{
bool sorted = true;
bool compact = false;
if (*arg == '\0' || strcmp(arg, "sorted") == 0)
;
else if (strcmp(arg, "unsorted") == 0)
sorted = false;
else if (strcmp(arg, "compact") == 0)
compact = true;
else {
printf("invalid flag, "
"must be 'sorted', 'unsorted' or 'compact'.\n");
return;
}
efi_memory_show_map(sorted, compact);
}
void
command_devpath(char *arg)
{
EFI_STATUS status;
UINTN i, nhandles;
EFI_HANDLE *handles;
EFI_DEVICE_PATH *dp0, *dp;
CHAR16 *path;
char *upath;
UINTN cols, rows, row = 0;
int rv;
status = uefi_call_wrapper(ST->ConOut->QueryMode, 4, ST->ConOut,
ST->ConOut->Mode->Mode, &cols, &rows);
if (EFI_ERROR(status) || rows <= 2)
rows = 0;
else
rows -= 2;
status = LibLocateHandle(ByProtocol, &DevicePathProtocol, NULL,
&nhandles, &handles);
if (EFI_ERROR(status))
return;
for (i = 0; i < nhandles; i++) {
status = uefi_call_wrapper(BS->HandleProtocol, 3, handles[i],
&DevicePathProtocol, (void **)&dp0);
if (EFI_ERROR(status))
break;
printf("DevicePathType %d\n", DevicePathType(dp0));
if (++row >= rows) {
row = 0;
printf("Press Any Key to continue :");
(void) awaitkey(-1, 0);
printf("\n");
}
for (dp = dp0;
!IsDevicePathEnd(dp);
dp = NextDevicePathNode(dp)) {
path = DevicePathToStr(dp);
upath = NULL;
rv = ucs2_to_utf8(path, &upath);
FreePool(path);
if (rv) {
printf("convert failed\n");
break;
}
printf("%d:%d:%s\n", DevicePathType(dp),
DevicePathSubType(dp), upath);
FreePool(upath);
if (++row >= rows) {
row = 0;
printf("Press Any Key to continue :");
(void) awaitkey(-1, 0);
printf("\n");
}
}
}
}
void
command_efivar(char *arg)
{
static const char header[] =
"GUID Variable Name Value\n"
"==================================== ==================== ========\n";
EFI_STATUS status;
UINTN sz = 64, osz;
CHAR16 *name = NULL, *tmp, *val, guid[128];
char *uname, *uval, *uguid;
EFI_GUID vendor;
UINTN cols, rows, row = 0;
int rv;
status = uefi_call_wrapper(ST->ConOut->QueryMode, 4, ST->ConOut,
ST->ConOut->Mode->Mode, &cols, &rows);
if (EFI_ERROR(status) || rows <= 2)
rows = 0;
else
rows -= 2;
name = AllocatePool(sz);
if (name == NULL) {
printf("memory allocation failed: %" PRIuMAX" bytes\n",
(uintmax_t)sz);
return;
}
SetMem(name, sz, 0);
vendor = NullGuid;
printf("%s", header);
for (;;) {
osz = sz;
status = uefi_call_wrapper(RT->GetNextVariableName, 3,
&sz, name, &vendor);
if (EFI_ERROR(status)) {
if (status == EFI_NOT_FOUND)
break;
if (status != EFI_BUFFER_TOO_SMALL) {
printf("GetNextVariableName failed: %" PRIxMAX "\n",
(uintmax_t)status);
break;
}
tmp = AllocatePool(sz);
if (tmp == NULL) {
printf("memory allocation failed: %" PRIuMAX
"bytes\n", (uintmax_t)sz);
break;
}
SetMem(tmp, sz, 0);
CopyMem(tmp, name, osz);
FreePool(name);
name = tmp;
continue;
}
val = LibGetVariable(name, &vendor);
if (val != NULL) {
uval = NULL;
rv = ucs2_to_utf8(val, &uval);
FreePool(val);
if (rv) {
printf("value convert failed\n");
break;
}
} else
uval = NULL;
uname = NULL;
rv = ucs2_to_utf8(name, &uname);
if (rv) {
printf("name convert failed\n");
FreePool(uval);
break;
}
GuidToString(guid, &vendor);
uguid = NULL;
rv = ucs2_to_utf8(guid, &uguid);
if (rv) {
printf("GUID convert failed\n");
FreePool(uval);
FreePool(uname);
break;
}
printf("%-35s %-20s %s\n", uguid, uname, uval ? uval : "(null)");
FreePool(uguid);
FreePool(uname);
if (uval != NULL)
FreePool(uval);
if (++row >= rows) {
row = 0;
printf("Press Any Key to continue :");
(void) awaitkey(-1, 0);
printf("\n");
}
}
FreePool(name);
}
