Map ramdisk, and fix bios boot issue due to long file name

Author: jasoncouture

bios/stage-2/src/main.rs

@@ -101,7 +101,7 @@ fn start(disk_number: u16, partition_table_start: *const u8) -> ! {
     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",
         RAMDISK_DST,
         &mut fs,
         &mut disk,

bios/stage-4/src/main.rs

@@ -56,13 +56,17 @@ pub extern "C" fn _start(info: &mut BiosInfo) -> ! {
         PhysAddr::new(info.kernel.start)
     };
     let kernel_size = info.kernel.len;
-    let mut frame_allocator = {
+    let mut frame_allocator = if info.ramdisk.start == 0  {
         let kernel_end = PhysFrame::containing_address(kernel_start + kernel_size - 1u64);
         let next_free = kernel_end + 1;
         LegacyFrameAllocator::new_starting_at(
             next_free,
             memory_map.iter().copied().map(MemoryRegion),
         )
+    } else {
+        let ramdisk_end = PhysFrame::containing_address(PhysAddr::new( info.ramdisk.start + info.ramdisk.len));
+        let next_free = ramdisk_end+1;
+        LegacyFrameAllocator::new_starting_at(next_free, memory_map.iter().copied().map(MemoryRegion))
     };
 
     // We identity-mapped all memory, so the offset between physical and virtual addresses is 0

common/src/lib.rs

@@ -122,6 +122,7 @@ where
         &mut page_tables,
         system_info.framebuffer.as_ref(),
         &config,
+        &system_info
     );
     let boot_info = create_boot_info(
         &config,
@@ -153,6 +154,7 @@ pub fn set_up_mappings<I, D>(
     page_tables: &mut PageTables,
     framebuffer: Option<&RawFrameBufferInfo>,
     config: &BootloaderConfig,
+    system_info: &SystemInfo
 ) -> Mappings
 where
     I: ExactSizeIterator<Item = D> + Clone,
@@ -184,7 +186,6 @@ where
     )
     .expect("no entry point");
     log::info!("Entry point at: {:#x}", entry_point.as_u64());
-
     // create a stack
     let stack_start_addr = mapping_addr(
         config.mappings.kernel_stack,
@@ -269,6 +270,36 @@ where
     } else {
         None
     };
+    let ramdisk_slice_len = system_info.ramdisk_len;
+    let ramdisk_slice_start = if let Some(ramdisk_address) = system_info.ramdisk_addr {
+        
+        let ramdisk_address_start = mapping_addr(
+            config.mappings.ramdisk_memory, 
+            system_info.ramdisk_len, 
+            8, 
+            &mut used_entries
+        );
+        let physical_address = PhysAddr::new(ramdisk_address);
+        let ramdisk_physical_start_page: PhysFrame<Size4KiB> = PhysFrame::containing_address(physical_address);
+        let ramdisk_page_count = (system_info.ramdisk_len - 1 / Size4KiB::SIZE) + 1;
+        let ramdisk_physical_end_page = ramdisk_physical_start_page + ramdisk_page_count;
+        let start_page = Page::containing_address(ramdisk_address_start);
+
+        let flags = PageTableFlags::PRESENT | PageTableFlags::WRITABLE;
+        for (i, frame) in PhysFrame::range_inclusive(ramdisk_physical_start_page, ramdisk_physical_end_page).enumerate() {
+            let page = start_page + i as u64;
+            match unsafe { kernel_page_table.map_to(page, frame, flags, frame_allocator) } {
+                Ok(tlb) => tlb.ignore(),
+                Err(err) => panic!(
+                    "Failed to map page {:?} to frame {:?}: {:?}",
+                    page, frame, err
+                ),
+            };
+        }
+        Some(ramdisk_address_start)
+    } else {
+        None
+    };
 
     let physical_memory_offset = if let Some(mapping) = config.mappings.physical_memory {
         log::info!("Map physical memory");
@@ -343,6 +374,8 @@ where
 
         kernel_slice_start,
         kernel_slice_len,
+        ramdisk_slice_start,
+        ramdisk_slice_len
     }
 }
 
@@ -368,6 +401,8 @@ pub struct Mappings {
     pub kernel_slice_start: u64,
     /// Size of the kernel slice allocation in memory.
     pub kernel_slice_len: u64,
+    pub ramdisk_slice_start: Option<VirtAddr>,
+    pub ramdisk_slice_len: u64
 }
 
 /// Allocates and initializes the boot info struct and the memory map.
@@ -477,8 +512,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.ramdisk_addr = mappings.ramdisk_slice_start.map(|addr| addr.as_u64()).into();
+        info.ramdisk_len = mappings.ramdisk_slice_len;
         info
     });
 

src/lib.rs

@@ -17,7 +17,7 @@ mod mbr;
 mod pxe;
 
 const KERNEL_FILE_NAME: &str = "kernel-x86_64";
-const RAMDISK_FILE_NAME: &str = "ramdisk-x86_64";
+const RAMDISK_FILE_NAME: &str = "ramdisk";
 const BIOS_STAGE_3: &str = "boot-stage-3";
 const BIOS_STAGE_4: &str = "boot-stage-4";
 
