block: Introduce SectorBuf to reduce hard-coded sector size

The current implementation assumes the block device sector size is
always 512 bytes. This can be a blocking issue when supporting block
devices with other sector sizes. To mitigate this, this commit
introduces `SectorBuf` that represents a single sector buffer instead of
`[u8; 512]`.

Signed-off-by: Akira Moroo <retrage01@gmail.com>

Author: retrage

src/block.rs

@@ -96,6 +96,30 @@ struct BlockRequestFooter {
     status: u8,
 }
 
+const SECTOR_SIZE: usize = 512;
+
+#[repr(C)]
+pub struct SectorBuf([u8; SECTOR_SIZE]);
+
+impl SectorBuf {
+    pub const fn new() -> Self {
+        Self([0_u8; SECTOR_SIZE])
+    }
+
+    #[inline]
+    pub const fn len() -> usize {
+        SECTOR_SIZE
+    }
+
+    pub fn as_bytes(&self) -> &[u8] {
+        &self.0
+    }
+
+    pub fn as_mut_bytes(&mut self) -> &mut [u8] {
+        &mut self.0
+    }
+}
+
 pub trait SectorRead {
     /// Read a single sector (512 bytes) from the block device. `data` must be
     /// exactly 512 bytes long.
@@ -213,7 +237,7 @@ impl<'a> VirtioBlockDevice<'a> {
         request: RequestType,
     ) -> Result<(), Error> {
         if request != RequestType::Flush {
-            assert_eq!(512, data.as_ref().unwrap().len());
+            assert_eq!(SectorBuf::len(), data.as_ref().unwrap().len());
         }
 
         const VIRTQ_DESC_F_NEXT: u16 = 1;
@@ -245,7 +269,7 @@ impl<'a> VirtioBlockDevice<'a> {
         let next_desc = (next_desc + 1) % QUEUE_SIZE;
         if request != RequestType::Flush {
             d.addr = data.unwrap().as_ptr() as u64;
-            d.length = core::mem::size_of::<[u8; 512]>() as u32;
+            d.length = SectorBuf::len() as u32;
         }
 
         d.flags = VIRTQ_DESC_F_NEXT

src/bzimage.rs

@@ -14,6 +14,7 @@
 use atomic_refcell::AtomicRefCell;
 
 use crate::{
+    block::SectorBuf,
     boot::{E820Entry, Header, Info, Params},
     fat::{self, Read},
     mem::MemoryRegion,
@@ -62,7 +63,7 @@ impl Kernel {
             0 => 4,
             n => n as u32,
         };
-        let setup_bytes = (setup_sects + 1) * 512;
+        let setup_bytes = (setup_sects + 1) * SectorBuf::len() as u32;
         let remaining_bytes = f.get_size() - setup_bytes;
 
         let mut region = MemoryRegion::new(KERNEL_LOCATION, remaining_bytes as u64);

src/efi/block.rs

@@ -20,6 +20,8 @@ use r_efi::{
     protocols::device_path::Protocol as DevicePathProtocol,
 };
 
+use crate::block::SectorBuf;
+
 pub const PROTOCOL_GUID: Guid = Guid::from_fields(
     0x964e_5b21,
     0x6459,
@@ -118,12 +120,13 @@ pub extern "win64" fn read_blocks(
     let wrapper = container_of!(proto, BlockWrapper, proto);
     let wrapper = unsafe { &*wrapper };
 
-    let blocks = (size / 512) as usize;
+    let block_size = wrapper.media.block_size as usize;
+    let blocks = size / block_size;
     let mut region = crate::mem::MemoryRegion::new(buffer as u64, size as u64);
 
     for i in 0..blocks {
         use crate::block::SectorRead;
-        let data = region.as_mut_slice(i as u64 * 512, 512);
+        let data = region.as_mut_slice((i * block_size) as u64, block_size as u64);
         let block = unsafe { &*wrapper.block };
         match block.read(wrapper.start_lba + start + i as u64, data) {
             Ok(()) => continue,
@@ -146,12 +149,13 @@ pub extern "win64" fn write_blocks(
     let wrapper = container_of!(proto, BlockWrapper, proto);
     let wrapper = unsafe { &*wrapper };
 
-    let blocks = (size / 512) as usize;
+    let block_size = wrapper.media.block_size as usize;
+    let blocks = (size / block_size) as usize;
     let mut region = crate::mem::MemoryRegion::new(buffer as u64, size as u64);
 
     for i in 0..blocks {
         use crate::block::SectorWrite;
-        let data = region.as_mut_slice(i as u64 * 512, 512);
+        let data = region.as_mut_slice((i * block_size) as u64, block_size as u64);
         let block = unsafe { &*wrapper.block };
         match block.write(wrapper.start_lba + start + i as u64, data) {
             Ok(()) => continue,
@@ -208,7 +212,7 @@ impl<'a> BlockWrapper<'a> {
                     logical_partition: false,
                     read_only: true,
                     write_caching: false,
-                    block_size: 512,
+                    block_size: SectorBuf::len() as u32,
                     io_align: 0,
                     last_block,
                 },

src/efi/file.rs

@@ -22,6 +22,8 @@ use r_efi::{
     },
 };
 
+use crate::block::SectorBuf;
+
 #[repr(C)]
 pub struct FileDevicePathProtocol {
     pub device_path: DevicePathProtocol,
@@ -154,12 +156,12 @@ pub extern "win64" fn read(file: *mut FileProtocol, size: *mut usize, buf: *mut
     loop {
         let buf = unsafe { core::slice::from_raw_parts_mut(buf as *mut u8, *size) };
 
-        let mut data: [u8; 512] = [0; 512];
+        let mut data = SectorBuf::new();
         unsafe {
-            match (*wrapper).node.read(&mut data) {
+            match (*wrapper).node.read(data.as_mut_bytes()) {
                 Ok(bytes_read) => {
                     buf[current_offset..current_offset + bytes_read as usize]
-                        .copy_from_slice(&data[0..bytes_read as usize]);
+                        .copy_from_slice(&data.as_bytes()[0..bytes_read as usize]);
                     current_offset += bytes_read as usize;
 
                     if bytes_remaining <= bytes_read as usize {