Add check in virt-host-validate for secure guest support on x86 for Intel Trust Domain Extentions. Suggested-by: Daniel P. Berrangé <berrange@redhat.com> Signed-off-by: Zhenzhong Duan <zhenzhong.duan@intel.com> --- tools/virt-host-validate-common.c | 22 +++++++++++++++++++++- tools/virt-host-validate-common.h | 1 + 2 files changed, 22 insertions(+), 1 deletion(-) diff --git a/tools/virt-host-validate-common.c b/tools/virt-host-validate-common.c index c8a23e2e99..4f0698b8ce 100644 --- a/tools/virt-host-validate-common.c +++ b/tools/virt-host-validate-common.c @@ -43,7 +43,8 @@ VIR_ENUM_IMPL(virHostValidateCPUFlag, "svm", "sie", "158", - "sev"); + "sev", + "tdx_host_platform"); static bool quiet; @@ -471,6 +472,7 @@ int virHostValidateSecureGuests(const char *hvname, g_autoptr(virBitmap) flags = NULL; bool hasFac158 = false; bool hasAMDSev = false; + bool hasIntelTDX = false; virArch arch = virArchFromHost(); g_autofree char *cmdline = NULL; static const char *kIBMValues[] = {"y", "Y", "on", "ON", "oN", "On", "1"}; @@ -482,6 +484,8 @@ int virHostValidateSecureGuests(const char *hvname, hasFac158 = true; else if (flags && virBitmapIsBitSet(flags, VIR_HOST_VALIDATE_CPU_FLAG_SEV)) hasAMDSev = true; + else if (flags && virBitmapIsBitSet(flags, VIR_HOST_VALIDATE_CPU_FLAG_TDX)) + hasIntelTDX = true; virHostMsgCheck(hvname, "%s", _("for secure guest support")); if (ARCH_IS_S390(arch)) { @@ -539,6 +543,22 @@ int virHostValidateSecureGuests(const char *hvname, "disabled in firmware."); return VIR_HOST_VALIDATE_FAILURE(level); } + } else if (hasIntelTDX) { + if (virFileReadValueString(&mod_value, "/sys/module/kvm_intel/parameters/tdx") < 0) { + virHostMsgFail(level, "Intel Trust Domain Extentions not " + "supported by the currently used kernel"); + return VIR_HOST_VALIDATE_FAILURE(level); + } + + if (mod_value[0] != 'Y') { + virHostMsgFail(level, + "Intel Trust Domain Extentions appears to be " + "disabled in kernel. Add kvm_intel.tdx=Y " + "to the kernel cmdline arguments"); + return VIR_HOST_VALIDATE_FAILURE(level); + } + virHostMsgPass(); + return 1; } virHostMsgFail(level, diff --git a/tools/virt-host-validate-common.h b/tools/virt-host-validate-common.h index 9334fa8588..c64f5669dc 100644 --- a/tools/virt-host-validate-common.h +++ b/tools/virt-host-validate-common.h @@ -39,6 +39,7 @@ typedef enum { VIR_HOST_VALIDATE_CPU_FLAG_SIE, VIR_HOST_VALIDATE_CPU_FLAG_FACILITY_158, VIR_HOST_VALIDATE_CPU_FLAG_SEV, + VIR_HOST_VALIDATE_CPU_FLAG_TDX, VIR_HOST_VALIDATE_CPU_FLAG_LAST, } virHostValidateCPUFlag; -- 2.34.1

Implement TDX check in order to generate domain feature capability correctly in case the availability of the feature changed. For INTEL TDX the verification is: - checking if "/sys/module/kvm_intel/parameters/tdx" contains the value 'Y': meaning TDX is enabled in the host kernel. Signed-off-by: Zhenzhong Duan <zhenzhong.duan@intel.com> Reviewed-by: Daniel P. Berrangé <berrange@redhat.com> --- src/qemu/qemu_capabilities.c | 21 ++++++++++++++++++++- 1 file changed, 20 insertions(+), 1 deletion(-) diff --git a/src/qemu/qemu_capabilities.c b/src/qemu/qemu_capabilities.c index 21f93c6774..7cccc28e80 100644 --- a/src/qemu/qemu_capabilities.c +++ b/src/qemu/qemu_capabilities.c @@ -5112,6 +5112,24 @@ virQEMUCapsKVMSupportsSecureGuestAMD(void) } +/* + * Check whether INTEL Trust Domain Extention (x86) is enabled + */ +static bool +virQEMUCapsKVMSupportsSecureGuestINTEL(void) +{ + g_autofree char *modValue = NULL; + + if (virFileReadValueString(&modValue, "/sys/module/kvm_intel/parameters/tdx") < 0) + return false; + + if (modValue[0] != 'Y') + return false; + + return true; +} + + /* * Check whether the secure guest functionality is enabled. * See the specific architecture function for details on the verifications made. @@ -5125,7 +5143,8 @@ virQEMUCapsKVMSupportsSecureGuest(void) return virQEMUCapsKVMSupportsSecureGuestS390(); if (ARCH_IS_X86(arch)) - return virQEMUCapsKVMSupportsSecureGuestAMD(); + return virQEMUCapsKVMSupportsSecureGuestAMD() || + virQEMUCapsKVMSupportsSecureGuestINTEL(); return false; } -- 2.34.1

Extend qemu TDX capability to domain capabilities. Signed-off-by: Chenyi Qiang <chenyi.qiang@intel.com> Signed-off-by: Zhenzhong Duan <zhenzhong.duan@intel.com> --- docs/formatdomaincaps.rst | 1 + src/conf/domain_capabilities.c | 1 + src/conf/domain_capabilities.h | 1 + src/conf/schemas/domaincaps.rng | 9 +++++++++ src/qemu/qemu_capabilities.c | 13 +++++++++++++ 5 files changed, 25 insertions(+) diff --git a/docs/formatdomaincaps.rst b/docs/formatdomaincaps.rst index 609a767189..36d56a433c 100644 --- a/docs/formatdomaincaps.rst +++ b/docs/formatdomaincaps.rst @@ -651,6 +651,7 @@ capabilities. All features occur as children of the main ``features`` element. <backingStoreInput supported='yes'/> <backup supported='yes'/> <async-teardown supported='yes'/> + <tdx supported='yes'/> <sev> <cbitpos>47</cbitpos> <reduced-phys-bits>1</reduced-phys-bits> diff --git a/src/conf/domain_capabilities.c b/src/conf/domain_capabilities.c index 68eb3c9797..8bfe19d774 100644 --- a/src/conf/domain_capabilities.c +++ b/src/conf/domain_capabilities.c @@ -42,6 +42,7 @@ VIR_ENUM_IMPL(virDomainCapsFeature, "backup", "async-teardown", "s390-pv", + "tdx", ); static virClass *virDomainCapsClass; diff --git a/src/conf/domain_capabilities.h b/src/conf/domain_capabilities.h index fadc30cdd7..690e2a1f03 100644 --- a/src/conf/domain_capabilities.h +++ b/src/conf/domain_capabilities.h @@ -250,6 +250,7 @@ typedef enum { VIR_DOMAIN_CAPS_FEATURE_BACKUP, VIR_DOMAIN_CAPS_FEATURE_ASYNC_TEARDOWN, VIR_DOMAIN_CAPS_FEATURE_S390_PV, + VIR_DOMAIN_CAPS_FEATURE_TDX, VIR_DOMAIN_CAPS_FEATURE_LAST } virDomainCapsFeature; diff --git a/src/conf/schemas/domaincaps.rng b/src/conf/schemas/domaincaps.rng index e7aa4a1066..a5522b1e67 100644 --- a/src/conf/schemas/domaincaps.rng +++ b/src/conf/schemas/domaincaps.rng @@ -308,6 +308,9 @@ <optional> <ref name="s390-pv"/> </optional> + <optional> + <ref name="tdx"/> + </optional> <optional> <ref name="sev"/> </optional> @@ -363,6 +366,12 @@ </element> </define> + <define name="tdx"> + <element name="tdx"> + <ref name="supported"/> + </element> + </define> + <define name="sev"> <element name="sev"> <ref name="supported"/> diff --git a/src/qemu/qemu_capabilities.c b/src/qemu/qemu_capabilities.c index 33d2b5f392..53a773b853 100644 --- a/src/qemu/qemu_capabilities.c +++ b/src/qemu/qemu_capabilities.c @@ -6675,6 +6675,18 @@ virQEMUCapsFillDomainFeatureHypervCaps(virQEMUCaps *qemuCaps, } +static void +virQEMUCapsFillDomainFeatureTDXCaps(virQEMUCaps *qemuCaps, + virDomainCaps *domCaps) +{ + if (domCaps->arch == VIR_ARCH_X86_64 && + domCaps->virttype == VIR_DOMAIN_VIRT_KVM && + virQEMUCapsGet(qemuCaps, QEMU_CAPS_TDX_GUEST) && + virQEMUCapsGetKVMSupportsSecureGuest(qemuCaps)) + domCaps->features[VIR_DOMAIN_CAPS_FEATURE_TDX] = VIR_TRISTATE_BOOL_YES; +} + + int virQEMUCapsFillDomainCaps(virQEMUCaps *qemuCaps, virArch hostarch, @@ -6734,6 +6746,7 @@ virQEMUCapsFillDomainCaps(virQEMUCaps *qemuCaps, virQEMUCapsFillDomainFeatureSGXCaps(qemuCaps, domCaps); virQEMUCapsFillDomainFeatureHypervCaps(qemuCaps, domCaps); virQEMUCapsFillDomainDeviceCryptoCaps(qemuCaps, crypto); + virQEMUCapsFillDomainFeatureTDXCaps(qemuCaps, domCaps); return 0; } -- 2.34.1

When 'tdx' is used, the VM will launched with Intel TDX feature enabled. TDX feature supports running encrypted VM (Trust Domain, TD) under the control of KVM. A TD runs in a CPU model which protects the confidentiality of its memory and its CPU state from other software There is a child element 'policy' and three optional element for tdx type. In 'policy', bit 0 is set to enable TDX debug, bit 28 set to enable sept-ve-disable, other bits are reserved currently. mrConfigId, mrOwner and mrOwnerConfig are base64 encoded SHA384 digest. For example: <launchSecurity type='tdx'> <policy>0x10000001</policy> <mrConfigId>xxx</mrConfigId> <mrOwner>xxx</mrOwner> <mrOwnerConfig>xxx</mrOwnerConfig> </launchSecurity> Signed-off-by: Zhenzhong Duan <zhenzhong.duan@intel.com> --- src/conf/domain_conf.c | 42 +++++++++++++++++++++++++++++++ src/conf/domain_conf.h | 9 +++++++ src/conf/schemas/domaincommon.rng | 29 +++++++++++++++++++++ src/conf/virconftypes.h | 2 ++ src/qemu/qemu_command.c | 2 ++ src/qemu/qemu_firmware.c | 1 + src/qemu/qemu_namespace.c | 1 + src/qemu/qemu_process.c | 1 + src/qemu/qemu_validate.c | 1 + 9 files changed, 88 insertions(+) diff --git a/src/conf/domain_conf.c b/src/conf/domain_conf.c index a0912062ff..c557da0c65 100644 --- a/src/conf/domain_conf.c +++ b/src/conf/domain_conf.c @@ -1508,6 +1508,7 @@ VIR_ENUM_IMPL(virDomainLaunchSecurity, "", "sev", "s390-pv", + "tdx", ); typedef enum { @@ -3832,6 +3833,10 @@ virDomainSecDefFree(virDomainSecDef *def) g_free(def->data.sev.dh_cert); g_free(def->data.sev.session); break; + case VIR_DOMAIN_LAUNCH_SECURITY_TDX: + g_free(def->data.tdx.mrconfigid); + g_free(def->data.tdx.mrowner); + g_free(def->data.tdx.mrownerconfig); case VIR_DOMAIN_LAUNCH_SECURITY_PV: case VIR_DOMAIN_LAUNCH_SECURITY_NONE: case VIR_DOMAIN_LAUNCH_SECURITY_LAST: @@ -13649,6 +13654,24 @@ virDomainSEVDefParseXML(virDomainSEVDef *def, } +static int +virDomainTDXDefParseXML(virDomainTDXDef *def, + xmlXPathContextPtr ctxt) +{ + if (virXPathULongLongBase("string(./policy)", ctxt, 16, &def->policy) < 0) { + virReportError(VIR_ERR_XML_ERROR, "%s", + _("failed to get launch security policy for launch security type TDX")); + return -1; + } + + def->mrconfigid = virXPathString("string(./mrConfigId)", ctxt); + def->mrowner = virXPathString("string(./mrOwner)", ctxt); + def->mrownerconfig = virXPathString("string(./mrOwnerConfig)", ctxt); + + return 0; +} + + static virDomainSecDef * virDomainSecDefParseXML(xmlNodePtr lsecNode, xmlXPathContextPtr ctxt) @@ -13668,6 +13691,10 @@ virDomainSecDefParseXML(xmlNodePtr lsecNode, if (virDomainSEVDefParseXML(&sec->data.sev, ctxt) < 0) return NULL; break; + case VIR_DOMAIN_LAUNCH_SECURITY_TDX: + if (virDomainTDXDefParseXML(&sec->data.tdx, ctxt) < 0) + return NULL; + break; case VIR_DOMAIN_LAUNCH_SECURITY_PV: break; case VIR_DOMAIN_LAUNCH_SECURITY_NONE: @@ -26661,6 +26688,21 @@ virDomainSecDefFormat(virBuffer *buf, virDomainSecDef *sec) break; } + case VIR_DOMAIN_LAUNCH_SECURITY_TDX: { + virDomainTDXDef *tdx = &sec->data.tdx; + + virBufferAsprintf(&childBuf, "<policy>0x%llx</policy>\n", tdx->policy); + + if (tdx->mrconfigid) + virBufferEscapeString(&childBuf, "<mrConfigId>%s</mrConfigId>\n", tdx->mrconfigid); + if (tdx->mrowner) + virBufferEscapeString(&childBuf, "<mrOwner>%s</mrOwner>\n", tdx->mrowner); + if (tdx->mrownerconfig) + virBufferEscapeString(&childBuf, "<mrOwnerConfig>%s</mrOwnerConfig>\n", tdx->mrownerconfig); + + break; + } + case VIR_DOMAIN_LAUNCH_SECURITY_PV: break; diff --git a/src/conf/domain_conf.h b/src/conf/domain_conf.h index 356c25405b..7882b7a75d 100644 --- a/src/conf/domain_conf.h +++ b/src/conf/domain_conf.h @@ -2856,6 +2856,7 @@ typedef enum { VIR_DOMAIN_LAUNCH_SECURITY_NONE, VIR_DOMAIN_LAUNCH_SECURITY_SEV, VIR_DOMAIN_LAUNCH_SECURITY_PV, + VIR_DOMAIN_LAUNCH_SECURITY_TDX, VIR_DOMAIN_LAUNCH_SECURITY_LAST, } virDomainLaunchSecurity; @@ -2872,10 +2873,18 @@ struct _virDomainSEVDef { virTristateBool kernel_hashes; }; +struct _virDomainTDXDef { + unsigned long long policy; + char *mrconfigid; + char *mrowner; + char *mrownerconfig; +}; + struct _virDomainSecDef { virDomainLaunchSecurity sectype; union { virDomainSEVDef sev; + virDomainTDXDef tdx; } data; }; diff --git a/src/conf/schemas/domaincommon.rng b/src/conf/schemas/domaincommon.rng index d84e030255..f6e1782b33 100644 --- a/src/conf/schemas/domaincommon.rng +++ b/src/conf/schemas/domaincommon.rng @@ -520,6 +520,9 @@ <value>s390-pv</value> </attribute> </group> + <group> + <ref name="launchSecurityTDX"/> + </group> </choice> </element> </define> @@ -565,6 +568,32 @@ </interleave> </define> + <define name="launchSecurityTDX"> + <attribute name="type"> + <value>tdx</value> + </attribute> + <interleave> + <element name="policy"> + <ref name="hexuint"/> + </element> + <optional> + <element name="mrConfigId"> + <data type="string"/> + </element> + </optional> + <optional> + <element name="mrOwner"> + <data type="string"/> + </element> + </optional> + <optional> + <element name="mrOwnerConfig"> + <data type="string"/> + </element> + </optional> + </interleave> + </define> + <!-- Enable or disable perf events for the domain. For each of the events the following rules apply: diff --git a/src/conf/virconftypes.h b/src/conf/virconftypes.h index 0779bc224b..e2e0bba012 100644 --- a/src/conf/virconftypes.h +++ b/src/conf/virconftypes.h @@ -212,6 +212,8 @@ typedef struct _virDomainResourceDef virDomainResourceDef; typedef struct _virDomainSEVDef virDomainSEVDef; +typedef struct _virDomainTDXDef virDomainTDXDef; + typedef struct _virDomainSecDef virDomainSecDef; typedef struct _virDomainShmemDef virDomainShmemDef; diff --git a/src/qemu/qemu_command.c b/src/qemu/qemu_command.c index 8d4442c360..dde2d5fa01 100644 --- a/src/qemu/qemu_command.c +++ b/src/qemu/qemu_command.c @@ -7037,6 +7037,7 @@ qemuBuildMachineCommandLine(virCommand *cmd, } break; case VIR_DOMAIN_LAUNCH_SECURITY_PV: + case VIR_DOMAIN_LAUNCH_SECURITY_TDX: virBufferAddLit(&buf, ",confidential-guest-support=lsec0"); break; case VIR_DOMAIN_LAUNCH_SECURITY_NONE: @@ -9758,6 +9759,7 @@ qemuBuildSecCommandLine(virDomainObj *vm, virCommand *cmd, case VIR_DOMAIN_LAUNCH_SECURITY_PV: return qemuBuildPVCommandLine(vm, cmd); break; + case VIR_DOMAIN_LAUNCH_SECURITY_TDX: case VIR_DOMAIN_LAUNCH_SECURITY_NONE: case VIR_DOMAIN_LAUNCH_SECURITY_LAST: virReportEnumRangeError(virDomainLaunchSecurity, sec->sectype); diff --git a/src/qemu/qemu_firmware.c b/src/qemu/qemu_firmware.c index 78844e3066..7ab10a9286 100644 --- a/src/qemu/qemu_firmware.c +++ b/src/qemu/qemu_firmware.c @@ -1339,6 +1339,7 @@ qemuFirmwareMatchDomain(const virDomainDef *def, } break; case VIR_DOMAIN_LAUNCH_SECURITY_PV: + case VIR_DOMAIN_LAUNCH_SECURITY_TDX: break; case VIR_DOMAIN_LAUNCH_SECURITY_NONE: case VIR_DOMAIN_LAUNCH_SECURITY_LAST: diff --git a/src/qemu/qemu_namespace.c b/src/qemu/qemu_namespace.c index 915d44310f..ac8a4b5c07 100644 --- a/src/qemu/qemu_namespace.c +++ b/src/qemu/qemu_namespace.c @@ -660,6 +660,7 @@ qemuDomainSetupLaunchSecurity(virDomainObj *vm, VIR_DEBUG("Set up launch security for SEV"); break; case VIR_DOMAIN_LAUNCH_SECURITY_PV: + case VIR_DOMAIN_LAUNCH_SECURITY_TDX: break; case VIR_DOMAIN_LAUNCH_SECURITY_NONE: case VIR_DOMAIN_LAUNCH_SECURITY_LAST: diff --git a/src/qemu/qemu_process.c b/src/qemu/qemu_process.c index da2b024f92..bd8624e3f6 100644 --- a/src/qemu/qemu_process.c +++ b/src/qemu/qemu_process.c @@ -6781,6 +6781,7 @@ qemuProcessPrepareLaunchSecurityGuestInput(virDomainObj *vm) case VIR_DOMAIN_LAUNCH_SECURITY_SEV: return qemuProcessPrepareSEVGuestInput(vm); case VIR_DOMAIN_LAUNCH_SECURITY_PV: + case VIR_DOMAIN_LAUNCH_SECURITY_TDX: return 0; case VIR_DOMAIN_LAUNCH_SECURITY_NONE: case VIR_DOMAIN_LAUNCH_SECURITY_LAST: diff --git a/src/qemu/qemu_validate.c b/src/qemu/qemu_validate.c index fd7b90e47d..ee25fd70d9 100644 --- a/src/qemu/qemu_validate.c +++ b/src/qemu/qemu_validate.c @@ -1322,6 +1322,7 @@ qemuValidateDomainDef(const virDomainDef *def, return -1; } break; + case VIR_DOMAIN_LAUNCH_SECURITY_TDX: case VIR_DOMAIN_LAUNCH_SECURITY_NONE: case VIR_DOMAIN_LAUNCH_SECURITY_LAST: virReportEnumRangeError(virDomainLaunchSecurity, def->sec->sectype); -- 2.34.1

TDX guest requires some special parameters to boot, currently: "kernel_irqchip=split" "pmu!=on" "smm!=on" "-bios" If not specified explicitly, QEMU should configure this option implicitly when start a TDX guest. Signed-off-by: Zhenzhong Duan <zhenzhong.duan@intel.com> --- src/qemu/qemu_validate.c | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/src/qemu/qemu_validate.c b/src/qemu/qemu_validate.c index db8493be68..8a3a64227e 100644 --- a/src/qemu/qemu_validate.c +++ b/src/qemu/qemu_validate.c @@ -1333,6 +1333,38 @@ qemuValidateDomainDef(const virDomainDef *def, _("Only bit0(debug) and bit28(sept-ve-disable) are supported intel TDX launch security policy")); return -1; } + if (def->features[VIR_DOMAIN_FEATURE_IOAPIC] == VIR_DOMAIN_IOAPIC_KVM) { + virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", + _("Intel TDX launch security needs split kernel irqchip")); + return -1; + } + /* Current KVM doesn't support PMU for TD guest. It returns + * error if TD is created with PMU bit being set in attributes. + * By default, QEMU disable PMU for TD guest. + */ + if (def->features[VIR_DOMAIN_FEATURE_PMU] == VIR_TRISTATE_SWITCH_ON) { + virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", + _("Intel TDX launch security is not supported with PMU enabled")); + return -1; + } + /* TDX doesn't support SMM and VMM cannot emulate SMM for TDX VMs + * because VMM cannot manipulate TDX VM's memory. + * By default, QEMU disable SMM for TD guest. + */ + if (def->features[VIR_DOMAIN_FEATURE_SMM] == VIR_TRISTATE_SWITCH_ON) { + virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", + _("Intel TDX launch security is not supported with SMM enabled")); + return -1; + } + /* TDVF(OVMF) needs to run at private memory for TD guest. TDX cannot + * support pflash device since it doesn't support read-only private memory. + * Thus load TDVF(OVMF) with -bios option for TDs. + */ + if (def->os.loader && def->os.loader->type == VIR_DOMAIN_LOADER_TYPE_PFLASH) { + virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", + _("Intel TDX launch security is not supported with pflash loader")); + return -1; + } break; case VIR_DOMAIN_LAUNCH_SECURITY_NONE: case VIR_DOMAIN_LAUNCH_SECURITY_LAST: -- 2.34.1

Add element "quoteGenerationService" to tdx launch security type. Currently it contains only one sub-element "SocketAddress". "SocketAddress" is modelized according to QEMU QAPI, supporting inet, unix, vsock and fd type and variant attributes depending on type. XML example: <launchSecurity type='tdx'> <policy>0x0</policy> <mrConfigId>xxx</mrConfigId> <mrOwner>xxx</mrOwner> <mrOwnerConfig>xxx</mrOwnerConfig> <quoteGenerationService> <SocketAddress type='vsock' cid='xxx' port='xxx'/> </quoteGenerationService> </launchSecurity> QEMU command line example: qemu-system-x86_64 \ -object '{"qom-type":"tdx-guest","id":"lsec0","sept-ve-disable":false,"mrconfigid":"xxx","mrowner":"xxx","mrownerconfig":"xxx","quote-generation-socket":{"type":"vsock","cid":"xxx","port":"xxx"}}' \ -machine pc-q35-6.0,confidential-guest-support=lsec0 Signed-off-by: Zhenzhong Duan <zhenzhong.duan@intel.com> --- src/conf/domain_conf.c | 272 +++++++++++++++++++++++++++++- src/conf/domain_conf.h | 61 +++++++ src/conf/schemas/domaincommon.rng | 106 ++++++++++++ src/qemu/qemu_command.c | 106 ++++++++++++ 4 files changed, 544 insertions(+), 1 deletion(-) diff --git a/src/conf/domain_conf.c b/src/conf/domain_conf.c index c557da0c65..e1ae8295e5 100644 --- a/src/conf/domain_conf.c +++ b/src/conf/domain_conf.c @@ -1511,6 +1511,15 @@ VIR_ENUM_IMPL(virDomainLaunchSecurity, "tdx", ); +VIR_ENUM_IMPL(virDomainSocketAddress, + VIR_DOMAIN_SOCKET_ADDRESS_LAST, + "", + "inet", + "unix", + "vsock", + "fd", +); + typedef enum { VIR_DOMAIN_NET_VHOSTUSER_MODE_NONE, VIR_DOMAIN_NET_VHOSTUSER_MODE_CLIENT, @@ -13654,6 +13663,190 @@ virDomainSEVDefParseXML(virDomainSEVDef *def, } +static int +virDomainInetSocketAddressDefParseXML(InetSocketAddress *inet, + xmlNodePtr node) +{ + int ret; + + if (!(inet->host = virXMLPropString(node, "host"))) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("missing host for inet socket address")); + return -1; + } + + if (!(inet->port = virXMLPropString(node, "port"))) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("missing port for inet socket address")); + return -1; + } + + if (virXMLPropTristateBool(node, "numeric", VIR_XML_PROP_NONE, + &inet->numeric) < 0) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("wrong attribute numeric for inet socket address")); + return -1; + } + + if ((ret = virXMLPropUInt(node, "to", 10, VIR_XML_PROP_NONE, + &inet->to)) < 0) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("wrong attribute to for inet socket address")); + return -1; + } + if (!ret) + inet->has_to = true; + + if (virXMLPropTristateBool(node, "ipv4", VIR_XML_PROP_NONE, + &inet->ipv4) < 0) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("wrong attribute ipv4 for inet socket address")); + return -1; + } + + if (virXMLPropTristateBool(node, "ipv6", VIR_XML_PROP_NONE, + &inet->ipv6) < 0) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("wrong attribute ipv6 for inet socket address")); + return -1; + } + + if (virXMLPropTristateBool(node, "keep_alive", VIR_XML_PROP_NONE, + &inet->keep_alive) < 0) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("wrong attribute keep_alive for inet socket address")); + return -1; + } + + if (virXMLPropTristateBool(node, "mptcp", VIR_XML_PROP_NONE, + &inet->mptcp) < 0) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("wrong attribute mptcp for inet socket address")); + return -1; + } + + return 0; +} + + +static int +virDomainUnixSocketAddressDefParseXML(UnixSocketAddress *Unix, + xmlNodePtr node) +{ + if (!(Unix->path = virXMLPropString(node, "path"))) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("missing path for unix socket address")); + return -1; + } + + if (virXMLPropTristateBool(node, "abstract", VIR_XML_PROP_NONE, + &Unix->abstract) < 0) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("wrong attribute abstract for unix socket address")); + return -1; + } + + if (virXMLPropTristateBool(node, "tight", VIR_XML_PROP_NONE, + &Unix->tight) < 0) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("wrong attribute tight for unix socket address")); + return -1; + } + + return 0; +} + + +static int +virDomainVsockSocketAddressDefParseXML(VsockSocketAddress *vsock, + xmlNodePtr node) +{ + if (!(vsock->cid = virXMLPropString(node, "cid"))) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("missing cid for vsock socket address")); + return -1; + } + + if (!(vsock->port = virXMLPropString(node, "port"))) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("missing port for vsock socket address")); + return -1; + } + + return 0; +} + + +static int +virDomainFdSocketAddressDefParseXML(FdSocketAddress *fd, + xmlNodePtr node) +{ + if (!(fd->str = virXMLPropString(node, "str"))) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("missing fd for fd socket address")); + return -1; + } + + return 0; +} + + +static int +virDomainTDXQGSDefParseXML(virDomainTDXDef *def, xmlXPathContextPtr ctxt) +{ + g_autofree xmlNodePtr *nodes = NULL; + SocketAddress *sa = &def->qgs_sa; + xmlNodePtr node; + int n; + + if ((n = virXPathNodeSet("./quoteGenerationService/SocketAddress", + ctxt, &nodes)) < 0) + return -1; + + if (!n) + return 0; + + if (n > 1) { + virReportError(VIR_ERR_XML_ERROR, "%s", + _("only a single QGS element is supported")); + return -1; + } + node = nodes[0]; + + if (virXMLPropEnum(node, "type", virDomainSocketAddressTypeFromString, + VIR_XML_PROP_REQUIRED, &sa->type) < 0) + return -1; + + switch ((virDomainSocketAddress) def->qgs_sa.type) { + case VIR_DOMAIN_SOCKET_ADDRESS_INET: + if (virDomainInetSocketAddressDefParseXML(&sa->u.inet, node) < 0) + return -1; + break; + case VIR_DOMAIN_SOCKET_ADDRESS_UNIX: + if (virDomainUnixSocketAddressDefParseXML(&sa->u.Unix, node) < 0) + return -1; + break; + case VIR_DOMAIN_SOCKET_ADDRESS_VSOCK: + if (virDomainVsockSocketAddressDefParseXML(&sa->u.vsock, node) < 0) + return -1; + break; + case VIR_DOMAIN_SOCKET_ADDRESS_FD: + if (virDomainFdSocketAddressDefParseXML(&sa->u.fd, node) < 0) + return -1; + break; + case VIR_DOMAIN_SOCKET_ADDRESS_NONE: + case VIR_DOMAIN_SOCKET_ADDRESS_LAST: + default: + virReportError(VIR_ERR_XML_ERROR, + _("unsupported socket address type '%1$s'"), + virDomainSocketAddressTypeToString(def->qgs_sa.type)); + return -1; + } + + return 0; +} + + static int virDomainTDXDefParseXML(virDomainTDXDef *def, xmlXPathContextPtr ctxt) @@ -13668,7 +13861,7 @@ virDomainTDXDefParseXML(virDomainTDXDef *def, def->mrowner = virXPathString("string(./mrOwner)", ctxt); def->mrownerconfig = virXPathString("string(./mrOwnerConfig)", ctxt); - return 0; + return virDomainTDXQGSDefParseXML(def, ctxt); } @@ -26652,6 +26845,82 @@ virDomainKeyWrapDefFormat(virBuffer *buf, virDomainKeyWrapDef *keywrap) } +static void +virDomainTDXQGSDefFormat(virBuffer *buf, virDomainTDXDef *tdx) +{ + SocketAddress *sa = &tdx->qgs_sa; + + if (sa->type == VIR_DOMAIN_SOCKET_ADDRESS_NONE) + return; + + virBufferAddLit(buf, "<quoteGenerationService>\n"); + virBufferAdjustIndent(buf, 2); + virBufferAsprintf(buf, "<SocketAddress type='%s'", + virDomainSocketAddressTypeToString(sa->type)); + + switch ((virDomainSocketAddress) sa->type) { + case VIR_DOMAIN_SOCKET_ADDRESS_INET: + { + InetSocketAddress *inet = &sa->u.inet; + + virBufferAsprintf(buf, " host='%s' port='%s'", inet->host, inet->port); + if (inet->numeric != VIR_TRISTATE_BOOL_ABSENT) + virBufferAsprintf(buf, " numeric='%s'", + virTristateBoolTypeToString(inet->numeric)); + if (inet->to) + virBufferAsprintf(buf, " to='%d'", inet->to); + if (inet->ipv4 != VIR_TRISTATE_BOOL_ABSENT) + virBufferAsprintf(buf, " ipv4='%s'", + virTristateBoolTypeToString(inet->ipv4)); + if (inet->ipv6 != VIR_TRISTATE_BOOL_ABSENT) + virBufferAsprintf(buf, " ipv6='%s'", + virTristateBoolTypeToString(inet->ipv6)); + if (inet->keep_alive != VIR_TRISTATE_BOOL_ABSENT) + virBufferAsprintf(buf, " keep_alive='%s'", + virTristateBoolTypeToString(inet->keep_alive)); + if (inet->mptcp != VIR_TRISTATE_BOOL_ABSENT) + virBufferAsprintf(buf, " mptcp='%s'", + virTristateBoolTypeToString(inet->mptcp)); + break; + } + case VIR_DOMAIN_SOCKET_ADDRESS_UNIX: + { + UnixSocketAddress *Unix = &sa->u.Unix; + + virBufferAsprintf(buf, " path='%s'", Unix->path); + if (Unix->abstract != VIR_TRISTATE_BOOL_ABSENT) + virBufferAsprintf(buf, " abstract='%s'", + virTristateBoolTypeToString(Unix->abstract)); + if (Unix->tight != VIR_TRISTATE_BOOL_ABSENT) + virBufferAsprintf(buf, " tight='%s'", + virTristateBoolTypeToString(Unix->tight)); + break; + } + case VIR_DOMAIN_SOCKET_ADDRESS_VSOCK: + { + VsockSocketAddress *vsock = &sa->u.vsock; + + virBufferAsprintf(buf, " cid='%s' port='%s'", vsock->cid, vsock->port); + break; + } + case VIR_DOMAIN_SOCKET_ADDRESS_FD: + { + FdSocketAddress *fd = &sa->u.fd; + + virBufferAsprintf(buf, " str='%s'", fd->str); + break; + } + case VIR_DOMAIN_SOCKET_ADDRESS_NONE: + case VIR_DOMAIN_SOCKET_ADDRESS_LAST: + default: + break; + } + virBufferAddLit(buf, "/>\n"); + virBufferAdjustIndent(buf, -2); + virBufferAddLit(buf, "</quoteGenerationService>\n"); +} + + static void virDomainSecDefFormat(virBuffer *buf, virDomainSecDef *sec) { @@ -26699,6 +26968,7 @@ virDomainSecDefFormat(virBuffer *buf, virDomainSecDef *sec) virBufferEscapeString(&childBuf, "<mrOwner>%s</mrOwner>\n", tdx->mrowner); if (tdx->mrownerconfig) virBufferEscapeString(&childBuf, "<mrOwnerConfig>%s</mrOwnerConfig>\n", tdx->mrownerconfig); + virDomainTDXQGSDefFormat(&childBuf, tdx); break; } diff --git a/src/conf/domain_conf.h b/src/conf/domain_conf.h index bb4973fce8..15cdb3e0e6 100644 --- a/src/conf/domain_conf.h +++ b/src/conf/domain_conf.h @@ -2852,6 +2852,55 @@ struct _virDomainKeyWrapDef { virTristateSwitch dea; }; +typedef enum { + VIR_DOMAIN_SOCKET_ADDRESS_NONE, + VIR_DOMAIN_SOCKET_ADDRESS_INET, + VIR_DOMAIN_SOCKET_ADDRESS_UNIX, + VIR_DOMAIN_SOCKET_ADDRESS_VSOCK, + VIR_DOMAIN_SOCKET_ADDRESS_FD, + + VIR_DOMAIN_SOCKET_ADDRESS_LAST +} virDomainSocketAddress; + +typedef struct _InetSocketAddress InetSocketAddress; +typedef struct _UnixSocketAddress UnixSocketAddress; +typedef struct _VsockSocketAddress VsockSocketAddress; +typedef struct _FdSocketAddress FdSocketAddress; + +struct _InetSocketAddress { + char *host; + char *port; + bool has_numeric; + virTristateBool numeric; + bool has_to; + unsigned int to; + bool has_ipv4; + virTristateBool ipv4; + bool has_ipv6; + virTristateBool ipv6; + bool has_keep_alive; + virTristateBool keep_alive; + bool has_mptcp; + virTristateBool mptcp; +}; + +struct _UnixSocketAddress { + char *path; + bool has_abstract; + virTristateBool abstract; + bool has_tight; + virTristateBool tight; +}; + +struct _VsockSocketAddress { + char *cid; + char *port; +}; + +struct _FdSocketAddress { + char *str; +}; + typedef enum { VIR_DOMAIN_LAUNCH_SECURITY_NONE, VIR_DOMAIN_LAUNCH_SECURITY_SEV, @@ -2873,11 +2922,22 @@ struct _virDomainSEVDef { virTristateBool kernel_hashes; }; +typedef struct SocketAddress { + virDomainSocketAddress type; + union { + InetSocketAddress inet; + UnixSocketAddress Unix; + VsockSocketAddress vsock; + FdSocketAddress fd; + } u; +} SocketAddress; + struct _virDomainTDXDef { unsigned long long policy; char *mrconfigid; char *mrowner; char *mrownerconfig; + SocketAddress qgs_sa; }; #define VIR_DOMAIN_TDX_POLICY_DEBUG 0x1 @@ -4258,6 +4318,7 @@ VIR_ENUM_DECL(virDomainCryptoBackend); VIR_ENUM_DECL(virDomainShmemModel); VIR_ENUM_DECL(virDomainShmemRole); VIR_ENUM_DECL(virDomainLaunchSecurity); +VIR_ENUM_DECL(virDomainSocketAddress); /* from libvirt.h */ VIR_ENUM_DECL(virDomainState); VIR_ENUM_DECL(virDomainNostateReason); diff --git a/src/conf/schemas/domaincommon.rng b/src/conf/schemas/domaincommon.rng index f6e1782b33..e8cc78992a 100644 --- a/src/conf/schemas/domaincommon.rng +++ b/src/conf/schemas/domaincommon.rng @@ -591,9 +591,115 @@ <data type="string"/> </element> </optional> + <optional> + <element name="quoteGenerationService"> + <ref name="SocketAddress"/> + </element> + </optional> </interleave> </define> + <define name="SocketAddress"> + <element name="SocketAddress"> + <choice> + <group> + <ref name="InetSocketAddress"/> + </group> + <group> + <ref name="UnixSocketAddress"/> + </group> + <group> + <ref name="VsockSocketAddress"/> + </group> + <group> + <ref name="FdSocketAddress"/> + </group> + </choice> + </element> + </define> + + <define name="InetSocketAddress"> + <attribute name="type"> + <value>inet</value> + </attribute> + <attribute name="host"> + <data type="string"/> + </attribute> + <attribute name="port"> + <data type="string"/> + </attribute> + <optional> + <attribute name="numeric"> + <ref name="virYesNo"/> + </attribute> + </optional> + <optional> + <attribute name="to"> + <ref name="uint16"/> + </attribute> + </optional> + <optional> + <attribute name="ipv4"> + <ref name="virYesNo"/> + </attribute> + </optional> + <optional> + <attribute name="ipv6"> + <ref name="virYesNo"/> + </attribute> + </optional> + <optional> + <attribute name="keep_alive"> + <ref name="virYesNo"/> + </attribute> + </optional> + <optional> + <attribute name="mptcp"> + <ref name="virYesNo"/> + </attribute> + </optional> + </define> + + <define name="UnixSocketAddress"> + <attribute name="type"> + <value>unix</value> + </attribute> + <attribute name="path"> + <data type="string"/> + </attribute> + <optional> + <attribute name="abstract"> + <ref name="virYesNo"/> + </attribute> + </optional> + <optional> + <attribute name="tight"> + <ref name="virYesNo"/> + </attribute> + </optional> + </define> + + <define name="VsockSocketAddress"> + <attribute name="type"> + <value>vsock</value> + </attribute> + <attribute name="cid"> + <data type="string"/> + </attribute> + <attribute name="port"> + <data type="string"/> + </attribute> + </define> + + <define name="FdSocketAddress"> + <attribute name="type"> + <value>fd</value> + </attribute> + <attribute name="str"> + <data type="string"/> + </attribute> + </define> + <!-- Enable or disable perf events for the domain. For each of the events the following rules apply: diff --git a/src/qemu/qemu_command.c b/src/qemu/qemu_command.c index d212d80038..05fec05cd5 100644 --- a/src/qemu/qemu_command.c +++ b/src/qemu/qemu_command.c @@ -9745,21 +9745,127 @@ qemuBuildPVCommandLine(virDomainObj *vm, virCommand *cmd) } +static virJSONValue * +qemuJSONBuildInetSocketAddress(const InetSocketAddress *inet) +{ + g_autoptr(virJSONValue) addr = NULL; + g_autoptr(virJSONValue) data = NULL; + + if (virJSONValueObjectAdd(&addr, + "s:type", "inet", + "s:host", inet->host, + "s:port", inet->port, + "T:numeric", inet->numeric, + "p:to", inet->to, + "T:ipv4", inet->ipv4, + "T:ipv6", inet->ipv6, + "T:keep-alive", inet->keep_alive, + "T:mptcp", inet->mptcp, + NULL) < 0) + return NULL; + + return g_steal_pointer(&addr); +} + + +static virJSONValue * +qemuJSONBuildUnixSocketAddress(const UnixSocketAddress *Unix) +{ + g_autoptr(virJSONValue) addr = NULL; + g_autoptr(virJSONValue) data = NULL; + + if (virJSONValueObjectAdd(&addr, + "s:type", "unix", + "s:path", Unix->path, + "T:abstract", Unix->abstract, + "T:tight", Unix->tight, + NULL) < 0) + return NULL; + + return g_steal_pointer(&addr); +} + + +static virJSONValue * +qemuJSONBuildVsockSocketAddress(const VsockSocketAddress *vsock) +{ + g_autoptr(virJSONValue) addr = NULL; + g_autoptr(virJSONValue) data = NULL; + + if (virJSONValueObjectAdd(&addr, + "s:type", "vsock", + "s:cid", vsock->cid, + "s:port", vsock->port, + NULL) < 0) + return NULL; + + return g_steal_pointer(&addr); +} + + +static virJSONValue * +qemuJSONBuildFdSocketAddress(const FdSocketAddress *fd) +{ + g_autoptr(virJSONValue) addr = NULL; + g_autoptr(virJSONValue) data = NULL; + + if (virJSONValueObjectAdd(&addr, + "s:type", "fd", + "s:str", fd->str, + NULL) < 0) + return NULL; + + return g_steal_pointer(&addr); +} + + +static virJSONValue * +qemuBuildTDXQGSCommandLine(virDomainTDXDef *tdx) +{ + g_autoptr(virJSONValue) addr = NULL; + + switch ((virDomainSocketAddress) tdx->qgs_sa.type) { + case VIR_DOMAIN_SOCKET_ADDRESS_INET: + addr = qemuJSONBuildInetSocketAddress(&tdx->qgs_sa.u.inet); + break; + case VIR_DOMAIN_SOCKET_ADDRESS_UNIX: + addr = qemuJSONBuildUnixSocketAddress(&tdx->qgs_sa.u.Unix); + break; + case VIR_DOMAIN_SOCKET_ADDRESS_VSOCK: + addr = qemuJSONBuildVsockSocketAddress(&tdx->qgs_sa.u.vsock); + break; + case VIR_DOMAIN_SOCKET_ADDRESS_FD: + addr = qemuJSONBuildFdSocketAddress(&tdx->qgs_sa.u.fd); + break; + case VIR_DOMAIN_SOCKET_ADDRESS_NONE: + case VIR_DOMAIN_SOCKET_ADDRESS_LAST: + default: + return NULL; + } + + return g_steal_pointer(&addr); +} + + static int qemuBuildTDXCommandLine(virDomainObj *vm, virCommand *cmd, virDomainTDXDef *tdx) { + g_autoptr(virJSONValue) addr = NULL; g_autoptr(virJSONValue) props = NULL; qemuDomainObjPrivate *priv = vm->privateData; bool sept_ve_disable = tdx->policy & VIR_DOMAIN_TDX_POLICY_SEPT_VE_DISABLE; VIR_DEBUG("policy=0x%llx", tdx->policy); + addr = qemuBuildTDXQGSCommandLine(tdx); + if (qemuMonitorCreateObjectProps(&props, "tdx-guest", "lsec0", "B:debug", !!(tdx->policy & VIR_DOMAIN_TDX_POLICY_DEBUG), "S:mrconfigid", tdx->mrconfigid, "S:mrowner", tdx->mrowner, "S:mrownerconfig", tdx->mrownerconfig, + "A:quote-generation-socket", &addr, NULL) < 0) return -1; -- 2.34.1

Signed-off-by: Zhenzhong Duan <zhenzhong.duan@intel.com> --- docs/formatdomain.rst | 68 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 68 insertions(+) diff --git a/docs/formatdomain.rst b/docs/formatdomain.rst index 83c1405c17..5ee9f3a426 100644 --- a/docs/formatdomain.rst +++ b/docs/formatdomain.rst @@ -8851,6 +8851,74 @@ spec <https://support.amd.com/TechDocs/55766_SEV-KM_API_Specification.pdf>`__ session blob defined in the SEV API spec. See SEV spec LAUNCH_START section for the session blob format. + +The contents of the ``<launchSecurity type='tdx'>`` element is used to provide +the guest owners input used for creating an encrypted VM using the Intel TDX +(Trusted Domain eXtensions). Intel TDX refers to an Intel technology that +extends Virtual Machine Extensions (VMX) and Multi-Key Total Memory Encryption +(MKTME) with a new kind of virtual machine guest called a Trust Domain (TD). +A TD runs in a CPU mode that is designed to protect the confidentiality of its +memory contents and its CPU state from any other software, including the hosting +Virtual Machine Monitor (VMM), unless explicitly shared by the TD itself. + +:: + + <domain> + ... + <launchSecurity type='tdx'> + <policy>0x10000001</policy> + <mrConfigId>xxx</mrConfigId> + <mrOwner>xxx</mrOwner> + <mrOwnerConfig>xxx</mrOwnerConfig> + <quoteGenerationService> + <SocketAddress type='vsock' cid='xxx' port='xxx'/> + </quoteGenerationService> + ... + </domain> + +``policy`` + The required ``policy`` element provides the guest TD attributes which is + passed by the host VMM as a guest TD initialization parameter as part of + TD_PARAMS, it exactly matches the definition of TD_PARAMS.ATTRIBUTES in + (Intel TDX Module Spec Table 22.2: ATTRIBUTES Definition). It is reported + to the guest TD by TDG.VP.INFO and as part of TDREPORT_STRUCT returned by + TDG.MR.REPORT. The guest policy is a 8 unsigned byte with the fields shown + in Table: + + ====== ==================================================================================== + Bit(s) Description + ====== ==================================================================================== + 0 Guest TD runs in off-TD debug mode when set + 1:27 reserved + 28 Disable EPT violation conversion to #VE on guest TD access of PENDING pages when set + 29:63 reserved + ====== ==================================================================================== + +``mrConfigId`` + The optional ``mrConfigId`` element provides ID for non-owner-defined + configuration of the guest TD, e.g., run-time or OS configuration + (base64 encoded SHA384 digest). + +``@mrowner`` + The optional ``@mrowner`` element provides ID for the guest TD’s owner + (base64 encoded SHA384 digest). + +``mrownerconfig`` + The optional ``mrownerconfig`` element provides ID for owner-defined + configuration of the guest TD, e.g., specific to the workload rather than + the run-time or OS (base64 encoded SHA384 digest). + +``quoteGenerationService`` + The optional ``quoteGenerationService`` subelement provides Quote + Generation Service(QGS) related configuration. QGS is a daemon running + on the host. User in TD guest cannot get TD quoting for attestation if + QGS is not provided. Currently only one subelement ``SocketAddress``. + + ``SocketAddress`` + The required ``SocketAddress`` element provides socket address for QGS. + Different properties of ``SocketAddress`` are supported depending on + value of ``type`` property which can be "inet", "unix", "vsock" and "fd". + Example configs =============== -- 2.34.1