Add ramdisk support

This adds support for loading a ramdisk/initrd, and an API to add one to the boot image.

Author: jasoncouture

Cargo.lock

@@ -23,6 +23,7 @@ members = [
     "tests/test_kernels/higher_half",
     "tests/test_kernels/pie",
     "tests/test_kernels/lto",
+    "tests/test_kernels/ramdisk"
 ]
 exclude = ["examples/basic", "examples/test_framework"]
 
@@ -50,6 +51,7 @@ test_kernel_default_settings = { path = "tests/test_kernels/default_settings", a
 test_kernel_higher_half = { path = "tests/test_kernels/higher_half", artifact = "bin", target = "x86_64-unknown-none" }
 test_kernel_map_phys_mem = { path = "tests/test_kernels/map_phys_mem", artifact = "bin", target = "x86_64-unknown-none" }
 test_kernel_pie = { path = "tests/test_kernels/pie", artifact = "bin", target = "x86_64-unknown-none" }
+test_kernel_ramdisk = { path = "tests/test_kernels/ramdisk", artifact = "bin", target = "x86_64-unknown-none" }
 
 [profile.dev]
 panic = "abort"

Cargo.toml

@@ -22,7 +22,8 @@ fn main() {
         (88, 9),
         (97, 9),
         (106, 9),
-        (115, 1),
+        (115, 9),
+        (124, 1)
     ];
 
     let mut code = String::new();

api/build.rs

@@ -39,7 +39,7 @@ impl BootloaderConfig {
         0x3D,
     ];
     #[doc(hidden)]
-    pub const SERIALIZED_LEN: usize = 116;
+    pub const SERIALIZED_LEN: usize = 125;
 
     /// Creates a new default configuration with the following values:
     ///
@@ -83,6 +83,7 @@ impl BootloaderConfig {
             aslr,
             dynamic_range_start,
             dynamic_range_end,
+            ramdisk_memory,
         } = mappings;
         let FrameBuffer {
             minimum_framebuffer_height,
@@ -131,23 +132,27 @@ impl BootloaderConfig {
             },
         );
 
-        let buf = concat_97_9(
+        let buf = concat_97_9(buf, ramdisk_memory.serialize());
+
+        let buf = concat_106_9(
             buf,
             match minimum_framebuffer_height {
                 Option::None => [0; 9],
                 Option::Some(addr) => concat_1_8([1], addr.to_le_bytes()),
             },
         );
 
-        let buf = concat_106_9(
+        
+        let buf = concat_115_9(
             buf,
             match minimum_framebuffer_width {
                 Option::None => [0; 9],
                 Option::Some(addr) => concat_1_8([1], addr.to_le_bytes()),
             },
         );
+        let buf = concat_124_1(buf, (*log_level as u8).to_le_bytes());
 
-        concat_115_1(buf, (*log_level as u8).to_le_bytes())
+        buf
     }
 
     /// Tries to deserialize a config byte array that was created using [`Self::serialize`].
@@ -205,6 +210,7 @@ impl BootloaderConfig {
             let (&dynamic_range_start, s) = split_array_ref(s);
             let (&dynamic_range_end_some, s) = split_array_ref(s);
             let (&dynamic_range_end, s) = split_array_ref(s);
+            let (&ramdisk_memory, s) = split_array_ref(s);
 
             let mappings = Mappings {
                 kernel_stack: Mapping::deserialize(&kernel_stack)?,
@@ -235,6 +241,7 @@ impl BootloaderConfig {
                     [1] => Option::Some(u64::from_le_bytes(dynamic_range_end)),
                     _ => return Err("invalid dynamic range end value"),
                 },
+                ramdisk_memory: Mapping::deserialize(&ramdisk_memory)?,
             };
             (mappings, s)
         };
@@ -398,6 +405,9 @@ pub struct Mappings {
     ///
     /// Defaults to `0xffff_ffff_ffff_f000`.
     pub dynamic_range_end: Option<u64>,
+    /// Virtual address to map ramdisk image, if present on disk
+    /// Defaults to dynamic
+    pub ramdisk_memory: Mapping,
 }
 
 impl Mappings {
@@ -414,6 +424,7 @@ impl Mappings {
             aslr: false,
             dynamic_range_start: None,
             dynamic_range_end: None,
+            ramdisk_memory: Mapping::new_default(),
         }
     }
 
@@ -446,6 +457,7 @@ impl Mappings {
             } else {
                 Option::None
             },
+            ramdisk_memory: Mapping::random(),
         }
     }
 }

api/src/config.rs

@@ -52,6 +52,10 @@ pub struct BootInfo {
     pub rsdp_addr: Optional<u64>,
     /// The thread local storage (TLS) template of the kernel executable, if present.
     pub tls_template: Optional<TlsTemplate>,
+    /// Ramdisk address, if loaded
+    pub ramdisk_addr: Optional<u64>,
+    /// Ramdisk image size, set to 0 if addr is None
+    pub ramdisk_len: u64,
 }
 
 impl BootInfo {
@@ -67,6 +71,8 @@ impl BootInfo {
             recursive_index: Optional::None,
             rsdp_addr: Optional::None,
             tls_template: Optional::None,
+            ramdisk_addr: Optional::None,
+            ramdisk_len: 0,
         }
     }
 }

