devpath 1.0.1

UEFI Device Path parsing library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

//! Memory Mapped Device Path
//!
//! This module implements the Memory Mapped device path node as defined in UEFI 2.11 specification
//! section 10.3.1.3. This device path describes a range of memory mapped I/O addresses.

use crate::parser::{ByteOrder, Invalid, Parser};
use crate::{Error, Head};

/// Memory types as defined in the UEFI specification
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum MemoryType {
    /// Reserved memory type
    Reserved,

    /// Loader code memory
    LoaderCode,

    /// Loader data memory
    LoaderData,

    /// Boot services code memory
    BootServicesCode,

    /// Boot services data memory
    BootServicesData,

    /// Runtime services code memory
    RuntimeServicesCode,

    /// Runtime services data memory
    RuntimeServicesData,

    /// Conventional memory
    ConventionalMemory,

    /// Unusable memory
    UnusableMemory,

    /// `ACPI` reclaimable memory
    AcpiReclaimMemory,

    /// `ACPI` memory `NVS`
    AcpiMemoryNvs,

    /// Memory mapped I/O
    MemoryMappedIo,

    /// Memory mapped I/O port space
    MemoryMappedIoPortSpace,

    /// `PAL` code memory
    PalCode,

    /// Persistent memory
    PersistentMemory,

    /// Unaccepted memory
    UnacceptedMemory,

    /// Maximum memory type
    MaxMemory,
}

impl Parser<MemoryType> for &[u8] {
    type Arg = ByteOrder;

    fn parse(&mut self, arg: Self::Arg) -> Result<MemoryType, Invalid> {
        match self.parse(arg)? {
            0u32 => Ok(MemoryType::Reserved),
            1 => Ok(MemoryType::LoaderCode),
            2 => Ok(MemoryType::LoaderData),
            3 => Ok(MemoryType::BootServicesCode),
            4 => Ok(MemoryType::BootServicesData),
            5 => Ok(MemoryType::RuntimeServicesCode),
            6 => Ok(MemoryType::RuntimeServicesData),
            7 => Ok(MemoryType::ConventionalMemory),
            8 => Ok(MemoryType::UnusableMemory),
            9 => Ok(MemoryType::AcpiReclaimMemory),
            10 => Ok(MemoryType::AcpiMemoryNvs),
            11 => Ok(MemoryType::MemoryMappedIo),
            12 => Ok(MemoryType::MemoryMappedIoPortSpace),
            13 => Ok(MemoryType::PalCode),
            14 => Ok(MemoryType::PersistentMemory),
            15 => Ok(MemoryType::UnacceptedMemory),
            16 => Ok(MemoryType::MaxMemory),
            _ => Err(Invalid),
        }
    }
}

/// Memory Mapped Device Path (SubType 0x03)
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct MemMap {
    /// The memory type
    pub kind: MemoryType,

    /// Starting memory address
    pub start: u64,

    /// Ending memory address
    pub end: u64,
}

impl<'a> TryFrom<Head<'a>> for MemMap {
    type Error = Error;

    fn try_from(mut node: Head<'a>) -> Result<Self, Self::Error> {
        Ok(Self {
            kind: node.data.parse(ByteOrder::Little)?,
            start: node.data.parse(ByteOrder::Little)?,
            end: node.data.finish(ByteOrder::Little)?,
        })
    }
}