Merge pull request #150 from rust-osdev/dev2

phip1611 · web-flow · commit ade1dddd7c08 · 2023-06-21T13:48:21.000+02:00
multiboot2: memory-map: derive Eq + uefi-raw@0.3.0
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/multiboot2/Cargo.toml b/multiboot2/Cargo.toml
@@ -45,5 +45,5 @@ bitflags.workspace = true
 derive_more.workspace = true
 log.workspace = true
 
-uefi-raw = { version = "0.2.0", default-features = false }
-ptr_meta = { version = "0.2.0", default-features = false }
+uefi-raw = { version = "0.3", default-features = false }
+ptr_meta = { version = "0.2", default-features = false }
diff --git a/multiboot2/Changelog.md b/multiboot2/Changelog.md
@@ -16,6 +16,12 @@
 - MSRV is 1.68.0
 - **BREAKING** Removed `MemoryAreaIter` and `MemoryMapTag::available_memory_areas`
 - Added `MemoryMapTag::entry_size` and `MemoryMapTag::entry_version`
+- **BREAKING** Renamed `BootInformation::load_base_addr` to `BootInformation::load_base_addr_tag`
+- **BREAKING** Renamed `BootInformation::efi_32_ih` to `BootInformation::efi_32_ih_tag`
+- **BREAKING** Renamed `BootInformation::efi_32_ih` to `BootInformation::efi_32_ih_tag`
+- **BREAKING** Renamed `ImageLoadPhysAddr` to `ImageLoadPhysAddrTag`
+- **BREAKING** Renamed `EFIImageHandle32` to `EFIImageHandle32Tag`
+- **BREAKING** Renamed `EFIImageHandle64` to `EFIImageHandle64Tag`
 
 ## 0.15.1 (2023-03-18)
 - **BREAKING** `MemoryMapTag::all_memory_areas()` was renamed to `memory_areas`
diff --git a/multiboot2/src/builder/information.rs b/multiboot2/src/builder/information.rs
@@ -2,9 +2,9 @@
 use crate::builder::traits::StructAsBytes;
 use crate::{
     BasicMemoryInfoTag, BootInformationInner, BootLoaderNameTag, CommandLineTag,
-    EFIBootServicesNotExited, EFIImageHandle32, EFIImageHandle64, EFIMemoryMapTag, EFISdt32,
-    EFISdt64, ElfSectionsTag, EndTag, FramebufferTag, ImageLoadPhysAddr, MemoryMapTag, ModuleTag,
-    RsdpV1Tag, RsdpV2Tag, SmbiosTag,
+    EFIBootServicesNotExited, EFIImageHandle32Tag, EFIImageHandle64Tag, EFIMemoryMapTag, EFISdt32,
+    EFISdt64, ElfSectionsTag, EndTag, FramebufferTag, ImageLoadPhysAddrTag, MemoryMapTag,
+    ModuleTag, RsdpV1Tag, RsdpV2Tag, SmbiosTag,
 };
 
 use alloc::boxed::Box;
@@ -14,19 +14,18 @@ use core::mem::size_of;
 /// Builder to construct a valid Multiboot2 information dynamically at runtime.
 /// The tags will appear in the order of their corresponding enumeration,
 /// except for the END tag.
