Provide SEV-SNP support for running under an SVSM

The snp_init() function is local to the boot/compressed/sev.c file and is not called from outside of the file. Change the name so that it is not tied to the function definition in arch/x86/include/asm/sev.h. Move the renamed snp_init() and related functions up in the file to avoid having to add a forward declaration and make the function static, too.

This will allow the snp_init() function in arch/x86/kernel/sev.c to be changed without having to make the same change in boot/compressed/sev.c.

Signed-off-by Tom Lendacky <[email protected]>

---
 arch/x86/boot/compressed/sev.c | 162 ++++++++++++++++-----------------
 1 file changed, 81 insertions(+), 81 deletions(-)

arch/x86/boot/compressed/sev.c +81 -71

index 454acd7a2daf..c3030cfb6484 100644
@@ -405,6 +405,85 @@ void snp_check_features(void)
        }
 }
 
+/* Search for Confidential Computing blob in the EFI config table. */
+static struct cc_blob_sev_info *find_cc_blob_efi(struct boot_params *bp)
+{
+       unsigned long cfg_table_pa;
+       unsigned int cfg_table_len;
+       int ret;
+
+       ret = efi_get_conf_table(bp, &cfg_table_pa, &cfg_table_len);
+       if (ret)
+               return NULL;
+
+       return (struct cc_blob_sev_info *)efi_find_vendor_table(bp, cfg_table_pa,
+                                                               cfg_table_len,
+                                                               EFI_CC_BLOB_GUID);
+}
+
+/*
+ * Initial set up of SNP relies on information provided by the
+ * Confidential Computing blob, which can be passed to the boot kernel
+ * by firmware/bootloader in the following ways:
+ *
+ * - via an entry in the EFI config table
+ * - via a setup_data structure, as defined by the Linux Boot Protocol
+ *
+ * Scan for the blob in that order.
+ */
+static struct cc_blob_sev_info *find_cc_blob(struct boot_params *bp)
+{
+       struct cc_blob_sev_info *cc_info;
+
+       cc_info = find_cc_blob_efi(bp);
+       if (cc_info)
+               goto found_cc_info;
+
+       cc_info = find_cc_blob_setup_data(bp);
+       if (!cc_info)
+               return NULL;
+
+found_cc_info:
+       if (cc_info->magic != CC_BLOB_SEV_HDR_MAGIC)
+               sev_es_terminate(SEV_TERM_SET_GEN, GHCB_SNP_UNSUPPORTED);
+
+       return cc_info;
+}
+
+/*
+ * Indicate SNP based on presence of SNP-specific CC blob. Subsequent checks
+ * will verify the SNP CPUID/MSR bits.
+ */
+static bool snp_setup(struct boot_params *bp)
+{
+       struct cc_blob_sev_info *cc_info;
+
+       if (!bp)
+               return false;
+
+       cc_info = find_cc_blob(bp);
+       if (!cc_info)
+               return false;
+
+       /*
+        * If a SNP-specific Confidential Computing blob is present, then
+        * firmware/bootloader have indicated SNP support. Verifying this
+        * involves CPUID checks which will be more reliable if the SNP
+        * CPUID table is used. See comments over snp_setup_cpuid_table() for
+        * more details.
+        */
+       setup_cpuid_table(cc_info);
+
+       /*
+        * Pass run-time kernel a pointer to CC info via boot_params so EFI
+        * config table doesn't need to be searched again during early startup
+        * phase.
+        */
+       bp->cc_blob_address = (u32)(unsigned long)cc_info;
+
+       return true;
+}
+
 /*
  * sev_check_cpu_support - Check for SEV support in the CPU capabilities
  *

@@ -455,7 +534,7 @@ void sev_enable(struct boot_params *bp)
                bp->cc_blob_address = 0;
 
        /*
-        * Do an initial SEV capability check before snp_init() which
+        * Do an initial SEV capability check before snp_setup() which
         * loads the CPUID page and the same checks afterwards are done
         * without the hypervisor and are trustworthy.
         *

@@ -470,7 +549,7 @@ void sev_enable(struct boot_params *bp)
         * Setup/preliminary detection of SNP. This will be sanity-checked
         * against CPUID/MSR values later.
         */
-       snp = snp_init(bp);
+       snp = snp_setup(bp);
 
        /* Now repeat the checks with the SNP CPUID table. */
 

@@ -527,85 +606,6 @@ u64 sev_get_status(void)
        return m.q;
 }
 
