multiboot2: consume multiboot2-common (3/N): GenericTag

Author: phip1611

multiboot2-common/src/lib.rs

@@ -62,6 +62,8 @@ pub enum DynSizedStructureError {
     SizeTooBig,
 }
 
+// todo impl core::error::Error
+
 /// A dynamically sized type with a common sized header and a dynamic amount of
 /// bytes that owns all its memory. It is fulfilling all memory requirements and
 /// guarantees of Multiboot2 structures and Rustc/Miri.
@@ -177,6 +179,31 @@ pub enum BytesRefError {
     MissingPadding,
 }
 
+// todo impl core::error::Error
+
+/// Wrapper type for all memory-related errors enums.
+#[derive(Copy, Clone, Debug, Ord, PartialOrd, Eq, PartialEq, Hash)]
+pub enum MemoryError {
+    /// See [`BytesRefError`].
+    BytesRef(BytesRefError),
+    /// See [`DynSizedStructureError`].
+    DynSizedStructure(DynSizedStructureError),
+}
+
+impl From<BytesRefError> for MemoryError {
+    fn from(value: BytesRefError) -> Self {
+        Self::BytesRef(value)
+    }
+}
+
+impl From<DynSizedStructureError> for MemoryError {
+    fn from(value: DynSizedStructureError) -> Self {
+        Self::DynSizedStructure(value)
+    }
+}
+
+// todo impl core::error::Error
+
 #[cfg(test)]
 mod tests {
     use super::*;

multiboot2/src/boot_loader_name.rs

@@ -87,7 +87,7 @@ impl TagTrait for BootLoaderNameTag {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::tag::{GenericTag, TagBytesRef};
+    use crate::tag::GenericTag;
     use core::borrow::Borrow;
     use multiboot2_common::test_utils::AlignedBytes;
 
@@ -106,8 +106,7 @@ mod tests {
     #[test]
     fn test_parse_str() {
         let bytes = get_bytes();
-        let bytes = TagBytesRef::try_from(bytes.borrow()).unwrap();
-        let tag = GenericTag::ref_from(bytes);
+        let tag = GenericTag::ref_from(bytes.borrow());
         let tag = tag.cast::<BootLoaderNameTag>();
         assert_eq!(tag.header.typ, TagType::BootLoaderName);
         assert_eq!(tag.name(), Ok("hello"));

multiboot2/src/command_line.rs

@@ -81,7 +81,7 @@ impl TagTrait for CommandLineTag {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::tag::{GenericTag, TagBytesRef};
+    use crate::tag::GenericTag;
     use core::borrow::Borrow;
     use multiboot2_common::test_utils::AlignedBytes;
 
@@ -100,8 +100,7 @@ mod tests {
     #[test]
     fn test_parse_str() {
         let bytes = get_bytes();
-        let bytes = TagBytesRef::try_from(bytes.borrow()).unwrap();
-        let tag = GenericTag::ref_from(bytes);
+        let tag = GenericTag::ref_from(bytes.borrow());
         let tag = tag.cast::<CommandLineTag>();
         assert_eq!(tag.header.typ, TagType::Cmdline);
         assert_eq!(tag.cmdline(), Ok("hello"));

multiboot2/src/module.rs

@@ -128,7 +128,7 @@ impl<'a> Debug for ModuleIter<'a> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::tag::{GenericTag, TagBytesRef};
+    use crate::tag::GenericTag;
     use core::borrow::Borrow;
     use multiboot2_common::test_utils::AlignedBytes;
 
@@ -151,8 +151,7 @@ mod tests {
     #[test]
     fn test_parse_str() {
         let bytes = get_bytes();
-        let bytes = TagBytesRef::try_from(bytes.borrow()).unwrap();
-        let tag = GenericTag::ref_from(bytes);
+        let tag = GenericTag::ref_from(bytes.borrow());
         let tag = tag.cast::<ModuleTag>();
         assert_eq!(tag.header.typ, TagType::Module);
         assert_eq!(tag.cmdline(), Ok("hello"));

multiboot2/src/smbios.rs

@@ -71,7 +71,7 @@ impl Debug for SmbiosTag {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::tag::{GenericTag, TagBytesRef};
+    use crate::tag::GenericTag;
     use core::borrow::Borrow;
     use multiboot2_common::test_utils::AlignedBytes;
 
@@ -97,8 +97,7 @@ mod tests {
     #[test]
     fn test_parse() {
         let bytes = get_bytes();
-        let bytes = TagBytesRef::try_from(bytes.borrow()).unwrap();
-        let tag = GenericTag::ref_from(bytes);
+        let tag = GenericTag::ref_from(bytes.borrow());
         let tag = tag.cast::<SmbiosTag>();
         assert_eq!(tag.header.typ, TagType::Smbios);
         assert_eq!(tag.major, 7);

multiboot2/src/tag.rs

@@ -13,9 +13,8 @@ use crate::util::increase_to_alignment;
 use crate::{TagTrait, TagType, TagTypeId};
 use core::fmt::{Debug, Formatter};
 use core::mem;
-use core::ops::Deref;
 use core::ptr;
-use multiboot2_common::ALIGNMENT;
+use multiboot2_common::{BytesRef, DynSizedStructure, Header};
 
 /// The common header that all tags have in common. This type is ABI compatible.
 ///
@@ -43,107 +42,48 @@ impl TagHeader {
     }
 }
 
-/// Wraps a byte slice representing a tag, but guarantees that the memory
-/// requirements are fulfilled.
-///
-/// This is the only type that can be used to construct a [`GenericTag`].
-///
-/// The main reason for this dedicated type is to create fine-grained unit-tests
-/// for Miri.
-///
-/// # Memory Requirements (for Multiboot and Rust/Miri)
-/// - At least as big as a `size_of<TagHeader>()`
-/// - at least [`ALIGNMENT`]-aligned
-/// - Length is multiple of [`ALIGNMENT`]. In other words, there are enough
-///   padding bytes until so that pointer coming right after the last byte
-///   is [`ALIGNMENT`]-aligned
-#[derive(Clone, Debug, PartialEq, Eq)]
-#[repr(transparent)]
-pub struct TagBytesRef<'a>(&'a [u8]);
-
-impl<'a> TryFrom<&'a [u8]> for TagBytesRef<'a> {
-    type Error = MemoryError;
-
-    fn try_from(value: &'a [u8]) -> Result<Self, Self::Error> {
-        if value.len() < mem::size_of::<TagHeader>() {
-            return Err(MemoryError::MinLengthNotSatisfied);
-        }
-        // Doesn't work as expected: if align_of_val(&value[0]) < ALIGNMENT {
-        if value.as_ptr().align_offset(ALIGNMENT) != 0 {
-            return Err(MemoryError::WrongAlignment);
-        }
-        let padding_bytes = value.len() % ALIGNMENT;
-        if padding_bytes != 0 {
-            return Err(MemoryError::MissingPadding);
-        }
-        Ok(Self(value))
+impl Header for TagHeader {
+    fn payload_len(&self) -> usize {
+        self.size as usize - size_of::<Self>()
     }
 }
 
-impl<'a> Deref for TagBytesRef<'a> {
-    type Target = &'a [u8];
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-/// Errors that occur when constructing a [`TagBytesRef`].
-#[derive(Copy, Clone, Debug, Ord, PartialOrd, Eq, PartialEq, Hash)]
-pub enum MemoryError {
-    /// The memory must be at least [`ALIGNMENT`]-aligned.
-    WrongAlignment,
-    /// The memory must cover at least the length of a [`TagHeader`].
-    MinLengthNotSatisfied,
-    /// The buffer misses the terminating padding to the next alignment
-    /// boundary.
-    // This is mainly relevant to satisfy Miri. As the spec also mandates an
-    // alignment, we can rely on this property.
-    MissingPadding,
-}
-
 /// A generic tag serving as base to cast to specific tags. This is a DST
 /// version of [`TagHeader`] that solves various type and memory safety
 /// problems by having a type that owns the whole memory of a tag.
-#[derive(Eq, Ord, PartialEq, PartialOrd, ptr_meta::Pointee)]
-#[repr(C)]
-pub struct GenericTag {
-    header: TagHeader,
-    /// Payload of the tag that is reflected in the `size` attribute, thus, no
-    /// padding bytes!
-    payload: [u8],
-}
+#[derive(PartialEq, Eq, ptr_meta::Pointee)]
+#[repr(transparent)]
+pub struct GenericTag(DynSizedStructure<TagHeader>);
 
 impl GenericTag {
-    /// Base size of the DST struct without the dynamic part.
-    const BASE_SIZE: usize = mem::size_of::<TagHeader>();
-
-    /// Creates a reference to a [`GenericTag`] from the provided `bytes`
-    /// [`TagBytesRef`].
-    pub(crate) fn ref_from(bytes: TagBytesRef) -> &Self {
-        let header = bytes.as_ptr().cast::<TagHeader>();
-        let header = unsafe { &*header };
-        let dst_len = Self::dst_len(header);
-        assert_eq!(header.size as usize, Self::BASE_SIZE + dst_len);
-
-        let generic_tag: *const Self = ptr_meta::from_raw_parts(bytes.as_ptr().cast(), dst_len);
-        unsafe { &*generic_tag }
+    /// Returns a reference to [`GenericTag`] to interpret the provided memory
+    /// as [`GenericTag`].
+    ///
+    /// # Panics
+    // pub fn ref_from<'a>(bytes: &'a [u8]) -> Result<&'a Self, MemoryError> {
+    // TODO return result
+    pub fn ref_from<'a>(bytes: &'a [u8]) -> &'a Self {
+        let bytes = BytesRef::<TagHeader>::try_from(bytes).unwrap();
+        let inner = DynSizedStructure::ref_from(bytes).unwrap();
+        let tag = unsafe { mem::transmute::<_, &'a Self>(inner) };
+        tag
     }
 
+    /// Returns the underlying [`TagHeader`].
     pub const fn header(&self) -> &TagHeader {
-        &self.header
+        self.0.header()
     }
 
     #[cfg(all(test, feature = "builder"))]
     pub const fn payload(&self) -> &[u8] {
-        &self.payload
+        self.0.payload()
     }
 
     /// Casts the generic tag to a specific [`TagTrait`] implementation which
     /// may be a ZST or DST typed tag.
     pub fn cast<T: TagTrait + ?Sized>(&self) -> &T {
         let base_ptr = ptr::addr_of!(*self);
-        let t_dst_size = T::dst_len(&self.header);
+        let t_dst_size = T::dst_len(&self.0.header());
         let t_ptr = ptr_meta::from_raw_parts(base_ptr.cast(), t_dst_size);
         let t_ref = unsafe { &*t_ptr };
         assert_eq!(mem::size_of_val(self), mem::size_of_val(t_ref));
@@ -154,7 +94,7 @@ impl GenericTag {
 impl Debug for GenericTag {
     fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
         f.debug_struct("GenericTag")
-            .field("header", &self.header)
+            .field("header", &self.0.header())
             .field("payload", &"<bytes>")
             .finish()
     }
@@ -164,8 +104,8 @@ impl TagTrait for GenericTag {
     const ID: TagType = TagType::Custom(0xffffffff);
 
     fn dst_len(header: &TagHeader) -> usize {
-        assert!(header.size as usize >= Self::BASE_SIZE);
-        header.size as usize - Self::BASE_SIZE
+        assert!(header.size as usize >= size_of::<TagHeader>());
+        header.size as usize - size_of::<TagHeader>()
     }
 }
 
@@ -227,16 +167,14 @@ impl<'a> Iterator for TagIter<'a> {
             &self.buffer[from..to]
         };
 
-        // Should never fail at this point.
-        let tag_bytes = TagBytesRef::try_from(bytes).unwrap();
-
-        Some(GenericTag::ref_from(tag_bytes))
+        Some(GenericTag::ref_from(bytes))
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::TagType;
     use core::borrow::Borrow;
     use core::mem;
     use multiboot2_common::test_utils::AlignedBytes;
@@ -251,11 +189,10 @@ mod tests {
             0x13, 0x37, 0x13, 0x37,
         ]);
 
-        let bytes = TagBytesRef::try_from(bytes.borrow()).unwrap();
-        let tag = GenericTag::ref_from(bytes);
-        assert_eq!(tag.header.typ, 0xffff_ffff);
-        assert_eq!(tag.header.size, 16);
-        assert_eq!(tag.payload.len(), 8);
+        let tag = GenericTag::ref_from(bytes.borrow());
+        assert_eq!(tag.header().typ, 0xffff_ffff);
+        assert_eq!(tag.header().size, 16);
+        assert_eq!(tag.payload().len(), 8);
     }
 
     #[test]
@@ -280,8 +217,7 @@ mod tests {
             0xef, 0xbe, 0xad, 0xde, /* field b: 0x1337_1337 */
             0x37, 0x13, 0x37, 0x13,
         ]);
-        let bytes = TagBytesRef::try_from(bytes.borrow()).unwrap();
-        let tag = GenericTag::ref_from(bytes);
+        let tag = GenericTag::ref_from(bytes.borrow());
         let custom_tag = tag.cast::<CustomTag>();
 
         assert_eq!(mem::size_of_val(custom_tag), 16);
@@ -316,8 +252,7 @@ mod tests {
             0x37, 0x13, 0x37, 0x13,
         ]);
 
-        let bytes = TagBytesRef::try_from(bytes.borrow()).unwrap();
-        let tag = GenericTag::ref_from(bytes);
+        let tag = GenericTag::ref_from(bytes.borrow());
         let custom_tag = tag.cast::<CustomDstTag>();
 
         assert_eq!(mem::size_of_val(custom_tag), 16);
@@ -345,10 +280,9 @@ mod tests {
                 0, 0, 0, 0, 0, 0
             ],
         );
-        let bytes = TagBytesRef::try_from(bytes.borrow()).unwrap();
-        let tag = GenericTag::ref_from(bytes);
-        assert_eq!(tag.header.typ, TagType::Cmdline);
-        assert_eq!(tag.header.size, 8 + 10);
+        let tag = GenericTag::ref_from(bytes.borrow());
+        assert_eq!(tag.header().typ, TagType::Cmdline);
+        assert_eq!(tag.header().size, 8 + 10);
     }
 
     #[test]
@@ -367,13 +301,12 @@ mod tests {
                 0, 0, 0, 0, 0, 0
             ],
         );
-        let bytes = TagBytesRef::try_from(bytes.borrow()).unwrap();
-        let tag = GenericTag::ref_from(bytes);
+        let tag = GenericTag::ref_from(bytes.borrow());
 
         // Main objective here is also that this test passes Miri.
         let tag = tag.cast::<GenericTag>();
-        assert_eq!(tag.header.typ, TagType::Cmdline);
-        assert_eq!(tag.header.size, 8 + 10);
+        assert_eq!(tag.header().typ, TagType::Cmdline);
+        assert_eq!(tag.header().size, 8 + 10);
     }
 
     #[test]
@@ -397,19 +330,19 @@ mod tests {
         );
         let mut iter = TagIter::new(bytes.borrow());
         let first = iter.next().unwrap();
-        assert_eq!(first.header.typ, TagType::Custom(0xff));
-        assert_eq!(first.header.size, 8);
-        assert!(first.payload.is_empty());
+        assert_eq!(first.header().typ, TagType::Custom(0xff));
+        assert_eq!(first.header().size, 8);
+        assert!(first.payload().is_empty());
 
         let second = iter.next().unwrap();
-        assert_eq!(second.header.typ, TagType::Custom(0xfe));
-        assert_eq!(second.header.size, 12);
-        assert_eq!(&second.payload, &[1, 2, 3, 4]);
+        assert_eq!(second.header().typ, TagType::Custom(0xfe));
+        assert_eq!(second.header().size, 12);
+        assert_eq!(&second.payload(), &[1, 2, 3, 4]);
 
         let third = iter.next().unwrap();
-        assert_eq!(third.header.typ, TagType::End);
-        assert_eq!(third.header.size, 8);
-        assert!(first.payload.is_empty());
+        assert_eq!(third.header().typ, TagType::End);
+        assert_eq!(third.header().size, 8);
+        assert!(first.payload().is_empty());
 
         assert_eq!(iter.next(), None);
     }