Method read_virtual_memory_page

src/kdmp/parser.rs:316–393

(
        &self,
        pml4: PhysicalAddress,
        virt_addr: VirtualAddress,
    )

    }

    fn read_virtual_memory_page(
        &self,
        pml4: PhysicalAddress,
        virt_addr: VirtualAddress,
    ) -> Result<&[u8], PageError> {
        let page_frame_number = PageEntry::from(pml4.addr).get_page_frame_number();
        let pml4_base = PhysicalAddress::from(page_frame_number << 12);
        let pml4_offset = virt_addr.get_pml4_offset();

        let level4_entry_address = PhysicalAddress::from(pml4_base.addr + pml4_offset);

        let level4_entry_data = self.read_physical_memory(level4_entry_address, 0x8)?;
        let level4_entry = u64::from_le_bytes(level4_entry_data.try_into().unwrap());

        let pml4_entry = PageEntry::from(level4_entry);

        if !pml4_entry.is_present() {
            println!("Error level 4");
            return Err(PageError::PageNotInDump);
        }

        let pdpt_base = PhysicalAddress::from(pml4_entry.get_page_frame_number() << 12);
        let pdpt_offset = virt_addr.get_pdpt_offset();

        let pdpt_entry_address = PhysicalAddress::from(pdpt_base.addr + pdpt_offset);
        let pdpt_entry_data = self.read_physical_memory(pdpt_entry_address, 0x8)?;
        let pdpt_entry = u64::from_le_bytes(pdpt_entry_data.try_into().unwrap());

        let pdpt_entry = PageEntry::from(pdpt_entry);

        if !pdpt_entry.is_present() {
            println!("Error level 3");
            return Err(PageError::PageNotInDump);
        }

        let pdt_base = PhysicalAddress::from(pdpt_entry.get_page_frame_number() << 12);
        let pdt_offset = virt_addr.get_pdt_offset();

        let pdt_entry_address = PhysicalAddress::from(pdt_base.addr + pdt_offset);
        let pdt_entry_data = self.read_physical_memory(pdt_entry_address, 0x8)?;
        let pdt_entry = u64::from_le_bytes(pdt_entry_data.try_into().unwrap());

        let pdt_entry = PageEntry::from(pdt_entry);

        if !pdt_entry.is_present() {
            println!("Error level 2");
            return Err(PageError::PageNotInDump);
        }

        if pdt_entry.is_large_page() {
            let pt_base = PhysicalAddress::from(pdt_entry.get_page_frame_number() << 12);
            let pt_offset = virt_addr.get_large_page_offset();

            let pt_entry_address = PhysicalAddress::from((pt_base.addr + pt_offset) & !0xFFF);
            let pt_entry_data = self.read_physical_memory(pt_entry_address, PAGE_SIZE)?;

            return Ok(pt_entry_data);
        }