multiboot2: Add SMBIOS tag

Author: YtvwlD

multiboot2/src/builder/information.rs

@@ -3,7 +3,7 @@ use crate::builder::traits::StructAsBytes;
 use crate::{
     BasicMemoryInfoTag, BootInformationInner, BootLoaderNameTag, CommandLineTag,
     EFISdt32, EFISdt64, ElfSectionsTag, EndTag, FramebufferTag, MemoryMapTag,
-    ModuleTag,
+    ModuleTag, SmbiosTag,
 };
 
 use alloc::boxed::Box;
@@ -24,6 +24,7 @@ pub struct Multiboot2InformationBuilder {
     module_tags: Vec<Box<ModuleTag>>,
     efisdt32: Option<EFISdt32>,
     efisdt64: Option<EFISdt64>,
+    smbios_tags: Vec<Box<SmbiosTag>>,
 }
 
 impl Multiboot2InformationBuilder {
@@ -38,6 +39,7 @@ impl Multiboot2InformationBuilder {
             framebuffer_tag: None,
             memory_map_tag: None,
             module_tags: Vec::new(),
+            smbios_tags: Vec::new(),
         }
     }
 
@@ -89,6 +91,9 @@ impl Multiboot2InformationBuilder {
         for tag in &self.module_tags {
             len += Self::size_or_up_aligned(tag.byte_size())
         }
+        for tag in &self.smbios_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
@@ -148,6 +153,9 @@ impl Multiboot2InformationBuilder {
         for tag in self.module_tags {
             Self::build_add_bytes(&mut data, &tag.struct_as_bytes(), false)
         }
+        for tag in self.smbios_tags {
+            Self::build_add_bytes(&mut data, &tag.struct_as_bytes(), false)
+        }
 
         Self::build_add_bytes(&mut data, &EndTag::new().struct_as_bytes(), true);
 
@@ -189,6 +197,10 @@ impl Multiboot2InformationBuilder {
     pub fn add_module_tag(&mut self, module_tag: Box<ModuleTag>) {
         self.module_tags.push(module_tag);
     }
+
+    pub fn add_smbios_tag(&mut self, smbios_tag: Box<SmbiosTag>) {
+        self.smbios_tags.push(smbios_tag);
+    }
 }
 
 #[cfg(test)]

multiboot2/src/lib.rs

@@ -60,6 +60,7 @@ pub use memory_map::{
 };
 pub use module::{ModuleIter, ModuleTag};
 pub use rsdp::{RsdpV1Tag, RsdpV2Tag};
+pub use smbios::SmbiosTag;
 pub use tag_type::TagType;
 use tag_type::{EndTag, METADATA_SIZE, Tag, TagIter};
 pub use vbe_info::{
@@ -79,6 +80,7 @@ mod image_load_addr;
 mod memory_map;
 mod module;
 mod rsdp;
+mod smbios;
 mod tag_type;
 mod vbe_info;
 

multiboot2/src/smbios.rs

@@ -0,0 +1,98 @@
+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::fmt::Debug;
+
+#[cfg(feature = "builder")]
+use alloc::boxed::Box;
+
+#[cfg(test)]
+const METADATA_SIZE: usize = core::mem::size_of::<TagType>()
+    + core::mem::size_of::<u32>() + core::mem::size_of::<u8>() * 8;
+
+
+/// This tag contains a copy of SMBIOS tables as well as their version.
+#[repr(C, packed)]
+pub struct SmbiosTag {
+    typ: TagType,
+    size: u32,
+    pub major: u8,
+    pub minor: u8,
+    _reserved: [u8; 6],
+    pub tables: [u8],
+}
+
+impl SmbiosTag {
+    #[cfg(feature = "builder")]
+    pub fn new(major: u8, minor: u8, tables: &[u8]) -> Box<Self> {
+        let mut bytes = [major, minor].to_vec();
+        bytes.extend(tables);
+        let tag = boxed_dst_tag(
+            TagType::Smbios, bytes.as_slice(),
+        );
+        unsafe { Box::from_raw(Box::into_raw(tag) as *mut Self) }
+    }
+}
+
+#[cfg(feature = "builder")]
+impl StructAsBytes for SmbiosTag {
+    fn byte_size(&self) -> usize {
+        self.size.try_into().unwrap()
+    }
+}
+
+impl Debug for SmbiosTag {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("BootLoaderNameTag")
+            .field("typ", &{self.typ})
+            .field("size", &{self.size})
+            .field("major", &{self.major})
+            .field("minor", &{self.minor})
+            .finish()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use core::ptr::slice_from_raw_parts;
+
+    use crate::{TagType, smbios::METADATA_SIZE};
+
+    /// Returns the tag structure in bytes in native endian format.
+    fn get_bytes() -> std::vec::Vec<u8> {
+        let tables = [0xabu8; 24];
+        // size is: 4 bytes for tag + 4 bytes for size + 1 byte for major and minor
+        // + 6 bytes reserved + the actual tables
+        let size = (4 + 4 + 1 + 1 + 6 + tables.len()) as u32;
+        let mut bytes = [
+            ((TagType::Smbios as u32).to_ne_bytes()), size.to_ne_bytes()
+        ].concat();
+        bytes.push(3);
+        bytes.push(0);
+        bytes.extend([0; 6]);
+        bytes.extend(tables);
+        bytes
+    }
+
+    /// Tests to parse a string with a terminating null byte from the tag (as the spec defines).
+    #[test]
+    fn test_parse() {
+        let tag = get_bytes();
+        let tag = unsafe {
+            let ptr = tag.as_ptr() as *const ();
+            (slice_from_raw_parts(
+                ptr, tag.len() - METADATA_SIZE
+            ) as *const super::SmbiosTag)
+                .as_ref()
+                .unwrap()
+        };
+        assert_eq!({ tag.typ }, TagType::Smbios);
+        assert_eq!(tag.major, 3);
+        assert_eq!(tag.minor, 0);
+        assert_eq!(tag.tables, [0xabu8; 24]);
+    }
+}