openhcl: relay NVIDIA GPUs to CVM guests behind a host config flag

openhcl/openhcl_attestation_protocol/src/igvm_attest/get.rs

@@ -500,6 +500,24 @@ pub mod runtime_claims {
         pub vmgs_provisioner: Option<VmgsProvisioner>,
         /// Hardware sealing policy
         pub hardware_sealing_policy: HardwareSealingPolicy,
+        /// Whether NVIDIA GPUs and NVLink/NVSwitch fabric devices are permitted
+        /// through the device filter for this guest.
+        ///
+        /// This reports that the filter was widened to admit those device
+        /// classes, not that such a device is present or attached. Per-device
+        /// trust comes from the guest's own device attestation.
+        ///
+        /// `None` when the relay was not enabled for these devices, which is
+        /// the default. This field is skipped during serialization when `None`
+        /// so that the runtime claims — and therefore the hardware-derived key
+        /// KDF input (see `underhill_attestation::hardware_key_sealing`) — are
+        /// byte-for-byte unchanged for guests that do not use this feature.
+        ///
+        /// Declared last on purpose: `MeshPayload` numbers fields by
+        /// declaration order, so inserting a field mid-struct would renumber
+        /// the following ones and break wire compatibility.
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub nvidia_vpci_relay_allowed: Option<bool>,
     }
 
     impl Default for AttestationVmConfig {
@@ -516,6 +534,7 @@ pub mod runtime_claims {
                 vm_unique_id: String::new(),
                 vmgs_provisioner: None,
                 hardware_sealing_policy: HardwareSealingPolicy::None,
+                nvidia_vpci_relay_allowed: None,
             }
         }
     }

openhcl/underhill_attestation/src/hardware_key_sealing.rs

@@ -229,11 +229,35 @@ mod tests {
             tpm_persisted: false,
             hardware_sealing_policy,
             filtered_vpci_devices_allowed: true,
+            nvidia_vpci_relay_allowed: None,
             vm_unique_id: "".to_string(),
             vmgs_provisioner: None,
         }
     }
 
