Ensure proper alignment of DAP target buffer

Author: phil-opp

bios/second_stage/src/disk.rs

@@ -9,14 +9,21 @@ pub struct DiskAccess {
 }
 
 impl Read for DiskAccess {
-    fn read_exact(&mut self, input_buf: &mut [u8]) {
-        static mut TMP_BUF: [u8; 512] = [0; 512];
-        let tmp_buf = unsafe { &mut TMP_BUF[..] };
-        let (buf, copy_needed) = if input_buf.len() >= tmp_buf.len() {
-            (&mut input_buf[..], false)
-        } else {
-            (&mut tmp_buf[..], true)
+    fn read_exact(&mut self, len: usize) -> &[u8] {
+        static mut TMP_BUF: AlignedBuffer<512> = AlignedBuffer {
+            buffer: [0; 512],
+            limit: 512,
         };
+        let buf = unsafe { &mut TMP_BUF };
+        assert!(len <= buf.buffer.len());
+
+        self.read_exact_into(buf);
+
+        &buf.buffer[..len]
+    }
+
+    fn read_exact_into(&mut self, buf: &mut dyn AlignedSlice) {
+        let buf = buf.slice_mut();
         assert_eq!(buf.len() % 512, 0);
 
         let end_addr = self.base_offset + self.current_offset + u64::try_from(buf.len()).unwrap();
@@ -48,13 +55,6 @@ impl Read for DiskAccess {
         }
 
         self.current_offset = end_addr;
-
-        if copy_needed {
-            let len = input_buf.len();
-            for i in 0..len {
-                input_buf[i] = tmp_buf[i];
-            }
-        }
     }
 }
 
@@ -76,7 +76,8 @@ impl Seek for DiskAccess {
 }
 
 pub trait Read {
-    fn read_exact(&mut self, buf: &mut [u8]);
+    fn read_exact(&mut self, len: usize) -> &[u8];
+    fn read_exact_into(&mut self, buf: &mut dyn AlignedSlice);
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -88,3 +89,23 @@ pub enum SeekFrom {
 pub trait Seek {
     fn seek(&mut self, pos: SeekFrom) -> u64;
 }
+
+#[repr(align(2))]
+pub struct AlignedBuffer<const LEN: usize> {
+    pub buffer: [u8; LEN],
+    pub limit: usize,
+}
+
+pub trait AlignedSlice {
+    fn slice(&self) -> &[u8];
+    fn slice_mut(&mut self) -> &mut [u8];
+}
+
+impl<const LEN: usize> AlignedSlice for AlignedBuffer<LEN> {
+    fn slice(&self) -> &[u8] {
+        &self.buffer[..self.limit]
+    }
+    fn slice_mut(&mut self) -> &mut [u8] {
+        &mut self.buffer[..self.limit]
+    }
+}

bios/second_stage/src/fat.rs

@@ -1,7 +1,7 @@
 // based on https://crates.io/crates/mini_fat by https://github.com/gridbugs
 
 use crate::{
-    disk::{Read, Seek, SeekFrom},
+    disk::{AlignedBuffer, AlignedSlice, Read, Seek, SeekFrom},
     screen,
 };
 use core::{char::DecodeUtf16Error, fmt::Write as _};
@@ -36,12 +36,7 @@ struct Bpb {
 
 impl Bpb {
     fn parse<D: Read + Seek>(disk: &mut D) -> Self {
-        static mut BPB_BUFFER: [u8; 512] = [0; 512];
-        let mut raw = {
-            let buffer = unsafe { &mut BPB_BUFFER[..] };
-            &mut buffer[..512]
-        };
-        disk.read_exact(&mut raw);
+        let raw = disk.read_exact(512);
 
         let bytes_per_sector = u16::from_le_bytes(raw[11..13].try_into().unwrap());
         let sectors_per_cluster = raw[13];
@@ -217,16 +212,20 @@ impl<D: Read + Seek> FileSystem<D> {
             }
             FatType::Fat12 | FatType::Fat16 => {
                 let root_directory_size = self.bpb.root_directory_size();
-                static mut ROOT_DIR_BUFFER: [u8; 0x4000] = [0; 0x4000];
-                let buffer = unsafe { &mut ROOT_DIR_BUFFER[..] };
-                assert!(root_directory_size <= buffer.len());
-                let raw = &mut buffer[..root_directory_size];
+                static mut ROOT_DIR_BUFFER: AlignedBuffer<0x4000> = AlignedBuffer {
+                    buffer: [0; 0x4000],
+                    limit: 0x4000,
+                };
+                let buffer = unsafe { &mut ROOT_DIR_BUFFER };
+                buffer.limit = root_directory_size;
 
                 self.disk
                     .seek(SeekFrom::Start(self.bpb.root_directory_offset()));
-                self.disk.read_exact(raw);
+                self.disk.read_exact_into(buffer);
 
-                raw.chunks(DIRECTORY_ENTRY_BYTES)
+                buffer
+                    .slice()
+                    .chunks(DIRECTORY_ENTRY_BYTES)
                     .take_while(|raw_entry| raw_entry[0] != END_OF_DIRECTORY_PREFIX)
                     .filter(|raw_entry| raw_entry[0] != UNUSED_ENTRY_PREFIX)
                     .map(RawDirectoryEntry::parse)
@@ -535,22 +534,22 @@ where
         FatType::Fat32 => {
             let base = n as u64 * 4;
             disk.seek(SeekFrom::Start(fat_start + base));
-            let mut buf = [0; 4];
-            disk.read_exact(&mut buf);
+            let buf = disk.read_exact(4);
+            let buf: [u8; 4] = buf.try_into().unwrap();
             u32::from_le_bytes(buf) & 0x0FFFFFFF
         }
         FatType::Fat16 => {
             let base = n as u64 * 2;
             disk.seek(SeekFrom::Start(fat_start + base));
-            let mut buf = [0; 2];
-            disk.read_exact(&mut buf);
+            let buf = disk.read_exact(2);
+            let buf: [u8; 2] = buf.try_into().unwrap();
             u16::from_le_bytes(buf) as u32
         }
         FatType::Fat12 => {
             let base = n as u64 + (n as u64 / 2);
             disk.seek(SeekFrom::Start(fat_start + base));
-            let mut buf = [0; 2];
-            disk.read_exact(&mut buf);
+            let buf = disk.read_exact(2);
+            let buf: [u8; 2] = buf.try_into().unwrap();
             let entry16 = u16::from_le_bytes(buf);
             if n & 1 == 0 {
                 (entry16 & 0xFFF) as u32