Add allocating get_info helper function

src/data_types/mod.rs

@@ -23,11 +23,13 @@ pub trait Align {
 
     /// Assert that some storage is correctly aligned for this type
     fn assert_aligned(storage: &mut [u8]) {
-        assert_eq!(
-            (storage.as_ptr() as usize) % Self::alignment(),
-            0,
-            "The provided storage is not correctly aligned for this type"
-        )
+        if !storage.is_empty() {
+            assert_eq!(
+                (storage.as_ptr() as usize) % Self::alignment(),
+                0,
+                "The provided storage is not correctly aligned for this type"
+            )
+        }
     }
 }
 

src/result/error.rs

@@ -21,6 +21,11 @@ impl<Data: Debug> Error<Data> {
     pub fn data(&self) -> &Data {
         &self.data
     }
+
+    /// Split this error into its inner status and error data
+    pub fn split(self) -> (Status, Data) {
+        (self.status, self.data)
+    }
 }
 
 // Errors without payloads can be autogenerated from statuses

src/result/mod.rs

@@ -43,6 +43,9 @@ pub trait ResultExt<Output, ErrData: Debug> {
     /// Expect success without warnings, panic with provided message otherwise
     fn expect_success(self, msg: &str) -> Output;
 
+    /// Expect error, panic with provided message otherwise, discarding output
+    fn expect_error(self, msg: &str) -> Error<ErrData>;
+
     /// Transform the inner output, if any
     fn map_inner<Mapped>(self, f: impl FnOnce(Output) -> Mapped) -> Result<Mapped, ErrData>;
 
@@ -75,6 +78,10 @@ impl<Output, ErrData: Debug> ResultExt<Output, ErrData> for Result<Output, ErrDa
         self.expect(msg).expect(msg)
     }
 
+    fn expect_error(self, msg: &str) -> Error<ErrData> {
+        self.map(|completion| completion.status()).expect_err(msg)
+    }
+
     fn map_inner<Mapped>(self, f: impl FnOnce(Output) -> Mapped) -> Result<Mapped, ErrData> {
         self.map(|completion| completion.map(f))
     }

uefi-exts/src/file.rs

@@ -0,0 +1,51 @@
+use alloc::{alloc::alloc, boxed::Box};
+use core::{alloc::Layout, mem, slice};
+use uefi::prelude::*;
+use uefi::proto::media::file::{File, FileProtocolInfo};
+use uefi::Result;
+
+/// Utility functions for dealing with file data
+pub trait FileExt: File {
+    /// Get the dynamically allocated info for a file
+    fn get_boxed_info<Info: FileProtocolInfo + ?Sized>(&mut self) -> Result<Box<Info>> {
+        // Initially try get_info with an empty array, this should always fail
+        // as all Info types at least need room for a null-terminator.
+        let size = match self
+            .get_info::<Info>(&mut [])
+            .expect_error("zero sized get_info unexpectedly succeeded")
+            .split()
+        {
+            (s, None) => return Err(s.into()),
+            (_, Some(size)) => size,
+        };
+
+        // These unsafe alloc APIs make sure our buffer is correctly aligned. We
+        // round up a size must always be a multiple of alignment. We turn the
+        // pointer into a Box<[u8]>, so it's always freed on error.
+        let layout = Layout::from_size_align(size, Info::alignment())
+            .unwrap()
+            .pad_to_align()
+            .unwrap();
+        let buffer_start = unsafe { alloc(layout) };
+        let mut buffer = unsafe { Box::from_raw(slice::from_raw_parts_mut(buffer_start, size)) };
+
+        let info = self
+            .get_info(&mut buffer)
+            .discard_errdata()?
+            .map(|info_ref| {
+                // This operation is safe because info uses the exact memory
+                // of the provied buffer (so no memory is leaked), and the box
+                // is created if and only if buffer is leaked (so no memory can
+                // ever be freed twice).
+
+                assert_eq!(mem::size_of_val(info_ref), layout.size());
+                assert_eq!(info_ref as *const Info as *const u8, buffer_start);
+                unsafe { Box::from_raw(info_ref as *mut _) }
+            });
+        mem::forget(buffer);
+
+        Ok(info)
+    }
+}
+
+impl<T: File> FileExt for T {}

uefi-exts/src/lib.rs

@@ -4,9 +4,12 @@
 //! which add utility functions to various UEFI objects.
 
 #![no_std]
-#![feature(alloc)]
+#![feature(alloc, alloc_layout_extra)]
 
 extern crate alloc;
 
 mod boot;
+mod file;
+
 pub use self::boot::BootServicesExt;
+pub use self::file::FileExt;