main/vaseboot
main
/
vaseboot
1
0
Fork 0
Code Issues Pull Requests 1 Packages Projects Releases Wiki Activity
vaseboot/VasEBoot-core/loader/i386/bsd.c

2196 lines
57 KiB
C
Raw Permalink Blame History

/*
* VAS_EBOOT -- GRand Unified Bootloader
* Copyright (C) 2008,2009,2010 Free Software Foundation, Inc.
*
* VAS_EBOOT is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* VAS_EBOOT is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with VAS_EBOOT. If not, see <http://www.gnu.org/licenses/>.
*/
#include <VasEBoot/loader.h>
#include <VasEBoot/i386/bsd.h>
#include <VasEBoot/i386/cpuid.h>
#include <VasEBoot/memory.h>
#include <VasEBoot/i386/memory.h>
#include <VasEBoot/file.h>
#include <VasEBoot/err.h>
#include <VasEBoot/dl.h>
#include <VasEBoot/mm.h>
#include <VasEBoot/elfload.h>
#include <VasEBoot/env.h>
#include <VasEBoot/misc.h>
#include <VasEBoot/aout.h>
#include <VasEBoot/command.h>
#include <VasEBoot/extcmd.h>
#include <VasEBoot/i18n.h>
#include <VasEBoot/ns8250.h>
#include <VasEBoot/bsdlabel.h>
#include <VasEBoot/crypto.h>
#include <VasEBoot/safemath.h>
#include <VasEBoot/verify.h>
#ifdef VAS_EBOOT_MACHINE_PCBIOS
#include <VasEBoot/machine/int.h>
#endif
VAS_EBOOT_MOD_LICENSE ("GPLv3+");
#include <VasEBoot/video.h>
#ifdef VAS_EBOOT_MACHINE_PCBIOS
#include <VasEBoot/machine/biosnum.h>
#endif
#ifdef VAS_EBOOT_MACHINE_EFI
#include <VasEBoot/efi/efi.h>
#define NETBSD_DEFAULT_VIDEO_MODE "800x600"
#else
#define NETBSD_DEFAULT_VIDEO_MODE "text"
#include <VasEBoot/i386/pc/vbe.h>
#endif
#include <VasEBoot/video.h>
#include <VasEBoot/disk.h>
#include <VasEBoot/device.h>
#include <VasEBoot/partition.h>
#include <VasEBoot/relocator.h>
#include <VasEBoot/i386/relocator.h>
#define ALIGN_DWORD(a) ALIGN_UP (a, 4)
#define ALIGN_QWORD(a) ALIGN_UP (a, 8)
#define ALIGN_VAR(a) ((is_64bit) ? (ALIGN_QWORD(a)) : (ALIGN_DWORD(a)))
#define ALIGN_PAGE(a) ALIGN_UP (a, 4096)
static int kernel_type = KERNEL_TYPE_NONE;
static VasEBoot_dl_t my_mod;
static VasEBoot_addr_t entry, entry_hi, kern_start, kern_end;
static void *kern_chunk_src;
static VasEBoot_uint32_t bootflags;
static int is_elf_kernel, is_64bit;
static VasEBoot_uint32_t openbsd_root;
static struct VasEBoot_relocator *relocator = NULL;
static struct VasEBoot_openbsd_ramdisk_descriptor openbsd_ramdisk;
struct bsd_tag
{
struct bsd_tag *next;
VasEBoot_size_t len;
VasEBoot_uint32_t type;
union {
VasEBoot_uint8_t a;
VasEBoot_uint16_t b;
VasEBoot_uint32_t c;
} data[0];
};
static struct bsd_tag *tags, *tags_last;
struct netbsd_module
{
struct netbsd_module *next;
struct VasEBoot_netbsd_btinfo_module mod;
};
static struct netbsd_module *netbsd_mods, *netbsd_mods_last;
static const struct VasEBoot_arg_option freebsd_opts[] =
{
{"dual", 'D', 0, N_("Display output on all consoles."), 0, 0},
{"serial", 'h', 0, N_("Use serial console."), 0, 0},
{"askname", 'a', 0, N_("Ask for file name to reboot from."), 0, 0},
{"cdrom", 'C', 0, N_("Use CD-ROM as root."), 0, 0},
{"config", 'c', 0, N_("Invoke user configuration routing."), 0, 0},
{"kdb", 'd', 0, N_("Enter in KDB on boot."), 0, 0},
{"gdb", 'g', 0, N_("Use GDB remote debugger instead of DDB."), 0, 0},
{"mute", 'm', 0, N_("Disable all boot output."), 0, 0},
{"nointr", 'n', 0, "", 0, 0},
{"pause", 'p', 0, N_("Wait for keypress after every line of output."), 0, 0},
{"quiet", 'q', 0, "", 0, 0},
{"dfltroot", 'r', 0, N_("Use compiled-in root device."), 0, 0},
{"single", 's', 0, N_("Boot into single mode."), 0, 0},
{"verbose", 'v', 0, N_("Boot with verbose messages."), 0, 0},
{0, 0, 0, 0, 0, 0}
};
static const VasEBoot_uint32_t freebsd_flags[] =
{
FREEBSD_RB_DUAL, FREEBSD_RB_SERIAL, FREEBSD_RB_ASKNAME,
FREEBSD_RB_CDROM, FREEBSD_RB_CONFIG, FREEBSD_RB_KDB,
FREEBSD_RB_GDB, FREEBSD_RB_MUTE, FREEBSD_RB_NOINTR,
FREEBSD_RB_PAUSE, FREEBSD_RB_QUIET, FREEBSD_RB_DFLTROOT,
FREEBSD_RB_SINGLE, FREEBSD_RB_VERBOSE, 0
};
static const struct VasEBoot_arg_option openbsd_opts[] =
{
{"askname", 'a', 0, N_("Ask for file name to reboot from."), 0, 0},
{"halt", 'b', 0, N_("Don't reboot, just halt."), 0, 0},
{"config", 'c', 0, N_("Change configured devices."), 0, 0},
{"single", 's', 0, N_("Boot into single mode."), 0, 0},
{"kdb", 'd', 0, N_("Enter in KDB on boot."), 0, 0},
{"root", 'r', 0, N_("Set root device."), "wdXY", ARG_TYPE_STRING},
{"serial", 'h', VAS_EBOOT_ARG_OPTION_OPTIONAL,
N_("Use serial console."),
/* TRANSLATORS: "com" is static and not to be translated. It refers to
serial ports e.g. com1.
*/
N_("comUNIT[,SPEED]"), ARG_TYPE_STRING},
{0, 0, 0, 0, 0, 0}
};
static const VasEBoot_uint32_t openbsd_flags[] =
{
OPENBSD_RB_ASKNAME, OPENBSD_RB_HALT, OPENBSD_RB_CONFIG,
OPENBSD_RB_SINGLE, OPENBSD_RB_KDB, 0
};
#define OPENBSD_ROOT_ARG (ARRAY_SIZE (openbsd_flags) - 1)
#define OPENBSD_SERIAL_ARG (ARRAY_SIZE (openbsd_flags))
static const struct VasEBoot_arg_option netbsd_opts[] =
{
{"no-smp", '1', 0, N_("Disable SMP."), 0, 0},
{"no-acpi", '2', 0, N_("Disable ACPI."), 0, 0},
{"askname", 'a', 0, N_("Ask for file name to reboot from."), 0, 0},
{"halt", 'b', 0, N_("Don't reboot, just halt."), 0, 0},
{"config", 'c', 0, N_("Change configured devices."), 0, 0},
{"kdb", 'd', 0, N_("Enter in KDB on boot."), 0, 0},
{"miniroot", 'm', 0, "", 0, 0},
{"quiet", 'q', 0, N_("Don't display boot diagnostic messages."), 0, 0},
{"single", 's', 0, N_("Boot into single mode."), 0, 0},
{"verbose", 'v', 0, N_("Boot with verbose messages."), 0, 0},
{"debug", 'x', 0, N_("Boot with debug messages."), 0, 0},
{"silent", 'z', 0, N_("Suppress normal output (warnings remain)."), 0, 0},
{"root", 'r', 0, N_("Set root device."), N_("DEVICE"), ARG_TYPE_STRING},
{"serial", 'h', VAS_EBOOT_ARG_OPTION_OPTIONAL,
N_("Use serial console."),
/* TRANSLATORS: "com" is static and not to be translated. It refers to
serial ports e.g. com1.
*/
N_("[ADDR|comUNIT][,SPEED]"), ARG_TYPE_STRING},
{0, 0, 0, 0, 0, 0}
};
static const VasEBoot_uint32_t netbsd_flags[] =
{
NETBSD_AB_NOSMP, NETBSD_AB_NOACPI, NETBSD_RB_ASKNAME,
NETBSD_RB_HALT, NETBSD_RB_USERCONFIG, NETBSD_RB_KDB,
NETBSD_RB_MINIROOT, NETBSD_AB_QUIET, NETBSD_RB_SINGLE,
NETBSD_AB_VERBOSE, NETBSD_AB_DEBUG, NETBSD_AB_SILENT, 0
};
#define NETBSD_ROOT_ARG (ARRAY_SIZE (netbsd_flags) - 1)
#define NETBSD_SERIAL_ARG (ARRAY_SIZE (netbsd_flags))
static void
VasEBoot_bsd_get_device (VasEBoot_uint32_t * biosdev,
VasEBoot_uint32_t * unit,
VasEBoot_uint32_t * slice, VasEBoot_uint32_t * part)
{
VasEBoot_device_t dev;
#ifdef VAS_EBOOT_MACHINE_PCBIOS
*biosdev = VasEBoot_get_root_biosnumber () & 0xff;
#else
*biosdev = 0xff;
#endif
*unit = (*biosdev & 0x7f);
*slice = 0xff;
*part = 0xff;
dev = VasEBoot_device_open (0);
if (dev && dev->disk && dev->disk->partition)
{
if (dev->disk->partition->parent)
{
*part = dev->disk->partition->number;
*slice = dev->disk->partition->parent->number + 1;
}
else
*slice = dev->disk->partition->number + 1;
}
if (dev)
VasEBoot_device_close (dev);
}
static VasEBoot_err_t
VasEBoot_bsd_add_meta_ptr (VasEBoot_uint32_t type, void **ptr, VasEBoot_uint32_t len)
{
struct bsd_tag *newtag;
newtag = VasEBoot_malloc (len + sizeof (struct bsd_tag));
if (!newtag)
return VasEBoot_errno;
newtag->len = len;
newtag->type = type;
newtag->next = NULL;
*ptr = newtag->data;
if (kernel_type == KERNEL_TYPE_FREEBSD
&& type == (FREEBSD_MODINFO_METADATA | FREEBSD_MODINFOMD_SMAP))
{
struct bsd_tag *p;
for (p = tags;
p && p->type != (FREEBSD_MODINFO_METADATA
| FREEBSD_MODINFOMD_KERNEND);
p = p->next);
if (p)
{
newtag->next = p->next;
p->next = newtag;
if (newtag->next == NULL)
tags_last = newtag;
return VAS_EBOOT_ERR_NONE;
}
}
if (tags_last)
tags_last->next = newtag;
else
tags = newtag;
tags_last = newtag;
return VAS_EBOOT_ERR_NONE;
}
VasEBoot_err_t
VasEBoot_bsd_add_meta (VasEBoot_uint32_t type, const void *data, VasEBoot_uint32_t len)
{
VasEBoot_err_t err;
void *ptr = NULL;
err = VasEBoot_bsd_add_meta_ptr (type, &ptr, len);
if (err)
return err;
if (len)
VasEBoot_memcpy (ptr, data, len);
return VAS_EBOOT_ERR_NONE;
}
struct VasEBoot_e820_mmap
{
VasEBoot_uint64_t addr;
VasEBoot_uint64_t size;
VasEBoot_uint32_t type;
} VAS_EBOOT_PACKED;
#define VAS_EBOOT_E820_RAM 1
#define VAS_EBOOT_E820_RESERVED 2
#define VAS_EBOOT_E820_ACPI 3
#define VAS_EBOOT_E820_NVS 4
#define VAS_EBOOT_E820_BADRAM 5
#define VAS_EBOOT_E820_COREBOOT_TABLES 0x10
/* Context for generate_e820_mmap. */
struct generate_e820_mmap_ctx
{
int count;
struct VasEBoot_e820_mmap *mmap;
struct VasEBoot_e820_mmap prev, cur;
};
/* Helper for generate_e820_mmap. */
static int
generate_e820_mmap_iter (VasEBoot_uint64_t addr, VasEBoot_uint64_t size,
VasEBoot_memory_type_t type, void *data)
{
struct generate_e820_mmap_ctx *ctx = data;
ctx->cur.addr = addr;
ctx->cur.size = size;
if (type == VAS_EBOOT_MEMORY_COREBOOT_TABLES
&& addr == 0)
/* Nowadays the tables at 0 don't contain anything important but
*BSD needs the memory at 0 for own needs.
*/
type = VAS_EBOOT_E820_RAM;
ctx->cur.type = type;
/* Merge regions if possible. */
if (ctx->count && ctx->cur.type == ctx->prev.type
&& ctx->cur.addr == ctx->prev.addr + ctx->prev.size)
{
ctx->prev.size += ctx->cur.size;
if (ctx->mmap)
ctx->mmap[-1] = ctx->prev;
}
else
{
if (ctx->mmap)
*ctx->mmap++ = ctx->cur;
ctx->prev = ctx->cur;
ctx->count++;
}
if (kernel_type == KERNEL_TYPE_OPENBSD && ctx->prev.addr < 0x100000
&& ctx->prev.addr + ctx->prev.size > 0x100000)
{
ctx->cur.addr = 0x100000;
ctx->cur.size = ctx->prev.addr + ctx->prev.size - 0x100000;
ctx->cur.type = ctx->prev.type;
ctx->prev.size = 0x100000 - ctx->prev.addr;
if (ctx->mmap)
{
ctx->mmap[-1] = ctx->prev;
ctx->mmap[0] = ctx->cur;
ctx->mmap++;
}
ctx->prev = ctx->cur;
ctx->count++;
}
return 0;
}
static void
generate_e820_mmap (VasEBoot_size_t *len, VasEBoot_size_t *cnt, void *buf)
{
struct generate_e820_mmap_ctx ctx = {
.count = 0,
.mmap = buf
};
VasEBoot_mmap_iterate (generate_e820_mmap_iter, &ctx);
if (len)
*len = ctx.count * sizeof (struct VasEBoot_e820_mmap);
*cnt = ctx.count;
return;
}
static VasEBoot_err_t
VasEBoot_bsd_add_mmap (void)
{
VasEBoot_size_t len, cnt;
void *buf = NULL, *buf0;
generate_e820_mmap (&len, &cnt, buf);
if (kernel_type == KERNEL_TYPE_NETBSD)
len += sizeof (VasEBoot_uint32_t);
if (kernel_type == KERNEL_TYPE_OPENBSD)
len += sizeof (struct VasEBoot_e820_mmap);
buf = VasEBoot_malloc (len);
if (!buf)
return VasEBoot_errno;
buf0 = buf;
if (kernel_type == KERNEL_TYPE_NETBSD)
{
*(VasEBoot_uint32_t *) buf = cnt;
buf = ((VasEBoot_uint32_t *) buf + 1);
}
generate_e820_mmap (NULL, &cnt, buf);
if (kernel_type == KERNEL_TYPE_OPENBSD)
VasEBoot_memset ((VasEBoot_uint8_t *) buf + len - sizeof (struct VasEBoot_e820_mmap), 0,
sizeof (struct VasEBoot_e820_mmap));
VasEBoot_dprintf ("bsd", "%u entries in smap\n", (unsigned) cnt);
if (kernel_type == KERNEL_TYPE_NETBSD)
VasEBoot_bsd_add_meta (NETBSD_BTINFO_MEMMAP, buf0, len);
else if (kernel_type == KERNEL_TYPE_OPENBSD)
VasEBoot_bsd_add_meta (OPENBSD_BOOTARG_MMAP, buf0, len);
else
VasEBoot_bsd_add_meta (FREEBSD_MODINFO_METADATA |
FREEBSD_MODINFOMD_SMAP, buf0, len);
VasEBoot_free (buf0);
return VasEBoot_errno;
}
VasEBoot_err_t
VasEBoot_freebsd_add_meta_module (const char *filename, const char *type,
int argc, char **argv,
VasEBoot_addr_t addr, VasEBoot_uint32_t size)
{
const char *name;
VasEBoot_err_t err;
name = VasEBoot_strrchr (filename, '/');
if (name)
name++;
else
name = filename;
if (VasEBoot_strcmp (type, "/boot/zfs/zpool.cache") == 0)
name = "/boot/zfs/zpool.cache";
if (VasEBoot_bsd_add_meta (FREEBSD_MODINFO_NAME, name, VasEBoot_strlen (name) + 1))
return VasEBoot_errno;
if (is_64bit)
{
VasEBoot_uint64_t addr64 = addr, size64 = size;
if (VasEBoot_bsd_add_meta (FREEBSD_MODINFO_TYPE, type, VasEBoot_strlen (type) + 1)
|| VasEBoot_bsd_add_meta (FREEBSD_MODINFO_ADDR, &addr64, sizeof (addr64))
|| VasEBoot_bsd_add_meta (FREEBSD_MODINFO_SIZE, &size64, sizeof (size64)))
return VasEBoot_errno;
}
else
{
if (VasEBoot_bsd_add_meta (FREEBSD_MODINFO_TYPE, type, VasEBoot_strlen (type) + 1)
|| VasEBoot_bsd_add_meta (FREEBSD_MODINFO_ADDR, &addr, sizeof (addr))
|| VasEBoot_bsd_add_meta (FREEBSD_MODINFO_SIZE, &size, sizeof (size)))
return VasEBoot_errno;
}
if (argc)
{
int i, n;
n = 0;
for (i = 0; i < argc; i++)
{
n += VasEBoot_strlen (argv[i]) + 1;
}
if (n)
{
void *cmdline;
char *p;
if (VasEBoot_bsd_add_meta_ptr (FREEBSD_MODINFO_ARGS, &cmdline, n))
return VasEBoot_errno;
p = cmdline;
for (i = 0; i < argc; i++)
{
VasEBoot_strcpy (p, argv[i]);
p += VasEBoot_strlen (argv[i]);
*(p++) = ' ';
}
*p = 0;
err = VasEBoot_verify_string (cmdline, VAS_EBOOT_VERIFY_MODULE_CMDLINE);
if (err)
return err;
}
}
return VAS_EBOOT_ERR_NONE;
}
static void
VasEBoot_freebsd_list_modules (void)
{
struct bsd_tag *tag;
VasEBoot_printf (" %-18s %-18s%14s%14s\n", _("name"), _("type"), _("addr"),
_("size"));
for (tag = tags; tag; tag = tag->next)
{
switch (tag->type)
{
case FREEBSD_MODINFO_NAME:
case FREEBSD_MODINFO_TYPE:
VasEBoot_printf (" %-18s", (char *) tag->data);
break;
case FREEBSD_MODINFO_ADDR:
{
VasEBoot_uint32_t addr;
addr = *((VasEBoot_uint32_t *) tag->data);
VasEBoot_printf (" 0x%08x", addr);
break;
}
case FREEBSD_MODINFO_SIZE:
{
VasEBoot_uint32_t len;
len = *((VasEBoot_uint32_t *) tag->data);
VasEBoot_printf (" 0x%08x\n", len);
}
}
}
}
static VasEBoot_err_t
VasEBoot_netbsd_add_meta_module (char *filename, VasEBoot_uint32_t type,
VasEBoot_addr_t addr, VasEBoot_uint32_t size)
{
char *name;
struct netbsd_module *mod;
name = VasEBoot_strrchr (filename, '/');
if (name)
name++;
else
name = filename;
mod = VasEBoot_zalloc (sizeof (*mod));
if (!mod)
return VasEBoot_errno;
VasEBoot_strncpy (mod->mod.name, name, sizeof (mod->mod.name) - 1);
mod->mod.addr = addr;
mod->mod.type = type;
mod->mod.size = size;
if (netbsd_mods_last)
netbsd_mods_last->next = mod;
else
netbsd_mods = mod;
netbsd_mods_last = mod;
return VAS_EBOOT_ERR_NONE;
}
static void
VasEBoot_netbsd_list_modules (void)
{
struct netbsd_module *mod;
VasEBoot_printf (" %-18s%14s%14s%14s\n", _("name"), _("type"), _("addr"),
_("size"));
for (mod = netbsd_mods; mod; mod = mod->next)
VasEBoot_printf (" %-18s 0x%08x 0x%08x 0x%08x", mod->mod.name,
mod->mod.type, mod->mod.addr, mod->mod.size);
}
/* This function would be here but it's under different license. */
#include "bsd_pagetable.c"
static VasEBoot_uint32_t freebsd_bootdev, freebsd_biosdev;
static VasEBoot_uint64_t freebsd_zfsguid;
static void
freebsd_get_zfs (void)
{
VasEBoot_device_t dev;
VasEBoot_fs_t fs;
char *uuid;
VasEBoot_err_t err;
dev = VasEBoot_device_open (0);
if (!dev)
return;
fs = VasEBoot_fs_probe (dev);
if (!fs)
return;
if (!fs->fs_uuid || VasEBoot_strcmp (fs->name, "zfs") != 0)
return;
err = fs->fs_uuid (dev, &uuid);
if (err)
return;
if (!uuid)
return;
freebsd_zfsguid = VasEBoot_strtoull (uuid, 0, 16);
VasEBoot_free (uuid);
}
static VasEBoot_err_t
VasEBoot_freebsd_boot (void)
{
struct VasEBoot_freebsd_bootinfo bi;
VasEBoot_uint8_t *p, *p0;
VasEBoot_addr_t p_target;
VasEBoot_size_t p_size = 0;
VasEBoot_err_t err;
VasEBoot_size_t tag_buf_len = 0;
struct VasEBoot_env_var *var;
VasEBoot_memset (&bi, 0, sizeof (bi));
bi.version = FREEBSD_BOOTINFO_VERSION;
bi.length = sizeof (bi);
bi.boot_device = freebsd_biosdev;
p_size = 0;
FOR_SORTED_ENV (var)
if ((VasEBoot_memcmp (var->name, "kFreeBSD.", sizeof("kFreeBSD.") - 1) == 0) && (var->name[sizeof("kFreeBSD.") - 1]))
{
p_size += VasEBoot_strlen (&var->name[sizeof("kFreeBSD.") - 1]);
p_size++;
p_size += VasEBoot_strlen (var->value) + 1;
}
if (p_size)
p_size = ALIGN_PAGE (kern_end + p_size + 1) - kern_end;
if (is_elf_kernel)
{
struct bsd_tag *tag;
err = VasEBoot_bsd_add_mmap ();
if (err)
return err;
err = VasEBoot_bsd_add_meta (FREEBSD_MODINFO_END, 0, 0);
if (err)
return err;
tag_buf_len = 0;
for (tag = tags; tag; tag = tag->next)
tag_buf_len = ALIGN_VAR (tag_buf_len
+ sizeof (struct freebsd_tag_header)
+ tag->len);
p_size = ALIGN_PAGE (kern_end + p_size + tag_buf_len) - kern_end;
}
if (is_64bit)
p_size += 4096 * 3;
{
VasEBoot_relocator_chunk_t ch;
err = VasEBoot_relocator_alloc_chunk_addr (relocator, &ch,
kern_end, p_size);
if (err)
return err;
p = get_virtual_current_address (ch);
}
p_target = kern_end;
p0 = p;
kern_end += p_size;
FOR_SORTED_ENV (var)
if ((VasEBoot_memcmp (var->name, "kFreeBSD.", sizeof("kFreeBSD.") - 1) == 0) && (var->name[sizeof("kFreeBSD.") - 1]))
{
VasEBoot_strcpy ((char *) p, &var->name[sizeof("kFreeBSD.") - 1]);
p += VasEBoot_strlen ((char *) p);
*(p++) = '=';
VasEBoot_strcpy ((char *) p, var->value);
p += VasEBoot_strlen ((char *) p) + 1;
}
if (p != p0)
{
*(p++) = 0;
bi.environment = p_target;
}
if (is_elf_kernel)
{
VasEBoot_uint8_t *p_tag = p;
struct bsd_tag *tag;
for (tag = tags; tag; tag = tag->next)
{
struct freebsd_tag_header *head
= (struct freebsd_tag_header *) p_tag;
head->type = tag->type;
head->len = tag->len;
p_tag += sizeof (struct freebsd_tag_header);
switch (tag->type)
{
case FREEBSD_MODINFO_METADATA | FREEBSD_MODINFOMD_HOWTO:
if (is_64bit)
*(VasEBoot_uint64_t *) p_tag = bootflags;
else
*(VasEBoot_uint32_t *) p_tag = bootflags;
break;
case FREEBSD_MODINFO_METADATA | FREEBSD_MODINFOMD_ENVP:
if (is_64bit)
*(VasEBoot_uint64_t *) p_tag = bi.environment;
else
*(VasEBoot_uint32_t *) p_tag = bi.environment;
break;
case FREEBSD_MODINFO_METADATA | FREEBSD_MODINFOMD_KERNEND:
if (is_64bit)
*(VasEBoot_uint64_t *) p_tag = kern_end;
else
*(VasEBoot_uint32_t *) p_tag = kern_end;
break;
default:
VasEBoot_memcpy (p_tag, tag->data, tag->len);
break;
}
p_tag += tag->len;
p_tag = ALIGN_VAR (p_tag - p) + p;
}
bi.tags = (p - p0) + p_target;
p = (ALIGN_PAGE ((p_tag - p0) + p_target) - p_target) + p0;
}
bi.kern_end = kern_end;
VasEBoot_video_set_mode ("text", 0, 0);
if (is_64bit)
{
struct VasEBoot_relocator64_state state = {0};
VasEBoot_uint8_t *pagetable;
VasEBoot_uint32_t *stack;
VasEBoot_addr_t stack_target;
{
VasEBoot_relocator_chunk_t ch;
err = VasEBoot_relocator_alloc_chunk_align (relocator, &ch,
0x10000, 0x90000,
3 * sizeof (VasEBoot_uint32_t)
+ sizeof (bi), 4,
VAS_EBOOT_RELOCATOR_PREFERENCE_NONE,
0);
if (err)
return err;
stack = get_virtual_current_address (ch);
stack_target = get_physical_target_address (ch);
}
#ifdef VAS_EBOOT_MACHINE_EFI
err = VasEBoot_efi_finish_boot_services (NULL, NULL, NULL, NULL, NULL);
if (err)
return err;
#endif
pagetable = p;
fill_bsd64_pagetable (pagetable, (pagetable - p0) + p_target);
state.cr3 = (pagetable - p0) + p_target;
state.rsp = stack_target;
state.rip = (((VasEBoot_uint64_t) entry_hi) << 32) | entry;
stack[0] = entry;
stack[1] = bi.tags;
stack[2] = kern_end;
return VasEBoot_relocator64_boot (relocator, state, 0, 0x40000000);
}
else
{
struct VasEBoot_relocator32_state state = {0};
VasEBoot_uint32_t *stack;
VasEBoot_addr_t stack_target;
{
VasEBoot_relocator_chunk_t ch;
err = VasEBoot_relocator_alloc_chunk_align (relocator, &ch,
0x10000, 0x90000,
9 * sizeof (VasEBoot_uint32_t)
+ sizeof (bi), 4,
VAS_EBOOT_RELOCATOR_PREFERENCE_NONE,
0);
if (err)
return err;
stack = get_virtual_current_address (ch);
stack_target = get_physical_target_address (ch);
}
#ifdef VAS_EBOOT_MACHINE_EFI
err = VasEBoot_efi_finish_boot_services (NULL, NULL, NULL, NULL, NULL);
if (err)
return err;
#endif
VasEBoot_memcpy (&stack[9], &bi, sizeof (bi));
state.eip = entry;
state.esp = stack_target;
state.ebp = stack_target;
stack[0] = entry; /* "Return" address. */
stack[1] = bootflags | FREEBSD_RB_BOOTINFO;
stack[2] = freebsd_bootdev;
stack[3] = freebsd_zfsguid ? 4 : 0;
stack[4] = freebsd_zfsguid;
stack[5] = freebsd_zfsguid >> 32;
stack[6] = stack_target + 9 * sizeof (VasEBoot_uint32_t);
stack[7] = bi.tags;
stack[8] = kern_end;
return VasEBoot_relocator32_boot (relocator, state, 0);
}
/* Not reached. */
return VAS_EBOOT_ERR_NONE;
}
static VasEBoot_err_t
VasEBoot_openbsd_boot (void)
{
VasEBoot_uint32_t *stack;
struct VasEBoot_relocator32_state state;
void *curarg, *buf0, *arg0;
VasEBoot_addr_t buf_target;
VasEBoot_err_t err;
VasEBoot_size_t tag_buf_len;
err = VasEBoot_bsd_add_mmap ();
if (err)
return err;
#ifdef VAS_EBOOT_MACHINE_PCBIOS
{
struct VasEBoot_bios_int_registers regs;
regs.flags = VAS_EBOOT_CPU_INT_FLAGS_DEFAULT;
regs.ebx = 0;
regs.ecx = 0;
regs.eax = 0xb101;
regs.es = 0;
regs.edi = 0;
regs.edx = 0;
VasEBoot_bios_interrupt (0x1a, &regs);
if (regs.edx == 0x20494350)
{
struct VasEBoot_openbsd_bootarg_pcibios pcibios;
pcibios.characteristics = regs.eax & 0xff;
pcibios.revision = regs.ebx & 0xffff;
pcibios.pm_entry = regs.edi;
pcibios.last_bus = regs.ecx & 0xff;
VasEBoot_bsd_add_meta (OPENBSD_BOOTARG_PCIBIOS, &pcibios,
sizeof (pcibios));
}
}
#endif
{
struct bsd_tag *tag;
tag_buf_len = 0;
for (tag = tags; tag; tag = tag->next)
tag_buf_len = ALIGN_VAR (tag_buf_len
+ sizeof (struct VasEBoot_openbsd_bootargs)
+ tag->len);
}
buf_target = VAS_EBOOT_BSD_TEMP_BUFFER - 9 * sizeof (VasEBoot_uint32_t);
{
VasEBoot_relocator_chunk_t ch;
err = VasEBoot_relocator_alloc_chunk_addr (relocator, &ch, buf_target,
tag_buf_len
+ sizeof (struct VasEBoot_openbsd_bootargs)
+ 9 * sizeof (VasEBoot_uint32_t));
if (err)
return err;
buf0 = get_virtual_current_address (ch);
}
stack = (VasEBoot_uint32_t *) buf0;
arg0 = curarg = stack + 9;
{
struct bsd_tag *tag;
struct VasEBoot_openbsd_bootargs *head;
for (tag = tags; tag; tag = tag->next)
{
head = curarg;
head->ba_type = tag->type;
head->ba_size = tag->len + sizeof (*head);
curarg = head + 1;
VasEBoot_memcpy (curarg, tag->data, tag->len);
curarg = (VasEBoot_uint8_t *) curarg + tag->len;
head->ba_next = (VasEBoot_uint8_t *) curarg - (VasEBoot_uint8_t *) buf0
+ buf_target;
}
head = curarg;
head->ba_type = OPENBSD_BOOTARG_END;
head->ba_size = 0;
head->ba_next = 0;
}
VasEBoot_video_set_mode ("text", 0, 0);
#ifdef VAS_EBOOT_MACHINE_EFI
err = VasEBoot_efi_finish_boot_services (NULL, NULL, NULL, NULL, NULL);
if (err)
return err;
#endif
state.eip = entry;
state.ebp = state.esp
= ((VasEBoot_uint8_t *) stack - (VasEBoot_uint8_t *) buf0) + buf_target;
stack[0] = entry;
stack[1] = bootflags;
stack[2] = openbsd_root;
stack[3] = OPENBSD_BOOTARG_APIVER;
stack[4] = 0;
stack[5] = VasEBoot_mmap_get_upper () >> 10;
stack[6] = VasEBoot_mmap_get_lower () >> 10;
stack[7] = (VasEBoot_uint8_t *) curarg - (VasEBoot_uint8_t *) arg0;
stack[8] = ((VasEBoot_uint8_t *) arg0 - (VasEBoot_uint8_t *) buf0) + buf_target;
return VasEBoot_relocator32_boot (relocator, state, 0);
}
static VasEBoot_err_t
VasEBoot_netbsd_setup_video (void)
{
struct VasEBoot_video_mode_info mode_info;
void *framebuffer;
const char *modevar;
struct VasEBoot_netbsd_btinfo_framebuf params = {0};
VasEBoot_err_t err;
VasEBoot_video_driver_id_t driv_id;
modevar = VasEBoot_env_get ("gfxpayload");
/* Now all graphical modes are acceptable.
May change in future if we have modes without framebuffer. */
if (modevar && *modevar != 0)
{
char *tmp;
tmp = VasEBoot_xasprintf ("%s;" NETBSD_DEFAULT_VIDEO_MODE, modevar);
if (! tmp)
return VasEBoot_errno;
err = VasEBoot_video_set_mode (tmp, 0, 0);
VasEBoot_free (tmp);
}
else
err = VasEBoot_video_set_mode (NETBSD_DEFAULT_VIDEO_MODE, 0, 0);
if (err)
return err;
driv_id = VasEBoot_video_get_driver_id ();
if (driv_id == VAS_EBOOT_VIDEO_DRIVER_NONE)
return VAS_EBOOT_ERR_NONE;
err = VasEBoot_video_get_info_and_fini (&mode_info, &framebuffer);
if (err)
return err;
params.width = mode_info.width;
params.height = mode_info.height;
params.bpp = mode_info.bpp;
params.pitch = mode_info.pitch;
params.flags = 0;
params.fbaddr = (VasEBoot_addr_t) framebuffer;
params.red_mask_size = mode_info.red_mask_size;
params.red_field_pos = mode_info.red_field_pos;
params.green_mask_size = mode_info.green_mask_size;
params.green_field_pos = mode_info.green_field_pos;
params.blue_mask_size = mode_info.blue_mask_size;
params.blue_field_pos = mode_info.blue_field_pos;
#ifdef VAS_EBOOT_MACHINE_PCBIOS
/* VESA packed modes may come with zeroed mask sizes, which need
to be set here according to DAC Palette width. If we don't,
this results in Linux displaying a black screen. */
if (mode_info.bpp <= 8 && driv_id == VAS_EBOOT_VIDEO_DRIVER_VBE)
{
struct VasEBoot_vbe_info_block controller_info;
int status;
int width = 8;
status = VasEBoot_vbe_bios_get_controller_info (&controller_info);
if (status == VAS_EBOOT_VBE_STATUS_OK &&
(controller_info.capabilities & VAS_EBOOT_VBE_CAPABILITY_DACWIDTH))
status = VasEBoot_vbe_bios_set_dac_palette_width (&width);
if (status != VAS_EBOOT_VBE_STATUS_OK)
/* 6 is default after mode reset. */
width = 6;
params.red_mask_size = params.green_mask_size
= params.blue_mask_size = width;
}
#endif
err = VasEBoot_bsd_add_meta (NETBSD_BTINFO_FRAMEBUF, &params, sizeof (params));
return err;
}
static VasEBoot_err_t
VasEBoot_netbsd_add_modules (void)
{
struct netbsd_module *mod;
unsigned modcnt = 0;
struct VasEBoot_netbsd_btinfo_modules *mods;
unsigned i;
VasEBoot_err_t err;
VasEBoot_size_t sz;
for (mod = netbsd_mods; mod; mod = mod->next)
modcnt++;
if (VasEBoot_mul (modcnt, sizeof (mods->mods[0]), &sz) ||
VasEBoot_add (sz, sizeof (*mods), &sz))
return VAS_EBOOT_ERR_OUT_OF_RANGE;
mods = VasEBoot_malloc (sz);
if (!mods)
return VasEBoot_errno;
mods->num = modcnt;
mods->last_addr = kern_end;
for (mod = netbsd_mods, i = 0; mod; i++, mod = mod->next)
mods->mods[i] = mod->mod;
err = VasEBoot_bsd_add_meta (NETBSD_BTINFO_MODULES, mods,
sizeof (*mods) + sizeof (mods->mods[0]) * modcnt);
VasEBoot_free (mods);
return err;
}
/*
* Adds NetBSD bootinfo bootdisk and bootwedge. The partition identified
* in these bootinfo fields is the root device.
*/
static void
VasEBoot_netbsd_add_boot_disk_and_wedge (void)
{
VasEBoot_device_t dev;
VasEBoot_disk_t disk;
VasEBoot_partition_t part;
VasEBoot_uint32_t biosdev;
VasEBoot_uint32_t partmapsector;
union {
VasEBoot_uint64_t raw[VAS_EBOOT_DISK_SECTOR_SIZE / 8];
struct VasEBoot_partition_bsd_disk_label label;
} buf;
if (VAS_EBOOT_MD_MD5->mdlen > VAS_EBOOT_CRYPTO_MAX_MDLEN)
{
VasEBoot_error (VAS_EBOOT_ERR_BUG, "mdlen too long");
return;
}
dev = VasEBoot_device_open (0);
if (! (dev && dev->disk && dev->disk->partition))
goto fail;
disk = dev->disk;
part = disk->partition;
if (disk->dev && disk->dev->id == VAS_EBOOT_DISK_DEVICE_BIOSDISK_ID)
biosdev = (VasEBoot_uint32_t) disk->id & 0xff;
else
biosdev = 0xff;
/* Absolute sector of the partition map describing this partition. */
partmapsector = VasEBoot_partition_get_start (part->parent) + part->offset;
disk->partition = part->parent;
if (VasEBoot_disk_read (disk, part->offset, 0, VAS_EBOOT_DISK_SECTOR_SIZE, buf.raw)
!= VAS_EBOOT_ERR_NONE)
goto fail;
disk->partition = part;
/* Fill bootwedge. */
{
struct VasEBoot_netbsd_btinfo_bootwedge biw;
VasEBoot_uint8_t hash[VAS_EBOOT_CRYPTO_MAX_MDLEN];
VasEBoot_memset (&biw, 0, sizeof (biw));
biw.biosdev = biosdev;
biw.startblk = VasEBoot_partition_get_start (part);
biw.nblks = part->len;
biw.matchblk = partmapsector;
biw.matchnblks = 1;
VasEBoot_crypto_hash (VAS_EBOOT_MD_MD5, hash,
buf.raw, VAS_EBOOT_DISK_SECTOR_SIZE);
VasEBoot_memcpy (biw.matchhash, hash, 16);
VasEBoot_bsd_add_meta (NETBSD_BTINFO_BOOTWEDGE, &biw, sizeof (biw));
}
/* Fill bootdisk. */
{
struct VasEBoot_netbsd_btinfo_bootdisk bid;
VasEBoot_memset (&bid, 0, sizeof (bid));
/* Check for a NetBSD disk label. */
if (part->partmap != NULL &&
(VasEBoot_strcmp (part->partmap->name, "netbsd") == 0 ||
(part->parent == NULL && VasEBoot_strcmp (part->partmap->name, "bsd") == 0)))
{
bid.labelsector = partmapsector;
bid.label.type = buf.label.type;
bid.label.checksum = buf.label.checksum;
VasEBoot_memcpy (bid.label.packname, buf.label.packname, 16);
}
else
{
bid.labelsector = -1;
}
bid.biosdev = biosdev;
bid.partition = part->number;
VasEBoot_bsd_add_meta (NETBSD_BTINFO_BOOTDISK, &bid, sizeof (bid));
}
fail:
if (dev)
VasEBoot_device_close (dev);
}
static VasEBoot_err_t
VasEBoot_netbsd_boot (void)
{
struct VasEBoot_netbsd_bootinfo *bootinfo;
void *curarg, *arg0;
VasEBoot_addr_t arg_target, stack_target;
VasEBoot_uint32_t *stack;
VasEBoot_err_t err;
struct VasEBoot_relocator32_state state;
VasEBoot_size_t tag_buf_len = 0;
int tag_count = 0;
err = VasEBoot_bsd_add_mmap ();
if (err)
return err;
err = VasEBoot_netbsd_setup_video ();
if (err)
{
VasEBoot_print_error ();
VasEBoot_puts_ (N_("Booting in blind mode"));
VasEBoot_errno = VAS_EBOOT_ERR_NONE;
}
err = VasEBoot_netbsd_add_modules ();
if (err)
return err;
#ifdef VAS_EBOOT_MACHINE_EFI
err = VasEBoot_bsd_add_meta (NETBSD_BTINFO_EFI,
&VasEBoot_efi_system_table,
sizeof (VasEBoot_efi_system_table));
if (err)
return err;
#endif
{
struct bsd_tag *tag;
tag_buf_len = 0;
for (tag = tags; tag; tag = tag->next)
{
tag_buf_len = ALIGN_VAR (tag_buf_len
+ sizeof (struct VasEBoot_netbsd_btinfo_common)
+ tag->len);
tag_count++;
}
}
arg_target = kern_end;
{
VasEBoot_relocator_chunk_t ch;
err = VasEBoot_relocator_alloc_chunk_addr (relocator, &ch,
arg_target, tag_buf_len
+ sizeof (struct VasEBoot_netbsd_bootinfo)
+ tag_count * sizeof (VasEBoot_uint32_t));
if (err)
return err;
curarg = get_virtual_current_address (ch);
}
arg0 = curarg;
bootinfo = (void *) ((VasEBoot_uint8_t *) arg0 + tag_buf_len);
{
struct bsd_tag *tag;
unsigned i;
bootinfo->bi_count = tag_count;
for (tag = tags, i = 0; tag; i++, tag = tag->next)
{
struct VasEBoot_netbsd_btinfo_common *head = curarg;
bootinfo->bi_data[i] = ((VasEBoot_uint8_t *) curarg - (VasEBoot_uint8_t *) arg0)
+ arg_target;
head->type = tag->type;
head->len = tag->len + sizeof (*head);
curarg = head + 1;
VasEBoot_memcpy (curarg, tag->data, tag->len);
curarg = (VasEBoot_uint8_t *) curarg + tag->len;
}
}
{
VasEBoot_relocator_chunk_t ch;
err = VasEBoot_relocator_alloc_chunk_align (relocator, &ch, 0x10000, 0x90000,
7 * sizeof (VasEBoot_uint32_t), 4,
VAS_EBOOT_RELOCATOR_PREFERENCE_NONE,
0);
if (err)
return err;
stack = get_virtual_current_address (ch);
stack_target = get_physical_target_address (ch);
}
#ifdef VAS_EBOOT_MACHINE_EFI
err = VasEBoot_efi_finish_boot_services (NULL, NULL, NULL, NULL, NULL);
if (err)
return err;
#endif
state.eip = entry;
state.esp = stack_target;
state.ebp = stack_target;
stack[0] = entry;
stack[1] = bootflags;
stack[2] = 0;
stack[3] = ((VasEBoot_uint8_t *) bootinfo - (VasEBoot_uint8_t *) arg0) + arg_target;
stack[4] = 0;
stack[5] = VasEBoot_mmap_get_upper () >> 10;
stack[6] = VasEBoot_mmap_get_lower () >> 10;
return VasEBoot_relocator32_boot (relocator, state, 0);
}
static VasEBoot_err_t
VasEBoot_bsd_unload (void)
{
struct bsd_tag *tag, *next;
for (tag = tags; tag; tag = next)
{
next = tag->next;
VasEBoot_free (tag);
}
tags = NULL;
tags_last = NULL;
kernel_type = KERNEL_TYPE_NONE;
VasEBoot_dl_unref (my_mod);
VasEBoot_relocator_unload (relocator);
relocator = NULL;
return VAS_EBOOT_ERR_NONE;
}
static VasEBoot_err_t
VasEBoot_bsd_load_aout (VasEBoot_file_t file, const char *filename)
{
VasEBoot_addr_t load_addr, load_end;
int ofs, align_page;
union VasEBoot_aout_header ah;
VasEBoot_err_t err;
VasEBoot_size_t bss_size;
if ((VasEBoot_file_seek (file, 0)) == (VasEBoot_off_t) - 1)
return VasEBoot_errno;
if (VasEBoot_file_read (file, &ah, sizeof (ah)) != sizeof (ah))
{
if (!VasEBoot_errno)
VasEBoot_error (VAS_EBOOT_ERR_READ_ERROR, N_("premature end of file %s"),
filename);
return VasEBoot_errno;
}
if (VasEBoot_aout_get_type (&ah) != AOUT_TYPE_AOUT32)
return VasEBoot_error (VAS_EBOOT_ERR_BAD_OS, "invalid a.out header");
entry = ah.aout32.a_entry & 0xFFFFFF;
if (AOUT_GETMAGIC (ah.aout32) == AOUT32_ZMAGIC)
{
load_addr = entry;
ofs = 0x1000;
align_page = 0;
}
else
{
load_addr = entry & 0xF00000;
ofs = sizeof (struct VasEBoot_aout32_header);
align_page = 1;
}
if (load_addr < 0x100000)
return VasEBoot_error (VAS_EBOOT_ERR_BAD_OS, "load address below 1M");
kern_start = load_addr;
load_end = kern_end = load_addr + ah.aout32.a_text + ah.aout32.a_data;
if (align_page)
kern_end = ALIGN_PAGE (kern_end);
if (ah.aout32.a_bss)
{
kern_end += ah.aout32.a_bss;
if (align_page)
kern_end = ALIGN_PAGE (kern_end);
bss_size = kern_end - load_end;
}
else
bss_size = 0;
{
VasEBoot_relocator_chunk_t ch;
err = VasEBoot_relocator_alloc_chunk_addr (relocator, &ch,
kern_start, kern_end - kern_start);
if (err)
return err;
kern_chunk_src = get_virtual_current_address (ch);
}
return VasEBoot_aout_load (file, ofs, kern_chunk_src,
ah.aout32.a_text + ah.aout32.a_data,
bss_size);
}
static VasEBoot_err_t
VasEBoot_bsd_load_elf (VasEBoot_elf_t elf, const char *filename)
{
VasEBoot_err_t err;
VasEBoot_size_t sz;
kern_end = 0;
kern_start = ~0;
if (VasEBoot_elf_is_elf32 (elf))
{
VasEBoot_relocator_chunk_t ch;
Elf32_Phdr *phdr;
entry = elf->ehdr.ehdr32.e_entry & 0xFFFFFFF;
FOR_ELF32_PHDRS (elf, phdr)
{
Elf32_Addr paddr;
if (phdr->p_type != PT_LOAD
&& phdr->p_type != PT_DYNAMIC)
continue;
paddr = phdr->p_paddr & 0xFFFFFFF;
if (paddr < kern_start)
kern_start = paddr;
if (paddr + phdr->p_memsz > kern_end)
kern_end = paddr + phdr->p_memsz;
}
if (VasEBoot_errno)
return VasEBoot_errno;
if (VasEBoot_sub (kern_end, kern_start, &sz))
return VasEBoot_error (VAS_EBOOT_ERR_OUT_OF_RANGE, "underflow detected while determining size of kernel for relocator");
err = VasEBoot_relocator_alloc_chunk_addr (relocator, &ch, kern_start, sz);
if (err)
return err;
kern_chunk_src = get_virtual_current_address (ch);
err = VasEBoot_elf32_load (elf, filename, (VasEBoot_uint8_t *) kern_chunk_src - kern_start, VAS_EBOOT_ELF_LOAD_FLAGS_LOAD_PT_DYNAMIC | VAS_EBOOT_ELF_LOAD_FLAGS_28BITS, 0, 0);
if (err)
return err;
if (kernel_type != KERNEL_TYPE_OPENBSD)
return VAS_EBOOT_ERR_NONE;
return VasEBoot_openbsd_find_ramdisk32 (elf->file, filename, kern_start,
kern_chunk_src, &openbsd_ramdisk);
}
else if (VasEBoot_elf_is_elf64 (elf))
{
Elf64_Phdr *phdr;
is_64bit = 1;
if (! VasEBoot_cpuid_has_longmode)
return VasEBoot_error (VAS_EBOOT_ERR_BAD_OS, "your CPU does not implement AMD64 architecture");
/* FreeBSD has 64-bit entry point. */
if (kernel_type == KERNEL_TYPE_FREEBSD)
{
entry = elf->ehdr.ehdr64.e_entry & 0xffffffff;
entry_hi = (elf->ehdr.ehdr64.e_entry >> 32) & 0xffffffff;
}
else
{
entry = elf->ehdr.ehdr64.e_entry & 0x0fffffff;
entry_hi = 0;
}
FOR_ELF64_PHDRS (elf, phdr)
{
Elf64_Addr paddr;
if (phdr->p_type != PT_LOAD
&& phdr->p_type != PT_DYNAMIC)
continue;
paddr = phdr->p_paddr & 0xFFFFFFF;
if (paddr < kern_start)
kern_start = paddr;
if (paddr + phdr->p_memsz > kern_end)
kern_end = paddr + phdr->p_memsz;
}
if (VasEBoot_errno)
return VasEBoot_errno;
VasEBoot_dprintf ("bsd", "kern_start = %lx, kern_end = %lx\n",
(unsigned long) kern_start, (unsigned long) kern_end);
{
VasEBoot_relocator_chunk_t ch;
if (VasEBoot_sub (kern_end, kern_start, &sz))
return VasEBoot_error (VAS_EBOOT_ERR_OUT_OF_RANGE, "underflow detected while determining size of kernel for relocator");
err = VasEBoot_relocator_alloc_chunk_addr (relocator, &ch, kern_start, sz);
if (err)
return err;
kern_chunk_src = get_virtual_current_address (ch);
}
err = VasEBoot_elf64_load (elf, filename,
(VasEBoot_uint8_t *) kern_chunk_src - kern_start, VAS_EBOOT_ELF_LOAD_FLAGS_LOAD_PT_DYNAMIC | VAS_EBOOT_ELF_LOAD_FLAGS_28BITS, 0, 0);
if (err)
return err;
if (kernel_type != KERNEL_TYPE_OPENBSD)
return VAS_EBOOT_ERR_NONE;
return VasEBoot_openbsd_find_ramdisk64 (elf->file, filename, kern_start,
kern_chunk_src, &openbsd_ramdisk);
}
else
return VasEBoot_error (VAS_EBOOT_ERR_BAD_OS, N_("invalid arch-dependent ELF magic"));
}
static VasEBoot_err_t
VasEBoot_bsd_load (int argc, char *argv[])
{
VasEBoot_file_t file;
VasEBoot_elf_t elf;
VasEBoot_dl_ref (my_mod);
VasEBoot_loader_unset ();
VasEBoot_memset (&openbsd_ramdisk, 0, sizeof (openbsd_ramdisk));
if (argc == 0)
{
VasEBoot_error (VAS_EBOOT_ERR_BAD_ARGUMENT, N_("filename expected"));
goto fail;
}
file = VasEBoot_file_open (argv[0], VAS_EBOOT_FILE_TYPE_BSD_KERNEL);
if (!file)
goto fail;
relocator = VasEBoot_relocator_new ();
if (!relocator)
{
VasEBoot_file_close (file);
goto fail;
}
elf = VasEBoot_elf_file (file, argv[0]);
if (elf)
{
is_elf_kernel = 1;
VasEBoot_bsd_load_elf (elf, argv[0]);
VasEBoot_elf_close (elf);
}
else
{
is_elf_kernel = 0;
VasEBoot_errno = 0;
VasEBoot_bsd_load_aout (file, argv[0]);
VasEBoot_file_close (file);
}
kern_end = ALIGN_PAGE (kern_end);
fail:
if (VasEBoot_errno != VAS_EBOOT_ERR_NONE)
VasEBoot_dl_unref (my_mod);
return VasEBoot_errno;
}
static VasEBoot_uint32_t
VasEBoot_bsd_parse_flags (const struct VasEBoot_arg_list *state,
const VasEBoot_uint32_t * flags)
{
VasEBoot_uint32_t result = 0;
unsigned i;
for (i = 0; flags[i]; i++)
if (state[i].set)
result |= flags[i];
return result;
}
static VasEBoot_err_t
VasEBoot_cmd_freebsd (VasEBoot_extcmd_context_t ctxt, int argc, char *argv[])
{
kernel_type = KERNEL_TYPE_FREEBSD;
bootflags = VasEBoot_bsd_parse_flags (ctxt->state, freebsd_flags);
if (VasEBoot_bsd_load (argc, argv) == VAS_EBOOT_ERR_NONE)
{
VasEBoot_uint32_t unit, slice, part;
kern_end = ALIGN_PAGE (kern_end);
if (is_elf_kernel)
{
VasEBoot_err_t err;
VasEBoot_uint64_t data = 0;
VasEBoot_file_t file;
int len = is_64bit ? 8 : 4;
err = VasEBoot_freebsd_add_meta_module (argv[0], FREEBSD_MODTYPE_KERNEL,
argc - 1, argv + 1,
kern_start,
kern_end - kern_start);
if (err)
return err;
file = VasEBoot_file_open (argv[0], VAS_EBOOT_FILE_TYPE_BSD_KERNEL);
if (! file)
return VasEBoot_errno;
if (is_64bit)
err = VasEBoot_freebsd_load_elf_meta64 (relocator, file, argv[0],
&kern_end);
else
err = VasEBoot_freebsd_load_elf_meta32 (relocator, file, argv[0],
&kern_end);
if (err)
return err;
err = VasEBoot_bsd_add_meta (FREEBSD_MODINFO_METADATA |
FREEBSD_MODINFOMD_HOWTO, &data, 4);
if (err)
return err;
err = VasEBoot_bsd_add_meta (FREEBSD_MODINFO_METADATA |
FREEBSD_MODINFOMD_ENVP, &data, len);
if (err)
return err;
err = VasEBoot_bsd_add_meta (FREEBSD_MODINFO_METADATA |
FREEBSD_MODINFOMD_KERNEND, &data, len);
if (err)
return err;
}
VasEBoot_bsd_get_device (&freebsd_biosdev, &unit, &slice, &part);
freebsd_zfsguid = 0;
if (!is_64bit)
freebsd_get_zfs ();
VasEBoot_print_error ();
freebsd_bootdev = (FREEBSD_B_DEVMAGIC + ((slice + 1) << FREEBSD_B_SLICESHIFT) +
(unit << FREEBSD_B_UNITSHIFT) + (part << FREEBSD_B_PARTSHIFT));
VasEBoot_loader_set (VasEBoot_freebsd_boot, VasEBoot_bsd_unload, 0);
}
return VasEBoot_errno;
}
static const char *types[] = {
[0] = "wd",
[2] = "fd",
[4] = "sd",
[6] = "cd",
[14] = "vnd",
[17] = "rd"
};
static VasEBoot_err_t
VasEBoot_cmd_openbsd (VasEBoot_extcmd_context_t ctxt, int argc, char *argv[])
{
VasEBoot_uint32_t bootdev;
kernel_type = KERNEL_TYPE_OPENBSD;
bootflags = VasEBoot_bsd_parse_flags (ctxt->state, openbsd_flags);
if (ctxt->state[OPENBSD_ROOT_ARG].set && ctxt->state[OPENBSD_ROOT_ARG].arg != NULL)
{
const char *arg = ctxt->state[OPENBSD_ROOT_ARG].arg;
unsigned type, unit, part;
for (type = 0; type < ARRAY_SIZE (types); type++)
if (types[type]
&& VasEBoot_strncmp (arg, types[type],
VasEBoot_strlen (types[type])) == 0)
{
arg += VasEBoot_strlen (types[type]);
break;
}
if (type == ARRAY_SIZE (types))
return VasEBoot_error (VAS_EBOOT_ERR_BAD_ARGUMENT,
"unknown disk type name");
unit = VasEBoot_strtoul (arg, &arg, 10);
if (! (*arg >= 'a' && *arg <= 'z'))
return VasEBoot_error (VAS_EBOOT_ERR_BAD_ARGUMENT,
"only device specifications of form "
"<type><number><lowercase letter> are supported");
part = *arg - 'a';
bootdev = (OPENBSD_B_DEVMAGIC | (type << OPENBSD_B_TYPESHIFT)
| (unit << OPENBSD_B_UNITSHIFT)
| (part << OPENBSD_B_PARTSHIFT));
}
else
bootdev = 0;
if (ctxt->state[OPENBSD_SERIAL_ARG].set)
{
struct VasEBoot_openbsd_bootarg_console serial;
const char *ptr;
unsigned port = 0;
unsigned speed = 9600;
VasEBoot_memset (&serial, 0, sizeof (serial));
if (ctxt->state[OPENBSD_SERIAL_ARG].arg)
{
ptr = ctxt->state[OPENBSD_SERIAL_ARG].arg;
if (VasEBoot_memcmp (ptr, "com", sizeof ("com") - 1) != 0)
return VasEBoot_error (VAS_EBOOT_ERR_BAD_ARGUMENT,
"only com0-com3 are supported");
ptr += sizeof ("com") - 1;
port = VasEBoot_strtoul (ptr, &ptr, 0);
if (port >= 4)
return VasEBoot_error (VAS_EBOOT_ERR_BAD_ARGUMENT,
"only com0-com3 are supported");
if (*ptr == ',')
{
ptr++;
speed = VasEBoot_strtoul (ptr, &ptr, 0);
if (VasEBoot_errno)
return VasEBoot_errno;
}
}
serial.device = (VAS_EBOOT_OPENBSD_COM_MAJOR << 8) | port;
serial.speed = speed;
serial.addr = VasEBoot_ns8250_hw_get_port (port);
VasEBoot_bsd_add_meta (OPENBSD_BOOTARG_CONSOLE, &serial, sizeof (serial));
bootflags |= OPENBSD_RB_SERCONS;
}
else
{
struct VasEBoot_openbsd_bootarg_console serial;
VasEBoot_memset (&serial, 0, sizeof (serial));
serial.device = (VAS_EBOOT_OPENBSD_VGA_MAJOR << 8);
serial.addr = 0xffffffff;
VasEBoot_bsd_add_meta (OPENBSD_BOOTARG_CONSOLE, &serial, sizeof (serial));
bootflags &= ~OPENBSD_RB_SERCONS;
}
if (VasEBoot_bsd_load (argc, argv) == VAS_EBOOT_ERR_NONE)
{
VasEBoot_loader_set (VasEBoot_openbsd_boot, VasEBoot_bsd_unload, 0);
openbsd_root = bootdev;
}
return VasEBoot_errno;
}
static VasEBoot_err_t
VasEBoot_cmd_netbsd (VasEBoot_extcmd_context_t ctxt, int argc, char *argv[])
{
VasEBoot_err_t err;
kernel_type = KERNEL_TYPE_NETBSD;
bootflags = VasEBoot_bsd_parse_flags (ctxt->state, netbsd_flags);
if (VasEBoot_bsd_load (argc, argv) == VAS_EBOOT_ERR_NONE)
{
if (is_elf_kernel)
{
VasEBoot_file_t file;
file = VasEBoot_file_open (argv[0], VAS_EBOOT_FILE_TYPE_BSD_KERNEL);
if (! file)
return VasEBoot_errno;
if (is_64bit)
err = VasEBoot_netbsd_load_elf_meta64 (relocator, file, argv[0], &kern_end);
else
err = VasEBoot_netbsd_load_elf_meta32 (relocator, file, argv[0], &kern_end);
if (err)
return err;
}
{
char bootpath[VAS_EBOOT_NETBSD_MAX_BOOTPATH_LEN];
char *name;
name = VasEBoot_strrchr (argv[0], '/');
if (name)
name++;
else
name = argv[0];
VasEBoot_memset (bootpath, 0, sizeof (bootpath));
VasEBoot_strncpy (bootpath, name, sizeof (bootpath) - 1);
VasEBoot_bsd_add_meta (NETBSD_BTINFO_BOOTPATH, bootpath, sizeof (bootpath));
}
if (ctxt->state[NETBSD_ROOT_ARG].set)
{
char root[VAS_EBOOT_NETBSD_MAX_ROOTDEVICE_LEN];
VasEBoot_memset (root, 0, sizeof (root));
VasEBoot_strncpy (root, ctxt->state[NETBSD_ROOT_ARG].arg,
sizeof (root) - 1);
VasEBoot_bsd_add_meta (NETBSD_BTINFO_ROOTDEVICE, root, sizeof (root));
}
if (ctxt->state[NETBSD_SERIAL_ARG].set)
{
struct VasEBoot_netbsd_btinfo_serial serial;
const char *ptr;
VasEBoot_memset (&serial, 0, sizeof (serial));
VasEBoot_strcpy (serial.devname, "com");
serial.addr = VasEBoot_ns8250_hw_get_port (0);
serial.speed = 9600;
if (ctxt->state[NETBSD_SERIAL_ARG].arg)
{
ptr = ctxt->state[NETBSD_SERIAL_ARG].arg;
if (VasEBoot_memcmp (ptr, "com", sizeof ("com") - 1) == 0)
{
ptr += sizeof ("com") - 1;
serial.addr
= VasEBoot_ns8250_hw_get_port (VasEBoot_strtoul (ptr, &ptr, 0));
}
else
serial.addr = VasEBoot_strtoul (ptr, &ptr, 0);
if (VasEBoot_errno)
return VasEBoot_errno;
if (*ptr == ',')
{
ptr++;
serial.speed = VasEBoot_strtoul (ptr, &ptr, 0);
if (VasEBoot_errno)
return VasEBoot_errno;
}
}
VasEBoot_bsd_add_meta (NETBSD_BTINFO_CONSOLE, &serial, sizeof (serial));
}
else
{
struct VasEBoot_netbsd_btinfo_serial cons;
VasEBoot_memset (&cons, 0, sizeof (cons));
VasEBoot_strcpy (cons.devname, "pc");
VasEBoot_bsd_add_meta (NETBSD_BTINFO_CONSOLE, &cons, sizeof (cons));
}
VasEBoot_netbsd_add_boot_disk_and_wedge ();
VasEBoot_loader_set (VasEBoot_netbsd_boot, VasEBoot_bsd_unload, 0);
}
return VasEBoot_errno;
}
static VasEBoot_err_t
VasEBoot_cmd_freebsd_loadenv (VasEBoot_command_t cmd __attribute__ ((unused)),
int argc, char *argv[])
{
VasEBoot_file_t file = 0;
char *buf = 0, *curr, *next;
int len;
if (! VasEBoot_loader_is_loaded ())
return VasEBoot_error (VAS_EBOOT_ERR_BAD_ARGUMENT,
N_("you need to load the kernel first"));
if (kernel_type != KERNEL_TYPE_FREEBSD)
return VasEBoot_error (VAS_EBOOT_ERR_BAD_ARGUMENT,
"only FreeBSD supports environment");
if (argc == 0)
{
VasEBoot_error (VAS_EBOOT_ERR_BAD_ARGUMENT, N_("filename expected"));
goto fail;
}
file = VasEBoot_file_open (argv[0], VAS_EBOOT_FILE_TYPE_FREEBSD_ENV);
if ((!file) || (!file->size))
goto fail;
len = file->size;
buf = VasEBoot_malloc (len + 1);
if (!buf)
goto fail;
if (VasEBoot_file_read (file, buf, len) != len)
goto fail;
buf[len] = 0;
next = buf;
while (next)
{
char *p;
curr = next;
next = VasEBoot_strchr (curr, '\n');
if (next)
{
p = next - 1;
while (p > curr)
{
if ((*p != '\r') && (*p != ' ') && (*p != '\t'))
break;
p--;
}
if ((p > curr) && (*p == '"'))
p--;
*(p + 1) = 0;
next++;
}
if (*curr == '#')
continue;
p = VasEBoot_strchr (curr, '=');
if (!p)
continue;
*(p++) = 0;
if (*curr)
{
char *name;
if (*p == '"')
p++;
name = VasEBoot_xasprintf ("kFreeBSD.%s", curr);
if (!name)
goto fail;
if (VasEBoot_env_set (name, p))
{
VasEBoot_free (name);
goto fail;
}
VasEBoot_free (name);
}
}
fail:
VasEBoot_free (buf);
if (file)
VasEBoot_file_close (file);
return VasEBoot_errno;
}
static VasEBoot_err_t
VasEBoot_cmd_freebsd_module (VasEBoot_command_t cmd __attribute__ ((unused)),
int argc, char *argv[])
{
VasEBoot_file_t file = 0;
int modargc;
char **modargv;
const char *type;
VasEBoot_err_t err;
void *src;
if (! VasEBoot_loader_is_loaded ())
return VasEBoot_error (VAS_EBOOT_ERR_BAD_ARGUMENT,
N_("you need to load the kernel first"));
if (kernel_type != KERNEL_TYPE_FREEBSD)
return VasEBoot_error (VAS_EBOOT_ERR_BAD_ARGUMENT, "no FreeBSD loaded");
if (!is_elf_kernel)
return VasEBoot_error (VAS_EBOOT_ERR_BAD_ARGUMENT,
"only ELF kernel supports module");
/* List the current modules if no parameter. */
if (!argc)
{
VasEBoot_freebsd_list_modules ();
return 0;
}
file = VasEBoot_file_open (argv[0], VAS_EBOOT_FILE_TYPE_FREEBSD_MODULE);
if ((!file) || (!file->size))
goto fail;
{
VasEBoot_relocator_chunk_t ch;
err = VasEBoot_relocator_alloc_chunk_addr (relocator, &ch, kern_end,
file->size);
if (err)
goto fail;
src = get_virtual_current_address (ch);
}
VasEBoot_file_read (file, src, file->size);
if (VasEBoot_errno)
goto fail;
modargc = argc - 1;
modargv = argv + 1;
if (modargc && (! VasEBoot_memcmp (modargv[0], "type=", 5)))
{
type = &modargv[0][5];
modargc--;
modargv++;
}
else
type = FREEBSD_MODTYPE_RAW;
err = VasEBoot_freebsd_add_meta_module (argv[0], type, modargc, modargv,
kern_end, file->size);
if (err)
goto fail;
kern_end = ALIGN_PAGE (kern_end + file->size);
fail:
if (file)
VasEBoot_file_close (file);
return VasEBoot_errno;
}
static VasEBoot_err_t
VasEBoot_netbsd_module_load (char *filename, VasEBoot_uint32_t type)
{
VasEBoot_file_t file = 0;
void *src;
VasEBoot_err_t err;
file = VasEBoot_file_open (filename, VAS_EBOOT_FILE_TYPE_NETBSD_MODULE);
if ((!file) || (!file->size))
goto fail;
{
VasEBoot_relocator_chunk_t ch;
err = VasEBoot_relocator_alloc_chunk_addr (relocator, &ch, kern_end,
file->size);
if (err)
goto fail;
src = get_virtual_current_address (ch);
}
VasEBoot_file_read (file, src, file->size);
if (VasEBoot_errno)
goto fail;
err = VasEBoot_netbsd_add_meta_module (filename, type, kern_end, file->size);
if (err)
goto fail;
kern_end = ALIGN_PAGE (kern_end + file->size);
fail:
if (file)
VasEBoot_file_close (file);
return VasEBoot_errno;
}
static VasEBoot_err_t
VasEBoot_cmd_netbsd_module (VasEBoot_command_t cmd,
int argc, char *argv[])
{
VasEBoot_uint32_t type;
if (! VasEBoot_loader_is_loaded ())
return VasEBoot_error (VAS_EBOOT_ERR_BAD_ARGUMENT,
N_("you need to load the kernel first"));
if (kernel_type != KERNEL_TYPE_NETBSD)
return VasEBoot_error (VAS_EBOOT_ERR_BAD_ARGUMENT, "no NetBSD loaded");
if (!is_elf_kernel)
return VasEBoot_error (VAS_EBOOT_ERR_BAD_ARGUMENT,
"only ELF kernel supports module");
/* List the current modules if no parameter. */
if (!argc)
{
VasEBoot_netbsd_list_modules ();
return 0;
}
if (VasEBoot_strcmp (cmd->name, "knetbsd_module_elf") == 0)
type = VAS_EBOOT_NETBSD_MODULE_ELF;
else
type = VAS_EBOOT_NETBSD_MODULE_RAW;
return VasEBoot_netbsd_module_load (argv[0], type);
}
static VasEBoot_err_t
VasEBoot_cmd_freebsd_module_elf (VasEBoot_command_t cmd __attribute__ ((unused)),
int argc, char *argv[])
{
VasEBoot_file_t file = 0;
VasEBoot_err_t err;
if (! VasEBoot_loader_is_loaded ())
return VasEBoot_error (VAS_EBOOT_ERR_BAD_ARGUMENT,
N_("you need to load the kernel first"));
if (kernel_type != KERNEL_TYPE_FREEBSD)
return VasEBoot_error (VAS_EBOOT_ERR_BAD_ARGUMENT,
"only FreeBSD supports module");
if (! is_elf_kernel)
return VasEBoot_error (VAS_EBOOT_ERR_BAD_ARGUMENT,
"only ELF kernel supports module");
/* List the current modules if no parameter. */
if (! argc)
{
VasEBoot_freebsd_list_modules ();
return 0;
}
file = VasEBoot_file_open (argv[0], VAS_EBOOT_FILE_TYPE_FREEBSD_MODULE_ELF);
if (!file)
return VasEBoot_errno;
if (!file->size)
{
VasEBoot_file_close (file);
return VasEBoot_errno;
}
if (is_64bit)
err = VasEBoot_freebsd_load_elfmodule_obj64 (relocator, file,
argc, argv, &kern_end);
else
err = VasEBoot_freebsd_load_elfmodule32 (relocator, file,
argc, argv, &kern_end);
VasEBoot_file_close (file);
return err;
}
static VasEBoot_err_t
VasEBoot_cmd_openbsd_ramdisk (VasEBoot_command_t cmd __attribute__ ((unused)),
int argc, char *args[])
{
VasEBoot_file_t file;
VasEBoot_size_t size;
if (argc != 1)
return VasEBoot_error (VAS_EBOOT_ERR_BAD_ARGUMENT, N_("filename expected"));
if (! VasEBoot_loader_is_loaded ())
return VasEBoot_error (VAS_EBOOT_ERR_BAD_ARGUMENT,
N_("you need to load the kernel first"));
if (kernel_type != KERNEL_TYPE_OPENBSD)
return VasEBoot_error (VAS_EBOOT_ERR_BAD_OS, "no kOpenBSD loaded");
if (!openbsd_ramdisk.max_size)
return VasEBoot_error (VAS_EBOOT_ERR_BAD_OS, "your kOpenBSD doesn't support ramdisk");
file = VasEBoot_file_open (args[0], VAS_EBOOT_FILE_TYPE_OPENBSD_RAMDISK);
if (! file)
return VasEBoot_errno;
size = VasEBoot_file_size (file);
if (size > openbsd_ramdisk.max_size)
{
VasEBoot_file_close (file);
return VasEBoot_error (VAS_EBOOT_ERR_BAD_OS, "your kOpenBSD supports ramdisk only"
" up to %" PRIuVAS_EBOOT_SIZE " bytes, however you supplied"
" a %" PRIuVAS_EBOOT_SIZE " bytes one",
openbsd_ramdisk.max_size, size);
}
if (VasEBoot_file_read (file, openbsd_ramdisk.target, size)
!= (VasEBoot_ssize_t) (size))
{
VasEBoot_file_close (file);
if (!VasEBoot_errno)
VasEBoot_error (VAS_EBOOT_ERR_BAD_OS, N_("premature end of file %s"), args[0]);
return VasEBoot_errno;
}
VasEBoot_memset (openbsd_ramdisk.target + size, 0,
openbsd_ramdisk.max_size - size);
*openbsd_ramdisk.size = ALIGN_UP (size, 512);
return VAS_EBOOT_ERR_NONE;
}
static VasEBoot_extcmd_t cmd_freebsd, cmd_openbsd, cmd_netbsd;
static VasEBoot_command_t cmd_freebsd_loadenv, cmd_freebsd_module;
static VasEBoot_command_t cmd_netbsd_module, cmd_freebsd_module_elf;
static VasEBoot_command_t cmd_netbsd_module_elf, cmd_openbsd_ramdisk;
VAS_EBOOT_MOD_INIT (bsd)
{
/* Net and OpenBSD kernels are often compressed. */
VasEBoot_dl_load ("gzio");
cmd_freebsd = VasEBoot_register_extcmd ("kfreebsd", VasEBoot_cmd_freebsd, 0,
N_("FILE"), N_("Load kernel of FreeBSD."),
freebsd_opts);
cmd_openbsd = VasEBoot_register_extcmd ("kopenbsd", VasEBoot_cmd_openbsd, 0,
N_("FILE"), N_("Load kernel of OpenBSD."),
openbsd_opts);
cmd_netbsd = VasEBoot_register_extcmd ("knetbsd", VasEBoot_cmd_netbsd, 0,
N_("FILE"), N_("Load kernel of NetBSD."),
netbsd_opts);
cmd_freebsd_loadenv =
VasEBoot_register_command ("kfreebsd_loadenv", VasEBoot_cmd_freebsd_loadenv,
0, N_("Load FreeBSD env."));
cmd_freebsd_module =
VasEBoot_register_command ("kfreebsd_module", VasEBoot_cmd_freebsd_module,
0, N_("Load FreeBSD kernel module."));
cmd_netbsd_module =
VasEBoot_register_command ("knetbsd_module", VasEBoot_cmd_netbsd_module,
0, N_("Load NetBSD kernel module."));
cmd_netbsd_module_elf =
VasEBoot_register_command ("knetbsd_module_elf", VasEBoot_cmd_netbsd_module,
0, N_("Load NetBSD kernel module (ELF)."));
cmd_freebsd_module_elf =
VasEBoot_register_command ("kfreebsd_module_elf", VasEBoot_cmd_freebsd_module_elf,
0, N_("Load FreeBSD kernel module (ELF)."));
cmd_openbsd_ramdisk = VasEBoot_register_command ("kopenbsd_ramdisk",
VasEBoot_cmd_openbsd_ramdisk, 0,
/* TRANSLATORS: ramdisk isn't identifier,
it can be translated. */
N_("Load kOpenBSD ramdisk."));
my_mod = mod;
}
VAS_EBOOT_MOD_FINI (bsd)
{
VasEBoot_unregister_extcmd (cmd_freebsd);
VasEBoot_unregister_extcmd (cmd_openbsd);
VasEBoot_unregister_extcmd (cmd_netbsd);
VasEBoot_unregister_command (cmd_freebsd_loadenv);
VasEBoot_unregister_command (cmd_freebsd_module);
VasEBoot_unregister_command (cmd_netbsd_module);
VasEBoot_unregister_command (cmd_freebsd_module_elf);
VasEBoot_unregister_command (cmd_netbsd_module_elf);
VasEBoot_unregister_command (cmd_openbsd_ramdisk);
VasEBoot_bsd_unload ();
}
Reference in New Issue View Git Blame Copy Permalink