no_std page table builder

Author: babayet2

Cargo.lock

@@ -5293,7 +5293,6 @@ name = "page_table"
 version = "0.0.0"
 dependencies = [
  "bitfield-struct 0.11.0",
- "tracing",
  "zerocopy 0.8.25",
 ]
 

vm/loader/manifests/openhcl-x64-cvm-dev.json

@@ -57,4 +57,4 @@
             }
         }
     ]
-}
+}

vm/loader/page_table/Cargo.toml

@@ -8,7 +8,6 @@ rust-version.workspace = true
 
 [dependencies]
 bitfield-struct.workspace = true
-tracing.workspace = true
 zerocopy.workspace = true
 [lints]
 workspace = true

vm/loader/page_table/src/aarch64.rs

@@ -3,8 +3,12 @@
 
 //! Methods to construct page tables on Aarch64.
 
+use crate::PageTableBuffer;
 use bitfield_struct::bitfield;
 
+//TODO(babayet2) nonsensical
+pub const MAX_PAGE_TABLE_REGION_SIZE: usize = 1024 * 1024;
+
 /// Some memory attributes. Refer to the ARM VMSA
 /// manual for further details and other types.
 #[derive(Debug, PartialEq, Eq, Clone, Copy, Default)]
@@ -437,10 +441,6 @@ impl<'a> Arm64PageTableSpace<'a> {
         debug_assert!(aligned(phys_table_start, Arm64PageSize::Small));
         debug_assert!(index < PAGE_SIZE_4K as usize / size_of::<Arm64PageTableEntry>());
 
-        tracing::debug!(
-            "Writing page table entry {entry:#016x}, index {index:#x}, table {phys_table_start:#x}"
-        );
-
         let pos = phys_table_start as usize - self.phys_page_table_root
             + index * size_of::<Arm64PageTableEntry>();
         self.space[pos..pos + 8].copy_from_slice(&entry.to_le_bytes());
@@ -677,13 +677,16 @@ impl<'a> Arm64PageTableSpace<'a> {
 }
 
 /// Build a set of Aarch64 page tables identity mapping the given region.
-pub fn build_identity_page_tables_aarch64(
+pub fn build_identity_page_tables_aarch64<P>(
     page_table_gpa: u64,
     start_gpa: u64,
     size: u64,
     memory_attribute_indirection: MemoryAttributeIndirectionEl1,
     page_table_region_size: usize,
-) -> Vec<u8> {
+    page_table_space: &mut P,
+) where
+    P: PageTableBuffer<Element = u8>,
+{
     // start_gpa and size must be 2MB aligned.
     if !aligned(start_gpa, Arm64PageSize::Large) {
         panic!("start_gpa not 2mb aligned");
@@ -693,13 +696,12 @@ pub fn build_identity_page_tables_aarch64(
         panic!("size not 2mb aligned");
     }
 
-    tracing::debug!(
-        "Creating Aarch64 page tables at {page_table_gpa:#x} mapping starting at {start_gpa:#x} of size {size} bytes"
-    );
+    for _ in 0..page_table_region_size {
+        page_table_space.push(0);
+    }
 
-    let mut page_table_space = vec![0; page_table_region_size];
     let mut page_tables =
-        Arm64PageTableSpace::new(page_table_gpa as usize, &mut page_table_space).unwrap();
+        Arm64PageTableSpace::new(page_table_gpa as usize, page_table_space.as_mut_slice()).unwrap();
     page_tables
         .map_range(
             start_gpa,
@@ -713,12 +715,8 @@ pub fn build_identity_page_tables_aarch64(
         .unwrap();
 
     let used_space = page_tables.used_space();
-    tracing::debug!("Page tables use {used_space} bytes");
-    tracing::debug!("Page tables stats by level: {:?}", page_tables.lvl_stats());
 
     page_table_space.truncate(used_space);
-
-    page_table_space
 }
 
 #[cfg(test)]

vm/loader/page_table/src/lib.rs

@@ -3,6 +3,7 @@
 
 //! Methods to construct page tables.
 
+#![no_std]
 #![expect(missing_docs)]
 #![forbid(unsafe_code)]
 
@@ -17,3 +18,27 @@ pub enum IdentityMapSize {
     /// Identity-map the bottom 8GB
     Size8Gb,
 }
+
+/// A trait for an indexable, mutable, and extendable working memory buffer for page table building
+pub trait PageTableBuffer:
+    core::ops::Index<usize, Output = Self::Element> + core::ops::IndexMut<usize, Output = Self::Element>
+{
+    /// Associated Type defining the element type stored in the buffer
+    type Element;
+
+    fn new() -> Self;
+
+    fn push(&mut self, item: Self::Element);
+
+    fn extend(&mut self, items: &[Self::Element]);
+
+    fn len(&self) -> usize;
+
+    fn as_slice(&self) -> &[Self::Element];
+
+    fn as_mut_slice(&mut self) -> &mut [Self::Element];
+
+    fn truncate(&mut self, new_len: usize);
+
+    fn iter_mut(&mut self) -> core::slice::IterMut<'_, Self::Element>;
+}