Specify kernel-code virt addr in BootloaderConfig

Author: Wasabi375

Cargo.lock

@@ -22,15 +22,15 @@ exclude = ["examples/basic", "examples/test_framework", "tests/test_kernels/*"]
 
 [workspace.package]
 # don't forget to update `workspace.dependencies` below
-version = "0.11.10"
+version = "0.12.0"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/rust-osdev/bootloader"
 
 [workspace.dependencies]
-bootloader_api = { version = "0.11.10", path = "api" }
-bootloader-x86_64-common = { version = "0.11.10", path = "common" }
-bootloader-boot-config = { version = "0.11.10", path = "common/config" }
-bootloader-x86_64-bios-common = { version = "0.11.10", path = "bios/common" }
+bootloader_api = { version = "0.12.0", path = "api" }
+bootloader-x86_64-common = { version = "0.12.0", path = "common" }
+bootloader-boot-config = { version = "0.12.0", path = "common/config" }
+bootloader-x86_64-bios-common = { version = "0.12.0", path = "bios/common" }
 
 [features]
 default = ["bios", "uefi"]
@@ -60,6 +60,7 @@ test_kernel_config_file = { path = "tests/test_kernels/config_file", artifact =
 test_kernel_min_stack = { path = "tests/test_kernels/min_stack", artifact = "bin", target = "x86_64-unknown-none" }
 test_kernel_lower_memory_free = { path = "tests/test_kernels/lower_memory_free", artifact = "bin", target = "x86_64-unknown-none" }
 test_kernel_write_usable_memory = { path = "tests/test_kernels/write_usable_memory", artifact = "bin", target = "x86_64-unknown-none" }
+test_kernel_fixed_kernel_address = { path = "tests/test_kernels/fixed_kernel_address", artifact = "bin", target = "x86_64-unknown-none" }
 
 [profile.dev]
 panic = "abort"

Cargo.toml

@@ -1,5 +1,11 @@
 # Unreleased
 
+## Features
+
+* add `kernel_code` mapping to the BootloaderConfig to specify the virtual address
+    at which the kernel is loaded.
+
+
 # 0.11.10 – 2025-02-10
 
 * [Remove "UEFI boot" log message](https://github.com/rust-osdev/bootloader/pull/476)

Changelog.md

@@ -15,14 +15,16 @@ fn main() {
         (31, 9),
         (40, 9),
         (49, 9),
-        (58, 10),
-        (68, 10),
-        (78, 1),
-        (79, 9),
+        (58, 9),
+        (67, 10),
+        (77, 10),
+        (87, 1),
         (88, 9),
         (97, 9),
         (106, 9),
         (115, 9),
+        (124, 9),
+        (133, 9),
     ];
 
     let mut code = String::new();

api/build.rs

@@ -43,7 +43,7 @@ impl BootloaderConfig {
         0x3D,
     ];
     #[doc(hidden)]
-    pub const SERIALIZED_LEN: usize = 124;
+    pub const SERIALIZED_LEN: usize = 133;
 
     /// Creates a new default configuration with the following values:
     ///
@@ -77,6 +77,7 @@ impl BootloaderConfig {
         } = version;
         let Mappings {
             kernel_stack,
+            kernel_code,
             boot_info,
             framebuffer,
             physical_memory,
@@ -97,53 +98,56 @@ impl BootloaderConfig {
             concat_4_3(one, two)
         };
         let buf = concat_16_7(Self::UUID, version);
+
         let buf = concat_23_8(buf, kernel_stack_size.to_le_bytes());
 
         let buf = concat_31_9(buf, kernel_stack.serialize());
-        let buf = concat_40_9(buf, boot_info.serialize());
-        let buf = concat_49_9(buf, framebuffer.serialize());
+        let buf = concat_40_9(buf, kernel_code.serialize());
+
+        let buf = concat_49_9(buf, boot_info.serialize());
+        let buf = concat_58_9(buf, framebuffer.serialize());
 
-        let buf = concat_58_10(
+        let buf = concat_67_10(
             buf,
             match physical_memory {
                 Option::None => [0; 10],
                 Option::Some(m) => concat_1_9([1], m.serialize()),
             },
         );
-        let buf = concat_68_10(
+        let buf = concat_77_10(
             buf,
             match page_table_recursive {
                 Option::None => [0; 10],
                 Option::Some(m) => concat_1_9([1], m.serialize()),
             },
         );
-        let buf = concat_78_1(buf, [(*aslr) as u8]);
-        let buf = concat_79_9(
+        let buf = concat_87_1(buf, [(*aslr) as u8]);
+        let buf = concat_88_9(
             buf,
             match dynamic_range_start {
                 Option::None => [0; 9],
                 Option::Some(addr) => concat_1_8([1], addr.to_le_bytes()),
             },
         );
-        let buf = concat_88_9(
+        let buf = concat_97_9(
             buf,
             match dynamic_range_end {
                 Option::None => [0; 9],
                 Option::Some(addr) => concat_1_8([1], addr.to_le_bytes()),
             },
         );
 
-        let buf = concat_97_9(buf, ramdisk_memory.serialize());
+        let buf = concat_106_9(buf, ramdisk_memory.serialize());
 
-        let buf = concat_106_9(
+        let buf = concat_115_9(
             buf,
             match minimum_framebuffer_height {
                 Option::None => [0; 9],
                 Option::Some(addr) => concat_1_8([1], addr.to_le_bytes()),
             },
         );
 
-        concat_115_9(
+        concat_124_9(
             buf,
             match minimum_framebuffer_width {
                 Option::None => [0; 9],
@@ -196,6 +200,7 @@ impl BootloaderConfig {
 
         let (mappings, s) = {
             let (&kernel_stack, s) = split_array_ref(s);
+            let (&kernel_code, s) = split_array_ref(s);
             let (&boot_info, s) = split_array_ref(s);
             let (&framebuffer, s) = split_array_ref(s);
             let (&physical_memory_some, s) = split_array_ref(s);
@@ -211,6 +216,7 @@ impl BootloaderConfig {
 
             let mappings = Mappings {
                 kernel_stack: Mapping::deserialize(&kernel_stack)?,
+                kernel_code: Mapping::deserialize(&kernel_code)?,
                 boot_info: Mapping::deserialize(&boot_info)?,
                 framebuffer: Mapping::deserialize(&framebuffer)?,
                 physical_memory: match physical_memory_some {
@@ -371,6 +377,11 @@ pub struct Mappings {
     /// `FixedAddress(0xf_0000_0000)` will result in a guard page at address
     /// `0xf_0000_0000` and the kernel stack starting at address `0xf_0000_1000`.
     pub kernel_stack: Mapping,
+    /// Configures how the kernel code should be mapped.
+    ///
+    /// If a fixed address is set, it must be paged alignned and requires the kernel to
+    /// be a shared object.
+    pub kernel_code: Mapping,
     /// Specifies where the [`crate::BootInfo`] struct should be placed in virtual memory.
     pub boot_info: Mapping,
     /// Specifies the mapping of the frame buffer memory region.
@@ -413,6 +424,7 @@ impl Mappings {
     pub const fn new_default() -> Self {
         Self {
             kernel_stack: Mapping::new_default(),
+            kernel_code: Mapping::new_default(),
             boot_info: Mapping::new_default(),
             framebuffer: Mapping::new_default(),
             physical_memory: Option::None,
@@ -430,6 +442,7 @@ impl Mappings {
         let recursive = rand::random();
         Self {
             kernel_stack: Mapping::random(),
+            kernel_code: Mapping::random(),
             boot_info: Mapping::random(),
             framebuffer: Mapping::random(),
             physical_memory: if phys {

api/src/config.rs

@@ -126,8 +126,10 @@ impl UsedLevel4Entries {
         }
     }
 
-    fn mark_p4_index_as_used(&mut self, p4_index: PageTableIndex) {
+    fn mark_p4_index_as_used(&mut self, p4_index: PageTableIndex) -> bool {
+        let used = self.entry_state[usize::from(p4_index)];
         self.entry_state[usize::from(p4_index)] = true;
+        used
     }
 
     /// Marks the virtual address range of all segments as used.
@@ -144,6 +146,26 @@ impl UsedLevel4Entries {
         }
     }
 
+    /// Marks all p4 entries in the range `[address..address+size)` as used.
+    pub fn try_mark_range_as_used(&mut self, address: u64, size: u64) -> Result<(), ()> {
+        let start = VirtAddr::new(address);
+        let end_inclusive = (start + size) - 1;
+        let start_page = Page::<Size4KiB>::containing_address(start);
+        let end_page_inclusive = Page::<Size4KiB>::containing_address(end_inclusive);
+
+        let mut any_used_before = false;
+        for p4_index in u16::from(start_page.p4_index())..=u16::from(end_page_inclusive.p4_index())
+        {
+            any_used_before |= self.mark_p4_index_as_used(PageTableIndex::new(p4_index));
+        }
+
+        if any_used_before {
+            Err(())
+        } else {
+            Ok(())
+        }
+    }
+
     /// Returns the first index of a `num` contiguous unused level 4 entries and marks them as
     /// used. If `CONFIG.aslr` is enabled, this will return random contiguous available entries.
     ///

common/src/level_4_entries.rs

@@ -59,27 +59,43 @@ where
         let virtual_address_offset = match elf_file.header.pt2.type_().as_type() {
             header::Type::None => unimplemented!(),
             header::Type::Relocatable => unimplemented!(),
-            header::Type::Executable => VirtualAddressOffset::zero(),
+            header::Type::Executable => match kernel.config.mappings.kernel_code {
+                bootloader_api::config::Mapping::Dynamic
+                | bootloader_api::config::Mapping::FixedAddress(0) => VirtualAddressOffset::zero(),
+                _ => return Err("Invalid kernel_code mapping. Executable can only be mapped at virtual_address_offset 0."),
+            },
             header::Type::SharedObject => {
-                // Find the highest virtual memory address and the biggest alignment.
-                let load_program_headers = elf_file
-                    .program_iter()
-                    .filter(|h| matches!(h.get_type(), Ok(Type::Load)));
-                let max_addr = load_program_headers
-                    .clone()
-                    .map(|h| h.virtual_addr() + h.mem_size())
-                    .max()
-                    .unwrap_or(0);
-                let min_addr = load_program_headers
-                    .clone()
-                    .map(|h| h.virtual_addr())
-                    .min()
-                    .unwrap_or(0);
-                let size = max_addr - min_addr;
-                let align = load_program_headers.map(|h| h.align()).max().unwrap_or(1);
-
-                let offset = used_entries.get_free_address(size, align).as_u64();
-                VirtualAddressOffset::new(i128::from(offset) - i128::from(min_addr))
+                    // Find the highest virtual memory address and the biggest alignment.
+                    let load_program_headers = elf_file
+                        .program_iter()
+                        .filter(|h| matches!(h.get_type(), Ok(Type::Load)));
+                    let max_addr = load_program_headers
+                        .clone()
+                        .map(|h| h.virtual_addr() + h.mem_size())
+                        .max()
+                        .unwrap_or(0);
+                    let min_addr = load_program_headers
+                        .clone()
+                        .map(|h| h.virtual_addr())
+                        .min()
+                        .unwrap_or(0);
+                    let size = max_addr - min_addr;
+                    let align = load_program_headers.map(|h| h.align()).max().unwrap_or(1);
+                match kernel.config.mappings.kernel_code {
+                    bootloader_api::config::Mapping::Dynamic => {
+                        let offset = used_entries.get_free_address(size, align).as_u64();
+                        VirtualAddressOffset::new(i128::from(offset) - i128::from(min_addr))
+                    }
+                    bootloader_api::config::Mapping::FixedAddress(address) => {
+                        if !VirtAddr::new(address).is_aligned(align) {
+                            return Err("kernel_code mapping alignment does not match elf file");
+                        }
+                        if used_entries.try_mark_range_as_used(address, size).is_err() {
+                            return Err("kernel_code mapping is already in use");
+                        }
+                        VirtualAddressOffset::new(i128::from(address))
+                    }
+                }
             }
             header::Type::Core => unimplemented!(),
             header::Type::ProcessorSpecific(_) => unimplemented!(),
@@ -151,7 +167,7 @@ where
         Ok(tls_template)
     }
 
-    fn entry_point(&self) -> VirtAddr {
+    pub fn entry_point(&self) -> VirtAddr {
         VirtAddr::new(self.inner.virtual_address_offset + self.elf_file.header.pt2.entry_point())
     }
 }

common/src/load_kernel.rs

@@ -0,0 +1,29 @@
+use bootloader_test_runner::run_test_kernel;
+
+#[test]
+fn basic_boot() {
+    run_test_kernel(env!(
+        "CARGO_BIN_FILE_TEST_KERNEL_FIXED_KERNEL_ADDRESS_basic_boot"
+    ));
+}
+
+#[test]
+fn should_panic() {
+    run_test_kernel(env!(
+        "CARGO_BIN_FILE_TEST_KERNEL_FIXED_KERNEL_ADDRESS_should_panic"
+    ));
+}
+
+#[test]
+fn check_boot_info() {
+    run_test_kernel(env!(
+        "CARGO_BIN_FILE_TEST_KERNEL_FIXED_KERNEL_ADDRESS_check_boot_info"
+    ));
+}
+
+#[test]
+fn verify_kernel_address() {
+    run_test_kernel(env!(
+        "CARGO_BIN_FILE_TEST_KERNEL_FIXED_KERNEL_ADDRESS_verify_kernel_address"
+    ));
+}

tests/fixed_kernel_address.rs

@@ -12,6 +12,7 @@ members = [
     "min_stack",
     "lower_memory_free",
     "write_usable_memory",
+    "fixed_kernel_address",
 ]
 
 [profile.release]

tests/test_kernels/Cargo.lock

@@ -0,0 +1,11 @@
+[package]
+name = "test_kernel_fixed_kernel_address"
+version = "0.1.0"
+edition = "2021"
+
+[target.'cfg(target_arch = "x86_64")'.dependencies]
+bootloader_api = { path = "../../../api" }
+x86_64 = { version = "0.15.2", default-features = false, features = [
+    "instructions",
+] }
+uart_16550 = "0.2.10"

tests/test_kernels/Cargo.toml

@@ -0,0 +1,18 @@
+#![no_std] // don't link the Rust standard library
+#![no_main] // disable all Rust-level entry points
+
+use bootloader_api::{entry_point, BootInfo};
+use test_kernel_fixed_kernel_address::{exit_qemu, QemuExitCode, BOOTLOADER_CONFIG};
+
+entry_point!(kernel_main, config = &BOOTLOADER_CONFIG);
+
+fn kernel_main(_boot_info: &'static mut BootInfo) -> ! {
+    exit_qemu(QemuExitCode::Success);
+}
+
+/// This function is called on panic.
+#[cfg(not(test))]
+#[panic_handler]
+fn panic(_info: &core::panic::PanicInfo) -> ! {
+    exit_qemu(QemuExitCode::Failed);
+}