Implement ramdisk for uefi

Author: jasoncouture

bios/stage-4/src/main.rs

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

uefi/src/main.rs

@@ -13,8 +13,8 @@ use uefi::{
     prelude::{entry, Boot, Handle, Status, SystemTable},
     proto::{
         console::gop::{GraphicsOutput, PixelFormat},
-        device_path::{self, DevicePath},
-        loaded_image::{self, LoadedImage},
+        device_path::DevicePath,
+        loaded_image::LoadedImage,
         media::{
             file::{File, FileAttribute, FileInfo, FileMode},
             fs::SimpleFileSystem,
@@ -23,9 +23,11 @@ use uefi::{
             pxe::{BaseCode, DhcpV4Packet},
             IpAddress,
         },
+        ProtocolPointer,
     },
     table::boot::{
         AllocateType, MemoryDescriptor, MemoryType, OpenProtocolAttributes, OpenProtocolParams,
+        ScopedProtocol,
     },
     CStr16, CStr8,
 };
@@ -37,8 +39,8 @@ use x86_64::{
 mod memory_descriptor;
 
 static SYSTEM_TABLE: RacyCell<Option<SystemTable<Boot>>> = RacyCell::new(None);
-const KERNEL_FILENAME: &str = "kernel-x86_64";
-const RAMDISK_FILENAME: &str = "ramdisk-x86_64";
+static KERNEL_FILENAME: &str = "kernel-x86_64\0";
+static RAMDISK_FILENAME: &str = "ramdisk-x86_64\0";
 
 struct RacyCell<T>(UnsafeCell<T>);
 
@@ -98,7 +100,7 @@ fn main_inner(image: Handle, mut st: SystemTable<Boot>) -> Status {
         let ptr = st
             .boot_services()
             .allocate_pool(MemoryType::LOADER_DATA, max_mmap_size)
-            .expect("Failed to allocate memory for memory map");
+            .expect("Failed to allocate memory for mmap storage");
         unsafe { slice::from_raw_parts_mut(ptr, max_mmap_size) }
     };
 
@@ -111,7 +113,12 @@ 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 {
+        ramdisk_len = rd.len() as u64;
+        ramdisk_addr = rd.as_ptr() as usize as u64;
+    }
     let system_info = SystemInfo {
         framebuffer,
         rsdp_addr: {
@@ -124,14 +131,11 @@ 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 {
-            Some(rd) => Some(rd as *const _ as u64),
-            None => None,
-        },
-        ramdisk_len: match ramdisk {
-            Some(rd) => rd.len() as u64,
-            None => 0u64,
+        ramdisk_addr: match ramdisk_addr {
+            0 => None,
+            v => Some(v),
         },
+        ramdisk_len: ramdisk_len,
     };
 
     bootloader_x86_64_common::load_and_switch_to_kernel(
@@ -142,100 +146,125 @@ fn main_inner(image: Handle, mut st: SystemTable<Boot>) -> Status {
     );
 }
 
-fn load_ramdisk(image: Handle, st: &SystemTable<Boot>) -> Option<&'static [u8]> {
+fn load_ramdisk(image: Handle, st: &SystemTable<Boot>) -> Option<&'static mut [u8]> {
     load_file_from_disk(RAMDISK_FILENAME, image, st)
+        .or_else(|| load_file_from_tftp_boot_server(RAMDISK_FILENAME, image, st))
 }
 
 fn load_kernel(image: Handle, st: &SystemTable<Boot>) -> Kernel<'static> {
     let kernel_slice = load_file_from_disk(KERNEL_FILENAME, image, st)
-        .or_else(|| load_kernel_file_from_tftp_boot_server(KERNEL_FILENAME, image, st))
+        .or_else(|| load_file_from_tftp_boot_server(KERNEL_FILENAME, image, st))
         .expect("couldn't find kernel");
     Kernel::parse(kernel_slice)
 }
 
-fn load_file_from_disk(
-    name: &str,
+fn open_device_path_protocol(
     image: Handle,
     st: &SystemTable<Boot>,
-) -> Option<&'static mut [u8]> {
-    let file_system_raw = {
-        let this = st.boot_services();
-        let loaded_image = this.open_protocol::<LoadedImage>(
+) -> Option<ScopedProtocol<DevicePath>> {
+    let this = st.boot_services();
+    let loaded_image = unsafe {
+        this.open_protocol::<LoadedImage>(
             OpenProtocolParams {
                 handle: image,
                 agent: image,
                 controller: None,
             },
             OpenProtocolAttributes::Exclusive,
-        );
+        )
+    };
 
-        if loaded_image.is_err() {
-            log::error!("Failed to open protocol SimpleFileSystem while attempting to load {name}");
-            return None;
-        }
-        let loaded_image = loaded_image.unwrap();
-        let loaded_image = unsafe { &*loaded_image.interface.get() };
+    if loaded_image.is_err() {
+        log::error!("Failed to open protocol LoadedImage");
+        return None;
+    }
+    let loaded_image = loaded_image.unwrap();
+    let loaded_image = unsafe { &*loaded_image.interface.get() };
 
-        let device_handle = loaded_image.device();
+    let device_handle = loaded_image.device();
 
-        let device_path = this.open_protocol::<DevicePath>(
+    let device_path = unsafe {
+        this.open_protocol::<DevicePath>(
             OpenProtocolParams {
                 handle: device_handle,
                 agent: image,
                 controller: None,
             },
             OpenProtocolAttributes::Exclusive,
-        );
-        if device_path.is_err() {
-            log::error!("Failed to open protocol DevicePath while attempting to load {name}");
-            return None;
-        }
-        let device_path = device_path.unwrap();
-        let mut device_path = unsafe { &*device_path.interface.get() };
+        )
+    };
+    if device_path.is_err() {
+        log::error!("Failed to open protocol DevicePath");
+        return None;
+    }
+    Some(device_path.unwrap())
+}
 
-        let fs_handle = this.locate_device_path::<SimpleFileSystem>(&mut device_path);
-        if fs_handle.is_err() {
-            log::error!("Failed to open device path while attempting to load {name}");
-            return None;
-        }
+fn locate_and_open_protocol<P: ProtocolPointer>(
+    image: Handle,
+    st: &SystemTable<Boot>,
+) -> Option<ScopedProtocol<P>> {
+    let this = st.boot_services();
+    let device_path = open_device_path_protocol(image, st);
+    if device_path.is_none() {
+        log::error!("Unable to open device path protocol from boot services");
+        return None;
+    }
+    let device_path = device_path.unwrap();
+    let mut device_path = unsafe { &*device_path.interface.get() };
 
-        let fs_handle = fs_handle.unwrap();
+    let fs_handle = this.locate_device_path::<P>(&mut device_path);
+    if fs_handle.is_err() {
+        log::error!("Failed to open device path");
+        return None;
+    }
 
-        let opened_handle = this.open_protocol::<SimpleFileSystem>(
+    let fs_handle = fs_handle.unwrap();
+
+    let opened_handle = unsafe {
+        this.open_protocol::<P>(
             OpenProtocolParams {
                 handle: fs_handle,
                 agent: image,
                 controller: None,
             },
             OpenProtocolAttributes::Exclusive,
-        );
-
-        if opened_handle.is_err() {
-            log::error!("Failed to open file system while attempting to load {name}");
-            return None;
-        }
-        Some(opened_handle.unwrap())
+        )
     };
 
+    if opened_handle.is_err() {
+        log::error!("Failed to open protocol {}", core::any::type_name::<P>());
+        return None;
+    }
+    Some(opened_handle.unwrap())
+}
+
+fn load_file_from_disk(
+    name: &str,
+    image: Handle,
+    st: &SystemTable<Boot>,
+) -> Option<&'static mut [u8]> {
+    let file_system_raw = locate_and_open_protocol::<SimpleFileSystem>(image, st);
+
     if file_system_raw.is_none() {
-        return None();
+        return None;
     }
     let file_system_raw = file_system_raw.unwrap();
     let file_system = unsafe { &mut *file_system_raw.interface.get() };
 
     let mut root = file_system.open_volume().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());
+    let mut buf = [0u16; 256];
+    assert!(name.len() < 256);
+    let filename = CStr16::from_str_with_buf(name.trim_end_matches('\0'), &mut buf)
+        .expect("Failed to convert string to utf16");
+
+    let file_handle_result = root.open(filename, FileMode::Read, FileAttribute::empty());
 
-    if kernel_file_handle_result.is_err() {
+    if file_handle_result.is_err() {
         return None;
     }
 
-    let file_handle = kernel_file_handle_result.unwrap();
+    let file_handle = file_handle_result.unwrap();
 
     let mut file = match file_handle.into_type().unwrap() {
         uefi::proto::media::file::FileType::Regular(f) => f,
@@ -262,90 +291,52 @@ fn load_file_from_disk(
 }
 
 /// Try to load a kernel from a TFTP boot server.
-fn load_kernel_file_from_tftp_boot_server(
+fn load_file_from_tftp_boot_server(
     name: &str,
     image: Handle,
     st: &SystemTable<Boot>,
 ) -> Option<&'static mut [u8]> {
-    let this = st.boot_services();
-
-    // Try to locate a `BaseCode` protocol on the boot device.
-
-    let loaded_image = unsafe { this
-        .open_protocol::<LoadedImage>(
-            OpenProtocolParams {
-                handle: image,
-                agent: image,
-                controller: None,
-            },
-            OpenProtocolAttributes::Exclusive,
-        )
-        .expect("Failed to retrieve `LoadedImage` protocol from handle")
-    };
-    let loaded_image = unsafe { &*loaded_image.interface.get() };
-
-    let device_handle = loaded_image.device();
-
-    let device_path = unsafe { this
-        .open_protocol::<DevicePath>(
-            OpenProtocolParams {
-                handle: device_handle,
-                agent: image,
-                controller: None,
-            },
-            OpenProtocolAttributes::Exclusive,
-        )
-        .expect("Failed to retrieve `DevicePath` protocol from image's device handle")
-    };
-    let mut device_path = unsafe { &*device_path.interface.get() };
-
-    let base_code_handle = this.locate_device_path::<BaseCode>(&mut device_path).ok()?;
-
-    let base_code_raw = unsafe { this
-        .open_protocol::<BaseCode>(
-            OpenProtocolParams {
-                handle: base_code_handle,
-                agent: image,
-                controller: None,
-            },
-            OpenProtocolAttributes::Exclusive,
-        )
-        .unwrap()
-    };
+    let base_code_raw = locate_and_open_protocol::<BaseCode>(image, st);
+    if base_code_raw.is_none() {
+        // The previous code will log errors along the way, we do not need to.
+        return None;
+    }
+    let base_code_raw = base_code_raw.unwrap();
     let base_code = unsafe { &mut *base_code_raw.interface.get() };
 
     // Find the TFTP boot server.
     let mode = base_code.mode();
     assert!(mode.dhcp_ack_received);
     let dhcpv4: &DhcpV4Packet = mode.dhcp_ack.as_ref();
     let server_ip = IpAddress::new_v4(dhcpv4.bootp_si_addr);
+    let mut buf = [0u8; 256];
+    assert!(name.len() < 256);
 
-    let filename = CStr8::from_bytes_with_nul(b"kernel-x86_64\0").unwrap();
+    let filename = CStr8::from_bytes_with_nul(name.as_bytes()).unwrap();
 
     // Determine the kernel file size.
     let file_size = base_code
-        .tftp_get_file_size(&server_ip, filename)
-        .expect("Failed to query the kernel file size");
-    let kernel_size =
-        usize::try_from(file_size).expect("The kernel file size should fit into usize");
+        .tftp_get_file_size(&server_ip, &filename)
+        .expect("Failed to query the file size");
+    let kernel_size = usize::try_from(file_size).expect("The file size should fit into usize");
 
     // Allocate some memory for the kernel file.
-    let kernel_ptr = st
+    let ptr = st
         .boot_services()
         .allocate_pages(
             AllocateType::AnyPages,
             MemoryType::LOADER_DATA,
             ((kernel_size - 1) / 4096) + 1,
         )
-        .expect("Failed to allocate memory for the kernel file") as *mut u8;
-    let kernel_slice = unsafe { slice::from_raw_parts_mut(kernel_ptr, kernel_size) };
+        .expect("Failed to allocate memory for the file") as *mut u8;
+    let slice = unsafe { slice::from_raw_parts_mut(ptr, kernel_size) };
 
     // Load the kernel file.
     base_code
-        .tftp_read_file(&server_ip, filename, Some(kernel_slice))
+        .tftp_read_file(&server_ip, &filename, Some(slice))
         .expect("Failed to read kernel file from the TFTP boot server");
 
-    Some(kernel_slice)
+    Some(slice)
 }
 
 /// Creates page table abstraction types for both the bootloader and kernel page tables.
@@ -415,10 +406,10 @@ fn create_page_tables(
 }
 
 fn init_logger(st: &SystemTable<Boot>, config: BootloaderConfig) -> Option<RawFrameBufferInfo> {
-    let gop = unsafe { st
-        .boot_services()
-        .locate_protocol::<GraphicsOutput>()
-        .ok()?
+    let gop = unsafe {
+        st.boot_services()
+            .locate_protocol::<GraphicsOutput>()
+            .ok()?
     };
     let gop = unsafe { &mut *gop.get() };