multiboot2: Implement building the multiboot2 information

Author: YtvwlD

multiboot2/src/boot_loader_name.rs

@@ -1,6 +1,8 @@
 use crate::TagType;
 #[cfg(feature = "builder")]
 use crate::builder::boxed_dst_tag;
+#[cfg(feature = "builder")]
+use crate::builder::traits::StructAsBytes;
 
 use core::convert::TryInto;
 use core::mem;
@@ -63,6 +65,13 @@ impl BootLoaderNameTag {
     }
 }
 
+#[cfg(feature = "builder")]
+impl StructAsBytes for BootLoaderNameTag {
+    fn byte_size(&self) -> usize {
+        self.size.try_into().unwrap()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use crate::{TagType, boot_loader_name::METADATA_SIZE};

multiboot2/src/builder/information.rs

@@ -1,12 +1,13 @@
 //! Exports item [`Multiboot2InformationBuilder`].
 use crate::builder::traits::StructAsBytes;
 use crate::{
-    BasicMemoryInfoTag, BootLoaderNameTag, CommandLineTag, ElfSectionsTag,
-    FramebufferTag, MemoryMapTag, ModuleTag,
+    BasicMemoryInfoTag, BootInformationInner, BootLoaderNameTag, CommandLineTag,
+    ElfSectionsTag, EndTag, FramebufferTag, MemoryMapTag, ModuleTag,
 };
 
 use alloc::boxed::Box;
 use alloc::vec::Vec;
+use core::mem::size_of;
 
 /// Builder to construct a valid Multiboot2 information dynamically at runtime.
 /// The tags will appear in the order of their corresponding enumeration,
@@ -35,6 +36,107 @@ impl Multiboot2InformationBuilder {
         }
     }
 
+    /// Returns the size, if the value is a multiple of 8 or returns
+    /// the next number that is a multiple of 8. With this, one can
+    /// easily calculate the size of a Multiboot2 header, where
+    /// all the tags are 8-byte aligned.
+    const fn size_or_up_aligned(size: usize) -> usize {
+        let remainder = size % 8;
+        if remainder == 0 {
+            size
+        } else {
+            size + 8 - remainder
+        }
+    }
+
+    /// Returns the expected length of the Multiboot2 header,
+    /// when the `build()`-method gets called.
+    pub fn expected_len(&self) -> usize {
+        let base_len = size_of::<BootInformationInner>();
+        // size_or_up_aligned not required, because length is 16 and the
+        // begin is 8 byte aligned => first tag automatically 8 byte aligned
+        let mut len = Self::size_or_up_aligned(base_len);
+        if let Some(tag) = &self.basic_memory_info_tag {
+            // we use size_or_up_aligned, because each tag will start at an 8 byte aligned address
+            len += Self::size_or_up_aligned(tag.byte_size())
+        }
+        if let Some(tag) = &self.boot_loader_name_tag {
+            len += Self::size_or_up_aligned(tag.byte_size())
+        }
+        if let Some(tag) = &self.command_line_tag {
+            len += Self::size_or_up_aligned(tag.byte_size())
+        }
+        if let Some(tag) = &self.elf_sections_tag {
+            len += Self::size_or_up_aligned(tag.byte_size())
+        }
+        if let Some(tag) = &self.framebuffer_tag {
+            len += Self::size_or_up_aligned(tag.byte_size())
+        }
+        if let Some(tag) = &self.memory_map_tag {
+            len += Self::size_or_up_aligned(tag.byte_size())
+        }
+        for tag in &self.module_tags {
+            len += Self::size_or_up_aligned(tag.byte_size())
+        }
+        // only here size_or_up_aligned is not important, because it is the last tag
+        len += size_of::<EndTag>();
+        len
+    }
+
+    /// Adds the bytes of a tag to the final Multiboot2 information byte vector.
+    /// Align should be true for all tags except the end tag.
+    fn build_add_bytes(dest: &mut Vec<u8>, source: &[u8], is_end_tag: bool) {
+        dest.extend(source);
+        if !is_end_tag {
+            let size = source.len();
+            let size_to_8_align = Self::size_or_up_aligned(size);
+            let size_to_8_align_diff = size_to_8_align - size;
+            // fill zeroes so that next data block is 8-byte aligned
+            dest.extend([0].repeat(size_to_8_align_diff));
+        }
+    }
+
+    /// Constructs the bytes for a valid Multiboot2 information with the given properties.
+    /// The bytes can be casted to a Multiboot2 structure.
+    pub fn build(self) -> Vec<u8> {
+        let mut data = Vec::new();
+
+        Self::build_add_bytes(
+            &mut data,
+            // important that we write the correct expected length into the header!
+            &BootInformationInner::new(
+                self.expected_len() as u32
+            ).struct_as_bytes(),
+            false,
+        );
+
+        if let Some(tag) = self.basic_memory_info_tag.as_ref() {
+            Self::build_add_bytes(&mut data, &tag.struct_as_bytes(), false)
+        }
+        if let Some(tag) = self.boot_loader_name_tag.as_ref() {
+            Self::build_add_bytes(&mut data, &tag.struct_as_bytes(), false)
+        }
+        if let Some(tag) = self.command_line_tag.as_ref() {
+            Self::build_add_bytes(&mut data, &tag.struct_as_bytes(), false)
+        }
+        if let Some(tag) = self.elf_sections_tag.as_ref() {
+            Self::build_add_bytes(&mut data, &tag.struct_as_bytes(), false)
+        }
+        if let Some(tag) = self.framebuffer_tag.as_ref() {
+            Self::build_add_bytes(&mut data, &tag.struct_as_bytes(), false)
+        }
+        if let Some(tag) = self.memory_map_tag.as_ref() {
+            Self::build_add_bytes(&mut data, &tag.struct_as_bytes(), false)
+        }
+        for tag in self.module_tags {
+            Self::build_add_bytes(&mut data, &tag.struct_as_bytes(), false)
+        }
+
+        Self::build_add_bytes(&mut data, &EndTag::new().struct_as_bytes(), true);
+
+        data
+    }
+
     pub fn basic_memory_info_tag(&mut self, basic_memory_info_tag: BasicMemoryInfoTag) {
         self.basic_memory_info_tag = Some(basic_memory_info_tag)
     }
@@ -63,3 +165,44 @@ impl Multiboot2InformationBuilder {
         self.module_tags.push(module_tag);
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::builder::information::Multiboot2InformationBuilder;
+    use crate::{
+        BasicMemoryInfoTag, CommandLineTag, ModuleTag, load,
+    };
+
+    #[test]
+    fn test_size_or_up_aligned() {
+        assert_eq!(0, Multiboot2InformationBuilder::size_or_up_aligned(0));
+        assert_eq!(8, Multiboot2InformationBuilder::size_or_up_aligned(1));
+        assert_eq!(8, Multiboot2InformationBuilder::size_or_up_aligned(8));
+        assert_eq!(16, Multiboot2InformationBuilder::size_or_up_aligned(9));
+    }
+
+    #[test]
+    fn test_size_builder() {
+        let mut builder = Multiboot2InformationBuilder::new();
+        // Multiboot2 basic information + end tag
+        let expected_len = 8 + 8;
+        assert_eq!(builder.expected_len(), expected_len);
+
+        // the most simple tag
+        builder.basic_memory_info_tag(BasicMemoryInfoTag::new(640, 7 * 1024));
+        // a tag that has a dynamic size
+        builder.command_line_tag(CommandLineTag::new("test"));
+        // many modules
+        builder.add_module_tag(ModuleTag::new(0, 1234, "module1"));
+        builder.add_module_tag(ModuleTag::new(5678, 6789, "module2"));
+
+        println!("builder: {:#?}", builder);
+        println!("expected_len: {} bytes", builder.expected_len());
+
+        let mb2i_data = builder.build();
+        let mb2i_addr = mb2i_data.as_ptr() as usize;
+        let mb2i = unsafe { load(mb2i_addr) };
+        println!("{:#?}", mb2i);
+    }
+}
+

multiboot2/src/builder/traits.rs

@@ -1,16 +1,13 @@
 //! Module for the helper trait [`StructAsBytes`].
 
-use core::mem::size_of;
-
 /// Trait for all tags that helps to create a byte array from the tag.
 /// Useful in builders to construct a byte vector that
 /// represents the Multiboot2 information with all its tags.
-pub(crate) trait StructAsBytes: Sized {
-    /// Returns the size in bytes of the struct, as known during compile
-    /// time. This doesn't use read the "size" field of tags.
-    fn byte_size(&self) -> usize {
-        size_of::<Self>()
-    }
+pub(crate) trait StructAsBytes {
+    /// Returns the size in bytes of the struct.
+    /// This can be either the "size" field of tags or the compile-time size
+    /// (if known).
+    fn byte_size(&self) -> usize;
 
     /// Returns a byte pointer to the begin of the struct.
     fn as_ptr(&self) -> *const u8 {

multiboot2/src/command_line.rs

@@ -3,6 +3,8 @@
 use crate::TagType;
 #[cfg(feature = "builder")]
 use crate::builder::boxed_dst_tag;
+#[cfg(feature = "builder")]
+use crate::builder::traits::StructAsBytes;
 use core::convert::TryInto;
 use core::mem;
 use core::slice;
@@ -61,6 +63,13 @@ impl CommandLineTag {
     }
 }
 
+#[cfg(feature = "builder")]
+impl StructAsBytes for CommandLineTag {
+    fn byte_size(&self) -> usize {
+        self.size.try_into().unwrap()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use crate::{TagType, command_line::METADATA_SIZE};

multiboot2/src/elf_sections.rs

@@ -1,6 +1,9 @@
 use crate::tag_type::{Tag, TagType};
 #[cfg(feature = "builder")]
 use crate::builder::boxed_dst_tag;
+#[cfg(feature = "builder")]
+use crate::builder::traits::StructAsBytes;
+
 use core::convert::TryInto;
 use core::{fmt::{Debug, Formatter}, mem};
 #[cfg(feature = "builder")]
@@ -68,6 +71,13 @@ impl ElfSectionsTag {
     }
 }
 
+#[cfg(feature = "builder")]
+impl StructAsBytes for ElfSectionsTag {
+    fn byte_size(&self) -> usize {
+        self.size.try_into().unwrap()
+    }
+}
+
 /// An iterator over some ELF sections.
 #[derive(Clone)]
 pub struct ElfSectionIter {

multiboot2/src/framebuffer.rs

@@ -141,6 +141,13 @@ impl FramebufferTag {
     }
 }
 
+#[cfg(feature = "builder")]
+impl StructAsBytes for FramebufferTag {
+    fn byte_size(&self) -> usize {
+        self.size.try_into().unwrap()
+    }
+}
+
 /// The type of framebuffer.
 #[derive(Debug, PartialEq, Eq)]
 pub enum FramebufferType<'a> {
@@ -206,7 +213,12 @@ pub struct FramebufferField {
     pub size: u8,
 }
 
-impl StructAsBytes for FramebufferField {}
+#[cfg(feature = "builder")]
+impl StructAsBytes for FramebufferField {
+    fn byte_size(&self) -> usize {
+        mem::size_of::<Self>()
+    }
+}
 
 /// A framebuffer color descriptor in the palette.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -222,4 +234,9 @@ pub struct FramebufferColor {
     pub blue: u8,
 }
 
-impl StructAsBytes for FramebufferColor {}
+#[cfg(feature = "builder")]
+impl StructAsBytes for FramebufferColor {
+    fn byte_size(&self) -> usize {
+        mem::size_of::<Self>()
+    }
+}

multiboot2/src/lib.rs

@@ -47,6 +47,8 @@ extern crate std;
 use core::{fmt, convert::TryInto};
 
 pub use boot_loader_name::BootLoaderNameTag;
+#[cfg(feature = "builder")]
+use builder::traits::StructAsBytes;
 pub use command_line::CommandLineTag;
 pub use efi::{EFIImageHandle32, EFIImageHandle64, EFISdt32, EFISdt64};
 pub use elf_sections::{
@@ -195,6 +197,19 @@ struct BootInformationInner {
     _reserved: u32,
 }
 
+impl BootInformationInner {
+    fn new(total_size: u32) -> Self {
+        Self { total_size, _reserved: 0 }
+    }
+}
+
+#[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 {

multiboot2/src/memory_map.rs

@@ -68,6 +68,13 @@ impl MemoryMapTag {
     }
 }
 
+#[cfg(feature = "builder")]
+impl StructAsBytes for MemoryMapTag {
+    fn byte_size(&self) -> usize {
+        self.size.try_into().unwrap()
+    }
+}
+
 /// A memory area entry descriptor.
 #[derive(Debug, Clone)]
 #[repr(C)]
@@ -105,7 +112,12 @@ impl MemoryArea {
     }
 }
 
-impl StructAsBytes for MemoryArea {}
+#[cfg(feature = "builder")]
+impl StructAsBytes for MemoryArea {
+    fn byte_size(&self) -> usize {
+        mem::size_of::<Self>()
+    }
+}
 
 /// An enum of possible reported region types.
 /// Inside the Multiboot2 spec this is kind of hidden
@@ -197,6 +209,13 @@ impl BasicMemoryInfoTag {
     }
 }
 
+#[cfg(feature = "builder")]
+impl StructAsBytes for BasicMemoryInfoTag {
+    fn byte_size(&self) -> usize {
+        mem::size_of::<Self>()
+    }
+}
+
 /// EFI memory map as per EFI specification.
 #[derive(Debug)]
 #[repr(C)]

multiboot2/src/module.rs

@@ -1,6 +1,8 @@
 use crate::tag_type::{Tag, TagIter, TagType};
 #[cfg(feature = "builder")]
 use crate::builder::boxed_dst_tag;
+#[cfg(feature = "builder")]
+use crate::builder::traits::StructAsBytes;
 
 use core::convert::TryInto;
 use core::fmt::{Debug, Formatter};
@@ -76,6 +78,13 @@ impl ModuleTag {
     }
 }
 
+#[cfg(feature = "builder")]
+impl StructAsBytes for ModuleTag {
+    fn byte_size(&self) -> usize {
+        self.size.try_into().unwrap()
+    }
+}
+
 impl Debug for ModuleTag {
     fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
         f.debug_struct("ModuleTag")