Merge pull request #164 from rust-osdev/foobar

multiboot2: API refactorings and simplifications: Make TagTrait more useful

Cargo.lock

@@ -28,6 +28,19 @@ checksum = "b06a4cde4c0f271a446782e3eff8de789548ce57dbc8eca9292c27f4a42004b4"
 [[package]]
 name = "multiboot2"
 version = "0.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b624a7b3f704734d98d21455b617607eb7043d4509d1c34bf9e7ff7dd47b31a"
+dependencies = [
+ "bitflags",
+ "derive_more",
+ "log",
+ "ptr_meta",
+ "uefi-raw",
+]
+
+[[package]]
+name = "multiboot2"
+version = "0.17.0"
 dependencies = [
  "bitflags",
  "derive_more",
@@ -41,7 +54,7 @@ name = "multiboot2-header"
 version = "0.3.1"
 dependencies = [
  "derive_more",
- "multiboot2",
+ "multiboot2 0.16.0",
 ]
 
 [[package]]

integration-test/bins/Cargo.lock

@@ -97,6 +97,19 @@ dependencies = [
 [[package]]
 name = "multiboot2"
 version = "0.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b624a7b3f704734d98d21455b617607eb7043d4509d1c34bf9e7ff7dd47b31a"
+dependencies = [
+ "bitflags 2.3.2",
+ "derive_more",
+ "log",
+ "ptr_meta",
+ "uefi-raw",
+]
+
+[[package]]
+name = "multiboot2"
+version = "0.17.0"
 dependencies = [
  "bitflags 2.3.2",
  "derive_more",
@@ -110,7 +123,7 @@ name = "multiboot2-header"
 version = "0.3.1"
 dependencies = [
  "derive_more",
- "multiboot2",
+ "multiboot2 0.16.0",
 ]
 
 [[package]]
@@ -122,7 +135,7 @@ dependencies = [
  "good_memory_allocator",
  "log",
  "multiboot",
- "multiboot2",
+ "multiboot2 0.17.0",
  "multiboot2-header",
  "util",
 ]
@@ -134,7 +147,7 @@ dependencies = [
  "anyhow",
  "good_memory_allocator",
  "log",
- "multiboot2",
+ "multiboot2 0.17.0",
  "util",
  "x86",
 ]

multiboot2-header/README.md

@@ -16,10 +16,10 @@ What this library is not optimal for:
 - compiling a Multiboot2 header statically into an object file using only Rust code
 
 ## Features and `no_std` Compatibility
-This library is always `no_std`. However, the default `builder`-feature requires
-the `alloc`-crate to be available. You need the `builder` only if you want to
-construct new headers at run time. For parsing, this is not relevant, and you
-can deactivate the default feature.
+This library is always `no_std` without `alloc`. However, the default `builder`-
+feature requires the `alloc`-crate and an `#[global_allocator]` to be available.
+You need the `builder` only if you want to construct new headers at runtime.
+For parsing, this is not relevant, and you can deactivate the default feature.
 
 ```toml
 # without `builder`-feature (and without `alloc`-crate)

multiboot2/Changelog.md

@@ -1,5 +1,15 @@
 # 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.
+- **BREAKING** `BoxedDst::new` doesn't have the `typ` parameter anymore. This
+  only effects you when you wrote a custom DST tag.
+- **BREAKING** Removed deprecated functions `load` and `load_with_offset`. Use
+  `BootInformation::load` instead.
+
 ## 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/README.md

@@ -11,10 +11,11 @@ is `no_std` and can be used in a Multiboot2-kernel.
 It follows the Multiboot 2.0 specification at https://www.gnu.org/software/grub/manual/multiboot2/multiboot.html and the ELF 64 specification at http://www.uclibc.org/docs/elf-64-gen.pdf.
 
 ## Features and `no_std` Compatibility
-This library is always `no_std`. However, the default `builder`-feature requires
-the `alloc`-crate to be available. You need the `builder` only if you want to
-construct new boot information structures at run time. For parsing, this is not
-relevant, and you can deactivate the default feature.
+This library is always `no_std` without `alloc`. However, the default `builder`-
+feature requires the `alloc`-crate and an `#[global_allocator]` to be available.
+You need the `builder` only if you want to construct new boot information
+structures at runtime. For parsing, this is not relevant, and you can
+deactivate the default feature.
 
 ## Background: The Multiboot 2 Information Structure
 The Multiboot information structure looks like this:

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>();
 
@@ -29,7 +25,7 @@ impl BootLoaderNameTag {
             // terminating null-byte
             bytes.push(0);
         }
-        BoxedDst::new(TagType::BootLoaderName, &bytes)
+        BoxedDst::new(&bytes)
     }
 
     /// Reads the name of the bootloader that is booting the kernel as Rust
@@ -42,7 +38,9 @@ impl BootLoaderNameTag {
     /// # Examples
     ///
     /// ```rust,no_run
-    /// # let boot_info = unsafe { multiboot2::load(0xdeadbeef).unwrap() };
+    /// # use multiboot2::{BootInformation, BootInformationHeader};
+    /// # let ptr = 0xdeadbeef as *const BootInformationHeader;
+    /// # let boot_info = unsafe { BootInformation::load(ptr).unwrap() };
     /// if let Some(tag) = boot_info.boot_loader_name_tag() {
     ///     assert_eq!(Ok("GRUB 2.02~beta3-5"), tag.name());
     /// }
@@ -63,22 +61,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 +107,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;
@@ -35,11 +35,10 @@ impl<T: TagTrait<Metadata = usize> + ?Sized> BoxedDst<T> {
     /// Create a boxed tag with the given content.
     ///
     /// # Parameters
-    /// - `typ` - The given [`TagTypeId`]
     /// - `content` - All payload bytes of the DST tag without the tag type or
     ///               the size. The memory is only read and can be discarded
     ///               afterwards.
-    pub(crate) fn new(typ: impl Into<TagTypeId>, content: &[u8]) -> Self {
+    pub(crate) fn new(content: &[u8]) -> Self {
         // Currently, I do not find a nice way of making this dynamic so that
         // also miri is guaranteed to be happy. But it seems that 4 is fine
         // here. I do have control over allocation and deallocation.
@@ -63,7 +62,7 @@ impl<T: TagTrait<Metadata = usize> + ?Sized> BoxedDst<T> {
         unsafe {
             // write tag type
             let ptrx = ptr.cast::<TagTypeId>();
-            ptrx.write(typ.into());
+            ptrx.write(T::ID.into());
 
             // write tag size
             let ptrx = ptrx.add(1).cast::<u32>();
@@ -110,6 +109,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 +128,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
@@ -136,11 +138,10 @@ mod tests {
 
     #[test]
     fn test_boxed_dst_tag() {
-        let tag_type_id = 1337_u32;
         let content = "hallo";
 
-        let tag = BoxedDst::<CustomTag>::new(tag_type_id, content.as_bytes());
-        assert_eq!(tag.typ, tag_type_id);
+        let tag = BoxedDst::<CustomTag>::new(content.as_bytes());
+        assert_eq!(tag.typ, CustomTag::ID);
         assert_eq!(tag.size as usize, METADATA_SIZE + content.len());
         assert_eq!(tag.string(), Ok(content));
     }

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>();
 
@@ -36,7 +33,7 @@ impl CommandLineTag {
             // terminating null-byte
             bytes.push(0);
         }
-        BoxedDst::new(TagType::Cmdline, &bytes)
+        BoxedDst::new(&bytes)
     }
 
     /// Reads the command line of the kernel as Rust string slice without
@@ -50,7 +47,9 @@ impl CommandLineTag {
     /// # Examples
     ///
     /// ```rust,no_run
-    /// # let boot_info = unsafe { multiboot2::load(0xdeadbeef).unwrap() };
+    /// # use multiboot2::{BootInformation, BootInformationHeader};
+    /// # let ptr = 0xdeadbeef as *const BootInformationHeader;
+    /// # let boot_info = unsafe { BootInformation::load(ptr).unwrap() };
     /// if let Some(tag) = boot_info.command_line_tag() {
     ///     let command_line = tag.cmdline();
     ///     assert_eq!(Ok("/bootarg"), command_line);
@@ -72,22 +71,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 +117,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)]
@@ -21,7 +18,7 @@ impl EFISdt32Tag {
     /// Create a new tag to pass the EFI32 System Table pointer.
     pub fn new(pointer: u32) -> Self {
         Self {
-            typ: TagType::Efi32.into(),
+            typ: Self::ID.into(),
             size: size_of::<Self>().try_into().unwrap(),
             pointer,
         }
@@ -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.
@@ -53,7 +49,7 @@ impl EFISdt64Tag {
     /// Create a new tag to pass the EFI64 System Table pointer.
     pub fn new(pointer: u64) -> Self {
         Self {
-            typ: TagType::Efi64.into(),
+            typ: Self::ID.into(),
             size: size_of::<Self>().try_into().unwrap(),
             pointer,
         }
@@ -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
@@ -86,7 +81,7 @@ impl EFIImageHandle32Tag {
     #[cfg(feature = "builder")]
     pub fn new(pointer: u32) -> Self {
         Self {
-            typ: TagType::Efi32Ih.into(),
+            typ: Self::ID.into(),
             size: size_of::<Self>().try_into().unwrap(),
             pointer,
         }
@@ -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
@@ -119,7 +113,7 @@ impl EFIImageHandle64Tag {
     #[cfg(feature = "builder")]
     pub fn new(pointer: u64) -> Self {
         Self {
-            typ: TagType::Efi64Ih.into(),
+            typ: Self::ID.into(),
             size: size_of::<Self>().try_into().unwrap(),
             pointer,
         }
@@ -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.
@@ -39,7 +37,7 @@ impl ElfSectionsTag {
         ]
         .concat();
         bytes.extend_from_slice(sections);
-        BoxedDst::new(TagType::ElfSections, &bytes)
+        BoxedDst::new(&bytes)
     }
 
     /// Get an iterator of loaded ELF sections.
@@ -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.
@@ -102,7 +97,7 @@ impl FramebufferTag {
         bytes.extend(height.to_le_bytes());
         bytes.extend(bpp.to_le_bytes());
         bytes.extend(buffer_type.to_bytes());
-        BoxedDst::new(TagType::Framebuffer, &bytes)
+        BoxedDst::new(&bytes)
     }
 
     /// Contains framebuffer physical address.
@@ -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: Self::ID.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::LoadBaseAddr;
+
+    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;
@@ -102,26 +101,6 @@ pub mod builder;
 /// that the Rust compiler output changes `eax` before you can access it.
 pub const MAGIC: u32 = 0x36d76289;
 
-/// # Safety
-/// Deprecated. Please use BootInformation::load() instead.
-#[deprecated = "Please use BootInformation::load() instead."]
-pub unsafe fn load<'a>(address: usize) -> Result<BootInformation<'a>, MbiLoadError> {
-    let ptr = address as *const BootInformationHeader;
-    BootInformation::load(ptr)
-}
-
-/// # Safety
-/// Deprecated. Please use BootInformation::load() instead.
-#[deprecated = "Please use BootInformation::load() instead."]
-pub unsafe fn load_with_offset<'a>(
-    address: usize,
-    offset: usize,
-) -> Result<BootInformation<'a>, MbiLoadError> {
-    let ptr = address as *const u8;
-    let ptr = ptr.add(offset);
-    BootInformation::load(ptr.cast())
-}
-
 /// Error type that describes errors while loading/parsing a multiboot2 information structure
 /// from a given address.
 #[derive(Display, Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -153,8 +132,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 +143,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.
@@ -267,7 +242,9 @@ impl<'a> BootInformation<'a> {
     /// This is the same as doing:
     ///
     /// ```rust,no_run
-    /// # let boot_info = unsafe { multiboot2::load(0xdeadbeef).unwrap() };
+    /// # use multiboot2::{BootInformation, BootInformationHeader};
+    /// # let ptr = 0xdeadbeef as *const BootInformationHeader;
+    /// # let boot_info = unsafe { BootInformation::load(ptr).unwrap() };
     /// let end_addr = boot_info.start_address() + boot_info.total_size();
     /// ```
     pub fn end_address(&self) -> usize {
@@ -281,7 +258,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
@@ -290,7 +267,9 @@ impl<'a> BootInformation<'a> {
     /// # Examples
     ///
     /// ```rust,no_run
-    /// # let boot_info = unsafe { multiboot2::load(0xdeadbeef).unwrap() };
+    /// # use multiboot2::{BootInformation, BootInformationHeader};
+    /// # let ptr = 0xdeadbeef as *const BootInformationHeader;
+    /// # let boot_info = unsafe { BootInformation::load(ptr).unwrap() };
     /// if let Some(sections) = boot_info.elf_sections() {
     ///     let mut total = 0;
     ///     for section in sections {
@@ -300,7 +279,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 +288,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 +298,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 +318,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 +343,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 +398,11 @@ impl<'a> BootInformation<'a> {
     ///
     /// ```no_run
     /// use std::str::Utf8Error;
-    /// use multiboot2::{Tag, TagTrait, TagTypeId};
+    /// use multiboot2::{BootInformation, BootInformationHeader, 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 +411,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
@@ -446,21 +426,17 @@ impl<'a> BootInformation<'a> {
     ///         Tag::get_dst_str_slice(&self.name)
     ///     }
     /// }
-    ///
-    /// let mbi = unsafe { multiboot2::load(0xdeadbeef).unwrap() };
+    /// let mbi_ptr = 0xdeadbeef as *const BootInformationHeader;
+    /// let mbi = unsafe { BootInformation::load(mbi_ptr).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 +508,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.
+/// create fat pointers for tags that are DST.
 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 +558,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::*;
@@ -1264,15 +1242,6 @@ mod tests {
         let bi = bi.unwrap();
         test_grub2_boot_info(&bi, addr, string_addr, &bytes.0, &string_bytes.0);
 
-        let bi = unsafe { load_with_offset(addr, 0) };
-        let bi = bi.unwrap();
-        test_grub2_boot_info(&bi, addr, string_addr, &bytes.0, &string_bytes.0);
-
-        let offset = 8usize;
-        let bi = unsafe { load_with_offset(addr - offset, offset) };
-        let bi = bi.unwrap();
-        test_grub2_boot_info(&bi, addr, string_addr, &bytes.0, &string_bytes.0);
-
         // Check that the MBI's debug output can be printed without SEGFAULT.
         // If this works, it is a good indicator than transitively a lot of
         // stuff works.
@@ -1574,8 +1543,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 +1550,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 +1568,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 +1601,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 +1609,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 +1624,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 +1646,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 +1679,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 +1728,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,9 +38,9 @@ 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())
+        BoxedDst::new(bytes.as_slice())
     }
 
     /// Returns the entry size.
@@ -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)]
@@ -249,7 +239,7 @@ pub struct BasicMemoryInfoTag {
 impl BasicMemoryInfoTag {
     pub fn new(memory_lower: u32, memory_upper: u32) -> Self {
         Self {
-            typ: TagType::BasicMeminfo.into(),
+            typ: Self::ID.into(),
             size: mem::size_of::<BasicMemoryInfoTag>().try_into().unwrap(),
             memory_lower,
             memory_upper,
@@ -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,9 +291,9 @@ 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())
+        BoxedDst::new(bytes.as_slice())
     }
 
     /// Return an iterator over ALL marked memory areas.
@@ -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>();
 
@@ -35,7 +35,7 @@ impl ModuleTag {
         let end_bytes = end.to_le_bytes();
         let mut content_bytes = [start_bytes, end_bytes].concat();
         content_bytes.extend_from_slice(&cmdline_bytes);
-        BoxedDst::new(TagType::Module, &content_bytes)
+        BoxedDst::new(&content_bytes)
     }
 
     /// Reads the command line of the boot module as Rust string slice without
@@ -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;
 
@@ -45,7 +42,7 @@ impl RsdpV1Tag {
         rsdt_address: u32,
     ) -> Self {
         Self {
-            typ: TagType::AcpiV1.into(),
+            typ: Self::ID.into(),
             size: size_of::<Self>().try_into().unwrap(),
             signature,
             checksum,
@@ -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.
@@ -127,7 +123,7 @@ impl RsdpV2Tag {
         ext_checksum: u8,
     ) -> Self {
         Self {
-            typ: TagType::AcpiV2.into(),
+            typ: Self::ID.into(),
             size: size_of::<Self>().try_into().unwrap(),
             signature,
             checksum,
@@ -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>()
@@ -27,24 +24,19 @@ impl SmbiosTag {
     pub fn new(major: u8, minor: u8, tables: &[u8]) -> BoxedDst<Self> {
         let mut bytes = [major, minor, 0, 0, 0, 0, 0, 0].to_vec();
         bytes.extend(tables);
-        BoxedDst::new(TagType::Smbios, &bytes)
+        BoxedDst::new(&bytes)
     }
 }
 
 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