implement file system ops

Signed-off-by: Daniel Schaefer <dhs@frame.work>

Author: JohnAZoidberg

Cargo.lock

@@ -19,5 +19,10 @@ default-members = [
     "framework_tool",
 ]
 
+# Need latest commit that hasn't been released yet
+[patch.crates-io]
+uefi = { git = "https://github.com/rust-osdev/uefi-rs", rev = "1fcf4d84d5ed10fe76055469b6df01318eb35af8" }
+uefi-raw = { git = "https://github.com/rust-osdev/uefi-rs", rev = "1fcf4d84d5ed10fe76055469b6df01318eb35af8" }
+
 [profile.release]
 lto = true

Cargo.toml

@@ -9,11 +9,11 @@
 //! - `windows` - It uses [DHowett's Windows driver](https://github.com/DHowett/FrameworkWindowsUtils)
 
 use crate::ec_binary;
+#[cfg(feature = "uefi")]
+use crate::fw_uefi::shell_get_execution_break_flag;
 use crate::os_specific;
 use crate::power;
 use crate::smbios;
-#[cfg(feature = "uefi")]
-use crate::fw_uefi::shell_get_execution_break_flag;
 use crate::util::{self, Platform};
 
 use no_std_compat::time::Duration;

framework_lib/src/chromium_ec/mod.rs

@@ -48,6 +48,8 @@ use crate::chromium_ec::{EcError, EcResult};
 use crate::csme;
 use crate::ec_binary;
 use crate::esrt;
+#[cfg(feature = "uefi")]
+use crate::fw_uefi::enable_page_break;
 #[cfg(feature = "rusb")]
 use crate::inputmodule::check_inputmodule_version;
 #[cfg(target_os = "linux")]
@@ -62,8 +64,6 @@ use crate::smbios::{dmidecode_string_val, get_smbios, is_framework};
 use crate::touchpad::print_touchpad_fw_ver;
 #[cfg(feature = "hidapi")]
 use crate::touchscreen;
-#[cfg(feature = "uefi")]
-use crate::fw_uefi::enable_page_break;
 #[cfg(feature = "rusb")]
 use crate::usbhub::check_usbhub_version;
 use crate::util::{self, Config, Platform, PlatformFamily};

framework_lib/src/commandline/mod.rs

@@ -4,9 +4,8 @@ use alloc::vec::Vec;
 
 #[allow(unused_imports)]
 use log::{debug, error, info, trace};
-use uefi::prelude::BootServices;
-use uefi::proto::shell_params::*;
-use uefi::Handle;
+use uefi::boot;
+use uefi::proto::shell_params::ShellParameters;
 
 use crate::chromium_ec::commands::SetGpuSerialMagic;
 use crate::chromium_ec::{CrosEcDriverType, HardwareDeviceType};
@@ -15,13 +14,19 @@ use crate::commandline::{Cli, LogLevel};
 use super::{ConsoleArg, FpBrightnessArg, InputDeckModeArg, RebootEcArg, TabletModeArg};
 
 /// Get commandline arguments from UEFI environment
