Add bios support for loading a ramdisk

Author: jasoncouture

api/src/config.rs

@@ -231,7 +231,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)?
+                ramdisk_memory: Mapping::deserialize(&ramdisk_memory)?,
             };
             (mappings, s)
         };
@@ -388,7 +388,7 @@ pub struct Mappings {
     pub dynamic_range_end: Option<u64>,
     /// Virtual address to map ramdisk image, if present on disk
     /// Defaults to dynamic
-    pub ramdisk_memory: Mapping
+    pub ramdisk_memory: Mapping,
 }
 
 impl Mappings {
@@ -405,7 +405,7 @@ impl Mappings {
             aslr: false,
             dynamic_range_start: None,
             dynamic_range_end: None,
-            ramdisk_memory: Mapping::new_default()
+            ramdisk_memory: Mapping::new_default(),
         }
     }
 
@@ -438,7 +438,7 @@ impl Mappings {
             } else {
                 Option::None
             },
-            ramdisk_memory: Mapping::random()
+            ramdisk_memory: Mapping::random(),
         }
     }
 }

api/src/info.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,
         }
     }
 }

bios/common/src/lib.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/stage-2/src/main.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,21 @@ 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 optional_file = fs.find_file_in_root_dir(file_name, disk_buffer);
+    if optional_file.is_none() {
+        return None;
+    }
+
+    let file = optional_file.unwrap();
+
     let file_size = file.file_size().into();
 
     let mut total_offset = 0;
@@ -195,7 +221,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-4/src/main.rs

@@ -118,6 +118,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);

common/src/lib.rs

@@ -49,6 +49,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.
@@ -464,6 +466,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
     });
 

uefi/src/main.rs

@@ -37,6 +37,7 @@ use x86_64::{
 mod memory_descriptor;
 
 static SYSTEM_TABLE: RacyCell<Option<SystemTable<Boot>>> = RacyCell::new(None);
+const KERNEL_FILENAME: &str = "kernel-x86_64";
 
 struct RacyCell<T>(UnsafeCell<T>);
 
@@ -120,6 +121,8 @@ fn main_inner(image: Handle, mut st: SystemTable<Boot>) -> Status {
                 .or_else(|| config_entries.find(|entry| matches!(entry.guid, cfg::ACPI_GUID)));
             rsdp.map(|entry| PhysAddr::new(entry.address as u64))
         },
+        ramdisk_addr: None,
+        ramdisk_len: 0
     };
 
     bootloader_x86_64_common::load_and_switch_to_kernel(
@@ -141,7 +144,7 @@ fn load_kernel_file(image: Handle, st: &SystemTable<Boot>) -> Option<&'static mu
         .or_else(|| load_kernel_file_from_tftp_boot_server(image, st))
 }
 
-fn load_kernel_file_from_disk(image: Handle, st: &SystemTable<Boot>) -> Option<&'static mut [u8]> {
+fn load_file_from_disk(name: &str, image: Handle, st: &SystemTable<Boot>) -> Option<&'static mut [u8]>{ 
     let file_system_raw = {
         let this = st.boot_services();
         let loaded_image = this
@@ -187,33 +190,46 @@ fn load_kernel_file_from_disk(image: Handle, st: &SystemTable<Boot>) -> Option<&
     let file_system = unsafe { &mut *file_system_raw.interface.get() };
 
     let mut root = file_system.open_volume().unwrap();
-    let mut buf = [0; 14 * 2];
-    let filename = CStr16::from_str_with_buf("kernel-x86_64", &mut buf).unwrap();
-    let kernel_file_handle = root
-        .open(filename, FileMode::Read, FileAttribute::empty())
-        .expect("Failed to load kernel (expected file named `kernel-x86_64`)");
-    let mut kernel_file = match kernel_file_handle.into_type().unwrap() {
+    if(name.len() > 255) {
+        panic!("File name {}, exceeds maximum length!", name);
+    }
+    let mut buf = [0; 512];
+    let filename = CStr16::from_str_with_buf(name, &mut buf).unwrap();
+    let kernel_file_handle_result = root
+        .open(filename, FileMode::Read, FileAttribute::empty());
+
+    if kernel_file_handle_result.is_err() {
+        return None;
+    }
+
+    let file_handle = kernel_file_handle_result.unwrap();
+
+    let mut file = match file_handle.into_type().unwrap() {
         uefi::proto::media::file::FileType::Regular(f) => f,
         uefi::proto::media::file::FileType::Dir(_) => panic!(),
     };
 
     let mut buf = [0; 500];
-    let kernel_info: &mut FileInfo = kernel_file.get_info(&mut buf).unwrap();
-    let kernel_size = usize::try_from(kernel_info.file_size()).unwrap();
+    let file_info: &mut FileInfo = file.get_info(&mut buf).unwrap();
+    let file_size = usize::try_from(file_info.file_size()).unwrap();
 
-    let kernel_ptr = st
+    let file_ptr = st
         .boot_services()
         .allocate_pages(
             AllocateType::AnyPages,
             MemoryType::LOADER_DATA,
-            ((kernel_size - 1) / 4096) + 1,
+            ((file_size - 1) / 4096) + 1,
         )
         .unwrap() as *mut u8;
-    unsafe { ptr::write_bytes(kernel_ptr, 0, kernel_size) };
-    let kernel_slice = unsafe { slice::from_raw_parts_mut(kernel_ptr, kernel_size) };
-    kernel_file.read(kernel_slice).unwrap();
+    unsafe { ptr::write_bytes(file_ptr, 0, file_size) };
+    let file_slice = unsafe { slice::from_raw_parts_mut(file_ptr, file_size) };
+    file.read(file_slice).unwrap();
 
-    Some(kernel_slice)
+    Some(file_slice)
+}
+
+fn load_kernel_file_from_disk(image: Handle, st: &SystemTable<Boot>) -> Option<&'static mut [u8]> {
+    Some(load_file_from_disk(KERNEL_FILENAME, image, st).expect("Failed to load kernel (expected file named `kernel-x86_64`)"))
 }
 
 /// Try to load a kernel from a TFTP boot server.