@@ -131,8 +131,11 @@ impl UefiBoot {
     /// bootloader won't be found.
     pub fn create_pxe_tftp_folder(&self, out_path: &Path) -> anyhow::Result<()> {
         let bootloader_path = Path::new(env!("UEFI_BOOTLOADER_PATH"));
-
-        pxe::create_uefi_tftp_folder(bootloader_path, self.kernel.as_path(), out_path)
+        let ramdisk_path = match self.ramdisk.as_ref() {
+            Some(rd) => Some(rd.as_path()),
+            None => None,
+        };
+        pxe::create_uefi_tftp_folder(bootloader_path, self.kernel.as_path(), ramdisk_path, out_path)
             .context("failed to create UEFI PXE tftp folder")?;
 
         Ok(())

src/pxe.rs

@@ -5,6 +5,7 @@ use anyhow::Context;
 pub fn create_uefi_tftp_folder(
     bootloader_path: &Path,
     kernel_binary: &Path,
+    ramdisk_path: Option<&Path>,
     out_path: &Path,
 ) -> anyhow::Result<()> {
     std::fs::create_dir_all(out_path)
@@ -27,6 +28,16 @@ pub fn create_uefi_tftp_folder(
             to.display()
         )
     })?;
+    let to = out_path.join("ramdisk");
+    if let Some(rp) = ramdisk_path {
+        std::fs::copy(rp, &to).with_context(|| {
+            format!(
+                "failed to copy ramdisk from {} to {}",
+                rp.display(),
+                to.display()
+            )
+        })?;
+    } 
 
     Ok(())
 }

tests/ramdisk.rs

@@ -1,5 +1,3 @@
-use std::path::Path;
-
 use bootloader_test_runner::run_test_kernel;
 static RAMDISK_PATH: &str = "tests/ramdisk.txt";
 

tests/runner/src/lib.rs

@@ -5,8 +5,8 @@ const QEMU_ARGS: &[&str] = &[
     "isa-debug-exit,iobase=0xf4,iosize=0x04",
     "-serial",
     "stdio",
-    "-display",
-    "none",
+    // "-display",
+    // "none",
     "--no-reboot",
     "-m",
     "size=2048",

tests/test_kernels/ramdisk/src/bin/ramdisk.rs

@@ -2,29 +2,24 @@
 #![no_main] // disable all Rust-level entry points
 
 use bootloader_api::{entry_point, BootInfo};
-use test_kernel_ramdisk::{exit_qemu, QemuExitCode, RAMDISK_CONTENTS};
+use test_kernel_ramdisk::{exit_qemu, QemuExitCode, RAMDISK_CONTENTS, serial};
+use core::{fmt::Write, ptr::slice_from_raw_parts};
 
 
 
 entry_point!(kernel_main);
 
-fn kernel_main(boot_info: &'static mut BootInfo) -> ! {   
+fn kernel_main(boot_info: &'static mut BootInfo) -> ! {  
+    writeln!(serial(), "Boot info: {:?}", boot_info).unwrap(); 
     assert!(boot_info.ramdisk_addr.into_option().is_some());
     assert_eq!(boot_info.ramdisk_len as usize, RAMDISK_CONTENTS.len());
-
-    let ramdisk = boot_info.ramdisk_addr.into_option().unwrap() as *const u8;
-    compare_ramdisk_contents(ramdisk);    
-
+    let actual_ramdisk = unsafe { &*slice_from_raw_parts(boot_info.ramdisk_addr.into_option().unwrap() as *const u8, boot_info.ramdisk_len as usize) };
+    writeln!(serial(), "Actual contents: {:?}", actual_ramdisk).unwrap();
+    assert_eq!(RAMDISK_CONTENTS, actual_ramdisk);
 
     exit_qemu(QemuExitCode::Success);
 }
 
-fn compare_ramdisk_contents(ramdisk: *const u8) {
-    let expected = RAMDISK_CONTENTS;
-    for i in 0..expected.len() {
-        unsafe { assert_eq!(expected[i], *ramdisk.offset(i as isize)); }
-    }
-}
 /// This function is called on panic.
 #[cfg(not(test))]
 #[panic_handler]

uefi/src/main.rs

@@ -150,12 +150,13 @@ fn main_inner(image: Handle, mut st: SystemTable<Boot>) -> Status {
         LegacyFrameAllocator::new(memory_map.copied().map(UefiMemoryDescriptor));
 
     let page_tables = create_page_tables(&mut frame_allocator);
-    let mut ramdisk_addr = 0u64;
     let mut ramdisk_len = 0u64;
-    if let Some(rd) = ramdisk {
+    let ramdisk_addr = if let Some(rd) = ramdisk {
         ramdisk_len = rd.len() as u64;
-        ramdisk_addr = rd.as_ptr() as usize as u64;
-    }
+        Some(rd.as_ptr() as usize as u64)
+    } else {
+        None
+    };
     let system_info = SystemInfo {
         framebuffer,
         rsdp_addr: {
@@ -168,10 +169,7 @@ 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: match ramdisk_addr {
-            0 => None,
-            v => Some(v),
-        },
+        ramdisk_addr: ramdisk_addr,
         ramdisk_len: ramdisk_len,
     };
 
@@ -194,7 +192,7 @@ fn load_ramdisk(
     st: &mut SystemTable<Boot>,
     boot_mode: BootMode,
 ) -> Option<&'static mut [u8]> {
-    load_file_from_boot_method(image, st, "ramdisk-x86_64\0", boot_mode)
+    load_file_from_boot_method(image, st, "ramdisk\0", boot_mode)
 }
 
 fn load_kernel(