multiboot2: Trait unification + API adjustments

This commit unifies the StructAsBytes and the TagTrait traits. Furthermore, it
adds an associated constant to the TagTrait. This way, the get_tag function can
get the ID from directly from the type and the user doesn't have to provide a
parameter anymore.

multiboot2/Changelog.md

@@ -1,5 +1,11 @@
 # CHANGELOG for crate `multiboot2`
 
+## 0.18.0 (2023-xx-xx)
+- **BREAKING** The `TagTrait` was enhanced and now has an associated `ID`
+  constant. This is only breaking to users that used `BootInformation::get_tag`
+  or that implement custom tags. `BootInformation::get_tag` doesn't need the
+  `typ` parameter anymore, as it can be deduced from the provided type.
+
 ## 0.17.0 (2023-07-12)
 - **BREAKING** Make functions of `InformationBuilder` chainable. They now consume the builder.
 - **BREAKING** Allow non-standard memory area types by using new pair of

multiboot2/src/boot_loader_name.rs

@@ -1,13 +1,9 @@
-use crate::{Tag, TagTrait, 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::traits::StructAsBytes, crate::builder::BoxedDst, crate::TagType,
-    alloc::vec::Vec,
-};
+use {crate::builder::BoxedDst, alloc::vec::Vec};
 
 const METADATA_SIZE: usize = size_of::<TagTypeId>() + size_of::<u32>();
 
