Aren
/
rulimine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #109 from Andy-Python-Programmer/trunk 

multiboot2: initial support
This commit is contained in:
mint 2021-09-13 04:33:39 +02:00 committed by GitHub
parent 7ad45e8daf 875d90d7a0
commit 90bdd0dca0
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
8 changed files with 944 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CONFIG.md
View File

@ -87,7 +87,7 @@ Some keys take *URIs* as values; these are described in the next section.
*Locally assignable (non protocol specific)* keys are:
* `COMMENT` - An optional comment string that will be displayed by the bootloader on the menu when an entry is selected.
* `PROTOCOL` - The boot protocol that will be used to boot the kernel. Valid protocols are: `linux`, `stivale`, `stivale2`, `chainload`, `multiboot` or `multiboot1`.
* `PROTOCOL` - The boot protocol that will be used to boot the kernel. Valid protocols are: `linux`, `stivale`, `stivale2`, `chainload`, `multiboot` or `multiboot1` and `multiboot2`.
* `CMDLINE` - The command line string to be passed to the kernel. Can be omitted.
* `KERNEL_CMDLINE` - Alias of `CMDLINE`.

1
README.md
View File

@ -20,6 +20,7 @@ Like Limine and want to support it? Donate Bitcoin to
* stivale and stivale2 (Limine's native boot protocols, see [their specifications](https://github.com/stivale/stivale) for details)
* Linux
* Multiboot 1
* Multiboot 2
* Chainloading
### Supported filesystems

3
stage23/entry.s3.c
View File

@ -16,6 +16,7 @@
#include <protos/linux.h>
#include <protos/chainload.h>
#include <protos/multiboot1.h>
#include <protos/multiboot2.h>
#include <menu.h>
#include <pxe/pxe.h>
#include <pxe/tftp.h>
@ -168,6 +169,8 @@ void stage3_common(void) {
chainload(config);
} else if (!strcmp(proto, "multiboot1") || !strcmp(proto, "multiboot")) {
multiboot1_load(config, cmdline);
} else if (!strcmp(proto, "multiboot2")) {
multiboot2_load(config, cmdline);
}
panic("Invalid protocol specified");

38
stage23/lib/elf.c
View File

@ -247,6 +247,44 @@ int elf64_load_section(uint8_t *elf, void *buffer, const char *name, size_t limi
return 2;
}
/// SAFETY: The caller must ensure that the provided `elf` is a valid 64-bit
/// ELF file.
struct elf_section_hdr_info* elf64_section_hdr_info(uint8_t *elf) {
struct elf_section_hdr_info* info = ext_mem_alloc(sizeof(struct elf_section_hdr_info));
struct elf64_hdr hdr;
memcpy(&hdr, elf + (0), sizeof(struct elf64_hdr));
info->num = hdr.sh_num;
info->section_entry_size = hdr.shdr_size;
info->section_hdr_size = info->num * info->section_entry_size;
info->str_section_idx = hdr.shstrndx;
info->section_hdrs = ext_mem_alloc(info->section_hdr_size);
memcpy(info->section_hdrs, elf + (hdr.shoff), info->section_hdr_size);
return info;
}
/// SAFETY: The caller must ensure that the provided `elf` is a valid 32-bit
/// ELF file.
struct elf_section_hdr_info* elf32_section_hdr_info(uint8_t *elf) {
struct elf_section_hdr_info* info = ext_mem_alloc(sizeof(struct elf_section_hdr_info));
struct elf32_hdr hdr;
memcpy(&hdr, elf + (0), sizeof(struct elf32_hdr));
info->num = hdr.sh_num;
info->section_entry_size = hdr.shdr_size;
info->section_hdr_size = info->num * info->section_entry_size;
info->str_section_idx = hdr.shstrndx;
info->section_hdrs = ext_mem_alloc(info->section_hdr_size);
memcpy(info->section_hdrs, elf + (hdr.shoff), info->section_hdr_size);
return info;
}
int elf32_load_section(uint8_t *elf, void *buffer, const char *name, size_t limit) {
struct elf32_hdr hdr;
memcpy(&hdr, elf + (0), sizeof(struct elf32_hdr));

10
stage23/lib/elf.h
View File

@ -17,12 +17,22 @@ struct elf_range {
uint64_t permissions;
};
struct elf_section_hdr_info {
uint32_t section_hdr_size;
uint32_t section_entry_size;
uint32_t str_section_idx;
uint32_t num;
void* section_hdrs;
};
int elf_bits(uint8_t *elf);
int elf64_load(uint8_t *elf, uint64_t *entry_point, uint64_t *top, uint64_t *_slide, uint32_t alloc_type, bool kaslr, bool use_paddr, struct elf_range **ranges, uint64_t *ranges_count);
int elf64_load_section(uint8_t *elf, void *buffer, const char *name, size_t limit, uint64_t slide);
struct elf_section_hdr_info* elf64_section_hdr_info(uint8_t *elf);
int elf32_load(uint8_t *elf, uint32_t *entry_point, uint32_t *top, uint32_t alloc_type);
int elf32_load_section(uint8_t *elf, void *buffer, const char *name, size_t limit);
struct elf_section_hdr_info* elf32_section_hdr_info(uint8_t *elf);
#endif

41
stage23/protos/multiboot2.32.c Normal file
View File

@ -0,0 +1,41 @@
#include <stdint.h>
#include <stddef.h>
#include <stdbool.h>
#include <mm/vmm.h>
#if bios == 1
# include <sys/idt.h>
#endif
__attribute__((noreturn)) void multiboot2_spinup_32(
uint32_t entry_point, uint32_t multiboot2_info) {
#if bios == 1
struct idtr idtr;
idtr.limit = 0x3ff;
idtr.ptr = 0;
asm volatile (
"lidt %0"
:
: "m" (idtr)
: "memory"
);
#endif
asm volatile (
"cld\n\t"
"pushl $0x18\n\t"
"pushl %%edi\n\t"
"movl $0x36D76289, %%eax\n\t"
"lret\n\t"
:
: "D" (entry_point),
"b" (multiboot2_info)
: "memory"
);
__builtin_unreachable();
}

430
stage23/protos/multiboot2.c Normal file
View File

@ -0,0 +1,430 @@
#include <protos/multiboot2.h>
#include <stdint.h>
#include <stddef.h>
#include <lib/libc.h>
#include <lib/elf.h>
#include <lib/blib.h>
#include <lib/config.h>
#include <lib/print.h>
#include <lib/uri.h>
#include <lib/fb.h>
#include <lib/term.h>
#include <sys/pic.h>
#include <sys/cpu.h>
#include <fs/file.h>
#include <mm/vmm.h>
#include <lib/acpi.h>
#include <mm/pmm.h>
#include <lib/blib.h>
#include <drivers/vga_textmode.h>
static struct multiboot_header* load_multiboot2_header(uint8_t* kernel) {
struct multiboot_header* ptr = {0};
struct multiboot_header header;
size_t header_offset = 0;
for (header_offset = 0; header_offset < MULTIBOOT_SEARCH; header_offset += MULTIBOOT_HEADER_ALIGN) {
uint32_t v;
memcpy(&v, kernel + header_offset, 4);
if (v == MULTIBOOT2_HEADER_MAGIC) {
memcpy(&header, kernel + header_offset, sizeof(header));
ptr = ext_mem_alloc(header.header_length);
memcpy(ptr, kernel + header_offset, header.header_length);
break;
}
}
if (ptr->magic != MULTIBOOT2_HEADER_MAGIC) {
panic("multiboot2: could not find header");
} else if (ptr->magic + ptr->architecture + ptr->checksum + ptr->header_length) {
panic("mutliboot2: header checksum is invalid");
}
return ptr;
}
/// Returns the size required to store the multiboot2 info.
static size_t get_multiboot2_info_size(
char* cmdline,
size_t modules_size,
struct elf_section_hdr_info* section_hdr_info
) {
return ALIGN_UP(sizeof(struct multiboot2_start_tag), MULTIBOOT_TAG_ALIGN) + // start
ALIGN_UP(strlen(cmdline) + 1 + offsetof(struct multiboot_tag_string, string), MULTIBOOT_TAG_ALIGN) + // cmdline
ALIGN_UP(8 + offsetof(struct multiboot_tag_string, string), MULTIBOOT_TAG_ALIGN) + // bootloader brand
ALIGN_UP(sizeof(struct multiboot_tag_framebuffer), MULTIBOOT_TAG_ALIGN) + // framebuffer
ALIGN_UP(sizeof(struct multiboot_tag_new_acpi) + 36, MULTIBOOT_TAG_ALIGN) + // new ACPI info
ALIGN_UP(sizeof(struct multiboot_tag_elf_sections) + section_hdr_info->section_hdr_size, MULTIBOOT_TAG_ALIGN) + // ELF info
ALIGN_UP(modules_size, MULTIBOOT_TAG_ALIGN) + // modules
ALIGN_UP(sizeof(struct multiboot_tag_mmap) + sizeof(struct multiboot_mmap_entry) * 256, MULTIBOOT_TAG_ALIGN) + // MMAP
#if uefi == 1
ALIGN_UP(sizeof(struct multiboot_tag_efi_mmap) + (efi_desc_size * 256), MULTIBOOT_TAG_ALIGN) + // EFI MMAP
#endif
ALIGN_UP(sizeof(struct multiboot_tag), MULTIBOOT_TAG_ALIGN); // end
}
#define append_tag(P, TAG) ({ (P) += ALIGN_UP((TAG)->size, MULTIBOOT_TAG_ALIGN); })
void multiboot2_load(char *config, char* cmdline) {
struct file_handle *kernel_file = ext_mem_alloc(sizeof(struct file_handle));
char *kernel_path = config_get_value(config, 0, "KERNEL_PATH");
if (kernel_path == NULL)
panic("multiboot2: KERNEL_PATH not specified");
print("multiboot2: loading kernel `%s`...\n", kernel_path);
if (!uri_open(kernel_file, kernel_path))
panic("multiboot2: failed to open kernel with path `%s`. Is the path correct?", kernel_path);
uint8_t *kernel = freadall(kernel_file, MEMMAP_BOOTLOADER_RECLAIMABLE);
struct multiboot_header* header = load_multiboot2_header(kernel);
uint32_t entry_point;
uint32_t kernel_top;
int bits = elf_bits(kernel);
struct elf_section_hdr_info* section_hdr_info;
switch (bits) {
case 32:
section_hdr_info = elf32_section_hdr_info(kernel);
if (elf32_load(kernel, &entry_point, &kernel_top, MEMMAP_KERNEL_AND_MODULES))
panic("multiboot2: ELF32 load failure");
break;
case 64: {
section_hdr_info = elf64_section_hdr_info(kernel);
uint64_t e, t;
if (elf64_load(kernel, &e, &t, NULL, MEMMAP_KERNEL_AND_MODULES, false, true, NULL, NULL))
panic("multiboot2: ELF64 load failure");
entry_point = e;
kernel_top = t;
break;
}
default:
panic("multiboot2: invalid ELF file bitness");
}
print("multiboot2: found kernel entry point at: %x\n", entry_point);
struct multiboot_header_tag_framebuffer *fbtag = NULL;
bool is_new_acpi_required = false;
// Iterate through the entries...
for (struct multiboot_header_tag* tag = (struct multiboot_header_tag*)(header + 1); // header + 1 to skip the header struct.
tag < (struct multiboot_header_tag*)((uintptr_t)header + header->header_length) && tag->type != MULTIBOOT_HEADER_TAG_END;
tag = (struct multiboot_header_tag*)((uintptr_t)tag + ALIGN_UP(tag->size, MULTIBOOT_TAG_ALIGN))) {
switch (tag->type) {
case MULTIBOOT_HEADER_TAG_INFORMATION_REQUEST: {
// Iterate the requests and check if they are supported by or not.
struct multiboot_header_tag_information_request* request = (void*)tag;
uint32_t size = (request->size - sizeof(struct multiboot_header_tag_information_request))
/ sizeof(uint32_t);
for (uint32_t i = 0; i < size; i++) {
uint32_t r = request->requests[i];
bool is_required = !(tag->flags & MULTIBOOT_HEADER_TAG_OPTIONAL);
switch(r) {
// We already support the following requests:
case MULTIBOOT_TAG_TYPE_CMDLINE:
case MULTIBOOT_TAG_TYPE_BOOT_LOADER_NAME:
case MULTIBOOT_TAG_TYPE_MODULE:
case MULTIBOOT_TAG_TYPE_MMAP:
case MULTIBOOT_TAG_TYPE_EFI_MMAP:
case MULTIBOOT_TAG_TYPE_FRAMEBUFFER:
case MULTIBOOT_TAG_TYPE_ELF_SECTIONS:
break;
case MULTIBOOT_TAG_TYPE_ACPI_NEW: is_new_acpi_required = is_required; break;
default: {
if (!(request->flags & MULTIBOOT_HEADER_TAG_OPTIONAL))
panic("multiboot2: requested tag `%d` which is not supported", r);
} break;
}
}
} break;
case MULTIBOOT_HEADER_TAG_FRAMEBUFFER: {
fbtag = (struct multiboot_header_tag_framebuffer*)tag;
} break;
// We always align the modules ;^)
case MULTIBOOT_HEADER_TAG_MODULE_ALIGN: break;
default: panic("multiboot2: unknown tag type");
}
}
size_t modules_size;
size_t n_modules = 0;
for (n_modules = 0;; n_modules++) {
if (config_get_value(config, modules_size, "MODULE_PATH") == NULL)
break;
char* module_cmdline = config_get_value(config, modules_size, "MODULE_STRING");
modules_size += sizeof(struct multiboot_tag_module) + strlen(module_cmdline) + 1;
}
size_t mb2_info_size = get_multiboot2_info_size(cmdline, modules_size, section_hdr_info);
size_t info_idx = 0;
uint8_t* mb2_info = ext_mem_alloc(mb2_info_size);
struct multiboot2_start_tag* mbi_start = (struct multiboot2_start_tag*)mb2_info;
info_idx += sizeof(struct multiboot2_start_tag);
//////////////////////////////////////////////
// Create modules tag
//////////////////////////////////////////////
for (size_t i = 0; i < n_modules; i++) {
char* module_path = config_get_value(config, i, "MODULE_PATH");
if (module_path == NULL)
panic("multiboot2: Module disappeared unexpectedly");
print("multiboot2: Loading module `%s`...\n", module_path);
struct file_handle f;
if (!uri_open(&f, module_path))
panic("multiboot2: Failed to open module with path `%s`. Is the path correct?", module_path);
char* module_cmdline = config_get_value(config, i, "MODULE_STRING");
void* module_addr = (void *)(uintptr_t)ALIGN_UP(kernel_top, 4096);
// Module commandline can be null, so we guard against that and make the
// string "".
if (module_cmdline == NULL) {
module_cmdline = "";
}
memmap_alloc_range((uintptr_t)module_addr, f.size, MEMMAP_KERNEL_AND_MODULES,
true, true, false, false);
kernel_top = (uintptr_t)module_addr + f.size;
fread(&f, module_addr, 0, f.size);
struct multiboot_tag_module* module_tag = (struct multiboot_tag_module*)(mb2_info + info_idx);
module_tag->type = MULTIBOOT_TAG_TYPE_MODULE;
module_tag->size = sizeof(struct multiboot_tag_module) + strlen(module_cmdline) + 1;
module_tag->mod_start = (uint32_t)(size_t)module_addr;
module_tag->mod_end = module_tag->mod_start + f.size;
strcpy(module_tag->cmdline, module_cmdline); // Copy over the command line
if (verbose) {
print("multiboot2: Requested module %u:\n", i);
print(" Path: %s\n", module_path);
print(" String: \"%s\"\n", module_cmdline ?: "");
print(" Begin: %x\n", module_tag->mod_start);
print(" End: %x\n", module_tag->mod_end);
}
append_tag(mb2_info, module_tag);
}
//////////////////////////////////////////////
// Create command line tag
//////////////////////////////////////////////
{
uint32_t size = strlen(cmdline) + 1 + offsetof(struct multiboot_tag_string, string);
struct multiboot_tag_string* tag = (struct multiboot_tag_string*)(mb2_info + info_idx);
tag->type = MULTIBOOT_TAG_TYPE_CMDLINE;
tag->size = size;
strcpy(tag->string, cmdline);
append_tag(info_idx, tag);
}
//////////////////////////////////////////////
// Create bootloader name tag
//////////////////////////////////////////////
{
char* brand = "Limine";
uint32_t size = sizeof(brand) + offsetof(struct multiboot_tag_string, string);
struct multiboot_tag_string* tag = (struct multiboot_tag_string*)(mb2_info + info_idx);
tag->type = MULTIBOOT_TAG_TYPE_BOOT_LOADER_NAME;
tag->size = size;
strcpy(tag->string, brand);
append_tag(info_idx, tag);
}
//////////////////////////////////////////////
// Create framebuffer tag
//////////////////////////////////////////////
{
if (fbtag) {
size_t req_width = fbtag->width;
size_t req_height = fbtag->height;
size_t req_bpp = 0x00;
char *resolution = config_get_value(config, 0, "RESOLUTION");
if (resolution != NULL)
parse_resolution(&req_width, &req_height, &req_bpp, resolution);
struct fb_info fbinfo;
if (!fb_init(&fbinfo, req_width, req_height, req_bpp))
panic("mutltiboot2: Unable to set video mode");
memmap_alloc_range(fbinfo.framebuffer_addr,
(uint64_t)fbinfo.framebuffer_pitch * fbinfo.framebuffer_height,
MEMMAP_FRAMEBUFFER, false, false, false, true);
struct multiboot_tag_framebuffer* tag = (struct multiboot_tag_framebuffer*)(mb2_info + info_idx);
tag->common.type = MULTIBOOT_TAG_TYPE_FRAMEBUFFER;
tag->common.size = sizeof(struct multiboot_tag_framebuffer);
tag->common.framebuffer_addr = fbinfo.framebuffer_addr;
tag->common.framebuffer_pitch = fbinfo.framebuffer_pitch;
tag->common.framebuffer_width = fbinfo.framebuffer_width;
tag->common.framebuffer_height = fbinfo.framebuffer_height;
tag->common.framebuffer_bpp = fbinfo.framebuffer_bpp;
tag->common.framebuffer_type = MULTIBOOT_FRAMEBUFFER_TYPE_RGB; // We only support RGB for VBE
tag->framebuffer_red_field_position = fbinfo.red_mask_shift;
tag->framebuffer_red_mask_size = fbinfo.red_mask_size;
tag->framebuffer_green_field_position = fbinfo.green_mask_shift;
tag->framebuffer_green_mask_size = fbinfo.green_mask_size;
tag->framebuffer_blue_field_position = fbinfo.blue_mask_shift;
tag->framebuffer_blue_mask_size = fbinfo.blue_mask_size;
info_idx += tag->common.size;
} else {
#if uefi == 1
panic("multiboot2: cannot use text mode with UEFI");
#elif bios == 1
size_t rows, cols;
init_vga_textmode(&rows, &cols, false);
#endif
}
}
//////////////////////////////////////////////
// Create new ACPI info tag
//////////////////////////////////////////////
{
void* new_rsdp = acpi_get_rsdp();
if (new_rsdp != NULL) {
uint32_t size = sizeof(struct multiboot_tag_new_acpi) + 36; // XSDP is 36 bytes wide
struct multiboot_tag_new_acpi* tag = (struct multiboot_tag_new_acpi*)(mb2_info + info_idx);
tag->type = MULTIBOOT_TAG_TYPE_ACPI_NEW;
tag->size = size;
memcpy(tag->rsdp, new_rsdp, 36);
append_tag(info_idx, tag);
} else if (is_new_acpi_required) {
panic("multiboot2: new ACPI table not present");
}
}
//////////////////////////////////////////////
// Create ELF info tag
//////////////////////////////////////////////
{
uint32_t size = sizeof(struct multiboot_tag_elf_sections) + section_hdr_info->section_hdr_size;
struct multiboot_tag_elf_sections* tag = (struct multiboot_tag_elf_sections*)(mb2_info + info_idx);
tag->type = MULTIBOOT_TAG_TYPE_ELF_SECTIONS;
tag->size = size;
tag->num = section_hdr_info->num;
tag->entsize = section_hdr_info->section_entry_size;
tag->shndx = section_hdr_info->str_section_idx;
memcpy(tag->sections, section_hdr_info->section_hdrs, section_hdr_info->section_hdr_size);
append_tag(info_idx, tag);
}
#if uefi == 1
efi_exit_boot_services();
#endif
//////////////////////////////////////////////
// Create memory map tag
//////////////////////////////////////////////
{
size_t mb_mmap_count;
struct e820_entry_t *raw_memmap = get_raw_memmap(&mb_mmap_count);
if (mb_mmap_count > 256) {
panic("multiboot2: too many memory map entries");
}
// Create the normal memory map tag.
uint32_t mmap_size = sizeof(struct multiboot_tag_mmap) + sizeof(struct multiboot_mmap_entry) * mb_mmap_count;
struct multiboot_tag_mmap* mmap_tag = (struct multiboot_tag_mmap*)(mb2_info + info_idx);
mmap_tag->type = MULTIBOOT_TAG_TYPE_MMAP;
mmap_tag->entry_size = sizeof(struct multiboot_mmap_entry);
mmap_tag->entry_version = 0;
mmap_tag->size = mmap_size;
for (size_t i = 0; i < mb_mmap_count; i++) {
struct multiboot_mmap_entry* entry = &mmap_tag->entries[i];
entry->addr = raw_memmap[i].base;
entry->len = raw_memmap[i].length;
entry->type = raw_memmap[i].type;
entry->zero = 0;
}
append_tag(info_idx, mmap_tag);
}
//////////////////////////////////////////////
// Create EFI memory map tag
//////////////////////////////////////////////
#if uefi == 1
{
if ((efi_mmap_size / efi_desc_size) > 256) {
panic("multiboot2: too many EFI memory map entries");
}
// Create the EFI memory map tag.
uint32_t size = sizeof(struct multiboot_tag_efi_mmap) * efi_mmap_size;
struct multiboot_tag_efi_mmap* mmap_tag = (struct multiboot_tag_efi_mmap*)(mb2_info + info_idx);
mmap_tag->type = MULTIBOOT_TAG_TYPE_EFI_MMAP;
mmap_tag->descr_vers = efi_desc_ver;
mmap_tag->descr_size = efi_desc_size;
mmap_tag->size = size;
// Copy over the EFI memory map.
memcpy(mmap_tag->efi_mmap, efi_mmap, efi_mmap_size);
append_tag(info_idx, mmap_tag);
}
#endif
//////////////////////////////////////////////
// Create end tag
//////////////////////////////////////////////
{
struct multiboot_tag* end_tag = (struct multiboot_tag*)(mb2_info + info_idx);
end_tag->type = MULTIBOOT_TAG_TYPE_END;
end_tag->size = sizeof(struct multiboot_tag);
append_tag(info_idx, end_tag);
}
mbi_start->size = mb2_info_size;
mbi_start->reserved = 0x00;
common_spinup(multiboot2_spinup_32, 2,
entry_point, (uint32_t)(uintptr_t)mbi_start);
}

420
stage23/protos/multiboot2.h Normal file
View File

@ -0,0 +1,420 @@
/* multiboot2.h - Multiboot 2 header file. Copied from the multiboot2 specs /
/ Copyright (C) 1999,2003,2007,2008,2009,2010 Free Software Foundation, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to
* deal in the Software without restriction, including without limitation the
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
* sell copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL ANY
* DEVELOPER OR DISTRIBUTOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
* IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#ifndef __PROTOS__MULTIBOOT2_H__
#define __PROTOS__MULTIBOOT2_H__
#include <stdint.h>
void multiboot2_load(char *config, char* cmdline);
/* How many bytes from the start of the file we search for the header. */
#define MULTIBOOT_SEARCH 32768
#define MULTIBOOT_HEADER_ALIGN 8
/* The magic field should contain this. */
#define MULTIBOOT2_HEADER_MAGIC 0xe85250d6
/* This should be in %eax. */
#define MULTIBOOT2_BOOTLOADER_MAGIC 0x36d76289
/* Alignment of multiboot modules. */
#define MULTIBOOT_MOD_ALIGN 0x00001000
/* Alignment of the multiboot info structure. */
#define MULTIBOOT_INFO_ALIGN 0x00000008
/* Flags set in the ’flags’ member of the multiboot header. */
#define MULTIBOOT_TAG_ALIGN 8
#define MULTIBOOT_TAG_TYPE_END 0
#define MULTIBOOT_TAG_TYPE_CMDLINE 1
#define MULTIBOOT_TAG_TYPE_BOOT_LOADER_NAME 2
#define MULTIBOOT_TAG_TYPE_MODULE 3
#define MULTIBOOT_TAG_TYPE_BASIC_MEMINFO 4
#define MULTIBOOT_TAG_TYPE_BOOTDEV 5
#define MULTIBOOT_TAG_TYPE_MMAP 6
#define MULTIBOOT_TAG_TYPE_VBE 7
#define MULTIBOOT_TAG_TYPE_FRAMEBUFFER 8
#define MULTIBOOT_TAG_TYPE_ELF_SECTIONS 9
#define MULTIBOOT_TAG_TYPE_APM 10
#define MULTIBOOT_TAG_TYPE_EFI32 11
#define MULTIBOOT_TAG_TYPE_EFI64 12
#define MULTIBOOT_TAG_TYPE_SMBIOS 13
#define MULTIBOOT_TAG_TYPE_ACPI_OLD 14
#define MULTIBOOT_TAG_TYPE_ACPI_NEW 15
#define MULTIBOOT_TAG_TYPE_NETWORK 16
#define MULTIBOOT_TAG_TYPE_EFI_MMAP 17
#define MULTIBOOT_TAG_TYPE_EFI_BS 18
#define MULTIBOOT_TAG_TYPE_EFI32_IH 19
#define MULTIBOOT_TAG_TYPE_EFI64_IH 20
#define MULTIBOOT_TAG_TYPE_LOAD_BASE_ADDR 21
#define MULTIBOOT_HEADER_TAG_END 0
#define MULTIBOOT_HEADER_TAG_INFORMATION_REQUEST 1
#define MULTIBOOT_HEADER_TAG_ADDRESS 2
#define MULTIBOOT_HEADER_TAG_ENTRY_ADDRESS 3
#define MULTIBOOT_HEADER_TAG_CONSOLE_FLAGS 4
#define MULTIBOOT_HEADER_TAG_FRAMEBUFFER 5
#define MULTIBOOT_HEADER_TAG_MODULE_ALIGN 6
#define MULTIBOOT_HEADER_TAG_EFI_BS 7
#define MULTIBOOT_HEADER_TAG_ENTRY_ADDRESS_EFI32 8
#define MULTIBOOT_HEADER_TAG_ENTRY_ADDRESS_EFI64 9
#define MULTIBOOT_HEADER_TAG_RELOCATABLE 10
#define MULTIBOOT_ARCHITECTURE_I386 0
#define MULTIBOOT_ARCHITECTURE_MIPS32 4
#define MULTIBOOT_HEADER_TAG_OPTIONAL 1
#define MULTIBOOT_LOAD_PREFERENCE_NONE 0
#define MULTIBOOT_LOAD_PREFERENCE_LOW 1
#define MULTIBOOT_LOAD_PREFERENCE_HIGH 2
#define MULTIBOOT_CONSOLE_FLAGS_CONSOLE_REQUIRED 1
#define MULTIBOOT_CONSOLE_FLAGS_EGA_TEXT_SUPPORTED 2
struct multiboot_header
{
/* Must be MULTIBOOT_MAGIC - see above. */
uint32_t magic;
/* ISA */
uint32_t architecture;
/* Total header length. */
uint32_t header_length;
/* The above fields plus this one must equal 0 mod 2^32. */
uint32_t checksum;
};
struct multiboot_header_tag
{
uint16_t type;
uint16_t flags;
uint32_t size;
};
struct multiboot_header_tag_information_request
{
uint16_t type;
uint16_t flags;
uint32_t size;
uint32_t requests[0];
};
struct multiboot2_start_tag {
uint32_t size;
uint32_t reserved;
};
struct multiboot_header_tag_address
{
uint16_t type;
uint16_t flags;
uint32_t size;
uint32_t header_addr;
uint32_t load_addr;
uint32_t load_end_addr;
uint32_t bss_end_addr;
};
struct multiboot_header_tag_entry_address
{
uint16_t type;
uint16_t flags;
uint32_t size;
uint32_t entry_addr;
};
struct multiboot_header_tag_console_flags
{
uint16_t type;
uint16_t flags;
uint32_t size;
uint32_t console_flags;
};
struct multiboot_header_tag_framebuffer
{
uint16_t type;
uint16_t flags;
uint32_t size;
uint32_t width;
uint32_t height;
uint32_t depth;
};
struct multiboot_header_tag_module_align
{
uint16_t type;
uint16_t flags;
uint32_t size;
};
struct multiboot_header_tag_relocatable
{
uint16_t type;
uint16_t flags;
uint32_t size;
uint32_t min_addr;
uint32_t max_addr;
uint32_t align;
uint32_t preference;
};
struct multiboot_color
{
uint8_t red;
uint8_t green;
uint8_t blue;
};
struct multiboot_mmap_entry
{
uint64_t addr;
uint64_t len;
#define MULTIBOOT_MEMORY_AVAILABLE 1
#define MULTIBOOT_MEMORY_RESERVED 2
#define MULTIBOOT_MEMORY_ACPI_RECLAIMABLE 3
#define MULTIBOOT_MEMORY_NVS 4
#define MULTIBOOT_MEMORY_BADRAM 5
uint32_t type;
uint32_t zero;
};
typedef struct multiboot_mmap_entry multiboot_memory_map_t;
struct multiboot_tag
{
uint32_t type;
uint32_t size;
};
struct multiboot_tag_string
{
uint32_t type;
uint32_t size;
char string[0];
};
struct multiboot_tag_module
{
uint32_t type;
uint32_t size;
uint32_t mod_start;
uint32_t mod_end;
char cmdline[0];
};
struct multiboot_tag_basic_meminfo
{
uint32_t type;
uint32_t size;
uint32_t mem_lower;
uint32_t mem_upper;
};
struct multiboot_tag_bootdev
{
uint32_t type;
uint32_t size;
uint32_t biosdev;
uint32_t slice;
uint32_t part;
};
struct multiboot_tag_mmap
{
uint32_t type;
uint32_t size;
uint32_t entry_size;
uint32_t entry_version;
struct multiboot_mmap_entry entries[0];
};
struct multiboot_vbe_info_block
{
uint8_t external_specification[512];
};
struct multiboot_vbe_mode_info_block
{
uint8_t external_specification[256];
};
struct multiboot_tag_vbe
{
uint32_t type;
uint32_t size;
uint16_t vbe_mode;
uint16_t vbe_interface_seg;
uint16_t vbe_interface_off;
uint16_t vbe_interface_len;
struct multiboot_vbe_info_block vbe_control_info;
struct multiboot_vbe_mode_info_block vbe_mode_info;
};
struct multiboot_tag_framebuffer_common
{
uint32_t type;
uint32_t size;
uint64_t framebuffer_addr;
uint32_t framebuffer_pitch;
uint32_t framebuffer_width;
uint32_t framebuffer_height;
uint8_t framebuffer_bpp;
#define MULTIBOOT_FRAMEBUFFER_TYPE_INDEXED 0
#define MULTIBOOT_FRAMEBUFFER_TYPE_RGB 1
#define MULTIBOOT_FRAMEBUFFER_TYPE_EGA_TEXT 2
uint8_t framebuffer_type;
uint16_t reserved;
};
struct multiboot_tag_framebuffer
{
struct multiboot_tag_framebuffer_common common;
union
{
struct
{
uint16_t framebuffer_palette_num_colors;
struct multiboot_color framebuffer_palette[0];
};
struct
{
uint8_t framebuffer_red_field_position;
uint8_t framebuffer_red_mask_size;
uint8_t framebuffer_green_field_position;
uint8_t framebuffer_green_mask_size;
uint8_t framebuffer_blue_field_position;
uint8_t framebuffer_blue_mask_size;
};
};
};
struct multiboot_tag_elf_sections
{
uint32_t type;
uint32_t size;
uint32_t num;
uint32_t entsize;
uint32_t shndx;
char sections[0];
};
struct multiboot_tag_apm
{
uint32_t type;
uint32_t size;
uint16_t version;
uint16_t cseg;
uint32_t offset;
uint16_t cseg_16;
uint16_t dseg;
uint16_t flags;
uint16_t cseg_len;
uint16_t cseg_16_len;
uint16_t dseg_len;
};
struct multiboot_tag_efi32
{
uint32_t type;
uint32_t size;
uint32_t pointer;
};
struct multiboot_tag_efi64
{
uint32_t type;
uint32_t size;
uint64_t pointer;
};
struct multiboot_tag_smbios
{
uint32_t type;
uint32_t size;
uint8_t major;
uint8_t minor;
uint8_t reserved[6];
uint8_t tables[0];
};
struct multiboot_tag_old_acpi
{
uint32_t type;
uint32_t size;
uint8_t rsdp[0];
};
struct multiboot_tag_new_acpi
{
uint32_t type;
uint32_t size;
uint8_t rsdp[0];
};
struct multiboot_tag_network
{
uint32_t type;
uint32_t size;
uint8_t dhcpack[0];
};
struct multiboot_tag_efi_mmap
{
uint32_t type;
uint32_t size;
uint32_t descr_size;
uint32_t descr_vers;
uint8_t efi_mmap[0];
};
struct multiboot_tag_efi32_ih
{
uint32_t type;
uint32_t size;
uint32_t pointer;
};
struct multiboot_tag_efi64_ih
{
uint32_t type;
uint32_t size;
uint64_t pointer;
};
struct multiboot_tag_load_base_addr
{
uint32_t type;
uint32_t size;
uint32_t load_base_addr;
};
__attribute__((noreturn)) void multiboot2_spinup_32(
uint32_t entry_point, uint32_t multiboot1_info);
#endif