Message ID | 50386eddbb8046b0b222d385e56e8115ed566526.1685887183.git.kai.huang@intel.com (mailing list archive) |
---|---|
State | New, archived |
Headers | show |
Series | TDX host kernel support | expand |
On 6/4/23 07:27, Kai Huang wrote: > Start to transit out the "multi-steps" to initialize the TDX module. > > TDX provides increased levels of memory confidentiality and integrity. > This requires special hardware support for features like memory > encryption and storage of memory integrity checksums. Not all memory > satisfies these requirements. > > As a result, TDX introduced the concept of a "Convertible Memory Region" > (CMR). During boot, the firmware builds a list of all of the memory > ranges which can provide the TDX security guarantees. > > CMRs tell the kernel which memory is TDX compatible. The kernel takes > CMRs (plus a little more metadata) and constructs "TD Memory Regions" > (TDMRs). TDMRs let the kernel grant TDX protections to some or all of > the CMR areas. > > The TDX module also reports necessary information to let the kernel > build TDMRs and run TDX guests in structure 'tdsysinfo_struct'. The > list of CMRs, along with the TDX module information, is available to > the kernel by querying the TDX module. > > As a preparation to construct TDMRs, get the TDX module information and > the list of CMRs. Print out CMRs to help user to decode which memory > regions are TDX convertible. > > The 'tdsysinfo_struct' is fairly large (1024 bytes) and contains a lot > of info about the TDX module. Fully define the entire structure, but > only use the fields necessary to build the TDMRs and pr_info() some > basics about the module. The rest of the fields will get used by KVM. > > For now both 'tdsysinfo_struct' and CMRs are only used during the module > initialization. But because they are both relatively big, declare them > inside the module initialization function but as static variables. > > Signed-off-by: Kai Huang <kai.huang@intel.com> > Reviewed-by: Isaku Yamahata <isaku.yamahata@intel.com> Reviewed-by: Dave Hansen <dave.hansen@linux.intel.com>
On Mon, Jun 05, 2023 at 02:27:21AM +1200, Kai Huang wrote: > For now both 'tdsysinfo_struct' and CMRs are only used during the module > initialization. But because they are both relatively big, declare them > inside the module initialization function but as static variables. This justification does not make sense to me. static variables will not be freed after function returned. They will still consume memory. I think you need to allocate/free memory dynamically, if they are too big for stack. ... > static int init_tdx_module(void) > { > + static DECLARE_PADDED_STRUCT(tdsysinfo_struct, tdsysinfo, > + TDSYSINFO_STRUCT_SIZE, TDSYSINFO_STRUCT_ALIGNMENT); > + static struct cmr_info cmr_array[MAX_CMRS] > + __aligned(CMR_INFO_ARRAY_ALIGNMENT);
On Thu, 2023-06-08 at 03:27 +0300, kirill.shutemov@linux.intel.com wrote: > On Mon, Jun 05, 2023 at 02:27:21AM +1200, Kai Huang wrote: > > For now both 'tdsysinfo_struct' and CMRs are only used during the module > > initialization. But because they are both relatively big, declare them > > inside the module initialization function but as static variables. > > This justification does not make sense to me. static variables will not be > freed after function returned. They will still consume memory. > > I think you need to allocate/free memory dynamically, if they are too big > for stack. I do need to keep tdsysinfo_struct as it will be used by KVM too. CMRs are not used by KVM now but they might get used in the future, e.g., we may want to expose them to /sys in the future. Also it takes more lines of code to do dynamic allocation. I'd prefer the code simplicity. Dave is fine with static too, but prefers to putting them inside the function: https://lore.kernel.org/lkml/cover.1670566861.git.kai.huang@intel.com/T/#mbfdaa353278588da09e43f3ce37b7bf8ddedc1b2 I can update the changelog to reflect above: For now both 'tdsysinfo_struct' and CMRs are only used during the module initialization. KVM will need to at least use 'tdsysinfo_struct' when supporting TDX guests. For now just declare them inside the module initialization function but as static variables. ?
On Thu, Jun 08, 2023 at 02:40:27AM +0000, Huang, Kai wrote: > On Thu, 2023-06-08 at 03:27 +0300, kirill.shutemov@linux.intel.com wrote: > > On Mon, Jun 05, 2023 at 02:27:21AM +1200, Kai Huang wrote: > > > For now both 'tdsysinfo_struct' and CMRs are only used during the module > > > initialization. But because they are both relatively big, declare them > > > inside the module initialization function but as static variables. > > > > This justification does not make sense to me. static variables will not be > > freed after function returned. They will still consume memory. > > > > I think you need to allocate/free memory dynamically, if they are too big > > for stack. > > > I do need to keep tdsysinfo_struct as it will be used by KVM too. Will you pass it down to KVM from this function? Will KVM use the struct after the function returns? > CMRs are not > used by KVM now but they might get used in the future, e.g., we may want to > expose them to /sys in the future. > > Also it takes more lines of code to do dynamic allocation. I'd prefer the code > simplicity. These structures take 1.5K of memory and the memory will be allocated for all machines that boots the kernel with TDX enabled, regardless if the machine has TDX or not. It seems very wasteful to me.
On 6/8/23 04:41, kirill.shutemov@linux.intel.com wrote: > These structures take 1.5K of memory and the memory will be allocated for > all machines that boots the kernel with TDX enabled, regardless if the > machine has TDX or not. It seems very wasteful to me. Actually, those variables are in .bss. They're allocated forever for anyone that runs a kernel that has TDX support.
On Thu, Jun 08, 2023 at 02:41:28PM +0300, "kirill.shutemov@linux.intel.com" <kirill.shutemov@linux.intel.com> wrote: > On Thu, Jun 08, 2023 at 02:40:27AM +0000, Huang, Kai wrote: > > On Thu, 2023-06-08 at 03:27 +0300, kirill.shutemov@linux.intel.com wrote: > > > On Mon, Jun 05, 2023 at 02:27:21AM +1200, Kai Huang wrote: > > > > For now both 'tdsysinfo_struct' and CMRs are only used during the module > > > > initialization. But because they are both relatively big, declare them > > > > inside the module initialization function but as static variables. > > > > > > This justification does not make sense to me. static variables will not be > > > freed after function returned. They will still consume memory. > > > > > > I think you need to allocate/free memory dynamically, if they are too big > > > for stack. > > > > > > I do need to keep tdsysinfo_struct as it will be used by KVM too. > > Will you pass it down to KVM from this function? Will KVM use the struct > after the function returns? KVM needs tdsysinfo_struct to create guest TD. It doesn't require 1024-alignment.
On Thu, Jun 08, 2023 at 04:29:19PM -0700, Isaku Yamahata wrote: > On Thu, Jun 08, 2023 at 02:41:28PM +0300, > "kirill.shutemov@linux.intel.com" <kirill.shutemov@linux.intel.com> wrote: > > > On Thu, Jun 08, 2023 at 02:40:27AM +0000, Huang, Kai wrote: > > > On Thu, 2023-06-08 at 03:27 +0300, kirill.shutemov@linux.intel.com wrote: > > > > On Mon, Jun 05, 2023 at 02:27:21AM +1200, Kai Huang wrote: > > > > > For now both 'tdsysinfo_struct' and CMRs are only used during the module > > > > > initialization. But because they are both relatively big, declare them > > > > > inside the module initialization function but as static variables. > > > > > > > > This justification does not make sense to me. static variables will not be > > > > freed after function returned. They will still consume memory. > > > > > > > > I think you need to allocate/free memory dynamically, if they are too big > > > > for stack. > > > > > > > > > I do need to keep tdsysinfo_struct as it will be used by KVM too. > > > > Will you pass it down to KVM from this function? Will KVM use the struct > > after the function returns? > > KVM needs tdsysinfo_struct to create guest TD. It doesn't require > 1024-alignment. How KVM gets it from here?
On Fri, Jun 09, 2023 at 02:54:41AM +0300, "kirill.shutemov@linux.intel.com" <kirill.shutemov@linux.intel.com> wrote: > On Thu, Jun 08, 2023 at 04:29:19PM -0700, Isaku Yamahata wrote: > > On Thu, Jun 08, 2023 at 02:41:28PM +0300, > > "kirill.shutemov@linux.intel.com" <kirill.shutemov@linux.intel.com> wrote: > > > > > On Thu, Jun 08, 2023 at 02:40:27AM +0000, Huang, Kai wrote: > > > > On Thu, 2023-06-08 at 03:27 +0300, kirill.shutemov@linux.intel.com wrote: > > > > > On Mon, Jun 05, 2023 at 02:27:21AM +1200, Kai Huang wrote: > > > > > > For now both 'tdsysinfo_struct' and CMRs are only used during the module > > > > > > initialization. But because they are both relatively big, declare them > > > > > > inside the module initialization function but as static variables. > > > > > > > > > > This justification does not make sense to me. static variables will not be > > > > > freed after function returned. They will still consume memory. > > > > > > > > > > I think you need to allocate/free memory dynamically, if they are too big > > > > > for stack. > > > > > > > > > > > > I do need to keep tdsysinfo_struct as it will be used by KVM too. > > > > > > Will you pass it down to KVM from this function? Will KVM use the struct > > > after the function returns? > > > > KVM needs tdsysinfo_struct to create guest TD. It doesn't require > > 1024-alignment. > > How KVM gets it from here? For now, TDX KVM patch series moves the tdsysinfo out of the function, and add a getter function of it. As long as KVM can access the info, it doesn't care how its memory is allocated. static or dynamic.
> @@ -21,6 +23,76 @@ > */ > #define TDH_SYS_INIT 33 > #define TDH_SYS_LP_INIT 35 > +#define TDH_SYS_INFO 32 Could you keep these defines ordered? Here and all following patches.
On Thu, 2023-06-08 at 06:13 -0700, Dave Hansen wrote: > On 6/8/23 04:41, kirill.shutemov@linux.intel.com wrote: > > These structures take 1.5K of memory and the memory will be allocated for > > all machines that boots the kernel with TDX enabled, regardless if the > > machine has TDX or not. It seems very wasteful to me. > > Actually, those variables are in .bss. They're allocated forever for > anyone that runs a kernel that has TDX support. > Hi Dave/Kirill, Thanks for feedback. My understanding is you both prefer dynamic allocation. I'll change to use that. Also I will free them after module initialization as for now they are only used by module initialization. Please let me know if you have any comments.
On Fri, 2023-06-09 at 13:02 +0300, kirill.shutemov@linux.intel.com wrote: > > @@ -21,6 +23,76 @@ > > */ > > #define TDH_SYS_INIT 33 > > #define TDH_SYS_LP_INIT 35 > > +#define TDH_SYS_INFO 32 > > Could you keep these defines ordered? Here and all following patches. > Sure will do. Thanks.
On 04.06.23 16:27, Kai Huang wrote: > Start to transit out the "multi-steps" to initialize the TDX module. > > TDX provides increased levels of memory confidentiality and integrity. > This requires special hardware support for features like memory > encryption and storage of memory integrity checksums. Not all memory > satisfies these requirements. > > As a result, TDX introduced the concept of a "Convertible Memory Region" > (CMR). During boot, the firmware builds a list of all of the memory > ranges which can provide the TDX security guarantees. > > CMRs tell the kernel which memory is TDX compatible. The kernel takes > CMRs (plus a little more metadata) and constructs "TD Memory Regions" > (TDMRs). TDMRs let the kernel grant TDX protections to some or all of > the CMR areas. > > The TDX module also reports necessary information to let the kernel > build TDMRs and run TDX guests in structure 'tdsysinfo_struct'. The > list of CMRs, along with the TDX module information, is available to > the kernel by querying the TDX module. > > As a preparation to construct TDMRs, get the TDX module information and > the list of CMRs. Print out CMRs to help user to decode which memory > regions are TDX convertible. > > The 'tdsysinfo_struct' is fairly large (1024 bytes) and contains a lot > of info about the TDX module. Fully define the entire structure, but > only use the fields necessary to build the TDMRs and pr_info() some > basics about the module. The rest of the fields will get used by KVM. > > For now both 'tdsysinfo_struct' and CMRs are only used during the module > initialization. But because they are both relatively big, declare them > inside the module initialization function but as static variables. > > Signed-off-by: Kai Huang <kai.huang@intel.com> > Reviewed-by: Isaku Yamahata <isaku.yamahata@intel.com> > --- [...] > --- > arch/x86/virt/vmx/tdx/tdx.c | 67 +++++++++++++++++++++++++++++++++- > arch/x86/virt/vmx/tdx/tdx.h | 72 +++++++++++++++++++++++++++++++++++++ > 2 files changed, 138 insertions(+), 1 deletion(-) > > diff --git a/arch/x86/virt/vmx/tdx/tdx.c b/arch/x86/virt/vmx/tdx/tdx.c > index bcf2b2d15a2e..9fde0f71dd8b 100644 > --- a/arch/x86/virt/vmx/tdx/tdx.c > +++ b/arch/x86/virt/vmx/tdx/tdx.c > @@ -20,6 +20,7 @@ > #include <asm/msr-index.h> > #include <asm/msr.h> > #include <asm/archrandom.h> > +#include <asm/page.h> > #include <asm/tdx.h> > #include "tdx.h" > > @@ -191,12 +192,76 @@ int tdx_cpu_enable(void) > } > EXPORT_SYMBOL_GPL(tdx_cpu_enable); > > +static inline bool is_cmr_empty(struct cmr_info *cmr) > +{ > + return !cmr->size; > +} > + Nit: maybe it's just me, but this function seems unnecessary. If "!cmr->size" is not expressive, then I don't know why "is_cmr_empty" should be. Just inline that into the single user. .. after all the single caller also uses/prints cmr->size ... > +static void print_cmrs(struct cmr_info *cmr_array, int nr_cmrs) > +{ > + int i; > + > + for (i = 0; i < nr_cmrs; i++) { > + struct cmr_info *cmr = &cmr_array[i]; > + > + /* > + * The array of CMRs reported via TDH.SYS.INFO can > + * contain tail empty CMRs. Don't print them. > + */ > + if (is_cmr_empty(cmr)) > + break; > + > + pr_info("CMR: [0x%llx, 0x%llx)\n", cmr->base, > + cmr->base + cmr->size); > + } > +} > + > +/* > + * Get the TDX module information (TDSYSINFO_STRUCT) and the array of > + * CMRs, and save them to @sysinfo and @cmr_array. @sysinfo must have > + * been padded to have enough room to save the TDSYSINFO_STRUCT. > + */ > +static int tdx_get_sysinfo(struct tdsysinfo_struct *sysinfo, > + struct cmr_info *cmr_array) > +{ > + struct tdx_module_output out; > + u64 sysinfo_pa, cmr_array_pa; > + int ret; > + > + sysinfo_pa = __pa(sysinfo); > + cmr_array_pa = __pa(cmr_array); > + ret = seamcall(TDH_SYS_INFO, sysinfo_pa, TDSYSINFO_STRUCT_SIZE, > + cmr_array_pa, MAX_CMRS, NULL, &out); > + if (ret) > + return ret; > + > + pr_info("TDX module: atributes 0x%x, vendor_id 0x%x, major_version %u, minor_version %u, build_date %u, build_num %u", "attributes" ? > + sysinfo->attributes, sysinfo->vendor_id, > + sysinfo->major_version, sysinfo->minor_version, > + sysinfo->build_date, sysinfo->build_num); > + > + /* R9 contains the actual entries written to the CMR array. */ > + print_cmrs(cmr_array, out.r9); > + > + return 0; > +} > + > static int init_tdx_module(void) > { > + static DECLARE_PADDED_STRUCT(tdsysinfo_struct, tdsysinfo, > + TDSYSINFO_STRUCT_SIZE, TDSYSINFO_STRUCT_ALIGNMENT); > + static struct cmr_info cmr_array[MAX_CMRS] > + __aligned(CMR_INFO_ARRAY_ALIGNMENT); > + struct tdsysinfo_struct *sysinfo = &PADDED_STRUCT(tdsysinfo); > + int ret; > + > + ret = tdx_get_sysinfo(sysinfo, cmr_array); > + if (ret) > + return ret; > + > /* > * TODO: > * > - * - Get TDX module information and TDX-capable memory regions. > * - Build the list of TDX-usable memory regions. > * - Construct a list of "TD Memory Regions" (TDMRs) to cover > * all TDX-usable memory regions. > diff --git a/arch/x86/virt/vmx/tdx/tdx.h b/arch/x86/virt/vmx/tdx/tdx.h > index 9fb46033c852..97f4d7e7f1a4 100644 > --- a/arch/x86/virt/vmx/tdx/tdx.h > +++ b/arch/x86/virt/vmx/tdx/tdx.h > @@ -3,6 +3,8 @@ > #define _X86_VIRT_TDX_H > > #include <linux/types.h> > +#include <linux/stddef.h> > +#include <linux/compiler_attributes.h> > > /* > * This file contains both macros and data structures defined by the TDX > @@ -21,6 +23,76 @@ > */ > #define TDH_SYS_INIT 33 > #define TDH_SYS_LP_INIT 35 > +#define TDH_SYS_INFO 32 > + > +struct cmr_info { > + u64 base; > + u64 size; > +} __packed; > + > +#define MAX_CMRS 32 > +#define CMR_INFO_ARRAY_ALIGNMENT 512 > + > +struct cpuid_config { > + u32 leaf; > + u32 sub_leaf; > + u32 eax; > + u32 ebx; > + u32 ecx; > + u32 edx; > +} __packed; > + > +#define DECLARE_PADDED_STRUCT(type, name, size, alignment) \ > + struct type##_padded { \ > + union { \ > + struct type name; \ > + u8 padding[size]; \ > + }; \ > + } name##_padded __aligned(alignment) > + > +#define PADDED_STRUCT(name) (name##_padded.name) > + > +#define TDSYSINFO_STRUCT_SIZE 1024 So, it can never be larger than 1024 bytes? Not even with many cpuid configs? > +#define TDSYSINFO_STRUCT_ALIGNMENT 1024 > +
> > +static inline bool is_cmr_empty(struct cmr_info *cmr) > > +{ > > + return !cmr->size; > > +} > > + > > Nit: maybe it's just me, but this function seems unnecessary. > > If "!cmr->size" is not expressive, then I don't know why "is_cmr_empty" > should be. Just inline that into the single user. > > .. after all the single caller also uses/prints cmr->size ... Agreed. I'll remove this function. Thanks! > > > +static void print_cmrs(struct cmr_info *cmr_array, int nr_cmrs) > > +{ > > + int i; > > + > > + for (i = 0; i < nr_cmrs; i++) { > > + struct cmr_info *cmr = &cmr_array[i]; > > + > > + /* > > + * The array of CMRs reported via TDH.SYS.INFO can > > + * contain tail empty CMRs. Don't print them. > > + */ > > + if (is_cmr_empty(cmr)) > > + break; > > + > > + pr_info("CMR: [0x%llx, 0x%llx)\n", cmr->base, > > + cmr->base + cmr->size); > > + } > > +} > > + > > +/* > > + * Get the TDX module information (TDSYSINFO_STRUCT) and the array of > > + * CMRs, and save them to @sysinfo and @cmr_array. @sysinfo must have > > + * been padded to have enough room to save the TDSYSINFO_STRUCT. > > + */ > > +static int tdx_get_sysinfo(struct tdsysinfo_struct *sysinfo, > > + struct cmr_info *cmr_array) > > +{ > > + struct tdx_module_output out; > > + u64 sysinfo_pa, cmr_array_pa; > > + int ret; > > + > > + sysinfo_pa = __pa(sysinfo); > > + cmr_array_pa = __pa(cmr_array); > > + ret = seamcall(TDH_SYS_INFO, sysinfo_pa, TDSYSINFO_STRUCT_SIZE, > > + cmr_array_pa, MAX_CMRS, NULL, &out); > > + if (ret) > > + return ret; > > + > > + pr_info("TDX module: atributes 0x%x, vendor_id 0x%x, major_version %u, minor_version %u, build_date %u, build_num %u", > > > "attributes" ? Appreciate! :) [...] > > +#define TDSYSINFO_STRUCT_SIZE 1024 > > So, it can never be larger than 1024 bytes? Not even with many cpuid > configs? Correct. The TDX module spec(s) says: TDSYSINFO_STRUCT’s size is 1024B. Which is an architectural sentence to me. We (Intel) already published TDX IO, and TDSYSINFO_STRUCT is 1024B for all TDX module versions. >
diff --git a/arch/x86/virt/vmx/tdx/tdx.c b/arch/x86/virt/vmx/tdx/tdx.c index bcf2b2d15a2e..9fde0f71dd8b 100644 --- a/arch/x86/virt/vmx/tdx/tdx.c +++ b/arch/x86/virt/vmx/tdx/tdx.c @@ -20,6 +20,7 @@ #include <asm/msr-index.h> #include <asm/msr.h> #include <asm/archrandom.h> +#include <asm/page.h> #include <asm/tdx.h> #include "tdx.h" @@ -191,12 +192,76 @@ int tdx_cpu_enable(void) } EXPORT_SYMBOL_GPL(tdx_cpu_enable); +static inline bool is_cmr_empty(struct cmr_info *cmr) +{ + return !cmr->size; +} + +static void print_cmrs(struct cmr_info *cmr_array, int nr_cmrs) +{ + int i; + + for (i = 0; i < nr_cmrs; i++) { + struct cmr_info *cmr = &cmr_array[i]; + + /* + * The array of CMRs reported via TDH.SYS.INFO can + * contain tail empty CMRs. Don't print them. + */ + if (is_cmr_empty(cmr)) + break; + + pr_info("CMR: [0x%llx, 0x%llx)\n", cmr->base, + cmr->base + cmr->size); + } +} + +/* + * Get the TDX module information (TDSYSINFO_STRUCT) and the array of + * CMRs, and save them to @sysinfo and @cmr_array. @sysinfo must have + * been padded to have enough room to save the TDSYSINFO_STRUCT. + */ +static int tdx_get_sysinfo(struct tdsysinfo_struct *sysinfo, + struct cmr_info *cmr_array) +{ + struct tdx_module_output out; + u64 sysinfo_pa, cmr_array_pa; + int ret; + + sysinfo_pa = __pa(sysinfo); + cmr_array_pa = __pa(cmr_array); + ret = seamcall(TDH_SYS_INFO, sysinfo_pa, TDSYSINFO_STRUCT_SIZE, + cmr_array_pa, MAX_CMRS, NULL, &out); + if (ret) + return ret; + + pr_info("TDX module: atributes 0x%x, vendor_id 0x%x, major_version %u, minor_version %u, build_date %u, build_num %u", + sysinfo->attributes, sysinfo->vendor_id, + sysinfo->major_version, sysinfo->minor_version, + sysinfo->build_date, sysinfo->build_num); + + /* R9 contains the actual entries written to the CMR array. */ + print_cmrs(cmr_array, out.r9); + + return 0; +} + static int init_tdx_module(void) { + static DECLARE_PADDED_STRUCT(tdsysinfo_struct, tdsysinfo, + TDSYSINFO_STRUCT_SIZE, TDSYSINFO_STRUCT_ALIGNMENT); + static struct cmr_info cmr_array[MAX_CMRS] + __aligned(CMR_INFO_ARRAY_ALIGNMENT); + struct tdsysinfo_struct *sysinfo = &PADDED_STRUCT(tdsysinfo); + int ret; + + ret = tdx_get_sysinfo(sysinfo, cmr_array); + if (ret) + return ret; + /* * TODO: * - * - Get TDX module information and TDX-capable memory regions. * - Build the list of TDX-usable memory regions. * - Construct a list of "TD Memory Regions" (TDMRs) to cover * all TDX-usable memory regions. diff --git a/arch/x86/virt/vmx/tdx/tdx.h b/arch/x86/virt/vmx/tdx/tdx.h index 9fb46033c852..97f4d7e7f1a4 100644 --- a/arch/x86/virt/vmx/tdx/tdx.h +++ b/arch/x86/virt/vmx/tdx/tdx.h @@ -3,6 +3,8 @@ #define _X86_VIRT_TDX_H #include <linux/types.h> +#include <linux/stddef.h> +#include <linux/compiler_attributes.h> /* * This file contains both macros and data structures defined by the TDX @@ -21,6 +23,76 @@ */ #define TDH_SYS_INIT 33 #define TDH_SYS_LP_INIT 35 +#define TDH_SYS_INFO 32 + +struct cmr_info { + u64 base; + u64 size; +} __packed; + +#define MAX_CMRS 32 +#define CMR_INFO_ARRAY_ALIGNMENT 512 + +struct cpuid_config { + u32 leaf; + u32 sub_leaf; + u32 eax; + u32 ebx; + u32 ecx; + u32 edx; +} __packed; + +#define DECLARE_PADDED_STRUCT(type, name, size, alignment) \ + struct type##_padded { \ + union { \ + struct type name; \ + u8 padding[size]; \ + }; \ + } name##_padded __aligned(alignment) + +#define PADDED_STRUCT(name) (name##_padded.name) + +#define TDSYSINFO_STRUCT_SIZE 1024 +#define TDSYSINFO_STRUCT_ALIGNMENT 1024 + +/* + * The size of this structure itself is flexible. The actual structure + * passed to TDH.SYS.INFO must be padded to TDSYSINFO_STRUCT_SIZE and be + * aligned to TDSYSINFO_STRUCT_ALIGNMENT using DECLARE_PADDED_STRUCT(). + */ +struct tdsysinfo_struct { + /* TDX-SEAM Module Info */ + u32 attributes; + u32 vendor_id; + u32 build_date; + u16 build_num; + u16 minor_version; + u16 major_version; + u8 reserved0[14]; + /* Memory Info */ + u16 max_tdmrs; + u16 max_reserved_per_tdmr; + u16 pamt_entry_size; + u8 reserved1[10]; + /* Control Struct Info */ + u16 tdcs_base_size; + u8 reserved2[2]; + u16 tdvps_base_size; + u8 tdvps_xfam_dependent_size; + u8 reserved3[9]; + /* TD Capabilities */ + u64 attributes_fixed0; + u64 attributes_fixed1; + u64 xfam_fixed0; + u64 xfam_fixed1; + u8 reserved4[32]; + u32 num_cpuid_config; + /* + * The actual number of CPUID_CONFIG depends on above + * 'num_cpuid_config'. + */ + DECLARE_FLEX_ARRAY(struct cpuid_config, cpuid_configs); +} __packed; /* * Do not put any hardware-defined TDX structure representations below