@@ -63,22 +59,17 @@ impl Debug for BootLoaderNameTag {
 }
 
 impl TagTrait for BootLoaderNameTag {
+    const ID: TagType = TagType::BootLoaderName;
+
     fn dst_size(base_tag: &Tag) -> usize {
         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()
-    }
-}
-
 #[cfg(test)]
 mod tests {
-    use crate::{BootLoaderNameTag, Tag, TagType};
+    use crate::{BootLoaderNameTag, Tag, TagTrait, TagType};
 
     const MSG: &str = "hello";
 
@@ -114,10 +105,8 @@ mod tests {
     #[test]
     #[cfg(feature = "builder")]
     fn test_build_str() {
-        use crate::builder::traits::StructAsBytes;
-
         let tag = BootLoaderNameTag::new(MSG);
-        let bytes = tag.struct_as_bytes();
+        let bytes = tag.as_bytes();
         assert_eq!(bytes, get_bytes());
         assert_eq!(tag.name(), Ok(MSG));
 

multiboot2/src/builder/information.rs

@@ -1,10 +1,9 @@
 //! Exports item [`InformationBuilder`].
-use crate::builder::traits::StructAsBytes;
 use crate::{
     BasicMemoryInfoTag, BootInformationHeader, BootLoaderNameTag, CommandLineTag,
     EFIBootServicesNotExitedTag, EFIImageHandle32Tag, EFIImageHandle64Tag, EFIMemoryMapTag,
     EFISdt32Tag, EFISdt64Tag, ElfSectionsTag, EndTag, FramebufferTag, ImageLoadPhysAddrTag,
-    MemoryMapTag, ModuleTag, RsdpV1Tag, RsdpV2Tag, SmbiosTag,
+    MemoryMapTag, ModuleTag, RsdpV1Tag, RsdpV2Tag, SmbiosTag, TagTrait, TagType,
 };
 
 use crate::builder::BoxedDst;
@@ -12,6 +11,16 @@ use alloc::vec::Vec;
 use core::mem::size_of;
 use core::ops::Deref;
 
+/// Helper trait for all structs that need to be serialized that do not
+/// implement `TagTrait`.
+pub trait AsBytes: Sized {
+    fn as_bytes(&self) -> &[u8] {
+        let ptr = core::ptr::addr_of!(*self);
+        let size = core::mem::size_of::<Self>();
+        unsafe { core::slice::from_raw_parts(ptr.cast(), size) }
+    }
+}
+
 /// Holds the raw bytes of a boot information built with [`InformationBuilder`]
 /// on the heap. The bytes returned by [`BootInformationBytes::as_bytes`] are
 /// guaranteed to be properly aligned.
@@ -107,55 +116,55 @@ impl InformationBuilder {
         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())
+            len += Self::size_or_up_aligned(tag.size())
         }
         if let Some(tag) = &self.boot_loader_name_tag {
-            len += Self::size_or_up_aligned(tag.byte_size())
+            len += Self::size_or_up_aligned(tag.size())
         }
         if let Some(tag) = &self.command_line_tag {
-            len += Self::size_or_up_aligned(tag.byte_size())
+            len += Self::size_or_up_aligned(tag.size())
         }
         if let Some(tag) = &self.efisdt32_tag {
-            len += Self::size_or_up_aligned(tag.byte_size())
+            len += Self::size_or_up_aligned(tag.size())
         }
         if let Some(tag) = &self.efisdt64_tag {
-            len += Self::size_or_up_aligned(tag.byte_size())
+            len += Self::size_or_up_aligned(tag.size())
         }
         if let Some(tag) = &self.efi_boot_services_not_exited_tag {
-            len += Self::size_or_up_aligned(tag.byte_size())
+            len += Self::size_or_up_aligned(tag.size())
         }
         if let Some(tag) = &self.efi_image_handle32 {
-            len += Self::size_or_up_aligned(tag.byte_size())
+            len += Self::size_or_up_aligned(tag.size())
         }
         if let Some(tag) = &self.efi_image_handle64 {
-            len += Self::size_or_up_aligned(tag.byte_size())
+            len += Self::size_or_up_aligned(tag.size())
         }
         if let Some(tag) = &self.efi_memory_map_tag {
-            len += Self::size_or_up_aligned(tag.byte_size())
+            len += Self::size_or_up_aligned(tag.size())
         }
         if let Some(tag) = &self.elf_sections_tag {
-            len += Self::size_or_up_aligned(tag.byte_size())
+            len += Self::size_or_up_aligned(tag.size())
         }
         if let Some(tag) = &self.framebuffer_tag {
-            len += Self::size_or_up_aligned(tag.byte_size())
+            len += Self::size_or_up_aligned(tag.size())
         }
         if let Some(tag) = &self.image_load_addr {
-            len += Self::size_or_up_aligned(tag.byte_size())
+            len += Self::size_or_up_aligned(tag.size())
         }
         if let Some(tag) = &self.memory_map_tag {
-            len += Self::size_or_up_aligned(tag.byte_size())
+            len += Self::size_or_up_aligned(tag.size())
         }
         for tag in &self.module_tags {
-            len += Self::size_or_up_aligned(tag.byte_size())
+            len += Self::size_or_up_aligned(tag.size())
         }
         if let Some(tag) = &self.rsdp_v1_tag {
-            len += Self::size_or_up_aligned(tag.byte_size())
+            len += Self::size_or_up_aligned(tag.size())
         }
         if let Some(tag) = &self.rsdp_v2_tag {
-            len += Self::size_or_up_aligned(tag.byte_size())
+            len += Self::size_or_up_aligned(tag.size())
         }
         for tag in &self.smbios_tags {
-            len += Self::size_or_up_aligned(tag.byte_size())
+            len += Self::size_or_up_aligned(tag.size())
         }
         // only here size_or_up_aligned is not important, because it is the last tag
         len += size_of::<EndTag>();
@@ -163,15 +172,18 @@ impl InformationBuilder {
     }
 
     /// Adds the bytes of a tag to the final Multiboot2 information byte vector.
-    fn build_add_bytes(dest: &mut Vec<u8>, source: &[u8], is_end_tag: bool) {
+    fn build_add_tag<T: TagTrait + ?Sized>(dest: &mut Vec<u8>, source: &T) {
         let vec_next_write_ptr = unsafe { dest.as_ptr().add(dest.len()) };
         // At this point, the alignment is guaranteed. If not, something is
         // broken fundamentally.
         assert_eq!(vec_next_write_ptr.align_offset(8), 0);
 
-        dest.extend(source);
+        dest.extend(source.as_bytes());
+
+        let is_end_tag = source.as_base_tag().typ == TagType::End;
+
         if !is_end_tag {
-            let size = source.len();
+            let size = source.size();
             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
@@ -205,6 +217,7 @@ impl InformationBuilder {
 
         // -----------------------------------------------
         // PHASE 2/2: Add Tags
+        bytes.extend(BootInformationHeader::new(self.expected_len() as u32).as_bytes());
         self.build_add_tags(&mut bytes);
 
         assert_eq!(
@@ -227,64 +240,58 @@ impl InformationBuilder {
 
     /// Helper method that adds all the tags to the given vector.
     fn build_add_tags(&self, bytes: &mut Vec<u8>) {
-        Self::build_add_bytes(
-            bytes,
-            // important that we write the correct expected length into the header!
-            &BootInformationHeader::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(bytes, &tag.struct_as_bytes(), false)
+            Self::build_add_tag(bytes, tag)
         }
         if let Some(tag) = self.boot_loader_name_tag.as_ref() {
-            Self::build_add_bytes(bytes, &tag.struct_as_bytes(), false)
+            Self::build_add_tag(bytes, &**tag)
         }
         if let Some(tag) = self.command_line_tag.as_ref() {
-            Self::build_add_bytes(bytes, &tag.struct_as_bytes(), false)
+            Self::build_add_tag(bytes, &**tag)
         }
         if let Some(tag) = self.efisdt32_tag.as_ref() {
-            Self::build_add_bytes(bytes, &tag.struct_as_bytes(), false)
+            Self::build_add_tag(bytes, tag)
         }
         if let Some(tag) = self.efisdt64_tag.as_ref() {
-            Self::build_add_bytes(bytes, &tag.struct_as_bytes(), false)
+            Self::build_add_tag(bytes, tag)
         }
         if let Some(tag) = self.efi_boot_services_not_exited_tag.as_ref() {
-            Self::build_add_bytes(bytes, &tag.struct_as_bytes(), false)
+            Self::build_add_tag(bytes, tag)
         }
         if let Some(tag) = self.efi_image_handle32.as_ref() {
-            Self::build_add_bytes(bytes, &tag.struct_as_bytes(), false)
+            Self::build_add_tag(bytes, tag)
         }
         if let Some(tag) = self.efi_image_handle64.as_ref() {
-            Self::build_add_bytes(bytes, &tag.struct_as_bytes(), false)
+            Self::build_add_tag(bytes, tag)
         }
         if let Some(tag) = self.efi_memory_map_tag.as_ref() {
-            Self::build_add_bytes(bytes, &tag.struct_as_bytes(), false)
+            Self::build_add_tag(bytes, &**tag)
         }
         if let Some(tag) = self.elf_sections_tag.as_ref() {
-            Self::build_add_bytes(bytes, &tag.struct_as_bytes(), false)
+            Self::build_add_tag(bytes, &**tag)
         }
         if let Some(tag) = self.framebuffer_tag.as_ref() {
-            Self::build_add_bytes(bytes, &tag.struct_as_bytes(), false)
+            Self::build_add_tag(bytes, &**tag)
         }
         if let Some(tag) = self.image_load_addr.as_ref() {
-            Self::build_add_bytes(bytes, &tag.struct_as_bytes(), false)
+            Self::build_add_tag(bytes, tag)
         }
         if let Some(tag) = self.memory_map_tag.as_ref() {
-            Self::build_add_bytes(bytes, &tag.struct_as_bytes(), false)
+            Self::build_add_tag(bytes, &**tag)
         }
         for tag in &self.module_tags {
-            Self::build_add_bytes(bytes, &tag.struct_as_bytes(), false)
+            Self::build_add_tag(bytes, &**tag)
         }
         if let Some(tag) = self.rsdp_v1_tag.as_ref() {
-            Self::build_add_bytes(bytes, &tag.struct_as_bytes(), false)
+            Self::build_add_tag(bytes, tag)
         }
         if let Some(tag) = self.rsdp_v2_tag.as_ref() {
-            Self::build_add_bytes(bytes, &tag.struct_as_bytes(), false)
+            Self::build_add_tag(bytes, tag)
         }
         for tag in &self.smbios_tags {
-            Self::build_add_bytes(bytes, &tag.struct_as_bytes(), false)
+            Self::build_add_tag(bytes, &**tag)
         }
-        Self::build_add_bytes(bytes, &EndTag::default().struct_as_bytes(), true);
+        Self::build_add_tag(bytes, &EndTag::default());
     }
 
     /// Adds a 'basic memory information' tag (represented by [`BasicMemoryInfoTag`]) to the builder.

multiboot2/src/builder/mod.rs

@@ -1,8 +1,8 @@
 //! Module for the builder-feature.
 
 mod information;
-pub(crate) mod traits;
 
+pub(crate) use information::AsBytes;
 pub use information::InformationBuilder;
 
 use alloc::alloc::alloc;
@@ -110,6 +110,7 @@ impl<T: ?Sized + PartialEq> PartialEq for BoxedDst<T> {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::TagType;
 
     const METADATA_SIZE: usize = 8;
 
@@ -128,6 +129,8 @@ mod tests {
     }
 
     impl TagTrait for CustomTag {
+        const ID: TagType = TagType::Custom(0x1337);
+
         fn dst_size(base_tag: &Tag) -> usize {
             assert!(base_tag.size as usize >= METADATA_SIZE);
             base_tag.size as usize - METADATA_SIZE

multiboot2/src/builder/traits.rs

@@ -1,26 +0,0 @@
-//! Module for the helper trait [`StructAsBytes`].
-
-use alloc::vec::Vec;
-
-/// 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 {
-    /// 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 {
-        self as *const Self as *const u8
-    }
-
-    /// Returns the structure as a vector of its bytes.
-    /// The length is determined by [`Self::byte_size`].
-    fn struct_as_bytes(&self) -> Vec<u8> {
-        let ptr = self.as_ptr();
-        let bytes = unsafe { core::slice::from_raw_parts(ptr, self.byte_size()) };
-        Vec::from(bytes)
-    }
-}

multiboot2/src/command_line.rs

@@ -1,16 +1,13 @@
 //! Module for [CommandLineTag].
 
-use crate::{Tag, TagTrait, TagTypeId};
+use crate::{Tag, TagTrait, TagType, TagTypeId};
 
 use core::fmt::{Debug, Formatter};
 use core::mem;
 use core::str;
 
 #[cfg(feature = "builder")]
-use {
-    crate::builder::traits::StructAsBytes, crate::builder::BoxedDst, crate::TagType,
-    alloc::vec::Vec, core::convert::TryInto,
-};
+use {crate::builder::BoxedDst, alloc::vec::Vec};
 
 pub(crate) const METADATA_SIZE: usize = mem::size_of::<TagTypeId>() + mem::size_of::<u32>();
 
@@ -72,22 +69,17 @@ impl Debug for CommandLineTag {
 }
 
 impl TagTrait for CommandLineTag {
+    const ID: TagType = TagType::Cmdline;
+
     fn dst_size(base_tag: &Tag) -> usize {
         assert!(base_tag.size as usize >= METADATA_SIZE);
         base_tag.size as usize - METADATA_SIZE
     }
 }
 
-#[cfg(feature = "builder")]
-impl StructAsBytes for CommandLineTag {
-    fn byte_size(&self) -> usize {
-        self.size.try_into().unwrap()
-    }
-}
-
 #[cfg(test)]
 mod tests {
-    use crate::{CommandLineTag, Tag, TagType};
+    use super::*;
 
     const MSG: &str = "hello";
 
@@ -123,10 +115,8 @@ mod tests {
     #[test]
     #[cfg(feature = "builder")]
     fn test_build_str() {
-        use crate::builder::traits::StructAsBytes;
-
         let tag = CommandLineTag::new(MSG);
-        let bytes = tag.struct_as_bytes();
+        let bytes = tag.as_bytes();
         assert_eq!(bytes, get_bytes());
         assert_eq!(tag.cmdline(), Ok(MSG));
 

multiboot2/src/efi.rs

@@ -1,13 +1,10 @@
 //! All MBI tags related to (U)EFI.
 
-use crate::TagType;
 use crate::TagTypeId;
+use crate::{Tag, TagTrait, TagType};
 use core::convert::TryInto;
 use core::mem::size_of;
 
-#[cfg(feature = "builder")]
-use crate::builder::traits::StructAsBytes;
-
 /// EFI system table in 32 bit mode tag.
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[repr(C)]
@@ -33,11 +30,10 @@ impl EFISdt32Tag {
     }
 }
 
-#[cfg(feature = "builder")]
-impl StructAsBytes for EFISdt32Tag {
-    fn byte_size(&self) -> usize {
-        size_of::<Self>()
-    }
+impl TagTrait for EFISdt32Tag {
+    const ID: TagType = TagType::Efi32;
+
+    fn dst_size(_base_tag: &Tag) {}
 }
 
 /// EFI system table in 64 bit mode tag.
@@ -65,11 +61,10 @@ impl EFISdt64Tag {
     }
 }
 
-#[cfg(feature = "builder")]
-impl StructAsBytes for EFISdt64Tag {
-    fn byte_size(&self) -> usize {
-        size_of::<Self>()
-    }
+impl TagTrait for EFISdt64Tag {
+    const ID: TagType = TagType::Efi64;
+
+    fn dst_size(_base_tag: &Tag) {}
 }
 
 /// Tag that contains the pointer to the boot loader's UEFI image handle
@@ -98,11 +93,10 @@ impl EFIImageHandle32Tag {
     }
 }
 
-#[cfg(feature = "builder")]
-impl StructAsBytes for EFIImageHandle32Tag {
-    fn byte_size(&self) -> usize {
-        size_of::<Self>()
-    }
+impl TagTrait for EFIImageHandle32Tag {
+    const ID: TagType = TagType::Efi32Ih;
+
+    fn dst_size(_base_tag: &Tag) {}
 }
 
 /// Tag that contains the pointer to the boot loader's UEFI image handle
@@ -131,11 +125,10 @@ impl EFIImageHandle64Tag {
     }
 }
 
-#[cfg(feature = "builder")]
-impl StructAsBytes for EFIImageHandle64Tag {
-    fn byte_size(&self) -> usize {
-        size_of::<Self>()
-    }
+impl TagTrait for EFIImageHandle64Tag {
+    const ID: TagType = TagType::Efi64Ih;
+
+    fn dst_size(_base_tag: &Tag) {}
 }
 
 #[cfg(all(test, feature = "builder"))]

multiboot2/src/elf_sections.rs

@@ -1,12 +1,10 @@
-use crate::{Tag, TagTrait, TagTypeId};
-
+#[cfg(feature = "builder")]
+use crate::builder::BoxedDst;
+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::traits::StructAsBytes, crate::builder::BoxedDst, crate::TagType};
-
 const METADATA_SIZE: usize = size_of::<TagTypeId>() + 4 * size_of::<u32>();
 
 /// This tag contains the section header table from an ELF binary.
@@ -61,19 +59,14 @@ impl ElfSectionsTag {
 }
 
 impl TagTrait for ElfSectionsTag {
+    const ID: TagType = TagType::ElfSections;
+
     fn dst_size(base_tag: &Tag) -> usize {
         assert!(base_tag.size as usize >= METADATA_SIZE);
         base_tag.size as usize - METADATA_SIZE
     }
 }
 
-#[cfg(feature = "builder")]
-impl StructAsBytes for ElfSectionsTag {
-    fn byte_size(&self) -> usize {
-        self.size.try_into().unwrap()
-    }
-}
-
 impl Debug for ElfSectionsTag {
     fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
         f.debug_struct("ElfSectionsTag")

multiboot2/src/framebuffer.rs

@@ -1,15 +1,10 @@
-use crate::{Tag, TagTrait, TagTypeId};
-
+use crate::{Tag, TagTrait, TagType, TagTypeId};
 use core::fmt::Debug;
 use core::mem::size_of;
 use core::slice;
 use derive_more::Display;
-
 #[cfg(feature = "builder")]
-use {
-    crate::builder::traits::StructAsBytes, crate::builder::BoxedDst, crate::TagType,
-    alloc::vec::Vec,
-};
+use {crate::builder::AsBytes, crate::builder::BoxedDst, alloc::vec::Vec};
 
 /// Helper struct to read bytes from a raw pointer and increase the pointer
 /// automatically.
@@ -177,19 +172,14 @@ impl FramebufferTag {
 }
 
 impl TagTrait for FramebufferTag {
+    const ID: TagType = TagType::Framebuffer;
+
     fn dst_size(base_tag: &Tag) -> usize {
         assert!(base_tag.size as usize >= METADATA_SIZE);
         base_tag.size as usize - METADATA_SIZE
     }
 }
 
-#[cfg(feature = "builder")]
-impl StructAsBytes for FramebufferTag {
-    fn byte_size(&self) -> usize {
-        self.size.try_into().unwrap()
-    }
-}
-
 impl Debug for FramebufferTag {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.debug_struct("FramebufferTag")
@@ -280,15 +270,15 @@ impl<'a> FramebufferType<'a> {
                 v.extend(0u16.to_le_bytes()); // reserved
                 v.extend((palette.len() as u32).to_le_bytes());
                 for color in palette.iter() {
-                    v.extend(color.struct_as_bytes());
+                    v.extend(color.as_bytes());
                 }
             }
             FramebufferType::RGB { red, green, blue } => {
                 v.extend(1u8.to_le_bytes()); // type
                 v.extend(0u16.to_le_bytes()); // reserved
-                v.extend(red.struct_as_bytes());
-                v.extend(green.struct_as_bytes());
-                v.extend(blue.struct_as_bytes());
+                v.extend(red.as_bytes());
+                v.extend(green.as_bytes());
+                v.extend(blue.as_bytes());
             }
             FramebufferType::Text => {
                 v.extend(2u8.to_le_bytes()); // type
@@ -301,6 +291,7 @@ impl<'a> FramebufferType<'a> {
 
 /// An RGB color type field.
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[repr(C)]
 pub struct FramebufferField {
     /// Color field position.
     pub position: u8,
@@ -310,11 +301,7 @@ pub struct FramebufferField {
 }
 
 #[cfg(feature = "builder")]
-impl StructAsBytes for FramebufferField {
-    fn byte_size(&self) -> usize {
-        size_of::<Self>()
-    }
-}
+impl AsBytes for FramebufferField {}
 
 /// A framebuffer color descriptor in the palette.
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -330,6 +317,9 @@ pub struct FramebufferColor {
     pub blue: u8,
 }
 
+#[cfg(feature = "builder")]
+impl AsBytes for FramebufferColor {}
+
 /// Error when an unknown [`FramebufferTypeId`] is found.
 #[derive(Debug, Copy, Clone, Display, PartialEq, Eq)]
 #[display(fmt = "Unknown framebuffer type {}", _0)]
@@ -338,13 +328,6 @@ pub struct UnknownFramebufferType(u8);
 #[cfg(feature = "unstable")]
 impl core::error::Error for UnknownFramebufferType {}
 
-#[cfg(feature = "builder")]
-impl StructAsBytes for FramebufferColor {
-    fn byte_size(&self) -> usize {
-        size_of::<Self>()
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

multiboot2/src/image_load_addr.rs

@@ -1,9 +1,6 @@
-use crate::tag_type::TagTypeId;
+use crate::{Tag, TagTrait, TagType, TagTypeId};
 #[cfg(feature = "builder")]
-use {
-    crate::builder::traits::StructAsBytes, crate::TagType, core::convert::TryInto,
-    core::mem::size_of,
-};
+use {core::convert::TryInto, core::mem::size_of};
 
 /// The physical load address tag. Typically, this is only available if the
 /// binary was relocated, for example if the relocatable header tag was
@@ -20,7 +17,7 @@ impl ImageLoadPhysAddrTag {
     #[cfg(feature = "builder")]
     pub fn new(load_base_addr: u32) -> Self {
         Self {
-            typ: TagType::LoadBaseAddr.into(),
+            typ: TagType::ImageLoadPhysAddr.into(),
             size: size_of::<Self>().try_into().unwrap(),
             load_base_addr,
         }
@@ -32,11 +29,10 @@ impl ImageLoadPhysAddrTag {
     }
 }
 
-#[cfg(feature = "builder")]
-impl StructAsBytes for ImageLoadPhysAddrTag {
-    fn byte_size(&self) -> usize {
-        size_of::<Self>()
-    }
+impl TagTrait for ImageLoadPhysAddrTag {
+    const ID: TagType = TagType::ImageLoadPhysAddr;
+
+    fn dst_size(_base_tag: &Tag) {}
 }
 
 #[cfg(all(test, feature = "builder"))]

multiboot2/src/lib.rs

@@ -47,12 +47,10 @@ use core::fmt;
 use core::mem::size_of;
 use derive_more::Display;
 // Must be public so that custom tags can be DSTs.
-pub use ptr_meta::Pointee;
-
+#[cfg(feature = "builder")]
+use crate::builder::AsBytes;
 use crate::framebuffer::UnknownFramebufferType;
 pub use boot_loader_name::BootLoaderNameTag;
-#[cfg(feature = "builder")]
-use builder::traits::StructAsBytes;
 pub use command_line::CommandLineTag;
 pub use efi::{EFIImageHandle32Tag, EFIImageHandle64Tag, EFISdt32Tag, EFISdt64Tag};
 pub use elf_sections::{
@@ -65,6 +63,7 @@ pub use memory_map::{
     EFIMemoryMapTag, MemoryArea, MemoryAreaType, MemoryAreaTypeId, MemoryMapTag,
 };
 pub use module::{ModuleIter, ModuleTag};
+pub use ptr_meta::Pointee;
 pub use rsdp::{RsdpV1Tag, RsdpV2Tag};
 pub use smbios::SmbiosTag;
 use tag_type::TagIter;
@@ -153,8 +152,8 @@ pub struct BootInformationHeader {
     // Followed by the boot information tags.
 }
 
+#[cfg(feature = "builder")]
 impl BootInformationHeader {
-    #[cfg(feature = "builder")]
     fn new(total_size: u32) -> Self {
         Self {
             total_size,
@@ -164,11 +163,7 @@ impl BootInformationHeader {
 }
 
 #[cfg(feature = "builder")]
-impl StructAsBytes for BootInformationHeader {
-    fn byte_size(&self) -> usize {
-        core::mem::size_of::<Self>()
-    }
-}
+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.
@@ -281,7 +276,7 @@ impl<'a> BootInformation<'a> {
 
     /// Search for the basic memory info tag.
     pub fn basic_memory_info_tag(&self) -> Option<&BasicMemoryInfoTag> {
-        self.get_tag::<BasicMemoryInfoTag, _>(TagType::BasicMeminfo)
+        self.get_tag::<BasicMemoryInfoTag>()
     }
 
     /// Returns an [`ElfSectionIter`] iterator over the ELF Sections, if the
@@ -300,7 +295,7 @@ impl<'a> BootInformation<'a> {
     /// }
     /// ```
     pub fn elf_sections(&self) -> Option<ElfSectionIter> {
-        let tag = self.get_tag::<ElfSectionsTag, _>(TagType::ElfSections);
+        let tag = self.get_tag::<ElfSectionsTag>();
         tag.map(|t| {
             assert!((t.entry_size * t.shndx) <= t.size);
             t.sections()
@@ -309,7 +304,7 @@ impl<'a> BootInformation<'a> {
 
     /// Search for the Memory map tag.
     pub fn memory_map_tag(&self) -> Option<&MemoryMapTag> {
-        self.get_tag::<MemoryMapTag, _>(TagType::Mmap)
+        self.get_tag::<MemoryMapTag>()
     }
 
     /// Get an iterator of all module tags.
@@ -319,18 +314,18 @@ impl<'a> BootInformation<'a> {
 
     /// Search for the BootLoader name tag.
     pub fn boot_loader_name_tag(&self) -> Option<&BootLoaderNameTag> {
-        self.get_tag::<BootLoaderNameTag, _>(TagType::BootLoaderName)
+        self.get_tag::<BootLoaderNameTag>()
     }
 
     /// Search for the Command line tag.
     pub fn command_line_tag(&self) -> Option<&CommandLineTag> {
-        self.get_tag::<CommandLineTag, _>(TagType::Cmdline)
+        self.get_tag::<CommandLineTag>()
     }
 
     /// Search for the VBE framebuffer tag. The result is `Some(Err(e))`, if the
     /// framebuffer type is unknown, while the framebuffer tag is present.
     pub fn framebuffer_tag(&self) -> Option<Result<&FramebufferTag, UnknownFramebufferType>> {
-        self.get_tag::<FramebufferTag, _>(TagType::Framebuffer)
+        self.get_tag::<FramebufferTag>()
             .map(|tag| match tag.buffer_type() {
                 Ok(_) => Ok(tag),
                 Err(e) => Err(e),
@@ -339,22 +334,22 @@ impl<'a> BootInformation<'a> {
 
     /// Search for the EFI 32-bit SDT tag.
     pub fn efi_sdt_32_tag(&self) -> Option<&EFISdt32Tag> {
-        self.get_tag::<EFISdt32Tag, _>(TagType::Efi32)
+        self.get_tag::<EFISdt32Tag>()
     }
 
     /// Search for the EFI 64-bit SDT tag.
     pub fn efi_sdt_64_tag(&self) -> Option<&EFISdt64Tag> {
-        self.get_tag::<EFISdt64Tag, _>(TagType::Efi64)
+        self.get_tag::<EFISdt64Tag>()
     }
 
     /// Search for the (ACPI 1.0) RSDP tag.
     pub fn rsdp_v1_tag(&self) -> Option<&RsdpV1Tag> {
-        self.get_tag::<RsdpV1Tag, _>(TagType::AcpiV1)
+        self.get_tag::<RsdpV1Tag>()
     }
 
     /// Search for the (ACPI 2.0 or later) RSDP tag.
     pub fn rsdp_v2_tag(&self) -> Option<&RsdpV2Tag> {
-        self.get_tag::<RsdpV2Tag, _>(TagType::AcpiV2)
+        self.get_tag::<RsdpV2Tag>()
     }
 
     /// Search for the EFI Memory map tag, if the boot services were exited.
@@ -364,40 +359,40 @@ impl<'a> BootInformation<'a> {
     pub fn efi_memory_map_tag(&self) -> Option<&EFIMemoryMapTag> {
         // If the EFIBootServicesNotExited is present, then we should not use
         // the memory map, as it could still be in use.
-        match self.get_tag::<Tag, _>(TagType::EfiBs) {
+        match self.get_tag::<EFIBootServicesNotExitedTag>() {
             Some(_tag) => None,
-            None => self.get_tag::<EFIMemoryMapTag, _>(TagType::EfiMmap),
+            None => self.get_tag::<EFIMemoryMapTag>(),
         }
     }
 
     /// Search for the EFI 32-bit image handle pointer tag.
     pub fn efi_32_ih_tag(&self) -> Option<&EFIImageHandle32Tag> {
-        self.get_tag::<EFIImageHandle32Tag, _>(TagType::Efi32Ih)
+        self.get_tag::<EFIImageHandle32Tag>()
     }
 
     /// Search for the EFI 64-bit image handle pointer tag.
     pub fn efi_64_ih_tag(&self) -> Option<&EFIImageHandle64Tag> {
-        self.get_tag::<EFIImageHandle64Tag, _>(TagType::Efi64Ih)
+        self.get_tag::<EFIImageHandle64Tag>()
     }
 
     /// Search for the EFI boot services not exited tag.
     pub fn efi_bs_not_exited_tag(&self) -> Option<&EFIBootServicesNotExitedTag> {
-        self.get_tag::<EFIBootServicesNotExitedTag, _>(TagType::EfiBs)
+        self.get_tag::<EFIBootServicesNotExitedTag>()
     }
 
     /// Search for the Image Load Base Physical Address tag.
     pub fn load_base_addr_tag(&self) -> Option<&ImageLoadPhysAddrTag> {
-        self.get_tag::<ImageLoadPhysAddrTag, _>(TagType::LoadBaseAddr)
+        self.get_tag::<ImageLoadPhysAddrTag>()
     }
 
     /// Search for the VBE information tag.
     pub fn vbe_info_tag(&self) -> Option<&VBEInfoTag> {
-        self.get_tag::<VBEInfoTag, _>(TagType::Vbe)
+        self.get_tag::<VBEInfoTag>()
     }
 
     /// Search for the SMBIOS tag.
     pub fn smbios_tag(&self) -> Option<&SmbiosTag> {
-        self.get_tag::<SmbiosTag, _>(TagType::Smbios)
+        self.get_tag::<SmbiosTag>()
     }
 
     /// Public getter to find any Multiboot tag by its type, including
@@ -419,12 +414,11 @@ impl<'a> BootInformation<'a> {
     ///
     /// ```no_run
     /// use std::str::Utf8Error;
-    /// use multiboot2::{Tag, TagTrait, TagTypeId};
+    /// use multiboot2::{Tag, TagTrait, TagType, TagTypeId};
     ///
     /// #[repr(C)]
     /// #[derive(multiboot2::Pointee)] // Only needed for DSTs.
     /// struct CustomTag {
-    ///     // new type from the lib: has repr(u32)
     ///     tag: TagTypeId,
     ///     size: u32,
     ///     // begin of inline string
@@ -433,6 +427,8 @@ impl<'a> BootInformation<'a> {
     ///
     /// // This implementation is only necessary for tags that are DSTs.
     /// impl TagTrait for CustomTag {
+    ///     const ID: TagType = TagType::Custom(0x1337);
+    ///
     ///     fn dst_size(base_tag: &Tag) -> usize {
     ///         // The size of the sized portion of the custom tag.
     ///         let tag_base_size = 8; // id + size is 8 byte in size
@@ -450,17 +446,13 @@ impl<'a> BootInformation<'a> {
     /// let mbi = unsafe { multiboot2::load(0xdeadbeef).unwrap() };
     ///
     /// let tag = mbi
-    ///     .get_tag::<CustomTag, _>(0x1337)
+    ///     .get_tag::<CustomTag>()
     ///     .unwrap();
     /// assert_eq!(tag.name(), Ok("name"));
     /// ```
-    pub fn get_tag<TagT: TagTrait + ?Sized + 'a, TagType: Into<TagTypeId>>(
-        &'a self,
-        typ: TagType,
-    ) -> Option<&'a TagT> {
-        let typ = typ.into();
+    pub fn get_tag<TagT: TagTrait + ?Sized + 'a>(&'a self) -> Option<&'a TagT> {
         self.tags()
-            .find(|tag| tag.typ == typ)
+            .find(|tag| tag.typ == TagT::ID)
             .map(|tag| tag.cast_tag::<TagT>())
     }
 
@@ -532,19 +524,42 @@ impl fmt::Debug for BootInformation<'_> {
 /// must me provided, which returns the right size hint for the dynamically
 /// sized portion of the struct.
 ///
-/// The [`TagTrait::from_base_tag`] method has a default implementation for all
-/// tags that are `Sized`.
-///
 /// # Trivia
 /// This crate uses the [`Pointee`]-abstraction of the [`ptr_meta`] crate to
 /// create fat pointers.
 pub trait TagTrait: Pointee {
+    /// The numeric ID of this tag.
+    const ID: TagType;
+
     /// Returns the amount of items in the dynamically sized portion of the
     /// DST. Note that this is not the amount of bytes. So if the dynamically
     /// sized portion is 16 bytes in size and each element is 4 bytes big, then
     /// this function must return 4.
+    ///
+    /// For sized tags, this just returns `()`. For DSTs, this returns an
+    /// `usize`.
     fn dst_size(base_tag: &Tag) -> Self::Metadata;
 
+    /// Returns the tag as the common base tag structure.
+    fn as_base_tag(&self) -> &Tag {
+        let ptr = core::ptr::addr_of!(*self);
+        unsafe { &*ptr.cast::<Tag>() }
+    }
+
+    /// Returns the total size of the tag. The depends on the `size` field of
+    /// the tag.
+    fn size(&self) -> usize {
+        self.as_base_tag().size as usize
+    }
+
+    /// Returns a slice to the underlying bytes of the tag. This includes all
+    /// bytes, also for tags that are DSTs. The slice length depends on the
+    /// `size` field of the tag.
+    fn as_bytes(&self) -> &[u8] {
+        let ptr = core::ptr::addr_of!(*self);
+        unsafe { core::slice::from_raw_parts(ptr.cast(), self.size()) }
+    }
+
     /// Creates a reference to a (dynamically sized) tag type in a safe way.
     /// DST tags need to implement a proper [`Self::dst_size`] implementation.
     ///
@@ -559,27 +574,6 @@ pub trait TagTrait: Pointee {
     }
 }
 
-// All sized tags automatically have a Pointee implementation where
-// Pointee::Metadata is (). Hence, the TagTrait is implemented automatically for
-// all tags that are sized.
-impl<T: Pointee<Metadata = ()>> TagTrait for T {
-    #[allow(clippy::unused_unit)]
-    fn dst_size(_: &Tag) -> Self::Metadata {
-        ()
-    }
-}
-
-/* TODO doesn't work, missing support in Rust (so far):
- https://github.com/rust-lang/rust/issues/20400
-    fn dst_size(base_tag: &Tag) -> usize {
-        // The size of the sized portion of the module tag.
-        let tag_base_size = 16;
-        assert!(base_tag.size >= 8);
-        base_tag.size as usize - tag_base_size
-    }
-}
-*/
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -1574,8 +1568,6 @@ mod tests {
     #[test]
     #[cfg_attr(miri, ignore)]
     fn get_custom_tag_from_mbi() {
-        const CUSTOM_TAG_ID: u32 = 0x1337;
-
         #[repr(C, align(8))]
         struct CustomTag {
             tag: TagTypeId,
@@ -1583,6 +1575,12 @@ mod tests {
             foo: u32,
         }
 
+        impl TagTrait for CustomTag {
+            const ID: TagType = TagType::Custom(0x1337);
+
+            fn dst_size(_base_tag: &Tag) {}
+        }
+
         #[repr(C, align(8))]
         struct AlignedBytes([u8; 32]);
         // Raw bytes of a MBI that only contains the custom tag.
@@ -1595,10 +1593,10 @@ mod tests {
             0,
             0,
             0, // end: padding; end of multiboot2 boot information begin
-            CUSTOM_TAG_ID.to_le_bytes()[0],
-            CUSTOM_TAG_ID.to_le_bytes()[1],
-            CUSTOM_TAG_ID.to_le_bytes()[2],
-            CUSTOM_TAG_ID.to_le_bytes()[3], // end: my custom tag id
+            CustomTag::ID.val().to_le_bytes()[0],
+            CustomTag::ID.val().to_le_bytes()[1],
+            CustomTag::ID.val().to_le_bytes()[2],
+            CustomTag::ID.val().to_le_bytes()[3], // end: my custom tag id
             12,
             0,
             0,
@@ -1628,7 +1626,7 @@ mod tests {
         assert_eq!(addr + bytes.0.len(), bi.end_address());
         assert_eq!(bytes.0.len(), bi.total_size());
 
-        let tag = bi.get_tag::<CustomTag, _>(CUSTOM_TAG_ID).unwrap();
+        let tag = bi.get_tag::<CustomTag>().unwrap();
         assert_eq!(tag.foo, 42);
     }
 
@@ -1636,8 +1634,6 @@ mod tests {
     #[test]
     #[cfg_attr(miri, ignore)]
     fn get_custom_dst_tag_from_mbi() {
-        const CUSTOM_TAG_ID: u32 = 0x1337;
-
         #[repr(C)]
         #[derive(crate::Pointee)]
         struct CustomTag {
@@ -1653,6 +1649,8 @@ mod tests {
         }
 
         impl TagTrait for CustomTag {
+            const ID: TagType = TagType::Custom(0x1337);
+
             fn dst_size(base_tag: &Tag) -> usize {
                 // The size of the sized portion of the command line tag.
                 let tag_base_size = 8;
@@ -1673,10 +1671,10 @@ mod tests {
             0,
             0,
             0, // end: padding; end of multiboot2 boot information begin
-            CUSTOM_TAG_ID.to_le_bytes()[0],
-            CUSTOM_TAG_ID.to_le_bytes()[1],
-            CUSTOM_TAG_ID.to_le_bytes()[2],
-            CUSTOM_TAG_ID.to_le_bytes()[3], // end: my custom tag id
+            CustomTag::ID.val().to_le_bytes()[0],
+            CustomTag::ID.val().to_le_bytes()[1],
+            CustomTag::ID.val().to_le_bytes()[2],
+            CustomTag::ID.val().to_le_bytes()[3], // end: my custom tag id
             14,
             0,
             0,
@@ -1706,7 +1704,7 @@ mod tests {
         assert_eq!(addr + bytes.0.len(), bi.end_address());
         assert_eq!(bytes.0.len(), bi.total_size());
 
-        let tag = bi.get_tag::<CustomTag, _>(CUSTOM_TAG_ID).unwrap();
+        let tag = bi.get_tag::<CustomTag>().unwrap();
         assert_eq!(tag.name(), Ok("hello"));
     }
 
@@ -1755,10 +1753,6 @@ mod tests {
         let bi = unsafe { BootInformation::load(ptr.cast()) };
         let bi = bi.unwrap();
 
-        let _tag = bi.get_tag::<CommandLineTag, _>(TagType::Cmdline).unwrap();
-
-        let _tag = bi.get_tag::<CommandLineTag, _>(1).unwrap();
-
-        let _tag = bi.get_tag::<CommandLineTag, _>(TagTypeId::new(1)).unwrap();
+        let _tag = bi.get_tag::<CommandLineTag>().unwrap();
     }
 }

multiboot2/src/memory_map.rs

@@ -1,14 +1,13 @@
+pub use uefi_raw::table::boot::MemoryDescriptor as EFIMemoryDesc;
+pub use uefi_raw::table::boot::MemoryType as EFIMemoryAreaType;
+
 use crate::{Tag, TagTrait, TagType, TagTypeId};
 use core::convert::TryInto;
 use core::fmt::{Debug, Formatter};
 use core::marker::PhantomData;
 use core::mem;
-
-pub use uefi_raw::table::boot::MemoryDescriptor as EFIMemoryDesc;
-pub use uefi_raw::table::boot::MemoryType as EFIMemoryAreaType;
-
 #[cfg(feature = "builder")]
-use {crate::builder::traits::StructAsBytes, crate::builder::BoxedDst};
+use {crate::builder::AsBytes, crate::builder::BoxedDst};
 
 const METADATA_SIZE: usize = mem::size_of::<TagTypeId>() + 3 * mem::size_of::<u32>();
 
@@ -39,7 +38,7 @@ impl MemoryMapTag {
         let entry_version: u32 = 0;
         let mut bytes = [entry_size.to_le_bytes(), entry_version.to_le_bytes()].concat();
         for area in areas {
-            bytes.extend(area.struct_as_bytes());
+            bytes.extend(area.as_bytes());
         }
         BoxedDst::new(TagType::Mmap, bytes.as_slice())
     }
@@ -63,6 +62,8 @@ impl MemoryMapTag {
 }
 
 impl TagTrait for MemoryMapTag {
+    const ID: TagType = TagType::Mmap;
+
     fn dst_size(base_tag: &Tag) -> usize {
         assert!(base_tag.size as usize >= METADATA_SIZE);
         let size = base_tag.size as usize - METADATA_SIZE;
@@ -71,13 +72,6 @@ impl TagTrait for MemoryMapTag {
     }
 }
 
-#[cfg(feature = "builder")]
-impl StructAsBytes for MemoryMapTag {
-    fn byte_size(&self) -> usize {
-        self.size.try_into().unwrap()
-    }
-}
-
 /// A memory area entry descriptor.
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[repr(C)]
@@ -121,11 +115,7 @@ impl MemoryArea {
 }
 
 #[cfg(feature = "builder")]
-impl StructAsBytes for MemoryArea {
-    fn byte_size(&self) -> usize {
-        mem::size_of::<Self>()
-    }
-}
+impl AsBytes for MemoryArea {}
 
 /// ABI-friendly version of [`MemoryAreaType`].
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -265,15 +255,17 @@ impl BasicMemoryInfoTag {
     }
 }
 
-#[cfg(feature = "builder")]
-impl StructAsBytes for BasicMemoryInfoTag {
-    fn byte_size(&self) -> usize {
-        mem::size_of::<Self>()
-    }
+impl TagTrait for BasicMemoryInfoTag {
+    const ID: TagType = TagType::BasicMeminfo;
+
+    fn dst_size(_base_tag: &Tag) {}
 }
 
 const EFI_METADATA_SIZE: usize = mem::size_of::<TagTypeId>() + 3 * mem::size_of::<u32>();
 
+#[cfg(feature = "builder")]
+impl AsBytes for EFIMemoryDesc {}
+
 /// EFI memory map tag. The [`EFIMemoryDesc`] follows the EFI specification.
 #[derive(ptr_meta::Pointee, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[repr(C)]
@@ -299,7 +291,7 @@ impl EFIMemoryMapTag {
         ]
         .concat();
         for desc in descs {
-            bytes.extend(desc.struct_as_bytes());
+            bytes.extend(desc.as_bytes());
         }
         BoxedDst::new(TagType::EfiMmap, bytes.as_slice())
     }
@@ -322,6 +314,8 @@ impl EFIMemoryMapTag {
 }
 
 impl TagTrait for EFIMemoryMapTag {
+    const ID: TagType = TagType::EfiMmap;
+
     fn dst_size(base_tag: &Tag) -> usize {
         assert!(base_tag.size as usize >= EFI_METADATA_SIZE);
         let size = base_tag.size as usize - EFI_METADATA_SIZE;
@@ -330,20 +324,6 @@ impl TagTrait for EFIMemoryMapTag {
     }
 }
 
-#[cfg(feature = "builder")]
-impl StructAsBytes for EFIMemoryMapTag {
-    fn byte_size(&self) -> usize {
-        self.size.try_into().unwrap()
-    }
-}
-
-#[cfg(feature = "builder")]
-impl StructAsBytes for EFIMemoryDesc {
-    fn byte_size(&self) -> usize {
-        mem::size_of::<Self>()
-    }
-}
-
 /// EFI ExitBootServices was not called tag.
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[repr(C)]
@@ -369,11 +349,10 @@ impl Default for EFIBootServicesNotExitedTag {
     }
 }
 
-#[cfg(feature = "builder")]
-impl StructAsBytes for EFIBootServicesNotExitedTag {
-    fn byte_size(&self) -> usize {
-        mem::size_of::<Self>()
-    }
+impl TagTrait for EFIBootServicesNotExitedTag {
+    const ID: TagType = TagType::EfiBs;
+
+    fn dst_size(_base_tag: &Tag) {}
 }
 
 /// An iterator over ALL EFI memory areas.

multiboot2/src/module.rs

@@ -5,7 +5,7 @@ use core::mem::size_of;
 use core::str::Utf8Error;
 
 #[cfg(feature = "builder")]
-use {crate::builder::traits::StructAsBytes, crate::builder::BoxedDst, alloc::vec::Vec};
+use {crate::builder::BoxedDst, alloc::vec::Vec};
 
 const METADATA_SIZE: usize = size_of::<TagTypeId>() + 3 * size_of::<u32>();
 
@@ -68,19 +68,14 @@ impl ModuleTag {
 }
 
 impl TagTrait for ModuleTag {
+    const ID: TagType = TagType::Module;
+
     fn dst_size(base_tag: &Tag) -> usize {
         assert!(base_tag.size as usize >= METADATA_SIZE);
         base_tag.size as usize - METADATA_SIZE
     }
 }
 
-#[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")
@@ -127,7 +122,7 @@ impl<'a> Debug for ModuleIter<'a> {
 
 #[cfg(test)]
 mod tests {
-    use crate::{ModuleTag, Tag, TagType};
+    use crate::{ModuleTag, Tag, TagTrait, TagType};
 
     const MSG: &str = "hello";
 
@@ -166,10 +161,8 @@ mod tests {
     #[test]
     #[cfg(feature = "builder")]
     fn test_build_str() {
-        use crate::builder::traits::StructAsBytes;
-
         let tag = ModuleTag::new(0, 0, MSG);
-        let bytes = tag.struct_as_bytes();
+        let bytes = tag.as_bytes();
         assert_eq!(bytes, get_bytes());
         assert_eq!(tag.cmdline(), Ok(MSG));
 

multiboot2/src/rsdp.rs

@@ -10,15 +10,12 @@
 //! signature should be manually verified.
 //!
 
-use crate::tag_type::TagTypeId;
+use crate::{Tag, TagTrait, TagType, TagTypeId};
 use core::slice;
 use core::str;
 use core::str::Utf8Error;
 #[cfg(feature = "builder")]
-use {
-    crate::builder::traits::StructAsBytes, crate::TagType, core::convert::TryInto,
-    core::mem::size_of,
-};
+use {core::convert::TryInto, core::mem::size_of};
 
 const RSDPV1_LENGTH: usize = 20;
 
@@ -88,11 +85,10 @@ impl RsdpV1Tag {
     }
 }
 
-#[cfg(feature = "builder")]
-impl StructAsBytes for RsdpV1Tag {
-    fn byte_size(&self) -> usize {
-        size_of::<Self>()
-    }
+impl TagTrait for RsdpV1Tag {
+    const ID: TagType = TagType::AcpiV1;
+
+    fn dst_size(_base_tag: &Tag) {}
 }
 
 /// This tag contains a copy of RSDP as defined per ACPI 2.0 or later specification.
@@ -182,9 +178,8 @@ impl RsdpV2Tag {
     }
 }
 
-#[cfg(feature = "builder")]
-impl StructAsBytes for RsdpV2Tag {
-    fn byte_size(&self) -> usize {
-        size_of::<Self>()
-    }
+impl TagTrait for RsdpV2Tag {
+    const ID: TagType = TagType::AcpiV2;
+
+    fn dst_size(_base_tag: &Tag) {}
 }

multiboot2/src/smbios.rs

@@ -1,10 +1,7 @@
-use crate::{Tag, TagTrait, TagTypeId};
-use core::fmt::Debug;
 #[cfg(feature = "builder")]
-use {
-    crate::builder::traits::StructAsBytes, crate::builder::BoxedDst, crate::TagType,
-    core::convert::TryInto,
-};
+use crate::builder::BoxedDst;
+use crate::{Tag, TagTrait, TagType, TagTypeId};
+use core::fmt::Debug;
 
 const METADATA_SIZE: usize = core::mem::size_of::<TagTypeId>()
     + core::mem::size_of::<u32>()
@@ -32,19 +29,14 @@ impl SmbiosTag {
 }
 
 impl TagTrait for SmbiosTag {
+    const ID: TagType = TagType::Smbios;
+
     fn dst_size(base_tag: &Tag) -> usize {
         assert!(base_tag.size as usize >= METADATA_SIZE);
         base_tag.size as usize - METADATA_SIZE
     }
 }
 
-#[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")
@@ -58,7 +50,7 @@ impl Debug for SmbiosTag {
 
 #[cfg(test)]
 mod tests {
-    use crate::{SmbiosTag, Tag, TagType};
+    use super::*;
 
     /// Returns the tag structure in bytes in little endian format.
     fn get_bytes() -> std::vec::Vec<u8> {
@@ -92,10 +84,8 @@ mod tests {
     #[test]
     #[cfg(feature = "builder")]
     fn test_build() {
-        use crate::builder::traits::StructAsBytes;
-
         let tag = SmbiosTag::new(3, 0, &[0xabu8; 24]);
-        let bytes = tag.struct_as_bytes();
+        let bytes = tag.as_bytes();
         assert_eq!(bytes, get_bytes());
     }
 }

multiboot2/src/tag_type.rs

@@ -5,9 +5,6 @@
 //! - [`TagTypeId`]
 //! - [`TagType`]
 //! - [`Tag`]
-#[cfg(feature = "builder")]
-use crate::builder::traits::StructAsBytes;
-
 use crate::TagTrait;
 use core::fmt::{Debug, Formatter};
 use core::hash::Hash;
@@ -313,6 +310,7 @@ pub struct Tag {
 impl Tag {
     /// Casts the base tag to the specific tag type.
     pub fn cast_tag<'a, T: TagTrait + ?Sized + 'a>(&'a self) -> &'a T {
+        assert_eq!(self.typ, T::ID);
         // Safety: At this point, we trust that "self.size" and the size hint
         // for DST tags are sane.
         unsafe { TagTrait::from_base_tag(self) }
@@ -378,11 +376,10 @@ impl Default for EndTag {
     }
 }
 
-#[cfg(feature = "builder")]
-impl StructAsBytes for EndTag {
-    fn byte_size(&self) -> usize {
-        core::mem::size_of::<Self>()
-    }
+impl TagTrait for EndTag {
+    const ID: TagType = TagType::End;
+
+    fn dst_size(_base_tag: &Tag) {}
 }
 
 /// Iterates the MBI's tags from the first tag to the end tag.

multiboot2/src/vbe_info.rs

@@ -1,4 +1,4 @@
-use crate::TagTypeId;
+use crate::{Tag, TagTrait, TagType, TagTypeId};
 use core::fmt;
 
 /// This tag contains VBE metadata, VBE controller information returned by the
@@ -37,6 +37,12 @@ pub struct VBEInfoTag {
     pub mode_info: VBEModeInfo,
 }
 
+impl TagTrait for VBEInfoTag {
+    const ID: TagType = TagType::Vbe;
+
+    fn dst_size(_base_tag: &Tag) {}
+}
+
 /// VBE controller information.
 ///
 /// The capabilities of the display controller, the revision level of the