api/src/info.rs

@@ -7,6 +7,7 @@ pub mod racy_cell;
 pub struct BiosInfo {
     pub stage_4: Region,
     pub kernel: Region,
+    pub ramdisk: Region,
     pub framebuffer: BiosFramebufferInfo,
     pub memory_map_addr: u32,
     pub memory_map_len: u16,

bios/common/src/lib.rs

@@ -27,6 +27,7 @@ const BOOTLOADER_SECOND_STAGE_PARTITION_TYPE: u8 = 0x20;
 const STAGE_3_DST: *mut u8 = 0x0010_0000 as *mut u8; // 1MiB (typically 14MiB accessible here)
 const STAGE_4_DST: *mut u8 = 0x0020_0000 as *mut u8; // 2MiB (typically still 13MiB accessible here)
 const KERNEL_DST: *mut u8 = 0x0100_0000 as *mut u8; // 16MiB
+const RAMDISK_DST: *mut u8 = 0x0400_0000 as *mut u8; // 64MiB
 
 static mut DISK_BUFFER: AlignedArrayBuffer<0x4000> = AlignedArrayBuffer {
     buffer: [0; 0x4000],
@@ -98,6 +99,23 @@ fn start(disk_number: u16, partition_table_start: *const u8) -> ! {
     writeln!(screen::Writer, "loading kernel...").unwrap();
     let kernel_len = load_file("kernel-x86_64", KERNEL_DST, &mut fs, &mut disk, disk_buffer);
     writeln!(screen::Writer, "kernel loaded at {KERNEL_DST:#p}").unwrap();
+    writeln!(screen::Writer, "Loading ramdisk...").unwrap();
+    let ramdisk_len = match try_load_file(
+        "ramdisk-x86_64",
+        RAMDISK_DST,
+        &mut fs,
+        &mut disk,
+        disk_buffer,
+    ) {
+        Some(s) => s,
+        None => 0u64,
+    };
+
+    if ramdisk_len == 0 {
+        writeln!(screen::Writer, "No ramdisk found, skipping.").unwrap();
+    } else {
+        writeln!(screen::Writer, "Loaded ramdisk at {RAMDISK_DST:#p}").unwrap();
+    }
 
     let memory_map = unsafe { memory_map::query_memory_map() }.unwrap();
     writeln!(screen::Writer, "{memory_map:x?}").unwrap();
@@ -129,6 +147,10 @@ fn start(disk_number: u16, partition_table_start: *const u8) -> ! {
             start: KERNEL_DST as u64,
             len: kernel_len,
         },
+        ramdisk: Region {
+            start: RAMDISK_DST as u64,
+            len: ramdisk_len,
+        },
         memory_map_addr: memory_map.as_mut_ptr() as u32,
         memory_map_len: memory_map.len().try_into().unwrap(),
         framebuffer: BiosFramebufferInfo {
@@ -151,17 +173,16 @@ fn start(disk_number: u16, partition_table_start: *const u8) -> ! {
     }
 }
 
-fn load_file(
+fn try_load_file(
     file_name: &str,
     dst: *mut u8,
     fs: &mut fat::FileSystem<disk::DiskAccess>,
     disk: &mut disk::DiskAccess,
     disk_buffer: &mut AlignedArrayBuffer<16384>,
-) -> u64 {
+) -> Option<u64> {
     let disk_buffer_size = disk_buffer.buffer.len();
-    let file = fs
-        .find_file_in_root_dir(file_name, disk_buffer)
-        .expect("file not found");
+    let file = fs.find_file_in_root_dir(file_name, disk_buffer)?;
+
     let file_size = file.file_size().into();
 
     let mut total_offset = 0;
@@ -195,7 +216,17 @@ fn load_file(
             total_offset += usize::try_from(len).unwrap();
         }
     }
-    file_size
+    Some(file_size)
+}
+
+fn load_file(
+    file_name: &str,
+    dst: *mut u8,
+    fs: &mut fat::FileSystem<disk::DiskAccess>,
+    disk: &mut disk::DiskAccess,
+    disk_buffer: &mut AlignedArrayBuffer<16384>,
+) -> u64 {
+    try_load_file(file_name, dst, fs, disk, disk_buffer).expect("file not found")
 }
 
 /// Taken from https://github.com/rust-lang/rust/blob/e100ec5bc7cd768ec17d75448b29c9ab4a39272b/library/core/src/slice/mod.rs#L1673-L1677

bios/stage-2/src/main.rs

@@ -121,6 +121,11 @@ pub extern "C" fn _start(info: &mut BiosInfo) -> ! {
             info: framebuffer_info,
         }),
         rsdp_addr: detect_rsdp(),
+        ramdisk_addr: match info.ramdisk.len {
+            0 => None,
+            _ => Some(info.ramdisk.start),
+        },
+        ramdisk_len: info.ramdisk.len,
     };
 
     load_and_switch_to_kernel(kernel, frame_allocator, page_tables, system_info);

bios/stage-4/src/main.rs

@@ -60,6 +60,8 @@ pub struct SystemInfo {
     pub framebuffer: Option<RawFrameBufferInfo>,
     /// Address of the _Root System Description Pointer_ structure of the ACPI standard.
     pub rsdp_addr: Option<PhysAddr>,
+    pub ramdisk_addr: Option<u64>,
+    pub ramdisk_len: u64,
 }
 
 /// The physical address of the framebuffer and information about the framebuffer.
@@ -475,6 +477,8 @@ where
         info.recursive_index = mappings.recursive_index.map(Into::into).into();
         info.rsdp_addr = system_info.rsdp_addr.map(|addr| addr.as_u64()).into();
         info.tls_template = mappings.tls_template.into();
+        info.ramdisk_addr = system_info.ramdisk_addr.into();
+        info.ramdisk_len = system_info.ramdisk_len;
         info
     });
 

