loader: update the page table builder to be no_std

Cargo.lock

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

tmk/tmk_vmm/src/load.rs

@@ -22,6 +22,7 @@ use vm_topology::processor::ProcessorTopology;
 use vm_topology::processor::aarch64::Aarch64Topology;
 use vm_topology::processor::x86::X86Topology;
 use zerocopy::FromBytes as _;
+use zerocopy::FromZeros;
 use zerocopy::IntoBytes;
 
 /// Loads a TMK, returning the initial registers for the BSP.
@@ -38,19 +39,24 @@ pub fn load_x86(
     let load_info = load_common(&mut loader, tmk, test)?;
 
     let page_table_base = load_info.next_available_address;
-    let page_tables = page_table::x64::build_page_tables_64(
+    let mut page_table_work_buffer: Vec<page_table::x64::PageTable> =
+        vec![page_table::x64::PageTable::new_zeroed(); page_table::x64::PAGE_TABLE_MAX_COUNT];
+    let mut page_tables: Vec<u8> = vec![0; page_table::x64::PAGE_TABLE_MAX_BYTES];
+    let page_table_builder = page_table::x64::IdentityMapBuilder::new(
         page_table_base,
-        0,
         page_table::IdentityMapSize::Size4Gb,
-        None,
     );
+    let page_tables = page_table_builder.build(
+        page_table_work_buffer.as_mut_slice(),
+        page_tables.as_mut_slice(),
+    )?;
     loader
         .import_pages(
             page_table_base >> 12,
             page_tables.len() as u64 >> 12,
             "page_tables",
             loader::importer::BootPageAcceptance::Exclusive,
-            &page_tables,
+            page_tables,
         )
         .context("failed to import page tables")?;
 

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

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

vm/loader/page_table/Cargo.toml

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

vm/loader/page_table/src/aarch64.rs

@@ -437,10 +437,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());
@@ -682,8 +678,8 @@ pub fn build_identity_page_tables_aarch64(
     start_gpa: u64,
     size: u64,
     memory_attribute_indirection: MemoryAttributeIndirectionEl1,
-    page_table_region_size: usize,
-) -> Vec<u8> {
+    page_table_space: &mut [u8],
+) -> &[u8] {
     // start_gpa and size must be 2MB aligned.
     if !aligned(start_gpa, Arm64PageSize::Large) {
         panic!("start_gpa not 2mb aligned");
@@ -693,13 +689,8 @@ 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"
-    );
-
-    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).unwrap();
     page_tables
         .map_range(
             start_gpa,
@@ -713,17 +704,16 @@ 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
+    &page_table_space[0..used_space]
 }
 
 #[cfg(test)]
 mod tests {
+    extern crate std;
+
     use super::*;
+    use std::vec;
 
     const DUMP_PAGE_TABLES: bool = false;
 

vm/loader/page_table/src/lib.rs

@@ -3,12 +3,25 @@
 
 //! Methods to construct page tables.
 
+#![no_std]
 #![expect(missing_docs)]
 #![forbid(unsafe_code)]
 
 pub mod aarch64;
 pub mod x64;
 
+use thiserror::Error;
+
+/// Errors returned by the Page Table Builder
+#[derive(Debug, PartialEq, Eq, Error)]
+pub enum Error {
+    /// The PageTableBuilder bytes buffer does not match the size of the struct buffer
+    #[error(
+        "PageTableBuilder bytes buffer size [{bytes_buf}] does not match the struct buffer size [{struct_buf}]"
+    )]
+    BadBufferSize { bytes_buf: usize, struct_buf: usize },
+}
+
 /// Size of the initial identity map
 #[derive(Debug, Copy, Clone)]
 pub enum IdentityMapSize {