Merge pull request #909 from nicholasbishop/bishop-raw-blockio

Add block I/O protocol to `uefi-raw` and use it in `uefi`

Author: phip1611

uefi-raw/src/protocol/block.rs

@@ -0,0 +1,53 @@
+use crate::{guid, Guid, Status};
+use core::ffi::c_void;
+
+/// Logical block address.
+pub type Lba = u64;
+
+/// Media information structure
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct BlockIoMedia {
+    pub media_id: u32,
+    pub removable_media: bool,
+    pub media_present: bool,
+    pub logical_partition: bool,
+    pub read_only: bool,
+    pub write_caching: bool,
+    pub block_size: u32,
+    pub io_align: u32,
+    pub last_block: Lba,
+
+    // Added in revision 2.
+    pub lowest_aligned_lba: Lba,
+    pub logical_blocks_per_physical_block: u32,
+
+    // Added in revision 3.
+    pub optimal_transfer_length_granularity: u32,
+}
+
+#[repr(C)]
+pub struct BlockIo {
+    pub revision: u64,
+    pub media: *const BlockIoMedia,
+    pub reset: unsafe extern "efiapi" fn(this: *mut Self, extended_verification: bool) -> Status,
+    pub read_blocks: unsafe extern "efiapi" fn(
+        this: *const Self,
+        media_id: u32,
+        lba: Lba,
+        buffer_size: usize,
+        buffer: *mut c_void,
+    ) -> Status,
+    pub write_blocks: unsafe extern "efiapi" fn(
+        this: *mut Self,
+        media_id: u32,
+        lba: Lba,
+        buffer_size: usize,
+        buffer: *const c_void,
+    ) -> Status,
+    pub flush_blocks: unsafe extern "efiapi" fn(this: *mut Self) -> Status,
+}
+
+impl BlockIo {
+    pub const GUID: Guid = guid!("964e5b21-6459-11d2-8e39-00a0c969723b");
+}

uefi-raw/src/protocol/mod.rs

@@ -4,6 +4,7 @@
 //! ID. They can be implemented by a UEFI driver or occasionally by a
 //! UEFI application.
 
+pub mod block;
 pub mod console;
 pub mod device_path;
 pub mod disk;

uefi/src/proto/media/block.rs

@@ -1,38 +1,20 @@
 //! Block I/O protocols.
 
 use crate::proto::unsafe_protocol;
-use crate::{Result, Status, StatusExt};
+use crate::{Result, StatusExt};
+
+pub use uefi_raw::protocol::block::Lba;
 
 /// The Block I/O protocol.
