From 4240256074723f4770ed825f2ad6c521b7d740d7 Mon Sep 17 00:00:00 2001 From: mintsuki Date: Wed, 30 Mar 2022 14:04:04 +0200 Subject: [PATCH] limine: Initial support for non-ELF executables --- PROTOCOL.md | 64 +++++++++++++++++++- common/protos/limine.c | 131 +++++++++++++++++++++++++++++++++++++---- limine.h | 31 +++++++++- 3 files changed, 210 insertions(+), 16 deletions(-) diff --git a/PROTOCOL.md b/PROTOCOL.md index 2de5d0c3..e2b3a199 100644 --- a/PROTOCOL.md +++ b/PROTOCOL.md @@ -19,6 +19,14 @@ languages. All pointers are 64-bit wide. All pointers point to the object with the higher half direct map offset already added to them, unless otherwise noted. +### Executable formats + +The Limine protocol does not enforce any specific executable format, but +kernels using formats not supported by the bootloader, or using flat binaries, +*must* provide a Executable Layout Feature (see below). + +Compliant bootloader must support at least the ELF 64-bit executable format. + ## Features The protocol is centered around the concept of request/response - collectively @@ -71,7 +79,7 @@ revisions do. This is all there is to features. For a list of official Limine features, read the "Feature List" section below. -## Executable memory layout +## Entry memory layout The protocol mandates kernels to load themselves at or above `0xffffffff80000000`. Lower half kernels are *not supported*. @@ -209,6 +217,60 @@ struct limine_stack_size_response { }; ``` +### Executable Layout Feature + +ID: +```c +#define LIMINE_EXECUTABLE_LAYOUT_REQUEST { LIMINE_COMMON_MAGIC, 0xbbd4597377e1fdbb, 0x17540007cfa435ad } +``` + +Request: +```c +typedef void (*limine_entry_point)(void); + +struct limine_executable_layout_request { + uint64_t id[4]; + uint64_t revision; + struct limine_executable_layout_response *response; + limine_entry_point entry_point; + uint64_t alignment; + uint64_t text_offset; + uint64_t text_address; + uint64_t text_size; + uint64_t data_offset; + uint64_t data_address; + uint64_t data_size; + uint64_t rodata_offset; + uint64_t rodata_address; + uint64_t rodata_size; + uint64_t bss_address; + uint64_t bss_size; +}; +``` + +* `entry_point` - The virtual address of the entry point of the kernel. It is +equivalent to an entry point specified in an executable format, and thus it can +be overridden by the Entry Point Feature. +* `alignment` - The requested alignment for the physical base address of the +kernel. It *must* be a power of 2. An alignment of 0 means 4096. +* `{text,data,rodata}_offset` - The offset within the file where the segment +begins. +* `{text,data,rodata,bss}_address` - The virtual address to which to load the +segment to. +* `{text,data,rodata,bss}_size` - The size of the segment both in the file and +in memory, except for bss, where it is only the in-memory size. + +Response: +```c +struct limine_executable_layout_response { + uint64_t revision; +}; +``` + +Notes: This request is parsed if the bootloader does not support the executable +format of the kernel. It is otherwise ignored. If it is parsed and used for +loading the kernel, then the response will be set to a vaild pointer. + ### HHDM (Higher Half Direct Map) Feature ID: diff --git a/common/protos/limine.c b/common/protos/limine.c index 174ac1a0..bb754f43 100644 --- a/common/protos/limine.c +++ b/common/protos/limine.c @@ -131,12 +131,6 @@ bool limine_load(char *config, char *cmdline) { int bits = elf_bits(kernel); - if (bits == -1 || bits == 32) { - printv("limine: Kernel in unrecognised format"); - return false; - } - - // ELF loading uint64_t entry_point = 0; struct elf_range *ranges; uint64_t ranges_count; @@ -144,12 +138,106 @@ bool limine_load(char *config, char *cmdline) { uint64_t image_size; bool is_reloc; - if (elf64_load(kernel, &entry_point, NULL, &slide, - MEMMAP_KERNEL_AND_MODULES, kaslr, false, - &ranges, &ranges_count, - true, &physical_base, &virtual_base, &image_size, - &is_reloc)) { - return false; + bool flat = false; + + if (bits == -1 || bits == 32) { + struct limine_executable_layout_request *exec_layout = NULL; + uint64_t exec_layout_id[4] = LIMINE_EXECUTABLE_LAYOUT_REQUEST; + + for (size_t i = 0; i < ALIGN_DOWN(kernel_file->size, 8); i += 8) { + uint64_t *p = (void *)(uintptr_t)kernel + i; + + if (p[0] != exec_layout_id[0]) { + continue; + } + if (p[1] != exec_layout_id[1]) { + continue; + } + if (p[2] != exec_layout_id[2]) { + continue; + } + if (p[3] != exec_layout_id[3]) { + continue; + } + + exec_layout = (void *)p; + break; + } + + if (exec_layout == NULL) { + printv("limine: Kernel in unrecognised format\n"); + return false; + } + + entry_point = exec_layout->entry_point; + + if (exec_layout->text_address % 4096 + || exec_layout->data_address % 4096 + || exec_layout->rodata_address % 4096 + || exec_layout->bss_address % 4096) { + panic(true, "limine: Address of an executable segment is not page aligned"); + } + + ranges_count = 4; + ranges = ext_mem_alloc(sizeof(struct elf_range) * ranges_count); + + ranges[0].base = exec_layout->text_address; + ranges[0].length = exec_layout->text_size; + ranges[0].permissions = ELF_PF_X | ELF_PF_R; + + ranges[1].base = exec_layout->data_address; + ranges[1].length = exec_layout->data_size; + ranges[1].permissions = ELF_PF_R | ELF_PF_W; + + ranges[2].base = exec_layout->rodata_address; + ranges[2].length = exec_layout->rodata_size; + ranges[2].permissions = ELF_PF_R; + + ranges[3].base = exec_layout->bss_address; + ranges[3].length = exec_layout->bss_size; + ranges[3].permissions = ELF_PF_R | ELF_PF_W; + + uint64_t min_addr = (uint64_t)-1; + uint64_t max_addr = 0; + for (size_t i = 0; i < ranges_count; i++) { + if (ranges[i].base < min_addr) { + min_addr = ranges[i].base; + } + if (ranges[i].base + ranges[i].length > max_addr) { + max_addr = ranges[i].base + ranges[i].length; + } + } + + image_size = max_addr - min_addr; + + is_reloc = false; + slide = 0; + + virtual_base = min_addr; + + void *image = ext_mem_alloc_type_aligned(image_size, + MEMMAP_KERNEL_AND_MODULES, exec_layout->alignment ?: 4096); + + physical_base = (uintptr_t)image; + + memcpy(image + (exec_layout->text_address - min_addr), + kernel + exec_layout->text_offset, exec_layout->text_size); + memcpy(image + (exec_layout->data_address - min_addr), + kernel + exec_layout->data_offset, exec_layout->data_size); + memcpy(image + (exec_layout->rodata_address - min_addr), + kernel + exec_layout->rodata_offset, exec_layout->rodata_size); + memset(image + (exec_layout->bss_address - min_addr), 0, exec_layout->bss_size); + + flat = true; + } else { + // ELF loading + if (elf64_load(kernel, &entry_point, NULL, &slide, + MEMMAP_KERNEL_AND_MODULES, kaslr, false, + &ranges, &ranges_count, + true, &physical_base, &virtual_base, &image_size, + &is_reloc)) { + return false; + } } kaslr = is_reloc; @@ -234,7 +322,7 @@ FEAT_START entry_point = entrypoint_request->entry; - print("limine: Entry point at %X\n", entry_point); + printv("limine: Entry point at %X\n", entry_point); struct limine_entry_point_response *entrypoint_response = ext_mem_alloc(sizeof(struct limine_entry_point_response)); @@ -242,6 +330,23 @@ FEAT_START entrypoint_request->response = reported_addr(entrypoint_response); FEAT_END + // Executable layout feature +FEAT_START + if (!flat) { + break; + } + + struct limine_executable_layout_request *exec_layout_request = get_request(LIMINE_EXECUTABLE_LAYOUT_REQUEST); + if (exec_layout_request == NULL) { + panic(true, "limine: How did this even happen?"); + } + + struct limine_executable_layout_response *exec_layout_response = + ext_mem_alloc(sizeof(struct limine_executable_layout_response)); + + exec_layout_request->response = reported_addr(exec_layout_response); +FEAT_END + // Bootloader info feature FEAT_START struct limine_bootloader_info_request *bootloader_info_request = get_request(LIMINE_BOOTLOADER_INFO_REQUEST); diff --git a/limine.h b/limine.h index bb7a4091..311bb61c 100644 --- a/limine.h +++ b/limine.h @@ -40,6 +40,8 @@ struct limine_file { struct limine_uuid part_uuid; }; +typedef void (*limine_entry_point)(void); + /* Boot info */ #define LIMINE_BOOTLOADER_INFO_REQUEST { LIMINE_COMMON_MAGIC, 0xf55038d8e2a1202f, 0x279426fcf5f59740 } @@ -71,6 +73,33 @@ struct limine_stack_size_request { uint64_t stack_size; }; +/* Executable layout */ + +#define LIMINE_EXECUTABLE_LAYOUT_REQUEST { LIMINE_COMMON_MAGIC, 0xbbd4597377e1fdbb, 0x17540007cfa435ad } + +struct limine_executable_layout_response { + uint64_t revision; +}; + +struct limine_executable_layout_request { + uint64_t id[4]; + uint64_t revision; + LIMINE_PTR(struct limine_executable_layout_response *) response; + LIMINE_PTR(limine_entry_point) entry_point; + uint64_t alignment; + uint64_t text_offset; + uint64_t text_address; + uint64_t text_size; + uint64_t data_offset; + uint64_t data_address; + uint64_t data_size; + uint64_t rodata_offset; + uint64_t rodata_address; + uint64_t rodata_size; + uint64_t bss_address; + uint64_t bss_size; +}; + /* HHDM */ #define LIMINE_HHDM_REQUEST { LIMINE_COMMON_MAGIC, 0x48dcf1cb8ad2b852, 0x63984e959a98244b } @@ -239,8 +268,6 @@ struct limine_memmap_request { #define LIMINE_ENTRY_POINT_REQUEST { LIMINE_COMMON_MAGIC, 0x13d86c035a1cd3e1, 0x2b0caa89d8f3026a } -typedef void (*limine_entry_point)(void); - struct limine_entry_point_response { uint64_t revision; };