common/src/lib.rs

@@ -17,22 +17,31 @@ mod mbr;
 mod pxe;
 
 const KERNEL_FILE_NAME: &str = "kernel-x86_64";
+const RAMDISK_FILE_NAME: &str = "ramdisk-x86_64";
 const BIOS_STAGE_3: &str = "boot-stage-3";
 const BIOS_STAGE_4: &str = "boot-stage-4";
 
 /// Create disk images for booting on legacy BIOS systems.
 pub struct BiosBoot {
     kernel: PathBuf,
+    ramdisk: Option<PathBuf>,
 }
 
 impl BiosBoot {
     /// Start creating a disk image for the given bootloader ELF executable.
     pub fn new(kernel_path: &Path) -> Self {
         Self {
             kernel: kernel_path.to_owned(),
+            ramdisk: None,
         }
     }
 
+    /// Add a ramdisk file to the image
+    pub fn set_ramdisk(&mut self, ramdisk_path: &Path) -> &mut Self {
+        self.ramdisk = Some(ramdisk_path.to_owned());
+        self
+    }
+
     /// Create a bootable UEFI disk image at the given path.
     pub fn create_disk_image(&self, out_path: &Path) -> anyhow::Result<()> {
         let bootsector_path = Path::new(env!("BIOS_BOOT_SECTOR_PATH"));
@@ -61,12 +70,15 @@ impl BiosBoot {
     fn create_fat_partition(&self) -> anyhow::Result<NamedTempFile> {
         let stage_3_path = Path::new(env!("BIOS_STAGE_3_PATH"));
         let stage_4_path = Path::new(env!("BIOS_STAGE_4_PATH"));
+        let kernel_path = self.kernel.as_path();
 
         let mut files = BTreeMap::new();
-        files.insert(KERNEL_FILE_NAME, self.kernel.as_path());
+        files.insert(KERNEL_FILE_NAME, kernel_path);
         files.insert(BIOS_STAGE_3, stage_3_path);
         files.insert(BIOS_STAGE_4, stage_4_path);
-
+        if let Some(ramdisk_path) = &self.ramdisk {
+            files.insert(RAMDISK_FILE_NAME, ramdisk_path);
+        }
         let out_file = NamedTempFile::new().context("failed to create temp file")?;
         fat::create_fat_filesystem(files, out_file.path())
             .context("failed to create BIOS FAT filesystem")?;
@@ -78,16 +90,24 @@ impl BiosBoot {
 /// Create disk images for booting on UEFI systems.
 pub struct UefiBoot {
     kernel: PathBuf,
+    ramdisk: Option<PathBuf>,
 }
 
 impl UefiBoot {
     /// Start creating a disk image for the given bootloader ELF executable.
     pub fn new(kernel_path: &Path) -> Self {
         Self {
             kernel: kernel_path.to_owned(),
+            ramdisk: None,
         }
     }
 
+    /// Add a ramdisk file to the disk image
+    pub fn set_ramdisk(&mut self, ramdisk_path: &Path) -> &mut Self {
+        self.ramdisk = Some(ramdisk_path.to_owned());
+        self
+    }
+
     /// Create a bootable BIOS disk image at the given path.
     pub fn create_disk_image(&self, out_path: &Path) -> anyhow::Result<()> {
         let fat_partition = self
@@ -121,10 +141,14 @@ impl UefiBoot {
     /// Creates an UEFI-bootable FAT partition with the kernel.
     fn create_fat_partition(&self) -> anyhow::Result<NamedTempFile> {
         let bootloader_path = Path::new(env!("UEFI_BOOTLOADER_PATH"));
-
+        let kernel_path = self.kernel.as_path();
         let mut files = BTreeMap::new();
         files.insert("efi/boot/bootx64.efi", bootloader_path);
-        files.insert(KERNEL_FILE_NAME, self.kernel.as_path());
+        files.insert(KERNEL_FILE_NAME, kernel_path);
+
+        if let Some(ramdisk_path) = &self.ramdisk {
+            files.insert(RAMDISK_FILE_NAME, ramdisk_path);
+        }
 
         let out_file = NamedTempFile::new().context("failed to create temp file")?;
         fat::create_fat_filesystem(files, out_file.path())