multiboot2: cleanup

Author: phip1611

multiboot2/src/efi.rs

@@ -162,7 +162,7 @@ mod tests {
 
     #[test]
     fn test_build_eftih64() {
-        let tag = EFIImageHandle32::new(ADDR.try_into().unwrap());
+        let tag = EFIImageHandle64::new(ADDR.try_into().unwrap());
         assert_eq!(tag.image_handle(), ADDR);
     }
 }

multiboot2/src/framebuffer.rs

@@ -1,4 +1,4 @@
-use crate::{Reader, Tag, TagTrait, TagTypeId};
+use crate::{Tag, TagTrait, TagTypeId};
 
 use core::fmt::Debug;
 use core::mem::size_of;
@@ -11,6 +11,39 @@ use {
     alloc::boxed::Box, alloc::vec::Vec,
 };
 
+/// Helper struct to read bytes from a raw pointer and increase the pointer
+/// automatically.
+pub struct Reader {
+    ptr: *const u8,
+    off: usize,
+}
+
+impl Reader {
+    pub(crate) fn new<T>(ptr: *const T) -> Reader {
+        Reader {
+            ptr: ptr as *const u8,
+            off: 0,
+        }
+    }
+
+    pub(crate) fn read_u8(&mut self) -> u8 {
+        self.off += 1;
+        unsafe { *self.ptr.add(self.off - 1) }
+    }
+
+    pub(crate) fn read_u16(&mut self) -> u16 {
+        self.read_u8() as u16 | (self.read_u8() as u16) << 8
+    }
+
+    pub(crate) fn read_u32(&mut self) -> u32 {
+        self.read_u16() as u32 | (self.read_u16() as u32) << 16
+    }
+
+    pub(crate) fn current_address(&self) -> usize {
+        unsafe { self.ptr.add(self.off) as usize }
+    }
+}
+
 const METADATA_SIZE: usize = size_of::<TagTypeId>()
     + 4 * size_of::<u32>()
     + size_of::<u64>()

multiboot2/src/lib.rs

@@ -135,6 +135,42 @@ pub enum MbiLoadError {
 #[cfg(feature = "unstable")]
 impl core::error::Error for MbiLoadError {}
 
+#[repr(C, align(8))]
+struct BootInformationInner {
+    total_size: u32,
+    _reserved: u32,
+    // followed by various, dynamically sized multiboot2 tags
+    tags: [Tag; 0],
+}
+
+impl BootInformationInner {
+    #[cfg(feature = "builder")]
+    fn new(total_size: u32) -> Self {
+        Self {
+            total_size,
+            _reserved: 0,
+            tags: [],
+        }
+    }
+
+    fn has_valid_end_tag(&self) -> bool {
+        let end_tag_prototype = EndTag::default();
+
+        let self_ptr = self as *const _;
+        let end_tag_addr = self_ptr as usize + (self.total_size - end_tag_prototype.size) as usize;
+        let end_tag = unsafe { &*(end_tag_addr as *const Tag) };
+
+        end_tag.typ == end_tag_prototype.typ && end_tag.size == end_tag_prototype.size
+    }
+}
+
+#[cfg(feature = "builder")]
+impl StructAsBytes for BootInformationInner {
+    fn byte_size(&self) -> usize {
+        core::mem::size_of::<Self>()
+    }
+}
+
 /// A Multiboot 2 Boot Information (MBI) accessor.
 #[repr(transparent)]
 pub struct BootInformation<'a>(&'a BootInformationInner);
@@ -185,35 +221,7 @@ impl BootInformation<'_> {
 
         Ok(Self(mbi))
     }
-}
-
-#[repr(C, align(8))]
-struct BootInformationInner {
-    total_size: u32,
-    _reserved: u32,
-    // followed by various, dynamically sized multiboot2 tags
-    tags: [Tag; 0],
-}
-
-impl BootInformationInner {
-    #[cfg(feature = "builder")]
-    fn new(total_size: u32) -> Self {
-        Self {
-            total_size,
-            _reserved: 0,
-            tags: [],
-        }
-    }
-}
 
-#[cfg(feature = "builder")]
-impl StructAsBytes for BootInformationInner {
-    fn byte_size(&self) -> usize {
-        core::mem::size_of::<Self>()
-    }
-}
-
-impl BootInformation<'_> {
     /// Get the start address of the boot info.
     pub fn start_address(&self) -> usize {
         core::ptr::addr_of!(*self.0) as usize
@@ -427,18 +435,6 @@ impl BootInformation<'_> {
     }
 }
 
-impl BootInformationInner {
-    fn has_valid_end_tag(&self) -> bool {
-        let end_tag_prototype = EndTag::default();
-
-        let self_ptr = self as *const _;
-        let end_tag_addr = self_ptr as usize + (self.total_size - end_tag_prototype.size) as usize;
-        let end_tag = unsafe { &*(end_tag_addr as *const Tag) };
-
-        end_tag.typ == end_tag_prototype.typ && end_tag.size == end_tag_prototype.size
-    }
-}
-
 // SAFETY: BootInformation contains a const ptr to memory that is never mutated.
 // Sending this pointer to other threads is sound.
 unsafe impl Send for BootInformation<'_> {}
@@ -496,37 +492,6 @@ impl fmt::Debug for BootInformation<'_> {
     }
 }
 
-pub(crate) struct Reader {
-    pub(crate) ptr: *const u8,
-    pub(crate) off: usize,
-}
-
-impl Reader {
-    pub(crate) fn new<T>(ptr: *const T) -> Reader {
-        Reader {
-            ptr: ptr as *const u8,
-            off: 0,
-        }
-    }
-
-    pub(crate) fn read_u8(&mut self) -> u8 {
-        self.off += 1;
-        unsafe { *self.ptr.add(self.off - 1) }
-    }
-
-    pub(crate) fn read_u16(&mut self) -> u16 {
-        self.read_u8() as u16 | (self.read_u8() as u16) << 8
-    }
-
-    pub(crate) fn read_u32(&mut self) -> u32 {
-        self.read_u16() as u32 | (self.read_u16() as u32) << 16
-    }
-
-    pub(crate) fn current_address(&self) -> usize {
-        unsafe { self.ptr.add(self.off) as usize }
-    }
-}
-
 /// A trait to abstract over all sized and unsized tags (DSTs). For sized tags,
 /// this trait does not much. For DSTs, a `TagTrait::dst_size` implementation
 /// must me provided, which returns the right size hint for the dynamically