Add more EFI tables and their search functions.

src/lib.rs

@@ -30,9 +30,15 @@ pub use elf_sections::{
 };
 pub use framebuffer::{FramebufferColor, FramebufferField, FramebufferTag, FramebufferType};
 use header::{Tag, TagIter};
-pub use memory_map::{EFIMemoryAreaType, EFIMemoryMapTag, EFIMemoryDesc, MemoryArea, MemoryAreaIter, MemoryAreaType, MemoryMapTag};
+pub use memory_map::{
+    EFIMemoryAreaType, EFIMemoryMapTag, EFIMemoryDesc, MemoryArea, MemoryAreaIter,
+    MemoryAreaType, MemoryMapTag,
+};
 pub use module::{ModuleIter, ModuleTag};
-pub use rsdp::{EFISdt32, EFISdt64, RsdpV1Tag, RsdpV2Tag};
+pub use rsdp::{
+    EFIImageHandle32, EFIImageHandle64, EFISdt32, EFISdt64, ImageLoadPhysAddr, 
+    RsdpV1Tag, RsdpV2Tag,
+};
 pub use vbe_info::{
     VBECapabilities, VBEControlInfo, VBEDirectColorAttributes, VBEField, VBEInfoTag,
     VBEMemoryModel, VBEModeAttributes, VBEModeInfo, VBEWindowAttributes,
@@ -172,10 +178,16 @@ impl BootInformation {
 
     /// Search for the EFI 32-bit SDT tag.
     pub fn efi_sdt_32_tag<'a>(&self) -> Option<&'a EFISdt32> {
-        self.get_tag(12)
+        self.get_tag(11)
             .map(|tag| unsafe { &*(tag as *const Tag as *const EFISdt32) })
     }
 
+    /// Search for the EFI 64-bit SDT tag.
+    pub fn efi_sdt_64_tag<'a>(&self) -> Option<&'a EFISdt64> {
+        self.get_tag(12)
+            .map(|tag| unsafe { &*(tag as *const Tag as *const EFISdt64) })
+    }
+
     /// Search for the (ACPI 1.0) RSDP tag.
     pub fn rsdp_v1_tag<'a>(&self) -> Option<&'a RsdpV1Tag> {
         self.get_tag(14)
@@ -190,15 +202,35 @@ impl BootInformation {
 
     /// Search for the EFI Memory map tag.
     pub fn efi_memory_map_tag<'a>(&'a self) -> Option<&'a EFIMemoryMapTag> {
+        // If the EFIBootServicesNotExited is present, then we should not use
+        // the memory map, as it could still be in use.
         match self.get_tag(18) {
-            Some(_) => {
+            Some(_tag) => None,
+            None => {
                 self.get_tag(17)
                     .map(|tag| unsafe { &*(tag as *const Tag as *const EFIMemoryMapTag) })
-            }, 
-            None => None
+            },
         }
     }
 
+    /// Search for the EFI 32-bit image handle pointer.
+    pub fn efi_32_ih<'a>(&'a self) -> Option<&'a EFIImageHandle32> {
+        self.get_tag(19)
+            .map(|tag| unsafe { &*(tag as *const Tag as *const EFIImageHandle32) })
+    }
+
+    /// Search for the EFI 64-bit image handle pointer.
+    pub fn efi_64_ih<'a>(&'a self) -> Option<&'a EFIImageHandle64> {
+        self.get_tag(20)
+            .map(|tag| unsafe { &*(tag as *const Tag as *const EFIImageHandle64) })
+    }
+
+    /// Search for the Image Load Base Physical Address.
+    pub fn load_base_addr<'a>(&'a self) -> Option<&'a ImageLoadPhysAddr> {
+        self.get_tag(21)
+            .map(|tag| unsafe { &*(tag as *const Tag as *const ImageLoadPhysAddr) })
+    }
+
     /// Search for the VBE information tag.
     pub fn vbe_info_tag(&self) -> Option<&'static VBEInfoTag> {
         self.get_tag(7)

src/memory_map.rs

@@ -221,8 +221,8 @@ impl EFIMemoryDesc {
     }
 
     /// The size in bytes of the memory region.
-    pub fn size(&self, page_size: u64) -> usize {
-        (self.num_pages * page_size) as usize
+    pub fn size(&self, page_size: u64) -> u64 {
+        self.num_pages * page_size
     }
 
     /// The type of the memory region.
@@ -256,35 +256,8 @@ pub struct EFIBootServicesNotExited {
     size: u32,
 }
 
-/// Contains pointer to boot loader image handle.
-#[derive(Debug)]
-#[repr(C)]
-pub struct EFIImageHandle32 {
-    typ: u32,
-    size: u32,
-    pointer: u32,
-}
 
-/// Contains pointer to boot loader image handle.
-#[derive(Debug)]
-#[repr(C)]
-pub struct EFIImageHandle64 {
-    typ: u32,
-    size: u32,
-    pointer: u64,
-}
-
-/// If the image has relocatable header tag, this tag contains the image's 
-/// base physical address.
-#[derive(Debug)]
-#[repr(C)]
-pub struct ImageLoadPhysAddr {
-    typ: u32,
-    size: u32,
-    load_base_addr: u32,
-}
-
-/// An iterator over All EFI memory areas.
+/// An iterator over ALL EFI memory areas.
 #[derive(Clone, Debug)]
 pub struct EFIMemoryAreaIter<'a> {
     current_area: u64,
@@ -301,9 +274,7 @@ impl<'a> Iterator for EFIMemoryAreaIter<'a> {
         } else {
             let area = unsafe{&*(self.current_area as *const EFIMemoryDesc)};
             self.current_area = self.current_area + (self.entry_size as u64);
-            if area.typ() == EFIMemoryAreaType::EfiConventionalMemory {
-                Some(area)
-            } else {self.next()}
+            Some(area)
         }
     }
 }

src/rsdp.rs

@@ -43,6 +43,34 @@ impl EFISdt64 {
     }
 }
 
+/// Contains pointer to boot loader image handle.
+#[derive(Debug)]
+#[repr(C)]
+pub struct EFIImageHandle32 {
+    typ: u32,
+    size: u32,
+    pointer: u32,
+}
+
+/// Contains pointer to boot loader image handle.
+#[derive(Debug)]
+#[repr(C)]
+pub struct EFIImageHandle64 {
+    typ: u32,
+    size: u32,
+    pointer: u64,
+}
+
+/// If the image has relocatable header tag, this tag contains the image's 
+/// base physical address.
+#[derive(Debug)]
+#[repr(C)]
+pub struct ImageLoadPhysAddr {
+    typ: u32,
+    size: u32,
+    load_base_addr: u32,
+}
+
 /// This tag contains a copy of RSDP as defined per ACPI 1.0 specification. 
 #[derive(Clone, Copy, Debug)]
 #[repr(C, packed)]