Merge branch 'main' into save_restore_vmgs

Author: tjones60

Cargo.lock

@@ -5428,6 +5428,7 @@ dependencies = [
  "petri_artifacts_core",
  "petri_artifacts_vmm_test",
  "pipette_client",
+ "powershell_builder",
  "prost",
  "scsidisk_resources",
  "serde",
@@ -5663,6 +5664,14 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
 
+[[package]]
+name = "powershell_builder"
+version = "0.0.0"
+dependencies = [
+ "guid",
+ "jiff",
+]
+
 [[package]]
 name = "prettyplease"
 version = "0.1.25"

Cargo.toml

@@ -134,6 +134,7 @@ pal_async = { path = "support/pal/pal_async" }
 pal_async_test = { path = "support/pal/pal_async_test" }
 pal_event = { path = "support/pal/pal_event" }
 pal_uring = { path = "support/pal/pal_uring" }
+powershell_builder = { path = "support/powershell_builder" }
 safeatomic = { path = "support/safeatomic" }
 serde_helpers = { path = "support/serde_helpers" }
 sev_guest_device = { path = "support/sev_guest_device" }

flowey/flowey_lib_hvlite/src/_jobs/cfg_versions.rs

@@ -23,7 +23,7 @@ pub const MDBOOK: &str = "0.4.40";
 pub const MDBOOK_ADMONISH: &str = "1.18.0";
 pub const MDBOOK_MERMAID: &str = "0.14.0";
 pub const RUSTUP_TOOLCHAIN: &str = "1.87.0";
-pub const MU_MSVM: &str = "25.1.3";
+pub const MU_MSVM: &str = "25.1.4";
 pub const NEXTEST: &str = "0.9.96";
 pub const NODEJS: &str = "18.x";
 // N.B. Kernel version numbers for dev and stable branches are not directly

openhcl/build_info/src/lib.rs

@@ -15,6 +15,10 @@ pub struct BuildInfo {
     revision: &'static str,
     #[inspect(safe, rename = "scm_branch")]
     branch: &'static str,
+    #[inspect(safe)]
+    internal_scm_revision: &'static str,
+    #[inspect(safe)]
+    internal_scm_branch: &'static str,
 }
 
 impl BuildInfo {
@@ -35,6 +39,16 @@ impl BuildInfo {
             } else {
                 ""
             },
+            internal_scm_revision: if let Some(r) = option_env!("INTERNAL_GIT_SHA") {
+                r
+            } else {
+                ""
+            },
+            internal_scm_branch: if let Some(r) = option_env!("INTERNAL_GIT_BRANCH") {
+                r
+            } else {
+                ""
+            },
         }
     }
 

openhcl/hcl/src/ioctl.rs

@@ -3039,8 +3039,6 @@ impl Hcl {
             .expect("check_vtl_access hypercall should not fail")
         };
 
-        // TODO GUEST_VSM: for isolated VMs, if the status is operation denied,
-        // return memory unaccepted?
         status.result().map_err(Error::CheckVtlAccess)?;
 
         let access_result = output[0];

openhcl/openhcl_dma_manager/src/lib.rs

@@ -155,7 +155,7 @@ pub struct DmaClientParameters {
 struct DmaManagerInner {
     shared_spawner: Option<PagePoolAllocatorSpawner>,
     private_spawner: Option<PagePoolAllocatorSpawner>,
-    lower_vtl: Arc<DmaManagerLowerVtl>,
+    lower_vtl: Option<Arc<DmaManagerLowerVtl>>,
 }
 
 /// Used by [`OpenhclDmaManager`] to modify VTL permissions via
@@ -164,6 +164,9 @@ struct DmaManagerInner {
 /// This is required due to some users (like the GET or partition struct itself)
 /// that are constructed before the partition struct which normally implements
 /// this trait.
+///
+/// This type should never be created on a hardware isolated VM, as the
+/// hypervisor is untrusted.
 struct DmaManagerLowerVtl {
     mshv_hvcall: hcl::ioctl::MshvHvcall,
 }
@@ -261,7 +264,12 @@ impl DmaManagerInner {
                             private
                                 .allocator(device_name.into())
                                 .context("failed to create private allocator")?,
-                            self.lower_vtl.clone(),
+                            self.lower_vtl
+                                .as_ref()
+                                .ok_or(anyhow::anyhow!(
+                                    "lower vtl not available on hardware isolated platforms"
+                                ))?
+                                .clone(),
                         ))
                     }
                 },
