multiboot2: use dst for tags where applicable

This commit transforms a few tags where applicable to DSTs. This better
fits into the Rust type system and makes a few things easier, such as
parsing the cmdline string from the command line tag.

Depending on how users used the tags, this change is not even breaking.
Additionally, there is now a public trait which allows custom tag users
to also benefit from DSTs.

Author: phip1611

Cargo.lock

@@ -40,3 +40,4 @@ unstable = []
 bitflags = "1"
 derive_more = { version = "0.99", default-features = false, features = ["display"] }
 log = { version = "0.4", default-features = false }
+ptr_meta = { version = "0.2.0", default-features = false }

multiboot2/Cargo.toml

@@ -1,5 +1,12 @@
 # CHANGELOG for crate `multiboot2`
 
+## unreleased
+- Add `TagTrait` trait which enables to use DSTs as multiboot2 tags. This is
+  mostly relevant for the command line tag, the modules tag, and the bootloader
+  name tag. However, this might also be relevant for users of custom multiboot2
+  tags that use DSTs as types. See the example provided in the doc of the
+  `get_tag` method.
+
 ## 0.15.1 (2023-03-18)
 - **BREAKING** `MemoryMapTag::all_memory_areas()` was renamed to `memory_areas`
   and now returns `MemoryAreaIter` instead of

multiboot2/Changelog.md

@@ -1,23 +1,24 @@
-use crate::TagTypeId;
+use crate::{Tag, TagTypeId};
+use core::fmt::{Debug, Formatter};
 use core::str::Utf8Error;
 
-/// This tag contains the name of the bootloader that is booting the kernel.
-///
-/// The name is a normal C-style UTF-8 zero-terminated string that can be
-/// obtained via the `name` method.
-#[derive(Clone, Copy, Debug)]
+/// The bootloader name tag.
+#[derive(ptr_meta::Pointee)]
 #[repr(C, packed)] // only repr(C) would add unwanted padding before first_section
 pub struct BootLoaderNameTag {
     typ: TagTypeId,
     size: u32,
     /// Null-terminated UTF-8 string
-    string: u8,
+    name: [u8],
 }
 
 impl BootLoaderNameTag {
-    /// Read the name of the bootloader that is booting the kernel.
-    /// This is an null-terminated UTF-8 string. If this returns `Err` then perhaps the memory
-    /// is invalid or the bootloader doesn't follow the spec.
+    /// Reads the name of the bootloader that is booting the kernel as Rust
+    /// string slice without the null-byte.
+    ///
+    /// For example, this returns `"GRUB 2.02~beta3-5"`.
+    ///
+    /// If the function returns `Err` then perhaps the memory is invalid.
     ///
     /// # Examples
     ///
@@ -28,17 +29,31 @@ impl BootLoaderNameTag {
     /// }
     /// ```
     pub fn name(&self) -> Result<&str, Utf8Error> {
-        use core::{mem, slice, str};
-        // strlen without null byte
-        let strlen = self.size as usize - mem::size_of::<BootLoaderNameTag>();
-        let bytes = unsafe { slice::from_raw_parts((&self.string) as *const u8, strlen) };
-        str::from_utf8(bytes)
+        Tag::get_dst_str_slice(&self.name)
+    }
+}
+
+impl Debug for BootLoaderNameTag {
+    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("BootLoaderNameTag")
+            .field("typ", &{ self.typ })
+            .field("size", &{ self.size })
+            .field("name", &self.name())
+            .finish()
+    }
+}
+
+impl crate::TagTrait for BootLoaderNameTag {
+    fn dst_size(base_tag: &Tag) -> usize {
+        // The size of the sized portion of the bootloader name tag.
+        let tag_base_size = 8;
+        base_tag.size as usize - tag_base_size
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::TagType;
+    use crate::{BootLoaderNameTag, Tag, TagType};
 
     const MSG: &str = "hello";
 
@@ -63,12 +78,8 @@ mod tests {
     #[test]
     fn test_parse_str() {
         let tag = get_bytes();
-        let tag = unsafe {
-            tag.as_ptr()
-                .cast::<super::BootLoaderNameTag>()
-                .as_ref()
-                .unwrap()
-        };
+        let tag = unsafe { &*tag.as_ptr().cast::<Tag>() };
+        let tag = tag.cast_tag::<BootLoaderNameTag>();
         assert_eq!({ tag.typ }, TagType::BootLoaderName);
         assert_eq!(tag.name().expect("must be valid UTF-8"), MSG);
     }

multiboot2/src/boot_loader_name.rs

@@ -1,27 +1,30 @@
 //! Module for [CommandLineTag].
 
-use crate::TagTypeId;
-use core::mem;
-use core::slice;
+use crate::{Tag, TagTrait, TagTypeId};
+use core::fmt::{Debug, Formatter};
 use core::str;
 
 /// This tag contains the command line string.
 ///
 /// The string is a normal C-style UTF-8 zero-terminated string that can be
 /// obtained via the `command_line` method.
-#[derive(Clone, Copy, Debug)]
 #[repr(C, packed)] // only repr(C) would add unwanted padding before first_section
+#[derive(ptr_meta::Pointee)]
 pub struct CommandLineTag {
     typ: TagTypeId,
     size: u32,
     /// Null-terminated UTF-8 string
-    string: u8,
+    cmdline: [u8],
 }
 
 impl CommandLineTag {
-    /// Read the command line string that is being passed to the booting kernel.
-    /// This is an null-terminated UTF-8 string. If this returns `Err` then perhaps the memory
-    /// is invalid or the bootloader doesn't follow the spec.
+    /// Reads the command line of the kernel as Rust string slice without
+    /// the null-byte.
+    ///
+    /// For example, this returns `"console=ttyS0"`.if the GRUB config
+    /// contains  `"multiboot2 /mykernel console=ttyS0"`.
+    ///
+    /// If the function returns `Err` then perhaps the memory is invalid.
     ///
     /// # Examples
     ///
@@ -33,16 +36,31 @@ impl CommandLineTag {
     /// }
     /// ```
     pub fn command_line(&self) -> Result<&str, str::Utf8Error> {
-        // strlen without null byte
-        let strlen = self.size as usize - mem::size_of::<CommandLineTag>();
-        let bytes = unsafe { slice::from_raw_parts((&self.string) as *const u8, strlen) };
-        str::from_utf8(bytes)
+        Tag::get_dst_str_slice(&self.cmdline)
+    }
+}
+
+impl Debug for CommandLineTag {
+    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("CommandLineTag")
+            .field("typ", &{ self.typ })
+            .field("size", &{ self.size })
+            .field("cmdline", &self.command_line())
+            .finish()
+    }
+}
+
+impl TagTrait for CommandLineTag {
+    fn dst_size(base_tag: &Tag) -> usize {
+        // The size of the sized portion of the command line tag.
+        let tag_base_size = 8;
+        base_tag.size as usize - tag_base_size
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::TagType;
+    use crate::{CommandLineTag, Tag, TagType};
 
     const MSG: &str = "hello";
 
@@ -67,12 +85,8 @@ mod tests {
     #[test]
     fn test_parse_str() {
         let tag = get_bytes();
-        let tag = unsafe {
-            tag.as_ptr()
-                .cast::<super::CommandLineTag>()
-                .as_ref()
-                .unwrap()
-        };
+        let tag = unsafe { &*tag.as_ptr().cast::<Tag>() };
+        let tag = tag.cast_tag::<CommandLineTag>();
         assert_eq!({ tag.typ }, TagType::Cmdline);
         assert_eq!(tag.command_line().expect("must be valid UTF-8"), MSG);
     }