Use rmm::PhysicalAddress and rmm::VirtualAddress directly

src/arch/x86_64/device/ioapic.rs

@@ -241,7 +241,7 @@ pub unsafe fn handle_ioapic(active_table: &mut ActivePageTable, madt_ioapic: &'s
     let result = active_table.map_to(page, frame, EntryFlags::PRESENT | EntryFlags::GLOBAL | EntryFlags::WRITABLE | EntryFlags::NO_CACHE);
     result.flush(active_table);
 
-    let ioapic_registers = page.start_address().get() as *const u32;
+    let ioapic_registers = page.start_address().data() as *const u32;
     let ioapic = IoApic::new(ioapic_registers, madt_ioapic.gsi_base);
 
     assert_eq!(ioapic.regs.lock().id(), madt_ioapic.id, "mismatched ACPI MADT I/O APIC ID, and the ID reported by the I/O APIC");

src/arch/x86_64/graphical_debug/mod.rs

@@ -45,7 +45,7 @@ pub fn init(active_table: &mut ActivePageTable) {
             let start_page = Page::containing_address(VirtualAddress::new(onscreen));
             let end_page = Page::containing_address(VirtualAddress::new(onscreen + size * 4));
             for page in Page::range_inclusive(start_page, end_page) {
-                let frame = Frame::containing_address(PhysicalAddress::new(page.start_address().get() - crate::KERNEL_OFFSET));
+                let frame = Frame::containing_address(PhysicalAddress::new(page.start_address().data() - crate::KERNEL_OFFSET));
                 let flags = EntryFlags::PRESENT | EntryFlags::NO_EXECUTE | EntryFlags::WRITABLE | EntryFlags::HUGE_PAGE;
                 let result = active_table.map_to(page, frame, flags);
                 flush_all.consume(result);

src/arch/x86_64/paging/entry.rs

@@ -63,8 +63,8 @@ impl Entry {
     }
 
     pub fn set(&mut self, frame: Frame, flags: EntryFlags) {
-        debug_assert!(frame.start_address().get() & !ADDRESS_MASK == 0);
-        self.0 = (frame.start_address().get() as u64) | flags.bits() | (self.0 & COUNTER_MASK);
+        debug_assert!(frame.start_address().data() & !ADDRESS_MASK == 0);
+        self.0 = (frame.start_address().data() as u64) | flags.bits() | (self.0 & COUNTER_MASK);
     }
 
     /// Get bits 52-61 in entry, used as counter for page table

src/arch/x86_64/paging/mapper.rs

@@ -105,9 +105,9 @@ impl Mapper {
 
         assert!(p1[page.p1_index()].is_unused(),
             "{:X}: Set to {:X}: {:?}, requesting {:X}: {:?}",
-            page.start_address().get(),
-            p1[page.p1_index()].address().get(), p1[page.p1_index()].flags(),
-            frame.start_address().get(), flags);
+            page.start_address().data(),
+            p1[page.p1_index()].address().data(), p1[page.p1_index()].flags(),
+            frame.start_address().data(), flags);
         p1.increment_entry_count();
         p1[page.p1_index()].set(frame, flags | EntryFlags::PRESENT);
         MapperFlush::new(page)
@@ -131,7 +131,7 @@ impl Mapper {
 
     /// Identity map a frame
     pub fn identity_map(&mut self, frame: Frame, flags: EntryFlags) -> MapperFlush {
-        let page = Page::containing_address(VirtualAddress::new(frame.start_address().get()));
+        let page = Page::containing_address(VirtualAddress::new(frame.start_address().data()));
         self.map_to(page, frame, flags)
     }
 
@@ -145,7 +145,7 @@ impl Mapper {
                     frame = if let Some(frame) = p1[page.p1_index()].pointed_frame() {
                         frame
                     } else {
-                        panic!("unmap_inner({:X}): frame not found", page.start_address().get())
+                        panic!("unmap_inner({:X}): frame not found", page.start_address().data())
                     };
 
                     p1.decrement_entry_count();
@@ -155,7 +155,7 @@ impl Mapper {
                         return frame;
                     }
                 } else {
-                    panic!("unmap_inner({:X}): p1 not found", page.start_address().get());
+                    panic!("unmap_inner({:X}): p1 not found", page.start_address().data());
                 }
 
                 if let Some(p1_frame) = p2[page.p2_index()].pointed_frame() {
@@ -164,14 +164,14 @@ impl Mapper {
                     p2[page.p2_index()].set_unused();
                     deallocate_frames(p1_frame, 1);
                 } else {
-                    panic!("unmap_inner({:X}): p1_frame not found", page.start_address().get());
+                    panic!("unmap_inner({:X}): p1_frame not found", page.start_address().data());
                 }
 
                 if ! p2.is_unused() {
                     return frame;
                 }
             } else {
-                panic!("unmap_inner({:X}): p2 not found", page.start_address().get());
+                panic!("unmap_inner({:X}): p2 not found", page.start_address().data());
             }
 
             if let Some(p2_frame) = p3[page.p3_index()].pointed_frame() {
@@ -180,14 +180,14 @@ impl Mapper {
                 p3[page.p3_index()].set_unused();
                 deallocate_frames(p2_frame, 1);
             } else {
-                panic!("unmap_inner({:X}): p2_frame not found", page.start_address().get());
+                panic!("unmap_inner({:X}): p2_frame not found", page.start_address().data());
             }
 
             if ! p3.is_unused() {
                 return frame;
             }
         } else {
-            panic!("unmap_inner({:X}): p3 not found", page.start_address().get());
+            panic!("unmap_inner({:X}): p3 not found", page.start_address().data());
         }
 
         if let Some(p3_frame) = p4[page.p4_index()].pointed_frame() {
@@ -196,7 +196,7 @@ impl Mapper {
             p4[page.p4_index()].set_unused();
             deallocate_frames(p3_frame, 1);
         } else {
-            panic!("unmap_inner({:X}): p3_frame not found", page.start_address().get());
+            panic!("unmap_inner({:X}): p3_frame not found", page.start_address().data());
         }
 
         frame
@@ -231,8 +231,8 @@ impl Mapper {
 
     /// Translate a virtual address to a physical one
     pub fn translate(&self, virtual_address: VirtualAddress) -> Option<PhysicalAddress> {
-        let offset = virtual_address.get() % PAGE_SIZE;
+        let offset = virtual_address.data() % PAGE_SIZE;
         self.translate_page(Page::containing_address(virtual_address))
-            .map(|frame| PhysicalAddress::new(frame.start_address().get() + offset))
+            .map(|frame| PhysicalAddress::new(frame.start_address().data() + offset))
     }
 }

src/arch/x86_64/paging/mod.rs

@@ -12,6 +12,8 @@ use self::entry::EntryFlags;
 use self::mapper::{Mapper, MapperFlushAll};
 use self::temporary_page::TemporaryPage;
 
+pub use rmm::{PhysicalAddress, VirtualAddress};
+
 pub mod entry;
 pub mod mapper;
 pub mod table;
@@ -262,14 +264,14 @@ impl ActivePageTable {
             )),
         };
         unsafe {
-            controlregs::cr3_write(new_table.p4_frame.start_address().get() as u64);
+            controlregs::cr3_write(new_table.p4_frame.start_address().data() as u64);
         }
         old_table
     }
 
     pub fn flush(&mut self, page: Page) {
         unsafe {
-            tlb::flush(page.start_address().get());
+            tlb::flush(page.start_address().data());
         }
     }
 
@@ -370,35 +372,7 @@ impl InactivePageTable {
     }
 
     pub unsafe fn address(&self) -> usize {
-        self.p4_frame.start_address().get()
-    }
-}
-
-/// A physical address.
-#[derive(Copy, Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
-pub struct PhysicalAddress(usize);
-
-impl PhysicalAddress {
-    pub fn new(address: usize) -> Self {
-        PhysicalAddress(address)
-    }
-
-    pub fn get(&self) -> usize {
-        self.0
-    }
-}
-
-/// A virtual address.
-#[derive(Copy, Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
-pub struct VirtualAddress(usize);
-
-impl VirtualAddress {
-    pub fn new(address: usize) -> Self {
-        VirtualAddress(address)
-    }
-
-    pub fn get(&self) -> usize {
-        self.0
+        self.p4_frame.start_address().data()
     }
 }
 
@@ -430,10 +404,10 @@ impl Page {
     }
 
     pub fn containing_address(address: VirtualAddress) -> Page {
-        //TODO assert!(address.get() < 0x0000_8000_0000_0000 || address.get() >= 0xffff_8000_0000_0000,
-        //    "invalid address: 0x{:x}", address.get());
+        //TODO assert!(address.data() < 0x0000_8000_0000_0000 || address.data() >= 0xffff_8000_0000_0000,
+        //    "invalid address: 0x{:x}", address.data());
         Page {
-            number: address.get() / PAGE_SIZE,
+            number: address.data() / PAGE_SIZE,
         }
     }
 

src/arch/x86_64/paging/temporary_page.rs

@@ -32,7 +32,7 @@ impl TemporaryPage {
     /// Maps the temporary page to the given page table frame in the active
     /// table. Returns a reference to the now mapped table.
     pub fn map_table_frame(&mut self, frame: Frame, flags: EntryFlags, active_table: &mut ActivePageTable) -> &mut Table<Level1> {
-        unsafe { &mut *(self.map(frame, flags, active_table).get() as *mut Table<Level1>) }
+        unsafe { &mut *(self.map(frame, flags, active_table).data() as *mut Table<Level1>) }
     }
 
     /// Unmaps the temporary page in the active table.