Add Protocol trait and a number of Protocol implementations

Author: jackpot51

src/exec.rs

@@ -0,0 +1,41 @@
+use uefi::Handle;
+use uefi::status::Result;
+
+use crate::ffi::wstr;
+use crate::fs::load;
+use crate::loaded_image::LoadedImage;
+use crate::proto::Protocol;
+
+pub fn exec_data(data: &[u8], name: &str, args: &[&str]) -> Result<usize> {
+    let handle = crate::handle();
+    let st = crate::system_table();
+
+    let mut image_handle = Handle(0);
+    (st.BootServices.LoadImage)(false, handle, 0, data.as_ptr(), data.len(), &mut image_handle)?;
+
+    let mut cmdline = format!("\"{}\"", name);
+    for arg in args.iter() {
+        cmdline.push_str(" \"");
+        cmdline.push_str(arg);
+        cmdline.push_str("\"");
+    }
+    cmdline.push('\0');
+
+    let wcmdline = wstr(&cmdline);
+
+    if let Ok(loaded_image) = LoadedImage::handle_protocol(image_handle) {
+        loaded_image.0.LoadOptionsSize = (wcmdline.len() as u32) * 2;
+        loaded_image.0.LoadOptions = wcmdline.as_ptr();
+    }
+
+    let mut exit_size = 0;
+    let mut exit_ptr = ::core::ptr::null_mut();
+    let ret = (st.BootServices.StartImage)(image_handle, &mut exit_size, &mut exit_ptr)?;
+
+    Ok(ret)
+}
+
+pub fn exec_path(path: &str, args: &[&str]) -> Result<usize> {
+    let data = load(path)?;
+    exec_data(&data, path, args)
+}

src/ffi.rs

@@ -0,0 +1,29 @@
+use core::char;
+
+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 nstr(wstring: *const u16) -> String {
+    let mut string = String::new();
+
+    let mut i = 0;
+    loop {
+        let w = unsafe { *wstring.offset(i) };
+        i += 1;
+        if w == 0 {
+            break;
+        }
+        let c = unsafe { char::from_u32_unchecked(w as u32) };
+        string.push(c);
+    }
+
+    string
+}

src/fs.rs

