mem: Simplify MemoryRegion methods

We really only need from_bytes and as_bytes. There's no need for a
generic from_slice method.

Signed-off-by: Joe Richey <[email protected]>

Author: josephlr

src/bzimage.rs

@@ -143,7 +143,7 @@ pub fn load_kernel(f: &mut dyn Read) -> Result<u64, Error> {
     f.read(&mut buf[0..512])?;
     f.read(&mut buf[512..])?;
 
-    let setup = crate::mem::MemoryRegion::from_slice(&buf[..]);
+    let setup = crate::mem::MemoryRegion::from_bytes(&mut buf[..]);
 
     if setup.read_u16(0x1fe) != 0xAA55 {
         return Err(Error::MagicMissing);

src/mem.rs

@@ -22,18 +22,23 @@ pub struct MemoryRegion {
 }
 
 impl MemoryRegion {
-    pub fn new(base: u64, length: u64) -> MemoryRegion {
+    pub const fn new(base: u64, length: u64) -> MemoryRegion {
         MemoryRegion { base, length }
     }
 
     /// Take a slice and turn it into a region of memory
-    pub fn from_slice<T>(data: &[T]) -> MemoryRegion {
+    pub fn from_bytes(data: &mut [u8]) -> MemoryRegion {
         MemoryRegion {
             base: data.as_ptr() as u64,
-            length: (data.len() * core::mem::size_of::<T>()) as u64,
+            length: data.len() as u64,
         }
     }
 
+    // Expose the entire region as a byte slice
+    pub fn as_bytes(&mut self) -> &mut [u8] {
+        self.as_mut_slice(0, self.length)
+    }
+
     /// Expose a section of the memory region as a slice
     pub fn as_mut_slice<T>(&mut self, offset: u64, length: u64) -> &mut [T] {
         assert!((offset + (length * core::mem::size_of::<T>() as u64)) <= self.length);

src/pe.rs

@@ -60,7 +60,7 @@ impl<'a> Loader<'a> {
             Err(_) => return Err(Error::FileError),
         }
 
-        let dos_region = MemoryRegion::from_slice(&data);
+        let dos_region = MemoryRegion::from_bytes(&mut data);
 
         // 'MZ' magic
         if dos_region.read_u16(0) != 0x5a4d {
@@ -74,7 +74,7 @@ impl<'a> Loader<'a> {
             return Err(Error::InvalidExecutable);
         }
 
-        let pe_region = MemoryRegion::from_slice(&data[pe_header_offset as usize..]);
+        let pe_region = MemoryRegion::from_bytes(&mut data[pe_header_offset as usize..]);
 
         // The Microsoft specification uses offsets relative to the COFF area
         // which is 4 after the signature (so all offsets are +4 relative to the spec)
@@ -91,7 +91,8 @@ impl<'a> Loader<'a> {
         self.num_sections = pe_region.read_u16(6);
 
         let optional_header_size = pe_region.read_u16(20);
-        let optional_region = MemoryRegion::from_slice(&data[(24 + pe_header_offset) as usize..]);
+        let optional_region =
+            MemoryRegion::from_bytes(&mut data[(24 + pe_header_offset) as usize..]);
 
         // Only support x86-64 EFI
         if optional_region.read_u16(0) != 0x20b {
@@ -177,7 +178,7 @@ impl<'a> Loader<'a> {
                 let l: &mut [u8] = loaded_region
                     .as_mut_slice(u64::from(section.virt_address), u64::from(section_size));
 
-                let reloc_region = MemoryRegion::from_slice(l);
+                let reloc_region = MemoryRegion::from_bytes(l);
 
                 let mut section_bytes_remaining = section_size;
                 let mut offset = 0;