fat: Add utility functions for loading data from files

This allows much of the existing code to be simplified, by letting us
load the remainer of a file into a specific memory region.

This also makes it much easier to write the code to load the Linux
Kernel header from the bzimage file.

Signed-off-by: Joe Richey <joerichey@google.com>

Author: josephlr

src/boot.rs

@@ -1,6 +1,10 @@
 use core::mem;
 
-use crate::common;
+use crate::{
+    common,
+    fat::{Error, Read},
+    mem::MemoryRegion,
+};
 
 // Common data needed for all boot paths
 pub trait Info {
@@ -140,6 +144,26 @@ pub struct Header {
     pub handover_offset: u32,
 }
 
+impl Header {
+    // Read a kernel header from the first two sectors of a file
+    pub fn from_file(f: &mut dyn Read) -> Result<Self, Error> {
+        let mut data: [u8; 1024] = [0; 1024];
+        let mut region = MemoryRegion::from_bytes(&mut data);
+
+        f.seek(0)?;
+        f.load_file(&mut region)?;
+
+        #[repr(C)]
+        struct HeaderData {
+            before: [u8; HEADER_START],
+            hdr: Header,
+            after: [u8; 1024 - HEADER_END],
+        }
+        // SAFETY: Struct consists entirely of primitive integral types.
+        Ok(unsafe { mem::transmute::<_, HeaderData>(data) }.hdr)
+    }
+}
+
 // Right now the stucts below are unused, so we only need them to be the correct
 // size. Update test_size_and_offset if a struct's real definition is added.
 #[derive(Clone, Copy)]

src/fat.rs

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use crate::block::SectorRead;
+use crate::{block::SectorRead, mem::MemoryRegion};
 
 #[repr(packed)]
 struct Header {
@@ -244,6 +244,27 @@ pub trait Read {
     fn read(&mut self, data: &mut [u8]) -> Result<u32, Error>;
     fn seek(&mut self, offset: u32) -> Result<(), Error>;
     fn get_size(&self) -> u32;
+
+    // Loads the remainer of the file into the specified memory region
+    fn load_file(&mut self, mem: &mut MemoryRegion) -> Result<(), Error> {
+        let mut chunks = mem.as_bytes().chunks_exact_mut(512);
+        for chunk in chunks.by_ref() {
+            self.read(chunk)?;
+        }
+        let last = chunks.into_remainder();
+        if last.is_empty() {
+            return Ok(());
+        }
+        // Use tmp buffer for last, partial sector
+        let mut dst: [u8; 512] = [0; 512];
+        if let Some(err) = self.read(&mut dst).err() {
+            if err != Error::EndOfFile {
+                return Err(err);
+            }
+        }
+        last.copy_from_slice(&dst[..last.len()]);
+        Ok(())
+    }
 }
 
 impl<'a> Read for File<'a> {