-pub fn get_args(bs: &BootServices, image_handle: Handle) -> Vec<String> {
-    if let Ok(shell_params) = bs.open_protocol_exclusive::<ShellParameters>(image_handle) {
-        shell_params.get_args()
-    } else {
-        // No protocol found if the application wasn't executed by the shell
-        vec![]
-    }
+pub fn get_args() -> Vec<String> {
+    let shell_params = uefi::boot::open_protocol_exclusive::<ShellParameters>(boot::image_handle());
+    let shell_params = match shell_params {
+        Ok(s) => s,
+        Err(e) => {
+            error!("Failed to get ShellParameters protocol");
+            // TODO: Return result
+            // return e.status();
+            return vec![];
+        }
+    };
+    let args: Vec<String> = shell_params.args().map(|x| x.to_string()).collect();
+    args
 }
 
 pub fn parse(args: &[String]) -> Cli {

framework_lib/src/commandline/uefi.rs

@@ -518,7 +518,7 @@ pub const SYSTEM_RESOURCE_TABLE_GUID_BYTES: [u8; 16] = [
 pub fn get_esrt() -> Option<Esrt> {
     with_config_table(|slice| {
         for i in slice {
-            if i.guid == uefi::table::cfg::ESRT_GUID {
+            if i.guid == ConfigTableEntry::ESRT_GUID {
                 unsafe {
                     return esrt_from_buf(i.address as *const u8);
                 }

framework_lib/src/esrt/mod.rs

@@ -0,0 +1,148 @@
+use alloc::vec;
+use alloc::vec::Vec;
+use uefi::prelude::*;
+use uefi::proto::shell::{Shell, ShellProtocol};
+//use uefi::proto::shell::FileOpenMode;
+use core::ffi::c_void;
+use core::mem::MaybeUninit;
+use core::ptr::NonNull;
+use uefi::Result;
+
+#[repr(transparent)]
+#[derive(Clone, Copy, Debug)]
+pub struct ShellFileHandle(NonNull<c_void>);
+
+const FILE_MODE_READ: u64 = 0x0000000000000001;
+const FILE_MODE_WRITE: u64 = 0x0000000000000002;
+const FILE_MODE_CREATE: u64 = 0x8000000000000000;
+
+pub fn wstr(string: &str) -> Vec<u16> {
+    let mut wstring = vec![];
+
+    for c in string.chars() {
+        wstring.push(c as u16);
+    }
+    wstring.push(0);
+
+    wstring
+}
+
+pub fn shell_read_file(path: &str) -> Option<Vec<u8>> {
+    let handle = boot::get_handle_for_protocol::<Shell>().expect("No Shell handles");
+    let mut shell =
+        boot::open_protocol_exclusive::<Shell>(handle).expect("Failed to open Shell protocol");
+    let shell = unsafe {
+        let proto: &ShellProtocol = std::mem::transmute(shell.get().unwrap());
+        proto
+    };
+
+    println!("Opened shell protocol");
+
+    debug_assert_eq!(shell.major_version, 2);
+    debug_assert_eq!(shell.minor_version, 2);
+
+    println!(
+        "Shell protocol ver: {}.{}",
+        shell.major_version, shell.minor_version
+    );
+
+    unsafe {
+        let c_path = wstr(path);
+        let mut mode = FILE_MODE_READ;
+        let mut handle: MaybeUninit<*const c_void> = MaybeUninit::zeroed();
+        (shell.open_file_by_name)(c_path.as_ptr(), handle.as_mut_ptr().cast(), mode);
+
+        println!("Opened file");
+
+        let file_handle = handle.assume_init();
+
+        let mut file_size = 0;
+        println!("get_file_size");
+        let res = (shell.get_file_size)(file_handle, &mut file_size);
+        // let file_size = res.unwrap();
+
+        let mut buffer: Vec<u8> = vec![0; file_size as usize];
+        let mut read_size = file_size as usize;
+        println!("read_file {} bytes", file_size);
+        (shell.read_file)(
+            file_handle,
+            &mut read_size,
+            buffer.as_mut_ptr() as *mut c_void,
+        );
+
+        println!("close_file");
+
+        //  TODO: Make it auto-close using Rust destructors
+        (shell.close_file)(file_handle);
+
+        println!("Done");
+
+        Some(buffer)
+    }
+}
+
+pub fn shell_write_file(path: &str, data: &[u8]) -> Result {
+    let handle = boot::get_handle_for_protocol::<Shell>().expect("No Shell handles");
+    let mut shell =
+        boot::open_protocol_exclusive::<Shell>(handle).expect("Failed to open Shell protocol");
+    let shell = unsafe {
+        let proto: &ShellProtocol = std::mem::transmute(shell.get().unwrap());
+        proto
+    };
+
+    debug_assert_eq!(shell.major_version, 2);
+    debug_assert_eq!(shell.minor_version, 2);
+
+    unsafe {
+        // let mode = FileOpenMode::Read as u64 + FileOpenMode::Write as u64 + FileOpenMode::Create as u64;
+        let mode = FILE_MODE_READ + FILE_MODE_WRITE + FILE_MODE_CREATE;
+        let c_path = wstr(path);
+        let mut handle: MaybeUninit<*const c_void> = MaybeUninit::zeroed();
+        (shell.open_file_by_name)(c_path.as_ptr(), handle.as_mut_ptr().cast(), mode);
+        let file_handle = handle.assume_init();
+
+        //// TODO: Free file_info buffer
+        //let file_info = (shell.0.GetFileInfo)(file_handle);
+        //if file_info.is_null() {
+        //    println!("Failed to get file info");
+        //    return ret;
+        //}
+
+        //// Not sure if it's useful to set FileInfo
+        ////let mut file_info = unsafe {
+        ////    &mut *(file_info as *mut FileInfo)
+        ////};
+        ////println!("file_info.Size: {}", file_info.Size);
+
+        ////if file_info.Size != 0 {
+        ////    file_info.Size = 0;
+        ////    let ret = (shell.0.SetFileInfo)(file_handle, file_info);
+        ////    if ret.0 != 0 {
+        ////        println!("Failed to set file info");
+        ////        return ret;
+        ////    }
+        ////}
+
+        //let mut buffer_size = data.len() as usize;
+        //let ret = (shell.0.WriteFile)(file_handle, &mut buffer_size, data.as_ptr());
+        //if ret.0 != 0 {
+        //    println!("Failed to write file");
+        //    return ret;
+        //}
+        //if buffer_size != data.len() {
+        //    println!(
+        //        "Failed to write whole buffer. Instead of {} wrote {} bytes.",
+        //        data.len(),
+        //        buffer_size
+        //    );
+        //    return Status(1);
+        //}
+
+        let mut read_size = data.len();
+        (shell.write_file)(file_handle, &mut read_size, data.as_ptr() as *mut c_void);
+
+        (shell.close_file)(file_handle);
+
+        Status::SUCCESS.to_result()
+    }
+}

framework_lib/src/fw_uefi/fs.rs

@@ -0,0 +1,115 @@
+use alloc::vec::Vec;
+use core::slice;
+use uefi::system::with_config_table;
+use uefi::table::cfg::ConfigTableEntry;
+
+#[allow(unused_imports)]
+use log::{debug, error, info, trace};
+use uefi::boot;
+use uefi::proto::shell::{Shell, ShellProtocol};
+
+pub mod fs;
+
+/// Returns true when the execution break was requested, false otherwise
+pub fn shell_get_execution_break_flag() -> bool {
+    let handle = boot::get_handle_for_protocol::<Shell>().expect("No Shell handles");
+    let shell =
+        boot::open_protocol_exclusive::<Shell>(handle).expect("Failed to open Shell protocol");
+    unsafe {
+        let proto: &ShellProtocol = std::mem::transmute(shell.get().unwrap());
+        (proto.get_page_break)()
+    }
+}
+
+/// Enable pagination in UEFI shell
+///
+/// Pagination is handled by the UEFI shell environment automatically, whenever
+/// the application prints more than fits on the screen.
+pub fn enable_page_break() {
+    let handle = boot::get_handle_for_protocol::<Shell>().expect("No Shell handles");
+    let shell =
+        boot::open_protocol_exclusive::<Shell>(handle).expect("Failed to open Shell protocol");
+    unsafe {
+        let proto: &ShellProtocol = std::mem::transmute(shell.get().unwrap());
+        (proto.enable_page_break)()
+    }
+}
+
+#[repr(C, packed)]
+pub struct Smbios {
+    pub anchor: [u8; 4],
+    pub checksum: u8,
+    pub length: u8,
+    pub major_version: u8,
+    pub minor_version: u8,
+    pub max_structure_size: u16,
+    pub revision: u8,
+    pub formatted: [u8; 5],
+    pub inter_anchor: [u8; 5],
+    pub inter_checksum: u8,
+    pub table_length: u16,
+    pub table_address: u32,
+    pub structure_count: u16,
+    pub bcd_revision: u8,
+}
+
+impl Smbios {
+    pub fn checksum_valid(&self) -> bool {
+        let mut sum: u8 = self.anchor.iter().sum::<u8>();
+        sum += self.checksum;
+        sum += self.length;
+        sum += self.major_version;
+        sum += self.minor_version;
+        sum += self.max_structure_size as u8;
+        sum += self.revision;
+        sum += self.formatted.iter().sum::<u8>();
+        sum == 0
+    }
+}
+
+pub struct Smbios3 {
+    pub anchor: [u8; 5],
+    pub checksum: u8,
+    pub length: u8,
+    pub major_version: u8,
+    pub minor_version: u8,
+    pub docrev: u8,
+    pub revision: u8,
+    _reserved: u8,
+    pub table_length: u32,
+    pub table_address: u64,
+}
+
+pub fn smbios_data() -> Option<Vec<u8>> {
+    with_config_table(|slice| {
+        for i in slice {
+            let table_data = match i.guid {
+                ConfigTableEntry::SMBIOS3_GUID => unsafe {
+                    let smbios = &*(i.address as *const Smbios3);
+                    debug!("SMBIOS3 valid: {:?}", smbios.anchor == *b"_SM3_");
+                    Some(slice::from_raw_parts(
+                        smbios.table_address as *const u8,
+                        smbios.table_length as usize,
+                    ))
+                },
+                ConfigTableEntry::SMBIOS_GUID => unsafe {
+                    let smbios = &*(i.address as *const Smbios);
+                    debug!("SMBIOS valid: {:?}", smbios.checksum_valid());
+                    Some(slice::from_raw_parts(
+                        smbios.table_address as *const u8,
+                        smbios.table_length as usize,
+                    ))
+                },
+                _ => None,
+            };
+
+            if let Some(data) = table_data {
+                // Return directly here because there is only ever the old config
+                // table or the new V3 config table. Never both.
+                return Some(data.to_vec());
+            }
+        }
+
+        None
+    })
+}