x86: Secure Memory Encryption (AMD)
Subsystems (26)
tip-bot for Tom Lendacky
merge bot[tip:x86/mm] x86/mm, kexec: Allow kexec to be used with SME
In reply to Tom Lendackyx86/mm, kexec: Allow kexec to be used with SME
Commit-ID: bba4ed011a52d494aa7ef5e08cf226709bbf3f60 Gitweb: http://git.kernel.org/tip/bba4ed011a52d494aa7ef5e08cf226709bbf3f60 Author: Tom Lendacky <[email protected]> AuthorDate: Mon, 17 Jul 2017 16:10:28 -0500 Committer: Ingo Molnar <[email protected]> CommitDate: Tue, 18 Jul 2017 11:38:04 +0200
x86/mm, kexec: Allow kexec to be used with SME
Provide support so that kexec can be used to boot a kernel when SME is enabled.
Support is needed to allocate pages for kexec without encryption. This is needed in order to be able to reboot in the kernel in the same manner as originally booted.
Additionally, when shutting down all of the CPUs we need to be sure to flush the caches and then halt. This is needed when booting from a state where SME was not active into a state where SME is active (or vice-versa). Without these steps, it is possible for cache lines to exist for the same physical location but tagged both with and without the encryption bit. This can cause random memory corruption when caches are flushed depending on which cacheline is written last.
--- arch/x86/include/asm/init.h | 1 + arch/x86/include/asm/kexec.h | 8 ++++++++ arch/x86/include/asm/pgtable_types.h | 1 + arch/x86/kernel/machine_kexec_64.c | 22 +++++++++++++++++++++- arch/x86/kernel/process.c | 17 +++++++++++++++-- arch/x86/mm/ident_map.c | 12 ++++++++---- include/linux/kexec.h | 8 ++++++++ kernel/kexec_core.c | 12 +++++++++++- 8 files changed, 73 insertions(+), 8 deletions(-)
arch/x86/include/asm/init.h +1 -0
@@ -7,6 +7,7 @@ struct x86_mapping_info {unsigned long page_flag;/* page flag for PMD or PUD entry */ unsigned long offset;/* ident mapping offset */ bool direct_gbpages;/* PUD level 1GB page support */ +unsigned long kernpg_flag;/* kernel pagetable flag override */ }; int kernel_ident_mapping_init(struct x86_mapping_info *info, pgd_t *pgd_page,
arch/x86/include/asm/kexec.h +8 -0
@@ -207,6 +207,14 @@ struct kexec_entry64_regs {uint64_t r15; uint64_t rip; }; + +extern int arch_kexec_post_alloc_pages (void *vaddr,unsigned int pages, +gfp_t gfp); +#define arch_kexec_post_alloc_pages arch_kexec_post_alloc_pages + +extern void arch_kexec_pre_free_pages (void *vaddr,unsigned int pages); +#define arch_kexec_pre_free_pages arch_kexec_pre_free_pages +#endif typedef void crash_vmclear_fn (void );
arch/x86/include/asm/pgtable_types.h +1 -0
@@ -213,6 +213,7 @@ enum page_cache_mode {#define PAGE_KERNEL __pgprot(__PAGE_KERNEL | _PAGE_ENC)#define PAGE_KERNEL_RO __pgprot(__PAGE_KERNEL_RO | _PAGE_ENC)#define PAGE_KERNEL_EXEC __pgprot(__PAGE_KERNEL_EXEC | _PAGE_ENC) +#define PAGE_KERNEL_EXEC_NOENC __pgprot(__PAGE_KERNEL_EXEC)#define PAGE_KERNEL_RX __pgprot(__PAGE_KERNEL_RX | _PAGE_ENC)#define PAGE_KERNEL_NOCACHE __pgprot(__PAGE_KERNEL_NOCACHE | _PAGE_ENC)#define PAGE_KERNEL_LARGE __pgprot(__PAGE_KERNEL_LARGE | _PAGE_ENC)
arch/x86/kernel/machine_kexec_64.c +21 -1
@@ -87,7 +87,7 @@ static int init_transition_pgtable(struct kimage *image, pgd_t *pgd)set_pmd (pmd,__pmd (__pa (pte) | _KERNPG_TABLE)); } pte =pte_offset_kernel (pmd, vaddr); -set_pte (pte,pfn_pte (paddr >>PAGE_SHIFT ,PAGE_KERNEL_EXEC )); +set_pte (pte,pfn_pte (paddr >>PAGE_SHIFT ,PAGE_KERNEL_EXEC_NOENC ));return 0 ; err:free_transition_pgtable (image);
@@ -115,6 +115,7 @@ static int init_pgtable(struct kimage *image, unsigned long start_pgtable) .alloc_pgt_page = alloc_pgt_page, .context = image, .page_flag = __PAGE_KERNEL_LARGE_EXEC, + .kernpg_flag = _KERNPG_TABLE_NOENC, };unsigned long mstart, mend;pgd_t *level4p;
@@ -602,3 +603,22 @@ void arch_kexec_unprotect_crashkres(void) {kexec_mark_crashkres (false); } + +int arch_kexec_post_alloc_pages (void *vaddr,unsigned int pages,gfp_t gfp) +{ +/* +* If SME is active we need to be sure that kexec pages are +* not encrypted because when we boot to the new kernel the +* pages won't be accessed encrypted (initially). +*/ +return set_memory_decrypted ((unsigned long )vaddr, pages); +} + +void arch_kexec_pre_free_pages (void *vaddr,unsigned int pages) +{ +/* +* If SME is active we need to reset the pages back to being +* an encrypted mapping before freeing them. +*/ +set_memory_encrypted ((unsigned long )vaddr, pages); +}
arch/x86/kernel/process.c +15 -2
@@ -355,6 +355,7 @@ bool xen_set_default_idle(void) return ret; }#endif +void stop_this_cpu (void *dummy) {local_irq_disable ();
@@ -365,8 +366,20 @@ void stop_this_cpu(void *dummy)disable_local_APIC ();mcheck_cpu_clear (this_cpu_ptr (&cpu_info)); -for (;;) -halt (); +for (;;) { +/* +* Use wbinvd followed by hlt to stop the processor. This +* provides support for kexec on a processor that supports +* SME. With kexec, going from SME inactive to SME active +* requires clearing cache entries so that addresses without +* the encryption bit set don't corrupt the same physical +* address that has the encryption bit set when caches are +* flushed. To achieve this a wbinvd is performed followed by +* a hlt. Even if the processor is not in the kexec/SME +* scenario this only adds a wbinvd to a halting processor. +*/ + asmvolatile ("wbinvd; hlt" : : :"memory" ); + } }/*
arch/x86/mm/ident_map.c +8 -4
@@ -51,7 +51,7 @@ static int ident_pud_init(struct x86_mapping_info *info, pud_t *pud_page,if (!pmd)return -ENOMEM ;ident_pmd_init (info, pmd, addr, next); -set_pud (pud,__pud (__pa (pmd) | _KERNPG_TABLE)); +set_pud (pud,__pud (__pa (pmd) | info->kernpg_flag)); }return 0 ;
@@ -79,7 +79,7 @@ static int ident_p4d_init(struct x86_mapping_info *info, p4d_t *p4d_page,if (!pud)return -ENOMEM ;ident_pud_init (info, pud, addr, next); -set_p4d (p4d,__p4d (__pa (pud) | _KERNPG_TABLE)); +set_p4d (p4d,__p4d (__pa (pud) | info->kernpg_flag)); }return 0 ;
@@ -93,6 +93,10 @@ int kernel_ident_mapping_init(struct x86_mapping_info *info, pgd_t *pgd_page,unsigned long next;int result; +/* Set the default pagetable flags if not supplied */ +if (!info->kernpg_flag) + info->kernpg_flag = _KERNPG_TABLE; +for (; addr < end; addr = next) {pgd_t *pgd = pgd_page +pgd_index (addr);p4d_t *p4d;
@@ -116,14 +120,14 @@ int kernel_ident_mapping_init(struct x86_mapping_info *info, pgd_t *pgd_page,if (result)return result;if (IS_ENABLED (CONFIG_X86_5LEVEL )) { -set_pgd (pgd,__pgd (__pa (p4d) | _KERNPG_TABLE)); +set_pgd (pgd,__pgd (__pa (p4d) | info->kernpg_flag)); }else {/* * With p4d folded, pgd is equal to p4d. * The pgd entry has to point to the pud page table in this case. */ pud_t *pud =pud_offset (p4d,0 ); -set_pgd (pgd,__pgd (__pa (pud) | _KERNPG_TABLE)); +set_pgd (pgd,__pgd (__pa (pud) | info->kernpg_flag)); } }
include/linux/kexec.h +8 -0
@@ -327,6 +327,14 @@ static inline void *boot_phys_to_virt(unsigned long entry) return phys_to_virt(boot_phys_to_phys(entry)); } +#ifndef arch_kexec_post_alloc_pages +static inline int arch_kexec_post_alloc_pages (void *vaddr,unsigned int pages,gfp_t gfp) {return 0 ; } +#endif + +#ifndef arch_kexec_pre_free_pages +static inline void arch_kexec_pre_free_pages (void *vaddr,unsigned int pages) { } +#endif +#else /* !CONFIG_KEXEC_CORE */ struct pt_regs ;struct task_struct ;
kernel/kexec_core.c +11 -1
@@ -301,7 +301,7 @@ static struct page *kimage_alloc_pages(gfp_t gfp_mask, unsigned int order) {struct page *pages; - pages =alloc_pages (gfp_mask, order); + pages =alloc_pages (gfp_mask & ~__GFP_ZERO, order);if (pages) {unsigned int count, i;
@@ -310,6 +310,13 @@ static struct page *kimage_alloc_pages(gfp_t gfp_mask, unsigned int order) count =1 << order;for (i =0 ; i < count; i++)SetPageReserved (pages + i); + +arch_kexec_post_alloc_pages (page_address (pages), count, + gfp_mask); + +if (gfp_mask & __GFP_ZERO) +for (i =0 ; i < count; i++) +clear_highpage (pages + i); }return pages;
@@ -321,6 +328,9 @@ static void kimage_free_pages(struct page *page) order =page_private (page); count =1 << order; + +arch_kexec_pre_free_pages (page_address (page), count); +for (i =0 ; i < count; i++)ClearPageReserved (page + i);__free_pages (page, order);
_______________________________________________
kexec mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/kexec
PATCH v10 32/38 xen/x86: Remove SME feature in PV guests
In reply to Tom LendackyXen does not currently support SME for PV guests. Clear the SME CPU capability in order to avoid any ambiguity.
--- arch/x86/xen/enlighten_pv.c | 1 + 1 file changed, 1 insertion(+)
arch/x86/xen/enlighten_pv.c +1 -0
@@ -263,6 +263,7 @@ static void __init xen_init_capabilities(void)setup_clear_cpu_cap (X86_FEATURE_MTRR );setup_clear_cpu_cap (X86_FEATURE_ACC );setup_clear_cpu_cap (X86_FEATURE_X2APIC ); +setup_clear_cpu_cap (X86_FEATURE_SME );/* * Xen PV would need some work to support PCID: CR3 handling as well
Signature · 1 line
1.9.1
tip-bot for Tom Lendacky
merge bot[tip:x86/mm] xen/x86: Remove SME feature in PV guests
xen/x86: Remove SME feature in PV guests
Commit-ID: f2f931c6819467af5260a21c59fb787ce2863f92 Gitweb: http://git.kernel.org/tip/f2f931c6819467af5260a21c59fb787ce2863f92 Author: Tom Lendacky <[email protected]> AuthorDate: Mon, 17 Jul 2017 16:10:29 -0500 Committer: Ingo Molnar <[email protected]> CommitDate: Tue, 18 Jul 2017 11:38:05 +0200
xen/x86: Remove SME feature in PV guests
Xen does not currently support SME for PV guests. Clear the SME CPU capability in order to avoid any ambiguity.
--- arch/x86/xen/enlighten_pv.c | 1 + 1 file changed, 1 insertion(+)
arch/x86/xen/enlighten_pv.c +1 -0
@@ -263,6 +263,7 @@ static void __init xen_init_capabilities(void)setup_clear_cpu_cap (X86_FEATURE_MTRR );setup_clear_cpu_cap (X86_FEATURE_ACC );setup_clear_cpu_cap (X86_FEATURE_X2APIC ); +setup_clear_cpu_cap (X86_FEATURE_SME );/* * Xen PV would need some work to support PCID: CR3 handling as well
_______________________________________________
Xen-devel mailing list
[email protected]
https://lists.xen.org/xen-devel
PATCH v10 32/38 xen/x86: Remove SME feature in PV guests
In reply to Tom LendackyXen does not currently support SME for PV guests. Clear the SME CPU capability in order to avoid any ambiguity.
--- arch/x86/xen/enlighten_pv.c | 1 + 1 file changed, 1 insertion(+)
arch/x86/xen/enlighten_pv.c +1 -0
@@ -263,6 +263,7 @@ static void __init xen_init_capabilities(void)setup_clear_cpu_cap (X86_FEATURE_MTRR );setup_clear_cpu_cap (X86_FEATURE_ACC );setup_clear_cpu_cap (X86_FEATURE_X2APIC ); +setup_clear_cpu_cap (X86_FEATURE_SME );/* * Xen PV would need some work to support PCID: CR3 handling as well
Signature · 7 lines
1.9.1 _______________________________________________ Xen-devel mailing list [email protected] https://lists.xen.org/xen-devel
PATCH v10 33/38 x86/mm: Use proper encryption attributes with /dev/mem
In reply to Tom LendackyWhen accessing memory using /dev/mem (or /dev/kmem) use the proper encryption attributes when mapping the memory.
To insure the proper attributes are applied when reading or writing /dev/mem, update the xlate_dev_mem_ptr() function to use memremap() which will essentially perform the same steps of applying __va for RAM or using ioremap() if not RAM.
To insure the proper attributes are applied when mmapping /dev/mem, update the phys_mem_access_prot() to call phys_mem_access_encrypted(), a new function which will check if the memory should be mapped encrypted or not. If it is not to be mapped encrypted then the VMA protection value is updated to remove the encryption bit.
--- arch/x86/include/asm/io.h | 3 +++ arch/x86/mm/ioremap.c | 18 +++++++++--------- arch/x86/mm/pat.c | 3 +++ 3 files changed, 15 insertions(+), 9 deletions(-)
arch/x86/include/asm/io.h +3 -0
@@ -386,4 +386,7 @@ extern bool arch_memremap_can_ram_remap(resource_size_t offset, unsigned long flags);#define arch_memremap_can_ram_remap arch_memremap_can_ram_remap +extern bool phys_mem_access_encrypted (unsigned long phys_addr, +unsigned long size); +#endif /* _ASM_X86_IO_H */
arch/x86/mm/ioremap.c +9 -9
@@ -400,12 +400,10 @@ void *xlate_dev_mem_ptr(phys_addr_t phys)unsigned long offset = phys & ~PAGE_MASK ;void *vaddr; -/* If page is RAM, we can use __va. Otherwise ioremap and unmap. */ -if (page_is_ram (start >>PAGE_SHIFT )) -return __va (phys); +/* memremap() maps if RAM, otherwise falls back to ioremap() */ + vaddr =memremap (start,PAGE_SIZE ,MEMREMAP_WB ); - vaddr =ioremap_cache (start,PAGE_SIZE ); -/* Only add the offset on success and return NULL if the ioremap() failed: */ +/* Only add the offset on success and return NULL if memremap() failed */ if (vaddr) vaddr += offset;
@@ -414,10 +412,7 @@ void *xlate_dev_mem_ptr(phys_addr_t phys)void unxlate_dev_mem_ptr (phys_addr_t phys,void *addr) { -if (page_is_ram (phys >>PAGE_SHIFT )) -return ; - -iounmap ((void __iomem *)((unsigned long )addr &PAGE_MASK )); +memunmap ((void *)((unsigned long )addr &PAGE_MASK )); }/*
@@ -626,6 +621,11 @@ pgprot_t __init early_memremap_pgprot_adjust(resource_size_t phys_addr,return prot; } +bool phys_mem_access_encrypted (unsigned long phys_addr,unsigned long size) +{ +return arch_memremap_can_ram_remap (phys_addr, size,0 ); +} +#ifdef CONFIG_ARCH_USE_MEMREMAP_PROT /* Remap memory with encryption */ void __init *early_memremap_encrypted(resource_size_t phys_addr,
arch/x86/mm/pat.c +3 -0
@@ -744,6 +744,9 @@ void arch_io_free_memtype_wc(resource_size_t start, resource_size_t size)pgprot_t phys_mem_access_prot (struct file *file,unsigned long pfn,unsigned long size,pgprot_t vma_prot) { +if (!phys_mem_access_encrypted (pfn <<PAGE_SHIFT , size)) + vma_prot =pgprot_decrypted (vma_prot); +return vma_prot; }
Signature · 7 lines
1.9.1 -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
tip-bot for Tom Lendacky
merge bot[tip:x86/mm] x86/mm: Use proper encryption attributes with /dev/mem
x86/mm: Use proper encryption attributes with /dev/mem
Commit-ID: 8458bf94b0399cd1bca6c437366bcafb29c230c5 Gitweb: http://git.kernel.org/tip/8458bf94b0399cd1bca6c437366bcafb29c230c5 Author: Tom Lendacky <[email protected]> AuthorDate: Mon, 17 Jul 2017 16:10:30 -0500 Committer: Ingo Molnar <[email protected]> CommitDate: Tue, 18 Jul 2017 11:38:05 +0200
x86/mm: Use proper encryption attributes with /dev/mem
When accessing memory using /dev/mem (or /dev/kmem) use the proper encryption attributes when mapping the memory.
To insure the proper attributes are applied when reading or writing /dev/mem, update the xlate_dev_mem_ptr() function to use memremap() which will essentially perform the same steps of applying __va for RAM or using ioremap() if not RAM.
To insure the proper attributes are applied when mmapping /dev/mem, update the phys_mem_access_prot() to call phys_mem_access_encrypted(), a new function which will check if the memory should be mapped encrypted or not. If it is not to be mapped encrypted then the VMA protection value is updated to remove the encryption bit.
--- arch/x86/include/asm/io.h | 3 +++ arch/x86/mm/ioremap.c | 18 +++++++++--------- arch/x86/mm/pat.c | 3 +++ 3 files changed, 15 insertions(+), 9 deletions(-)
arch/x86/include/asm/io.h +3 -0
@@ -386,4 +386,7 @@ extern bool arch_memremap_can_ram_remap(resource_size_t offset, unsigned long flags);#define arch_memremap_can_ram_remap arch_memremap_can_ram_remap +extern bool phys_mem_access_encrypted (unsigned long phys_addr, +unsigned long size); +#endif /* _ASM_X86_IO_H */
arch/x86/mm/ioremap.c +9 -9
@@ -400,12 +400,10 @@ void *xlate_dev_mem_ptr(phys_addr_t phys)unsigned long offset = phys & ~PAGE_MASK ;void *vaddr; -/* If page is RAM, we can use __va. Otherwise ioremap and unmap. */ -if (page_is_ram (start >>PAGE_SHIFT )) -return __va (phys); +/* memremap() maps if RAM, otherwise falls back to ioremap() */ + vaddr =memremap (start,PAGE_SIZE ,MEMREMAP_WB ); - vaddr =ioremap_cache (start,PAGE_SIZE ); -/* Only add the offset on success and return NULL if the ioremap() failed: */ +/* Only add the offset on success and return NULL if memremap() failed */ if (vaddr) vaddr += offset;
@@ -414,10 +412,7 @@ void *xlate_dev_mem_ptr(phys_addr_t phys)void unxlate_dev_mem_ptr (phys_addr_t phys,void *addr) { -if (page_is_ram (phys >>PAGE_SHIFT )) -return ; - -iounmap ((void __iomem *)((unsigned long )addr &PAGE_MASK )); +memunmap ((void *)((unsigned long )addr &PAGE_MASK )); }/*
@@ -626,6 +621,11 @@ pgprot_t __init early_memremap_pgprot_adjust(resource_size_t phys_addr,return prot; } +bool phys_mem_access_encrypted (unsigned long phys_addr,unsigned long size) +{ +return arch_memremap_can_ram_remap (phys_addr, size,0 ); +} +#ifdef CONFIG_ARCH_USE_MEMREMAP_PROT /* Remap memory with encryption */ void __init *early_memremap_encrypted(resource_size_t phys_addr,
arch/x86/mm/pat.c +3 -0
@@ -744,6 +744,9 @@ EXPORT_SYMBOL(arch_io_free_memtype_wc);pgprot_t phys_mem_access_prot (struct file *file,unsigned long pfn,unsigned long size,pgprot_t vma_prot) { +if (!phys_mem_access_encrypted (pfn <<PAGE_SHIFT , size)) + vma_prot =pgprot_decrypted (vma_prot); +return vma_prot; }
PATCH v10 34/38 x86/mm: Create native_make_p4d() for PGTABLE_LEVELS <= 4
In reply to Tom LendackyCurrently, native_make_p4d() is only defined when CONFIG_PGTABLE_LEVELS is greater than 4. Create a macro that will allow for defining and using native_make_p4d() when CONFIG_PGTABLES_LEVELS is not greater than 4.
--- arch/x86/include/asm/pgtable_types.h | 5 +++++ 1 file changed, 5 insertions(+)
arch/x86/include/asm/pgtable_types.h +5 -0
@@ -309,6 +309,11 @@ static inline p4dval_t native_p4d_val(p4d_t p4d)#else #include <asm-generic/pgtable-nop4d.h> +static inline p4d_t native_make_p4d (pudval_t val) +{ +return (p4d_t ) { .pgd =native_make_pgd ((pgdval_t )val) }; +} +static inline p4dval_t native_p4d_val (p4d_t p4d) {return native_pgd_val (p4d.pgd);
Signature · 7 lines
1.9.1 -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
tip-bot for Tom Lendacky
merge bot[tip:x86/mm] x86/mm: Create native_make_p4d() for PGTABLE_LEVELS <= 4
x86/mm: Create native_make_p4d() for PGTABLE_LEVELS <= 4
Commit-ID: db516997a985b461f021d594e78155bbc7fc3e7e Gitweb: http://git.kernel.org/tip/db516997a985b461f021d594e78155bbc7fc3e7e Author: Tom Lendacky <[email protected]> AuthorDate: Mon, 17 Jul 2017 16:10:31 -0500 Committer: Ingo Molnar <[email protected]> CommitDate: Tue, 18 Jul 2017 11:38:05 +0200
x86/mm: Create native_make_p4d() for PGTABLE_LEVELS <= 4
Currently, native_make_p4d() is only defined when CONFIG_PGTABLE_LEVELS is greater than 4. Create a macro that will allow for defining and using native_make_p4d() when CONFIG_PGTABLES_LEVELS is not greater than 4.
--- arch/x86/include/asm/pgtable_types.h | 5 +++++ 1 file changed, 5 insertions(+)
arch/x86/include/asm/pgtable_types.h +5 -0
@@ -309,6 +309,11 @@ static inline p4dval_t native_p4d_val(p4d_t p4d)#else #include <asm-generic/pgtable-nop4d.h> +static inline p4d_t native_make_p4d (pudval_t val) +{ +return (p4d_t ) { .pgd =native_make_pgd ((pgdval_t )val) }; +} +static inline p4dval_t native_p4d_val (p4d_t p4d) {return native_pgd_val (p4d.pgd);
PATCH v10 35/38 x86/mm: Add support to encrypt the kernel in-place
In reply to Tom LendackyAdd the support to encrypt the kernel in-place. This is done by creating new page mappings for the kernel - a decrypted write-protected mapping and an encrypted mapping. The kernel is encrypted by copying it through a temporary buffer.
--- arch/x86/include/asm/mem_encrypt.h | 6 + arch/x86/mm/Makefile | 1 + arch/x86/mm/mem_encrypt.c | 310 +++++++++++++++++++++++++++++++++++++ arch/x86/mm/mem_encrypt_boot.S | 149 ++++++++++++++++++ 4 files changed, 466 insertions(+) create mode 100644 arch/x86/mm/mem_encrypt_boot.S
arch/x86/include/asm/mem_encrypt.h +6 -0
@@ -21,6 +21,12 @@extern unsigned long sme_me_mask; +void sme_encrypt_execute (unsigned long encrypted_kernel_vaddr, +unsigned long decrypted_kernel_vaddr, +unsigned long kernel_len, +unsigned long encryption_wa, +unsigned long encryption_pgd); +void __init sme_early_encrypt (resource_size_t paddr,unsigned long size); void __init sme_early_decrypt(resource_size_t paddr,
arch/x86/mm/Makefile +1 -0
@@ -40,3 +40,4 @@ obj-$(CONFIG_X86_INTEL_MEMORY_PROTECTION_KEYS) += pkeys.o obj-$(CONFIG_RANDOMIZE_MEMORY) += kaslr.o obj-$(CONFIG_AMD_MEM_ENCRYPT) += mem_encrypt.o +obj-$(CONFIG_AMD_MEM_ENCRYPT) += mem_encrypt_boot.o
arch/x86/mm/mem_encrypt.c +310 -0
324 lines not on this page · raw message
arch/x86/mm/mem_encrypt_boot.S new file +149 -0
149 lines not on this page · raw message
Signature · 7 lines
1.9.1 -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
tip-bot for Tom Lendacky
merge bot[tip:x86/mm] x86/mm: Add support to encrypt the kernel in-place
x86/mm: Add support to encrypt the kernel in-place
Commit-ID: 6ebcb060713f614c92216482eed501b31cee74ec Gitweb: http://git.kernel.org/tip/6ebcb060713f614c92216482eed501b31cee74ec Author: Tom Lendacky <[email protected]> AuthorDate: Mon, 17 Jul 2017 16:10:32 -0500 Committer: Ingo Molnar <[email protected]> CommitDate: Tue, 18 Jul 2017 11:38:05 +0200
x86/mm: Add support to encrypt the kernel in-place
Add the support to encrypt the kernel in-place. This is done by creating new page mappings for the kernel - a decrypted write-protected mapping and an encrypted mapping. The kernel is encrypted by copying it through a temporary buffer.
--- arch/x86/include/asm/mem_encrypt.h | 6 + arch/x86/mm/Makefile | 1 + arch/x86/mm/mem_encrypt.c | 310 +++++++++++++++++++++++++++++++++++++ arch/x86/mm/mem_encrypt_boot.S | 149 ++++++++++++++++++ 4 files changed, 466 insertions(+)
arch/x86/include/asm/mem_encrypt.h +6 -0
@@ -21,6 +21,12 @@extern unsigned long sme_me_mask; +void sme_encrypt_execute (unsigned long encrypted_kernel_vaddr, +unsigned long decrypted_kernel_vaddr, +unsigned long kernel_len, +unsigned long encryption_wa, +unsigned long encryption_pgd); +void __init sme_early_encrypt (resource_size_t paddr,unsigned long size); void __init sme_early_decrypt(resource_size_t paddr,
arch/x86/mm/Makefile +1 -0
@@ -40,3 +40,4 @@ obj-$(CONFIG_X86_INTEL_MEMORY_PROTECTION_KEYS) += pkeys.o obj-$(CONFIG_RANDOMIZE_MEMORY) += kaslr.o obj-$(CONFIG_AMD_MEM_ENCRYPT) += mem_encrypt.o +obj-$(CONFIG_AMD_MEM_ENCRYPT) += mem_encrypt_boot.o
arch/x86/mm/mem_encrypt.c +310 -0
324 lines not on this page · raw message
arch/x86/mm/mem_encrypt_boot.S new file +149 -0
149 lines not on this page · raw message
PATCH v10 36/38 x86/boot: Add early cmdline parsing for options with arguments
In reply to Tom LendackyAdd a cmdline_find_option() function to look for cmdline options that take arguments. The argument is returned in a supplied buffer and the argument length (regardless of whether it fits in the supplied buffer) is returned, with -1 indicating not found.
--- arch/x86/include/asm/cmdline.h | 2 + arch/x86/lib/cmdline.c | 105 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 107 insertions(+)
arch/x86/include/asm/cmdline.h +2 -0
@@ -2,5 +2,7 @@#define _ASM_X86_CMDLINE_Hint cmdline_find_option_bool (const char *cmdline_ptr,const char *option); +int cmdline_find_option (const char *cmdline_ptr,const char *option, +char *buffer,int bufsize);#endif /* _ASM_X86_CMDLINE_H */
arch/x86/lib/cmdline.c +105 -0
112 lines not on this page · raw message
Signature · 1 line
1.9.1
tip-bot for Tom Lendacky
merge bot[tip:x86/mm] x86/boot: Add early cmdline parsing for options with arguments
x86/boot: Add early cmdline parsing for options with arguments
Commit-ID: e505371dd83963caae1a37ead9524e8d997341be Gitweb: http://git.kernel.org/tip/e505371dd83963caae1a37ead9524e8d997341be Author: Tom Lendacky <[email protected]> AuthorDate: Mon, 17 Jul 2017 16:10:33 -0500 Committer: Ingo Molnar <[email protected]> CommitDate: Tue, 18 Jul 2017 11:38:06 +0200
x86/boot: Add early cmdline parsing for options with arguments
Add a cmdline_find_option() function to look for cmdline options that take arguments. The argument is returned in a supplied buffer and the argument length (regardless of whether it fits in the supplied buffer) is returned, with -1 indicating not found.
--- arch/x86/include/asm/cmdline.h | 2 + arch/x86/lib/cmdline.c | 105 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 107 insertions(+)
arch/x86/include/asm/cmdline.h +2 -0
@@ -2,5 +2,7 @@#define _ASM_X86_CMDLINE_Hint cmdline_find_option_bool (const char *cmdline_ptr,const char *option); +int cmdline_find_option (const char *cmdline_ptr,const char *option, +char *buffer,int bufsize);#endif /* _ASM_X86_CMDLINE_H */
arch/x86/lib/cmdline.c +105 -0
112 lines not on this page · raw message
PATCH v10 37/38 compiler-gcc.h: Introduce __nostackp function attribute
In reply to Tom LendackyCreate a new function attribute, __nostackp, that can used to turn off stack protection on a per function basis.
--- include/linux/compiler-gcc.h | 2 ++ include/linux/compiler.h | 4 ++++ 2 files changed, 6 insertions(+)
include/linux/compiler-gcc.h +2 -0
@@ -166,6 +166,8 @@#if GCC_VERSION >=40100 # define __compiletime_object_size (obj) __builtin_object_size(obj, 0) + +#define __nostackp __attribute__((__optimize__("no-stack-protector")))#endif #if GCC_VERSION >=40300
include/linux/compiler.h +4 -0
@@ -470,6 +470,10 @@ static __always_inline void __write_once_size(volatile void *p, void *res, int s#define __visible#endif +#ifndef __nostackp +#define __nostackp +#endif +/* * Assume alignment of return value. */
Signature · 1 line
1.9.1
Re: [PATCH v10 37/38] compiler-gcc.h: Introduce __nostackp function attribute
Quoted 27 lines · Tom Lendacky
Create a new function attribute,
__nostackp, that can used to turn off stack protection on a per function basis.Signed-off-by Tom Lendacky <[email protected]>--- include/linux/compiler-gcc.h | 2 ++ include/linux/compiler.h | 4 ++++ 2 files changed, 6 insertions(+)include/linux/compiler-gcc.h +2
-0@@ -166,6 +166,8 @@#if GCC_VERSION >=40100 # define __compiletime_object_size (obj) __builtin_object_size(obj, 0) + +#define __nostackp __attribute__((__optimize__("no-stack-protector")))#endif #if GCC_VERSION >=40300 include/linux/compiler.h +0
-0
include/linux/compiler.h static __always_inline void __write_once_size(volatile void *p, void *res, int s · line 475
Quoted 6 lines
include/linux/compiler.h +3
-0@@ -470,6 +470,10 @@ static __always_inline void __write_once_size(volatile void *p, void *res, int s#define __visible#endif +#ifndef __nostackp +#define __nostackp +#endif
So I changed this from the hard to read and ambiguous "__nostackp" abbreviation (does it mean 'no stack pointer?') to "__nostackprotector", plus added this detail to the changelog:
| ( This is needed by the SME in-place kernel memory encryption feature, | which activates encryption in its sme_enable() function and thus changes the | visible value of the stack protection cookie on function return. )
Agreed?
Thanks,
Ingo
Re: [PATCH v10 37/38] compiler-gcc.h: Introduce __nostackp function attribute
Quoted 41 lines · Ingo Molnar
Quoted 27 lines · Tom Lendacky
Create a new function attribute,
__nostackp, that can used to turn off stack protection on a per function basis.Signed-off-by Tom Lendacky <[email protected]>--- include/linux/compiler-gcc.h | 2 ++ include/linux/compiler.h | 4 ++++ 2 files changed, 6 insertions(+)include/linux/compiler-gcc.h +2
-0@@ -166,6 +166,8 @@#if GCC_VERSION >=40100 # define __compiletime_object_size (obj) __builtin_object_size(obj, 0) + +#define __nostackp __attribute__((__optimize__("no-stack-protector")))#endif #if GCC_VERSION >=40300 include/linux/compiler.h +0
-0include/linux/compiler.h static __always_inline void __write_once_size(volatile void *p, void *res, int s · line 475
Quoted 6 lines
include/linux/compiler.h +3
-0@@ -470,6 +470,10 @@ static __always_inline void __write_once_size(volatile void *p, void *res, int s#define __visible#endif +#ifndef __nostackp +#define __nostackp +#endif So I changed this from the hard to read and ambiguous "
__nostackp" abbreviation (does it mean 'no stack pointer?') to "__nostackprotector", plus added this detail to the changelog:
Quoted 5 lines
| ( This is needed by the SME in-place kernel memory encryption feature, | which activates encryption in its sme_enable() function and thus changes the | visible value of the stack protection cookie on function return. )Agreed?
Hi Ingo,
I debugged this to needing "__nostackprotector" because sme_enable() is called very early in the boot process before everything is properly setup to fully support stack protection when KASLR is enabled. Without this attribute the call to sme_enable() would fail even if encryption was disabled with the "mem_encrypt=off" command line option.
If KASLR wasn't enabled, then everything worked fine without the "__nostackprotector" attribute, encryption enabled or not.
The stack protection support is activated because of the 16-byte character buffer in the sme_enable() routine. I think we'll find that if a character buffer greater than 8 bytes is added to, for example, __startup_64, then this attribute will need to be added to that routine.
Thanks,
Tom
Quoted 5 lines
Thanks,
Ingo
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
tip-bot for Tom Lendacky
merge bot[tip:x86/mm] compiler-gcc.h: Introduce __nostackprotector function attribute
In reply to Tom Lendackycompiler-gcc.h: Introduce __nostackprotector function attribute
Commit-ID: f11988d59f8e1e6f0941e94bd634911f648622ca Gitweb: http://git.kernel.org/tip/f11988d59f8e1e6f0941e94bd634911f648622ca Author: Tom Lendacky <[email protected]> AuthorDate: Mon, 17 Jul 2017 16:10:34 -0500 Committer: Ingo Molnar <[email protected]> CommitDate: Tue, 18 Jul 2017 11:38:06 +0200
compiler-gcc.h: Introduce __nostackprotector function attribute
Create a new function attribute, __nostackprotector, that can used to turn off stack protection on a per function basis.
( This is needed by the SME in-place kernel memory encryption feature,
which activates encryption and thus changes the value of the stack protection cookie on function return. )
--- include/linux/compiler-gcc.h | 2 ++ include/linux/compiler.h | 4 ++++ 2 files changed, 6 insertions(+)
include/linux/compiler-gcc.h +2 -0
@@ -166,6 +166,8 @@#if GCC_VERSION >=40100 # define __compiletime_object_size (obj) __builtin_object_size(obj, 0) + +#define __nostackprotector __attribute__((__optimize__("no-stack-protector")))#endif #if GCC_VERSION >=40300
include/linux/compiler.h +4 -0
@@ -470,6 +470,10 @@ static __always_inline void __write_once_size(volatile void *p, void *res, int s#define __visible#endif +#ifndef __nostackprotector +# define __nostackprotector +#endif +/* * Assume alignment of return value. */
tip-bot for Tom Lendacky
merge bot[tip:x86/mm] compiler-gcc.h: Introduce __nostackprotector function attribute
In reply to Tom Lendackycompiler-gcc.h: Introduce __nostackprotector function attribute
Commit-ID: 7375ae3a0b79ea072f4c672039f08f5db633b9e1 Gitweb: http://git.kernel.org/tip/7375ae3a0b79ea072f4c672039f08f5db633b9e1 Author: Tom Lendacky <[email protected]> AuthorDate: Mon, 17 Jul 2017 16:10:34 -0500 Committer: Ingo Molnar <[email protected]> CommitDate: Tue, 18 Jul 2017 20:23:20 +0200
compiler-gcc.h: Introduce __nostackprotector function attribute
Create a new function attribute, __nostackprotector, that can used to turn off stack protection on a per function basis.
--- include/linux/compiler-gcc.h | 2 ++ include/linux/compiler.h | 4 ++++ 2 files changed, 6 insertions(+)
include/linux/compiler-gcc.h +2 -0
@@ -166,6 +166,8 @@#if GCC_VERSION >=40100 # define __compiletime_object_size (obj) __builtin_object_size(obj, 0) + +#define __nostackprotector __attribute__((__optimize__("no-stack-protector")))#endif #if GCC_VERSION >=40300
include/linux/compiler.h +4 -0
@@ -470,6 +470,10 @@ static __always_inline void __write_once_size(volatile void *p, void *res, int s#define __visible#endif +#ifndef __nostackprotector +# define __nostackprotector +#endif +/* * Assume alignment of return value. */
PATCH v10 38/38 x86/mm: Add support to make use of Secure Memory Encryption
In reply to Tom LendackyAdd support to check if SME has been enabled and if memory encryption should be activated (checking of command line option based on the configuration of the default state). If memory encryption is to be activated, then the encryption mask is set and the kernel is encrypted "in place."
--- arch/x86/include/asm/mem_encrypt.h | 6 ++- arch/x86/kernel/head64.c | 5 ++- arch/x86/mm/mem_encrypt.c | 77 +++++++++++++++++++++++++++++++++++++- 3 files changed, 83 insertions(+), 5 deletions(-)
arch/x86/include/asm/mem_encrypt.h +4 -2
@@ -17,6 +17,8 @@#include <linux/init.h> +#include <asm/bootparam.h> +#ifdef CONFIG_AMD_MEM_ENCRYPT extern unsigned long sme_me_mask;
@@ -38,7 +40,7 @@ void __init sme_early_decrypt(resource_size_t paddr,void __init sme_early_init (void );void __init sme_encrypt_kernel (void ); -void __init sme_enable (void ); +void __init sme_enable (struct boot_params *bp);/* Architecture __weak replacement functions */ void __init mem_encrypt_init (void );
@@ -60,7 +62,7 @@ static inline void __init sme_unmap_bootdata(char *real_mode_data) { }static inline void __init sme_early_init (void ) { }static inline void __init sme_encrypt_kernel (void ) { } -static inline void __init sme_enable (void ) { } +static inline void __init sme_enable (struct boot_params *bp) { }#endif /* CONFIG_AMD_MEM_ENCRYPT */
arch/x86/kernel/head64.c +3 -2
@@ -45,7 +45,8 @@ static void __head *fixup_pointer(void *ptr, unsigned long physaddr)return ptr - (void *)_text + (void *)physaddr; } -unsigned long __head __startup_64 (unsigned long physaddr) +unsigned long __head __startup_64 (unsigned long physaddr, +struct boot_params *bp) {unsigned long load_delta, *p;unsigned long pgtable_flags;
@@ -70,7 +71,7 @@ unsigned long __head __startup_64(unsigned long physaddr)for (;;);/* Activate Secure Memory Encryption (SME) if supported and enabled */ -sme_enable (); +sme_enable (bp);/* Include the SME encryption mask in the fixup value */ load_delta +=sme_get_me_mask ();
arch/x86/mm/mem_encrypt.c +76 -1
100 lines not on this page · raw message
Signature · 7 lines
1.9.1 -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
tip-bot for Tom Lendacky
merge bot[tip:x86/mm] x86/mm: Add support to make use of Secure Memory Encryption
x86/mm: Add support to make use of Secure Memory Encryption
Commit-ID: 99192ce65da54280d2137655706d280b6913bee9 Gitweb: http://git.kernel.org/tip/99192ce65da54280d2137655706d280b6913bee9 Author: Tom Lendacky <[email protected]> AuthorDate: Mon, 17 Jul 2017 16:10:35 -0500 Committer: Ingo Molnar <[email protected]> CommitDate: Tue, 18 Jul 2017 11:48:16 +0200
x86/mm: Add support to make use of Secure Memory Encryption
Add support to check if SME has been enabled and if memory encryption should be activated (checking of command line option based on the configuration of the default state). If memory encryption is to be activated, then the encryption mask is set and the kernel is encrypted "in place."
--- arch/x86/include/asm/mem_encrypt.h | 6 ++- arch/x86/kernel/head64.c | 5 ++- arch/x86/mm/mem_encrypt.c | 77 +++++++++++++++++++++++++++++++++++++- 3 files changed, 83 insertions(+), 5 deletions(-)
arch/x86/include/asm/mem_encrypt.h +4 -2
@@ -17,6 +17,8 @@#include <linux/init.h> +#include <asm/bootparam.h> +#ifdef CONFIG_AMD_MEM_ENCRYPT extern unsigned long sme_me_mask;
@@ -38,7 +40,7 @@ void __init sme_unmap_bootdata(char *real_mode_data);void __init sme_early_init (void );void __init sme_encrypt_kernel (void ); -void __init sme_enable (void ); +void __init sme_enable (struct boot_params *bp);/* Architecture __weak replacement functions */ void __init mem_encrypt_init (void );
@@ -60,7 +62,7 @@ static inline void __init sme_unmap_bootdata(char *real_mode_data) { }static inline void __init sme_early_init (void ) { }static inline void __init sme_encrypt_kernel (void ) { } -static inline void __init sme_enable (void ) { } +static inline void __init sme_enable (struct boot_params *bp) { }#endif /* CONFIG_AMD_MEM_ENCRYPT */
arch/x86/kernel/head64.c +3 -2
@@ -45,7 +45,8 @@ static void __head *fixup_pointer(void *ptr, unsigned long physaddr)return ptr - (void *)_text + (void *)physaddr; } -unsigned long __head __startup_64 (unsigned long physaddr) +unsigned long __head __startup_64 (unsigned long physaddr, +struct boot_params *bp) {unsigned long load_delta, *p;unsigned long pgtable_flags;
@@ -70,7 +71,7 @@ unsigned long __head __startup_64(unsigned long physaddr)for (;;);/* Activate Secure Memory Encryption (SME) if supported and enabled */ -sme_enable (); +sme_enable (bp);/* Include the SME encryption mask in the fixup value */ load_delta +=sme_get_me_mask ();
arch/x86/mm/mem_encrypt.c +76 -1
100 lines not on this page · raw message
tip-bot for Tom Lendacky
merge bot[tip:x86/mm] x86/mm: Add support to make use of Secure Memory Encryption
In reply to Tom Lendackyx86/mm: Add support to make use of Secure Memory Encryption
Commit-ID: aca20d5462149333ba8b24a4a352be5b7a00dfd2 Gitweb: http://git.kernel.org/tip/aca20d5462149333ba8b24a4a352be5b7a00dfd2 Author: Tom Lendacky <[email protected]> AuthorDate: Mon, 17 Jul 2017 16:10:35 -0500 Committer: Ingo Molnar <[email protected]> CommitDate: Tue, 18 Jul 2017 20:23:26 +0200
x86/mm: Add support to make use of Secure Memory Encryption
Add support to check if SME has been enabled and if memory encryption should be activated (checking of command line option based on the configuration of the default state). If memory encryption is to be activated, then the encryption mask is set and the kernel is encrypted "in place."
--- arch/x86/include/asm/mem_encrypt.h | 6 ++- arch/x86/kernel/head64.c | 5 ++- arch/x86/mm/mem_encrypt.c | 77 +++++++++++++++++++++++++++++++++++++- 3 files changed, 83 insertions(+), 5 deletions(-)
arch/x86/include/asm/mem_encrypt.h +4 -2
@@ -17,6 +17,8 @@#include <linux/init.h> +#include <asm/bootparam.h> +#ifdef CONFIG_AMD_MEM_ENCRYPT extern unsigned long sme_me_mask;
@@ -38,7 +40,7 @@ void __init sme_unmap_bootdata(char *real_mode_data);void __init sme_early_init (void );void __init sme_encrypt_kernel (void ); -void __init sme_enable (void ); +void __init sme_enable (struct boot_params *bp);/* Architecture __weak replacement functions */ void __init mem_encrypt_init (void );
@@ -60,7 +62,7 @@ static inline void __init sme_unmap_bootdata(char *real_mode_data) { }static inline void __init sme_early_init (void ) { }static inline void __init sme_encrypt_kernel (void ) { } -static inline void __init sme_enable (void ) { } +static inline void __init sme_enable (struct boot_params *bp) { }#endif /* CONFIG_AMD_MEM_ENCRYPT */
arch/x86/kernel/head64.c +3 -2
@@ -45,7 +45,8 @@ static void __head *fixup_pointer(void *ptr, unsigned long physaddr)return ptr - (void *)_text + (void *)physaddr; } -unsigned long __head __startup_64 (unsigned long physaddr) +unsigned long __head __startup_64 (unsigned long physaddr, +struct boot_params *bp) {unsigned long load_delta, *p;unsigned long pgtable_flags;
@@ -70,7 +71,7 @@ unsigned long __head __startup_64(unsigned long physaddr)for (;;);/* Activate Secure Memory Encryption (SME) if supported and enabled */ -sme_enable (); +sme_enable (bp);/* Include the SME encryption mask in the fixup value */ load_delta +=sme_get_me_mask ();
arch/x86/mm/mem_encrypt.c +76 -1
100 lines not on this page · raw message
Quoted 24 lines · Tom Lendacky
This patch series provides support for AMD's new Secure Memory Encryption (SME) feature.
SME can be used to mark individual pages of memory as encrypted through the page tables. A page of memory that is marked encrypted will be automatically decrypted when read from DRAM and will be automatically encrypted when written to DRAM. Details on SME can found in the links below.
The SME feature is identified through a CPUID function and enabled through the SYSCFG MSR. Once enabled, page table entries will determine how the memory is accessed. If a page table entry has the memory encryption mask set, then that memory will be accessed as encrypted memory. The memory encryption mask (as well as other related information) is determined from settings returned through the same CPUID function that identifies the presence of the feature.
The approach that this patch series takes is to encrypt everything possible starting early in the boot where the kernel is encrypted. Using the page table macros the encryption mask can be incorporated into all page table entries and page allocations. By updating the protection map, userspace allocations are also marked encrypted. Certain data must be accounted for as having been placed in memory before SME was enabled (EFI, initrd, etc.) and accessed accordingly.
Quoted 4 lines
This patch series is a pre-cursor to another AMD processor feature called Secure Encrypted Virtualization (SEV). The support for SEV will build upon the SME support and will be submitted later. Details on SEV can be found in the links below.
Well done series. Thanks to all people involved, especially Tom and Boris! It was a pleasure to review that.
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Quoted 30 lines · Thomas Gleixner
Quoted 24 lines · Tom Lendacky
This patch series provides support for AMD's new Secure Memory Encryption (SME) feature.
SME can be used to mark individual pages of memory as encrypted through the page tables. A page of memory that is marked encrypted will be automatically decrypted when read from DRAM and will be automatically encrypted when written to DRAM. Details on SME can found in the links below.
The SME feature is identified through a CPUID function and enabled through the SYSCFG MSR. Once enabled, page table entries will determine how the memory is accessed. If a page table entry has the memory encryption mask set, then that memory will be accessed as encrypted memory. The memory encryption mask (as well as other related information) is determined from settings returned through the same CPUID function that identifies the presence of the feature.
The approach that this patch series takes is to encrypt everything possible starting early in the boot where the kernel is encrypted. Using the page table macros the encryption mask can be incorporated into all page table entries and page allocations. By updating the protection map, userspace allocations are also marked encrypted. Certain data must be accounted for as having been placed in memory before SME was enabled (EFI, initrd, etc.) and accessed accordingly.
Quoted 4 lines
This patch series is a pre-cursor to another AMD processor feature called Secure Encrypted Virtualization (SEV). The support for SEV will build upon the SME support and will be submitted later. Details on SEV can be found in the links below.
Quoted 4 lines
Well done series. Thanks to all people involved, especially Tom and Boris! It was a pleasure to review that.
Reviewed-by Thomas Gleixner <[email protected]>
A big thanks from me to everyone that helped review this. I truly appreciate all the time that everyone put into this - especially Boris, who helped guide this series from the start.
Thanks,
Tom
Quoted 1 line
Quoted 30 lines · Thomas Gleixner
Quoted 24 lines · Tom Lendacky
This patch series provides support for AMD's new Secure Memory Encryption (SME) feature.
SME can be used to mark individual pages of memory as encrypted through the page tables. A page of memory that is marked encrypted will be automatically decrypted when read from DRAM and will be automatically encrypted when written to DRAM. Details on SME can found in the links below.
The SME feature is identified through a CPUID function and enabled through the SYSCFG MSR. Once enabled, page table entries will determine how the memory is accessed. If a page table entry has the memory encryption mask set, then that memory will be accessed as encrypted memory. The memory encryption mask (as well as other related information) is determined from settings returned through the same CPUID function that identifies the presence of the feature.
The approach that this patch series takes is to encrypt everything possible starting early in the boot where the kernel is encrypted. Using the page table macros the encryption mask can be incorporated into all page table entries and page allocations. By updating the protection map, userspace allocations are also marked encrypted. Certain data must be accounted for as having been placed in memory before SME was enabled (EFI, initrd, etc.) and accessed accordingly.
Quoted 4 lines
This patch series is a pre-cursor to another AMD processor feature called Secure Encrypted Virtualization (SEV). The support for SEV will build upon the SME support and will be submitted later. Details on SEV can be found in the links below.
Quoted 4 lines
Well done series. Thanks to all people involved, especially Tom and Boris! It was a pleasure to review that.
Reviewed-by Thomas Gleixner <[email protected]>
A big thanks from me to everyone that helped review this. I truly appreciate all the time that everyone put into this - especially Boris, who helped guide this series from the start.
Thanks,
Tom
Quoted 1 line
_______________________________________________
Xen-devel mailing list
[email protected]
https://lists.xen.org/xen-devel
Quoted 24 lines · Tom Lendacky
This patch series provides support for AMD's new Secure Memory Encryption (SME) feature.
SME can be used to mark individual pages of memory as encrypted through the page tables. A page of memory that is marked encrypted will be automatically decrypted when read from DRAM and will be automatically encrypted when written to DRAM. Details on SME can found in the links below.
The SME feature is identified through a CPUID function and enabled through the SYSCFG MSR. Once enabled, page table entries will determine how the memory is accessed. If a page table entry has the memory encryption mask set, then that memory will be accessed as encrypted memory. The memory encryption mask (as well as other related information) is determined from settings returned through the same CPUID function that identifies the presence of the feature.
The approach that this patch series takes is to encrypt everything possible starting early in the boot where the kernel is encrypted. Using the page table macros the encryption mask can be incorporated into all page table entries and page allocations. By updating the protection map, userspace allocations are also marked encrypted. Certain data must be accounted for as having been placed in memory before SME was enabled (EFI, initrd, etc.) and accessed accordingly.
Quoted 4 lines
This patch series is a pre-cursor to another AMD processor feature called Secure Encrypted Virtualization (SEV). The support for SEV will build upon the SME support and will be submitted later. Details on SEV can be found in the links below.
Well done series. Thanks to all people involved, especially Tom and Boris! It was a pleasure to review that.
_______________________________________________
Xen-devel mailing list
[email protected]
https://lists.xen.org/xen-devel