Pass root_n

zpzigi754 · zpzigi754 · commit a0526232ee9f · 2024-07-15T14:59:20.000+09:00
diff --git a/rmm/src/mm/page_table/entry.rs b/rmm/src/mm/page_table/entry.rs
@@ -108,7 +108,7 @@ impl page_table::Entry for Entry {
         }
     }
 
-    fn index_with_level(addr: usize, level: usize, _is_root: bool) -> usize {
+    fn index_with_level(addr: usize, level: usize, _is_root: bool, _root_n: usize) -> usize {
         match level {
             0 => RawGPA::from(addr).get_masked_value(RawGPA::L0Index) as usize,
             1 => RawGPA::from(addr).get_masked_value(RawGPA::L1Index) as usize,
diff --git a/rmm/src/mm/translation.rs b/rmm/src/mm/translation.rs
@@ -136,7 +136,7 @@ impl<'a> Inner<'a> {
 
         if self
             .root_pgtlb
-            .set_pages(1, virtaddr, phyaddr, flags, false)
+            .set_pages(1, virtaddr, phyaddr, flags, false, 1)
             .is_err()
         {
             warn!("set_pages error");
@@ -146,7 +146,7 @@ impl<'a> Inner<'a> {
     fn unset_page(&mut self, addr: usize) {
         let va = VirtAddr::from(addr);
         let page = Page::<BasePageSize, VirtAddr>::including_address(va);
-        self.root_pgtlb.unset_page(1, page);
+        self.root_pgtlb.unset_page(1, page, 1);
     }
 
     fn set_pages_for_rmi(&mut self, addr: usize, secure: bool) -> bool {
diff --git a/rmm/src/realm/mm/page_table/entry.rs b/rmm/src/realm/mm/page_table/entry.rs
@@ -113,11 +113,11 @@ impl page_table::Entry for Entry {
         }
     }
 
-    fn index_with_level(addr: usize, level: usize, is_root: bool) -> usize {
+    fn index_with_level(addr: usize, level: usize, is_root: bool, root_n: usize) -> usize {
         match level {
             0 => RawGPA::from(addr).get_masked_value(RawGPA::L0Index) as usize,
             1 => {
-                if is_root {
+                if is_root && root_n > 1 {
                     // We know that refering one direct parent table is enough
                     // because concatenation of the initial lookup table is upto 16.
                     let l0 = RawGPA::from(addr).get_masked_value(RawGPA::L0Index) as usize;
@@ -129,7 +129,7 @@ impl page_table::Entry for Entry {
                 }
             }
             2 => {
-                if is_root {
+                if is_root && root_n > 1 {
                     let l1 = RawGPA::from(addr).get_masked_value(RawGPA::L1Index) as usize;
                     let l2 = RawGPA::from(addr).get_masked_value(RawGPA::L2Index) as usize;
                     l1 * L3Table::NUM_ENTRIES + l2
diff --git a/rmm/src/realm/mm/stage2_translation.rs b/rmm/src/realm/mm/stage2_translation.rs
@@ -39,14 +39,14 @@ type RootTBL<'a, const L: usize, const N: usize, const E: usize> =
     &'a mut PageTable<GuestPhysAddr, entry::Entry, { E }>;
 
 pub enum Root<'a> {
-    L0N1(RootTBL<'a, 0, 1, ENTR1>, usize),
-    L0N16(RootTBL<'a, 0, 16, ENTR16>, usize),
-    L1N1(RootTBL<'a, 1, 1, ENTR1>, usize),
-    L1N2(RootTBL<'a, 1, 2, ENTR2>, usize),
-    L1N8(RootTBL<'a, 1, 8, ENTR8>, usize),
-    L2N4(RootTBL<'a, 2, 4, ENTR4>, usize),
-    L2N8(RootTBL<'a, 2, 8, ENTR8>, usize),
-    L2N16(RootTBL<'a, 2, 16, ENTR16>, usize),
+    L0N1(RootTBL<'a, 0, 1, ENTR1>, usize, usize),
+    L0N16(RootTBL<'a, 0, 16, ENTR16>, usize, usize),
+    L1N1(RootTBL<'a, 1, 1, ENTR1>, usize, usize),
+    L1N2(RootTBL<'a, 1, 2, ENTR2>, usize, usize),
+    L1N8(RootTBL<'a, 1, 8, ENTR8>, usize, usize),
+    L2N4(RootTBL<'a, 2, 4, ENTR4>, usize, usize),
+    L2N8(RootTBL<'a, 2, 8, ENTR8>, usize, usize),
+    L2N16(RootTBL<'a, 2, 16, ENTR16>, usize, usize),
 }
 
 #[macro_export]
@@ -77,24 +77,24 @@ impl<'a> Stage2Translation<'a> {
         let root_pgtlb = match root_level {
             0 => unsafe {
                 match root_pages {
-                    1 => Root::L0N1(init_table!(0, 1, rtt_base), 0),
-                    16 => Root::L0N16(init_table!(0, 16, rtt_base), 0),
+                    1 => Root::L0N1(init_table!(0, 1, rtt_base), 0, 1),
+                    16 => Root::L0N16(init_table!(0, 16, rtt_base), 0, 16),
                     _ => todo!(),
                 }
             },
             1 => unsafe {
                 match root_pages {
-                    1 => Root::L1N1(init_table!(1, 1, rtt_base), 1),
-                    2 => Root::L1N2(init_table!(1, 2, rtt_base), 1),
-                    8 => Root::L1N8(init_table!(1, 8, rtt_base), 1),
+                    1 => Root::L1N1(init_table!(1, 1, rtt_base), 1, 1),
+                    2 => Root::L1N2(init_table!(1, 2, rtt_base), 1, 2),
+                    8 => Root::L1N8(init_table!(1, 8, rtt_base), 1, 8),
                     _ => todo!(),
                 }
             },
             2 => unsafe {
                 match root_pages {
-                    4 => Root::L2N4(init_table!(2, 4, rtt_base), 2),
-                    8 => Root::L2N8(init_table!(2, 8, rtt_base), 2),
-                    16 => Root::L2N16(init_table!(2, 16, rtt_base), 2),
+                    4 => Root::L2N4(init_table!(2, 4, rtt_base), 2, 4),
+                    8 => Root::L2N8(init_table!(2, 8, rtt_base), 2, 8),
+                    16 => Root::L2N16(init_table!(2, 16, rtt_base), 2, 16),
                     _ => todo!(),
                 }
             },
@@ -159,46 +159,46 @@ impl<'a> MemAlloc for Stage2Translation<'a> {
 #[macro_export]
 // ipa_to_pa closure
 macro_rules! to_pa {
-    ($root:expr, $guest:expr, $level:expr, $pa:expr, $root_level:expr) => {
+    ($root:expr, $guest:expr, $level:expr, $pa:expr, $root_level:expr, $root_n:expr) => {
         $root.entry($root_level, $guest, $level, false, |entry| {
             $pa = entry.address(0);
             Ok(None)
-        }, true)
+        }, true, $root_n)
     };
 }
 
 // ipa_to_pa closure
 macro_rules! to_pte {
-    ($root:expr, $guest:expr, $level:expr, $pte:expr, $root_level:expr) => {
+    ($root:expr, $guest:expr, $level:expr, $pte:expr, $root_level:expr, $root_n:expr) => {
         $root.entry($root_level, $guest, $level, true, |entry| {
             $pte = entry.pte();
             Ok(None)
-        }, true)
+        }, true, $root_n)
     };
 }
 
 // ipa_to_pte_set clousre
 macro_rules! set_pte {
-    ($root:expr, $guest:expr, $level:expr, $val:expr, $root_level:expr) => {
+    ($root:expr, $guest:expr, $level:expr, $val:expr, $root_level:expr, $root_n:expr) => {
         $root.entry($root_level, $guest, $level, true, |entry| {
             let pte = entry.mut_pte();
             *pte = RawPTE($val);
             Ok(None)
-        }, true)
+        }, true, $root_n)
     };
 }
 
 impl<'a> IPATranslation for Stage2Translation<'a> {
     fn get_base_address(&self) -> *const c_void {
         match &self.root_pgtlb {
-            Root::L2N8(c, _) => *c as *const _ as *const c_void, // most likely first, for linux-realm
-            Root::L0N1(a, _) => *a as *const _ as *const c_void,
-            Root::L0N16(a, _) => *a as *const _ as *const c_void,
-            Root::L1N1(b, _) => *b as *const _ as *const c_void,
-            Root::L1N2(b, _) => *b as *const _ as *const c_void,
-            Root::L1N8(b, _) => *b as *const _ as *const c_void,
-            Root::L2N4(c, _) => *c as *const _ as *const c_void,
-            Root::L2N16(c, _) => *c as *const _ as *const c_void,
+            Root::L2N8(c, _, _) => *c as *const _ as *const c_void, // most likely first, for linux-realm
+            Root::L0N1(a, _, _) => *a as *const _ as *const c_void,
+            Root::L0N16(a, _, _) => *a as *const _ as *const c_void,
+            Root::L1N1(b, _, _) => *b as *const _ as *const c_void,
+            Root::L1N2(b, _, _) => *b as *const _ as *const c_void,
+            Root::L1N8(b, _, _) => *b as *const _ as *const c_void,
+            Root::L2N4(c, _, _) => *c as *const _ as *const c_void,
+            Root::L2N16(c, _, _) => *c as *const _ as *const c_void,
         }
     }
 
@@ -218,14 +218,14 @@ impl<'a> IPATranslation for Stage2Translation<'a> {
         let mut pa = None;
 
         let res = match &mut self.root_pgtlb {
-            Root::L2N8(root, root_level) => to_pa!(root, guest, level, pa, *root_level), // most likely first, for linux-realm
-            Root::L0N1(root, root_level) => to_pa!(root, guest, level, pa, *root_level),
-            Root::L0N16(root, root_level) => to_pa!(root, guest, level, pa, *root_level),
-            Root::L1N1(root, root_level) => to_pa!(root, guest, level, pa, *root_level),
-            Root::L1N2(root, root_level) => to_pa!(root, guest, level, pa, *root_level),
-            Root::L1N8(root, root_level) => to_pa!(root, guest, level, pa, *root_level),
-            Root::L2N4(root, root_level) => to_pa!(root, guest, level, pa, *root_level),
-            Root::L2N16(root, root_level) => to_pa!(root, guest, level, pa, *root_level),
+            Root::L2N8(root, root_level, root_n) => to_pa!(root, guest, level, pa, *root_level, *root_n), // most likely first, for linux-realm
+            Root::L0N1(root, root_level, root_n) => to_pa!(root, guest, level, pa, *root_level, *root_n),
+            Root::L0N16(root, root_level, root_n) => to_pa!(root, guest, level, pa, *root_level, *root_n),
+            Root::L1N1(root, root_level, root_n) => to_pa!(root, guest, level, pa, *root_level, *root_n),
+            Root::L1N2(root, root_level, root_n) => to_pa!(root, guest, level, pa, *root_level, *root_n),
+            Root::L1N8(root, root_level, root_n) => to_pa!(root, guest, level, pa, *root_level, *root_n),
+            Root::L2N4(root, root_level, root_n) => to_pa!(root, guest, level, pa, *root_level, *root_n),
+            Root::L2N16(root, root_level, root_n) => to_pa!(root, guest, level, pa, *root_level, *root_n),
         };
         if res.is_ok() {
             pa
@@ -249,14 +249,14 @@ impl<'a> IPATranslation for Stage2Translation<'a> {
         let guest = Page::<BasePageSize, GuestPhysAddr>::including_address(guest);
         let mut pte = 0;
         let res = match &mut self.root_pgtlb {
-            Root::L2N8(root, root_level) => to_pte!(root, guest, level, pte, *root_level), // most likely first, for linux-realm
-            Root::L0N1(root, root_level) => to_pte!(root, guest, level, pte, *root_level),
-            Root::L0N16(root, root_level) => to_pte!(root, guest, level, pte, *root_level),
-            Root::L1N1(root, root_level) => to_pte!(root, guest, level, pte, *root_level),
-            Root::L1N2(root, root_level) => to_pte!(root, guest, level, pte, *root_level),
-            Root::L1N8(root, root_level) => to_pte!(root, guest, level, pte, *root_level),
-            Root::L2N4(root, root_level) => to_pte!(root, guest, level, pte, *root_level),
-            Root::L2N16(root, root_level) => to_pte!(root, guest, level, pte, *root_level),
+            Root::L2N8(root, root_level, root_n) => to_pte!(root, guest, level, pte, *root_level, *root_n), // most likely first, for linux-realm
+            Root::L0N1(root, root_level, root_n) => to_pte!(root, guest, level, pte, *root_level, *root_n),
+            Root::L0N16(root, root_level, root_n) => to_pte!(root, guest, level, pte, *root_level, *root_n),
+            Root::L1N1(root, root_level, root_n) => to_pte!(root, guest, level, pte, *root_level, *root_n),
+            Root::L1N2(root, root_level, root_n) => to_pte!(root, guest, level, pte, *root_level, *root_n),
+            Root::L1N8(root, root_level, root_n) => to_pte!(root, guest, level, pte, *root_level, *root_n),
+            Root::L2N4(root, root_level, root_n) => to_pte!(root, guest, level, pte, *root_level, *root_n),
+            Root::L2N16(root, root_level, root_n) => to_pte!(root, guest, level, pte, *root_level, *root_n),
         };
         if let Ok(x) = res {
             Some((pte, x.1))
@@ -273,14 +273,14 @@ impl<'a> IPATranslation for Stage2Translation<'a> {
     ) -> Result<(), Error> {
         let guest = Page::<BasePageSize, GuestPhysAddr>::including_address(guest);
         let res = match &mut self.root_pgtlb {
-            Root::L2N8(root, root_level) => set_pte!(root, guest, level, val, *root_level),
-            Root::L0N1(root, root_level) => set_pte!(root, guest, level, val, *root_level),
-            Root::L0N16(root, root_level) => set_pte!(root, guest, level, val, *root_level),
-            Root::L1N1(root, root_level) => set_pte!(root, guest, level, val, *root_level),
-            Root::L1N2(root, root_level) => set_pte!(root, guest, level, val, *root_level),
-            Root::L1N8(root, root_level) => set_pte!(root, guest, level, val, *root_level),
-            Root::L2N4(root, root_level) => set_pte!(root, guest, level, val, *root_level),
-            Root::L2N16(root, root_level) => set_pte!(root, guest, level, val, *root_level),
+            Root::L2N8(root, root_level, root_n) => set_pte!(root, guest, level, val, *root_level, *root_n),
+            Root::L0N1(root, root_level, root_n) => set_pte!(root, guest, level, val, *root_level, *root_n),
+            Root::L0N16(root, root_level, root_n) => set_pte!(root, guest, level, val, *root_level, *root_n),
+            Root::L1N1(root, root_level, root_n) => set_pte!(root, guest, level, val, *root_level, *root_n),
+            Root::L1N2(root, root_level, root_n) => set_pte!(root, guest, level, val, *root_level, *root_n),
+            Root::L1N8(root, root_level, root_n) => set_pte!(root, guest, level, val, *root_level, *root_n),
+            Root::L2N4(root, root_level, root_n) => set_pte!(root, guest, level, val, *root_level, *root_n),
+            Root::L2N16(root, root_level, root_n) => set_pte!(root, guest, level, val, *root_level, *root_n),
         };
         if let Ok(_x) = res {
             Ok(())

Original file line number	Diff line number	Diff line change
`@@ -108,7 +108,7 @@ impl page_table::Entry for Entry {`
`108`	`108`	`}`
`109`	`109`	`}`
`110`	`110`
`111`		`- fn index_with_level(addr: usize, level: usize, _is_root: bool) -> usize {`
	`111`	`+ fn index_with_level(addr: usize, level: usize, _is_root: bool, _root_n: usize) -> usize {`
`112`	`112`	`match level {`
`113`	`113`	`0 => RawGPA::from(addr).get_masked_value(RawGPA::L0Index) as usize,`
`114`	`114`	`1 => RawGPA::from(addr).get_masked_value(RawGPA::L1Index) as usize,`
Original file line number	Diff line number	Diff line change
`@@ -113,11 +113,11 @@ impl page_table::Entry for Entry {`
`113`	`113`	`}`
`114`	`114`	`}`
`115`	`115`
`116`		`- fn index_with_level(addr: usize, level: usize, is_root: bool) -> usize {`
	`116`	`+ fn index_with_level(addr: usize, level: usize, is_root: bool, root_n: usize) -> usize {`
`117`	`117`	`match level {`
`118`	`118`	`0 => RawGPA::from(addr).get_masked_value(RawGPA::L0Index) as usize,`
`119`	`119`	`1 => {`
`120`		`- if is_root {`
	`120`	`+ if is_root && root_n > 1 {`
`121`	`121`	`// We know that refering one direct parent table is enough`
`122`	`122`	`// because concatenation of the initial lookup table is upto 16.`
`123`	`123`	`let l0 = RawGPA::from(addr).get_masked_value(RawGPA::L0Index) as usize;`
`@@ -129,7 +129,7 @@ impl page_table::Entry for Entry {`
`129`	`129`	`}`
`130`	`130`	`}`
`131`	`131`	`2 => {`
`132`		`- if is_root {`
	`132`	`+ if is_root && root_n > 1 {`
`133`	`133`	`let l1 = RawGPA::from(addr).get_masked_value(RawGPA::L1Index) as usize;`
`134`	`134`	`let l2 = RawGPA::from(addr).get_masked_value(RawGPA::L2Index) as usize;`
`135`	`135`	`l1 * L3Table::NUM_ENTRIES + l2`