static int
multiboot_obj_loadfile(char *filename, u_int64_t dest,
struct preloaded_file **result)
{
struct preloaded_file *mfp, *kfp, *rfp;
int error, mod_num;
/* See if there's a aout multiboot kernel loaded */
mfp = file_findfile(NULL, "aout multiboot kernel");
if (mfp != NULL) {
/* we have normal kernel loaded, add module */
rfp = file_loadraw(filename, "module", 0, NULL, 0);
if (rfp == NULL) {
printf(
"Unable to load %s as a multiboot payload module\n",
filename);
return (EINVAL);
}
rfp->f_size = roundup(rfp->f_size, PAGE_SIZE);
*result = rfp;
return (0);
}
/* See if there's a multiboot kernel loaded */
mfp = file_findfile(NULL, "elf multiboot kernel");
if (mfp == NULL) {
return (EFTYPE); /* this allows to check other methods */
}
/*
* We have a multiboot kernel loaded, see if there's a
* kernel loaded also.
*/
kfp = file_findfile(NULL, "elf kernel");
if (kfp == NULL) {
/*
* No kernel loaded, this must be it. The kernel has to
* be loaded as a raw file, it will be processed by
* Xen and correctly loaded as an ELF file.
*/
rfp = file_loadraw(filename, "elf kernel", 0, NULL, 0);
if (rfp == NULL) {
printf(
"Unable to load %s as a multiboot payload kernel\n",
filename);
return (EINVAL);
}
/* Load kernel metadata... */
setenv("kernelname", filename, 1);
error = elf64_load_modmetadata(rfp, rfp->f_addr + rfp->f_size);
if (error) {
printf("Unable to load kernel %s metadata error: %d\n",
rfp->f_name, error);
return (EINVAL);
}
/*
* Save space at the end of the kernel in order to place
* the metadata information. We do an approximation of the
* max metadata size, this is not optimal but it's probably
* the best we can do at this point. Once all modules are
* loaded and the size of the metadata is known this
* space will be recovered if not used.
*/
mod_num = num_modules(rfp);
rfp->f_size = roundup(rfp->f_size, PAGE_SIZE);
rfp->f_size += METADATA_RESV_SIZE(mod_num);
*result = rfp;
} else {
/* The rest should be loaded as regular modules */
error = elf64_obj_loadfile(filename, dest, result);
if (error != 0) {
printf("Unable to load %s as an object file, error: %d",
filename, error);
return (error);
}
}
return (0);
}
static int
multiboot_exec(struct preloaded_file *fp)
{
vm_offset_t module_start, last_addr, metadata_size;
vm_offset_t modulep, kernend, entry;
struct file_metadata *md;
Elf_Ehdr *ehdr;
struct multiboot_info *mb_info = NULL;
struct multiboot_mod_list *mb_mod = NULL;
char *cmdline = NULL;
size_t len;
int error, mod_num;
/*
* Don't pass the memory size found by the bootloader, the memory
* available to Dom0 will be lower than that.
*/
unsetenv("smbios.memory.enabled");
/* Allocate the multiboot struct and fill the basic details. */
mb_info = malloc(sizeof(struct multiboot_info));
if (mb_info == NULL) {
error = ENOMEM;
goto error;
}
bzero(mb_info, sizeof(struct multiboot_info));
mb_info->flags = MULTIBOOT_INFO_MEMORY|MULTIBOOT_INFO_BOOT_LOADER_NAME;
mb_info->mem_lower = bios_basemem / 1024;
mb_info->mem_upper = bios_extmem / 1024;
mb_info->boot_loader_name = VTOP(mbl_name);
/* Set the Xen command line. */
if (fp->f_args == NULL) {
/* Add the Xen command line if it is set. */
cmdline = getenv("xen_cmdline");
if (cmdline != NULL) {
fp->f_args = strdup(cmdline);
if (fp->f_args == NULL) {
error = ENOMEM;
goto error;
}
}
}
if (fp->f_args != NULL) {
len = strlen(fp->f_name) + 1 + strlen(fp->f_args) + 1;
cmdline = malloc(len);
if (cmdline == NULL) {
error = ENOMEM;
goto error;
}
snprintf(cmdline, len, "%s %s", fp->f_name, fp->f_args);
mb_info->cmdline = VTOP(cmdline);
mb_info->flags |= MULTIBOOT_INFO_CMDLINE;
}
/* Find the entry point of the Xen kernel and save it for later */
if ((md = file_findmetadata(fp, MODINFOMD_ELFHDR)) == NULL) {
printf("Unable to find %s entry point\n", fp->f_name);
error = EINVAL;
goto error;
}
ehdr = (Elf_Ehdr *)&(md->md_data);
entry = ehdr->e_entry & 0xffffff;
/*
* Prepare the multiboot module list, Xen assumes the first
* module is the Dom0 kernel, and the second one is the initramfs.
* This is not optimal for FreeBSD, that doesn't have a initramfs
* but instead loads modules dynamically and creates the metadata
* info on-the-fly.
*
* As expected, the first multiboot module is going to be the
* FreeBSD kernel loaded as a raw file. The second module is going
* to contain the metadata info and the loaded modules.
*
* On native FreeBSD loads all the modules and then places the
* metadata info at the end, but this is painful when running on Xen,
* because it relocates the second multiboot module wherever it
* likes. In order to workaround this limitation the metadata
* information is placed at the start of the second module and
* the original modulep value is saved together with the other
* metadata, so we can relocate everything.
*
* Native layout:
* fp->f_addr + fp->f_size
* +---------+----------------+------------+
* | | | |
* | Kernel | Modules | Metadata |
* | | | |
* +---------+----------------+------------+
* fp->f_addr modulep kernend
*
* Xen layout:
*
* Initial:
* fp->f_addr + fp->f_size
* +---------+----------+----------------+------------+
* | | | | |
* | Kernel | Reserved | Modules | Metadata |
* | | | | dry run |
* +---------+----------+----------------+------------+
* fp->f_addr
*
* After metadata polacement (ie: final):
* fp->f_addr + fp->f_size
* +-----------+---------+----------+----------------+
* | | | | |
* | Kernel | Free | Metadata | Modules |
* | | | | |
* +-----------+---------+----------+----------------+
* fp->f_addr modulep kernend
* \__________/ \__________________________/
* Multiboot module 0 Multiboot module 1
*/
fp = file_findfile(NULL, "elf kernel");
if (fp == NULL) {
printf("No FreeBSD kernel provided, aborting\n");
error = EINVAL;
goto error;
}
if (fp->f_metadata != NULL) {
printf("FreeBSD kernel already contains metadata, aborting\n");
error = EINVAL;
goto error;
}
mb_mod = malloc(sizeof(struct multiboot_mod_list) * NUM_MODULES);
if (mb_mod == NULL) {
error = ENOMEM;
goto error;
}
bzero(mb_mod, sizeof(struct multiboot_mod_list) * NUM_MODULES);
/*
* Calculate how much memory is needed for the metatdata. We did
* an approximation of the maximum size when loading the kernel,
* but now we know the exact size, so we can release some of this
* preallocated memory if not needed.
*/
last_addr = roundup(max_addr(), PAGE_SIZE);
mod_num = num_modules(fp);
/*
* Place the metadata after the last used address in order to
* calculate it's size, this will not be used.
*/
error = bi_load64(fp->f_args, last_addr, &modulep, &kernend, 0);
if (error != 0) {
printf("bi_load64 failed: %d\n", error);
goto error;
}
metadata_size = roundup(kernend - last_addr, PAGE_SIZE);
/* Check that the size is not greater than what we have reserved */
if (metadata_size > METADATA_RESV_SIZE(mod_num)) {
printf("Required memory for metadata is greater than reserved "
"space, please increase METADATA_FIXED_SIZE and "
"METADATA_MODULE_SIZE and rebuild the loader\n");
error = ENOMEM;
goto error;
}
/* Clean the metadata added to the kernel in the bi_load64 dry run */
file_removemetadata(fp);
/*
* This is the position where the second multiboot module
* will be placed.
*/
module_start = fp->f_addr + fp->f_size - metadata_size;
error = bi_load64(fp->f_args, module_start, &modulep, &kernend, 0);
if (error != 0) {
printf("bi_load64 failed: %d\n", error);
goto error;
}
mb_mod[0].mod_start = fp->f_addr;
mb_mod[0].mod_end = fp->f_addr + fp->f_size;
mb_mod[0].mod_end -= METADATA_RESV_SIZE(mod_num);
mb_mod[1].mod_start = module_start;
mb_mod[1].mod_end = last_addr;
mb_info->mods_count = NUM_MODULES;
mb_info->mods_addr = VTOP(mb_mod);
mb_info->flags |= MULTIBOOT_INFO_MODS;
dev_cleanup();
__exec((void *)VTOP(multiboot_tramp), (void *)entry,
(void *)VTOP(mb_info));
panic("exec returned");
error:
if (mb_mod)
free(mb_mod);
if (mb_info)
free(mb_info);
if (cmdline)
free(cmdline);
return (error);
}