Define the next_table methods only for P4, P3, and P2 tables

src/memory/paging/table.rs

@@ -1,20 +1,26 @@
 use memory::paging::entry::*;
 use memory::paging::ENTRY_COUNT;
 use core::ops::{Index, IndexMut};
+use core::marker::PhantomData;
 
-pub const P4: *mut Table = 0xffffffff_fffff000 as *mut _;
+pub const P4: *mut Table<Level4> = 0xffffffff_fffff000 as *mut _;
 
-pub struct Table {
+pub struct Table<L: TableLevel> {
     entries: [Entry; ENTRY_COUNT],
+    level: PhantomData<L>,
 }
 
-impl Table {
+impl<L> Table<L> where L: TableLevel
+{
     pub fn zero(&mut self) {
         for entry in self.entries.iter_mut() {
             entry.set_unused();
         }
     }
+}
 
+impl<L> Table<L> where L: HierachicalLevel
+{
     fn next_table_address(&self, index: usize) -> Option<usize> {
         let entry_flags = self[index].flags();
         if entry_flags.contains(PRESENT) && !entry_flags.contains(HUGE_PAGE) {
@@ -25,18 +31,19 @@ impl Table {
         }
     }
 
-    pub unsafe fn next_table(&self, index: usize) -> Option<&Table> {
+    pub fn next_table(&self, index: usize) -> Option<&Table<L::NextLevel>> {
         self.next_table_address(index)
             .map(|t| unsafe { &*(t as *const _) })
     }
 
-    pub unsafe fn next_table_mut(&mut self, index: usize) -> Option<&mut Table> {
+    pub fn next_table_mut(&mut self, index: usize) -> Option<&mut Table<L::NextLevel>> {
         self.next_table_address(index)
             .map(|t| unsafe { &mut *(t as *mut _) })
     }
 }
 
-impl Index<usize> for Table {
+impl<L> Index<usize> for Table<L> where L: TableLevel
+{
     type Output = Entry;
 
     fn index(&self, index: usize) -> &Entry {
@@ -44,8 +51,37 @@ impl Index<usize> for Table {
     }
 }
 
-impl IndexMut<usize> for Table {
+impl<L> IndexMut<usize> for Table<L> where L: TableLevel
+{
     fn index_mut(&mut self, index: usize) -> &mut Entry {
         &mut self.entries[index]
     }
 }
+
+pub trait TableLevel {}
+
+pub enum Level4 {}
+enum Level3 {}
+enum Level2 {}
+enum Level1 {}
+
+impl TableLevel for Level4 {}
+impl TableLevel for Level3 {}
+impl TableLevel for Level2 {}
+impl TableLevel for Level1 {}
+
+trait HierachicalLevel: TableLevel {
+    type NextLevel: TableLevel;
+}
+
+impl HierachicalLevel for Level4 {
+    type NextLevel = Level3;
+}
+
+impl HierachicalLevel for Level3 {
+    type NextLevel = Level2;
+}
+
+impl HierachicalLevel for Level2 {
+    type NextLevel = Level1;
+}