-#[repr(C)]
-#[unsafe_protocol("964e5b21-6459-11d2-8e39-00a0c969723b")]
-pub struct BlockIO {
-    revision: u64,
-    media: *const BlockIOMedia,
-
-    reset: extern "efiapi" fn(this: &BlockIO, extended_verification: bool) -> Status,
-    read_blocks: extern "efiapi" fn(
-        this: &BlockIO,
-        media_id: u32,
-        lba: Lba,
-        buffer_size: usize,
-        buffer: *mut u8,
-    ) -> Status,
-    write_blocks: extern "efiapi" fn(
-        this: &BlockIO,
-        media_id: u32,
-        lba: Lba,
-        buffer_size: usize,
-        buffer: *const u8,
-    ) -> Status,
-    flush_blocks: extern "efiapi" fn(this: &BlockIO) -> Status,
-}
+#[repr(transparent)]
+#[unsafe_protocol(uefi_raw::protocol::block::BlockIo::GUID)]
+pub struct BlockIO(uefi_raw::protocol::block::BlockIo);
 
 impl BlockIO {
     /// Pointer for block IO media.
     #[must_use]
     pub const fn media(&self) -> &BlockIOMedia {
-        unsafe { &*self.media }
+        unsafe { &*self.0.media.cast::<BlockIOMedia>() }
     }
 
     /// Resets the block device hardware.
@@ -44,7 +26,7 @@ impl BlockIO {
     /// # Errors
     /// * `uefi::Status::DEVICE_ERROR`  The block device is not functioning correctly and could not be reset.
     pub fn reset(&mut self, extended_verification: bool) -> Result {
-        (self.reset)(self, extended_verification).to_result()
+        unsafe { (self.0.reset)(&mut self.0, extended_verification) }.to_result()
     }
 
     /// Read the requested number of blocks from the device.
@@ -65,7 +47,16 @@ impl BlockIO {
     ///     proper alignment.
     pub fn read_blocks(&self, media_id: u32, lba: Lba, buffer: &mut [u8]) -> Result {
         let buffer_size = buffer.len();
-        (self.read_blocks)(self, media_id, lba, buffer_size, buffer.as_mut_ptr()).to_result()
+        unsafe {
+            (self.0.read_blocks)(
+                &self.0,
+                media_id,
+                lba,
+                buffer_size,
+                buffer.as_mut_ptr().cast(),
+            )
+        }
+        .to_result()
     }
 
     /// Writes the requested number of blocks to the device.
@@ -87,7 +78,16 @@ impl BlockIO {
     ///     on proper alignment.
     pub fn write_blocks(&mut self, media_id: u32, lba: Lba, buffer: &[u8]) -> Result {
         let buffer_size = buffer.len();
-        (self.write_blocks)(self, media_id, lba, buffer_size, buffer.as_ptr()).to_result()
+        unsafe {
+            (self.0.write_blocks)(
+                &mut self.0,
+                media_id,
+                lba,
+                buffer_size,
+                buffer.as_ptr().cast(),
+            )
+        }
+        .to_result()
     }
 
     /// Flushes all modified data to a physical block device.
@@ -96,108 +96,87 @@ impl BlockIO {
     /// * `uefi::Status::DEVICE_ERROR`          The device reported an error while attempting to write data.
     /// * `uefi::Status::NO_MEDIA`              There is no media in the device.
     pub fn flush_blocks(&mut self) -> Result {
-        (self.flush_blocks)(self).to_result()
+        unsafe { (self.0.flush_blocks)(&mut self.0) }.to_result()
     }
 }
 
-/// EFI LBA type
-pub type Lba = u64;
-
 /// Media information structure
-#[repr(C)]
+#[repr(transparent)]
 #[derive(Debug)]
-pub struct BlockIOMedia {
-    media_id: u32,
-    removable_media: bool,
-    media_present: bool,
-    logical_partition: bool,
-    read_only: bool,
-    write_caching: bool,
-
-    block_size: u32,
-    io_align: u32,
-    last_block: Lba,
-
-    // Revision 2
-    lowest_aligned_lba: Lba,
-    logical_blocks_per_physical_block: u32,
-
-    // Revision 3
-    optimal_transfer_length_granularity: u32,
-}
+pub struct BlockIOMedia(uefi_raw::protocol::block::BlockIoMedia);
 
 impl BlockIOMedia {
     /// The current media ID.
     #[must_use]
     pub const fn media_id(&self) -> u32 {
-        self.media_id
+        self.0.media_id
     }
 
     /// True if the media is removable.
     #[must_use]
     pub const fn is_removable_media(&self) -> bool {
-        self.removable_media
+        self.0.removable_media
     }
 
     /// True if there is a media currently present in the device.
     #[must_use]
     pub const fn is_media_present(&self) -> bool {
-        self.media_present
+        self.0.media_present
     }
 
     /// True if block IO was produced to abstract partition structure.
     #[must_use]
     pub const fn is_logical_partition(&self) -> bool {
-        self.logical_partition
+        self.0.logical_partition
     }
 
     /// True if the media is marked read-only.
     #[must_use]
     pub const fn is_read_only(&self) -> bool {
-        self.read_only
+        self.0.read_only
     }
 
     /// True if `writeBlocks` function writes data.
     #[must_use]
     pub const fn is_write_caching(&self) -> bool {
-        self.write_caching
+        self.0.write_caching
     }
 
     /// The intrinsic block size of the device.
     ///
     /// If the media changes, then this field is updated. Returns the number of bytes per logical block.
     #[must_use]
     pub const fn block_size(&self) -> u32 {
-        self.block_size
+        self.0.block_size
     }
 
     /// Supplies the alignment requirement for any buffer used in a data transfer.
     #[must_use]
     pub const fn io_align(&self) -> u32 {
-        self.io_align
+        self.0.io_align
     }
 
     /// The last LBA on the device. If the media changes, then this field is updated.
     #[must_use]
     pub const fn last_block(&self) -> Lba {
-        self.last_block
+        self.0.last_block
     }
 
     /// Returns the first LBA that is aligned to a physical block boundary.
     #[must_use]
     pub const fn lowest_aligned_lba(&self) -> Lba {
-        self.lowest_aligned_lba
+        self.0.lowest_aligned_lba
     }
 
     /// Returns the number of logical blocks per physical block.
     #[must_use]
     pub const fn logical_blocks_per_physical_block(&self) -> u32 {
-        self.logical_blocks_per_physical_block
+        self.0.logical_blocks_per_physical_block
     }
 
     /// Returns the optimal transfer length granularity as a number of logical blocks.
     #[must_use]
     pub const fn optimal_transfer_length_granularity(&self) -> u32 {
-        self.optimal_transfer_length_granularity
+        self.0.optimal_transfer_length_granularity
     }
 }