x86/boot/compressed/64: Add set_page_en/decrypted() helpers

The functions are needed to map the GHCB for SEV-ES guests. The GHCB
is used for communication with the hypervisor, so its content must not
be encrypted. After the GHCB is not needed anymore it must be mapped
encrypted again so that the running kernel image can safely re-use the
memory.

Signed-off-by: Joerg Roedel <jroedel@suse.de>
Signed-off-by: Borislav Petkov <bp@suse.de>
Link: https://lkml.kernel.org/r/20200907131613.12703-23-joro@8bytes.org

diff --git a/arch/x86/boot/compressed/ident_map_64.c b/arch/x86/boot/compressed/ident_map_64.c
index aa91bebc0fe978e2398878255b126ecc2fd4a975..05742f641a0625826e1a7f9453cd73868cb39456 100644 (file)
--- a/arch/x86/boot/compressed/ident_map_64.c
+++ b/arch/x86/boot/compressed/ident_map_64.c
@@ -24,6 +24,7 @@
 
 /* These actually do the work of building the kernel identity maps. */
 #include <linux/pgtable.h>
+#include <asm/cmpxchg.h>
 #include <asm/trap_pf.h>
 #include <asm/trapnr.h>
 #include <asm/init.h>
@@ -165,6 +166,138 @@ void finalize_identity_maps(void)
        write_cr3(top_level_pgt);
 }
 
+static pte_t *split_large_pmd(struct x86_mapping_info *info,
+                             pmd_t *pmdp, unsigned long __address)
+{
+       unsigned long page_flags;
+       unsigned long address;
+       pte_t *pte;
+       pmd_t pmd;
+       int i;
+
+       pte = (pte_t *)info->alloc_pgt_page(info->context);
+       if (!pte)
+               return NULL;
+
+       address     = __address & PMD_MASK;
+       /* No large page - clear PSE flag */
+       page_flags  = info->page_flag & ~_PAGE_PSE;
+
+       /* Populate the PTEs */
+       for (i = 0; i < PTRS_PER_PMD; i++) {
+               set_pte(&pte[i], __pte(address | page_flags));
+               address += PAGE_SIZE;
+       }
+
+       /*
+        * Ideally we need to clear the large PMD first and do a TLB
+        * flush before we write the new PMD. But the 2M range of the
+        * PMD might contain the code we execute and/or the stack
+        * we are on, so we can't do that. But that should be safe here
+        * because we are going from large to small mappings and we are
+        * also the only user of the page-table, so there is no chance
+        * of a TLB multihit.
+        */
+       pmd = __pmd((unsigned long)pte | info->kernpg_flag);
+       set_pmd(pmdp, pmd);
+       /* Flush TLB to establish the new PMD */
+       write_cr3(top_level_pgt);
+
+       return pte + pte_index(__address);
+}
+
+static void clflush_page(unsigned long address)
+{
+       unsigned int flush_size;
+       char *cl, *start, *end;
+
+       /*
+        * Hardcode cl-size to 64 - CPUID can't be used here because that might
+        * cause another #VC exception and the GHCB is not ready to use yet.
+        */
+       flush_size = 64;
+       start      = (char *)(address & PAGE_MASK);
+       end        = start + PAGE_SIZE;
+
+       /*
+        * First make sure there are no pending writes on the cache-lines to
+        * flush.
+        */
+       asm volatile("mfence" : : : "memory");
+
+       for (cl = start; cl != end; cl += flush_size)
+               clflush(cl);
+}
+
+static int set_clr_page_flags(struct x86_mapping_info *info,
+                             unsigned long address,
+                             pteval_t set, pteval_t clr)
+{
+       pgd_t *pgdp = (pgd_t *)top_level_pgt;
+       p4d_t *p4dp;
+       pud_t *pudp;
+       pmd_t *pmdp;
+       pte_t *ptep, pte;
+
+       /*
+        * First make sure there is a PMD mapping for 'address'.
+        * It should already exist, but keep things generic.
+        *
+        * To map the page just read from it and fault it in if there is no
+        * mapping yet. add_identity_map() can't be called here because that
+        * would unconditionally map the address on PMD level, destroying any
+        * PTE-level mappings that might already exist. Use assembly here so
+        * the access won't be optimized away.
+        */
+       asm volatile("mov %[address], %%r9"
+                    :: [address] "g" (*(unsigned long *)address)
+                    : "r9", "memory");
+
+       /*
+        * The page is mapped at least with PMD size - so skip checks and walk
+        * directly to the PMD.
+        */
+       p4dp = p4d_offset(pgdp, address);
+       pudp = pud_offset(p4dp, address);
+       pmdp = pmd_offset(pudp, address);
+
+       if (pmd_large(*pmdp))
+               ptep = split_large_pmd(info, pmdp, address);
+       else
+               ptep = pte_offset_kernel(pmdp, address);
+
+       if (!ptep)
+               return -ENOMEM;
+
+       /*
+        * Changing encryption attributes of a page requires to flush it from
+        * the caches.
+        */
+       if ((set | clr) & _PAGE_ENC)
+               clflush_page(address);
+
+       /* Update PTE */
+       pte = *ptep;
+       pte = pte_set_flags(pte, set);
+       pte = pte_clear_flags(pte, clr);
+       set_pte(ptep, pte);
+
+       /* Flush TLB after changing encryption attribute */
+       write_cr3(top_level_pgt);
+
+       return 0;
+}
+
+int set_page_decrypted(unsigned long address)
+{
+       return set_clr_page_flags(&mapping_info, address, 0, _PAGE_ENC);
+}
+
+int set_page_encrypted(unsigned long address)
+{
+       return set_clr_page_flags(&mapping_info, address, _PAGE_ENC, 0);
+}
+
 static void do_pf_error(const char *msg, unsigned long error_code,
                        unsigned long address, unsigned long ip)
 {

diff --git a/arch/x86/boot/compressed/misc.h b/arch/x86/boot/compressed/misc.h
index eaa8b45ebccbc952f58c511f410ea609f555ba32..01c0fb3417ca7242663dd1af3b3053de26f40c6b 100644 (file)
--- a/arch/x86/boot/compressed/misc.h
+++ b/arch/x86/boot/compressed/misc.h
@@ -98,6 +98,8 @@ static inline void choose_random_location(unsigned long input,
 #endif
 
 #ifdef CONFIG_X86_64
+extern int set_page_decrypted(unsigned long address);
+extern int set_page_encrypted(unsigned long address);
 extern unsigned char _pgtable[];
 #endif