+    /// The serialized `AttestationVmConfig` is an input to the hardware-derived
+    /// key KDF, so a guest that does not opt into the NVIDIA VPCI relay must
+    /// serialize exactly as it did before the field was introduced. Otherwise
+    /// every existing stateful CVM would derive different sealing keys and fail
+    /// to unseal its state after an upgrade.
+    #[test]
+    fn nvidia_vpci_relay_claim_omitted_when_unset() {
+        let vm_config = create_test_vm_config(HardwareSealingPolicy::Hash);
+        let json = serde_json::to_string(&vm_config).unwrap();
+        assert!(
+            !json.contains("nvidia-vpci-relay-allowed"),
+            "claim must be omitted when unset, got {json}"
+        );
+
+        let enabled = AttestationVmConfig {
+            nvidia_vpci_relay_allowed: Some(true),
+            ..create_test_vm_config(HardwareSealingPolicy::Hash)
+        };
+        let enabled_json = serde_json::to_string(&enabled).unwrap();
+        assert!(enabled_json.contains(r#""nvidia-vpci-relay-allowed":true"#));
+        assert_ne!(json, enabled_json);
+    }
+
     #[test]
     fn hardware_derived_keys_hash_policy() {
         let vm_config = create_test_vm_config(HardwareSealingPolicy::Hash);

openhcl/underhill_attestation/src/igvm_attest/mod.rs

@@ -511,6 +511,7 @@ mod tests {
             tpm_persisted: false,
             hardware_sealing_policy: HardwareSealingPolicy::Signer,
             filtered_vpci_devices_allowed: true,
+            nvidia_vpci_relay_allowed: None,
             vm_unique_id: String::new(),
             vmgs_provisioner: None,
         };
@@ -535,6 +536,7 @@ mod tests {
             tpm_persisted: false,
             hardware_sealing_policy: HardwareSealingPolicy::Hash,
             filtered_vpci_devices_allowed: true,
+            nvidia_vpci_relay_allowed: None,
             vm_unique_id: String::new(),
             vmgs_provisioner: None,
         };

openhcl/underhill_attestation/src/lib.rs

@@ -2118,6 +2118,7 @@ mod tests {
             tpm_persisted: true,
             hardware_sealing_policy: HardwareSealingPolicy::None,
             filtered_vpci_devices_allowed: false,
+            nvidia_vpci_relay_allowed: None,
             vm_unique_id: String::new(),
             vmgs_provisioner: None,
         }
@@ -2692,6 +2693,7 @@ mod tests {
                 tpm_persisted: false,
                 hardware_sealing_policy: HardwareSealingPolicy::Hash,
                 filtered_vpci_devices_allowed: true,
+                nvidia_vpci_relay_allowed: None,
                 vm_unique_id: String::new(),
                 vmgs_provisioner: None,
             },
@@ -2769,6 +2771,7 @@ mod tests {
                 tpm_persisted: false,
                 hardware_sealing_policy: HardwareSealingPolicy::Hash,
                 filtered_vpci_devices_allowed: true,
+                nvidia_vpci_relay_allowed: None,
                 vm_unique_id: String::new(),
                 vmgs_provisioner: None,
             },
@@ -2811,6 +2814,7 @@ mod tests {
                 tpm_persisted: false,
                 hardware_sealing_policy: HardwareSealingPolicy::Hash,
                 filtered_vpci_devices_allowed: true,
+                nvidia_vpci_relay_allowed: None,
                 vm_unique_id: String::new(),
                 vmgs_provisioner: None,
             },
@@ -2879,6 +2883,7 @@ mod tests {
                 tpm_persisted: false,
                 hardware_sealing_policy: HardwareSealingPolicy::Hash,
                 filtered_vpci_devices_allowed: true,
+                nvidia_vpci_relay_allowed: None,
                 vm_unique_id: String::new(),
                 vmgs_provisioner: None,
             },

openhcl/underhill_core/src/dispatch/vtl2_settings_worker.rs

@@ -287,6 +287,7 @@ impl Vtl2SettingsWorker {
         let old_settings = Vtl2Settings {
             fixed: Default::default(),
             dynamic: self.old_settings.clone(),
+            device_policy: None,
         };
         let vtl2_settings = Vtl2Settings::read_from(buf, old_settings).map_err(|err| match err {
             underhill_config::schema::ParseError::Json(err) => {
@@ -314,6 +315,19 @@ impl Vtl2SettingsWorker {
 
         let vtl2_settings = vtl2_settings?;
 
+        // The device policy is consumed once, during VM startup, to build the
+        // VPCI relay's allow-list. Applying it later would let the reported
+        // device posture drift from the attestation claim, which is computed at
+        // the same time, so a runtime update is ignored. Say so rather than
+        // silently dropping it.
+        if vtl2_settings.device_policy.is_some() {
+            tracelimit::warn_ratelimited!(
+                CVM_ALLOWED,
+                "ignoring DevicePolicy in a runtime VTL2 settings update; \
+                 it is only honored at VM startup"
+            );
+        }
+
         let new_settings = vtl2_settings.dynamic;
 
         tracing::info!(CVM_ALLOWED, ?new_settings, "Received VTL2 settings");

openhcl/underhill_core/src/lib.rs

@@ -356,6 +356,7 @@ async fn launch_workers(
         strict_encryption_policy: opt.strict_encryption_policy,
         attempt_ak_cert_callback: opt.attempt_ak_cert_callback,
         enable_vpci_relay: opt.enable_vpci_relay,
+        nvidia_vpci_relay_allowed: opt.nvidia_vpci_relay_allowed,
         disable_proxy_redirect: opt.disable_proxy_redirect,
         disable_lower_vtl_timer_virt: opt.disable_lower_vtl_timer_virt,
         config_timeout_in_seconds: opt.config_timeout_in_seconds,

openhcl/underhill_core/src/options.rs

@@ -336,6 +336,14 @@ pub struct Options {
     /// (OPENHCL_ENABLE_VPCI_RELAY=1) Enable the VPCI relay.
     pub enable_vpci_relay: Option<bool>,
 
+    /// (OPENHCL_NVIDIA_VPCI_RELAY_ALLOWED=1) Allow NVIDIA GPUs and
+    /// NVLink/NVSwitch fabric devices through the VPCI relay's device filter.
+    ///
+    /// Overrides the host's `NvidiaVpciRelayAllowed` Device Platform Settings
+    /// value, for hosts that cannot yet set it. The attestation claim follows
+    /// this override, so the reported posture always matches the filter.
+    pub nvidia_vpci_relay_allowed: Option<bool>,
+
     /// (OPENHCL_DISABLE_PROXY_REDIRECT=1) Disable proxy interrupt redirection.
     pub disable_proxy_redirect: bool,
 
@@ -540,6 +548,7 @@ impl Options {
         let strict_encryption_policy = parse_env_bool_opt("HCL_STRICT_ENCRYPTION_POLICY");
         let attempt_ak_cert_callback = parse_env_bool_opt("HCL_ATTEMPT_AK_CERT_CALLBACK");
         let enable_vpci_relay = parse_env_bool_opt("OPENHCL_ENABLE_VPCI_RELAY");
+        let nvidia_vpci_relay_allowed = parse_env_bool_opt("OPENHCL_NVIDIA_VPCI_RELAY_ALLOWED");
         let disable_proxy_redirect = parse_env_bool("OPENHCL_DISABLE_PROXY_REDIRECT");
         let disable_lower_vtl_timer_virt = parse_env_bool("OPENHCL_DISABLE_LOWER_VTL_TIMER_VIRT");
         let config_timeout_in_seconds =
@@ -611,6 +620,7 @@ impl Options {
             strict_encryption_policy,
             attempt_ak_cert_callback,
             enable_vpci_relay,
+            nvidia_vpci_relay_allowed,
             disable_proxy_redirect,
             disable_lower_vtl_timer_virt,
             config_timeout_in_seconds,