Merge pull request #895 from nicholasbishop/bishop-raw-disk

Add raw disk protocols and use them in `uefi`

Author: phip1611

uefi-raw/src/protocol/disk.rs

@@ -0,0 +1,62 @@
+use crate::{guid, Event, Guid, Status};
+use core::ffi::c_void;
+
+#[repr(C)]
+pub struct DiskIoProtocol {
+    pub revision: u64,
+    pub read_disk: unsafe extern "efiapi" fn(
+        this: *const Self,
+        media_id: u32,
+        offset: u64,
+        buffer_size: usize,
+        buffer: *mut c_void,
+    ) -> Status,
+    pub write_disk: unsafe extern "efiapi" fn(
+        this: *mut Self,
+        media_id: u32,
+        offset: u64,
+        buffer_size: usize,
+        buffer: *const c_void,
+    ) -> Status,
+}
+
+impl DiskIoProtocol {
+    pub const GUID: Guid = guid!("ce345171-ba0b-11d2-8e4f-00a0c969723b");
+    pub const REVISION: u64 = 0x00010000;
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd)]
+pub struct DiskIo2Token {
+    pub event: Event,
+    pub transaction_status: Status,
+}
+
+#[repr(C)]
+pub struct DiskIo2Protocol {
+    pub revision: u64,
+    pub cancel: unsafe extern "efiapi" fn(this: *mut Self) -> Status,
+    pub read_disk_ex: unsafe extern "efiapi" fn(
+        this: *const Self,
+        media_id: u32,
+        offset: u64,
+        token: *mut DiskIo2Token,
+        buffer_size: usize,
+        buffer: *mut c_void,
+    ) -> Status,
+    pub write_disk_ex: unsafe extern "efiapi" fn(
+        this: *mut Self,
+        media_id: u32,
+        offset: u64,
+        token: *mut DiskIo2Token,
+        buffer_size: usize,
+        buffer: *const c_void,
+    ) -> Status,
+    pub flush_disk_ex:
+        unsafe extern "efiapi" fn(this: *mut Self, token: *mut DiskIo2Token) -> Status,
+}
+
+impl DiskIo2Protocol {
+    pub const GUID: Guid = guid!("151c8eae-7f2c-472c-9e54-9828194f6a88");
+    pub const REVISION: u64 = 0x00020000;
+}

uefi-raw/src/protocol/mod.rs

@@ -6,5 +6,6 @@
 
 pub mod console;
 pub mod device_path;
+pub mod disk;
 pub mod loaded_image;
 pub mod rng;

uefi/src/proto/media/disk.rs

@@ -1,34 +1,20 @@
 //! Disk I/O protocols.
 
 use crate::proto::unsafe_protocol;
+use crate::util::opt_nonnull_to_ptr;
 use crate::{Event, Result, Status, StatusExt};
 use core::ptr::NonNull;
+use uefi_raw::protocol::disk::{DiskIo2Protocol, DiskIoProtocol};
 
 /// The disk I/O protocol.
 ///
 /// This protocol is used to abstract the block accesses of the block I/O
 /// protocol to a more general offset-length protocol. Firmware is
 /// responsible for adding this protocol to any block I/O interface that
 /// appears in the system that does not already have a disk I/O protocol.
