Add Secure TSC support for SNP guests
v14 cover Add Secure TSC support for SNP guests
This patchset is also available at:
https://github.com/AMDESE/linux-kvm/tree/sectsc-guest-latest
and is based on tip/x86/sev
Overview
--------
Secure TSC allows guests to securely use RDTSC/RDTSCP instructions as the parameters being used cannot be changed by hypervisor once the guest is launched. More details in the AMD64 APM Vol 2, Section "Secure TSC".
In order to enable secure TSC, SEV-SNP guests need to send a TSC_INFO guest message before the APs are booted. Details from the TSC_INFO response will then be used to program the VMSA before the APs are brought up. See "SEV Secure Nested Paging Firmware ABI Specification" document (currently at
https://www.amd.com/system/files/TechDocs/56860.pdf) section "TSC Info"
SEV-guest driver has the implementation for guest and AMD Security Processor communication. As the TSC_INFO needs to be initialized during early boot before APs are started, move the guest messaging code from sev-guest driver to sev/core.c and provide well defined APIs to the sev-guest driver.
Patches:
01-02: Patches moving SNP guest messaging code from SEV guest driver to
SEV common code
03-09: SecureTSC enablement patches
10-11: Generic TSC/kvmclock improvements
12-13: SecureTSC enablement patches.
Testing SecureTSC
-----------------
SecureTSC hypervisor patches based on top of SEV-SNP Guest MEMFD series:
https://github.com/AMDESE/linux-kvm/tree/sectsc-host-latest
QEMU changes:
https://github.com/nikunjad/qemu/tree/snp-securetsc-latest
QEMU commandline SEV-SNP with SecureTSC:
qemu-system-x86_64 -cpu EPYC-Milan-v2 -smp 4 \
-object memory-backend-memfd,id=ram1,size=1G,share=true,prealloc=false,reserve=false \
-object sev-snp-guest,id=sev0,cbitpos=51,reduced-phys-bits=1,secure-tsc=on \
-machine q35,confidential-guest-support=sev0,memory-backend=ram1 \
...Changelog:
----------
v14:
* Make zero_key as static const(Christophe JAILLET)
* As req structure does not have sensitive data remove memzero_explicit(). (Christophe JAILLET)
* Document the assumption that MSR_IA32_TSC is intercepted for Secure TSC (Xiaoyao Li)
* Update commit message for RDTSC/RTDSCP (Xiaoyao Li)
* Check against sev_status directly similar to DEBUG_SWAP, in case the handler gets called from early code. (Tom)
* Make enable_native_sched_clock() static for non-paravirt case (kernel test robot)
* Add a WARN_ON when kvmclock is selected in the guest so there is a splat in the guest as well. (Tom)
* Update commit message. (Tom)
v13: https://lore.kernel.org/lkml/[email protected]/
* Rebased on top of tip/x86/sev
* Squashed CC_ATTR_GUEST_SNP_SNP_SECURE_TSC change to patch where it used. (Tom)
* Fixed sparse warnings (kernel test robot)
* Added patch to prevent GUEST_TSC_FREQ MSR interception(Tom)
* Fix sched_clock override in common code (Sean)
* Added GHCB_TERM_SECURE_TSC_KVMCLOCK reason code and use sev_es_terminate() to inform the hypervisor that KVMCLOCK was being instead of Secure TSC.
v12: https://lore.kernel.org/lkml/[email protected]/
Nikunj A Dadhania (13):
x86/sev: Carve out and export SNP guest messaging init routines x86/sev: Relocate SNP guest messaging routines to common code x86/sev: Add Secure TSC support for SNP guests
x86/sev: Change TSC MSR behavior for Secure TSC enabled guests x86/sev: Prevent RDTSC/RDTSCP interception for Secure TSC enabled
guests
x86/sev: Prevent GUEST_TSC_FREQ MSR interception for Secure TSC
enabled guests
x86/sev: Mark Secure TSC as reliable clocksource x86/cpu/amd: Do not print FW_BUG for Secure TSC
tsc: Use the GUEST_TSC_FREQ MSR for discovering TSC frequency
tsc: Upgrade TSC clocksource rating
tsc: Switch to native sched clock
x86/kvmclock: Abort SecureTSC enabled guest when kvmclock is selected x86/sev: Allow Secure TSC feature for SNP guests
arch/x86/include/asm/msr-index.h | 1 + arch/x86/include/asm/sev-common.h | 2 + arch/x86/include/asm/sev.h | 134 +++++- arch/x86/include/asm/svm.h | 6 +- include/linux/cc_platform.h | 8 + arch/x86/boot/compressed/sev.c | 3 +- arch/x86/coco/core.c | 3 + arch/x86/coco/sev/core.c | 566 +++++++++++++++++++++++- arch/x86/coco/sev/shared.c | 13 +- arch/x86/kernel/cpu/amd.c | 3 +- arch/x86/kernel/kvmclock.c | 9 + arch/x86/kernel/tsc.c | 41 ++ arch/x86/mm/mem_encrypt.c | 4 + arch/x86/mm/mem_encrypt_amd.c | 4 + drivers/virt/coco/sev-guest/sev-guest.c | 485 +------------------- arch/x86/Kconfig | 1 + drivers/virt/coco/sev-guest/Kconfig | 1 - 17 files changed, 793 insertions(+), 491 deletions(-)
base-commit: 0a895c0d9b73d934de95aa0dd4e631c394bdd25d
Signature · 1 line
2.34.1
PATCH v14 1/13 x86/sev: Carve out and export SNP guest messaging init routines
Currently, the SEV guest driver is the only user of SNP guest messaging. All routines for initializing SNP guest messaging are implemented within the SEV guest driver. To add Secure TSC guest support, these initialization routines need to be available during early boot.
Carve out common SNP guest messaging buffer allocations and message initialization routines to core/sev.c and export them. These newly added APIs set up the SNP message context (snp_msg_desc), which contains all the necessary details for sending SNP guest messages.
At present, the SEV guest platform data structure is used to pass the secrets page physical address to SEV guest driver. Since the secrets page address is locally available to the initialization routine, use the cached address. Remove the unused SEV guest platform data structure.
--- arch/x86/include/asm/sev.h | 71 ++++++++- arch/x86/coco/sev/core.c | 133 +++++++++++++++- drivers/virt/coco/sev-guest/sev-guest.c | 195 +++--------------------- 3 files changed, 215 insertions(+), 184 deletions(-)
arch/x86/include/asm/sev.h +67 -4
@@ -14,6 +14,7 @@#include <asm/insn.h> #include <asm/sev-common.h> #include <asm/coco.h> +#include <asm/set_memory.h> #define GHCB_PROTOCOL_MIN 1ULL#define GHCB_PROTOCOL_MAX 2ULL
@@ -170,10 +171,6 @@ struct snp_guest_msg {u8 payload[PAGE_SIZE -sizeof (struct snp_guest_msg_hdr )]; } __packed; -struct sev_guest_platform_data { -u64 secrets_gpa; -}; -struct snp_guest_req {void *req_buf;size_t req_sz;
@@ -253,6 +250,7 @@ struct snp_msg_desc {u32 *os_area_msg_seqno;u8 *vmpck; +int vmpck_id; };/*
@@ -438,6 +436,63 @@ u64 sev_get_status(void);void sev_show_status (void );void snp_update_svsm_ca (void ); +static inline void free_shared_pages (void *buf,size_t sz) +{ +unsigned int npages =PAGE_ALIGN (sz) >>PAGE_SHIFT ; +int ret; + +if (!buf) +return ; + + ret =set_memory_encrypted ((unsigned long )buf, npages); +if (ret) { +WARN_ONCE (ret,"failed to restore encryption mask (leak it)\n" ); +return ; + } + +__free_pages (virt_to_page (buf),get_order (sz)); +} + +static inline void *alloc_shared_pages (size_t sz) +{ +unsigned int npages =PAGE_ALIGN (sz) >>PAGE_SHIFT ; +struct page *page; +int ret; + + page =alloc_pages (GFP_KERNEL_ACCOUNT ,get_order (sz)); +if (!page) +return NULL ; + + ret =set_memory_decrypted ((unsigned long )page_address (page), npages); +if (ret) { +pr_err ("failed to mark page shared, ret=%d\n" , ret); +__free_pages (page,get_order (sz)); +return NULL ; + } + +return page_address (page); +} + +static inline bool is_vmpck_empty (struct snp_msg_desc *mdesc) +{ +static const char zero_key[VMPCK_KEY_LEN ] = {0 }; + +if (mdesc->vmpck) +return !memcmp (mdesc->vmpck, zero_key,VMPCK_KEY_LEN ); + +return true; +} + +int snp_msg_init (struct snp_msg_desc *mdesc,int vmpck_id); +struct snp_msg_desc *snp_msg_alloc (void ); + +static inline void snp_msg_cleanup (struct snp_msg_desc *mdesc) +{ + mdesc->vmpck =NULL ; + mdesc->os_area_msg_seqno =NULL ; +kfree (mdesc->ctx); +} +#else /* !CONFIG_AMD_MEM_ENCRYPT */ #define snp_vmpl 0
@@ -474,6 +529,14 @@ static inline u64 snp_get_unsupported_features(u64 status) { return 0; }static inline u64 sev_get_status (void ) {return 0 ; }static inline void sev_show_status (void ) { }static inline void snp_update_svsm_ca (void ) { } +static inline void free_shared_pages (void *buf,size_t sz) { } +static inline void *alloc_shared_pages (size_t sz) {return NULL ; } +static inline bool is_vmpck_empty (struct snp_msg_desc *mdesc) {return false; } + +static inline int snp_msg_init (struct snp_msg_desc *mdesc,int vmpck_id) {return -1 ; } +static inline struct snp_msg_desc *snp_msg_alloc (void ) {return NULL ; } + +static inline void snp_msg_cleanup (struct snp_msg_desc *mdesc) { }#endif /* CONFIG_AMD_MEM_ENCRYPT */
arch/x86/coco/sev/core.c +127 -6
157 lines not on this page · raw message
drivers/virt/coco/sev-guest/sev-guest.c +21 -174
292 lines not on this page · raw message
Signature · 1 line
2.34.1
Borislav Petkov
maintainerRe: [PATCH v14 01/13] x86/sev: Carve out and export SNP guest messaging init routines
Quoted 10 lines · Nikunj A Dadhania
Currently, the SEV guest driver is the only user of SNP guest messaging. All routines for initializing SNP guest messaging are implemented within the SEV guest driver. To add Secure TSC guest support, these initialization routines need to be available during early boot.
Carve out common SNP guest messaging buffer allocations and message initialization routines to
core/sev.cand export them. These newly added APIs set up the SNP message context (snp_msg_desc), which contains all the necessary details for sending SNP guest messages.
Quoted 4 lines
At present, the SEV guest platform data structure is used to pass the secrets page physical address to SEV guest driver. Since the secrets page address is locally available to the initialization routine, use the cached address. Remove the unused SEV guest platform data structure.
Do not talk about *what* the patch is doing in the commit message - that should be obvious from the diff itself. Rather, concentrate on the *why* it needs to be done.
Imagine one fine day you're doing git archeology, you find the place in the code about which you want to find out why it was changed the way it is now.
You do git annotate <filename> ... find the line, see the commit id and you do:
git show <commit id>
You read the commit message and there's just gibberish and nothing's explaining *why* that change was done. And you start scratching your head, trying to figure out why.
See what I mean?
Quoted 40 lines
Signed-off-by Nikunj A Dadhania <[email protected]>Reviewed-by Tom Lendacky <[email protected]>--- arch/x86/include/asm/sev.h | 71 ++++++++- arch/x86/coco/sev/core.c | 133 +++++++++++++++- drivers/virt/coco/sev-guest/sev-guest.c | 195 +++--------------------- 3 files changed, 215 insertions(+), 184 deletions(-)arch/x86/include/asm/sev.h +2
-4@@ -14,6 +14,7 @@#include <asm/insn.h> #include <asm/sev-common.h> #include <asm/coco.h> +#include <asm/set_memory.h> #define GHCB_PROTOCOL_MIN 1ULL#define GHCB_PROTOCOL_MAX 2ULL@@ -170,10 +171,6 @@ struct snp_guest_msg {u8 payload[PAGE_SIZE -sizeof (struct snp_guest_msg_hdr )]; } __packed; -struct sev_guest_platform_data { -u64 secrets_gpa; -}; -struct snp_guest_req {void *req_buf;size_t req_sz;@@ -253,6 +250,7 @@ struct snp_msg_desc {u32 *os_area_msg_seqno;u8 *vmpck; +int vmpck_id; };/*
arch/x86/include/asm/sev.h u64 sev_get_status(void); · line 439
Quoted 4 lines
arch/x86/include/asm/sev.h +1
-0@@ -438,6 +436,63 @@ u64 sev_get_status(void);void sev_show_status (void );void snp_update_svsm_ca (void ); +static inline void free_shared_pages (void *buf,size_t sz)
A function with a generic name exported in a header?!
First of all, why is it in a header?
Then, why isn't it called something "sev_" or so...?
Same holds true for all the below.
Quoted 14 lines
arch/x86/include/asm/sev.h +14
-0+unsigned int npages =PAGE_ALIGN (sz) >>PAGE_SHIFT ; +int ret; + +if (!buf) +return ; + + ret =set_memory_encrypted ((unsigned long )buf, npages); +if (ret) { +WARN_ONCE (ret,"failed to restore encryption mask (leak it)\n" ); +return ; + } + +__free_pages (virt_to_page (buf),get_order (sz)); +}
...
arch/x86/include/asm/sev.h
Quoted 9 lines
arch/x86/include/asm/sev.h +9
-0+static struct aesgcm_ctx *snp_init_crypto (u8 *key,size_t keylen) +{ +struct aesgcm_ctx *ctx; + + ctx =kzalloc (sizeof (*ctx),GFP_KERNEL_ACCOUNT ); +if (!ctx) +return NULL ; + +if (aesgcm_expandkey (ctx, key, keylen,AUTHTAG_LEN )) {
ld: vmlinux.o: in function `snp_init_crypto':
/home/boris/kernel/2nd/linux/arch/x86/coco/sev/core.c:2700:(.text+0x1fa3): undefined reference to `aesgcm_expandkey' make[2]: *** [scripts/Makefile.vmlinux:34: vmlinux] Error 1
make[1]: *** [/mnt/kernel/kernel/2nd/linux/Makefile:1166: vmlinux] Error 2
make[1]: *** Waiting for unfinished jobs....
make: *** [Makefile:224: __sub-make] Error 2
I'll stop here until you fix those.
Btw, tip patches are done against tip/master - not against the branch they get queued in.
Thx.
Signature · 4 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquetteNikunj A. Dadhania
Reviewed-by Tom LendackyRe: [PATCH v14 01/13] x86/sev: Carve out and export SNP guest messaging init routines
Hi Boris,
Quoted 5 lines · Borislav Petkov
Quoted 4 lines · Nikunj A Dadhania
Currently, the SEV guest driver is the only user of SNP guest messaging. All routines for initializing SNP guest messaging are implemented within the SEV guest driver. To add Secure TSC guest support, these initialization routines need to be available during early boot.
The above paragraph explains why the change is being done.
Quoted 5 lines
Quoted 5 lines
Carve out common SNP guest messaging buffer allocations and message initialization routines to
core/sev.cand export them. These newly added APIs set up the SNP message context (snp_msg_desc), which contains all the necessary details for sending SNP guest messages.
This explains how it is being done, which I think is useful. However, if you think otherwise, I can remove.
Quoted 4 lines
Quoted 4 lines
At present, the SEV guest platform data structure is used to pass the secrets page physical address to SEV guest driver. Since the secrets page address is locally available to the initialization routine, use the cached address. Remove the unused SEV guest platform data structure.
In the above paragraph I tried to explains why I have removed sev_guest_platform_data.
Quoted 12 lines
Do not talk about *what* the patch is doing in the commit message - that should be obvious from the diff itself. Rather, concentrate on the *why* it needs to be done.
Imagine one fine day you're doing git archeology, you find the place in the code about which you want to find out why it was changed the way it is now.
You do git annotate <filename> ... find the line, see the commit id and you do:
Quoted 7 lines
git show <commit id>
You read the commit message and there's just gibberish and nothing's explaining *why* that change was done. And you start scratching your head, trying to figure out why.
See what I mean?
People have different styles of writing, as long as we are capturing the required information, IMHO, it should be fine.
Let me try to repharse the commit message again:
x86/sev: Carve out and export SNP guest messaging init routines
Currently, the sev-guest driver is the only user of SNP guest messaging. All routines for initializing SNP guest messaging are implemented within the sev-guest driver and are not available during early boot. In prepratation for adding Secure TSC guest support, carve out APIs to allocate and initialize guest messaging descriptor context and make it part of coco/sev/core.c. As there is no user of sev_guest_platform_data anymore, remove the structure.
Quoted 48 lines
Quoted 41 lines
Signed-off-by Nikunj A Dadhania <[email protected]>Reviewed-by Tom Lendacky <[email protected]>--- arch/x86/include/asm/sev.h | 71 ++++++++- arch/x86/coco/sev/core.c | 133 +++++++++++++++- drivers/virt/coco/sev-guest/sev-guest.c | 195 +++--------------------- 3 files changed, 215 insertions(+), 184 deletions(-)arch/x86/include/asm/sev.h +2
-4@@ -14,6 +14,7 @@#include <asm/insn.h> #include <asm/sev-common.h> #include <asm/coco.h> +#include <asm/set_memory.h> #define GHCB_PROTOCOL_MIN 1ULL#define GHCB_PROTOCOL_MAX 2ULL@@ -170,10 +171,6 @@ struct snp_guest_msg {u8 payload[PAGE_SIZE -sizeof (struct snp_guest_msg_hdr )]; } __packed; -struct sev_guest_platform_data { -u64 secrets_gpa; -}; -struct snp_guest_req {void *req_buf;size_t req_sz;@@ -253,6 +250,7 @@ struct snp_msg_desc {u32 *os_area_msg_seqno;u8 *vmpck; +int vmpck_id; };/* arch/x86/include/asm/sev.h u64 sev_get_status(void); · line 439
Quoted 4 lines
arch/x86/include/asm/sev.h +1
-0@@ -438,6 +436,63 @@ u64 sev_get_status(void);void sev_show_status (void );void snp_update_svsm_ca (void ); +static inline void free_shared_pages (void *buf,size_t sz)A function with a generic name exported in a header?!
Quoted 5 lines
First of all, why is it in a header?
Then, why isn't it called something "
sev_" or so...?Same holds true for all the below.
Sure, will update it accordingly in my next version.
Quoted 35 lines
Quoted 15 lines
arch/x86/include/asm/sev.h +14
-0+unsigned int npages =PAGE_ALIGN (sz) >>PAGE_SHIFT ; +int ret; + +if (!buf) +return ; + + ret =set_memory_encrypted ((unsigned long )buf, npages); +if (ret) { +WARN_ONCE (ret,"failed to restore encryption mask (leak it)\n" ); +return ; + } + +__free_pages (virt_to_page (buf),get_order (sz)); +}...
arch/x86/include/asm/sev.h
Quoted 9 lines
arch/x86/include/asm/sev.h +9
-0+static struct aesgcm_ctx *snp_init_crypto (u8 *key,size_t keylen) +{ +struct aesgcm_ctx *ctx; + + ctx =kzalloc (sizeof (*ctx),GFP_KERNEL_ACCOUNT ); +if (!ctx) +return NULL ; + +if (aesgcm_expandkey (ctx, key, keylen,AUTHTAG_LEN )) {ld: vmlinux.o: in function `snp_init_crypto':
/home/boris/kernel/2nd/linux/arch/x86/coco/sev/core.c:2700:(.text+0x1fa3): undefined reference to `aesgcm_expandkey' make[2]: *** [scripts/Makefile.vmlinux:34: vmlinux] Error 1
make[1]: *** [/mnt/kernel/kernel/2nd/linux/Makefile:1166: vmlinux] Error 2
make[1]: *** Waiting for unfinished jobs....
make: *** [Makefile:224: __sub-make] Error 2
Quoted 1 line
I'll stop here until you fix those.
Sorry for this, I had sev-guest driver as in-built module in my config, so wasn't able to catch this in my per patch build script. The corresponding fix is in the following patch[1], during patch juggling it had landed there:
arch/x86/Kconfig +1 -0
@@ -1556,6 +1556,7 @@ config AMD_MEM_ENCRYPT select ARCH_HAS_CC_PLATFORM select X86_MEM_ENCRYPT select UNACCEPTED_MEMORY + select CRYPTO_LIB_AESGCM help Say yes to enable support for the encryption of system memory. This requires an AMD processor that supports Secure Memory
drivers/virt/coco/sev-guest/Kconfig +0 -1
@@ -2,7 +2,6 @@ config SEV_GUEST tristate "AMD SEV Guest driver" default m depends on AMD_MEM_ENCRYPT - select CRYPTO_LIB_AESGCM select TSM_REPORTS help SEV-SNP firmware provides the guest a mechanism to communicate with
Quoted 2 lines
Btw, tip patches are done against tip/master - not against the branch they get queued in.
Sure, I will keep that in mind.
Thanks for the review,
Nikunj
1. https://lore.kernel.org/all/[email protected]/#Z31arch:x86:Kconfig
Borislav Petkov
maintainerRe: [PATCH v14 01/13] x86/sev: Carve out and export SNP guest messaging init routines
Quoted 7 lines · Nikunj A. Dadhania
Quoted 4 lines
Quoted 4 lines
Carve out common SNP guest messaging buffer allocations and message initialization routines to
core/sev.cand export them. These newly added APIs set up the SNP message context (snp_msg_desc), which contains all the necessary details for sending SNP guest messages.This explains how it is being done, which I think is useful. However, if you think otherwise, I can remove.
Useful why? It should be visible from the diff itself. Why do you have to explain your diff?
If you feel the need to have to explain it, then *maybe* it needs splitting or simplifying or whatnot.
Quoted 7 lines
Quoted 4 lines
Quoted 4 lines
At present, the SEV guest platform data structure is used to pass the secrets page physical address to SEV guest driver. Since the secrets page address is locally available to the initialization routine, use the cached address. Remove the unused SEV guest platform data structure.
In the above paragraph I tried to explains why I have removed
sev_guest_platform_data.
Probably ok.
Quoted 2 lines
People have different styles of writing, as long as we are capturing the required information, IMHO, it should be fine.
"... as long we are not writing what the patch does - which is visible from the diff itself, it should be fine." is what I would say.
Quoted 11 lines
Let me try to repharse the commit message again:
x86/sev: Carve out and export SNP guest messaging init routines
Currently, the sev-guest driver is the only user of SNP guest messaging. All routines for initializing SNP guest messaging are implemented within the sev-guest driver and are not available during early boot. In prepratation for adding Secure TSC guest support, carve out APIs to allocate and initialize guest messaging descriptor context and make it part of
coco/sev/core.c. As there is no user ofsev_guest_platform_dataanymore, remove the structure.
Yap, better.
Btw, you can even use AI for help rephrasing it:
-> Please simpliify this code change description by concentrating only on why the change is being done:
<insert commit message here>
ChatGPT: "This change is being made to allow the Secure TSC guest feature to access SNP guest messaging routines earlier in the boot process. By moving common SNP message initialization routines to a central location (core/sev.c) and exporting them, these routines become accessible for early boot needs. Additionally, since the secrets page address is now accessible within the initialization, the redundant SEV guest platform data structure has been removed."
-> Do the same as the above but write it in imperative tone
ChatGPT: "Enable Secure TSC guest support by moving the SNP guest messaging routines to core/sev.c, making them available during early boot. Export these routines to set up the SNP message context (snp_msg_desc) needed for guest messaging. Use the cached secrets page address in the initialization routine, and remove the unused SEV guest platform data structure."
I think that's a good help to use at least as a starter for the final commit message.
To sum up: I'd like the commit message to contain enough information to know *why* a change has been done. No rambling about what the patch does.
Quoted 18 lines
Quoted 8 lines
ld: vmlinux.o: in function `snp_init_crypto':
/home/boris/kernel/2nd/linux/arch/x86/coco/sev/core.c:2700:(.text+0x1fa3): undefined reference to `aesgcm_expandkey' make[2]: *** [scripts/Makefile.vmlinux:34: vmlinux] Error 1
make[1]: *** [/mnt/kernel/kernel/2nd/linux/Makefile:1166: vmlinux] Error 2
make[1]: *** Waiting for unfinished jobs....
make: *** [Makefile:224: __sub-make] Error 2I'll stop here until you fix those.
Sorry for this, I had sev-guest driver as in-built module in my config, so wasn't able to catch this in my per patch build script. The corresponding fix is in the following patch[1], during patch juggling it had landed there:
arch/x86/Kconfig +0
-0
arch/x86/Kconfig config AMD_MEM_ENCRYPT · line 1559
Quoted 4 lines
arch/x86/Kconfig +1
-0@@ -1556,6 +1556,7 @@ config AMD_MEM_ENCRYPT select ARCH_HAS_CC_PLATFORM select X86_MEM_ENCRYPT select UNACCEPTED_MEMORY + select CRYPTO_LIB_AESGCM
Right, that is debatable. AMD memory encryption support cannot really depend on a crypto library - you can get it without it too - just won't get secure TSC but for simplicity's sake let's leave it that way for now.
Because looking at this:
config AMD_MEM_ENCRYPT
bool "AMD Secure Memory Encryption (SME) support" depends on X86_64 && CPU_SUP_AMD
depends on EFI_STUB
select DMA_COHERENT_POOL
select ARCH_USE_MEMREMAP_PROT
select INSTRUCTION_DECODER
select ARCH_HAS_CC_PLATFORM
select X86_MEM_ENCRYPT
select UNACCEPTED_MEMORY
select CRYPTO_LIB_AESGCM
that symbol is pulling in a lot of other stuff. I guess it is ok for now...
Signature · 4 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquettePATCH v14 2/13 x86/sev: Relocate SNP guest messaging routines to common code
In reply to Nikunj A DadhaniaAt present, the SEV guest driver exclusively handles SNP guest messaging. All routines for sending guest messages are embedded within the guest driver. To support Secure TSC, SEV-SNP guests must communicate with the AMD Security Processor during early boot. However, these guest messaging functions are not accessible during early boot since they are currently part of the guest driver.
Hence, relocate the core SNP guest messaging functions to SEV common code and provide an API for sending SNP guest messages.
No functional change, but just an export symbol added for sev_send_geust_message() and dropped the export symbol on snp_issue_guest_request() and made it static.
--- arch/x86/include/asm/sev.h | 15 +- arch/x86/coco/sev/core.c | 295 +++++++++++++++++++++++- drivers/virt/coco/sev-guest/sev-guest.c | 292 ----------------------- arch/x86/Kconfig | 1 + drivers/virt/coco/sev-guest/Kconfig | 1 - 5 files changed, 301 insertions(+), 303 deletions(-)
arch/x86/include/asm/sev.h +8 -7
@@ -125,6 +125,9 @@ struct snp_req_data {#define AAD_LEN 48#define MSG_HDR_VER 1 +#define SNP_REQ_MAX_RETRY_DURATION (60*HZ) +#define SNP_REQ_RETRY_DELAY (2*HZ) +/* See SNP spec SNP_GUEST_REQUEST section for the structure */ enum msg_type {SNP_MSG_TYPE_INVALID =0 ,
@@ -427,8 +430,6 @@ void snp_set_wakeup_secondary_cpu(void);bool snp_init (struct boot_params *bp);void __noreturn snp_abort (void );void snp_dmi_setup (void ); -int snp_issue_guest_request (struct snp_guest_req *req,struct snp_req_data *input, -struct snp_guest_request_ioctl *rio);int snp_issue_svsm_attest_req (u64 call_id,struct svsm_call *call,struct svsm_attest_call *input);void snp_accept_memory (phys_addr_t start,phys_addr_t end);u64 snp_get_unsupported_features (u64 status);
@@ -493,6 +494,9 @@ static inline void snp_msg_cleanup(struct snp_msg_desc *mdesc) kfree(mdesc->ctx); } +int snp_send_guest_request (struct snp_msg_desc *mdesc,struct snp_guest_req *req, +struct snp_guest_request_ioctl *rio); +#else /* !CONFIG_AMD_MEM_ENCRYPT */ #define snp_vmpl 0
@@ -515,11 +519,6 @@ static inline void snp_set_wakeup_secondary_cpu(void) { }static inline bool snp_init (struct boot_params *bp) {return false; }static inline void snp_abort (void ) { }static inline void snp_dmi_setup (void ) { } -static inline int snp_issue_guest_request (struct snp_guest_req *req,struct snp_req_data *input, -struct snp_guest_request_ioctl *rio) -{ -return -ENOTTY ; -}static inline int snp_issue_svsm_attest_req (u64 call_id,struct svsm_call *call,struct svsm_attest_call *input) {return -ENOTTY ;
@@ -537,6 +536,8 @@ static inline int snp_msg_init(struct snp_msg_desc *mdesc, int vmpck_id) { returstatic inline struct snp_msg_desc *snp_msg_alloc (void ) {return NULL ; }static inline void snp_msg_cleanup (struct snp_msg_desc *mdesc) { } +static inline int snp_send_guest_request (struct snp_msg_desc *mdesc,struct snp_guest_req *req, +struct snp_guest_request_ioctl *rio) {return -ENODEV ; }#endif /* CONFIG_AMD_MEM_ENCRYPT */
arch/x86/coco/sev/core.c +292 -3
310 lines not on this page · raw message
drivers/virt/coco/sev-guest/sev-guest.c +0 -292
310 lines not on this page · raw message
arch/x86/Kconfig +1 -0
@@ -1556,6 +1556,7 @@ config AMD_MEM_ENCRYPT select ARCH_HAS_CC_PLATFORM select X86_MEM_ENCRYPT select UNACCEPTED_MEMORY + select CRYPTO_LIB_AESGCM help Say yes to enable support for the encryption of system memory. This requires an AMD processor that supports Secure Memory
drivers/virt/coco/sev-guest/Kconfig +0 -1
@@ -2,7 +2,6 @@ config SEV_GUEST tristate "AMD SEV Guest driver" default m depends on AMD_MEM_ENCRYPT - select CRYPTO_LIB_AESGCM select TSM_REPORTS help SEV-SNP firmware provides the guest a mechanism to communicate with
Signature · 1 line
2.34.1
PATCH v14 3/13 x86/sev: Add Secure TSC support for SNP guests
In reply to Nikunj A DadhaniaAdd support for Secure TSC in SNP-enabled guests. Secure TSC allows guests to securely use RDTSC/RDTSCP instructions, ensuring that the parameters used cannot be altered by the hypervisor once the guest is launched.
Secure TSC-enabled guests need to query TSC information from the AMD Security Processor. This communication channel is encrypted between the AMD Security Processor and the guest, with the hypervisor acting merely as a conduit to deliver the guest messages to the AMD Security Processor. Each message is protected with AEAD (AES-256 GCM). Use a minimal AES GCM library to encrypt and decrypt SNP guest messages for communication with the PSP.
Use mem_encrypt_init() to fetch SNP TSC information from the AMD Security Processor and initialize snp_tsc_scale and snp_tsc_offset. During secondary CPU initialization, set the VMSA fields GUEST_TSC_SCALE (offset 2F0h) and GUEST_TSC_OFFSET (offset 2F8h) with snp_tsc_scale and snp_tsc_offset, respectively.
Add confidential compute platform attribute CC_ATTR_GUEST_SNP_SECURE_TSC that can be used by the guest to query whether the Secure TSC feature is active.
Since handle_guest_request() is common routine used by both the SEV guest driver and Secure TSC code, move it to the SEV header file.
--- arch/x86/include/asm/sev-common.h | 1 + arch/x86/include/asm/sev.h | 46 ++++++++++++++++ arch/x86/include/asm/svm.h | 6 ++- include/linux/cc_platform.h | 8 +++ arch/x86/coco/core.c | 3 ++ arch/x86/coco/sev/core.c | 90 +++++++++++++++++++++++++++++++ arch/x86/mm/mem_encrypt.c | 4 ++ 7 files changed, 156 insertions(+), 2 deletions(-)
arch/x86/include/asm/sev-common.h +1 -0
@@ -206,6 +206,7 @@ struct snp_psc_desc {#define GHCB_TERM_NO_SVSM 7/* SVSM is not advertised in the secrets page */ #define GHCB_TERM_SVSM_VMPL0 8/* SVSM is present but has set VMPL to 0 */ #define GHCB_TERM_SVSM_CAA 9/* SVSM is present but CAA is not page aligned */ +#define GHCB_TERM_SECURE_TSC 10/* Secure TSC initialization failed */ #define GHCB_RESP_CODE (v) ((v) & GHCB_MSR_INFO_MASK)
arch/x86/include/asm/sev.h +46 -0
70 lines not on this page · raw message
arch/x86/include/asm/svm.h +4 -2
@@ -417,7 +417,9 @@ struct sev_es_save_area {u8 reserved_0x298[80 ];u32 pkru;u32 tsc_aux; -u8 reserved_0x2f0[24 ]; +u64 tsc_scale; +u64 tsc_offset; +u8 reserved_0x300[8 ];u64 rcx;u64 rdx;u64 rbx;
@@ -564,7 +566,7 @@ static inline void __unused_size_checks(void)BUILD_BUG_RESERVED_OFFSET (sev_es_save_area,0x1c0 );BUILD_BUG_RESERVED_OFFSET (sev_es_save_area,0x248 );BUILD_BUG_RESERVED_OFFSET (sev_es_save_area,0x298 ); -BUILD_BUG_RESERVED_OFFSET (sev_es_save_area,0x2f0 ); +BUILD_BUG_RESERVED_OFFSET (sev_es_save_area,0x300 );BUILD_BUG_RESERVED_OFFSET (sev_es_save_area,0x320 );BUILD_BUG_RESERVED_OFFSET (sev_es_save_area,0x380 );BUILD_BUG_RESERVED_OFFSET (sev_es_save_area,0x3f0 );
include/linux/cc_platform.h +8 -0
@@ -88,6 +88,14 @@ enum cc_attr {* enabled to run SEV-SNP guests. */ CC_ATTR_HOST_SEV_SNP , + +/** +* @CC_ATTR_GUEST_SNP_SECURE_TSC: SNP Secure TSC is active. +* +* The platform/OS is running as a guest/virtual machine and actively +* using AMD SEV-SNP Secure TSC feature. +*/ + CC_ATTR_GUEST_SNP_SECURE_TSC, };#ifdef CONFIG_ARCH_HAS_CC_PLATFORM
arch/x86/coco/core.c +3 -0
@@ -100,6 +100,9 @@ static bool noinstr amd_cc_platform_has(enum cc_attr attr)case CC_ATTR_HOST_SEV_SNP :return cc_flags.host_sev_snp; +case CC_ATTR_GUEST_SNP_SECURE_TSC : +return sev_status &MSR_AMD64_SNP_SECURE_TSC ; +default :return false; }
arch/x86/coco/sev/core.c +90 -0
105 lines not on this page · raw message
arch/x86/mm/mem_encrypt.c +4 -0
@@ -94,6 +94,10 @@ void __init mem_encrypt_init(void)/* Call into SWIOTLB to update the SWIOTLB DMA buffers */ swiotlb_update_mem_attributes (); +/* Initialize SNP Secure TSC */ +if (cc_platform_has (CC_ATTR_GUEST_SEV_SNP )) +snp_secure_tsc_prepare (); +print_mem_encrypt_feature_info (); }
Signature · 1 line
2.34.1
Re: [PATCH v14 03/13] x86/sev: Add Secure TSC support for SNP guests
Quoted 11 lines · Nikunj A Dadhania
Add support for Secure TSC in SNP-enabled guests. Secure TSC allows guests to securely use RDTSC/RDTSCP instructions, ensuring that the parameters used cannot be altered by the hypervisor once the guest is launched.
Secure TSC-enabled guests need to query TSC information from the AMD Security Processor. This communication channel is encrypted between the AMD Security Processor and the guest, with the hypervisor acting merely as a conduit to deliver the guest messages to the AMD Security Processor. Each message is protected with AEAD (AES-256 GCM). Use a minimal AES GCM library to encrypt and decrypt SNP guest messages for communication with the PSP.
Quoted 2 lines
Use
mem_encrypt_init()to fetch SNP TSC information from the AMD Security Processor and initializesnp_tsc_scaleandsnp_tsc_offset.
Why do it inside mem_encrypt_init()?
It's better to introduce a snp_guest_init/setup() like tdx_early_init() to do all the SNP related setup stuff instead of scattering them all around the kernel code.
Quoted 5 lines
During secondary
CPU initialization, set the VMSA fieldsGUEST_TSC_SCALE(offset 2F0h) andGUEST_TSC_OFFSET(offset 2F8h) withsnp_tsc_scaleandsnp_tsc_offset, respectively.
Re: [PATCH v14 03/13] x86/sev: Add Secure TSC support for SNP guests
Quoted 12 lines · Xiaoyao Li
Quoted 11 lines · Nikunj A Dadhania
Add support for Secure TSC in SNP-enabled guests. Secure TSC allows guests to securely use RDTSC/RDTSCP instructions, ensuring that the parameters used cannot be altered by the hypervisor once the guest is launched.
Secure TSC-enabled guests need to query TSC information from the AMD Security Processor. This communication channel is encrypted between the AMD Security Processor and the guest, with the hypervisor acting merely as a conduit to deliver the guest messages to the AMD Security Processor. Each message is protected with AEAD (AES-256 GCM). Use a minimal AES GCM library to encrypt and decrypt SNP guest messages for communication with the PSP.
Quoted 4 lines
Quoted 2 lines
Use
mem_encrypt_init()to fetch SNP TSC information from the AMD Security Processor and initializesnp_tsc_scaleandsnp_tsc_offset.Why do it inside
mem_encrypt_init()?
It was discussed here: https://lore.kernel.org/lkml/20240422132058.GBZiZkOqU0zFviMzoC@fat_crate.local/
Regards
Nikunj
Re: [PATCH v14 03/13] x86/sev: Add Secure TSC support for SNP guests
Quoted 15 lines · Nikunj A. Dadhania
Quoted 12 lines · Xiaoyao Li
Quoted 11 lines · Nikunj A Dadhania
Add support for Secure TSC in SNP-enabled guests. Secure TSC allows guests to securely use RDTSC/RDTSCP instructions, ensuring that the parameters used cannot be altered by the hypervisor once the guest is launched.
Secure TSC-enabled guests need to query TSC information from the AMD Security Processor. This communication channel is encrypted between the AMD Security Processor and the guest, with the hypervisor acting merely as a conduit to deliver the guest messages to the AMD Security Processor. Each message is protected with AEAD (AES-256 GCM). Use a minimal AES GCM library to encrypt and decrypt SNP guest messages for communication with the PSP.
Quoted 6 lines
Quoted 4 lines
Quoted 2 lines
Use
mem_encrypt_init()to fetch SNP TSC information from the AMD Security Processor and initializesnp_tsc_scaleandsnp_tsc_offset.Why do it inside
mem_encrypt_init()?It was discussed here: https://lore.kernel.org/lkml/20240422132058.GBZiZkOqU0zFviMzoC@fat_crate.local/
IMHO, it's a bad starter. As more and more SNP features will be enabled in the future, a SNP init function like tdx_early_init() would be a good place for all SNP guest stuff.
Just my 2 cents.
Quoted 2 lines
Regards
Nikunj
Borislav Petkov
maintainerRe: [PATCH v14 03/13] x86/sev: Add Secure TSC support for SNP guests
Quoted 1 line · Xiaoyao Li
IMHO, it's a bad starter.
What does a "bad starter" mean exactly?
Quoted 3 lines
As more and more SNP features will be enabled in the future, a SNP init function like
tdx_early_init()would be a good place for all SNP guest stuff.
There is already a call to sme_early_init() around that area. It could be repurposed for SEV/SNP stuff too...
Signature · 4 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquetteRe: [PATCH v14 03/13] x86/sev: Add Secure TSC support for SNP guests
Quoted 11 lines · Borislav Petkov
Quoted 1 line · Xiaoyao Li
IMHO, it's a bad starter.
What does a "bad starter" mean exactly?
Quoted 3 lines
As more and more SNP features will be enabled in the future, a SNP init function like
tdx_early_init()would be a good place for all SNP guest stuff.There is already a call to
sme_early_init()around that area. It could be repurposed for SEV/SNP stuff too...
Yes, the early call to sme_early_init() is meant for SME, SEV, SEV-ES and SEV-SNP since we have to support them all and currently does initialization for all of these. It is analogous to the tdx_early_init() call.
TDX also makes use of initialization that happens in mem_encrypt_init() and mem_encrypt_setup_arch(), so it doesn't only use tdx_early_init().
Thanks,
Tom
Quoted 1 line
Borislav Petkov
maintainerRe: [PATCH v14 03/13] x86/sev: Add Secure TSC support for SNP guests
Quoted 2 lines · Tom Lendacky
TDX also makes use of initialization that happens in
mem_encrypt_init()andmem_encrypt_setup_arch(), so it doesn't only usetdx_early_init().
I think he means that mem_encrypt_init() should do some more "generic" memory encryption setup while the vendor-specific one should be concentrated in vendor-specific calls.
But this is all meh - there are vendor checks in all the memory encryption paths so I'm not sure what we're even discussing here actually...
Signature · 4 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquetteRe: [PATCH v14 03/13] x86/sev: Add Secure TSC support for SNP guests
In reply to Borislav PetkovQuoted 4 lines · Borislav Petkov
Quoted 1 line · Xiaoyao Li
IMHO, it's a bad starter.
What does a "bad starter" mean exactly?
I meant the starter to add SNP guest specific feature initialization code in somewhat in proper place.
Borislav Petkov
maintainerRe: [PATCH v14 03/13] x86/sev: Add Secure TSC support for SNP guests
Quoted 2 lines · Xiaoyao Li
I meant the starter to add SNP guest specific feature initialization code in somewhat in proper place.
https://lore.kernel.org/r/20241029144948.GIZyD2DBjyg6FBLdo4@fat_crate.local
IOW, I don't think we really have a "proper" place yet. There are vendor checks all over the memory encryption code for different reasons.
Signature · 4 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquetteRe: [PATCH v14 03/13] x86/sev: Add Secure TSC support for SNP guests
Quoted 7 lines · Borislav Petkov
Quoted 2 lines · Xiaoyao Li
I meant the starter to add SNP guest specific feature initialization code in somewhat in proper place.
https://lore.kernel.org/r/20241029144948.GIZyD2DBjyg6FBLdo4@fat_crate.local
IOW, I don't think we really have a "proper" place yet.
Then why can't we create one for it?
Quoted 2 lines
There are vendor
checks all over the memory encryption code for different reasons.
But they are at least related to memory encryption, I think.
However, how secure TSC related to memory encryption?
Borislav Petkov
maintainerRe: [PATCH v14 03/13] x86/sev: Add Secure TSC support for SNP guests
Quoted 1 line · Xiaoyao Li
However, how secure TSC related to memory encryption?
Are you kidding me?
Secure TSC is a SNP feature.
I don't think you're getting it so lemme elaborate:
mem_encrypt.c is only *trying* to be somewhat generic but there is stuff like:
if (cc_platform_has(CC_ATTR_HOST_SEV_SNP))
snp_fixup_e820_tables();for example.
Both TDX and SEV/SNP need to call *something* at different times during boot for various reasons.
We could aim for generalizing things by doing per-vendor early init functions, which is ok, but hasn't been the main goal so far. So far the goal is to do the proper init/setup calls at the right time during boot and not allow the code to grow into an unmaintainable mess while doing so.
But both vendors need to do different things at different times during the lifetime of the kernel depending on what they need/want to support.
IOW, the memory encryption code is still shaping up...
Signature · 4 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquetteRe: [PATCH v14 03/13] x86/sev: Add Secure TSC support for SNP guests
In reply to Xiaoyao LiQuoted 11 lines · Xiaoyao Li
Quoted 8 lines · Borislav Petkov
Quoted 3 lines · Xiaoyao Li
I meant the starter to add SNP guest specific feature initialization code in
somewhat in proper place.https://lore.kernel.org/r/20241029144948.GIZyD2DBjyg6FBLdo4@fat_crate.local
IOW, I don't think we really have a "proper" place yet.
Then why can't we create one for it?
The code looks fine to me as-is. If anyone sees a better way to refactor it and stash it elsewhere to make it cleaner and simpler, I'd love to see the patch.
Borislav Petkov
maintainerRe: [PATCH v14 03/13] x86/sev: Add Secure TSC support for SNP guests
Quoted 3 lines · Dave Hansen
The code looks fine to me as-is. If anyone sees a better way to refactor it and stash it elsewhere to make it cleaner and simpler, I'd love to see the patch.
You basically read my mind!
:-)
Signature · 4 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquetteRe: [PATCH v14 03/13] x86/sev: Add Secure TSC support for SNP guests
In reply to Nikunj A DadhaniaQuoted 12 lines · Nikunj A Dadhania
arch/x86/include/asm/sev.h +8
-0@@ -497,6 +516,27 @@ static inline void snp_msg_cleanup(struct snp_msg_desc *mdesc)int snp_send_guest_request (struct snp_msg_desc *mdesc,struct snp_guest_req *req,struct snp_guest_request_ioctl *rio); +static inline int handle_guest_request (struct snp_msg_desc *mdesc,u64 exit_code, +struct snp_guest_request_ioctl *rio,u8 type, +void *req_buf,size_t req_sz,void *resp_buf, +u32 resp_sz) +{ +struct snp_guest_req req = { + .msg_version = rio->msg_version, + .msg_type = type,
arch/x86/include/asm/sev.h static inline void snp_msg_cleanup(struct snp_msg_desc *mdesc) · line 536
Quoted 10 lines
arch/x86/include/asm/sev.h +10
-0+ .vmpck_id = mdesc->vmpck_id, + .req_buf = req_buf, + .req_sz = req_sz, + .resp_buf = resp_buf, + .resp_sz = resp_sz, + .exit_code = exit_code, + }; + +return snp_send_guest_request (mdesc, &req, rio); +}
I realized that the above is not required anymore. I will remove in my next version.
arch/x86/include/asm/sev.h static inline struct snp_msg_desc *snp_msg_alloc(void) { return NULL; } · line 585
Quoted 9 lines
arch/x86/include/asm/sev.h +5
-0@@ -538,6 +578,12 @@ static inline struct snp_msg_desc *snp_msg_alloc(void) { return NULL; }static inline void snp_msg_cleanup (struct snp_msg_desc *mdesc) { }static inline int snp_send_guest_request (struct snp_msg_desc *mdesc,struct snp_guest_req *req,struct snp_guest_request_ioctl *rio) {return -ENODEV ; } +static inline int handle_guest_request (struct snp_msg_desc *mdesc,u64 exit_code, +struct snp_guest_request_ioctl *rio,u8 type, +void *req_buf,size_t req_sz,void *resp_buf, +u32 resp_sz) {return -ENODEV ; } +
Ditto.
Regards
Nikunj
Borislav Petkov
maintainerRe: [PATCH v14 03/13] x86/sev: Add Secure TSC support for SNP guests
In reply to Nikunj A DadhaniaQuoted 9 lines · Nikunj A Dadhania
Add support for Secure TSC in SNP-enabled guests. Secure TSC allows guests to securely use RDTSC/RDTSCP instructions, ensuring that the parameters used cannot be altered by the hypervisor once the guest is launched.
Secure TSC-enabled guests need to query TSC information from the AMD Security Processor. This communication channel is encrypted between the AMD Security Processor and the guest, with the hypervisor acting merely as a conduit to deliver the guest messages to the AMD Security Processor. Each message is protected with AEAD (AES-256 GCM).
Zap all that text below or shorten it to the bits only which explain why something is done the way it is.
Quoted 15 lines
Use a minimal AES GCM library
to encrypt and decrypt SNP guest messages for communication with the PSP.Use
mem_encrypt_init()to fetch SNP TSC information from the AMD Security Processor and initializesnp_tsc_scaleandsnp_tsc_offset. During secondary CPU initialization, set the VMSA fieldsGUEST_TSC_SCALE(offset 2F0h) andGUEST_TSC_OFFSET(offset 2F8h) withsnp_tsc_scaleandsnp_tsc_offset, respectively.Add confidential compute platform attribute
CC_ATTR_GUEST_SNP_SECURE_TSCthat can be used by the guest to query whether the Secure TSC feature is active.Since
handle_guest_request()is common routine used by both the SEV guest driver and Secure TSC code, move it to the SEV header file.
...
arch/x86/coco/sev/core.c static u64 secrets_pa __ro_after_init; · line 103
Quoted 11 lines
arch/x86/coco/sev/core.c +3
-0@@ -98,6 +98,10 @@ static u64 secrets_pa __ro_after_init;static struct snp_msg_desc *snp_mdesc; +/* Secure TSC values read using TSC_INFO SNP Guest request */ +static u64 snp_tsc_scale__ro_after_init ; +static u64 snp_tsc_offset__ro_after_init ;
I don't understand the point of this: this is supposed to be per VMSA so everytime you create a guest, that guest is supposed to query the PSP. What are those for?
Or are those the guest's TSC values which you're supposed to replicate across the APs?
If so, put that info in the comment above it - it is much more important than what you have there now.
arch/x86/coco/sev/core.c static int wakeup_cpu_via_vmgexit(u32 apic_id, unsigned long start_ip) · line 1155
Quoted 8 lines
arch/x86/coco/sev/core.c +1
-0/* #VC handler runtime per-CPU data */ struct sev_es_runtime_data {struct ghcb ghcb_page;@@ -1148,6 +1152,12 @@ static int wakeup_cpu_via_vmgexit(u32 apic_id, unsigned long start_ip) vmsa->vmpl = snp_vmpl; vmsa->sev_features = sev_status >>2 ; +/* Set Secure TSC parameters */
That's obvious. Why are you setting them, is more important.
Quoted 9 lines
arch/x86/coco/sev/core.c +5
-0+if (cc_platform_has (CC_ATTR_GUEST_SNP_SECURE_TSC )) { + vmsa->tsc_scale = snp_tsc_scale; + vmsa->tsc_offset = snp_tsc_offset; + } +/* Switch the page over to a VMSA page now that it is initialized */ ret =snp_set_vmsa (vmsa, caa, apic_id, true);if (ret) {
arch/x86/coco/sev/core.c int snp_send_guest_request(struct snp_msg_desc *mdesc, struct snp_guest_req *req · line 2958
Quoted 7 lines
arch/x86/coco/sev/core.c +4
-0@@ -2942,3 +2952,83 @@ int snp_send_guest_request(struct snp_msg_desc *mdesc, struct snp_guest_req *reqreturn 0 ; }EXPORT_SYMBOL_GPL (snp_send_guest_request); + +static int __init snp_get_tsc_info (void ) +{ +static u8 buf[SNP_TSC_INFO_RESP_SZ +AUTHTAG_LEN ];
You're allocating stuff below dynamically. Why is this buffer allocated on the stack?
arch/x86/coco/sev/core.c int snp_send_guest_request(struct snp_msg_desc *mdesc, struct snp_guest_req *req · line 2960
Quoted 2 lines
arch/x86/coco/sev/core.c +2
-0+struct snp_guest_request_ioctl rio; +struct snp_tsc_info_resp tsc_resp;
Ditto.
arch/x86/coco/sev/core.c int snp_send_guest_request(struct snp_msg_desc *mdesc, struct snp_guest_req *req · line 2970
Quoted 10 lines
arch/x86/coco/sev/core.c +10
-0+struct snp_tsc_info_req *tsc_req; +struct snp_msg_desc *mdesc; +struct snp_guest_req req; +int rc; + +/* +* The intermediate response buffer is used while decrypting the +* response payload. Make sure that it has enough space to cover the +* authtag. +*/
Yes, this is how you do comments - you comment stuff which is non-obvious.
arch/x86/coco/sev/core.c int snp_send_guest_request(struct snp_msg_desc *mdesc, struct snp_guest_req *req · line 2983
Quoted 13 lines
arch/x86/coco/sev/core.c +13
-0+BUILD_BUG_ON (sizeof (buf) < (sizeof (tsc_resp) +AUTHTAG_LEN )); + + mdesc =snp_msg_alloc (); +if (IS_ERR_OR_NULL (mdesc)) +return -ENOMEM ; + + rc =snp_msg_init (mdesc, snp_vmpl); +if (rc) +return rc; + + tsc_req =kzalloc (sizeof (struct snp_tsc_info_req ),GFP_KERNEL ); +if (!tsc_req) +return -ENOMEM ;
You return here and you leak mdesc. Where are those mdesc things even freed? I see snp_msg_alloc() but not a "free" counterpart...
Quoted 9 lines
arch/x86/coco/sev/core.c +9
-0+memset (&req,0 ,sizeof (req)); +memset (&rio,0 ,sizeof (rio)); +memset (buf,0 ,sizeof (buf)); + + req.msg_version =MSG_HDR_VER ; + req.msg_type =SNP_MSG_TSC_INFO_REQ ; + req.vmpck_id = snp_vmpl; + req.req_buf = tsc_req; + req.req_sz =sizeof (*tsc_req);
arch/x86/coco/sev/core.c int snp_send_guest_request(struct snp_msg_desc *mdesc, struct snp_guest_req *req · line 3003
Quoted 10 lines
arch/x86/coco/sev/core.c +10
-0+ req.resp_buf = buf; + req.resp_sz =sizeof (tsc_resp) +AUTHTAG_LEN ; + req.exit_code =SVM_VMGEXIT_GUEST_REQUEST ; + + rc =snp_send_guest_request (mdesc, &req, &rio); +if (rc) + goto err_req; + +memcpy (&tsc_resp, buf,sizeof (tsc_resp)); + pr_debug("%s: response status %x scale %llx offset %llx factor %x\n",
Prefix all hex values with "0x" so that it is unambiguous.
arch/x86/coco/sev/core.c int snp_send_guest_request(struct snp_msg_desc *mdesc, struct snp_guest_req *req · line 3006
Quoted 3 lines
arch/x86/coco/sev/core.c +3
-0+ __func__, tsc_resp.status, tsc_resp.tsc_scale, tsc_resp.tsc_offset, + tsc_resp.tsc_factor); +
if (!tsc_resp.status)
arch/x86/coco/sev/core.c int snp_send_guest_request(struct snp_msg_desc *mdesc, struct snp_guest_req *req · line 3011
Quoted 5 lines
arch/x86/coco/sev/core.c +5
-0+if (tsc_resp.status ==0 ) { + snp_tsc_scale = tsc_resp.tsc_scale; + snp_tsc_offset = tsc_resp.tsc_offset; + }else { +pr_err ("Failed to get TSC info, response status %x\n" , tsc_resp.status);
Ox
arch/x86/coco/sev/core.c int snp_send_guest_request(struct snp_msg_desc *mdesc, struct snp_guest_req *req · line 3016
Quoted 5 lines
arch/x86/coco/sev/core.c +5
-0+ rc = -EIO ; + } + +err_req: +/* The response buffer contains the sensitive data, explicitly clear it. */
s/the //
Quoted 23 lines
arch/x86/coco/sev/core.c +18
-0+memzero_explicit (buf,sizeof (buf)); +memzero_explicit (&tsc_resp,sizeof (tsc_resp)); + +return rc; +} + +void __init snp_secure_tsc_prepare (void ) +{ +if (!cc_platform_has (CC_ATTR_GUEST_SNP_SECURE_TSC )) +return ; + +if (snp_get_tsc_info ()) { +pr_alert ("Unable to retrieve Secure TSC info from ASP\n" ); +sev_es_terminate (SEV_TERM_SET_LINUX ,GHCB_TERM_SECURE_TSC ); + } + +pr_debug ("SecureTSC enabled" ); +}arch/x86/mm/mem_encrypt.c +0
-0
arch/x86/mm/mem_encrypt.c void __init mem_encrypt_init(void) · line 97
Quoted 4 lines
arch/x86/mm/mem_encrypt.c +1
-0@@ -94,6 +94,10 @@ void __init mem_encrypt_init(void)/* Call into SWIOTLB to update the SWIOTLB DMA buffers */ swiotlb_update_mem_attributes (); +/* Initialize SNP Secure TSC */
Useless comment.
arch/x86/mm/mem_encrypt.c void __init mem_encrypt_init(void) · line 99
Quoted 2 lines
arch/x86/mm/mem_encrypt.c +2
-0+if (cc_platform_has (CC_ATTR_GUEST_SEV_SNP )) +snp_secure_tsc_prepare ();
Why don't you call this one in the same if-condition in mem_encrypt_setup_arch() ?
Quoted 7 lines
arch/x86/mm/mem_encrypt.c +1
-0+print_mem_encrypt_feature_info (); }Signature · 1 line
2.34.1
Signature · 4 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquetteRe: [PATCH v14 03/13] x86/sev: Add Secure TSC support for SNP guests
Quoted 5 lines · Borislav Petkov
Quoted 4 lines · Nikunj A Dadhania
Add support for Secure TSC in SNP-enabled guests. Secure TSC allows guests to securely use RDTSC/RDTSCP instructions, ensuring that the parameters used cannot be altered by the hypervisor once the guest is launched.
Quoted 8 lines
Quoted 5 lines
Secure TSC-enabled guests need to query TSC information from the AMD Security Processor. This communication channel is encrypted between the AMD Security Processor and the guest, with the hypervisor acting merely as a conduit to deliver the guest messages to the AMD Security Processor. Each message is protected with AEAD (AES-256 GCM).
Zap all that text below or shorten it to the bits only which explain why something is done the way it is.
Sure, I will update.
Quoted 35 lines
Quoted 16 lines
Use a minimal AES GCM library
to encrypt and decrypt SNP guest messages for communication with the PSP.Use
mem_encrypt_init()to fetch SNP TSC information from the AMD Security Processor and initializesnp_tsc_scaleandsnp_tsc_offset. During secondary CPU initialization, set the VMSA fieldsGUEST_TSC_SCALE(offset 2F0h) andGUEST_TSC_OFFSET(offset 2F8h) withsnp_tsc_scaleandsnp_tsc_offset, respectively.Add confidential compute platform attribute
CC_ATTR_GUEST_SNP_SECURE_TSCthat can be used by the guest to query whether the Secure TSC feature is active.Since
handle_guest_request()is common routine used by both the SEV guest driver and Secure TSC code, move it to the SEV header file....
arch/x86/coco/sev/core.c static u64 secrets_pa __ro_after_init; · line 103
Quoted 11 lines
arch/x86/coco/sev/core.c +3
-0@@ -98,6 +98,10 @@ static u64 secrets_pa __ro_after_init;static struct snp_msg_desc *snp_mdesc; +/* Secure TSC values read using TSC_INFO SNP Guest request */ +static u64 snp_tsc_scale__ro_after_init ; +static u64 snp_tsc_offset__ro_after_init ;I don't understand the point of this: this is supposed to be per VMSA so everytime you create a guest, that guest is supposed to query the PSP. What are those for?
Quoted 2 lines
Or are those the guest's TSC values which you're supposed to replicate across the APs?
Yes, that is correct. The BP makes the SNP guest requests and initializes both the values. These are later used by APs to initialize the VMSA fields (TSC_SCALE and TSC_OFFSET).
Quoted 2 lines
If so, put that info in the comment above it - it is much more important than what you have there now.
Make sense, I will update the comment.
Quoted 11 lines
arch/x86/coco/sev/core.c static int wakeup_cpu_via_vmgexit(u32 apic_id, unsigned long start_ip) · line 1155
Quoted 9 lines
arch/x86/coco/sev/core.c +1
-0/* #VC handler runtime per-CPU data */ struct sev_es_runtime_data {struct ghcb ghcb_page;@@ -1148,6 +1152,12 @@ static int wakeup_cpu_via_vmgexit(u32 apic_id, unsigned long start_ip) vmsa->vmpl = snp_vmpl; vmsa->sev_features = sev_status >>2 ; +/* Set Secure TSC parameters */ That's obvious. Why are you setting them, is more important.
Sure will update.
Quoted 21 lines
Quoted 10 lines
arch/x86/coco/sev/core.c +5
-0+if (cc_platform_has (CC_ATTR_GUEST_SNP_SECURE_TSC )) { + vmsa->tsc_scale = snp_tsc_scale; + vmsa->tsc_offset = snp_tsc_offset; + } +/* Switch the page over to a VMSA page now that it is initialized */ ret =snp_set_vmsa (vmsa, caa, apic_id, true);if (ret) {arch/x86/coco/sev/core.c int snp_send_guest_request(struct snp_msg_desc *mdesc, struct snp_guest_req *req · line 2958
Quoted 7 lines
arch/x86/coco/sev/core.c +4
-0@@ -2942,3 +2952,83 @@ int snp_send_guest_request(struct snp_msg_desc *mdesc, struct snp_guest_req *reqreturn 0 ; }EXPORT_SYMBOL_GPL (snp_send_guest_request); + +static int __init snp_get_tsc_info (void ) +{ +static u8 buf[SNP_TSC_INFO_RESP_SZ +AUTHTAG_LEN ];You're allocating stuff below dynamically. Why is this buffer allocated on the stack?
Quoted 4 lines
arch/x86/coco/sev/core.c int snp_send_guest_request(struct snp_msg_desc *mdesc, struct snp_guest_req *req · line 2960
Quoted 2 lines
arch/x86/coco/sev/core.c +2
-0+struct snp_guest_request_ioctl rio; +struct snp_tsc_info_resp tsc_resp;Ditto.
Ok, will allocate dynamically.
Quoted 13 lines
arch/x86/coco/sev/core.c int snp_send_guest_request(struct snp_msg_desc *mdesc, struct snp_guest_req *req · line 2970
Quoted 10 lines
Quoted 1 line
arch/x86/coco/sev/core.c +1
-0+struct snp_tsc_info_req *tsc_req;arch/x86/coco/sev/core.c +9
-0+struct snp_msg_desc *mdesc; +struct snp_guest_req req; +int rc; + +/* +* The intermediate response buffer is used while decrypting the +* response payload. Make sure that it has enough space to cover the +* authtag. +*/ Yes, this is how you do comments - you comment stuff which is non-obvious.
Quoted 16 lines
arch/x86/coco/sev/core.c int snp_send_guest_request(struct snp_msg_desc *mdesc, struct snp_guest_req *req · line 2983
Quoted 13 lines
arch/x86/coco/sev/core.c +13
-0+BUILD_BUG_ON (sizeof (buf) < (sizeof (tsc_resp) +AUTHTAG_LEN )); + + mdesc =snp_msg_alloc (); +if (IS_ERR_OR_NULL (mdesc)) +return -ENOMEM ; + + rc =snp_msg_init (mdesc, snp_vmpl); +if (rc) +return rc; + + tsc_req =kzalloc (sizeof (struct snp_tsc_info_req ),GFP_KERNEL ); +if (!tsc_req) +return -ENOMEM ;You return here and you leak mdesc. Where are those mdesc things even freed? I see
snp_msg_alloc()but not a "free" counterpart...
Right, will add snp_msg_free().
Quoted 14 lines
Quoted 14 lines
arch/x86/coco/sev/core.c +13
-0+memset (&req,0 ,sizeof (req)); +memset (&rio,0 ,sizeof (rio)); +memset (buf,0 ,sizeof (buf)); + + req.msg_version =MSG_HDR_VER ; + req.msg_type =SNP_MSG_TSC_INFO_REQ ; + req.vmpck_id = snp_vmpl; + req.req_buf = tsc_req; + req.req_sz =sizeof (*tsc_req); + req.resp_buf = buf; + req.resp_sz =sizeof (tsc_resp) +AUTHTAG_LEN ; + req.exit_code =SVM_VMGEXIT_GUEST_REQUEST ; +
Quoted 8 lines
arch/x86/coco/sev/core.c int snp_send_guest_request(struct snp_msg_desc *mdesc, struct snp_guest_req *req · line 3003
Quoted 6 lines
arch/x86/coco/sev/core.c +6
-0+ rc =snp_send_guest_request (mdesc, &req, &rio); +if (rc) + goto err_req; + +memcpy (&tsc_resp, buf,sizeof (tsc_resp)); + pr_debug("%s: response status %x scale %llx offset %llx factor %x\n",Prefix all hex values with "0x" so that it is unambiguous.
Sure.
Quoted 15 lines
arch/x86/coco/sev/core.c int snp_send_guest_request(struct snp_msg_desc *mdesc, struct snp_guest_req *req · line 3006
Quoted 4 lines
arch/x86/coco/sev/core.c +3
-0+ __func__, tsc_resp.status, tsc_resp.tsc_scale, tsc_resp.tsc_offset, + tsc_resp.tsc_factor); +if (!tsc_resp.status)
arch/x86/coco/sev/core.c int snp_send_guest_request(struct snp_msg_desc *mdesc, struct snp_guest_req *req · line 3011
Quoted 5 lines
arch/x86/coco/sev/core.c +5
-0+if (tsc_resp.status ==0 ) { + snp_tsc_scale = tsc_resp.tsc_scale; + snp_tsc_offset = tsc_resp.tsc_offset; + }else { +pr_err ("Failed to get TSC info, response status %x\n" , tsc_resp.status);Ox
Quoted 7 lines
arch/x86/coco/sev/core.c int snp_send_guest_request(struct snp_msg_desc *mdesc, struct snp_guest_req *req · line 3016
Quoted 5 lines
arch/x86/coco/sev/core.c +5
-0+ rc = -EIO ; + } + +err_req: +/* The response buffer contains the sensitive data, explicitly clear it. */ s/the //
Sure.
Quoted 31 lines
Quoted 24 lines
arch/x86/coco/sev/core.c +18
-0+memzero_explicit (buf,sizeof (buf)); +memzero_explicit (&tsc_resp,sizeof (tsc_resp)); + +return rc; +} + +void __init snp_secure_tsc_prepare (void ) +{ +if (!cc_platform_has (CC_ATTR_GUEST_SNP_SECURE_TSC )) +return ; + +if (snp_get_tsc_info ()) { +pr_alert ("Unable to retrieve Secure TSC info from ASP\n" ); +sev_es_terminate (SEV_TERM_SET_LINUX ,GHCB_TERM_SECURE_TSC ); + } + +pr_debug ("SecureTSC enabled" ); +}arch/x86/mm/mem_encrypt.c +0
-0arch/x86/mm/mem_encrypt.c void __init mem_encrypt_init(void) · line 97
Quoted 4 lines
arch/x86/mm/mem_encrypt.c +1
-0@@ -94,6 +94,10 @@ void __init mem_encrypt_init(void)/* Call into SWIOTLB to update the SWIOTLB DMA buffers */ swiotlb_update_mem_attributes (); +/* Initialize SNP Secure TSC */ Useless comment.
Quoted 5 lines
arch/x86/mm/mem_encrypt.c void __init mem_encrypt_init(void) · line 99
Quoted 2 lines
arch/x86/mm/mem_encrypt.c +2
-0+if (cc_platform_has (CC_ATTR_GUEST_SEV_SNP )) +snp_secure_tsc_prepare ();Why don't you call this one in the same if-condition in
mem_encrypt_setup_arch()?
kmalloc() does not work at this stage. Moreover, mem_encrypt_setup_arch() does not have CC_ATTR_GUEST_SEV_SNP check.
Regards
Nikunj
Re: [PATCH v14 03/13] x86/sev: Add Secure TSC support for SNP guests
Quoted 18 lines · Nikunj A. Dadhania
Quoted 17 lines · Borislav Petkov
arch/x86/coco/sev/core.c int snp_send_guest_request(struct snp_msg_desc *mdesc, struct snp_guest_req *req · line 2983
Quoted 13 lines · Nikunj A Dadhania
arch/x86/coco/sev/core.c +13
-0+BUILD_BUG_ON (sizeof (buf) < (sizeof (tsc_resp) +AUTHTAG_LEN )); + + mdesc =snp_msg_alloc (); +if (IS_ERR_OR_NULL (mdesc)) +return -ENOMEM ; + + rc =snp_msg_init (mdesc, snp_vmpl); +if (rc) +return rc; + + tsc_req =kzalloc (sizeof (struct snp_tsc_info_req ),GFP_KERNEL ); +if (!tsc_req) +return -ENOMEM ;You return here and you leak mdesc.
mdesc is allocated only once in snp_msg_alloc() and is stored in static variable snp_mdesc, subsequent snp_msg_alloc() calls from the sev-guest driver will return snp_mdesc.
Quoted 1 line
Quoted 1 line
Where are those mdesc things even freed?
snp_mdesc is initialized once and is not freed.
Quoted 1 line
Quoted 1 line
I see
snp_msg_alloc()but not a "free" counterpart...
That was the reason I had not implemented "free" counterpart.
Regards
Nikunj
Borislav Petkov
maintainerRe: [PATCH v14 03/13] x86/sev: Add Secure TSC support for SNP guests
Quoted 1 line · Nikunj A. Dadhania
That was the reason I had not implemented "free" counterpart.
Then let's simplify this too because it is kinda silly right now:
---
arch/x86/coco/sev/core.c +4 -12
@@ -96,7 +96,7 @@ static u64 sev_hv_features __ro_after_init;/* Secrets page physical address from the CC blob */ static u64 secrets_pa__ro_after_init ; -static struct snp_msg_desc *snp_mdesc; +static struct snp_msg_desc snp_mdesc;/* Secure TSC values read using TSC_INFO SNP Guest request */ static u64 snp_tsc_scale__ro_after_init ;
@@ -2749,19 +2749,13 @@ EXPORT_SYMBOL_GPL(snp_msg_init);struct snp_msg_desc *snp_msg_alloc (void ) { -struct snp_msg_desc *mdesc; +struct snp_msg_desc *mdesc = &snp_mdesc;BUILD_BUG_ON (sizeof (struct snp_guest_msg ) >PAGE_SIZE ); -if (snp_mdesc) -return snp_mdesc; - - mdesc =kzalloc (sizeof (struct snp_msg_desc ),GFP_KERNEL ); -if (!mdesc) -return ERR_PTR (-ENOMEM ); +memset (mdesc,0 ,sizeof (struct snp_msg_desc )); - mdesc->secrets = (__force struct snp_secrets_page *)ioremap_encrypted (secrets_pa, -PAGE_SIZE ); + mdesc->secrets = (__force struct snp_secrets_page *)ioremap_encrypted (secrets_pa,PAGE_SIZE );if (!mdesc->secrets)return ERR_PTR (-ENODEV );
@@ -2783,8 +2777,6 @@ struct snp_msg_desc *snp_msg_alloc(void) mdesc->input.resp_gpa =__pa (mdesc->response); mdesc->input.data_gpa =__pa (mdesc->certs_data); - snp_mdesc = mdesc; -return mdesc; e_free_response:
Signature · 4 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquetteRe: [PATCH v14 03/13] x86/sev: Add Secure TSC support for SNP guests
Quoted 4 lines · Borislav Petkov
Quoted 1 line · Nikunj A. Dadhania
That was the reason I had not implemented "free" counterpart.
Then let's simplify this too because it is kinda silly right now:
When snp_msg_alloc() is called by the sev-guest driver, secrets will be reinitialized and buffers will be re-allocated, leaking memory allocated during snp_get_tsc_info()::snp_msg_alloc().
As you suggested, implementing a "free" counterpart will be better.
arch/x86/include/asm/sev.h +2 -9
@@ -488,14 +488,7 @@ static inline bool snp_is_vmpck_empty(struct snp_msg_desc *mdesc)int snp_msg_init (struct snp_msg_desc *mdesc,int vmpck_id);struct snp_msg_desc *snp_msg_alloc (void ); - -static inline void snp_msg_cleanup (struct snp_msg_desc *mdesc) -{ - mdesc->vmpck =NULL ; - mdesc->os_area_msg_seqno =NULL ; -kfree (mdesc->ctx); -} - +void snp_msg_free (struct snp_msg_desc *mdesc);int snp_send_guest_request (struct snp_msg_desc *mdesc,struct snp_guest_req *req,struct snp_guest_request_ioctl *rio);
@@ -541,7 +534,7 @@ static inline void snp_kexec_begin(void) { }static inline bool snp_is_vmpck_empty (struct snp_msg_desc *mdesc) {return false; }static inline int snp_msg_init (struct snp_msg_desc *mdesc,int vmpck_id) {return -1 ; }static inline struct snp_msg_desc *snp_msg_alloc (void ) {return NULL ; } -static inline void snp_msg_cleanup (struct snp_msg_desc *mdesc) { } +static inline void snp_msg_free (struct snp_msg_desc *mdesc) { }static inline int snp_send_guest_request (struct snp_msg_desc *mdesc,struct snp_guest_req *req,struct snp_guest_request_ioctl *rio) {return -ENODEV ; }static inline void __init snp_secure_tsc_prepare (void ) { }
arch/x86/coco/sev/core.c +27 -11
@@ -96,8 +96,6 @@ static u64 sev_hv_features __ro_after_init;/* Secrets page physical address from the CC blob */ static u64 secrets_pa__ro_after_init ; -static struct snp_msg_desc *snp_mdesc; -/* Secure TSC values read using TSC_INFO SNP Guest request */ static u64 snp_tsc_scale__ro_after_init ;static u64 snp_tsc_offset__ro_after_init ;
@@ -2818,9 +2816,6 @@ struct snp_msg_desc *snp_msg_alloc(void)BUILD_BUG_ON (sizeof (struct snp_guest_msg ) >PAGE_SIZE ); -if (snp_mdesc) -return snp_mdesc; - mdesc =kzalloc (sizeof (struct snp_msg_desc ),GFP_KERNEL );if (!mdesc)return ERR_PTR (-ENOMEM );
@@ -2848,8 +2843,6 @@ struct snp_msg_desc *snp_msg_alloc(void) mdesc->input.resp_gpa =__pa (mdesc->response); mdesc->input.data_gpa =__pa (mdesc->certs_data); - snp_mdesc = mdesc; -return mdesc; e_free_response:
@@ -2858,11 +2851,29 @@ struct snp_msg_desc *snp_msg_alloc(void)free_shared_pages (mdesc->request,sizeof (struct snp_guest_msg )); e_unmap:iounmap ((__force void __iomem *)mdesc->secrets); +kfree (mdesc);return ERR_PTR (-ENOMEM ); }EXPORT_SYMBOL_GPL (snp_msg_alloc); +void snp_msg_free (struct snp_msg_desc *mdesc) +{ +if (!mdesc) +return ; + + mdesc->vmpck =NULL ; + mdesc->os_area_msg_seqno =NULL ; +kfree (mdesc->ctx); + +free_shared_pages (mdesc->response,sizeof (struct snp_guest_msg )); +free_shared_pages (mdesc->request,sizeof (struct snp_guest_msg )); +iounmap ((__force void __iomem *)mdesc->secrets); + +kfree (mdesc); +} +EXPORT_SYMBOL_GPL (snp_msg_free); +/* Mutex to serialize the shared buffer access and command handling. */ static DEFINE_MUTEX (snp_cmd_mutex);
@@ -3179,8 +3190,10 @@ static int __init snp_get_tsc_info(void)return rc; tsc_req =kzalloc (sizeof (struct snp_tsc_info_req ),GFP_KERNEL ); -if (!tsc_req) -return -ENOMEM ; +if (!tsc_req) { + rc = -ENOMEM ; + goto e_free_mdesc; + }memset (&req,0 ,sizeof (req));memset (&rio,0 ,sizeof (rio));
@@ -3197,7 +3210,7 @@ static int __init snp_get_tsc_info(void) rc =snp_send_guest_request (mdesc, &req, &rio);if (rc) - goto err_req; + goto e_request;memcpy (&tsc_resp, buf,sizeof (tsc_resp)); pr_debug("%s: response status %x scale %llx offset %llx factor %x\n",
@@ -3212,11 +3225,14 @@ static int __init snp_get_tsc_info(void) rc = -EIO ; } -err_req: +e_request:/* The response buffer contains the sensitive data, explicitly clear it. */ memzero_explicit (buf,sizeof (buf));memzero_explicit (&tsc_resp,sizeof (tsc_resp)); +e_free_mdesc: +snp_msg_free (mdesc); +return rc; }
drivers/virt/coco/sev-guest/sev-guest.c +2 -2
@@ -647,7 +647,7 @@ static int __init sev_guest_probe(struct platform_device *pdev)return 0 ; e_msg_init: -snp_msg_cleanup (mdesc); +snp_msg_free (mdesc);return ret; }
@@ -656,7 +656,7 @@ static void __exit sev_guest_remove(struct platform_device *pdev) {struct snp_guest_dev *snp_dev =platform_get_drvdata (pdev); -snp_msg_cleanup (snp_dev->msg_desc); +snp_msg_free (snp_dev->msg_desc);misc_deregister (&snp_dev->misc); }
Borislav Petkov
maintainerRe: [PATCH v14 03/13] x86/sev: Add Secure TSC support for SNP guests
Quoted 3 lines · Nikunj A. Dadhania
When
snp_msg_alloc()is called by the sev-guest driver, secrets will be reinitialized and buffers will be re-allocated, leaking memory allocated during snp_get_tsc_info()::snp_msg_alloc().
Huh?
How do you leak memory when you clear all buffers before that?!?
Signature · 4 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquetteRe: [PATCH v14 03/13] x86/sev: Add Secure TSC support for SNP guests
Quoted 8 lines · Borislav Petkov
Quoted 3 lines · Nikunj A. Dadhania
When
snp_msg_alloc()is called by the sev-guest driver, secrets will be reinitialized and buffers will be re-allocated, leaking memory allocated during snp_get_tsc_info()::snp_msg_alloc().Huh?
How do you leak memory when you clear all buffers before that?!?
Memory allocated for the request, response and certs_data is not freed and we will clear the mdesc when sev-guest driver calls snp_msg_alloc().
Let me try again to explain what I mean:
snp_msg_alloc() will be called by snp_get_tsc_info() and later by sev-guest driver.
snp_prepare_tsc()
->snp_get_tsc_info()
->snp_msg_alloc()
-> clears mdesc
->ioremaps secrets_pa
->request = alloc_shared_pages()
-> alloc_pages()
->response = alloc_shared_pages()
-> alloc_pages()
->certs_data = alloc_shared_pages()
-> alloc_pages()sev-guest driversev_guest_probe()
->snp_msg_alloc()
->clears mdesc
->ioremaps secrets_pa
->request = alloc_shared_pages()
-> alloc_pages()
->response = alloc_shared_pages()
-> alloc_pages()
->certs_data = alloc_shared_pages()
-> alloc_pages()request, response and certs_data are re-allocated. Am I missing something ?
Regards
Nikunj
Borislav Petkov
maintainerRe: [PATCH v14 03/13] x86/sev: Add Secure TSC support for SNP guests
Quoted 3 lines · Nikunj A. Dadhania
Memory allocated for the request, response and
certs_datais not freed and we will clear the mdesc when sev-guest driver callssnp_msg_alloc().
Ah, right.
Yeah, this was a weird scheme anyway - a static pointer mdesc but then the things it points to get dynamically allocated. So yeah, a full dynamic allocation makes it a much more normal pattern.
Thx.
Signature · 4 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquetteRe: [PATCH v14 03/13] x86/sev: Add Secure TSC support for SNP guests
Quoted 10 lines · Borislav Petkov
Quoted 3 lines · Nikunj A. Dadhania
Memory allocated for the request, response and
certs_datais not freed and we will clear the mdesc when sev-guest driver callssnp_msg_alloc().Ah, right.
Yeah, this was a weird scheme anyway - a static pointer mdesc but then the things it points to get dynamically allocated. So yeah, a full dynamic allocation makes it a much more normal pattern.
I have pushed the updated tree here: https://github.com/AMDESE/linux-kvm/commits/sectsc-guest-wip/
Will wait for your comments on rest of the patches before I post the next version.
Regards
Nikunj
Borislav Petkov
maintainerRe: [PATCH v14 03/13] x86/sev: Add Secure TSC support for SNP guests
In reply to Nikunj A. DadhaniaQuoted 2 lines · Nikunj A. Dadhania
kmalloc()does not work at this stage. Moreover,mem_encrypt_setup_arch()does not haveCC_ATTR_GUEST_SEV_SNPcheck.
Bah, let's simplify it then:
arch/x86/mm/mem_encrypt.c +1 -3
@@ -94,9 +94,7 @@ void __init mem_encrypt_init(void)/* Call into SWIOTLB to update the SWIOTLB DMA buffers */ swiotlb_update_mem_attributes (); -/* Initialize SNP Secure TSC */ -if (cc_platform_has (CC_ATTR_GUEST_SEV_SNP )) -snp_secure_tsc_prepare (); +snp_secure_tsc_prepare ();print_mem_encrypt_feature_info (); }
Signature · 4 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquettePATCH v14 4/13 x86/sev: Change TSC MSR behavior for Secure TSC enabled guests
In reply to Nikunj A DadhaniaSecure TSC enabled guests should not write to MSR_IA32_TSC(10H) register as the subsequent TSC value reads are undefined. For AMD platform, MSR_IA32_TSC is intercepted by the hypervisor, MSR_IA32_TSC read/write accesses should not exit to the hypervisor for such guests.
Accesses to MSR_IA32_TSC needs special handling in the #VC handler for the guests with Secure TSC enabled. Writes to MSR_IA32_TSC should be ignored, and reads of MSR_IA32_TSC should return the result of the RDTSC instruction.
--- arch/x86/coco/sev/core.c | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+)
arch/x86/coco/sev/core.c +24 -0
@@ -1308,6 +1308,30 @@ static enum es_result vc_handle_msr(struct ghcb *ghcb, struct es_em_ctxt *ctxt)return ES_OK ; } +/* +* TSC related accesses should not exit to the hypervisor when a +* guest is executing with SecureTSC enabled, so special handling +* is required for accesses of MSR_IA32_TSC: +* +* Writes: Writing to MSR_IA32_TSC can cause subsequent reads +* of the TSC to return undefined values, so ignore all +* writes. +* Reads: Reads of MSR_IA32_TSC should return the current TSC +* value, use the value returned by RDTSC. +*/ +if (regs->cx ==MSR_IA32_TSC && (sev_status &MSR_AMD64_SNP_SECURE_TSC )) { +u64 tsc; + +if (exit_info_1) +return ES_OK ; + + tsc =rdtsc (); + regs->ax =UINT_MAX & tsc; + regs->dx =UINT_MAX & (tsc >>32 ); + +return ES_OK ; + } +ghcb_set_rcx (ghcb, regs->cx);if (exit_info_1) {ghcb_set_rax (ghcb, regs->ax);
Signature · 1 line
2.34.1
Borislav Petkov
maintainerRe: [PATCH v14 04/13] x86/sev: Change TSC MSR behavior for Secure TSC enabled guests
Quoted 8 lines · Nikunj A Dadhania
arch/x86/coco/sev/core.c +8
-0+/* +* TSC related accesses should not exit to the hypervisor when a +* guest is executing with SecureTSC enabled, so special handling +* is required for accesses of MSR_IA32_TSC: +* +* Writes: Writing to MSR_IA32_TSC can cause subsequent reads +* of the TSC to return undefined values, so ignore all +* writes.
arch/x86/coco/sev/core.c static enum es_result vc_handle_msr(struct ghcb *ghcb, struct es_em_ctxt *ctxt) · line 1328
Quoted 10 lines
arch/x86/coco/sev/core.c +10
-0+* Reads: Reads of MSR_IA32_TSC should return the current TSC +* value, use the value returned by RDTSC. +*/ +if (regs->cx ==MSR_IA32_TSC && (sev_status &MSR_AMD64_SNP_SECURE_TSC )) { +u64 tsc; + +if (exit_info_1) +return ES_OK ; + + tsc =rdtsc ();
rdtsc_ordered() I guess.
arch/x86/coco/sev/core.c static enum es_result vc_handle_msr(struct ghcb *ghcb, struct es_em_ctxt *ctxt) · line 1334
Quoted 6 lines
arch/x86/coco/sev/core.c +6
-0+ regs->ax =UINT_MAX & tsc; + regs->dx =UINT_MAX & (tsc >>32 ); + +return ES_OK ; + } +
All that you're adding - put that in a __vc_handle_msr_tsc() helper so that it doesn't distract from the function's flow.
Thx.
Signature · 4 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquetteRe: [PATCH v14 04/13] x86/sev: Change TSC MSR behavior for Secure TSC enabled guests
Quoted 13 lines · Borislav Petkov
Quoted 12 lines · Nikunj A Dadhania
arch/x86/coco/sev/core.c +12
-0+/* +* TSC related accesses should not exit to the hypervisor when a +* guest is executing with SecureTSC enabled, so special handling +* is required for accesses of MSR_IA32_TSC: +* +* Writes: Writing to MSR_IA32_TSC can cause subsequent reads +* of the TSC to return undefined values, so ignore all +* writes. +* Reads: Reads of MSR_IA32_TSC should return the current TSC +* value, use the value returned by RDTSC. +*/ +if (regs->cx ==MSR_IA32_TSC && (sev_status &MSR_AMD64_SNP_SECURE_TSC )) {
Quoted 8 lines
arch/x86/coco/sev/core.c static enum es_result vc_handle_msr(struct ghcb *ghcb, struct es_em_ctxt *ctxt) · line 1328
Quoted 6 lines
arch/x86/coco/sev/core.c +6
-0+u64 tsc; + +if (exit_info_1) +return ES_OK ; + + tsc =rdtsc ();
rdtsc_ordered()I guess.
Yes, will update.
Quoted 10 lines
arch/x86/coco/sev/core.c static enum es_result vc_handle_msr(struct ghcb *ghcb, struct es_em_ctxt *ctxt) · line 1334
Quoted 7 lines
arch/x86/coco/sev/core.c +6
-0+ regs->ax =UINT_MAX & tsc; + regs->dx =UINT_MAX & (tsc >>32 ); + +return ES_OK ; + } +All that you're adding - put that in a
__vc_handle_msr_tsc()helper so that it doesn't distract from the function's flow.
Sure, I noticed your patch adding __vc_handle_msr_caa().
Regards
Nikunj
PATCH v14 5/13 x86/sev: Prevent RDTSC/RDTSCP interception for Secure TSC enabled guests
In reply to Nikunj A DadhaniaThe hypervisor should not be intercepting RDTSC/RDTSCP when Secure TSC is enabled. A #VC exception will be generated if the RDTSC/RDTSCP instructions are being intercepted. If this should occur and Secure TSC is enabled, guest execution should be terminated as the guest cannot rely on the TSC value provided by the hypervisor.
--- arch/x86/coco/sev/shared.c | 10 ++++++++++ 1 file changed, 10 insertions(+)
arch/x86/coco/sev/shared.c +10 -0
@@ -1140,6 +1140,16 @@ static enum es_result vc_handle_rdtsc(struct ghcb *ghcb,bool rdtscp = (exit_code ==SVM_EXIT_RDTSCP );enum es_result ret; +/* +* RDTSC and RDTSCP should not be intercepted when Secure TSC is +* enabled. Terminate the SNP guest when the interception is enabled. +* This file is included from kernel/sev.c and boot/compressed/sev.c, +* use sev_status here as cc_platform_has() is not available when +* compiling boot/compressed/sev.c. +*/ +if (sev_status &MSR_AMD64_SNP_SECURE_TSC ) +return ES_VMM_ERROR ; + ret =sev_es_ghcb_hv_call (ghcb, ctxt, exit_code,0 ,0 );if (ret !=ES_OK )return ret;
Signature · 1 line
2.34.1
Borislav Petkov
maintainerRe: [PATCH v14 05/13] x86/sev: Prevent RDTSC/RDTSCP interception for Secure TSC enabled guests
Quoted 5 lines · Nikunj A Dadhania
The hypervisor should not be intercepting RDTSC/RDTSCP when Secure TSC is enabled. A #VC exception will be generated if the RDTSC/RDTSCP instructions are being intercepted. If this should occur and Secure TSC is enabled, guest execution should be terminated as the guest cannot rely on the TSC value provided by the hypervisor.
This should be in the comment below.
Quoted 31 lines
Signed-off-by Nikunj A Dadhania <[email protected]>Tested-by Peter Gonda <[email protected]>Reviewed-by Tom Lendacky <[email protected]>--- arch/x86/coco/sev/shared.c | 10 ++++++++++ 1 file changed, 10 insertions(+)arch/x86/coco/sev/shared.c +10
-0@@ -1140,6 +1140,16 @@ static enum es_result vc_handle_rdtsc(struct ghcb *ghcb,bool rdtscp = (exit_code ==SVM_EXIT_RDTSCP );enum es_result ret; +/* +* RDTSC and RDTSCP should not be intercepted when Secure TSC is +* enabled. Terminate the SNP guest when the interception is enabled. +* This file is included from kernel/sev.c and boot/compressed/sev.c, +* use sev_status here as cc_platform_has() is not available when +* compiling boot/compressed/sev.c. +*/ +if (sev_status &MSR_AMD64_SNP_SECURE_TSC ) +return ES_VMM_ERROR ; + ret =sev_es_ghcb_hv_call (ghcb, ctxt, exit_code,0 ,0 );if (ret !=ES_OK )return ret;Signature · 1 line
2.34.1
Signature · 4 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquetteRe: [PATCH v14 05/13] x86/sev: Prevent RDTSC/RDTSCP interception for Secure TSC enabled guests
Quoted 8 lines · Borislav Petkov
Quoted 5 lines · Nikunj A Dadhania
The hypervisor should not be intercepting RDTSC/RDTSCP when Secure TSC is enabled. A #VC exception will be generated if the RDTSC/RDTSCP instructions are being intercepted. If this should occur and Secure TSC is enabled, guest execution should be terminated as the guest cannot rely on the TSC value provided by the hypervisor.
This should be in the comment below.
Same message in commit and the code comment ?
Quoted 33 lines
Quoted 32 lines
Signed-off-by Nikunj A Dadhania <[email protected]>Tested-by Peter Gonda <[email protected]>Reviewed-by Tom Lendacky <[email protected]>--- arch/x86/coco/sev/shared.c | 10 ++++++++++ 1 file changed, 10 insertions(+)arch/x86/coco/sev/shared.c +10
-0@@ -1140,6 +1140,16 @@ static enum es_result vc_handle_rdtsc(struct ghcb *ghcb,bool rdtscp = (exit_code ==SVM_EXIT_RDTSCP );enum es_result ret; +/* +* RDTSC and RDTSCP should not be intercepted when Secure TSC is +* enabled. Terminate the SNP guest when the interception is enabled. +* This file is included from kernel/sev.c and boot/compressed/sev.c, +* use sev_status here as cc_platform_has() is not available when +* compiling boot/compressed/sev.c. +*/ +if (sev_status &MSR_AMD64_SNP_SECURE_TSC ) +return ES_VMM_ERROR ; + ret =sev_es_ghcb_hv_call (ghcb, ctxt, exit_code,0 ,0 );if (ret !=ES_OK )return ret;Signature · 1 line
2.34.1
Borislav Petkov
maintainerRe: [PATCH v14 05/13] x86/sev: Prevent RDTSC/RDTSCP interception for Secure TSC enabled guests
Quoted 1 line · Nikunj A. Dadhania
Same message in commit and the code comment ?
Yes, the explanation in the commit message is more detailed than in the comment below. And if you have to put it in a comment, then it is preferrable the comment contains the more detailed variant because the comment is a lot easier to find than some commit message in git history...
Signature · 4 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquettePATCH v14 6/13 x86/sev: Prevent GUEST_TSC_FREQ MSR interception for Secure TSC enabled guests
In reply to Nikunj A DadhaniaThe hypervisor should not be intercepting GUEST_TSC_FREQ MSR(0xcOO10134) when Secure TSC is enabled. A #VC exception will be generated if the GUEST_TSC_FREQ MSR is being intercepted. If this should occur and SecureTSC is enabled, terminate guest execution.
--- arch/x86/include/asm/msr-index.h | 1 + arch/x86/coco/sev/core.c | 8 ++++++++ 2 files changed, 9 insertions(+)
arch/x86/include/asm/msr-index.h +1 -0
@@ -608,6 +608,7 @@#define MSR_AMD_PERF_CTL 0xc0010062#define MSR_AMD_PERF_STATUS 0xc0010063#define MSR_AMD_PSTATE_DEF_BASE 0xc0010064 +#define MSR_AMD64_GUEST_TSC_FREQ 0xc0010134#define MSR_AMD64_OSVW_ID_LENGTH 0xc0010140#define MSR_AMD64_OSVW_STATUS 0xc0010141#define MSR_AMD_PPIN_CTL 0xc00102f0
arch/x86/coco/sev/core.c +8 -0
@@ -1332,6 +1332,14 @@ static enum es_result vc_handle_msr(struct ghcb *ghcb, struct es_em_ctxt *ctxt)return ES_OK ; } +/* +* GUEST_TSC_FREQ should not be intercepted when Secure TSC is +* enabled. Terminate the SNP guest when the interception is enabled. +*/ +if (regs->cx ==MSR_AMD64_GUEST_TSC_FREQ && (sev_status &MSR_AMD64_SNP_SECURE_TSC )) +return ES_VMM_ERROR ; + +ghcb_set_rcx (ghcb, regs->cx);if (exit_info_1) {ghcb_set_rax (ghcb, regs->ax);
Signature · 1 line
2.34.1
PATCH v14 7/13 x86/sev: Mark Secure TSC as reliable clocksource
In reply to Nikunj A DadhaniaIn SNP guest environment with Secure TSC enabled, unlike other clock sources (such as HPET, ACPI timer, APIC, etc.), the RDTSC instruction is handled without causing a VM exit, resulting in minimal overhead and jitters. Hence, mark Secure TSC as the only reliable clock source, bypassing unstable calibration.
--- arch/x86/mm/mem_encrypt_amd.c | 4 ++++ 1 file changed, 4 insertions(+)
arch/x86/mm/mem_encrypt_amd.c +4 -0
@@ -516,6 +516,10 @@ void __init sme_early_init(void)* kernel mapped. */ snp_update_svsm_ca (); + +/* Mark the TSC as reliable when Secure TSC is enabled */ +if (sev_status &MSR_AMD64_SNP_SECURE_TSC ) +setup_force_cpu_cap (X86_FEATURE_TSC_RELIABLE ); }void __init mem_encrypt_free_decrypted_mem (void )
Signature · 1 line
2.34.1
PATCH v14 8/13 x86/cpu/amd: Do not print FW_BUG for Secure TSC
In reply to Nikunj A DadhaniaWhen Secure TSC is enabled and TscInvariant (bit 8) in CPUID_8000_0007_edx is set, the kernel complains with the below firmware bug:
[Firmware Bug]: TSC doesn't count with P0 frequency!
Secure TSC does not need to run at P0 frequency; the TSC frequency is set by the VMM as part of the SNP_LAUNCH_START command. Skip this check when Secure TSC is enabled
--- arch/x86/kernel/cpu/amd.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
arch/x86/kernel/cpu/amd.c +2 -1
@@ -370,7 +370,8 @@ static void bsp_determine_snp(struct cpuinfo_x86 *c)static void bsp_init_amd (struct cpuinfo_x86 *c) { -if (cpu_has (c,X86_FEATURE_CONSTANT_TSC )) { +if (cpu_has (c,X86_FEATURE_CONSTANT_TSC ) && + !cc_platform_has (CC_ATTR_GUEST_SNP_SECURE_TSC )) {if (c->x86 >0x10 || (c->x86 ==0x10 && c->x86_model >=0x2 )) {
Signature · 1 line
2.34.1
PATCH v14 9/13 tsc: Use the GUEST_TSC_FREQ MSR for discovering TSC frequency
In reply to Nikunj A DadhaniaCalibrating the TSC frequency using the kvmclock is not correct for SecureTSC enabled guests. Use the platform provided TSC frequency via the GUEST_TSC_FREQ MSR (C001_0134h).
--- arch/x86/include/asm/sev.h | 2 ++ arch/x86/coco/sev/core.c | 16 ++++++++++++++++ arch/x86/kernel/tsc.c | 5 +++++ 3 files changed, 23 insertions(+)
arch/x86/include/asm/sev.h +2 -0
@@ -536,6 +536,7 @@ static inline int handle_guest_request(struct snp_msg_desc *mdesc, u64 exit_code }void __init snp_secure_tsc_prepare (void ); +void __init snp_secure_tsc_init (void );#else /* !CONFIG_AMD_MEM_ENCRYPT */
@@ -584,6 +585,7 @@ static inline int handle_guest_request(struct snp_msg_desc *mdesc, u64 exit_code u32 resp_sz) { return -ENODEV; }static inline void __init snp_secure_tsc_prepare (void ) { } +static inline void __init snp_secure_tsc_init (void ) { }#endif /* CONFIG_AMD_MEM_ENCRYPT */
arch/x86/coco/sev/core.c +16 -0
@@ -3064,3 +3064,19 @@ void __init snp_secure_tsc_prepare(void)pr_debug ("SecureTSC enabled" ); } + +static unsigned long securetsc_get_tsc_khz (void ) +{ +unsigned long long tsc_freq_mhz; + +setup_force_cpu_cap (X86_FEATURE_TSC_KNOWN_FREQ ); +rdmsrl (MSR_AMD64_GUEST_TSC_FREQ , tsc_freq_mhz); + +return (unsigned long )(tsc_freq_mhz *1000 ); +} + +void __init snp_secure_tsc_init (void ) +{ + x86_platform.calibrate_cpu = securetsc_get_tsc_khz; + x86_platform.calibrate_tsc = securetsc_get_tsc_khz; +}
arch/x86/kernel/tsc.c +5 -0
@@ -30,6 +30,7 @@#include <asm/i8259.h> #include <asm/topology.h> #include <asm/uv/uv.h> +#include <asm/sev.h> unsigned int __read_mostly cpu_khz;/* TSC clocks / usec, not used here */ EXPORT_SYMBOL (cpu_khz);
@@ -1514,6 +1515,10 @@ void __init tsc_early_init(void)/* Don't change UV TSC multi-chassis synchronization */ if (is_early_uv_system ())return ; + +if (cc_platform_has (CC_ATTR_GUEST_SNP_SECURE_TSC )) +snp_secure_tsc_init (); +if (!determine_cpu_tsc_frequencies (true))return ;tsc_enable_sched_clock ();
Signature · 1 line
2.34.1
Re: [PATCH v14 09/13] tsc: Use the GUEST_TSC_FREQ MSR for discovering TSC frequency
Quoted 68 lines · Nikunj A Dadhania
Calibrating the TSC frequency using the kvmclock is not correct for SecureTSC enabled guests. Use the platform provided TSC frequency via the
GUEST_TSC_FREQMSR (C001_0134h).Signed-off-by Nikunj A Dadhania <[email protected]>--- arch/x86/include/asm/sev.h | 2 ++ arch/x86/coco/sev/core.c | 16 ++++++++++++++++ arch/x86/kernel/tsc.c | 5 +++++ 3 files changed, 23 insertions(+)arch/x86/include/asm/sev.h +2
-0@@ -536,6 +536,7 @@ static inline int handle_guest_request(struct snp_msg_desc *mdesc, u64 exit_code }void __init snp_secure_tsc_prepare (void ); +void __init snp_secure_tsc_init (void );#else /* !CONFIG_AMD_MEM_ENCRYPT */ @@ -584,6 +585,7 @@ static inline int handle_guest_request(struct snp_msg_desc *mdesc, u64 exit_code u32 resp_sz) { return -ENODEV; }static inline void __init snp_secure_tsc_prepare (void ) { } +static inline void __init snp_secure_tsc_init (void ) { }#endif /* CONFIG_AMD_MEM_ENCRYPT */ arch/x86/coco/sev/core.c +16
-0@@ -3064,3 +3064,19 @@ void __init snp_secure_tsc_prepare(void)pr_debug ("SecureTSC enabled" ); } + +static unsigned long securetsc_get_tsc_khz (void ) +{ +unsigned long long tsc_freq_mhz; + +setup_force_cpu_cap (X86_FEATURE_TSC_KNOWN_FREQ ); +rdmsrl (MSR_AMD64_GUEST_TSC_FREQ , tsc_freq_mhz); + +return (unsigned long )(tsc_freq_mhz *1000 ); +} + +void __init snp_secure_tsc_init (void ) +{ + x86_platform.calibrate_cpu = securetsc_get_tsc_khz; + x86_platform.calibrate_tsc = securetsc_get_tsc_khz; +}arch/x86/kernel/tsc.c +1
-0@@ -30,6 +30,7 @@#include <asm/i8259.h> #include <asm/topology.h> #include <asm/uv/uv.h> +#include <asm/sev.h> unsigned int __read_mostly cpu_khz;/* TSC clocks / usec, not used here */ EXPORT_SYMBOL (cpu_khz);
arch/x86/kernel/tsc.c void __init tsc_early_init(void) · line 1520
Quoted 6 lines
arch/x86/kernel/tsc.c +3
-0@@ -1514,6 +1515,10 @@ void __init tsc_early_init(void)/* Don't change UV TSC multi-chassis synchronization */ if (is_early_uv_system ())return ; + +if (cc_platform_has (CC_ATTR_GUEST_SNP_SECURE_TSC )) +snp_secure_tsc_init ();
IMHO, it isn't the good place to call snp_secure_tsc_init() to update the callbacks here.
It's better to be called in some snp init functions.
Quoted 3 lines
arch/x86/kernel/tsc.c +0
-0if (!determine_cpu_tsc_frequencies (true))return ;tsc_enable_sched_clock ();
Re: [PATCH v14 09/13] tsc: Use the GUEST_TSC_FREQ MSR for discovering TSC frequency
Quoted 70 lines · Xiaoyao Li
Quoted 60 lines · Nikunj A Dadhania
Calibrating the TSC frequency using the kvmclock is not correct for SecureTSC enabled guests. Use the platform provided TSC frequency via the
GUEST_TSC_FREQMSR (C001_0134h).Signed-off-by Nikunj A Dadhania <[email protected]>---
arch/x86/include/asm/sev.h| 2 ++ arch/x86/coco/sev/core.c | 16 ++++++++++++++++ arch/x86/kernel/tsc.c | 5 +++++3 files changed, 23 insertions(+)arch/x86/include/asm/sev.h +1
-0@@ -536,6 +536,7 @@ static inline int handle_guest_request(struct snp_msg_desc *mdesc, u64 exit_code } void __init snp_secure_tsc_prepare(void); +void __init snp_secure_tsc_init (void ); #else /* !CONFIG_AMD_MEM_ENCRYPT */@@ -584,6 +585,7 @@ static inline int
handle_guest_request(struct snp_msg_desc *mdesc, u64 exit_code u32 resp_sz){ return-ENODEV; }
static inline void__initsnp_secure_tsc_prepare(void){ }
+static inline void__initsnp_secure_tsc_init(void){ }
#endif /*CONFIG_AMD_MEM_ENCRYPT*/
diff --gita/arch/x86/coco/sev/core.cb/arch/x86/coco/sev/core.c
index140759fafe0c..0be9496b8dea100644arch/x86/coco/sev/core.c +16
-0@@ -3064,3 +3064,19 @@ void __init snp_secure_tsc_prepare(void) pr_debug("SecureTSC enabled"); } + +static unsigned long securetsc_get_tsc_khz (void ) +{ + unsigned long long tsc_freq_mhz; + + setup_force_cpu_cap(X86_FEATURE_TSC_KNOWN_FREQ); + rdmsrl(MSR_AMD64_GUEST_TSC_FREQ, tsc_freq_mhz); + + return (unsigned long)(tsc_freq_mhz * 1000); +} + +void __init snp_secure_tsc_init (void ) +{ + x86_platform.calibrate_cpu = securetsc_get_tsc_khz; + x86_platform.calibrate_tsc = securetsc_get_tsc_khz; +}arch/x86/kernel/tsc.c +1
-0@@ -30,6 +30,7 @@ #include <asm/i8259.h> #include <asm/topology.h> #include <asm/uv/uv.h> +#include <asm/sev.h> unsigned int
__read_mostlycpu_khz; /* TSC clocks / usec, not used here */EXPORT_SYMBOL(cpu_khz);arch/x86/kernel/tsc.c void __init tsc_early_init(void) · line 1520
Quoted 6 lines
arch/x86/kernel/tsc.c +3
-0@@ -1514,6 +1515,10 @@ void __init tsc_early_init(void) /* Don't change UV TSC multi-chassis synchronization */ if (is_early_uv_system()) return; + + if (cc_platform_has(CC_ATTR_GUEST_SNP_SECURE_TSC)) + snp_secure_tsc_init();IMHO, it isn't the good place to call
snp_secure_tsc_init()to update the callbacks here.
Quoted 1 line
It's better to be called in some snp init functions.
As part of setup_arch(), init_hypervisor_platform() gets called and all the PV clocks are registered and initialized as part of init_platform callback. Once the hypervisor platform is initialized, tsc_early_init() is called. SEV SNP guest can be running on any hypervisor, so the call back needs to be updated either in tsc_early_init() or init_hypervisor_platform(), as the change is TSC related, I have updated it here.
Quoted 5 lines
arch/x86/kernel/tsc.c void __init tsc_early_init(void) · line 1524
Quoted 4 lines
arch/x86/kernel/tsc.c +0
-0if (!determine_cpu_tsc_frequencies(true)) return; tsc_enable_sched_clock();
Regards,
Nikunj
Re: [PATCH v14 09/13] tsc: Use the GUEST_TSC_FREQ MSR for discovering TSC frequency
Quoted 73 lines · Nikunj A. Dadhania
Quoted 70 lines · Xiaoyao Li
Quoted 60 lines · Nikunj A Dadhania
Calibrating the TSC frequency using the kvmclock is not correct for SecureTSC enabled guests. Use the platform provided TSC frequency via the
GUEST_TSC_FREQMSR (C001_0134h).Signed-off-by Nikunj A Dadhania <[email protected]>--- arch/x86/include/asm/sev.h | 2 ++ arch/x86/coco/sev/core.c | 16 ++++++++++++++++ arch/x86/kernel/tsc.c | 5 +++++ 3 files changed, 23 insertions(+)arch/x86/include/asm/sev.h +2
-0@@ -536,6 +536,7 @@ static inline int handle_guest_request(struct snp_msg_desc *mdesc, u64 exit_code } void __init snp_secure_tsc_prepare(void); +void __init snp_secure_tsc_init (void ); #else /* !CONFIG_AMD_MEM_ENCRYPT */ @@ -584,6 +585,7 @@ static inline int handle_guest_request(struct snp_msg_desc *mdesc, u64 exit_code u32 resp_sz) { return -ENODEV; } static inline void __init snp_secure_tsc_prepare(void) { } +static inline void __init snp_secure_tsc_init (void ) { } #endif /* CONFIG_AMD_MEM_ENCRYPT */ diff --git a/arch/x86/coco/sev/core.c b/arch/x86/coco/sev/core.cindex
140759fafe0c..0be9496b8dea100644arch/x86/coco/sev/core.c +16
-0@@ -3064,3 +3064,19 @@ void __init snp_secure_tsc_prepare(void) pr_debug("SecureTSC enabled"); } + +static unsigned long securetsc_get_tsc_khz (void ) +{ + unsigned long long tsc_freq_mhz; + + setup_force_cpu_cap(X86_FEATURE_TSC_KNOWN_FREQ); + rdmsrl(MSR_AMD64_GUEST_TSC_FREQ, tsc_freq_mhz); + + return (unsigned long)(tsc_freq_mhz * 1000); +} + +void __init snp_secure_tsc_init (void ) +{ + x86_platform.calibrate_cpu = securetsc_get_tsc_khz; + x86_platform.calibrate_tsc = securetsc_get_tsc_khz; +}arch/x86/kernel/tsc.c +1
-0@@ -30,6 +30,7 @@ #include <asm/i8259.h> #include <asm/topology.h> #include <asm/uv/uv.h> +#include <asm/sev.h> unsigned int __read_mostly cpu_khz; /* TSC clocks / usec, not used here */ EXPORT_SYMBOL(cpu_khz);arch/x86/kernel/tsc.c void __init tsc_early_init(void) · line 1520
Quoted 6 lines
arch/x86/kernel/tsc.c +3
-0@@ -1514,6 +1515,10 @@ void __init tsc_early_init(void) /* Don't change UV TSC multi-chassis synchronization */ if (is_early_uv_system()) return; + + if (cc_platform_has(CC_ATTR_GUEST_SNP_SECURE_TSC)) + snp_secure_tsc_init();IMHO, it isn't the good place to call
snp_secure_tsc_init()to update the callbacks here.
Quoted 7 lines
Quoted 1 line
It's better to be called in some snp init functions.
As part of
setup_arch(),init_hypervisor_platform()gets called and all the PV clocks are registered and initialized as part ofinit_platformcallback. Once the hypervisor platform is initialized,tsc_early_init()is called. SEV SNP guest can be running on any hypervisor, so the call back needs to be updated either intsc_early_init()orinit_hypervisor_platform(), as the change is TSC related, I have updated it here.
I think it might be due to
1. it lacks a central place for SNP related stuff, like tdx_early_init()
2. even we have some place of 1), the callbacks will be overwrote in init_hypervisor_platform() by specific PV ops.
However, I don't think it's good practice to update it tsc.c. The reason why callback is used is that arch/hypervisor specific code can implement and overwrite with it's own implementation in its own file.
Back to your case, I think a central snp init function would be helpful, and we can introduce a new flag to skip the overwrite of tsc/cpu calibration for hypervisor when the flag is set.
Quoted 8 lines
Quoted 5 lines
arch/x86/kernel/tsc.c void __init tsc_early_init(void) · line 1524
Quoted 4 lines
arch/x86/kernel/tsc.c +0
-0if (!determine_cpu_tsc_frequencies(true)) return; tsc_enable_sched_clock();Regards,
Nikunj
Re: [PATCH v14 09/13] tsc: Use the GUEST_TSC_FREQ MSR for discovering TSC frequency
Quoted 82 lines · Xiaoyao Li
Quoted 73 lines · Nikunj A. Dadhania
Quoted 70 lines · Xiaoyao Li
Quoted 60 lines · Nikunj A Dadhania
Calibrating the TSC frequency using the kvmclock is not correct for SecureTSC enabled guests. Use the platform provided TSC frequency via the
GUEST_TSC_FREQMSR (C001_0134h).Signed-off-by Nikunj A Dadhania <[email protected]>---
arch/x86/include/asm/sev.h| 2 ++ arch/x86/coco/sev/core.c | 16 ++++++++++++++++ arch/x86/kernel/tsc.c | 5 +++++3 files changed, 23 insertions(+)arch/x86/include/asm/sev.h +1
-0@@ -536,6 +536,7 @@ static inline int handle_guest_request(struct snp_msg_desc *mdesc, u64 exit_code } void __init snp_secure_tsc_prepare(void); +void __init snp_secure_tsc_init (void ); #else /* !CONFIG_AMD_MEM_ENCRYPT */@@ -584,6 +585,7 @@ static inline int
handle_guest_request(struct snp_msg_desc *mdesc, u64 exit_code u32 resp_sz){ return-ENODEV; }
static inline void__initsnp_secure_tsc_prepare(void){ }
+static inline void__initsnp_secure_tsc_init(void){ }
#endif /*CONFIG_AMD_MEM_ENCRYPT*/
diff --gita/arch/x86/coco/sev/core.cb/arch/x86/coco/sev/core.c
index140759fafe0c..0be9496b8dea100644arch/x86/coco/sev/core.c +16
-0@@ -3064,3 +3064,19 @@ void __init snp_secure_tsc_prepare(void) pr_debug("SecureTSC enabled"); } + +static unsigned long securetsc_get_tsc_khz (void ) +{ + unsigned long long tsc_freq_mhz; + + setup_force_cpu_cap(X86_FEATURE_TSC_KNOWN_FREQ); + rdmsrl(MSR_AMD64_GUEST_TSC_FREQ, tsc_freq_mhz); + + return (unsigned long)(tsc_freq_mhz * 1000); +} + +void __init snp_secure_tsc_init (void ) +{ + x86_platform.calibrate_cpu = securetsc_get_tsc_khz; + x86_platform.calibrate_tsc = securetsc_get_tsc_khz; +}arch/x86/kernel/tsc.c +1
-0@@ -30,6 +30,7 @@ #include <asm/i8259.h> #include <asm/topology.h> #include <asm/uv/uv.h> +#include <asm/sev.h> unsigned int
__read_mostlycpu_khz; /* TSC clocks / usec, not used here */EXPORT_SYMBOL(cpu_khz);arch/x86/kernel/tsc.c void __init tsc_early_init(void) · line 1520
Quoted 6 lines
arch/x86/kernel/tsc.c +3
-0@@ -1514,6 +1515,10 @@ void __init tsc_early_init(void) /* Don't change UV TSC multi-chassis synchronization */ if (is_early_uv_system()) return; + + if (cc_platform_has(CC_ATTR_GUEST_SNP_SECURE_TSC)) + snp_secure_tsc_init();IMHO, it isn't the good place to call
snp_secure_tsc_init()to update the callbacks here.Quoted 7 lines
Quoted 1 line
It's better to be called in some snp init functions.
As part of
setup_arch(),init_hypervisor_platform()gets called and all the PV clocks are registered and initialized as part ofinit_platformcallback. Once the hypervisor platform is initialized,tsc_early_init()is called. SEV SNP guest can be running on any hypervisor, so the call back needs to be updated either intsc_early_init()orinit_hypervisor_platform(), as the change is TSC related, I have updated it here.
Quoted 3 lines
I think it might be due to
1. it lacks a central place for SNP related stuff, like
tdx_early_init()
sme_early_init() does the init for SEV/SNP related stuff, but this is not the right place to do TSC callback inits as kvmclock will over-ride it.
Quoted 6 lines
2. even we have some place of 1), the callbacks will be overwrote in
init_hypervisor_platform()by specific PV ops.However, I don't think it's good practice to update it
tsc.c. The reason why callback is used is thatarch/hypervisorspecific code can implement and overwrite with it's own implementation in its own file.Back to your case, I think a central snp init function would be helpful, and we can introduce a new flag to skip the overwrite of tsc/cpu calibration for hypervisor when the flag is set.
That again touches all the hypervisor (KVM, Xen, HyperV and VMWare). We wanted to move this to common code as suggested by Sean.
Regards,
Nikunj
PATCH v14 10/13 tsc: Upgrade TSC clocksource rating
In reply to Nikunj A DadhaniaIn virtualized environments running on modern CPUs, the underlying platforms guarantees to have a stable, always running TSC, i.e. that the TSC is a superior timesource as compared to other clock sources (such as kvmclock, HPET, ACPI timer, APIC, etc.).
Upgrade the rating of the early and regular clock source to prefer TSC over other clock sources when TSC is invariant, non-stop and stable.
--- arch/x86/kernel/tsc.c | 17 +++++++++++++++++ 1 file changed, 17 insertions(+)
arch/x86/kernel/tsc.c +17 -0
@@ -1264,6 +1264,21 @@ static void __init check_system_tsc_reliable(void)tsc_disable_clocksource_watchdog (); } +static void __init upgrade_clock_rating (struct clocksource *tsc_early, +struct clocksource *tsc) +{ +/* +* Upgrade the clock rating for TSC early and regular clocksource when +* the underlying platform provides non-stop, invaraint and stable TSC. +*/ +if (boot_cpu_has (X86_FEATURE_CONSTANT_TSC ) && +boot_cpu_has (X86_FEATURE_NONSTOP_TSC ) && + !tsc_unstable) { + tsc_early->rating =449 ; + tsc->rating =450 ; + } +} +/* * Make an educated guess if the TSC is trustworthy and synchronized * over all CPUs.
@@ -1565,6 +1580,8 @@ void __init tsc_init(void)if (tsc_clocksource_reliable || no_tsc_watchdog)tsc_disable_clocksource_watchdog (); +upgrade_clock_rating (&clocksource_tsc_early, &clocksource_tsc); +clocksource_register_khz (&clocksource_tsc_early, tsc_khz);detect_art (); }
Signature · 1 line
2.34.1
PATCH v14 11/13 tsc: Switch to native sched clock
In reply to Nikunj A DadhaniaAlthough the kernel switches over to stable TSC clocksource instead of PV clocksource, the scheduler still keeps on using PV clocks as the sched clock source. This is because KVM, Xen and VMWare, switch the paravirt sched clock handler in their init routines. HyperV is the only PV clock source that checks if the platform provides an invariant TSC and does not switch to PV sched clock.
When switching back to stable TSC, restore the scheduler clock to native_sched_clock().
As the clock selection happens in the stop machine context, schedule delayed work to update the static_call()
--- arch/x86/kernel/tsc.c | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+)
arch/x86/kernel/tsc.c +19 -0
@@ -272,10 +272,25 @@ bool using_native_sched_clock(void) {return static_call_query (pv_sched_clock) == native_sched_clock; } + +static void enable_native_sc_work (struct work_struct *work) +{ +pr_info ("using native sched clock\n" ); +paravirt_set_sched_clock (native_sched_clock); +} +static DECLARE_DELAYED_WORK(enable_native_sc, enable_native_sc_work); + +static void enable_native_sched_clock (void ) +{ +if (!using_native_sched_clock ()) +schedule_delayed_work (&enable_native_sc,0 ); +}#else u64 sched_clock_noinstr (void ) __attribute__((alias ("native_sched_clock" )));bool using_native_sched_clock (void ) {return true; } + +static void enable_native_sched_clock (void ) { }#endif notrace u64 sched_clock(void)
@@ -1157,6 +1172,10 @@ static void tsc_cs_tick_stable(struct clocksource *cs)static int tsc_cs_enable (struct clocksource *cs) {vclocks_set_used (VDSO_CLOCKMODE_TSC ); + +/* Restore native_sched_clock() when switching to TSC */ +enable_native_sched_clock (); +return 0 ; }
Signature · 1 line
2.34.1
PATCH v14 12/13 x86/kvmclock: Abort SecureTSC enabled guest when kvmclock is selected
In reply to Nikunj A DadhaniaSecureTSC enabled guests should use TSC as the only clock source, terminate the guest with appropriate code when clock source switches to hypervisor controlled kvmclock.
--- arch/x86/include/asm/sev-common.h | 1 + arch/x86/include/asm/sev.h | 2 ++ arch/x86/coco/sev/shared.c | 3 +-- arch/x86/kernel/kvmclock.c | 9 +++++++++ 4 files changed, 13 insertions(+), 2 deletions(-)
arch/x86/include/asm/sev-common.h +1 -0
@@ -207,6 +207,7 @@ struct snp_psc_desc {#define GHCB_TERM_SVSM_VMPL0 8/* SVSM is present but has set VMPL to 0 */ #define GHCB_TERM_SVSM_CAA 9/* SVSM is present but CAA is not page aligned */ #define GHCB_TERM_SECURE_TSC 10/* Secure TSC initialization failed */ +#define GHCB_TERM_SECURE_TSC_KVMCLOCK 11/* KVM clock selected instead of Secure TSC */ #define GHCB_RESP_CODE (v) ((v) & GHCB_MSR_INFO_MASK)
arch/x86/include/asm/sev.h +2 -0
@@ -537,6 +537,7 @@ static inline int handle_guest_request(struct snp_msg_desc *mdesc, u64 exit_codevoid __init snp_secure_tsc_prepare (void );void __init snp_secure_tsc_init (void ); +void __noreturn sev_es_terminate (unsigned int set,unsigned int reason);#else /* !CONFIG_AMD_MEM_ENCRYPT */
@@ -586,6 +587,7 @@ static inline int handle_guest_request(struct snp_msg_desc *mdesc, u64 exit_codestatic inline void __init snp_secure_tsc_prepare (void ) { }static inline void __init snp_secure_tsc_init (void ) { } +static inline void sev_es_terminate (unsigned int set,unsigned int reason) { }#endif /* CONFIG_AMD_MEM_ENCRYPT */
arch/x86/coco/sev/shared.c +1 -2
@@ -117,8 +117,7 @@ static bool __init sev_es_check_cpu_features(void)return true; } -static void __head __noreturn -sev_es_terminate (unsigned int set,unsigned int reason) +void __head __noreturn sev_es_terminate(unsigned int set, unsigned int reason) {u64 val =GHCB_MSR_TERM_REQ ;
arch/x86/kernel/kvmclock.c +9 -0
@@ -21,6 +21,7 @@#include <asm/hypervisor.h> #include <asm/x86_init.h> #include <asm/kvmclock.h> +#include <asm/sev.h> static int kvmclock__initdata =1 ;static int kvmclock_vsyscall__initdata =1 ;
@@ -150,6 +151,14 @@ bool kvm_check_and_clear_guest_paused(void)static int kvm_cs_enable (struct clocksource *cs) { +/* +* For a guest with SecureTSC enabled, the TSC should be the only clock +* source. Abort the guest when kvmclock is selected as the clock +* source. +*/ +if (WARN_ON (cc_platform_has (CC_ATTR_GUEST_SNP_SECURE_TSC ))) +sev_es_terminate (SEV_TERM_SET_LINUX ,GHCB_TERM_SECURE_TSC_KVMCLOCK ); +vclocks_set_used (VDSO_CLOCKMODE_PVCLOCK );return 0 ; }
Signature · 1 line
2.34.1
PATCH v14 13/13 x86/sev: Allow Secure TSC feature for SNP guests
In reply to Nikunj A DadhaniaNow that all the required plumbing is done for enabling SNP Secure TSC feature, add Secure TSC to SNP features present list.
--- arch/x86/boot/compressed/sev.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
arch/x86/boot/compressed/sev.c +2 -1
@@ -401,7 +401,8 @@ void do_boot_stage2_vc(struct pt_regs *regs, unsigned long exit_code)* by the guest kernel. As and when a new feature is implemented in the * guest kernel, a corresponding bit should be added to the mask. */ -#define SNP_FEATURES_PRESENT MSR_AMD64_SNP_DEBUG_SWAP +#define SNP_FEATURES_PRESENT (MSR_AMD64_SNP_DEBUG_SWAP | \ + MSR_AMD64_SNP_SECURE_TSC)u64 snp_get_unsupported_features (u64 status) {
Signature · 1 line
2.34.1