@@ -0,0 +1,139 @@
+use core::{mem, slice};
+use uefi::fs::{File as InnerFile, FileInfo, SimpleFileSystem, FILE_MODE_READ};
+use uefi::guid::{Guid, FILE_INFO_ID, FILE_SYSTEM_GUID};
+use uefi::status::{Error, Result};
+
+use crate::proto::Protocol;
+use crate::ffi::wstr;
+
+pub struct FileSystem(pub &'static mut SimpleFileSystem);
+
+impl Protocol<SimpleFileSystem> for FileSystem {
+    fn guid() -> Guid {
+        FILE_SYSTEM_GUID
+    }
+
+    fn new(inner: &'static mut SimpleFileSystem) -> Self {
+        FileSystem(inner)
+    }
+}
+
+impl FileSystem {
+    pub fn root(&mut self) -> Result<Dir> {
+        let mut interface = 0 as *mut InnerFile;
+        (self.0.OpenVolume)(self.0, &mut interface)?;
+
+        Ok(Dir(File(unsafe { &mut *interface })))
+    }
+}
+
+pub struct File(pub &'static mut InnerFile);
+
+impl File {
+    pub fn info(&mut self) -> Result<FileInfo> {
+        let mut info = FileInfo::default();
+        let buf = unsafe {
+            slice::from_raw_parts_mut(
+                &mut info as *mut _ as *mut u8,
+                mem::size_of_val(&info)
+            )
+        };
+        let mut len = buf.len();
+        (self.0.GetInfo)(self.0, &FILE_INFO_ID, &mut len, buf.as_mut_ptr())?;
+        Ok(info)
+    }
+
+    pub fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
+        let mut len = buf.len();
+        (self.0.Read)(self.0, &mut len, buf.as_mut_ptr())?;
+        Ok(len)
+    }
+
+    pub fn read_to_end(&mut self, vec: &mut Vec<u8>) -> Result<usize> {
+        let mut total = 0;
+
+        loop {
+            let mut buf = [0; 8192];
+
+            let count = self.read(&mut buf)?;
+            if count == 0 {
+                break;
+            }
+
+            vec.extend(&buf[.. count]);
+            total += count;
+        }
+
+        Ok(total)
+    }
+
+    pub fn write(&mut self, buf: &[u8]) -> Result<usize> {
+        let mut len = buf.len();
+        (self.0.Write)(self.0, &mut len, buf.as_ptr())?;
+        Ok(len)
+    }
+}
+
+impl Drop for File {
+    fn drop(&mut self) {
+        let _ = (self.0.Close)(self.0);
+    }
+}
+
+pub struct Dir(pub File);
+
+impl Dir {
+    pub fn open(&mut self, filename: &[u16]) -> Result<File> {
+        let mut interface = 0 as *mut InnerFile;
+        ((self.0).0.Open)((self.0).0, &mut interface, filename.as_ptr(), FILE_MODE_READ, 0)?;
+
+        Ok(File(unsafe { &mut *interface }))
+    }
+
+    pub fn open_dir(&mut self, filename: &[u16]) -> Result<Dir> {
+        let file = self.open(filename)?;
+        Ok(Dir(file))
+    }
+
+    pub fn read(&mut self) -> Result<Option<FileInfo>> {
+        let mut info = FileInfo::default();
+        let buf = unsafe {
+            slice::from_raw_parts_mut(
+                &mut info as *mut _ as *mut u8,
+                mem::size_of_val(&info)
+            )
+        };
+        match self.0.read(buf) {
+            Ok(0) => Ok(None),
+            Ok(_len) => Ok(Some(info)),
+            Err(err) => Err(err)
+        }
+    }
+}
+
+pub fn find(path: &str) -> Result<(usize, File)> {
+    let wpath = wstr(path);
+
+    for (i, mut fs) in FileSystem::all().iter_mut().enumerate() {
+        let mut root = fs.root()?;
+        match root.open(&wpath) {
+            Ok(file) => {
+                return Ok((i, file));
+            },
+            Err(err) => if err != Error::NotFound {
+                return Err(err);
+            }
+        }
+    }
+
+    Err(Error::NotFound)
+}
+
+pub fn load(path: &str) -> Result<Vec<u8>> {
+    let (_i, mut file) = find(path)?;
+
+    let mut data = vec![];
+    let _count = file.read_to_end(&mut data)?;
+
+    Ok(data)
+}

src/lib.rs

@@ -78,14 +78,24 @@ pub use core::hint;
 
 /* } */
 
+// Re-export uefi and uefi_alloc
 pub use uefi;
 pub use uefi_alloc;
 
-pub mod io;
-pub mod math;
-pub mod panic;
+// Runtime support
 pub mod rt;
 
+// Public modules
+pub mod exec;
+pub mod ffi;
+pub mod fs;
+pub mod io;
+pub mod loaded_image;
+pub mod pointer;
+pub mod proto;
+pub mod shell;
+pub mod vars;
+
 #[global_allocator]
 static ALLOCATOR: uefi_alloc::Allocator = uefi_alloc::Allocator;
 

src/loaded_image.rs

@@ -0,0 +1,16 @@
+use uefi::guid::{Guid, LOADED_IMAGE_PROTOCOL_GUID};
+use uefi::loaded_image::LoadedImage as UefiLoadedImage;
+
+use crate::proto::Protocol;
+
+pub struct LoadedImage(pub &'static mut UefiLoadedImage);
+
+impl Protocol<UefiLoadedImage> for LoadedImage {
+    fn guid() -> Guid {
+        LOADED_IMAGE_PROTOCOL_GUID
+    }
+
+    fn new(inner: &'static mut UefiLoadedImage) -> Self {
+        LoadedImage(inner)
+    }
+}

src/pointer.rs

@@ -0,0 +1,16 @@
+use uefi::guid::{Guid, SIMPLE_POINTER_GUID};
+use uefi::pointer::SimplePointer;
+
+use crate::proto::Protocol;
+
+pub struct Pointer(pub &'static mut SimplePointer);
+
+impl Protocol<SimplePointer> for Pointer {
+    fn guid() -> Guid {
+        SIMPLE_POINTER_GUID
+    }
+
+    fn new(inner: &'static mut SimplePointer) -> Self {
+        Pointer(inner)
+    }
+}

src/proto.rs

@@ -0,0 +1,53 @@
+use core::mem;
+use uefi::Handle;
+use uefi::boot::LocateSearchType;
+use uefi::guid::Guid;
+use uefi::status::Result;
+
+use crate::system_table;
+
+pub trait Protocol<T: 'static> {
+    fn guid() -> Guid;
+
+    fn new(fs: &'static mut T) -> Self where Self: Sized;
+
+    fn locate_protocol() -> Result<Self> where Self: Sized {
+        let guid = Self::guid();
+        let mut interface = 0;
+        (system_table().BootServices.LocateProtocol)(&guid, 0, &mut interface)?;
+
+        Ok(Self::new(unsafe { &mut *(interface as *mut T) }))
+    }
+
+    fn handle_protocol(handle: Handle) -> Result<Self> where Self: Sized {
+        let guid = Self::guid();
+        let mut interface = 0;
+        (system_table().BootServices.HandleProtocol)(handle, &guid, &mut interface)?;
+
+        Ok(Self::new(unsafe { &mut *(interface as *mut T) }))
+    }
+
+    fn locate_handle() -> Result<Vec<Self>> where Self: Sized {
+        let guid = Self::guid();
+        let mut handles = Vec::with_capacity(256);
+        let mut len = handles.capacity() * mem::size_of::<Handle>();
+        (system_table().BootServices.LocateHandle)(LocateSearchType::ByProtocol, &guid, 0, &mut len, handles.as_mut_ptr())?;
+        unsafe { handles.set_len(len / mem::size_of::<Handle>()); }
+
+        let mut instances = Vec::new();
+        for handle in handles {
+            if let Ok(instance) = Self::handle_protocol(handle) {
+                instances.push(instance);
+            }
+        }
+        Ok(instances)
+    }
+
+    fn one() -> Result<Self> where Self: Sized {
+        Self::locate_protocol()
+    }
+
+    fn all() -> Vec<Self> where Self: Sized {
+        Self::locate_handle().unwrap_or(Vec::new())
+    }
+}

src/math.rs renamed to src/rt/math.rs

@@ -0,0 +1,3 @@
+pub mod math;
+pub mod panic;
+pub mod start;