-#[repr(C)]
-#[unsafe_protocol("ce345171-ba0b-11d2-8e4f-00a0c969723b")]
-pub struct DiskIo {
-    revision: u64,
-    read_disk: extern "efiapi" fn(
-        this: &DiskIo,
-        media_id: u32,
-        offset: u64,
-        len: usize,
-        buffer: *mut u8,
-    ) -> Status,
-    write_disk: extern "efiapi" fn(
-        this: &mut DiskIo,
-        media_id: u32,
-        offset: u64,
-        len: usize,
-        buffer: *const u8,
-    ) -> Status,
-}
+#[repr(transparent)]
+#[unsafe_protocol(DiskIoProtocol::GUID)]
+pub struct DiskIo(DiskIoProtocol);
 
 impl DiskIo {
     /// Reads bytes from the disk device.
@@ -46,7 +32,16 @@ impl DiskIo {
     /// * `uefi::status::NO_MEDIA`          There is no medium in the device.
     /// * `uefi::status::MEDIA_CHANGED`     `media_id` is not for the current medium.
     pub fn read_disk(&self, media_id: u32, offset: u64, buffer: &mut [u8]) -> Result {
-        (self.read_disk)(self, media_id, offset, buffer.len(), buffer.as_mut_ptr()).to_result()
+        unsafe {
+            (self.0.read_disk)(
+                &self.0,
+                media_id,
+                offset,
+                buffer.len(),
+                buffer.as_mut_ptr().cast(),
+            )
+        }
+        .to_result()
     }
 
     /// Writes bytes to the disk device.
@@ -65,7 +60,16 @@ impl DiskIo {
     /// * `uefi::status::MEDIA_CHANGED`     `media_id` is not for the current medium.
     /// * `uefi::status::WRITE_PROTECTED`   The device cannot be written to.
     pub fn write_disk(&mut self, media_id: u32, offset: u64, buffer: &[u8]) -> Result {
-        (self.write_disk)(self, media_id, offset, buffer.len(), buffer.as_ptr()).to_result()
+        unsafe {
+            (self.0.write_disk)(
+                &mut self.0,
+                media_id,
+                offset,
+                buffer.len(),
+                buffer.as_ptr().cast(),
+            )
+        }
+        .to_result()
     }
 }
 
@@ -83,30 +87,9 @@ pub struct DiskIo2Token {
 ///
 /// This protocol provides an extension to the disk I/O protocol to enable
 /// non-blocking / asynchronous byte-oriented disk operation.
-#[repr(C)]
-#[unsafe_protocol("151c8eae-7f2c-472c-9e54-9828194f6a88")]
-pub struct DiskIo2 {
-    revision: u64,
-    cancel: extern "efiapi" fn(this: &mut DiskIo2) -> Status,
-    read_disk_ex: extern "efiapi" fn(
-        this: &DiskIo2,
-        media_id: u32,
-        offset: u64,
-        token: Option<NonNull<DiskIo2Token>>,
-        len: usize,
-        buffer: *mut u8,
-    ) -> Status,
-    write_disk_ex: extern "efiapi" fn(
-        this: &mut DiskIo2,
-        media_id: u32,
-        offset: u64,
-        token: Option<NonNull<DiskIo2Token>>,
-        len: usize,
-        buffer: *const u8,
-    ) -> Status,
-    flush_disk_ex:
-        extern "efiapi" fn(this: &mut DiskIo2, token: Option<NonNull<DiskIo2Token>>) -> Status,
-}
+#[repr(transparent)]
+#[unsafe_protocol(DiskIo2Protocol::GUID)]
+pub struct DiskIo2(DiskIo2Protocol);
 
 impl DiskIo2 {
     /// Terminates outstanding asynchronous requests to the device.
@@ -115,7 +98,7 @@ impl DiskIo2 {
     /// * `uefi::status::DEVICE_ERROR`  The device reported an error while performing
     ///                                 the cancel operation.
     pub fn cancel(&mut self) -> Result {
-        (self.cancel)(self).to_result()
+        unsafe { (self.0.cancel)(&mut self.0) }.to_result()
     }
 
     /// Reads bytes from the disk device.
@@ -149,7 +132,9 @@ impl DiskIo2 {
         len: usize,
         buffer: *mut u8,
     ) -> Result {
-        (self.read_disk_ex)(self, media_id, offset, token, len, buffer).to_result()
+        let token = opt_nonnull_to_ptr(token);
+        (self.0.read_disk_ex)(&self.0, media_id, offset, token.cast(), len, buffer.cast())
+            .to_result()
     }
 
     /// Writes bytes to the disk device.
@@ -184,7 +169,16 @@ impl DiskIo2 {
         len: usize,
         buffer: *const u8,
     ) -> Result {
-        (self.write_disk_ex)(self, media_id, offset, token, len, buffer).to_result()
+        let token = opt_nonnull_to_ptr(token);
+        (self.0.write_disk_ex)(
+            &mut self.0,
+            media_id,
+            offset,
+            token.cast(),
+            len,
+            buffer.cast(),
+        )
+        .to_result()
     }
 
     /// Flushes all modified data to the physical device.
@@ -202,6 +196,7 @@ impl DiskIo2 {
     ///                                     the flush operation.
     /// * `uefi::status::WRITE_PROTECTED`   The device cannot be written to.
     pub fn flush_disk(&mut self, token: Option<NonNull<DiskIo2Token>>) -> Result {
-        (self.flush_disk_ex)(self, token).to_result()
+        let token = opt_nonnull_to_ptr(token);
+        unsafe { (self.0.flush_disk_ex)(&mut self.0, token.cast()) }.to_result()
     }
 }

uefi/src/table/boot.rs

@@ -6,6 +6,7 @@ use crate::proto::device_path::DevicePath;
 use crate::proto::loaded_image::LoadedImage;
 use crate::proto::media::fs::SimpleFileSystem;
 use crate::proto::{Protocol, ProtocolPointer};
+use crate::util::opt_nonnull_to_ptr;
 use crate::{Char16, Error, Event, Guid, Handle, Result, Status, StatusExt};
 use core::cell::UnsafeCell;
 use core::ffi::c_void;
@@ -42,11 +43,6 @@ static IMAGE_HANDLE: GlobalImageHandle = GlobalImageHandle {
 /// size is always 4 KiB.
 pub const PAGE_SIZE: usize = 4096;
 
-/// Get the raw pointer from `opt`, defaulting to `null_mut`.
-fn opt_nonnull_to_ptr<T>(opt: Option<NonNull<T>>) -> *mut T {
-    opt.map(NonNull::as_ptr).unwrap_or(ptr::null_mut())
-}
-
 /// Contains pointers to all of the boot services.
 ///
 /// # Accessing `BootServices`

uefi/src/util.rs

@@ -1,4 +1,5 @@
 use core::mem;
+use core::ptr::{self, NonNull};
 
 /// Copy the bytes of `val` to `ptr`, then advance pointer to just after the
 /// newly-copied bytes.
@@ -24,6 +25,11 @@ pub const fn usize_from_u32(val: u32) -> usize {
     }
 }
 
+/// Get the raw pointer from `opt`, defaulting to `null_mut`.
+pub fn opt_nonnull_to_ptr<T>(opt: Option<NonNull<T>>) -> *mut T {
+    opt.map(NonNull::as_ptr).unwrap_or(ptr::null_mut())
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;