Add check in virt-host-validate for secure guest support on x86 for Intel Trust Domain Extentions. Suggested-by: Daniel P. Berrangé <berrange(a)redhat.com&gt; Signed-off-by: Zhenzhong Duan <zhenzhong.duan(a)intel.com&gt; --- 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

This string is used to compare with output of /proc/cpuinfo. So we can't use 'tdx', or else string compare will fail. Thanks Zhenzhong

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(a)intel.com&gt; Reviewed-by: Daniel P. Berrangé <berrange(a)redhat.com&gt; --- 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

Go it. Thanks Zhenzhong

Extend qemu TDX capability to domain capabilities. Signed-off-by: Chenyi Qiang <chenyi.qiang(a)intel.com&gt; Signed-off-by: Zhenzhong Duan <zhenzhong.duan(a)intel.com&gt; --- 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(a)intel.com&gt; --- 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

Will do. Thanks Zhenzhong

On Fri, May 24, 2024 at 02:21:21PM +0800, Zhenzhong Duan wrote: I like that you've just exposed the "policy" as an int field in libvirt, but find it unpleasant that we have to unpack it to pass bits to QEMU, whereupon QEMU re-packs it into the original int field we already had. I think this is a mistake in the QEMU QAPI design - QEMU shoud just accept the policy in 'int' format. I've CC'd you on a mail to qemu-devel where I raise this point. With regards, Daniel -- |: https://berrange.com -o- https://www.flickr.com/photos/dberrange :| |: https://libvirt.org -o- https://fstop138.berrange.com :| |: https://entangle-photo.org -o- https://www.instagram.com/dberrange :|

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(a)intel.com&gt; --- 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(a)intel.com&gt; --- 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

Got it, will do. Good catch, I copied from qemu QAPI but forgot to cleanup. I'll remove them all except 'has_to'. Thanks Zhenzhong

On Fri, May 24, 2024 at 02:21:24PM +0800, Zhenzhong Duan wrote: snip So the 'qemuProcessFakeReboot' currently fakes reboot via a machine CPU reset. This new code fakes reboot via QEMU re-creation. I'd suggest that the current method gets renamed to qemuProcessFakeRebootViaReset(), then your new qemuProcessSecFakeReboot() gets renamed to qemuProcessFakeRebootViaRecreate(). Then create a qemuProcessFakeReboot, that calls into either qemuProcessFakeRebootViaReset or qemuProcessFakeRebootViaRecreate as appropriate. With regards, Daniel -- |: https://berrange.com -o- https://www.flickr.com/photos/dberrange :| |: https://libvirt.org -o- https://fstop138.berrange.com :| |: https://entangle-photo.org -o- https://www.instagram.com/dberrange :|

Signed-off-by: Zhenzhong Duan <zhenzhong.duan(a)intel.com&gt; --- 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