Make MemoryType a newtype enum too, extend the set of automatic derives

Author: HadrienG2

src/data_types/enums.rs

@@ -17,8 +17,11 @@
 /// Interface a C-style enum as an integer newtype.
 ///
 /// This macro implements Debug for you, the way you would expect it to work on
-/// Rust enums (printing the variant name instead of its integer value). If you
-/// want anything else to be derived, you need to ask for it.
+/// Rust enums (printing the variant name instead of its integer value). It also
+/// derives Clone, Copy, Eq and PartialEq, since that always makes sense for
+/// C-style enums and is used by the implementation. If you want anything else
+/// to be derived, you can ask for it by adding extra derives as shown in the
+/// example below.
 ///
 /// One minor annoyance is that since variants will be translated into
 /// associated constants in a separate impl block, you need to discriminate
@@ -28,7 +31,7 @@
 /// Usage example:
 /// ```
 /// newtype_enum! {
-/// #[derive(Copy, Clone)]
+/// #[derive(Cmp, PartialCmp)]
 /// pub enum UnixBool: i32 => #[allow(missing_docs)] {
 ///     FALSE          =  0,
 ///     TRUE           =  1,
@@ -49,6 +52,7 @@ macro_rules! newtype_enum {
     ) => {
         $(#[$type_attrs])*
         #[repr(transparent)]
+        #[derive(Clone, Copy, Eq, PartialEq)]
         pub struct $type($base_integer);
 
         $(#[$impl_attrs])*

src/error/status.rs

@@ -13,7 +13,6 @@ newtype_enum! {
 /// enum, as injecting an unknown value in a Rust enum is undefined behaviour.
 ///
 /// For lack of a better option, we therefore model them as a newtype of usize.
-#[derive(Copy, Clone, Eq, PartialEq)]
 #[must_use]
 pub enum Status: usize => {
     /// The operation completed successfully.

src/proto/console/text/input.rs

@@ -64,7 +64,6 @@ newtype_enum! {
 /// Codes 0x8000 -> 0xFFFF are reserved for future OEM extensibility, therefore
 /// this C enum is _not_ safe to model as a Rust enum (where the compiler must
 /// know about all variants at compile time).
-#[derive(Copy, Clone, Eq, PartialEq)]
 pub enum ScanCode: u16 => #[allow(missing_docs)] {
     /// Null scan code, indicates that the Unicode character should be used.
     NULL        = 0x00,

src/proto/debug/mod.rs

@@ -28,7 +28,6 @@ newtype_enum! {
 /// UEFI can be and has been ported to new CPU architectures in the past,
 /// therefore modeling this C enum as a Rust enum (where the compiler must know
 /// about every variant in existence) would _not_ be safe.
-#[derive(Copy, Clone, Eq, PartialEq)]
 pub enum ProcessorArch: u32 => {
     /// 32-bit x86 PC
     X86_32      = 0x014C,

src/table/boot.rs

@@ -407,50 +407,51 @@ pub enum AllocateType {
     Address(usize),
 }
 
+newtype_enum! {
 /// The type of a memory range.
-#[derive(Debug, Copy, Clone)]
-#[repr(u32)]
-pub enum MemoryType {
+///
+/// UEFI allows firmwares and operating systems to introduce new memory types
+/// in the 0x70000000..0xFFFFFFFF range. Therefore, we don't know the full set
+/// of memory types at compile time, and it is _not_ safe to model this C enum
+/// as a Rust enum.
+pub enum MemoryType: u32 => {
     /// This enum variant is not used.
-    Reserved,
+    RESERVED                =  0,
     /// The code portions of a loaded UEFI application.
-    LoaderCode,
+    LOADER_CODE             =  1,
     /// The data portions of a loaded UEFI applications,
     /// as well as any memory allocated by it.
-    LoaderData,
+    LOADER_DATA             =  2,
     /// Code of the boot drivers.
     ///
     /// Can be reused after OS is loaded.
-    BootServicesCode,
+    BOOT_SERVICES_CODE      =  3,
     /// Memory used to store boot drivers' data.
     ///
     /// Can be reused after OS is loaded.
-    BootServicesData,
+    BOOT_SERVICES_DATA      =  4,
     /// Runtime drivers' code.
-    RuntimeServicesCode,
+    RUNTIME_SERVICES_CODE   =  5,
     /// Runtime services' code.
-    RuntimeServicesData,
+    RUNTIME_SERVICES_DATA   =  6,
     /// Free usable memory.
-    Conventional,
+    CONVENTIONAL            =  7,
     /// Memory in which errors have been detected.
-    Unusable,
+    UNUSABLE                =  8,
     /// Memory that holds ACPI tables.
     /// Can be reclaimed after they are parsed.
-    AcpiReclaim,
+    ACPI_RECLAIM            =  9,
     /// Firmware-reserved addresses.
-    AcpiNonVolatile,
+    ACPI_NON_VOLATILE       = 10,
     /// A region used for memory-mapped I/O.
-    Mmio,
+    MMIO                    = 11,
     /// Address space used for memory-mapped port I/O.
-    MmioPortSpace,
+    MMIO_PORT_SPACE         = 12,
     /// Address space which is part of the processor.
-    PalCode,
+    PAL_CODE                = 13,
     /// Memory region which is usable and is also non-volatile.
-    PersistentMemory,
-    // SAFETY: UEFI defines a MaxMemoryType, therefore adding new memory types
-    //         would be a breaking change, and exposing them as a Rust enum
-    //         seems to be safe.
-}
+    PERSISTENT_MEMORY       = 14,
+}}
 
 /// A structure describing a region of memory.
 #[derive(Debug, Copy, Clone)]
@@ -473,7 +474,7 @@ pub struct MemoryDescriptor {
 impl Default for MemoryDescriptor {
     fn default() -> MemoryDescriptor {
         MemoryDescriptor {
-            ty: MemoryType::Reserved,
+            ty: MemoryType::RESERVED,
             padding: 0,
             phys_start: 0,
             virt_start: 0,

uefi-alloc/src/lib.rs

@@ -42,7 +42,7 @@ pub struct Allocator;
 
 unsafe impl GlobalAlloc for Allocator {
     unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
-        let mem_ty = MemoryType::LoaderData;
+        let mem_ty = MemoryType::LOADER_DATA;
         let size = layout.size();
         let align = layout.align();
 

uefi-test-runner/src/boot/memory.rs

@@ -17,7 +17,7 @@ fn allocate_pages(bt: &BootServices) {
     info!("Allocating some pages of memory");
 
     let ty = AllocateType::AnyPages;
-    let mem_ty = MemoryType::LoaderData;
+    let mem_ty = MemoryType::LOADER_DATA;
     let pgs = bt
         .allocate_pages(ty, mem_ty, 1)
         .expect("Failed to allocate a page of memory");