Add a builder to multiboot2

multiboot2-header/src/builder/header.rs

@@ -244,7 +244,7 @@ mod tests {
     }
 
     #[test]
-    fn test_size_builder() {
+    fn test_builder() {
         let builder = Multiboot2HeaderBuilder::new(HeaderTagISA::I386);
         // Multiboot2 basic header + end tag
         let mut expected_len = 16 + 8;
@@ -274,14 +274,28 @@ mod tests {
             4096,
             RelocatableHeaderTagPreference::None,
         ));
+        expected_len += 0x18;
+        assert_eq!(builder.expected_len(), expected_len);
 
         println!("builder: {:#?}", builder);
         println!("expected_len: {} bytes", builder.expected_len());
 
         let mb2_hdr_data = builder.build();
         let mb2_hdr = mb2_hdr_data.as_ptr() as usize;
-        let mb2_hdr = unsafe { Multiboot2Header::from_addr(mb2_hdr) };
+        let mb2_hdr = unsafe { Multiboot2Header::from_addr(mb2_hdr) }
+            .expect("the generated header to be loadable");
         println!("{:#?}", mb2_hdr);
+        assert_eq!(
+            mb2_hdr.relocatable_tag().unwrap().flags(),
+            HeaderTagFlag::Required
+        );
+        assert_eq!(mb2_hdr.relocatable_tag().unwrap().min_addr(), 0x1337);
+        assert_eq!(mb2_hdr.relocatable_tag().unwrap().max_addr(), 0xdeadbeef);
+        assert_eq!(mb2_hdr.relocatable_tag().unwrap().align(), 4096);
+        assert_eq!(
+            mb2_hdr.relocatable_tag().unwrap().preference(),
+            RelocatableHeaderTagPreference::None
+        );
 
         /* you can write the binary to a file and a tool such as crate "bootinfo"
            will be able to fully parse the MB2 header

multiboot2-header/src/relocatable.rs

@@ -8,7 +8,7 @@ use core::mem::size_of;
 /// but not lower than min addr and ‘2’ means load image at highest possible
 /// address but not higher than max addr.
 #[repr(u32)]
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone, Debug, PartialEq)]
 pub enum RelocatableHeaderTagPreference {
     /// Let boot loader decide.
     None = 0,

multiboot2/Cargo.toml

@@ -32,7 +32,10 @@ repository = "https://github.com/rust-osdev/multiboot2"
 documentation = "https://docs.rs/multiboot2"
 
 [features]
-default = []
+# by default, builder is included
+default = ["builder"]
+std = []
+builder = ["std"]
 # Nightly-only features that will eventually be stabilized.
 unstable = []
 

multiboot2/src/boot_loader_name.rs

@@ -1,8 +1,16 @@
-use crate::TagTrait;
-use crate::{Tag, TagTypeId};
+use crate::{Tag, TagTrait, TagType, TagTypeId};
 use core::fmt::{Debug, Formatter};
+use core::mem::size_of;
 use core::str::Utf8Error;
 
+#[cfg(feature = "builder")]
+use {
+    crate::builder::boxed_dst_tag, crate::builder::traits::StructAsBytes, alloc::boxed::Box,
+    alloc::vec::Vec,
+};
+
+const METADATA_SIZE: usize = size_of::<TagTypeId>() + size_of::<u32>();
+
 /// The bootloader name tag.
 #[derive(ptr_meta::Pointee)]
 #[repr(C, packed)] // only repr(C) would add unwanted padding before first_section
@@ -14,6 +22,13 @@ pub struct BootLoaderNameTag {
 }
 
 impl BootLoaderNameTag {
+    #[cfg(feature = "builder")]
+    pub fn new(name: &str) -> Box<Self> {
+        let mut bytes: Vec<_> = name.bytes().collect();
+        bytes.push(0);
+        boxed_dst_tag(TagType::BootLoaderName, &bytes)
+    }
+
     /// Reads the name of the bootloader that is booting the kernel as Rust
     /// string slice without the null-byte.
     ///
@@ -46,10 +61,15 @@ impl Debug for BootLoaderNameTag {
 
 impl TagTrait for BootLoaderNameTag {
     fn dst_size(base_tag: &Tag) -> usize {
-        // The size of the sized portion of the bootloader name tag.
-        let tag_base_size = 8;
-        assert!(base_tag.size >= 8);
-        base_tag.size as usize - tag_base_size
+        assert!(base_tag.size as usize >= METADATA_SIZE);
+        base_tag.size as usize - METADATA_SIZE
+    }
+}
+
+#[cfg(feature = "builder")]
+impl StructAsBytes for BootLoaderNameTag {
+    fn byte_size(&self) -> usize {
+        self.size.try_into().unwrap()
     }
 }
 
@@ -85,4 +105,15 @@ mod tests {
         assert_eq!({ tag.typ }, TagType::BootLoaderName);
         assert_eq!(tag.name().expect("must be valid UTF-8"), MSG);
     }
+
+    /// Test to generate a tag from a given string.
+    #[test]
+    #[cfg(feature = "builder")]
+    fn test_build_str() {
+        use crate::builder::traits::StructAsBytes;
+
+        let tag = BootLoaderNameTag::new(MSG);
+        let bytes = tag.struct_as_bytes();
+        assert_eq!(bytes, get_bytes());
+    }
 }