-/* Search for Confidential Computing blob in the EFI config table. */
-static struct cc_blob_sev_info *find_cc_blob_efi(struct boot_params *bp)
-{
-       unsigned long cfg_table_pa;
-       unsigned int cfg_table_len;
-       int ret;
-
-       ret = efi_get_conf_table(bp, &cfg_table_pa, &cfg_table_len);
-       if (ret)
-               return NULL;
-
-       return (struct cc_blob_sev_info *)efi_find_vendor_table(bp, cfg_table_pa,
-                                                               cfg_table_len,
-                                                               EFI_CC_BLOB_GUID);
-}
-
-/*
- * Initial set up of SNP relies on information provided by the
- * Confidential Computing blob, which can be passed to the boot kernel
- * by firmware/bootloader in the following ways:
- *
- * - via an entry in the EFI config table
- * - via a setup_data structure, as defined by the Linux Boot Protocol
- *
- * Scan for the blob in that order.
- */
-static struct cc_blob_sev_info *find_cc_blob(struct boot_params *bp)
-{
-       struct cc_blob_sev_info *cc_info;
-
-       cc_info = find_cc_blob_efi(bp);
-       if (cc_info)
-               goto found_cc_info;
-
-       cc_info = find_cc_blob_setup_data(bp);
-       if (!cc_info)
-               return NULL;
-
-found_cc_info:
-       if (cc_info->magic != CC_BLOB_SEV_HDR_MAGIC)
-               sev_es_terminate(SEV_TERM_SET_GEN, GHCB_SNP_UNSUPPORTED);
-
-       return cc_info;
-}
-
-/*
- * Indicate SNP based on presence of SNP-specific CC blob. Subsequent checks
- * will verify the SNP CPUID/MSR bits.
- */
-bool snp_init(struct boot_params *bp)
-{
-       struct cc_blob_sev_info *cc_info;
-
-       if (!bp)
-               return false;
-
-       cc_info = find_cc_blob(bp);
-       if (!cc_info)
-               return false;
-
-       /*
-        * If a SNP-specific Confidential Computing blob is present, then
-        * firmware/bootloader have indicated SNP support. Verifying this
-        * involves CPUID checks which will be more reliable if the SNP
-        * CPUID table is used. See comments over snp_setup_cpuid_table() for
-        * more details.
-        */
-       setup_cpuid_table(cc_info);
-

arch/x86/boot/compressed/sev.c +0 -1

 void sev_prep_identity_maps(unsigned long top_level_pgt)
 {
        /*
--

2.42.0

Quoted 15 lines · Tom Lendacky

The snp_init() function is local to the boot/compressed/sev.c file and is not called from outside of the file. Change the name so that it is not tied to the function definition in arch/x86/include/asm/sev.h. Move the renamed snp_init() and related functions up in the file to avoid having to add a forward declaration and make the function static, too.

This will allow the snp_init() function in arch/x86/kernel/sev.c to be changed without having to make the same change in boot/compressed/sev.c.

Signed-off-by Tom Lendacky <[email protected]>

---
  arch/x86/boot/compressed/sev.c | 162 ++++++++++++++++-----------------
  1 file changed, 81 insertions(+), 81 deletions(-)

arch/x86/boot/compressed/sev.c

Quoted 4 lines

arch/x86/boot/compressed/sev.c +0 -0

index 454acd7a2daf..c3030cfb6484 100644

Did some kind of whitespace replacement happen accidentally? There's a lot that isn't changed but the diff is quite big.

Quoted 8 lines

void sev_prep_identity_maps(unsigned long top_level_pgt)

  {
         /*

--
2.42.0

The SVSM Calling Area (CA) is used to communicate between Linux and the SVSM. Since the firmware supplied CA for the BSP is likely to be in reserved memory, switch off that CA to a kernel provided CA so that access and use of the CA is available during boot. The CA switch is done using the SVSM core protocol SVSM_CORE_REMAP_CAA call.

An SVSM call is executed by filling out the SVSM CA and setting the proper register state as documented by the SVSM protocol. The SVSM is invoked by by requesting the hypervisor to run VMPL0.

Once it is safe to allocate/reserve memory, allocate a CA for each CPU. After allocating the new CAs, the BSP will switch from the boot CA to the per-CPU CA. The CA for an AP is identified to the SVSM when creating the VMSA in preparation for booting the AP.

Signed-off-by Tom Lendacky <[email protected]>

---
 arch/x86/include/asm/sev-common.h |  13 ++
 arch/x86/include/asm/sev.h        |  32 +++++
 arch/x86/include/uapi/asm/svm.h   |   1 +
 arch/x86/kernel/sev-shared.c      |  94 +++++++++++++-
 arch/x86/kernel/sev.c             | 207 +++++++++++++++++++++++++-----
 arch/x86/mm/mem_encrypt_amd.c     |   8 +-
 6 files changed, 320 insertions(+), 35 deletions(-)

arch/x86/include/asm/sev-common.h +13 -0

index 68a8cdf6fd6a..71db5ba020b9 100644
@@ -96,6 +96,19 @@ enum psc_op {
        /* GHCBData[63:32] */                           \
        (((u64)(val) & GENMASK_ULL(63, 32)) >> 32)
 
+/* GHCB Run at VMPL Request/Response */
+#define GHCB_MSR_VMPL_REQ              0x016
+#define GHCB_MSR_VMPL_REQ_LEVEL(v)                     \
+       /* GHCBData[39:32] */                           \
+       (((u64)(v) & GENMASK_ULL(7, 0) << 32) |         \
+       /* GHCBDdata[11:0] */                           \
+       GHCB_MSR_VMPL_REQ)
+
+#define GHCB_MSR_VMPL_RESP             0x017
+#define GHCB_MSR_VMPL_RESP_VAL(v)                      \
+       /* GHCBData[63:32] */                           \
+       (((u64)(v) & GENMASK_ULL(63, 32)) >> 32)
+
 /* GHCB Hypervisor Feature Request/Response */
 #define GHCB_MSR_HV_FT_REQ             0x080
 #define GHCB_MSR_HV_FT_RESP            0x081

arch/x86/include/asm/sev.h +18 -0

index 207c315041ba..2f1e583769fc 100644
@@ -163,6 +163,36 @@ struct svsm_ca {
        u8 svsm_buffer[PAGE_SIZE - 8];
 };
 
+#define SVSM_SUCCESS                           0
+#define SVSM_ERR_INCOMPLETE                    0x80000000
+#define SVSM_ERR_UNSUPPORTED_PROTOCOL          0x80000001
+#define SVSM_ERR_UNSUPPORTED_CALL              0x80000002
+#define SVSM_ERR_INVALID_ADDRESS               0x80000003
+#define SVSM_ERR_INVALID_FORMAT                        0x80000004
+#define SVSM_ERR_INVALID_PARAMETER             0x80000005
+#define SVSM_ERR_INVALID_REQUEST               0x80000006
+#define SVSM_ERR_BUSY                          0x80000007
+
+/*
+ * SVSM protocol structure
+ */
+struct svsm_call {
+       struct svsm_ca *caa;
+       u64 rax;
+       u64 rcx;
+       u64 rdx;

arch/x86/include/asm/sev.h +4 -0

+#define SVSM_CORE_REMAP_CA             0
+
 #ifdef CONFIG_AMD_MEM_ENCRYPT
 extern void __sev_es_ist_enter(struct pt_regs *regs);
 extern void __sev_es_ist_exit(void);

@@ -236,6 +266,7 @@ int snp_issue_guest_request(u64 exit_code, struct snp_req_data *input, struct sn
 void snp_accept_memory(phys_addr_t start, phys_addr_t end);
 u64 snp_get_unsupported_features(u64 status);
 u64 sev_get_status(void);
+void __init snp_remap_svsm_ca(void);
 #else
 static inline void sev_es_ist_enter(struct pt_regs *regs) { }
 static inline void sev_es_ist_exit(void) { }

@@ -264,6 +295,7 @@ static inline int snp_issue_guest_request(u64 exit_code, struct snp_req_data *in
 static inline void snp_accept_memory(phys_addr_t start, phys_addr_t end) { }
 static inline u64 snp_get_unsupported_features(u64 status) { return 0; }
 static inline u64 sev_get_status(void) { return 0; }
+static inline void snp_remap_svsm_ca(void) { }
 #endif
 
 #endif

arch/x86/include/uapi/asm/svm.h +1 -0

index 80e1df482337..1814b413fd57 100644
@@ -115,6 +115,7 @@
 #define SVM_VMGEXIT_AP_CREATE_ON_INIT          0
 #define SVM_VMGEXIT_AP_CREATE                  1
 #define SVM_VMGEXIT_AP_DESTROY                 2
+#define SVM_VMGEXIT_SNP_RUN_VMPL               0x80000018
 #define SVM_VMGEXIT_HV_FEATURES                        0x8000fffd
 #define SVM_VMGEXIT_TERM_REQUEST               0x8000fffe
 #define SVM_VMGEXIT_TERM_REASON(reason_set, reason_code)       \

arch/x86/kernel/sev-shared.c +93 -1

index 99170f129eef..7e9fa5d8889b 100644
@@ -14,7 +14,9 @@
 #define has_cpuflag(f) boot_cpu_has(f)
 #else
 #undef WARN
-#define WARN(condition, format...) (!!(condition))
+#define WARN(condition, format...)     (!!(condition))
+#undef vc_forward_exception
+#define vc_forward_exception(c)                panic("SNP: Hypervisor requested exception\n")
 #endif
 
 /* I/O parameters for CPUID-related helpers */

@@ -240,6 +242,96 @@ static enum es_result verify_exception_info(struct ghcb *ghcb, struct es_em_ctxt
        return ES_VMM_ERROR;
 }
 
+static __always_inline void issue_svsm_call(struct svsm_call *call, u8 *pending)
+{
+       /*
+        * Issue the VMGEXIT to run the SVSM:
+        *   - Load the SVSM register state (RAX, RCX, RDX, R8 and R9)
+        *   - Set the CA call pending field to 1
+        *   - Issue VMGEXIT
+        *   - Save the SVSM return register state (RAX, RCX, RDX, R8 and R9)
+        *   - Perform atomic exchange of the CA call pending field
+        */
+       asm volatile("mov %9, %%r8\n\t"
+                    "mov %10, %%r9\n\t"
+                    "movb $1, %11\n\t"
+                    "rep; vmmcall\n\t"
+                    "mov %%r8, %3\n\t"
+                    "mov %%r9, %4\n\t"
+                    "xchgb %5, %11\n\t"
+                    : "=a" (call->rax_out), "=c" (call->rcx_out), "=d" (call->rdx_out),
+                      "=m" (call->r8_out), "=m" (call->r9_out),
+                      "+r" (*pending)
+                    : "a" (call->rax), "c" (call->rcx), "d" (call->rdx),
+                      "r" (call->r8), "r" (call->r9),
+                      "m" (call->caa->call_pending)
+                    : "r8", "r9", "memory");
+}
+
+static int __svsm_msr_protocol(struct svsm_call *call)
+{
+       u64 val, resp;
+       u8 pending;
+
+       val = sev_es_rd_ghcb_msr();
+
+       sev_es_wr_ghcb_msr(GHCB_MSR_VMPL_REQ_LEVEL(0));
+
+       pending = 0;
+       issue_svsm_call(call, &pending);
+
+       resp = sev_es_rd_ghcb_msr();
+
+       sev_es_wr_ghcb_msr(val);
+
+       if (pending)
+               return -EINVAL;
+
+       if (GHCB_RESP_CODE(resp) != GHCB_MSR_VMPL_RESP)
+               return -EINVAL;
+
+       if (GHCB_MSR_VMPL_RESP_VAL(resp) != 0)
+               return -EINVAL;
+
+       return call->rax_out;
+}
+
+static int __svsm_ghcb_protocol(struct ghcb *ghcb, struct svsm_call *call)
+{
+       struct es_em_ctxt ctxt;
+       u8 pending;
+
+       vc_ghcb_invalidate(ghcb);
+
+       /* Fill in protocol and format specifiers */
+       ghcb->protocol_version = ghcb_version;
+       ghcb->ghcb_usage       = GHCB_DEFAULT_USAGE;
+
+       ghcb_set_sw_exit_code(ghcb, SVM_VMGEXIT_SNP_RUN_VMPL);
+       ghcb_set_sw_exit_info_1(ghcb, 0);
+       ghcb_set_sw_exit_info_2(ghcb, 0);
+
+       sev_es_wr_ghcb_msr(__pa(ghcb));
+
+       pending = 0;
+       issue_svsm_call(call, &pending);
+
+       if (pending)
+               return -EINVAL;
+
+       switch (verify_exception_info(ghcb, &ctxt)) {
+       case ES_OK:
+               break;
+       case ES_EXCEPTION:
+               vc_forward_exception(&ctxt);
+               fallthrough;
+       default:
+               return -EINVAL;
+       }
+
+       return call->rax_out;
+}
+
 static enum es_result sev_es_ghcb_hv_call(struct ghcb *ghcb,
                                          struct es_em_ctxt *ctxt,
                                          u64 exit_code, u64 exit_info_1,

arch/x86/kernel/sev.c +129 -27

index 7066afaa8133..3bd7860fbfe1 100644
@@ -114,6 +114,8 @@ struct ghcb_state {
 
 static DEFINE_PER_CPU(struct sev_es_runtime_data*, runtime_data);
 static DEFINE_PER_CPU(struct sev_es_save_area *, sev_vmsa);
+static DEFINE_PER_CPU(struct svsm_ca *, svsm_caa);
+static DEFINE_PER_CPU(u64, svsm_caa_pa);
 
 /*
  * SVSM related information:

@@ -121,6 +123,7 @@ static DEFINE_PER_CPU(struct sev_es_save_area *, sev_vmsa);
  *   non-zero. The VMPL is therefore used to indicate the presence of an SVSM.
  */
 static u8 vmpl __ro_after_init;
+static struct svsm_ca boot_svsm_ca_page __aligned(PAGE_SIZE);
 static struct svsm_ca *boot_svsm_caa __ro_after_init;
 static u64 boot_svsm_caa_pa __ro_after_init;
 

@@ -138,11 +141,26 @@ struct sev_config {
               */
              ghcbs_initialized : 1,
 
+             /*
+              * A flag used to indicate when the per-CPU SVSM CA is to be
+              * used instead of the boot SVSM CA.
+              *
+              * For APs, the per-CPU SVSM CA is created as part of the AP
+              * bringup, so this flag can be used globally for the BSP and APs.
+              */
+             cas_initialized   : 1,
+
              __reserved        : 62;
 };
 
 static struct sev_config sev_cfg __read_mostly;
 
+static struct svsm_ca *__svsm_get_caa(void)
+{
+       return sev_cfg.cas_initialized ? this_cpu_read(svsm_caa)
+                                      : boot_svsm_caa;
+}
+
 static __always_inline bool on_vc_stack(struct pt_regs *regs)
 {
        unsigned long sp = regs->sp;

@@ -560,6 +578,33 @@ static enum es_result vc_ioio_check(struct es_em_ctxt *ctxt, u16 port, size_t si
        return ES_EXCEPTION;
 }
 
+static __always_inline void vc_forward_exception(struct es_em_ctxt *ctxt)
+{
+       long error_code = ctxt->fi.error_code;
+       int trapnr = ctxt->fi.vector;
+
+       ctxt->regs->orig_ax = ctxt->fi.error_code;
+
+       switch (trapnr) {
+       case X86_TRAP_GP:
+               exc_general_protection(ctxt->regs, error_code);
+               break;
+       case X86_TRAP_UD:
+               exc_invalid_op(ctxt->regs);
+               break;
+       case X86_TRAP_PF:
+               write_cr2(ctxt->fi.cr2);
+               exc_page_fault(ctxt->regs, error_code);
+               break;
+       case X86_TRAP_AC:
+               exc_alignment_check(ctxt->regs, error_code);
+               break;
+       default:
+               pr_emerg("Unsupported exception in #VC instruction emulation - can't continue\n");
+               BUG();
+       }
+}
+
 /* Include code shared with pre-decompression boot stage */
 #include "sev-shared.c"
 

@@ -588,6 +633,42 @@ static noinstr void __sev_put_ghcb(struct ghcb_state *state)
        }
 }
 
+static int svsm_protocol(struct svsm_call *call)
+{
+       struct ghcb_state state;
+       unsigned long flags;
+       struct ghcb *ghcb;
+       int ret;
+
+       /*
+        * This can be called very early in the boot, use native functions in
+        * order to avoid paravirt issues.
+        */
+       flags = native_save_fl();
+       if (flags & X86_EFLAGS_IF)
+               native_irq_disable();
+
+       if (sev_cfg.ghcbs_initialized)
+               ghcb = __sev_get_ghcb(&state);
+       else if (boot_ghcb)
+               ghcb = boot_ghcb;
+       else
+               ghcb = NULL;
+
+       do {
+               ret = ghcb ? __svsm_ghcb_protocol(ghcb, call)
+                          : __svsm_msr_protocol(call);
+       } while (ret == SVSM_ERR_BUSY);
+
+       if (sev_cfg.ghcbs_initialized)
+               __sev_put_ghcb(&state);
+
+       if (flags & X86_EFLAGS_IF)
+               native_irq_enable();
+
+       return ret;
+}
+
 void noinstr __sev_es_nmi_complete(void)
 {
        struct ghcb_state state;

@@ -1348,6 +1429,18 @@ static void __init alloc_runtime_data(int cpu)
                panic("Can't allocate SEV-ES runtime data");
 
        per_cpu(runtime_data, cpu) = data;
+
+       if (vmpl) {
+               struct svsm_ca *caa;
+
+               /* Allocate the SVSM CA page if an SVSM is present */
+               caa = memblock_alloc(sizeof(*caa), PAGE_SIZE);
+               if (!caa)
+                       panic("Can't allocate SVSM CA page\n");
+
+               per_cpu(svsm_caa, cpu) = caa;
+               per_cpu(svsm_caa_pa, cpu) = __pa(caa);
+       }
 }
 
 static void __init init_ghcb(int cpu)

@@ -1397,6 +1490,31 @@ void __init sev_es_init_vc_handling(void)
                init_ghcb(cpu);
        }
 
+       /* If running under an SVSM, switch to the per-cpu CA */
+       if (vmpl) {
+               struct svsm_call call = {};
+               unsigned long flags;
+               int ret;
+
+               local_irq_save(flags);
+
+               /*
+                * SVSM_CORE_REMAP_CA call:
+                *   RAX = 0 (Protocol=0, CallID=0)
+                *   RCX = New CA GPA
+                */
+               call.caa = __svsm_get_caa();
+               call.rax = SVSM_CORE_CALL(SVSM_CORE_REMAP_CA);
+               call.rcx = this_cpu_read(svsm_caa_pa);
+               ret = svsm_protocol(&call);
+               if (ret != SVSM_SUCCESS)
+                       panic("Can't remap the SVSM CA, ret=%#x (%d)\n", ret, ret);
+
+               sev_cfg.cas_initialized = true;
+
+               local_irq_restore(flags);
+       }
+
        sev_es_setup_play_dead();
 
        /* Secondary CPUs use the runtime #VC handler */

@@ -1818,33 +1936,6 @@ static enum es_result vc_handle_exitcode(struct es_em_ctxt *ctxt,
        return result;
 }
 
-static __always_inline void vc_forward_exception(struct es_em_ctxt *ctxt)
-{
-       long error_code = ctxt->fi.error_code;
-       int trapnr = ctxt->fi.vector;
-
-       ctxt->regs->orig_ax = ctxt->fi.error_code;
-
-       switch (trapnr) {
-       case X86_TRAP_GP:
-               exc_general_protection(ctxt->regs, error_code);
-               break;
-       case X86_TRAP_UD:
-               exc_invalid_op(ctxt->regs);
-               break;
-       case X86_TRAP_PF:
-               write_cr2(ctxt->fi.cr2);
-               exc_page_fault(ctxt->regs, error_code);
-               break;
-       case X86_TRAP_AC:
-               exc_alignment_check(ctxt->regs, error_code);
-               break;
-       default:
-               pr_emerg("Unsupported exception in #VC instruction emulation - can't continue\n");
-               BUG();
-       }
-}
-
 static __always_inline bool is_vc2_stack(unsigned long sp)
 {
        return (sp >= __this_cpu_ist_bottom_va(VC2) && sp < __this_cpu_ist_top_va(VC2));

@@ -2094,6 +2185,52 @@ static __init struct cc_blob_sev_info *find_cc_blob(struct boot_params *bp)
        return cc_info;
 }
 
+static __init void setup_svsm(struct cc_blob_sev_info *cc_info)
+{
+       struct svsm_call call = {};
+       int ret;
+       u64 pa;
+
+       /*
+        * Record the SVSM Calling Area address (CAA) if the guest is not
+        * running at VMPL0. The CA will be used to communicate with the
+        * SVSM to perform the SVSM services.
+        */

arch/x86/kernel/sev.c +35 -6

+        * RIP-relative addressing.
+        */
+       asm volatile ("lea boot_svsm_ca_page(%%rip), %0"
+                     : "=r" (pa)
+                     : "p" (&boot_svsm_ca_page));
+
+       /*
+        * Switch over to the boot SVSM CA while the current CA is still
+        * addressable. There is no GHCB at this point so use the MSR protocol.
+        *
+        * SVSM_CORE_REMAP_CA call:
+        *   RAX = 0 (Protocol=0, CallID=0)
+        *   RCX = New CA GPA
+        */
+       call.caa = __svsm_get_caa();
+       call.rax = SVSM_CORE_CALL(SVSM_CORE_REMAP_CA);
+       call.rcx = pa;
+       ret = svsm_protocol(&call);
+       if (ret != SVSM_SUCCESS)
+               panic("Can't remap the SVSM CA, ret=%#x (%d)\n", ret, ret);
+
+       boot_svsm_caa = (struct svsm_ca *)pa;
+       boot_svsm_caa_pa = pa;
+}
+
 bool __init snp_init(struct boot_params *bp)
 {
        struct cc_blob_sev_info *cc_info;

@@ -2107,12 +2244,7 @@ bool __init snp_init(struct boot_params *bp)
 
        setup_cpuid_table(cc_info);
 
-       /*
-        * Record the SVSM Calling Area address (CAA) if the guest is not
-        * running at VMPL0. The CA will be used to communicate with the
-        * SVSM to perform the SVSM services.
-        */
-       setup_svsm_ca(cc_info);
+       setup_svsm(cc_info);
 
        /*
         * The CC blob will be used later to access the secrets page. Cache

@@ -2278,3 +2410,12 @@ static int __init snp_init_platform_device(void)
        return 0;
 }
 device_initcall(snp_init_platform_device);
+
+void __init snp_remap_svsm_ca(void)
+{
+       if (!vmpl)
+               return;
+
+       /* Update the CAA to a proper kernel address */
+       boot_svsm_caa = &boot_svsm_ca_page;
+}

arch/x86/mm/mem_encrypt_amd.c +7 -2

index 70b91de2e053..8943286f9fdc 100644
@@ -2,7 +2,7 @@
 /*
  * AMD Memory Encryption Support
  *
- * Copyright (C) 2016 Advanced Micro Devices, Inc.
+ * Copyright (C) 2016-2024 Advanced Micro Devices, Inc.
  *
  * Author: Tom Lendacky <[email protected]>
  */

@@ -492,6 +492,12 @@ void __init sme_early_init(void)
         */
        if (sev_status & MSR_AMD64_SEV_ENABLED)
                ia32_disable();
+
+       /*
+        * Switch the SVSM CA mapping (if active) from identity mapped to
+        * kernel mapped.
+        */
+       snp_remap_svsm_ca();
 }
 
 void __init mem_encrypt_free_decrypted_mem(void)
--

2.42.0

Quoted 6 lines · Tom Lendacky

The SVSM Calling Area (CA) is used to communicate between Linux and the SVSM. Since the firmware supplied CA for the BSP is likely to be in reserved memory, switch off that CA to a kernel provided CA so that access and use of the CA is available during boot. The CA switch is done using the SVSM core protocol SVSM_CORE_REMAP_CAA call.

REMAP_CA, not CAA.

Quoted 25 lines

An SVSM call is executed by filling out the SVSM CA and setting the proper register state as documented by the SVSM protocol. The SVSM is invoked by by requesting the hypervisor to run VMPL0.

Once it is safe to allocate/reserve memory, allocate a CA for each CPU. After allocating the new CAs, the BSP will switch from the boot CA to the per-CPU CA. The CA for an AP is identified to the SVSM when creating the VMSA in preparation for booting the AP.

Signed-off-by Tom Lendacky <[email protected]>

---
  arch/x86/include/asm/sev-common.h |  13 ++
  arch/x86/include/asm/sev.h        |  32 +++++
  arch/x86/include/uapi/asm/svm.h   |   1 +
  arch/x86/kernel/sev-shared.c      |  94 +++++++++++++-
  arch/x86/kernel/sev.c             | 207 +++++++++++++++++++++++++-----
  arch/x86/mm/mem_encrypt_amd.c     |   8 +-
  6 files changed, 320 insertions(+), 35 deletions(-)

arch/x86/include/asm/sev-common.h +0 -0

index 68a8cdf6fd6a..71db5ba020b9 100644

arch/x86/include/asm/sev-common.h

Quoted 3 lines

arch/x86/include/asm/sev-common.h +2 -0

 
+
+#define SVSM_CORE_CALL(x)              ((0ULL << 32) | (x))

Given that we should expect to see other SVSM protocols used in the kernel, should we not have

#define SVSM_PROTOCOL_CALL(protocol, call) (((unsigned long)(protocol) << 32) | (call))
#define SVSM_CORE_PROTOCOL 0
#define SVSM_ATTESTATION_PROTOCOL 1
#define SVSM_VTPM_PROTOCOL 2

And then

#define SVSM_CORE_CALL(x) SVSM_PROTOCOL_CALL(SVSM_CORE_PROTOCOL, x)

or be cute and use symbol concatenation like

#define SVSM_PROTOCOL_ID(id) SVSM_##id##_PROTOCOL
#define SVSM_CALL(id, call) SVSM_PROTOCOL_CALL(SVSM_PROTOCOL_ID(id), call)

So you can just do SVSM_CALL(CORE, 0) ?

The PVALIDATE instruction can only be performed at VMPL0. An SVSM will be present when running at VMPL1 or a lower privilege level.

When an SVSM is present, use the SVSM_CORE_PVALIDATE call to perform memory validation instead of issuing the PVALIDATE instruction directly.

The validation of a single 4K page is now explicitly identified as such in the function name, pvalidate_4k_page(). The pvalidate_pages() function is used for validating 1 or more pages at either 4K or 2M in size. Each function, however, determines whether it can issue the PVALIDATE directly or whether the SVSM needs to be invoked.

Signed-off-by Tom Lendacky <[email protected]>

---
 arch/x86/boot/compressed/sev.c |  42 +++++++-
 arch/x86/include/asm/sev.h     |  22 +++++
 arch/x86/kernel/sev-shared.c   | 176 ++++++++++++++++++++++++++++++++-
 arch/x86/kernel/sev.c          |  25 +++--
 4 files changed, 247 insertions(+), 18 deletions(-)

arch/x86/boot/compressed/sev.c +14 -0

index 5d2403914ceb..3fbb614c31e0 100644
@@ -38,6 +38,16 @@ static u8 vmpl __section(".data");
 static u64 boot_svsm_caa_pa __section(".data");
 static struct svsm_ca *boot_svsm_caa __section(".data");
 
+static struct svsm_ca *__svsm_get_caa(void)
+{
+       return boot_svsm_caa;
+}
+
+static u64 __svsm_get_caa_pa(void)
+{
+       return boot_svsm_caa_pa;
+}
+
 /*
  * Copy a version of this function here - insn-eval.c can't be used in
  * pre-decompression code.

@@ -135,6 +145,24 @@ static bool fault_in_kernel_space(unsigned long address)
 /* Include code for early handlers */
 #include "../../kernel/sev-shared.c"
 
+static int svsm_protocol(struct svsm_call *call)
+{
+       struct ghcb *ghcb;
+       int ret;

arch/x86/boot/compressed/sev.c +8 -4

+
+       return ret;
+}
+
 bool sev_snp_enabled(void)
 {
        return sev_status & MSR_AMD64_SEV_SNP_ENABLED;

@@ -151,8 +179,8 @@ static void __page_state_change(unsigned long paddr, enum psc_op op)
         * If private -> shared then invalidate the page before requesting the
         * state change in the RMP table.
         */
-       if (op == SNP_PAGE_STATE_SHARED && pvalidate(paddr, RMP_PG_SIZE_4K, 0))
-               sev_es_terminate(SEV_TERM_SET_LINUX, GHCB_TERM_PVALIDATE);
+       if (op == SNP_PAGE_STATE_SHARED)
+               pvalidate_4k_page(paddr, paddr, 0);
 
        /* Issue VMGEXIT to change the page state in RMP table. */
        sev_es_wr_ghcb_msr(GHCB_MSR_PSC_REQ_GFN(paddr >> PAGE_SHIFT, op));

@@ -167,8 +195,8 @@ static void __page_state_change(unsigned long paddr, enum psc_op op)
         * Now that page state is changed in the RMP table, validate it so that it is
         * consistent with the RMP entry.
         */
-       if (op == SNP_PAGE_STATE_PRIVATE && pvalidate(paddr, RMP_PG_SIZE_4K, 1))
-               sev_es_terminate(SEV_TERM_SET_LINUX, GHCB_TERM_PVALIDATE);
+       if (op == SNP_PAGE_STATE_PRIVATE)
+               pvalidate_4k_page(paddr, paddr, 1);
 }
 
 void snp_set_page_private(unsigned long paddr)

arch/x86/boot/compressed/sev.c +4 -0

+        * under an SVSM.
+        */
+       boot_ghcb = NULL;
+
        /*
         * GHCB Page must be flushed from the cache and mapped encrypted again.
         * Otherwise the running kernel will see strange cache effects when

arch/x86/include/asm/sev.h +22 -0

index 2f1e583769fc..dbd7fd041689 100644
@@ -172,6 +172,27 @@ struct svsm_ca {
 #define SVSM_ERR_INVALID_PARAMETER             0x80000005
 #define SVSM_ERR_INVALID_REQUEST               0x80000006
 #define SVSM_ERR_BUSY                          0x80000007
+#define SVSM_PVALIDATE_FAIL_SIZEMISMATCH       0x80001006
+
+/*
+ * The SVSM PVALIDATE related structures
+ */
+struct svsm_pvalidate_entry {
+       u64 page_size           : 2,
+           action              : 1,
+           ignore_cf           : 1,
+           rsvd                : 8,
+           pfn                 : 52;
+};
+
+struct svsm_pvalidate_call {
+       u16 entries;
+       u16 next;
+
+       u8 rsvd1[4];
+
+       struct svsm_pvalidate_entry entry[];
+};
 
 /*
  * SVSM protocol structure

@@ -192,6 +213,7 @@ struct svsm_call {
 
 #define SVSM_CORE_CALL(x)              ((0ULL << 32) | (x))
 #define SVSM_CORE_REMAP_CA             0
+#define SVSM_CORE_PVALIDATE            1
 
 #ifdef CONFIG_AMD_MEM_ENCRYPT
 extern void __sev_es_ist_enter(struct pt_regs *regs);

arch/x86/kernel/sev-shared.c +175 -1

index 7e9fa5d8889b..f26e872bc5d0 100644
@@ -81,6 +81,8 @@ static u32 cpuid_std_range_max __ro_after_init;
 static u32 cpuid_hyp_range_max __ro_after_init;
 static u32 cpuid_ext_range_max __ro_after_init;
 
+static int svsm_protocol(struct svsm_call *call);
+
 static bool __init sev_es_check_cpu_features(void)
 {
        if (!has_cpuflag(X86_FEATURE_RDRAND)) {

@@ -1181,7 +1183,65 @@ static void __init setup_cpuid_table(const struct cc_blob_sev_info *cc_info)
        }
 }
 
-static void pvalidate_pages(struct snp_psc_desc *desc)
+static int base_pvalidate_4k_page(unsigned long vaddr, bool validate)
+{
+       return pvalidate(vaddr, RMP_PG_SIZE_4K, validate);
+}
+
+static int svsm_pvalidate_4k_page(unsigned long paddr, bool validate)
+{
+       struct svsm_pvalidate_call *pvalidate_call;
+       struct svsm_call call = {};
+       u64 pvalidate_call_pa;
+       unsigned long flags;
+       int ret;
+
+       /*
+        * This can be called very early in the boot, use native functions in
+        * order to avoid paravirt issues.
+        */
+       flags = native_save_fl();
+       if (flags & X86_EFLAGS_IF)
+               native_irq_disable();
+
+       call.caa = __svsm_get_caa();
+
+       pvalidate_call = (struct svsm_pvalidate_call *)call.caa->svsm_buffer;
+       pvalidate_call_pa = __svsm_get_caa_pa() + offsetof(struct svsm_ca, svsm_buffer);
+
+       pvalidate_call->entries = 1;
+       pvalidate_call->next    = 0;
+       pvalidate_call->entry[0].page_size = RMP_PG_SIZE_4K;
+       pvalidate_call->entry[0].action    = validate;
+       pvalidate_call->entry[0].ignore_cf = 0;
+       pvalidate_call->entry[0].pfn       = paddr >> PAGE_SHIFT;
+
+       /* Protocol 0, Call ID 1 */
+       call.rax = SVSM_CORE_CALL(SVSM_CORE_PVALIDATE);
+       call.rcx = pvalidate_call_pa;
+
+       ret = svsm_protocol(&call);
+
+       if (flags & X86_EFLAGS_IF)
+               native_irq_enable();
+
+       return ret;
+}
+
+static void pvalidate_4k_page(unsigned long vaddr, unsigned long paddr, bool validate)
+{
+       int ret;
+
+       ret = vmpl ? svsm_pvalidate_4k_page(paddr, validate)
+                  : base_pvalidate_4k_page(vaddr, validate);
+
+       if (ret) {
+               WARN(1, "Failed to validate address 0x%lx ret %d", vaddr, ret);
+               sev_es_terminate(SEV_TERM_SET_LINUX, GHCB_TERM_PVALIDATE);
+       }
+}
+
+static void base_pvalidate_pages(struct snp_psc_desc *desc)
 {
        struct psc_entry *e;
        unsigned long vaddr;

@@ -1215,6 +1275,120 @@ static void pvalidate_pages(struct snp_psc_desc *desc)
        }
 }
 
+static void svsm_pvalidate_pages(struct snp_psc_desc *desc)
+{
+       struct svsm_pvalidate_call *pvalidate_call;
+       struct svsm_pvalidate_entry *pe;
+       unsigned int call_count, i;
+       struct svsm_call call = {};
+       u64 pvalidate_call_pa;
+       struct psc_entry *e;
+       unsigned long flags;
+       unsigned long vaddr;
+       bool action;
+       int ret;
+
+       /*
+        * This can be called very early in the boot, use native functions in
+        * order to avoid paravirt issues.
+        */
+       flags = native_save_fl();
+       if (flags & X86_EFLAGS_IF)
+               native_irq_disable();
+
+       call.caa = __svsm_get_caa();
+
+       pvalidate_call = (struct svsm_pvalidate_call *)call.caa->svsm_buffer;
+       pvalidate_call_pa = __svsm_get_caa_pa() + offsetof(struct svsm_ca, svsm_buffer);
+
+       /* Calculate how many entries the CA buffer can hold */
+       call_count = sizeof(call.caa->svsm_buffer);
+       call_count -= offsetof(struct svsm_pvalidate_call, entry);
+       call_count /= sizeof(pvalidate_call->entry[0]);
+
+       /* Protocol 0, Call ID 1 */
+       call.rax = SVSM_CORE_CALL(SVSM_CORE_PVALIDATE);
+       call.rcx = pvalidate_call_pa;
+
+       pvalidate_call->entries = 0;
+       pvalidate_call->next    = 0;
+
+       for (i = 0; i <= desc->hdr.end_entry; i++) {
+               e = &desc->entries[i];
+               pe = &pvalidate_call->entry[pvalidate_call->entries];
+
+               pe->page_size = e->pagesize ? RMP_PG_SIZE_2M : RMP_PG_SIZE_4K;
+               pe->action    = e->operation == SNP_PAGE_STATE_PRIVATE;
+               pe->ignore_cf = 0;
+               pe->pfn       = e->gfn;
+
+               pvalidate_call->entries++;
+               if (pvalidate_call->entries < call_count && i != desc->hdr.end_entry)
+                       continue;
+
+               ret = svsm_protocol(&call);
+               if (ret == SVSM_PVALIDATE_FAIL_SIZEMISMATCH &&
+                   pvalidate_call->entry[pvalidate_call->next].page_size == RMP_PG_SIZE_2M) {
+                       u64 pfn, pfn_end;
+
+                       /*
+                        * The "next" field is the index of the failed entry. Calculate the
+                        * index of the entry after the failed entry before the fields are
+                        * cleared so that processing can continue on from that point (take
+                        * into account the for loop adding 1 to the entry).
+                        */
+                       i -= pvalidate_call->entries - pvalidate_call->next;
+                       i += 1;
+
+                       action = pvalidate_call->entry[pvalidate_call->next].action;
+                       pfn = pvalidate_call->entry[pvalidate_call->next].pfn;
+                       pfn_end = pfn + 511;
+
+                       pvalidate_call->entries = 0;
+                       pvalidate_call->next    = 0;
+                       for (; pfn <= pfn_end; pfn++) {
+                               pe = &pvalidate_call->entry[pvalidate_call->entries];
+
+                               pe->page_size = RMP_PG_SIZE_4K;
+                               pe->action    = action;
+                               pe->ignore_cf = 0;
+                               pe->pfn       = pfn;
+
+                               pvalidate_call->entries++;
+                               if (pvalidate_call->entries < call_count && pfn != pfn_end)
+                                       continue;
+
+                               ret = svsm_protocol(&call);
+                               if (ret != SVSM_SUCCESS)
+                                       break;
+
+                               pvalidate_call->entries = 0;
+                               pvalidate_call->next    = 0;
+                       }
+               }
+
+               if (ret != SVSM_SUCCESS) {
+                       pe = &pvalidate_call->entry[pvalidate_call->next];
+                       vaddr = (unsigned long)pfn_to_kaddr(pe->pfn);
+
+                       WARN(1, "Failed to validate address %lx ret=%#x (%d)", vaddr, ret, ret);
+                       sev_es_terminate(SEV_TERM_SET_LINUX, GHCB_TERM_PVALIDATE);
+               }
+
+               pvalidate_call->entries = 0;
+               pvalidate_call->next    = 0;
+       }
+
+       if (flags & X86_EFLAGS_IF)
+               native_irq_enable();
+}
+
+static void pvalidate_pages(struct snp_psc_desc *desc)
+{
+       vmpl ? svsm_pvalidate_pages(desc)
+            : base_pvalidate_pages(desc);
+}
+
 static int vmgexit_psc(struct ghcb *ghcb, struct snp_psc_desc *desc)
 {
        int cur_entry, end_entry, ret = 0;

arch/x86/kernel/sev.c +12 -14

index 3bd7860fbfe1..2fd21090ef6b 100644
@@ -161,6 +161,12 @@ static struct svsm_ca *__svsm_get_caa(void)
                                       : boot_svsm_caa;
 }
 
+static u64 __svsm_get_caa_pa(void)
+{
+       return sev_cfg.cas_initialized ? this_cpu_read(svsm_caa_pa)
+                                      : boot_svsm_caa_pa;
+}
+
 static __always_inline bool on_vc_stack(struct pt_regs *regs)
 {
        unsigned long sp = regs->sp;

@@ -777,7 +783,6 @@ static void early_set_pages_state(unsigned long vaddr, unsigned long paddr,
 {
        unsigned long paddr_end;
        u64 val;
-       int ret;
 
        vaddr = vaddr & PAGE_MASK;
 

@@ -785,12 +790,9 @@ static void early_set_pages_state(unsigned long vaddr, unsigned long paddr,
        paddr_end = paddr + (npages << PAGE_SHIFT);
 
        while (paddr < paddr_end) {
-               if (op == SNP_PAGE_STATE_SHARED) {
-                       /* Page validation must be rescinded before changing to shared */
-                       ret = pvalidate(vaddr, RMP_PG_SIZE_4K, false);
-                       if (WARN(ret, "Failed to validate address 0x%lx ret %d", paddr, ret))
-                               goto e_term;
-               }
+               /* Page validation must be rescinded before changing to shared */
+               if (op == SNP_PAGE_STATE_SHARED)
+                       pvalidate_4k_page(vaddr, paddr, false);
 
                /*
                 * Use the MSR protocol because this function can be called before

@@ -812,12 +814,9 @@ static void early_set_pages_state(unsigned long vaddr, unsigned long paddr,
                         paddr, GHCB_MSR_PSC_RESP_VAL(val)))
                        goto e_term;
 
-               if (op == SNP_PAGE_STATE_PRIVATE) {
-                       /* Page validation must be performed after changing to private */
-                       ret = pvalidate(vaddr, RMP_PG_SIZE_4K, true);
-                       if (WARN(ret, "Failed to validate address 0x%lx ret %d", paddr, ret))
-                               goto e_term;
-               }
+               /* Page validation must be performed after changing to private */
+               if (op == SNP_PAGE_STATE_PRIVATE)
+                       pvalidate_4k_page(vaddr, paddr, true);
 
                vaddr += PAGE_SIZE;
                paddr += PAGE_SIZE;
--

2.42.0

Quoted 25 lines · Tom Lendacky

The PVALIDATE instruction can only be performed at VMPL0. An SVSM will be present when running at VMPL1 or a lower privilege level.

When an SVSM is present, use the SVSM_CORE_PVALIDATE call to perform memory validation instead of issuing the PVALIDATE instruction directly.

The validation of a single 4K page is now explicitly identified as such in the function name, pvalidate_4k_page(). The pvalidate_pages() function is used for validating 1 or more pages at either 4K or 2M in size. Each function, however, determines whether it can issue the PVALIDATE directly or whether the SVSM needs to be invoked.

Signed-off-by Tom Lendacky <[email protected]>

---
  arch/x86/boot/compressed/sev.c |  42 +++++++-
  arch/x86/include/asm/sev.h     |  22 +++++
  arch/x86/kernel/sev-shared.c   | 176 ++++++++++++++++++++++++++++++++-
  arch/x86/kernel/sev.c          |  25 +++--
  4 files changed, 247 insertions(+), 18 deletions(-)

arch/x86/boot/compressed/sev.c +0 -0

index 5d2403914ceb..3fbb614c31e0 100644

Quoted 4 lines

arch/x86/boot/compressed/sev.c +4 -0

+static int svsm_protocol(struct svsm_call *call)
+{
+       struct ghcb *ghcb;
+       int ret;

arch/x86/boot/compressed/sev.c static bool fault_in_kernel_space(unsigned long address) · line 161

Quoted 10 lines

arch/x86/boot/compressed/sev.c +10 -0

+
+       if (boot_ghcb)
+               ghcb = boot_ghcb;
+       else
+               ghcb = NULL;
+
+       do {
+               ret = ghcb ? __svsm_ghcb_protocol(ghcb, call)
+                          : __svsm_msr_protocol(call);
+       } while (ret == SVSM_ERR_BUSY);

Should this loop forever or eventually give up and panic?

arch/x86/boot/compressed/sev.c void sev_es_shutdown_ghcb(void) · line 293

Quoted 9 lines

void snp_set_page_private(unsigned long paddr)

arch/x86/boot/compressed/sev.c +2 -0

@@ -261,6 +289,12 @@ void sev_es_shutdown_ghcb(void)
         if (!sev_es_check_cpu_features())
                 error("SEV-ES CPU Features missing.");
 
+       /*
+        * Ensure that the boot GHCB isn't used for the PVALIDATE when running

Why the definite article? Which PVALIDATE is this referring to?

The SVSM specification documents an alternative method of discovery for the SVSM using a reserved CPUID bit and a reserved MSR.

For the CPUID support, the #VC handler of an SEV-SNP guest should modify the returned value in the EAX register for the 0x8000001f CPUID function by setting bit 28 when an SVSM is present.

For the MSR support, new reserved MSR 0xc001f000 has been defined. A #VC should be generated when accessing this MSR. The #VC handler is expected to ignore writes to this MSR and return the physical calling area address (CAA) on reads of this MSR.

Signed-off-by Tom Lendacky <[email protected]>

---
 arch/x86/include/asm/msr-index.h |  2 ++
 arch/x86/kernel/sev-shared.c     |  4 ++++
 arch/x86/kernel/sev.c            | 17 +++++++++++++++++
 3 files changed, 23 insertions(+)

arch/x86/include/asm/msr-index.h +2 -0

index f1bd7b91b3c6..4746135cbe21 100644
@@ -622,6 +622,8 @@
 
 #define MSR_AMD64_VIRT_SPEC_CTRL	0xc001011f
 
+#define MSR_SVSM_CAA			0xc001f000
+
 /* AMD Collaborative Processor Performance Control MSRs */
 #define MSR_AMD_CPPC_CAP1		0xc00102b0
 #define MSR_AMD_CPPC_ENABLE		0xc00102b1

arch/x86/kernel/sev-shared.c +4 -0

index f26e872bc5d0..9bd7d7e75b31 100644
@@ -628,6 +628,10 @@ static int snp_cpuid_postprocess(struct ghcb *ghcb, struct es_em_ctxt *ctxt,
 		/* node ID */
 		leaf->ecx = (leaf->ecx & GENMASK(31, 8)) | (leaf_hv.ecx & GENMASK(7, 0));
 		break;
+	case 0x8000001f:
+		if (vmpl)
+			leaf->eax |= BIT(28);
+		break;
 	default:
 		/* No fix-ups needed, use values as-is. */
 		break;

Quoted 3 lines · Tom Lendacky

The SVSM specification documents an alternative method of discovery for the SVSM using a reserved CPUID bit and a reserved MSR.

Quoted 4 lines

For the CPUID support, the #VC handler of an SEV-SNP guest should modify the returned value in the EAX register for the 0x8000001f CPUID function by setting bit 28 when an SVSM is present.

It seems awkward that the guest would have to set the bit in the CPUID response itself. Is there no way for the SVSM to fixup the CPUID page contents, or the CPUID instruction return?

Could you also add a definition for the feature to arch/x86/include/asm/cpufeatures.h.

Quoted 41 lines

For the MSR support, new reserved MSR 0xc001f000 has been defined. A #VC should be generated when accessing this MSR. The #VC handler is expected to ignore writes to this MSR and return the physical calling area address (CAA) on reads of this MSR.

Signed-off-by Tom Lendacky <[email protected]>

---
  arch/x86/include/asm/msr-index.h |  2 ++
  arch/x86/kernel/sev-shared.c     |  4 ++++
  arch/x86/kernel/sev.c            | 17 +++++++++++++++++
  3 files changed, 23 insertions(+)

arch/x86/include/asm/msr-index.h +2 -0

index f1bd7b91b3c6..4746135cbe21 100644
@@ -622,6 +622,8 @@
 
  #define MSR_AMD64_VIRT_SPEC_CTRL	0xc001011f
 
+#define MSR_SVSM_CAA			0xc001f000
+
  /* AMD Collaborative Processor Performance Control MSRs */
  #define MSR_AMD_CPPC_CAP1		0xc00102b0
  #define MSR_AMD_CPPC_ENABLE		0xc00102b1

arch/x86/kernel/sev-shared.c +4 -0

index f26e872bc5d0..9bd7d7e75b31 100644
@@ -628,6 +628,10 @@ static int snp_cpuid_postprocess(struct ghcb *ghcb, struct es_em_ctxt *ctxt,
  		/* node ID */
  		leaf->ecx = (leaf->ecx & GENMASK(31, 8)) | (leaf_hv.ecx & GENMASK(7, 0));
  		break;
+	case 0x8000001f:
+		if (vmpl)
+			leaf->eax |= BIT(28);
+		break;
  	default:
  		/* No fix-ups needed, use values as-is. */
  		break;

Requesting an attestation report from userspace involves providing the VMPL level for the report. Currently any value from 0-3 is valid because Linux enforces running at VMPL0.

When an SVSM is present, though, Linux will not be running at VMPL0 and only VMPL values starting at the VMPL level Linux is running at to 3 are valid. In order to allow userspace to determine the minimum VMPL value that can be supplied to an attestation report, create a sysfs entry that can be used to retrieve the current VMPL level of Linux.

Signed-off-by Tom Lendacky <[email protected]>

---
 arch/x86/kernel/sev.c | 37 +++++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)

arch/x86/kernel/sev.c +37 -1

index 121a9bad86c9..9844c772099c 100644
@@ -2479,3 +2479,40 @@ void __init snp_remap_svsm_ca(void)
        /* Update the CAA to a proper kernel address */
        boot_svsm_caa = &boot_svsm_ca_page;
 }
+
+static ssize_t vmpl_show(struct kobject *kobj,
+                        struct kobj_attribute *attr, char *buf)
+{
+       return sysfs_emit(buf, "%d\n", vmpl);
+}
+
+static struct kobj_attribute vmpl_attr = __ATTR_RO(vmpl);
+
+static struct attribute *vmpl_attrs[] = {
+       &vmpl_attr.attr,
+       NULL
+};
+
+static struct attribute_group sev_attr_group = {
+       .attrs = vmpl_attrs,
+};
+
+static int __init sev_sysfs_init(void)
+{
+       struct kobject *sev_kobj;
+       int ret;
+
+       if (!cc_platform_has(CC_ATTR_GUEST_SEV_SNP))
+               return -ENODEV;
+
+       sev_kobj = kobject_create_and_add("sev", kernel_kobj);
+       if (!sev_kobj)
+               return -ENOMEM;
+
+       ret = sysfs_create_group(sev_kobj, &sev_attr_group);
+       if (ret)
+               kobject_put(sev_kobj);
+
+       return ret;
+}
+arch_initcall(sev_sysfs_init);
--

2.42.0

Quoted 5 lines · Tom Lendacky

Requesting an attestation report from userspace involves providing the VMPL level for the report. Currently any value from 0-3 is valid because Linux enforces running at VMPL0.

Quoted 5 lines

When an SVSM is present, though, Linux will not be running at VMPL0 and only VMPL values starting at the VMPL level Linux is running at to 3 are valid. In order to allow userspace to determine the minimum VMPL value that can be supplied to an attestation report, create a sysfs entry that can be used to retrieve the current VMPL level of Linux.

Is this not the intended meaning of privlevel_floor in /sys/kernel/config/tsm/report/$report0/privlevel_floor?

When an SVSM is present, the guest can also request attestation reports from the SVSM. These SVSM attestation reports can be used to attest the SVSM and any services running within the SVSM.

Extend the config-fs attestation support to allow for an SVSM attestation report. This involves creating four (4) new config-fs attributes:

- 'svsm' (input)
This attribute is used to determine whether the attestation request should be sent to the SVSM or to the SEV firmware.

- 'service_guid' (input)
Used for requesting the attestation of a single service within the SVSM. A null GUID implies that the SVSM_ATTEST_SERVICES call should be used to request the attestation report. A non-null GUID implies that the SVSM_ATTEST_SINGLE_SERVICE call should be used.

- 'service_version' (input)
Used with the SVSM_ATTEST_SINGLE_SERVICE call, the service version represents a specific service manifest version be used for the attestation report.

- 'manifestblob' (output)
Used to return the service manifest associated with the attestation report.

Signed-off-by Tom Lendacky <[email protected]>

---
 Documentation/ABI/testing/configfs-tsm  |  55 ++++++++++
 arch/x86/include/asm/sev.h              |  31 +++++-
 arch/x86/kernel/sev.c                   |  50 +++++++++
 drivers/virt/coco/sev-guest/sev-guest.c | 137 ++++++++++++++++++++++++
 drivers/virt/coco/tsm.c                 |  95 +++++++++++++++-
 include/linux/tsm.h                     |  11 ++
 6 files changed, 376 insertions(+), 3 deletions(-)

Documentation/ABI/testing/configfs-tsm +55 -0

index dd24202b5ba5..c5423987d323 100644
@@ -31,6 +31,21 @@ Description:
                Standardization v2.03 Section 4.1.8.1 MSG_REPORT_REQ.
                https://www.amd.com/content/dam/amd/en/documents/epyc-technical-docs/specifications/56421.pdf
 
+What:          /sys/kernel/config/tsm/report/$name/manifestblob
+Date:          January, 2024
+KernelVersion: v6.9
+Contact:       [email protected]
+Description:
+               (RO) Optional supplemental data that a TSM may emit, visibility
+               of this attribute depends on TSM, and may be empty if no
+               manifest data is available.
+
+               When @provider is "sev_guest" and the "svsm" attribute is set
+               this file contains the service manifest used for the SVSM
+               attestation report from Secure VM Service Module for SEV-SNP
+               Guests v1.00 Section 7.
+               https://www.amd.com/content/dam/amd/en/documents/epyc-technical-docs/specifications/58019.pdf
+
 What:          /sys/kernel/config/tsm/report/$name/provider
 Date:          September, 2023
 KernelVersion: v6.7

@@ -80,3 +95,43 @@ Contact:     [email protected]
 Description:
                (RO) Indicates the minimum permissible value that can be written
                to @privlevel.
+
+What:          /sys/kernel/config/tsm/report/$name/svsm
+Date:          January, 2024
+KernelVersion: v6.9
+Contact:       [email protected]
+Description:
+               (WO) Attribute is visible if a TSM implementation provider
+               supports the concept of attestation reports for TVMs running
+               under an SVSM, like SEV-SNP. Specifying any non-zero value
+               implies that the attestation report should come from the SVSM.
+               Secure VM Service Module for SEV-SNP Guests v1.00 Section 7.
+               https://www.amd.com/content/dam/amd/en/documents/epyc-technical-docs/specifications/58019.pdf
+
+What:          /sys/kernel/config/tsm/report/$name/service_guid
+Date:          January, 2024
+KernelVersion: v6.9
+Contact:       [email protected]
+Description:
+               (WO) Attribute is visible if a TSM implementation provider
+               supports the concept of attestation reports for TVMs running
+               under an SVSM, like SEV-SNP. Specifying a empty or null GUID
+               (00000000-0000-0000-0000-000000) requests all active services
+               within the SVSM be part of the attestation report. Specifying
+               a non-null GUID requests an attestation report of just the
+               specified service using the manifest form specified by the
+               service_version attribute.
+               Secure VM Service Module for SEV-SNP Guests v1.00 Section 7.
+               https://www.amd.com/content/dam/amd/en/documents/epyc-technical-docs/specifications/58019.pdf
+
+What:          /sys/kernel/config/tsm/report/$name/service_version
+Date:          January, 2024
+KernelVersion: v6.9
+Contact:       [email protected]
+Description:
+               (WO) Attribute is visible if a TSM implementation provider
+               supports the concept of attestation reports for TVMs running
+               under an SVSM, like SEV-SNP. Indicates the service manifest
+               version requested for the attestation report.
+               Secure VM Service Module for SEV-SNP Guests v1.00 Section 7.
+               https://www.amd.com/content/dam/amd/en/documents/epyc-technical-docs/specifications/58019.pdf

arch/x86/include/asm/sev.h +30 -1

index b126e50a1358..4cafa92d1d3e 100644
@@ -194,6 +194,27 @@ struct svsm_pvalidate_call {
        struct svsm_pvalidate_entry entry[];
 };
 
+/*
+ * The SVSM Attestation related structures
+ */
+struct svsm_location_entry {
+       u64 pa;
+       u32 len;
+       u8 rsvd[4];
+};
+
+struct svsm_attestation_call {
+       struct svsm_location_entry report_buffer;
+       struct svsm_location_entry nonce;
+       struct svsm_location_entry manifest_buffer;
+       struct svsm_location_entry certificates_buffer;
+
+       /* For attesting a single service */
+       u8 service_guid[16];
+       u32 service_version;
+       u8 rsvd[4];
+};
+
 /*
  * SVSM protocol structure
  */

@@ -217,6 +238,10 @@ struct svsm_call {
 #define SVSM_CORE_CREATE_VCPU          2
 #define SVSM_CORE_DELETE_VCPU          3
 
+#define SVSM_ATTEST_CALL(x)            ((1ULL << 32) | (x))
+#define SVSM_ATTEST_SERVICES           0
+#define SVSM_ATTEST_SINGLE_SERVICE     1
+
 #ifdef CONFIG_AMD_MEM_ENCRYPT
 extern void __sev_es_ist_enter(struct pt_regs *regs);
 extern void __sev_es_ist_exit(void);

@@ -287,6 +312,7 @@ void snp_set_wakeup_secondary_cpu(void);
 bool snp_init(struct boot_params *bp);
 void __init __noreturn snp_abort(void);
 int snp_issue_guest_request(u64 exit_code, struct snp_req_data *input, struct snp_guest_request_ioctl *rio);
+int snp_issue_svsm_attestation_request(u64 call_id, struct svsm_attestation_call *input);
 void snp_accept_memory(phys_addr_t start, phys_addr_t end);
 u64 snp_get_unsupported_features(u64 status);
 u64 sev_get_status(void);

@@ -316,7 +342,10 @@ static inline int snp_issue_guest_request(u64 exit_code, struct snp_req_data *in
 {
        return -ENOTTY;
 }
-
+static inline int snp_issue_svsm_attestation_request(u64 call_id, struct svsm_attestation_call *input)
+{
+       return -ENOTTY;
+}
 static inline void snp_accept_memory(phys_addr_t start, phys_addr_t end) { }
 static inline u64 snp_get_unsupported_features(u64 status) { return 0; }
 static inline u64 sev_get_status(void) { return 0; }

arch/x86/kernel/sev.c +50 -0

index 849df3aae4e1..83bc5efa8fcf 100644
@@ -2378,6 +2378,56 @@ static int __init init_sev_config(char *str)
 }
 __setup("sev=", init_sev_config);
 
+static void update_attestation_input(struct svsm_call *call, struct svsm_attestation_call *input)
+{
+       /* If (new) lengths have been returned, propograte them up */
+       if (call->rcx_out != call->rcx)
+               input->manifest_buffer.len = call->rcx_out;
+
+       if (call->rdx_out != call->rdx)
+               input->certificates_buffer.len = call->rdx_out;
+
+       if (call->r8_out != call->r8)
+               input->report_buffer.len = call->r8_out;
+}
+
+int snp_issue_svsm_attestation_request(u64 call_id, struct svsm_attestation_call *input)
+{
+       struct svsm_attestation_call *attest_call;
+       struct svsm_call call = {};
+       unsigned long flags;
+       u64 attest_call_pa;
+       int ret;
+
+       if (!vmpl)
+               return -EINVAL;
+
+       local_irq_save(flags);
+
+       call.caa = __svsm_get_caa();
+
+       attest_call = (struct svsm_attestation_call *)call.caa->svsm_buffer;
+       attest_call_pa = __svsm_get_caa_pa() + offsetof(struct svsm_ca, svsm_buffer);
+
+       memcpy(attest_call, input, sizeof(*attest_call));
+
+       /*
+        * Set input registers for the request and set RDX and R8 to known
+        * values in order to detect length values being returned in them.
+        */
+       call.rax = call_id;
+       call.rcx = attest_call_pa;
+       call.rdx = -1;
+       call.r8 = -1;
+       ret = svsm_protocol(&call);
+       update_attestation_input(&call, input);
+
+       local_irq_restore(flags);
+
+       return ret;
+}
+EXPORT_SYMBOL_GPL(snp_issue_svsm_attestation_request);
+
 int snp_issue_guest_request(u64 exit_code, struct snp_req_data *input, struct snp_guest_request_ioctl *rio)
 {
        struct ghcb_state state;

drivers/virt/coco/sev-guest/sev-guest.c +137 -0

index 1ff897913bf4..3693373c4227 100644
@@ -783,6 +783,140 @@ struct snp_msg_cert_entry {
        u32 length;
 };
 
+static int sev_svsm_report_new(struct tsm_report *report, void *data)
+{
+       unsigned int report_len, manifest_len, certificates_len;
+       void *report_blob, *manifest_blob, *certificates_blob;
+       struct svsm_attestation_call attest_call = {};
+       struct tsm_desc *desc = &report->desc;
+       unsigned int size;
+       bool try_again;
+       void *buffer;
+       u64 call_id;
+       int ret;
+
+       /*
+        * Allocate pages for the request:
+        * - Report blob (4K)
+        * - Manifest blob (4K)
+        * - Certificate blob (16K)
+        *
+        * Above addresses must be 4K aligned
+        */
+       report_len = SZ_4K;
+       manifest_len = SZ_4K;
+       certificates_len = SEV_FW_BLOB_MAX_SIZE;
+
+retry:
+       size = report_len + manifest_len + certificates_len;
+       buffer = alloc_pages_exact(size, __GFP_ZERO);
+       if (!buffer)
+               return -ENOMEM;
+
+       report_blob = buffer;
+       attest_call.report_buffer.pa = __pa(report_blob);
+       attest_call.report_buffer.len = report_len;
+
+       manifest_blob = report_blob + report_len;
+       attest_call.manifest_buffer.pa = __pa(manifest_blob);
+       attest_call.manifest_buffer.len = manifest_len;
+
+       certificates_blob = manifest_blob + manifest_len;
+       attest_call.certificates_buffer.pa = __pa(certificates_blob);
+       attest_call.certificates_buffer.len = certificates_len;
+
+       attest_call.nonce.pa = __pa(desc->inblob);
+       attest_call.nonce.len = desc->inblob_len;
+
+       if (guid_is_null(&desc->service_guid)) {
+               call_id = SVSM_ATTEST_CALL(SVSM_ATTEST_SERVICES);
+       } else {
+               export_guid(attest_call.service_guid, &desc->service_guid);
+               attest_call.service_version = desc->service_version;
+
+               call_id = SVSM_ATTEST_CALL(SVSM_ATTEST_SINGLE_SERVICE);
+       }
+
+       ret = snp_issue_svsm_attestation_request(call_id, &attest_call);
+       switch (ret) {
+       case SVSM_SUCCESS:
+               break;
+       case SVSM_ERR_INVALID_PARAMETER:
+               try_again = false;
+
+               if (attest_call.report_buffer.len > report_len) {
+                       report_len = PAGE_ALIGN(attest_call.report_buffer.len);
+                       try_again = true;
+               }
+
+               if (attest_call.manifest_buffer.len > manifest_len) {
+                       manifest_len = PAGE_ALIGN(attest_call.manifest_buffer.len);
+                       try_again = true;
+               }
+
+               if (attest_call.certificates_buffer.len > certificates_len) {
+                       certificates_len = PAGE_ALIGN(attest_call.certificates_buffer.len);
+                       try_again = true;
+               }
+
+               /* If one of the buffers wasn't large enough, retry the request */
+               if (try_again) {
+                       free_pages_exact(buffer, size);
+                       goto retry;
+               }
+
+               ret = -EINVAL;
+               goto error;
+       case SVSM_ERR_BUSY:
+               ret = -EAGAIN;
+               goto error;
+       default:
+               pr_err_ratelimited("SVSM attestation request failed (%#x)\n", ret);
+               ret = -EINVAL;
+               goto error;
+       }
+
+       ret = -ENOMEM;
+
+       report_len = attest_call.report_buffer.len;
+       void *rbuf __free(kvfree) = kvzalloc(report_len, GFP_KERNEL);
+       if (!rbuf)
+               goto error;
+
+       memcpy(rbuf, report_blob, report_len);
+       report->outblob = no_free_ptr(rbuf);
+       report->outblob_len = report_len;
+
+       manifest_len = attest_call.manifest_buffer.len;
+       void *mbuf __free(kvfree) = kvzalloc(manifest_len, GFP_KERNEL);
+       if (!mbuf)
+               goto error;
+
+       memcpy(mbuf, manifest_blob, manifest_len);
+       report->manifestblob = no_free_ptr(mbuf);
+       report->manifestblob_len = manifest_len;
+
+       certificates_len = attest_call.certificates_buffer.len;
+       if (!certificates_len)
+               goto success;
+
+       void *cbuf __free(kvfree) = kvzalloc(certificates_len, GFP_KERNEL);
+       if (!cbuf)
+               goto error;
+
+       memcpy(cbuf, certificates_blob, certificates_len);
+       report->auxblob = no_free_ptr(cbuf);
+       report->auxblob_len = certificates_len;
+
+success:
+       ret = 0;
+
+error:
+       free_pages_exact(buffer, size);
+
+       return ret;
+}
+
 static int sev_report_new(struct tsm_report *report, void *data)
 {
        struct snp_msg_cert_entry *cert_table;

@@ -797,6 +931,9 @@ static int sev_report_new(struct tsm_report *report, void *data)
        if (desc->inblob_len != SNP_REPORT_USER_DATA_SIZE)
                return -EINVAL;
 
+       if (desc->svsm)
+               return sev_svsm_report_new(report, data);
+
        void *buf __free(kvfree) = kvzalloc(size, GFP_KERNEL);
        if (!buf)
                return -ENOMEM;

drivers/virt/coco/tsm.c +93 -2

index d1c2db83a8ca..33fa26406bc6 100644
@@ -35,7 +35,7 @@ static DECLARE_RWSEM(tsm_rwsem);
  * The attestation report format is TSM provider specific, when / if a standard
  * materializes that can be published instead of the vendor layout. Until then
  * the 'provider' attribute indicates the format of 'outblob', and optionally
- * 'auxblob'.
+ * 'auxblob' and 'manifestblob'.
  */
 
 struct tsm_report_state {

@@ -48,6 +48,7 @@ struct tsm_report_state {
 enum tsm_data_select {
        TSM_REPORT,
        TSM_CERTS,
+       TSM_MANIFEST,
 };
 
 static struct tsm_report *to_tsm_report(struct config_item *cfg)

@@ -119,6 +120,77 @@ static ssize_t tsm_report_privlevel_floor_show(struct config_item *cfg,
 }
 CONFIGFS_ATTR_RO(tsm_report_, privlevel_floor);
 
+static ssize_t tsm_report_svsm_store(struct config_item *cfg,
+                                    const char *buf, size_t len)
+{
+       struct tsm_report *report = to_tsm_report(cfg);
+       unsigned int val;
+       int rc;
+
+       rc = kstrtouint(buf, 0, &val);
+       if (rc)
+               return rc;
+
+       guard(rwsem_write)(&tsm_rwsem);
+       rc = try_advance_write_generation(report);
+       if (rc)
+               return rc;
+       report->desc.svsm = !!val;
+
+       return len;
+}
+CONFIGFS_ATTR_WO(tsm_report_, svsm);
+
+static ssize_t tsm_report_service_guid_store(struct config_item *cfg,
+                                            const char *buf, size_t len)
+{
+       struct tsm_report *report = to_tsm_report(cfg);
+       size_t guid_len;
+       int rc;
+
+       guard(rwsem_write)(&tsm_rwsem);
+       rc = try_advance_write_generation(report);
+       if (rc)
+               return rc;
+
+       /* Obtain the GUID string length */
+       guid_len = (len && buf[len - 1] == '\n') ? len - 1 : len;
+       if (guid_len && guid_len != UUID_STRING_LEN)
+               return -EINVAL;
+
+       if (guid_len == UUID_STRING_LEN) {
+               rc = guid_parse(buf, &report->desc.service_guid);
+               if (rc)
+                       return rc;
+       } else {
+               report->desc.service_guid = guid_null;
+       }
+
+       return len;
+}
+CONFIGFS_ATTR_WO(tsm_report_, service_guid);
+
+static ssize_t tsm_report_service_version_store(struct config_item *cfg,
+                                               const char *buf, size_t len)
+{
+       struct tsm_report *report = to_tsm_report(cfg);
+       unsigned int val;
+       int rc;
+
+       rc = kstrtouint(buf, 0, &val);
+       if (rc)
+               return rc;
+
+       guard(rwsem_write)(&tsm_rwsem);
+       rc = try_advance_write_generation(report);
+       if (rc)
+               return rc;
+       report->desc.service_version = val;
+
+       return len;
+}
+CONFIGFS_ATTR_WO(tsm_report_, service_version);
+
 static ssize_t tsm_report_inblob_write(struct config_item *cfg,
                                       const void *buf, size_t count)
 {

@@ -163,6 +235,9 @@ static ssize_t __read_report(struct tsm_report *report, void *buf, size_t count,
        if (select == TSM_REPORT) {
                out = report->outblob;
                len = report->outblob_len;
+       } else if (select == TSM_MANIFEST) {
+               out = report->manifestblob;
+               len = report->manifestblob_len;
        } else {
                out = report->auxblob;
                len = report->auxblob_len;

@@ -188,7 +263,7 @@ static ssize_t read_cached_report(struct tsm_report *report, void *buf,
 
        /*
         * A given TSM backend always fills in ->outblob regardless of
-        * whether the report includes an auxblob or not.
+        * whether the report includes an auxblob/manifestblob or not.
         */
        if (!report->outblob ||
            state->read_generation != state->write_generation)

@@ -224,8 +299,10 @@ static ssize_t tsm_report_read(struct tsm_report *report, void *buf,
 
        kvfree(report->outblob);
        kvfree(report->auxblob);
+       kvfree(report->manifestblob);
        report->outblob = NULL;
        report->auxblob = NULL;
+       report->manifestblob = NULL;
        rc = ops->report_new(report, provider.data);
        if (rc < 0)
                return rc;

@@ -252,6 +329,15 @@ static ssize_t tsm_report_auxblob_read(struct config_item *cfg, void *buf,
 }
 CONFIGFS_BIN_ATTR_RO(tsm_report_, auxblob, NULL, TSM_OUTBLOB_MAX);
 
+static ssize_t tsm_report_manifestblob_read(struct config_item *cfg, void *buf,
+                                           size_t count)
+{
+       struct tsm_report *report = to_tsm_report(cfg);
+
+       return tsm_report_read(report, buf, count, TSM_MANIFEST);
+}
+CONFIGFS_BIN_ATTR_RO(tsm_report_, manifestblob, NULL, TSM_OUTBLOB_MAX);
+
 #define TSM_DEFAULT_ATTRS() \
        &tsm_report_attr_generation, \
        &tsm_report_attr_provider

@@ -265,6 +351,9 @@ static struct configfs_attribute *tsm_report_extra_attrs[] = {
        TSM_DEFAULT_ATTRS(),
        &tsm_report_attr_privlevel,
        &tsm_report_attr_privlevel_floor,
+       &tsm_report_attr_svsm,
+       &tsm_report_attr_service_guid,
+       &tsm_report_attr_service_version,
        NULL,
 };
 

@@ -280,6 +369,7 @@ static struct configfs_bin_attribute *tsm_report_bin_attrs[] = {
 static struct configfs_bin_attribute *tsm_report_bin_extra_attrs[] = {
        TSM_DEFAULT_BIN_ATTRS(),
        &tsm_report_attr_auxblob,
+       &tsm_report_attr_manifestblob,
        NULL,
 };
 

@@ -288,6 +378,7 @@ static void tsm_report_item_release(struct config_item *cfg)
        struct tsm_report *report = to_tsm_report(cfg);
        struct tsm_report_state *state = to_state(report);
 
+       kvfree(report->manifestblob);
        kvfree(report->auxblob);
        kvfree(report->outblob);
        kfree(state);

include/linux/tsm.h +11 -1

index de8324a2223c..7c36b8448b4f 100644
@@ -4,6 +4,7 @@
 
 #include <linux/sizes.h>
 #include <linux/types.h>
+#include <linux/uuid.h>
 
 #define TSM_INBLOB_MAX 64
 #define TSM_OUTBLOB_MAX SZ_32K

@@ -19,11 +20,17 @@
  * @privlevel: optional privilege level to associate with @outblob
  * @inblob_len: sizeof @inblob
  * @inblob: arbitrary input data
+ * @svsm: optional indicator of where to obtain the tsm report blob
+ * @service_guid: optional SVSM service guid to attest
+ * @service_version: optional SVSM service manifest version requested
  */
 struct tsm_desc {
        unsigned int privlevel;
        size_t inblob_len;
        u8 inblob[TSM_INBLOB_MAX];
+       bool svsm;
+       guid_t service_guid;
+       unsigned int service_version;
 };
 
 /**

@@ -33,6 +40,8 @@ struct tsm_desc {
  * @outblob: generated evidence to provider to the attestation agent
  * @auxblob_len: sizeof(@auxblob)
  * @auxblob: (optional) auxiliary data to the report (e.g. certificate data)
+ * @manifestblob_len: sizeof(@manifestblob)
+ * @manifestblob: (optional) manifest data associated with the report
  */
 struct tsm_report {
        struct tsm_desc desc;

@@ -40,6 +49,8 @@ struct tsm_report {
        u8 *outblob;
        size_t auxblob_len;
        u8 *auxblob;
+       size_t manifestblob_len;
+       u8 *manifestblob;
 };
 
 /**
--

2.42.0

Quoted 8 lines · Tom Lendacky

When an SVSM is present, the guest can also request attestation reports from the SVSM. These SVSM attestation reports can be used to attest the SVSM and any services running within the SVSM.

Extend the config-fs attestation support to allow for an SVSM attestation report. This involves creating four (4) new config-fs attributes:

Quoted 3 lines

- 'svsm' (input)
This attribute is used to determine whether the attestation request should be sent to the SVSM or to the SEV firmware.

This is where I'm torn. If there's an SVSM, it's there to provide paravirtualization for unenlightened guests /or/ it's there to protect

runtime measurement registers. I don't see there being any particular value in bifurcating the attestation report space by adding this option. If there's an SVSM present, the configfs-tsm report should return the full SVSM attestation only.

Quoted 8 lines

- 'service_guid' (input)
Used for requesting the attestation of a single service within the SVSM. A null GUID implies that the SVSM_ATTEST_SERVICES call should be used to request the attestation report. A non-null GUID implies that the SVSM_ATTEST_SINGLE_SERVICE call should be used.

Quoted 4 lines

- 'service_version' (input)
Used with the SVSM_ATTEST_SINGLE_SERVICE call, the service version represents a specific service manifest version be used for the attestation report.

I know that this is specified for the SVSM, but I still don't know what the intended use case is such that we wouldn't simply always return the full service manifest.
I can see an argument for an evidence requester not being ready for a new manifest version and wanting the older version until they can bridge the gap. I don't see that as needing configuration from the user space. We can either require new service GUIDs for new versions, require manifest ABIs to be internally versioned to be additive-only to not break verifiers that understand up to manifest byte X, or we allow breaking version changes through control plane configuration that's passed directly to the SVSM.

New versions get new GUIDs allows for gradual deprecation at the expense of size. I think that is a reasonable trade-off to keep from making tsm/report vendor-specific.

Quoted 5 lines

- 'manifestblob' (output)
Used to return the service manifest associated with the attestation report.

Given the above, I think we can just append the manifest to the report since the report size is known a priori.

Quoted 584 lines

Signed-off-by Tom Lendacky <[email protected]>

---
  Documentation/ABI/testing/configfs-tsm  |  55 ++++++++++
  arch/x86/include/asm/sev.h              |  31 +++++-
  arch/x86/kernel/sev.c                   |  50 +++++++++
  drivers/virt/coco/sev-guest/sev-guest.c | 137 ++++++++++++++++++++++++
  drivers/virt/coco/tsm.c                 |  95 +++++++++++++++-
  include/linux/tsm.h                     |  11 ++
  6 files changed, 376 insertions(+), 3 deletions(-)

Documentation/ABI/testing/configfs-tsm +55 -0

index dd24202b5ba5..c5423987d323 100644
@@ -31,6 +31,21 @@ Description:
                 Standardization v2.03 Section 4.1.8.1 MSG_REPORT_REQ.
                 https://www.amd.com/content/dam/amd/en/documents/epyc-technical-docs/specifications/56421.pdf
 
+What:          /sys/kernel/config/tsm/report/$name/manifestblob
+Date:          January, 2024
+KernelVersion: v6.9
+Contact:       [email protected]
+Description:
+               (RO) Optional supplemental data that a TSM may emit, visibility
+               of this attribute depends on TSM, and may be empty if no
+               manifest data is available.
+
+               When @provider is "sev_guest" and the "svsm" attribute is set
+               this file contains the service manifest used for the SVSM
+               attestation report from Secure VM Service Module for SEV-SNP
+               Guests v1.00 Section 7.
+               https://www.amd.com/content/dam/amd/en/documents/epyc-technical-docs/specifications/58019.pdf
+
  What:          /sys/kernel/config/tsm/report/$name/provider
  Date:          September, 2023
  KernelVersion: v6.7

@@ -80,3 +95,43 @@ Contact:     [email protected]
  Description:
                 (RO) Indicates the minimum permissible value that can be written
                 to @privlevel.
+
+What:          /sys/kernel/config/tsm/report/$name/svsm
+Date:          January, 2024
+KernelVersion: v6.9
+Contact:       [email protected]
+Description:
+               (WO) Attribute is visible if a TSM implementation provider
+               supports the concept of attestation reports for TVMs running
+               under an SVSM, like SEV-SNP. Specifying any non-zero value
+               implies that the attestation report should come from the SVSM.
+               Secure VM Service Module for SEV-SNP Guests v1.00 Section 7.
+               https://www.amd.com/content/dam/amd/en/documents/epyc-technical-docs/specifications/58019.pdf
+
+What:          /sys/kernel/config/tsm/report/$name/service_guid
+Date:          January, 2024
+KernelVersion: v6.9
+Contact:       [email protected]
+Description:
+               (WO) Attribute is visible if a TSM implementation provider
+               supports the concept of attestation reports for TVMs running
+               under an SVSM, like SEV-SNP. Specifying a empty or null GUID
+               (00000000-0000-0000-0000-000000) requests all active services
+               within the SVSM be part of the attestation report. Specifying
+               a non-null GUID requests an attestation report of just the
+               specified service using the manifest form specified by the
+               service_version attribute.
+               Secure VM Service Module for SEV-SNP Guests v1.00 Section 7.
+               https://www.amd.com/content/dam/amd/en/documents/epyc-technical-docs/specifications/58019.pdf
+
+What:          /sys/kernel/config/tsm/report/$name/service_version
+Date:          January, 2024
+KernelVersion: v6.9
+Contact:       [email protected]
+Description:
+               (WO) Attribute is visible if a TSM implementation provider
+               supports the concept of attestation reports for TVMs running
+               under an SVSM, like SEV-SNP. Indicates the service manifest
+               version requested for the attestation report.
+               Secure VM Service Module for SEV-SNP Guests v1.00 Section 7.
+               https://www.amd.com/content/dam/amd/en/documents/epyc-technical-docs/specifications/58019.pdf

arch/x86/include/asm/sev.h +30 -1

index b126e50a1358..4cafa92d1d3e 100644
@@ -194,6 +194,27 @@ struct svsm_pvalidate_call {
         struct svsm_pvalidate_entry entry[];
  };
 
+/*
+ * The SVSM Attestation related structures
+ */
+struct svsm_location_entry {
+       u64 pa;
+       u32 len;
+       u8 rsvd[4];
+};
+
+struct svsm_attestation_call {
+       struct svsm_location_entry report_buffer;
+       struct svsm_location_entry nonce;
+       struct svsm_location_entry manifest_buffer;
+       struct svsm_location_entry certificates_buffer;
+
+       /* For attesting a single service */
+       u8 service_guid[16];
+       u32 service_version;
+       u8 rsvd[4];
+};
+
  /*
   * SVSM protocol structure
   */

@@ -217,6 +238,10 @@ struct svsm_call {
  #define SVSM_CORE_CREATE_VCPU          2
  #define SVSM_CORE_DELETE_VCPU          3
 
+#define SVSM_ATTEST_CALL(x)            ((1ULL << 32) | (x))
+#define SVSM_ATTEST_SERVICES           0
+#define SVSM_ATTEST_SINGLE_SERVICE     1
+
  #ifdef CONFIG_AMD_MEM_ENCRYPT
  extern void __sev_es_ist_enter(struct pt_regs *regs);
  extern void __sev_es_ist_exit(void);

@@ -287,6 +312,7 @@ void snp_set_wakeup_secondary_cpu(void);
  bool snp_init(struct boot_params *bp);
  void __init __noreturn snp_abort(void);
  int snp_issue_guest_request(u64 exit_code, struct snp_req_data *input, struct snp_guest_request_ioctl *rio);
+int snp_issue_svsm_attestation_request(u64 call_id, struct svsm_attestation_call *input);
  void snp_accept_memory(phys_addr_t start, phys_addr_t end);
  u64 snp_get_unsupported_features(u64 status);
  u64 sev_get_status(void);

@@ -316,7 +342,10 @@ static inline int snp_issue_guest_request(u64 exit_code, struct snp_req_data *in
  {
         return -ENOTTY;
  }
-
+static inline int snp_issue_svsm_attestation_request(u64 call_id, struct svsm_attestation_call *input)
+{
+       return -ENOTTY;
+}
  static inline void snp_accept_memory(phys_addr_t start, phys_addr_t end) { }
  static inline u64 snp_get_unsupported_features(u64 status) { return 0; }
  static inline u64 sev_get_status(void) { return 0; }

arch/x86/kernel/sev.c +50 -0

index 849df3aae4e1..83bc5efa8fcf 100644
@@ -2378,6 +2378,56 @@ static int __init init_sev_config(char *str)
  }
  __setup("sev=", init_sev_config);
 
+static void update_attestation_input(struct svsm_call *call, struct svsm_attestation_call *input)
+{
+       /* If (new) lengths have been returned, propograte them up */
+       if (call->rcx_out != call->rcx)
+               input->manifest_buffer.len = call->rcx_out;
+
+       if (call->rdx_out != call->rdx)
+               input->certificates_buffer.len = call->rdx_out;
+
+       if (call->r8_out != call->r8)
+               input->report_buffer.len = call->r8_out;
+}
+
+int snp_issue_svsm_attestation_request(u64 call_id, struct svsm_attestation_call *input)
+{
+       struct svsm_attestation_call *attest_call;
+       struct svsm_call call = {};
+       unsigned long flags;
+       u64 attest_call_pa;
+       int ret;
+
+       if (!vmpl)
+               return -EINVAL;
+
+       local_irq_save(flags);
+
+       call.caa = __svsm_get_caa();
+
+       attest_call = (struct svsm_attestation_call *)call.caa->svsm_buffer;
+       attest_call_pa = __svsm_get_caa_pa() + offsetof(struct svsm_ca, svsm_buffer);
+
+       memcpy(attest_call, input, sizeof(*attest_call));
+
+       /*
+        * Set input registers for the request and set RDX and R8 to known
+        * values in order to detect length values being returned in them.
+        */
+       call.rax = call_id;
+       call.rcx = attest_call_pa;
+       call.rdx = -1;
+       call.r8 = -1;
+       ret = svsm_protocol(&call);
+       update_attestation_input(&call, input);
+
+       local_irq_restore(flags);
+
+       return ret;
+}
+EXPORT_SYMBOL_GPL(snp_issue_svsm_attestation_request);
+
  int snp_issue_guest_request(u64 exit_code, struct snp_req_data *input, struct snp_guest_request_ioctl *rio)
  {
         struct ghcb_state state;

drivers/virt/coco/sev-guest/sev-guest.c +137 -0

index 1ff897913bf4..3693373c4227 100644
@@ -783,6 +783,140 @@ struct snp_msg_cert_entry {
         u32 length;
  };
 
+static int sev_svsm_report_new(struct tsm_report *report, void *data)
+{
+       unsigned int report_len, manifest_len, certificates_len;
+       void *report_blob, *manifest_blob, *certificates_blob;
+       struct svsm_attestation_call attest_call = {};
+       struct tsm_desc *desc = &report->desc;
+       unsigned int size;
+       bool try_again;
+       void *buffer;
+       u64 call_id;
+       int ret;
+
+       /*
+        * Allocate pages for the request:
+        * - Report blob (4K)
+        * - Manifest blob (4K)
+        * - Certificate blob (16K)
+        *
+        * Above addresses must be 4K aligned
+        */
+       report_len = SZ_4K;
+       manifest_len = SZ_4K;
+       certificates_len = SEV_FW_BLOB_MAX_SIZE;
+
+retry:
+       size = report_len + manifest_len + certificates_len;
+       buffer = alloc_pages_exact(size, __GFP_ZERO);
+       if (!buffer)
+               return -ENOMEM;
+
+       report_blob = buffer;
+       attest_call.report_buffer.pa = __pa(report_blob);
+       attest_call.report_buffer.len = report_len;
+
+       manifest_blob = report_blob + report_len;
+       attest_call.manifest_buffer.pa = __pa(manifest_blob);
+       attest_call.manifest_buffer.len = manifest_len;
+
+       certificates_blob = manifest_blob + manifest_len;
+       attest_call.certificates_buffer.pa = __pa(certificates_blob);
+       attest_call.certificates_buffer.len = certificates_len;
+
+       attest_call.nonce.pa = __pa(desc->inblob);
+       attest_call.nonce.len = desc->inblob_len;
+
+       if (guid_is_null(&desc->service_guid)) {
+               call_id = SVSM_ATTEST_CALL(SVSM_ATTEST_SERVICES);
+       } else {
+               export_guid(attest_call.service_guid, &desc->service_guid);
+               attest_call.service_version = desc->service_version;
+
+               call_id = SVSM_ATTEST_CALL(SVSM_ATTEST_SINGLE_SERVICE);
+       }
+
+       ret = snp_issue_svsm_attestation_request(call_id, &attest_call);
+       switch (ret) {
+       case SVSM_SUCCESS:
+               break;
+       case SVSM_ERR_INVALID_PARAMETER:
+               try_again = false;
+
+               if (attest_call.report_buffer.len > report_len) {
+                       report_len = PAGE_ALIGN(attest_call.report_buffer.len);
+                       try_again = true;
+               }
+
+               if (attest_call.manifest_buffer.len > manifest_len) {
+                       manifest_len = PAGE_ALIGN(attest_call.manifest_buffer.len);
+                       try_again = true;
+               }
+
+               if (attest_call.certificates_buffer.len > certificates_len) {
+                       certificates_len = PAGE_ALIGN(attest_call.certificates_buffer.len);
+                       try_again = true;
+               }
+
+               /* If one of the buffers wasn't large enough, retry the request */
+               if (try_again) {
+                       free_pages_exact(buffer, size);
+                       goto retry;
+               }
+
+               ret = -EINVAL;
+               goto error;
+       case SVSM_ERR_BUSY:
+               ret = -EAGAIN;
+               goto error;
+       default:
+               pr_err_ratelimited("SVSM attestation request failed (%#x)\n", ret);
+               ret = -EINVAL;
+               goto error;
+       }
+
+       ret = -ENOMEM;
+
+       report_len = attest_call.report_buffer.len;
+       void *rbuf __free(kvfree) = kvzalloc(report_len, GFP_KERNEL);
+       if (!rbuf)
+               goto error;
+
+       memcpy(rbuf, report_blob, report_len);
+       report->outblob = no_free_ptr(rbuf);
+       report->outblob_len = report_len;
+
+       manifest_len = attest_call.manifest_buffer.len;
+       void *mbuf __free(kvfree) = kvzalloc(manifest_len, GFP_KERNEL);
+       if (!mbuf)
+               goto error;
+
+       memcpy(mbuf, manifest_blob, manifest_len);
+       report->manifestblob = no_free_ptr(mbuf);
+       report->manifestblob_len = manifest_len;
+
+       certificates_len = attest_call.certificates_buffer.len;
+       if (!certificates_len)
+               goto success;
+
+       void *cbuf __free(kvfree) = kvzalloc(certificates_len, GFP_KERNEL);
+       if (!cbuf)
+               goto error;
+
+       memcpy(cbuf, certificates_blob, certificates_len);
+       report->auxblob = no_free_ptr(cbuf);
+       report->auxblob_len = certificates_len;
+
+success:
+       ret = 0;
+
+error:
+       free_pages_exact(buffer, size);
+
+       return ret;
+}
+
  static int sev_report_new(struct tsm_report *report, void *data)
  {
         struct snp_msg_cert_entry *cert_table;

@@ -797,6 +931,9 @@ static int sev_report_new(struct tsm_report *report, void *data)
         if (desc->inblob_len != SNP_REPORT_USER_DATA_SIZE)
                 return -EINVAL;
 
+       if (desc->svsm)
+               return sev_svsm_report_new(report, data);
+
         void *buf __free(kvfree) = kvzalloc(size, GFP_KERNEL);
         if (!buf)
                 return -ENOMEM;

drivers/virt/coco/tsm.c +93 -2

index d1c2db83a8ca..33fa26406bc6 100644
@@ -35,7 +35,7 @@ static DECLARE_RWSEM(tsm_rwsem);
   * The attestation report format is TSM provider specific, when / if a standard
   * materializes that can be published instead of the vendor layout. Until then
   * the 'provider' attribute indicates the format of 'outblob', and optionally
- * 'auxblob'.
+ * 'auxblob' and 'manifestblob'.
   */
 
  struct tsm_report_state {

@@ -48,6 +48,7 @@ struct tsm_report_state {
  enum tsm_data_select {
         TSM_REPORT,
         TSM_CERTS,
+       TSM_MANIFEST,
  };
 
  static struct tsm_report *to_tsm_report(struct config_item *cfg)

@@ -119,6 +120,77 @@ static ssize_t tsm_report_privlevel_floor_show(struct config_item *cfg,
  }
  CONFIGFS_ATTR_RO(tsm_report_, privlevel_floor);
 
+static ssize_t tsm_report_svsm_store(struct config_item *cfg,
+                                    const char *buf, size_t len)
+{
+       struct tsm_report *report = to_tsm_report(cfg);
+       unsigned int val;
+       int rc;
+
+       rc = kstrtouint(buf, 0, &val);
+       if (rc)
+               return rc;
+
+       guard(rwsem_write)(&tsm_rwsem);
+       rc = try_advance_write_generation(report);
+       if (rc)
+               return rc;
+       report->desc.svsm = !!val;
+
+       return len;
+}
+CONFIGFS_ATTR_WO(tsm_report_, svsm);
+
+static ssize_t tsm_report_service_guid_store(struct config_item *cfg,
+                                            const char *buf, size_t len)
+{
+       struct tsm_report *report = to_tsm_report(cfg);
+       size_t guid_len;
+       int rc;
+
+       guard(rwsem_write)(&tsm_rwsem);
+       rc = try_advance_write_generation(report);
+       if (rc)
+               return rc;
+
+       /* Obtain the GUID string length */
+       guid_len = (len && buf[len - 1] == '\n') ? len - 1 : len;
+       if (guid_len && guid_len != UUID_STRING_LEN)
+               return -EINVAL;
+
+       if (guid_len == UUID_STRING_LEN) {
+               rc = guid_parse(buf, &report->desc.service_guid);
+               if (rc)
+                       return rc;
+       } else {
+               report->desc.service_guid = guid_null;
+       }
+
+       return len;
+}
+CONFIGFS_ATTR_WO(tsm_report_, service_guid);
+
+static ssize_t tsm_report_service_version_store(struct config_item *cfg,
+                                               const char *buf, size_t len)
+{
+       struct tsm_report *report = to_tsm_report(cfg);
+       unsigned int val;
+       int rc;
+
+       rc = kstrtouint(buf, 0, &val);
+       if (rc)
+               return rc;
+
+       guard(rwsem_write)(&tsm_rwsem);
+       rc = try_advance_write_generation(report);
+       if (rc)
+               return rc;
+       report->desc.service_version = val;
+
+       return len;
+}
+CONFIGFS_ATTR_WO(tsm_report_, service_version);
+
  static ssize_t tsm_report_inblob_write(struct config_item *cfg,
                                        const void *buf, size_t count)
  {

@@ -163,6 +235,9 @@ static ssize_t __read_report(struct tsm_report *report, void *buf, size_t count,
         if (select == TSM_REPORT) {
                 out = report->outblob;
                 len = report->outblob_len;
+       } else if (select == TSM_MANIFEST) {
+               out = report->manifestblob;
+               len = report->manifestblob_len;
         } else {
                 out = report->auxblob;
                 len = report->auxblob_len;

@@ -188,7 +263,7 @@ static ssize_t read_cached_report(struct tsm_report *report, void *buf,
 
         /*
          * A given TSM backend always fills in ->outblob regardless of
-        * whether the report includes an auxblob or not.
+        * whether the report includes an auxblob/manifestblob or not.
          */
         if (!report->outblob ||
             state->read_generation != state->write_generation)

@@ -224,8 +299,10 @@ static ssize_t tsm_report_read(struct tsm_report *report, void *buf,
 
         kvfree(report->outblob);
         kvfree(report->auxblob);
+       kvfree(report->manifestblob);
         report->outblob = NULL;
         report->auxblob = NULL;
+       report->manifestblob = NULL;
         rc = ops->report_new(report, provider.data);
         if (rc < 0)
                 return rc;

@@ -252,6 +329,15 @@ static ssize_t tsm_report_auxblob_read(struct config_item *cfg, void *buf,
  }
  CONFIGFS_BIN_ATTR_RO(tsm_report_, auxblob, NULL, TSM_OUTBLOB_MAX);
 
+static ssize_t tsm_report_manifestblob_read(struct config_item *cfg, void *buf,
+                                           size_t count)
+{
+       struct tsm_report *report = to_tsm_report(cfg);
+
+       return tsm_report_read(report, buf, count, TSM_MANIFEST);
+}
+CONFIGFS_BIN_ATTR_RO(tsm_report_, manifestblob, NULL, TSM_OUTBLOB_MAX);
+
  #define TSM_DEFAULT_ATTRS() \
         &tsm_report_attr_generation, \
         &tsm_report_attr_provider

@@ -265,6 +351,9 @@ static struct configfs_attribute *tsm_report_extra_attrs[] = {
         TSM_DEFAULT_ATTRS(),
         &tsm_report_attr_privlevel,
         &tsm_report_attr_privlevel_floor,
+       &tsm_report_attr_svsm,
+       &tsm_report_attr_service_guid,
+       &tsm_report_attr_service_version,
         NULL,
  };
 

@@ -280,6 +369,7 @@ static struct configfs_bin_attribute *tsm_report_bin_attrs[] = {
  static struct configfs_bin_attribute *tsm_report_bin_extra_attrs[] = {
         TSM_DEFAULT_BIN_ATTRS(),
         &tsm_report_attr_auxblob,
+       &tsm_report_attr_manifestblob,
         NULL,
  };
 

@@ -288,6 +378,7 @@ static void tsm_report_item_release(struct config_item *cfg)
         struct tsm_report *report = to_tsm_report(cfg);
         struct tsm_report_state *state = to_state(report);
 
+       kvfree(report->manifestblob);
         kvfree(report->auxblob);
         kvfree(report->outblob);
         kfree(state);

include/linux/tsm.h +11 -1

index de8324a2223c..7c36b8448b4f 100644
@@ -4,6 +4,7 @@
 
  #include <linux/sizes.h>
  #include <linux/types.h>
+#include <linux/uuid.h>
 
  #define TSM_INBLOB_MAX 64
  #define TSM_OUTBLOB_MAX SZ_32K

@@ -19,11 +20,17 @@
   * @privlevel: optional privilege level to associate with @outblob
   * @inblob_len: sizeof @inblob
   * @inblob: arbitrary input data
+ * @svsm: optional indicator of where to obtain the tsm report blob
+ * @service_guid: optional SVSM service guid to attest
+ * @service_version: optional SVSM service manifest version requested
   */
  struct tsm_desc {
         unsigned int privlevel;
         size_t inblob_len;
         u8 inblob[TSM_INBLOB_MAX];
+       bool svsm;
+       guid_t service_guid;
+       unsigned int service_version;
  };
 
  /**

@@ -33,6 +40,8 @@ struct tsm_desc {
   * @outblob: generated evidence to provider to the attestation agent
   * @auxblob_len: sizeof(@auxblob)
   * @auxblob: (optional) auxiliary data to the report (e.g. certificate data)
+ * @manifestblob_len: sizeof(@manifestblob)
+ * @manifestblob: (optional) manifest data associated with the report
   */
  struct tsm_report {
         struct tsm_desc desc;

@@ -40,6 +49,8 @@ struct tsm_report {
         u8 *outblob;
         size_t auxblob_len;
         u8 *auxblob;
+       size_t manifestblob_len;
+       u8 *manifestblob;
  };
 
  /**
--

2.42.0