@@ -290,7 +298,12 @@ impl DmaManagerInner {
                         // lowering VTL permissions is required.
                         DmaClientBacking::LockedMemoryLowerVtl(LowerVtlMemorySpawner::new(
                             LockedMemorySpawner,
-                            self.lower_vtl.clone(),
+                            self.lower_vtl
+                                .as_ref()
+                                .ok_or(anyhow::anyhow!(
+                                    "lower vtl not available on hardware isolated platforms"
+                                ))?
+                                .clone(),
                         ))
                     }
                 },
@@ -308,6 +321,7 @@ impl OpenhclDmaManager {
         shared_ranges: &[MemoryRange],
         private_ranges: &[MemoryRange],
         vtom: u64,
+        isolation_type: virt::IsolationType,
     ) -> anyhow::Result<Self> {
         let shared_pool = if shared_ranges.is_empty() {
             None
@@ -337,7 +351,11 @@ impl OpenhclDmaManager {
             inner: Arc::new(DmaManagerInner {
                 shared_spawner: shared_pool.as_ref().map(|pool| pool.allocator_spawner()),
                 private_spawner: private_pool.as_ref().map(|pool| pool.allocator_spawner()),
-                lower_vtl: DmaManagerLowerVtl::new().context("failed to create lower vtl")?,
+                lower_vtl: if isolation_type.is_hardware_isolated() {
+                    None
+                } else {
+                    Some(DmaManagerLowerVtl::new().context("failed to create lower vtl")?)
+                },
             }),
             shared_pool,
             private_pool,

openhcl/underhill_core/src/worker.rs

@@ -1523,6 +1523,7 @@ async fn new_underhill_vm(
             .vtom_offset_bit
             .map(|bit| 1 << bit)
             .unwrap_or(0),
+        isolation,
     )
     .context("failed to create global dma manager")?;
 

openhcl/underhill_mem/src/init.rs

@@ -227,7 +227,11 @@ pub async fn init(params: &Init<'_>) -> anyhow::Result<MemoryMappings> {
         tracing::debug!("Building valid encrypted memory view");
         let encrypted_memory_view = {
             let _span = tracing::info_span!("create encrypted memory view", CVM_ALLOWED).entered();
-            GuestPartitionMemoryView::new(params.mem_layout, true)?
+            GuestPartitionMemoryView::new(
+                params.mem_layout,
+                crate::mapping::GuestValidMemoryType::Encrypted,
+                true,
+            )?
         };
 
         tracing::debug!("Building encrypted memory map");
@@ -241,8 +245,8 @@ pub async fn init(params: &Init<'_>) -> anyhow::Result<MemoryMappings> {
 
         let use_vtl1 = params.maximum_vtl >= Vtl::Vtl1;
 
-        // Start by giving VTL 0 full access to all lower-vtl memory. TODO GUEST
-        // VSM: with lazy acceptance, it should instead be initialized to no
+        // Start by giving VTL 0 full access to all lower-vtl memory.
+        // TODO GUEST VSM: with lazy acceptance, it should instead be initialized to no
         // access.
         tracing::debug!("Building VTL0 memory map");
         let vtl0_mapping = Arc::new({
@@ -321,7 +325,11 @@ pub async fn init(params: &Init<'_>) -> anyhow::Result<MemoryMappings> {
 
         let shared_memory_view = {
             let _span = tracing::info_span!("create shared memory view", CVM_ALLOWED).entered();
-            GuestPartitionMemoryView::new(params.complete_memory_layout, false)?
+            GuestPartitionMemoryView::new(
+                params.complete_memory_layout,
+                crate::mapping::GuestValidMemoryType::Shared,
+                false,
+            )?
         };
 
         let valid_shared_memory = shared_memory_view.partition_valid_memory();
@@ -442,9 +450,6 @@ pub async fn init(params: &Init<'_>) -> anyhow::Result<MemoryMappings> {
             acceptor.as_ref().unwrap().clone(),
         )) as Arc<dyn ProtectIsolatedMemory>;
 
-        // TODO GUEST VSM: create guest memory objects using execute permissions
-        // for the instruction emulator to use when reading instructions.
-
         tracing::debug!("Creating VTL0 guest memory for kernel execute access");
         let vtl0_kx_gm = GuestMemory::new_multi_region(
             "vtl0_kx",

openhcl/underhill_mem/src/lib.rs

@@ -766,7 +766,7 @@ impl ProtectIsolatedMemory for HardwareIsolatedMemoryProtector {
             for gpn in
                 ram_range.range.start() / PAGE_SIZE as u64..ram_range.range.end() / PAGE_SIZE as u64
             {
-                // TODO GUEST_VSM: for now, use the encrypted mapping to
+                // TODO GUEST VSM: for now, use the encrypted mapping to
                 // find all accepted memory. When lazy acceptance exists,
                 // this should track all pages that have been accepted and
                 // should be used instead.
@@ -955,6 +955,12 @@ impl ProtectIsolatedMemory for HardwareIsolatedMemoryProtector {
         Ok(())
     }
 
+    fn is_overlay_page(&self, vtl: GuestVtl, gpn: u64) -> bool {
+        self.inner.lock().overlay_pages[vtl]
+            .iter()
+            .any(|p| p.gpn == gpn)
+    }
+
     fn set_vtl1_protections_enabled(&self) {
         self.vtl1_protections_enabled
             .store(true, std::sync::atomic::Ordering::Relaxed);

openhcl/underhill_mem/src/mapping.rs

@@ -35,10 +35,11 @@ impl<'a> GuestPartitionMemoryView<'a> {
     /// page.
     pub fn new(
         memory_layout: &'a MemoryLayout,
+        memory_type: GuestValidMemoryType,
         valid_bitmap_state: bool,
     ) -> Result<Self, MappingError> {
         let valid_memory =
-            GuestValidMemory::new(memory_layout, valid_bitmap_state).map(Arc::new)?;
+            GuestValidMemory::new(memory_layout, memory_type, valid_bitmap_state).map(Arc::new)?;
         Ok(Self {
             memory_layout,
             valid_memory,
@@ -88,6 +89,18 @@ impl GuestMemoryView {
     }
 }
 
+#[derive(Error, Debug)]
+#[error("the specified page is not mapped")]
+struct NotMapped;
+
+#[derive(Error, Debug)]
+enum BitmapFailure {
+    #[error("the specified page was accessed using the wrong visibility mapping")]
+    IncorrectHostVisibilityAccess,
+    #[error("the specified page access violates VTL 1 protections")]
+    Vtl1ProtectionsViolation,
+}
+
 /// SAFETY: Implementing the `GuestMemoryAccess` contract, including the
 /// size and lifetime of the mappings and bitmaps.
 unsafe impl GuestMemoryAccess for GuestMemoryView {
@@ -164,6 +177,91 @@ unsafe impl GuestMemoryAccess for GuestMemoryView {
                 .map(|bitmap| bitmap.access_bitmap())
         }
     }
+
+    fn page_fault(
+        &self,
+        address: u64,
+        len: usize,
+        write: bool,
+        bitmap_failure: bool,
+    ) -> guestmem::PageFaultAction {
+        let gpn = address / PAGE_SIZE as u64;
+        if !bitmap_failure {
+            guestmem::PageFaultAction::Fail(guestmem::PageFaultError::other(NotMapped {}))
+        } else {
+            let valid_memory = self
+                .memory_mapping
+                .valid_memory
+                .as_ref()
+                .expect("all backings with bitmaps should have a GuestValidMemory");
+            if !valid_memory.check_valid(gpn) {
+                match valid_memory.memory_type() {
+                    GuestValidMemoryType::Shared => {
+                        tracing::warn!(
+                            ?address,
+                            ?len,
+                            ?write,
+                            "tried to access private page using shared mapping"
+                        );
+                        guestmem::PageFaultAction::Fail(guestmem::PageFaultError::new(
+                            guestmem::GuestMemoryErrorKind::NotShared,
+                            BitmapFailure::IncorrectHostVisibilityAccess,
+                        ))
+                    }
+                    GuestValidMemoryType::Encrypted => {
+                        tracing::warn!(
+                            ?address,
+                            ?len,
+                            ?write,
+                            "tried to access shared page using private mapping"
+                        );
+                        guestmem::PageFaultAction::Fail(guestmem::PageFaultError::new(
+                            guestmem::GuestMemoryErrorKind::NotPrivate,
+                            BitmapFailure::IncorrectHostVisibilityAccess,
+                        ))
+                    }
+                }
+            } else {
+                // Currently, only VTL 1 permissions are tracked, so any
+                // invalid accesses here violate VTL 1 protections.
+                if let Some(permission_bitmaps) = &self.memory_mapping.permission_bitmaps {
+                    let check_bitmap = if write {
+                        &permission_bitmaps.write_bitmap
+                    } else {
+                        match self.view_type {
+                            GuestMemoryViewReadType::Read => &permission_bitmaps.read_bitmap,
+                            GuestMemoryViewReadType::KernelExecute => {
+                                &permission_bitmaps.kernel_execute_bitmap
+                            }
+                            GuestMemoryViewReadType::UserExecute => {
+                                &permission_bitmaps.user_execute_bitmap
+                            }
+                        }
+                    };
+
+                    if !check_bitmap.page_state(gpn) {
+                        tracing::warn!(?address, ?len, ?write, ?self.view_type, "VTL 1 permissions violation");
+
+                        return guestmem::PageFaultAction::Fail(guestmem::PageFaultError::new(
+                            guestmem::GuestMemoryErrorKind::VtlProtected,
+                            BitmapFailure::Vtl1ProtectionsViolation,
+                        ));
+                    }
+                }
+
+                // Possible race condition where the bitmaps are in transition
+                // and while the original check failed, the bitmaps now show
+                // valid access to the page. Retry in that situation.
+                guestmem::PageFaultAction::Retry
+            }
+        }
+    }
+}
+
+#[derive(Debug, Copy, Clone)]
+pub enum GuestValidMemoryType {
+    Shared,
+    Encrypted,
 }
 
 /// Partition-wide (cross-vtl) tracking of valid memory that can be used in
@@ -172,10 +270,15 @@ unsafe impl GuestMemoryAccess for GuestMemoryView {
 pub struct GuestValidMemory {
     valid_bitmap: GuestMemoryBitmap,
     valid_bitmap_lock: Mutex<()>,
+    memory_type: GuestValidMemoryType,
 }
 
 impl GuestValidMemory {
-    fn new(memory_layout: &MemoryLayout, valid_bitmap_state: bool) -> Result<Self, MappingError> {
+    fn new(
+        memory_layout: &MemoryLayout,
+        memory_type: GuestValidMemoryType,
+        valid_bitmap_state: bool,
+    ) -> Result<Self, MappingError> {
         let valid_bitmap = {
             let mut bitmap = {
                 // Calculate the total size of the address space by looking at the ending region.
@@ -201,6 +304,7 @@ impl GuestValidMemory {
         Ok(GuestValidMemory {
             valid_bitmap,
             valid_bitmap_lock: Default::default(),
+            memory_type,
         })
     }
 
@@ -215,6 +319,11 @@ impl GuestValidMemory {
         self.valid_bitmap.page_state(gpn)
     }
 
+    /// Returns the type of memory tracked by the bitmap
+    pub(crate) fn memory_type(&self) -> GuestValidMemoryType {
+        self.memory_type
+    }
+
     fn access_bitmap(&self) -> guestmem::BitmapInfo {
         let ptr = NonNull::new(self.valid_bitmap.as_ptr()).unwrap();
         guestmem::BitmapInfo {