arch/x86/boot/compressed/sev.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * AMD Encrypted Register State Support
   4  *
   5  * Author: Joerg Roedel <jroedel@suse.de>
   6  */
   7
   8 /*
   9  * misc.h needs to be first because it knows how to include the other kernel
  10  * headers in the pre-decompression code in a way that does not break
  11  * compilation.
  12  */
  13 #include "misc.h"
  14
  15 #include <asm/pgtable_types.h>
  16 #include <asm/sev.h>
  17 #include <asm/trapnr.h>
  18 #include <asm/trap_pf.h>
  19 #include <asm/msr-index.h>
  20 #include <asm/fpu/xcr.h>
  21 #include <asm/ptrace.h>
  22 #include <asm/svm.h>
  23
  24 #include "error.h"
  25
  26 struct ghcb boot_ghcb_page __aligned(PAGE_SIZE);
  27 struct ghcb *boot_ghcb;
  28
  29 /*
  30  * Copy a version of this function here - insn-eval.c can't be used in
  31  * pre-decompression code.
  32  */
  33 static bool insn_has_rep_prefix(struct insn *insn)
  34 {
  35         insn_byte_t p;
  36         int i;
  37
  38         insn_get_prefixes(insn);
  39
  40         for_each_insn_prefix(insn, i, p) {
  41                 if (p == 0xf2 || p == 0xf3)
  42                         return true;
  43         }
  44
  45         return false;
  46 }
  47
  48 /*
  49  * Only a dummy for insn_get_seg_base() - Early boot-code is 64bit only and
  50  * doesn't use segments.
  51  */
  52 static unsigned long insn_get_seg_base(struct pt_regs *regs, int seg_reg_idx)
  53 {
  54         return 0UL;
  55 }
  56
  57 static inline u64 sev_es_rd_ghcb_msr(void)
  58 {
  59         unsigned long low, high;
  60
  61         asm volatile("rdmsr" : "=a" (low), "=d" (high) :
  62                         "c" (MSR_AMD64_SEV_ES_GHCB));
  63
  64         return ((high << 32) | low);
  65 }
  66
  67 static inline void sev_es_wr_ghcb_msr(u64 val)
  68 {
  69         u32 low, high;
  70
  71         low  = val & 0xffffffffUL;
  72         high = val >> 32;
  73
  74         asm volatile("wrmsr" : : "c" (MSR_AMD64_SEV_ES_GHCB),
  75                         "a"(low), "d" (high) : "memory");
  76 }
  77
  78 static enum es_result vc_decode_insn(struct es_em_ctxt *ctxt)
  79 {
  80         char buffer[MAX_INSN_SIZE];
  81         int ret;
  82
  83         memcpy(buffer, (unsigned char *)ctxt->regs->ip, MAX_INSN_SIZE);
  84
  85         ret = insn_decode(&ctxt->insn, buffer, MAX_INSN_SIZE, INSN_MODE_64);
  86         if (ret < 0)
  87                 return ES_DECODE_FAILED;
  88
  89         return ES_OK;
  90 }
  91
  92 static enum es_result vc_write_mem(struct es_em_ctxt *ctxt,
  93                                    void *dst, char *buf, size_t size)
  94 {
  95         memcpy(dst, buf, size);
  96
  97         return ES_OK;
  98 }
  99
 100 static enum es_result vc_read_mem(struct es_em_ctxt *ctxt,
 101                                   void *src, char *buf, size_t size)
 102 {
 103         memcpy(buf, src, size);
 104
 105         return ES_OK;
 106 }
 107
 108 static enum es_result vc_ioio_check(struct es_em_ctxt *ctxt, u16 port, size_t size)
 109 {
 110         return ES_OK;
 111 }
 112
 113 static bool fault_in_kernel_space(unsigned long address)
 114 {
 115         return false;
 116 }
 117
 118 #undef __init
 119 #undef __pa
 120 #define __init
 121 #define __pa(x) ((unsigned long)(x))
 122
 123 #define __BOOT_COMPRESSED
 124
 125 /* Basic instruction decoding support needed */
 126 #include "../../lib/inat.c"
 127 #include "../../lib/insn.c"
 128
 129 /* Include code for early handlers */
 130 #include "../../kernel/sev-shared.c"
 131
 132 static bool early_setup_sev_es(void)
 133 {
 134         if (!sev_es_negotiate_protocol())
 135                 sev_es_terminate(GHCB_SEV_ES_REASON_PROTOCOL_UNSUPPORTED);
 136
 137         if (set_page_decrypted((unsigned long)&boot_ghcb_page))
 138                 return false;
 139
 140         /* Page is now mapped decrypted, clear it */
 141         memset(&boot_ghcb_page, 0, sizeof(boot_ghcb_page));
 142
 143         boot_ghcb = &boot_ghcb_page;
 144
 145         /* Initialize lookup tables for the instruction decoder */
 146         inat_init_tables();
 147
 148         return true;
 149 }
 150
 151 void sev_es_shutdown_ghcb(void)
 152 {
 153         if (!boot_ghcb)
 154                 return;
 155
 156         if (!sev_es_check_cpu_features())
 157                 error("SEV-ES CPU Features missing.");
 158
 159         /*
 160          * GHCB Page must be flushed from the cache and mapped encrypted again.
 161          * Otherwise the running kernel will see strange cache effects when
 162          * trying to use that page.
 163          */
 164         if (set_page_encrypted((unsigned long)&boot_ghcb_page))
 165                 error("Can't map GHCB page encrypted");
 166
 167         /*
 168          * GHCB page is mapped encrypted again and flushed from the cache.
 169          * Mark it non-present now to catch bugs when #VC exceptions trigger
 170          * after this point.
 171          */
 172         if (set_page_non_present((unsigned long)&boot_ghcb_page))
 173                 error("Can't unmap GHCB page");
 174 }
 175
 176 bool sev_es_check_ghcb_fault(unsigned long address)
 177 {
 178         /* Check whether the fault was on the GHCB page */
 179         return ((address & PAGE_MASK) == (unsigned long)&boot_ghcb_page);
 180 }
 181
 182 void do_boot_stage2_vc(struct pt_regs *regs, unsigned long exit_code)
 183 {
 184         struct es_em_ctxt ctxt;
 185         enum es_result result;
 186
 187         if (!boot_ghcb && !early_setup_sev_es())
 188                 sev_es_terminate(GHCB_SEV_ES_REASON_GENERAL_REQUEST);
 189
 190         vc_ghcb_invalidate(boot_ghcb);
 191         result = vc_init_em_ctxt(&ctxt, regs, exit_code);
 192         if (result != ES_OK)
 193                 goto finish;
 194
 195         switch (exit_code) {
 196         case SVM_EXIT_RDTSC:
 197         case SVM_EXIT_RDTSCP:
 198                 result = vc_handle_rdtsc(boot_ghcb, &ctxt, exit_code);
 199                 break;
 200         case SVM_EXIT_IOIO:
 201                 result = vc_handle_ioio(boot_ghcb, &ctxt);
 202                 break;
 203         case SVM_EXIT_CPUID:
 204                 result = vc_handle_cpuid(boot_ghcb, &ctxt);
 205                 break;
 206         default:
 207                 result = ES_UNSUPPORTED;
 208                 break;
 209         }
 210
 211 finish:
 212         if (result == ES_OK)
 213                 vc_finish_insn(&ctxt);
 214         else if (result != ES_RETRY)
 215                 sev_es_terminate(GHCB_SEV_ES_REASON_GENERAL_REQUEST);
 216 }