vi and busybox

src/fs/uefi.rs

@@ -0,0 +1,179 @@
+use core::ffi::c_void;
+
+use crate::efi::{
+    EFI_LOADED_IMAGE_PROTOCOL_GUID, EFI_NOT_FOUND, EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID,
+    EFI_SUCCESS, EfiBootServices, EfiGuid, EfiHandle, EfiLoadedImageProtocol, EfiStatus,
+};
+use crate::memory::{PAGE_SIZE, PhysicalMemoryManager};
+
+pub const BASH_PATH: &[u16] = &[
+    '\\' as u16,
+    'b' as u16,
+    'i' as u16,
+    'n' as u16,
+    '\\' as u16,
+    'b' as u16,
+    'a' as u16,
+    's' as u16,
+    'h' as u16,
+    0,
+];
+
+pub const SH_PATH: &[u16] = &[
+    '\\' as u16,
+    'b' as u16,
+    'i' as u16,
+    'n' as u16,
+    '\\' as u16,
+    's' as u16,
+    'h' as u16,
+    0,
+];
+
+const EFI_FILE_MODE_READ: u64 = 1;
+const EFI_FILE_INFO_GUID: EfiGuid = EfiGuid::new(
+    0x09576e92,
+    0x6d3f,
+    0x11d2,
+    [0x8e, 0x39, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b],
+);
+
+pub struct LoadedFile {
+    pub ptr: *const u8,
+    pub len: usize,
+}
+
+#[repr(C)]
+struct EfiSimpleFileSystemProtocol {
+    revision: u64,
+    open_volume: extern "efiapi" fn(
+        this: *mut EfiSimpleFileSystemProtocol,
+        root: *mut *mut EfiFileProtocol,
+    ) -> EfiStatus,
+}
+
+#[repr(C)]
+struct EfiFileProtocol {
+    revision: u64,
+    open: extern "efiapi" fn(
+        this: *mut EfiFileProtocol,
+        new_handle: *mut *mut EfiFileProtocol,
+        file_name: *const u16,
+        open_mode: u64,
+        attributes: u64,
+    ) -> EfiStatus,
+    close: extern "efiapi" fn(this: *mut EfiFileProtocol) -> EfiStatus,
+    delete: usize,
+    read: extern "efiapi" fn(
+        this: *mut EfiFileProtocol,
+        buffer_size: *mut usize,
+        buffer: *mut c_void,
+    ) -> EfiStatus,
+    write: usize,
+    get_position: usize,
+    set_position: usize,
+    get_info: extern "efiapi" fn(
+        this: *mut EfiFileProtocol,
+        information_type: *const EfiGuid,
+        buffer_size: *mut usize,
+        buffer: *mut c_void,
+    ) -> EfiStatus,
+}
+
+#[repr(C)]
+struct EfiFileInfoPrefix {
+    size: u64,
+    file_size: u64,
+    physical_size: u64,
+}
+
+pub unsafe fn load_file(
+    image_handle: EfiHandle,
+    boot_services: *mut EfiBootServices,
+    memory: &mut PhysicalMemoryManager,
+    path: &[u16],
+) -> Option<LoadedFile> {
+    let mut loaded_image = core::ptr::null_mut();
+    let status = unsafe {
+        ((*boot_services).handle_protocol)(
+            image_handle,
+            &EFI_LOADED_IMAGE_PROTOCOL_GUID,
+            &mut loaded_image,
+        )
+    };
+    if status != EFI_SUCCESS || loaded_image.is_null() {
+        return None;
+    }
+
+    let loaded_image = loaded_image as *mut EfiLoadedImageProtocol;
+    let mut fs = core::ptr::null_mut();
+    let status = unsafe {
+        ((*boot_services).handle_protocol)(
+            (*loaded_image).device_handle,
+            &EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID,
+            &mut fs,
+        )
+    };
+    if status != EFI_SUCCESS || fs.is_null() {
+        return None;
+    }
+
+    let fs = fs as *mut EfiSimpleFileSystemProtocol;
+    let mut root = core::ptr::null_mut();
+    let status = unsafe { ((*fs).open_volume)(fs, &mut root) };
+    if status != EFI_SUCCESS || root.is_null() {
+        return None;
+    }
+
+    let mut file = core::ptr::null_mut();
+    let status = unsafe { ((*root).open)(root, &mut file, path.as_ptr(), EFI_FILE_MODE_READ, 0) };
+    unsafe {
+        ((*root).close)(root);
+    }
+    if status == EFI_NOT_FOUND || status != EFI_SUCCESS || file.is_null() {
+        return None;
+    }
+
+    let size = unsafe { file_size(file)? };
+    let pages = size.div_ceil(PAGE_SIZE).max(1);
+    let buffer = memory.alloc_pages(pages)?;
+    let mut read_len = size;
+    let status = unsafe { ((*file).read)(file, &mut read_len, buffer.cast::<c_void>()) };
+    unsafe {
+        ((*file).close)(file);
+    }
+
+    if status != EFI_SUCCESS || read_len == 0 {
+        unsafe {
+            memory.free_pages(buffer, pages);
+        }
+        return None;
+    }
+
+    Some(LoadedFile {
+        ptr: buffer as *const u8,
+        len: read_len,
+    })
+}
+
+unsafe fn file_size(file: *mut EfiFileProtocol) -> Option<usize> {
+    let mut info_buffer = [0u8; 1024];
+    let mut info_size = info_buffer.len();
+    let status = unsafe {
+        ((*file).get_info)(
+            file,
+            &EFI_FILE_INFO_GUID,
+            &mut info_size,
+            info_buffer.as_mut_ptr().cast::<c_void>(),
+        )
+    };
+    if status != EFI_SUCCESS {
+        return None;
+    }
+    if info_size < core::mem::size_of::<EfiFileInfoPrefix>() {
+        return None;
+    }
+
+    let info = unsafe { &*(info_buffer.as_ptr() as *const EfiFileInfoPrefix) };
+    usize::try_from(info.file_size).ok()
+}