Move root dir buffer into main.rs to reuse it later

We can reuse it to load the kernel.

Author: phil-opp

bios/second_stage/src/disk.rs

@@ -1,5 +1,4 @@
-use crate::{dap, screen};
-use core::fmt::Write as _;
+use crate::dap;
 
 #[derive(Clone)]
 pub struct DiskAccess {
@@ -10,7 +9,7 @@ pub struct DiskAccess {
 
 impl Read for DiskAccess {
     fn read_exact(&mut self, len: usize) -> &[u8] {
-        static mut TMP_BUF: AlignedBuffer<512> = AlignedBuffer {
+        static mut TMP_BUF: AlignedArrayBuffer<512> = AlignedArrayBuffer {
             buffer: [0; 512],
             limit: 512,
         };
@@ -22,7 +21,7 @@ impl Read for DiskAccess {
         &buf.buffer[..len]
     }
 
-    fn read_exact_into(&mut self, buf: &mut dyn AlignedSlice) {
+    fn read_exact_into(&mut self, buf: &mut dyn AlignedBuffer) {
         let buf = buf.slice_mut();
         assert_eq!(buf.len() % 512, 0);
 
@@ -77,7 +76,7 @@ impl Seek for DiskAccess {
 
 pub trait Read {
     fn read_exact(&mut self, len: usize) -> &[u8];
-    fn read_exact_into(&mut self, buf: &mut dyn AlignedSlice);
+    fn read_exact_into(&mut self, buf: &mut dyn AlignedBuffer);
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -91,21 +90,26 @@ pub trait Seek {
 }
 
 #[repr(align(2))]
-pub struct AlignedBuffer<const LEN: usize> {
+pub struct AlignedArrayBuffer<const LEN: usize> {
     pub buffer: [u8; LEN],
     pub limit: usize,
 }
 
-pub trait AlignedSlice {
+pub trait AlignedBuffer {
     fn slice(&self) -> &[u8];
     fn slice_mut(&mut self) -> &mut [u8];
+    fn set_limit(&mut self, limit: usize);
 }
 
-impl<const LEN: usize> AlignedSlice for AlignedBuffer<LEN> {
+impl<const LEN: usize> AlignedBuffer for AlignedArrayBuffer<LEN> {
     fn slice(&self) -> &[u8] {
         &self.buffer[..self.limit]
     }
     fn slice_mut(&mut self) -> &mut [u8] {
         &mut self.buffer[..self.limit]
     }
+    fn set_limit(&mut self, limit: usize) {
+        assert!(limit <= LEN);
+        self.limit = limit;
+    }
 }

bios/second_stage/src/fat.rs

@@ -1,9 +1,6 @@
 // based on https://crates.io/crates/mini_fat by https://github.com/gridbugs
 
-use crate::{
-    disk::{AlignedBuffer, AlignedSlice, Read, Seek, SeekFrom},
-    screen,
-};
+use crate::disk::{AlignedBuffer, Read, Seek, SeekFrom};
 use core::{char::DecodeUtf16Error, fmt::Write as _};
 
 const DIRECTORY_ENTRY_BYTES: usize = 32;
@@ -158,8 +155,12 @@ impl<D: Read + Seek> FileSystem<D> {
         }
     }
 
-    pub fn find_file_in_root_dir(&mut self, name: &str) -> Option<File> {
-        let mut root_entries = self.read_root_dir().filter_map(|e| e.ok());
+    pub fn find_file_in_root_dir(
+        &mut self,
+        name: &str,
+        buffer: &mut dyn AlignedBuffer,
+    ) -> Option<File> {
+        let mut root_entries = self.read_root_dir(buffer).filter_map(|e| e.ok());
         let raw_entry = root_entries.find(|e| e.eq_name(name))?;
 
         let entry = match raw_entry {
@@ -202,20 +203,18 @@ impl<D: Read + Seek> FileSystem<D> {
         }
     }
 
-    fn read_root_dir<'a>(&'a mut self) -> impl Iterator<Item = Result<RawDirectoryEntry, ()>> + 'a {
+    fn read_root_dir<'a>(
+        &'a mut self,
+        buffer: &'a mut (dyn AlignedBuffer + 'a),
+    ) -> impl Iterator<Item = Result<RawDirectoryEntry, ()>> + 'a {
         match self.bpb.fat_type() {
             FatType::Fat32 => {
                 self.bpb.root_cluster;
                 unimplemented!();
             }
             FatType::Fat12 | FatType::Fat16 => {
                 let root_directory_size = self.bpb.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;
+                buffer.set_limit(root_directory_size);
 
                 self.disk
                     .seek(SeekFrom::Start(self.bpb.root_directory_offset()));

bios/second_stage/src/main.rs

@@ -2,7 +2,8 @@
 #![no_main]
 
 use byteorder::{ByteOrder, LittleEndian};
-use core::{arch::asm, fmt::Write as _, mem::size_of, slice};
+use core::{fmt::Write as _, slice};
+use disk::AlignedArrayBuffer;
 use mbr_nostd::{PartitionTableEntry, PartitionType};
 
 use crate::protected_mode::enter_unreal_mode;
@@ -24,6 +25,11 @@ fn second_stage_end() -> *const u8 {
     unsafe { &_second_stage_end }
 }
 
+static mut DISK_BUFFER: AlignedArrayBuffer<0x4000> = AlignedArrayBuffer {
+    buffer: [0; 0x4000],
+    limit: 0x4000,
+};
+
 #[no_mangle]
 #[link_section = ".start"]
 pub extern "C" fn _start(disk_number: u16, partition_table_start: *const u8) {
@@ -71,8 +77,10 @@ pub extern "C" fn _start(disk_number: u16, partition_table_start: *const u8) {
 
     let mut fs = fat::FileSystem::parse(disk.clone());
 
+    let disk_buffer = unsafe { &mut DISK_BUFFER };
+
     let kernel = fs
-        .find_file_in_root_dir("kernel-x86_64")
+        .find_file_in_root_dir("kernel-x86_64", disk_buffer)
         .expect("no `kernel-x86_64` file found");
 
     for cluster in fs.file_clusters(&kernel) {