multiboot2: consume multiboot2-common (2/N): BootInformation

We get rid of BootInformationInner and use BootInformation as wrapper
around our new common type.

Author: phip1611

multiboot2/src/boot_information.rs

@@ -12,8 +12,9 @@ use crate::{
 };
 use core::fmt;
 use core::mem;
-use core::ptr;
+use core::slice;
 use derive_more::Display;
+use multiboot2_common::{BytesRef, DynSizedStructure, Header};
 
 /// Error type that describes errors while loading/parsing a multiboot2 information structure
 /// from a given address.
@@ -62,40 +63,18 @@ impl BootInformationHeader {
     }
 }
 
-#[cfg(feature = "builder")]
-impl AsBytes for BootInformationHeader {}
-
-/// This type holds the whole data of the MBI. This helps to better satisfy miri
-/// when it checks for memory issues.
-#[derive(ptr_meta::Pointee)]
-#[repr(C, align(8))]
-struct BootInformationInner {
-    header: BootInformationHeader,
-    tags: [u8],
-}
-
-impl BootInformationInner {
-    /// Checks if the MBI has a valid end tag by checking the end of the mbi's
-    /// bytes.
-    fn has_valid_end_tag(&self) -> bool {
-        let self_ptr = ptr::addr_of!(*self);
-
-        let end_tag_ptr = unsafe {
-            self_ptr
-                .cast::<u8>()
-                .add(self.header.total_size as usize)
-                .sub(mem::size_of::<EndTag>())
-                .cast::<TagHeader>()
-        };
-        let end_tag = unsafe { &*end_tag_ptr };
-
-        end_tag.typ == EndTag::ID && end_tag.size as usize == mem::size_of::<EndTag>()
+impl Header for BootInformationHeader {
+    fn payload_len(&self) -> usize {
+        self.total_size as usize - size_of::<Self>()
     }
 }
 
+#[cfg(feature = "builder")]
+impl AsBytes for BootInformationHeader {}
+
 /// A Multiboot 2 Boot Information (MBI) accessor.
 #[repr(transparent)]
-pub struct BootInformation<'a>(&'a BootInformationInner);
+pub struct BootInformation<'a>(&'a DynSizedStructure<BootInformationHeader>);
 
 impl<'a> BootInformation<'a> {
     /// Loads the [`BootInformation`] from a pointer. The pointer must be valid
@@ -115,7 +94,7 @@ impl<'a> BootInformation<'a> {
     /// ```
     ///
     /// ## Safety
-    /// * `ptr` must be valid for reading. Otherwise this function might cause
+    /// * `ptr` must be valid for reading. Otherwise, this function might cause
     ///   invalid machine state or crash your binary (kernel). This can be the
     ///   case in environments with standard environment (segfault), but also in
     ///   boot environments, such as UEFI.
@@ -135,16 +114,39 @@ impl<'a> BootInformation<'a> {
             return Err(MbiLoadError::IllegalTotalSize(mbi.total_size));
         }
 
-        let slice_size = mbi.total_size as usize - mem::size_of::<BootInformationHeader>();
-        // mbi: reference to full mbi
-        let mbi = ptr_meta::from_raw_parts::<BootInformationInner>(ptr.cast(), slice_size);
-        let mbi = &*mbi;
+        let slice = unsafe { slice::from_raw_parts(ptr.cast::<u8>(), mbi.total_size as usize) };
+        let bytes = BytesRef::<BootInformationHeader>::try_from(slice).map_err(|e| {
+            log::error!("Load error: {e:#?}");
+            MbiLoadError::IllegalAddress
+        })?;
+        let inner = DynSizedStructure::ref_from(bytes).map_err(|e| {
+            log::error!("Load error: {e:#?}");
+            MbiLoadError::IllegalTotalSize(mbi.total_size)
+        })?;
 
-        if !mbi.has_valid_end_tag() {
+        let this = Self(inner);
+
+        if !this.has_valid_end_tag() {
             return Err(MbiLoadError::NoEndTag);
         }
+        Ok(this)
+    }
+
+    /// Checks if the MBI has a valid end tag by checking the end of the mbi's
+    /// bytes.
+    fn has_valid_end_tag(&self) -> bool {
+        let header = self.0.header();
+        let end_tag_ptr = unsafe {
+            self.0
+                .payload()
+                .as_ptr()
+                .add(header.payload_len())
+                .sub(mem::size_of::<EndTag>())
+                .cast::<TagHeader>()
+        };
+        let end_tag = unsafe { &*end_tag_ptr };
 
-        Ok(Self(mbi))
+        end_tag.typ == EndTag::ID && end_tag.size as usize == mem::size_of::<EndTag>()
     }
 
     /// Get the start address of the boot info.
@@ -177,7 +179,7 @@ impl<'a> BootInformation<'a> {
     /// Get the total size of the boot info struct.
     #[must_use]
     pub const fn total_size(&self) -> usize {
-        self.0.header.total_size as usize
+        self.0.header().total_size as usize
     }
 
     // ######################################################
@@ -408,7 +410,7 @@ impl<'a> BootInformation<'a> {
 
     /// Returns an iterator over all tags.
     fn tags(&self) -> TagIter {
-        TagIter::new(&self.0.tags)
+        TagIter::new(&self.0.payload())
     }
 }