-#[derive(Debug)]
-// #[derive(Debug, PartialEq, Eq)] // wait for uefi-raw 0.3.0
+#[derive(Debug, PartialEq, Eq)]
 pub struct InformationBuilder {
     basic_memory_info_tag: Option<BasicMemoryInfoTag>,
     boot_loader_name_tag: Option<Box<BootLoaderNameTag>>,
     command_line_tag: Option<Box<CommandLineTag>>,
     efi_boot_services_not_exited: Option<EFIBootServicesNotExited>,
-    efi_image_handle32: Option<EFIImageHandle32>,
-    efi_image_handle64: Option<EFIImageHandle64>,
+    efi_image_handle32: Option<EFIImageHandle32Tag>,
+    efi_image_handle64: Option<EFIImageHandle64Tag>,
     efi_memory_map_tag: Option<Box<EFIMemoryMapTag>>,
     elf_sections_tag: Option<Box<ElfSectionsTag>>,
     framebuffer_tag: Option<Box<FramebufferTag>>,
-    image_load_addr: Option<ImageLoadPhysAddr>,
+    image_load_addr: Option<ImageLoadPhysAddrTag>,
     memory_map_tag: Option<Box<MemoryMapTag>>,
     module_tags: Vec<Box<ModuleTag>>,
     efisdt32: Option<EFISdt32>,
@@ -242,11 +241,11 @@ impl InformationBuilder {
         self.efi_boot_services_not_exited = Some(EFIBootServicesNotExited::new());
     }
 
-    pub fn efi_image_handle32(&mut self, efi_image_handle32: EFIImageHandle32) {
+    pub fn efi_image_handle32(&mut self, efi_image_handle32: EFIImageHandle32Tag) {
         self.efi_image_handle32 = Some(efi_image_handle32);
     }
 
-    pub fn efi_image_handle64(&mut self, efi_image_handle64: EFIImageHandle64) {
+    pub fn efi_image_handle64(&mut self, efi_image_handle64: EFIImageHandle64Tag) {
         self.efi_image_handle64 = Some(efi_image_handle64);
     }
 
@@ -262,7 +261,7 @@ impl InformationBuilder {
         self.framebuffer_tag = Some(framebuffer_tag);
     }
 
-    pub fn image_load_addr(&mut self, image_load_addr: ImageLoadPhysAddr) {
+    pub fn image_load_addr(&mut self, image_load_addr: ImageLoadPhysAddrTag) {
         self.image_load_addr = Some(image_load_addr);
     }
 
diff --git a/multiboot2/src/efi.rs b/multiboot2/src/efi.rs
@@ -72,16 +72,17 @@ impl StructAsBytes for EFISdt64 {
     }
 }
 
-/// Contains pointer to boot loader image handle.
+/// Tag that contains the pointer to the boot loader's UEFI image handle
+/// (32-bit).
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[repr(C)]
-pub struct EFIImageHandle32 {
+pub struct EFIImageHandle32Tag {
     typ: TagTypeId,
     size: u32,
     pointer: u32,
 }
 
-impl EFIImageHandle32 {
+impl EFIImageHandle32Tag {
     #[cfg(feature = "builder")]
     pub fn new(pointer: u32) -> Self {
         Self {
@@ -98,22 +99,23 @@ impl EFIImageHandle32 {
 }
 
 #[cfg(feature = "builder")]
-impl StructAsBytes for EFIImageHandle32 {
+impl StructAsBytes for EFIImageHandle32Tag {
     fn byte_size(&self) -> usize {
         size_of::<Self>()
     }
 }
 
-/// Contains pointer to boot loader image handle.
+/// Tag that contains the pointer to the boot loader's UEFI image handle
+/// (64-bit).
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[repr(C)]
-pub struct EFIImageHandle64 {
+pub struct EFIImageHandle64Tag {
     typ: TagTypeId,
     size: u32,
     pointer: u64,
 }
 
-impl EFIImageHandle64 {
+impl EFIImageHandle64Tag {
     #[cfg(feature = "builder")]
     pub fn new(pointer: u64) -> Self {
         Self {
@@ -130,15 +132,15 @@ impl EFIImageHandle64 {
 }
 
 #[cfg(feature = "builder")]
-impl StructAsBytes for EFIImageHandle64 {
+impl StructAsBytes for EFIImageHandle64Tag {
     fn byte_size(&self) -> usize {
         size_of::<Self>()
     }
 }
 
 #[cfg(all(test, feature = "builder"))]
 mod tests {
-    use super::{EFIImageHandle32, EFIImageHandle64, EFISdt32, EFISdt64};
+    use super::{EFIImageHandle32Tag, EFIImageHandle64Tag, EFISdt32, EFISdt64};
 
     const ADDR: usize = 0xABCDEF;
 
@@ -156,13 +158,13 @@ mod tests {
 
     #[test]
     fn test_build_eftih32() {
-        let tag = EFIImageHandle32::new(ADDR.try_into().unwrap());
+        let tag = EFIImageHandle32Tag::new(ADDR.try_into().unwrap());
         assert_eq!(tag.image_handle(), ADDR);
     }
 
     #[test]
     fn test_build_eftih64() {
-        let tag = EFIImageHandle64::new(ADDR.try_into().unwrap());
+        let tag = EFIImageHandle64Tag::new(ADDR.try_into().unwrap());
         assert_eq!(tag.image_handle(), ADDR);
     }
 }
diff --git a/multiboot2/src/image_load_addr.rs b/multiboot2/src/image_load_addr.rs
@@ -9,13 +9,13 @@ use {
 /// base physical address.
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[repr(C)]
-pub struct ImageLoadPhysAddr {
+pub struct ImageLoadPhysAddrTag {
     typ: TagTypeId,
     size: u32,
     load_base_addr: u32,
 }
 
-impl ImageLoadPhysAddr {
+impl ImageLoadPhysAddrTag {
     #[cfg(feature = "builder")]
     pub fn new(load_base_addr: u32) -> Self {
         Self {
@@ -32,21 +32,21 @@ impl ImageLoadPhysAddr {
 }
 
 #[cfg(feature = "builder")]
-impl StructAsBytes for ImageLoadPhysAddr {
+impl StructAsBytes for ImageLoadPhysAddrTag {
     fn byte_size(&self) -> usize {
         size_of::<Self>()
     }
 }
 
 #[cfg(all(test, feature = "builder"))]
 mod tests {
-    use super::ImageLoadPhysAddr;
+    use super::ImageLoadPhysAddrTag;
 
     const ADDR: u32 = 0xABCDEF;
 
     #[test]
     fn test_build_load_addr() {
-        let tag = ImageLoadPhysAddr::new(ADDR);
+        let tag = ImageLoadPhysAddrTag::new(ADDR);
         assert_eq!(tag.load_base_addr(), ADDR);
     }
 }
diff --git a/multiboot2/src/lib.rs b/multiboot2/src/lib.rs
@@ -50,12 +50,12 @@ pub use boot_loader_name::BootLoaderNameTag;
 #[cfg(feature = "builder")]
 use builder::traits::StructAsBytes;
 pub use command_line::CommandLineTag;
-pub use efi::{EFIImageHandle32, EFIImageHandle64, EFISdt32, EFISdt64};
+pub use efi::{EFIImageHandle32Tag, EFIImageHandle64Tag, EFISdt32, EFISdt64};
 pub use elf_sections::{
     ElfSection, ElfSectionFlags, ElfSectionIter, ElfSectionType, ElfSectionsTag,
 };
 pub use framebuffer::{FramebufferColor, FramebufferField, FramebufferTag, FramebufferType};
-pub use image_load_addr::ImageLoadPhysAddr;
+pub use image_load_addr::ImageLoadPhysAddrTag;
 pub use memory_map::{
     BasicMemoryInfoTag, EFIBootServicesNotExited, EFIMemoryAreaType, EFIMemoryDesc,
     EFIMemoryMapTag, MemoryArea, MemoryAreaType, MemoryMapTag,
@@ -335,19 +335,19 @@ impl BootInformation {
         }
     }
 
-    /// Search for the EFI 32-bit image handle pointer.
-    pub fn efi_32_ih(&self) -> Option<&EFIImageHandle32> {
-        self.get_tag::<EFIImageHandle32, _>(TagType::Efi32Ih)
+    /// 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)
     }
 
-    /// Search for the EFI 64-bit image handle pointer.
-    pub fn efi_64_ih(&self) -> Option<&EFIImageHandle64> {
-        self.get_tag::<EFIImageHandle64, _>(TagType::Efi64Ih)
+    /// 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)
     }
 
-    /// Search for the Image Load Base Physical Address.
-    pub fn load_base_addr(&self) -> Option<&ImageLoadPhysAddr> {
-        self.get_tag::<ImageLoadPhysAddr, _>(TagType::LoadBaseAddr)
+    /// Search for the Image Load Base Physical Address tag.
+    pub fn load_base_addr_tag(&self) -> Option<&ImageLoadPhysAddrTag> {
+        self.get_tag::<ImageLoadPhysAddrTag, _>(TagType::LoadBaseAddr)
     }
 
     /// Search for the VBE information tag.
@@ -374,7 +374,7 @@ impl BootInformation {
     /// However, it doesn't forbid to use custom tags. Because of this, there
     /// exists the [`TagType`] abstraction. It is recommended to use this
     /// getter only for custom tags. For specified tags, use getters, such as
-    /// [`Self::efi_64_ih`].
+    /// [`Self::efi_64_ih_tag`].
     ///
     /// ## Use Custom Tags
     /// The following example shows how you may use this interface to parse
@@ -493,8 +493,8 @@ impl fmt::Debug for BootInformation {
         }
 
         debug
-            .field("efi_32_ih", &self.efi_32_ih())
-            .field("efi_64_ih", &self.efi_64_ih())
+            .field("efi_32_ih", &self.efi_32_ih_tag())
+            .field("efi_64_ih", &self.efi_64_ih_tag())
             .field("efi_sdt_32_tag", &self.efi_sdt_32_tag())
             .field("efi_sdt_64_tag", &self.efi_sdt_64_tag())
             .field("efi_memory_map_tag", &self.efi_memory_map_tag())
diff --git a/multiboot2/src/memory_map.rs b/multiboot2/src/memory_map.rs
@@ -205,9 +205,7 @@ impl StructAsBytes for BasicMemoryInfoTag {
 const EFI_METADATA_SIZE: usize = mem::size_of::<TagTypeId>() + 3 * mem::size_of::<u32>();
 
 /// EFI memory map as per EFI specification.
-#[derive(ptr_meta::Pointee)]
-// #[derive(Debug, PartialEq, Eq)] // wait for uefi-raw 0.3.0
-#[derive(Debug)]
+#[derive(ptr_meta::Pointee, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[repr(C)]
 pub struct EFIMemoryMapTag {
     typ: TagTypeId,

Original file line number	Diff line number	Diff line change
`@@ -72,16 +72,17 @@ impl StructAsBytes for EFISdt64 {`
`72`	`72`	`}`
`73`	`73`	`}`
`74`	`74`
`75`		`-/// Contains pointer to boot loader image handle.`
	`75`	`+/// Tag that contains the pointer to the boot loader's UEFI image handle`
	`76`	`+/// (32-bit).`
`76`	`77`	`#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]`
`77`	`78`	`#[repr(C)]`
`78`		`-pub struct EFIImageHandle32 {`
	`79`	`+pub struct EFIImageHandle32Tag {`
`79`	`80`	`typ: TagTypeId,`
`80`	`81`	`size: u32,`
`81`	`82`	`pointer: u32,`
`82`	`83`	`}`
`83`	`84`
`84`		`-impl EFIImageHandle32 {`
	`85`	`+impl EFIImageHandle32Tag {`
`85`	`86`	`#[cfg(feature = "builder")]`
`86`	`87`	`pub fn new(pointer: u32) -> Self {`
`87`	`88`	`Self {`
`@@ -98,22 +99,23 @@ impl EFIImageHandle32 {`
`98`	`99`	`}`
`99`	`100`
`100`	`101`	`#[cfg(feature = "builder")]`
`101`		`-impl StructAsBytes for EFIImageHandle32 {`
	`102`	`+impl StructAsBytes for EFIImageHandle32Tag {`
`102`	`103`	`fn byte_size(&self) -> usize {`
`103`	`104`	`size_of::<Self>()`
`104`	`105`	`}`
`105`	`106`	`}`
`106`	`107`
`107`		`-/// Contains pointer to boot loader image handle.`
	`108`	`+/// Tag that contains the pointer to the boot loader's UEFI image handle`
	`109`	`+/// (64-bit).`
`108`	`110`	`#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]`
`109`	`111`	`#[repr(C)]`
`110`		`-pub struct EFIImageHandle64 {`
	`112`	`+pub struct EFIImageHandle64Tag {`
`111`	`113`	`typ: TagTypeId,`
`112`	`114`	`size: u32,`
`113`	`115`	`pointer: u64,`
`114`	`116`	`}`
`115`	`117`
`116`		`-impl EFIImageHandle64 {`
	`118`	`+impl EFIImageHandle64Tag {`
`117`	`119`	`#[cfg(feature = "builder")]`
`118`	`120`	`pub fn new(pointer: u64) -> Self {`
`119`	`121`	`Self {`
`@@ -130,15 +132,15 @@ impl EFIImageHandle64 {`
`130`	`132`	`}`
`131`	`133`
`132`	`134`	`#[cfg(feature = "builder")]`
`133`		`-impl StructAsBytes for EFIImageHandle64 {`
	`135`	`+impl StructAsBytes for EFIImageHandle64Tag {`
`134`	`136`	`fn byte_size(&self) -> usize {`
`135`	`137`	`size_of::<Self>()`
`136`	`138`	`}`
`137`	`139`	`}`
`138`	`140`
`139`	`141`	`#[cfg(all(test, feature = "builder"))]`
`140`	`142`	`mod tests {`
`141`		`- use super::{EFIImageHandle32, EFIImageHandle64, EFISdt32, EFISdt64};`
	`143`	`+ use super::{EFIImageHandle32Tag, EFIImageHandle64Tag, EFISdt32, EFISdt64};`
`142`	`144`
`143`	`145`	`const ADDR: usize = 0xABCDEF;`
`144`	`146`
`@@ -156,13 +158,13 @@ mod tests {`
`156`	`158`
`157`	`159`	`#[test]`
`158`	`160`	`fn test_build_eftih32() {`
`159`		`- let tag = EFIImageHandle32::new(ADDR.try_into().unwrap());`
	`161`	`+ let tag = EFIImageHandle32Tag::new(ADDR.try_into().unwrap());`
`160`	`162`	`assert_eq!(tag.image_handle(), ADDR);`
`161`	`163`	`}`
`162`	`164`
`163`	`165`	`#[test]`
`164`	`166`	`fn test_build_eftih64() {`
`165`		`- let tag = EFIImageHandle64::new(ADDR.try_into().unwrap());`
	`167`	`+ let tag = EFIImageHandle64Tag::new(ADDR.try_into().unwrap());`
`166`	`168`	`assert_eq!(tag.image_handle(), ADDR);`
`167`	`169`	`}`
`168`	`170`	`}`