uefi: use MemoryMap::from_raw everywhere and don't create it explicitly

Unify the construction.

Author: phip1611

uefi/src/table/boot.rs

@@ -262,16 +262,7 @@ impl BootServices {
                 &mut entry_version,
             )
         }
-        .to_result_with_val(move || {
-            let len = map_size / desc_size;
-
-            MemoryMap {
-                key: map_key,
-                buf: buffer,
-                desc_size,
-                len,
-            }
-        })
+        .to_result_with_val(move || MemoryMap::from_raw(map_size, buffer, desc_size, map_key))
     }
 
     /// Allocates from a memory pool. The pointer will be 8-byte aligned.
@@ -1640,40 +1631,46 @@ pub struct MemoryMapSize {
 /// always use `entry_size` as step-size when interfacing with the memory map on
 /// a low level.
 ///
-///
-///
 /// [0]: https://github.com/tianocore/edk2/blob/7142e648416ff5d3eac6c6d607874805f5de0ca8/MdeModulePkg/Core/PiSmmCore/Page.c#L1059
 #[derive(Debug)]
 pub struct MemoryMap<'buf> {
     key: MemoryMapKey,
+    /// The backing memory. Might be slightly larger than the actual map.
     buf: &'buf mut [u8],
     /// Usually bound to the size of a [`MemoryDescriptor`] but can indicate if
     /// this field is ever extended by a new UEFI standard.
     desc_size: usize,
-    len: usize,
+    map_size: usize,
+    num_entries: usize,
 }
 
 impl<'buf> MemoryMap<'buf> {
-    /// Creates a [`MemoryMap`] from the given buffer and entry size.
-    /// The entry size is usually bound to the size of a [`MemoryDescriptor`]
-    /// but can indicate if this field is ever extended by a new UEFI standard.
-    ///
-    /// This allows parsing a memory map provided by a kernel after boot
-    /// services have already exited.
-    pub fn from_raw(buf: &'buf mut [u8], desc_size: usize) -> Self {
+    /// Creates a [`MemoryMap`] from the given buffer, and the reported
+    /// memory map size, descriptor size, and [`MemoryMapKey`] from UEFI.
+    ///
+    /// This map technically owns the buffer (although not modeled yet by type
+    /// system).
+    pub fn from_raw(
+        map_size: usize,
+        buf: &'buf mut [u8],
+        desc_size: usize,
+        key: MemoryMapKey,
+    ) -> Self {
         assert!(!buf.is_empty());
+        assert!(map_size <= buf.len());
         assert_eq!(
             buf.len() % desc_size,
             0,
             "The buffer length must be a multiple of the desc_size"
         );
         assert!(desc_size >= mem::size_of::<MemoryDescriptor>());
-        let len = buf.len() / desc_size;
+        let num_entries = map_size / desc_size;
         MemoryMap {
-            key: MemoryMapKey(0),
+            key,
             buf,
+            map_size,
             desc_size,
-            len,
+            num_entries,
         }
     }
 
@@ -1687,7 +1684,7 @@ impl<'buf> MemoryMap<'buf> {
     /// This operation is optional and should be invoked only once.
     pub fn sort(&mut self) {
         unsafe {
-            self.qsort(0, self.len - 1);
+            self.qsort(0, self.num_entries - 1);
         }
     }
 
@@ -1772,7 +1769,7 @@ impl<'buf> MemoryMap<'buf> {
     /// Returns a reference to the [`MemoryDescriptor`] at `index` or `None` if out of bounds.
     #[must_use]
     pub fn get(&self, index: usize) -> Option<&'buf MemoryDescriptor> {
-        if index >= self.len {
+        if index >= self.num_entries {
             return None;
         }
 
@@ -1790,7 +1787,7 @@ impl<'buf> MemoryMap<'buf> {
     /// Returns a mut reference to the [`MemoryDescriptor`] at `index` or `None` if out of bounds.
     #[must_use]
     pub fn get_mut(&mut self, index: usize) -> Option<&'buf mut MemoryDescriptor> {
-        if index >= self.len {
+        if index >= self.num_entries {
             return None;
         }
 
@@ -1832,7 +1829,7 @@ impl<'buf> Iterator for MemoryMapIter<'buf> {
     type Item = &'buf MemoryDescriptor;
 
     fn size_hint(&self) -> (usize, Option<usize>) {
-        let sz = self.memory_map.len - self.index;
+        let sz = self.memory_map.num_entries - self.index;
 
         (sz, Some(sz))
     }
@@ -1848,7 +1845,7 @@ impl<'buf> Iterator for MemoryMapIter<'buf> {
 
 impl ExactSizeIterator for MemoryMapIter<'_> {
     fn len(&self) -> usize {
-        self.memory_map.len
+        self.memory_map.num_entries
     }
 }
 
@@ -1980,6 +1977,7 @@ pub struct ProtocolSearchKey(NonNull<c_void>);
 #[cfg(test)]
 mod tests {
     use core::mem::{size_of, size_of_val};
+    use uefi::table::boot::MemoryMapKey;
 
     use crate::table::boot::{MemoryAttribute, MemoryMap, MemoryType};
 
@@ -1992,7 +1990,7 @@ mod tests {
             }
         };
 
-        MemoryMap::from_raw(byte_buffer, size_of::<MemoryDescriptor>())
+        MemoryMap::from_raw(byte_buffer.len(), byte_buffer, size_of::<MemoryDescriptor>(), MemoryMapKey(0))
     }
 
     #[test]