]> Git Repo - linux.git/blob - arch/x86/boot/compressed/sev.c
Linux 6.14-rc3
[linux.git] / 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 <[email protected]>
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/bootparam.h>
16 #include <asm/pgtable_types.h>
17 #include <asm/sev.h>
18 #include <asm/trapnr.h>
19 #include <asm/trap_pf.h>
20 #include <asm/msr-index.h>
21 #include <asm/fpu/xcr.h>
22 #include <asm/ptrace.h>
23 #include <asm/svm.h>
24 #include <asm/cpuid.h>
25
26 #include "error.h"
27 #include "../msr.h"
28
29 static struct ghcb boot_ghcb_page __aligned(PAGE_SIZE);
30 struct ghcb *boot_ghcb;
31
32 /*
33  * Copy a version of this function here - insn-eval.c can't be used in
34  * pre-decompression code.
35  */
36 static bool insn_has_rep_prefix(struct insn *insn)
37 {
38         insn_byte_t p;
39         int i;
40
41         insn_get_prefixes(insn);
42
43         for_each_insn_prefix(insn, i, p) {
44                 if (p == 0xf2 || p == 0xf3)
45                         return true;
46         }
47
48         return false;
49 }
50
51 /*
52  * Only a dummy for insn_get_seg_base() - Early boot-code is 64bit only and
53  * doesn't use segments.
54  */
55 static unsigned long insn_get_seg_base(struct pt_regs *regs, int seg_reg_idx)
56 {
57         return 0UL;
58 }
59
60 static inline u64 sev_es_rd_ghcb_msr(void)
61 {
62         struct msr m;
63
64         boot_rdmsr(MSR_AMD64_SEV_ES_GHCB, &m);
65
66         return m.q;
67 }
68
69 static inline void sev_es_wr_ghcb_msr(u64 val)
70 {
71         struct msr m;
72
73         m.q = val;
74         boot_wrmsr(MSR_AMD64_SEV_ES_GHCB, &m);
75 }
76
77 static enum es_result vc_decode_insn(struct es_em_ctxt *ctxt)
78 {
79         char buffer[MAX_INSN_SIZE];
80         int ret;
81
82         memcpy(buffer, (unsigned char *)ctxt->regs->ip, MAX_INSN_SIZE);
83
84         ret = insn_decode(&ctxt->insn, buffer, MAX_INSN_SIZE, INSN_MODE_64);
85         if (ret < 0)
86                 return ES_DECODE_FAILED;
87
88         return ES_OK;
89 }
90
91 static enum es_result vc_write_mem(struct es_em_ctxt *ctxt,
92                                    void *dst, char *buf, size_t size)
93 {
94         memcpy(dst, buf, size);
95
96         return ES_OK;
97 }
98
99 static enum es_result vc_read_mem(struct es_em_ctxt *ctxt,
100                                   void *src, char *buf, size_t size)
101 {
102         memcpy(buf, src, size);
103
104         return ES_OK;
105 }
106
107 static enum es_result vc_ioio_check(struct es_em_ctxt *ctxt, u16 port, size_t size)
108 {
109         return ES_OK;
110 }
111
112 static bool fault_in_kernel_space(unsigned long address)
113 {
114         return false;
115 }
116
117 #undef __init
118 #define __init
119
120 #undef __head
121 #define __head
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 "../../coco/sev/shared.c"
131
132 static struct svsm_ca *svsm_get_caa(void)
133 {
134         return boot_svsm_caa;
135 }
136
137 static u64 svsm_get_caa_pa(void)
138 {
139         return boot_svsm_caa_pa;
140 }
141
142 static int svsm_perform_call_protocol(struct svsm_call *call)
143 {
144         struct ghcb *ghcb;
145         int ret;
146
147         if (boot_ghcb)
148                 ghcb = boot_ghcb;
149         else
150                 ghcb = NULL;
151
152         do {
153                 ret = ghcb ? svsm_perform_ghcb_protocol(ghcb, call)
154                            : svsm_perform_msr_protocol(call);
155         } while (ret == -EAGAIN);
156
157         return ret;
158 }
159
160 bool sev_snp_enabled(void)
161 {
162         return sev_status & MSR_AMD64_SEV_SNP_ENABLED;
163 }
164
165 static void __page_state_change(unsigned long paddr, enum psc_op op)
166 {
167         u64 val;
168
169         if (!sev_snp_enabled())
170                 return;
171
172         /*
173          * If private -> shared then invalidate the page before requesting the
174          * state change in the RMP table.
175          */
176         if (op == SNP_PAGE_STATE_SHARED)
177                 pvalidate_4k_page(paddr, paddr, false);
178
179         /* Issue VMGEXIT to change the page state in RMP table. */
180         sev_es_wr_ghcb_msr(GHCB_MSR_PSC_REQ_GFN(paddr >> PAGE_SHIFT, op));
181         VMGEXIT();
182
183         /* Read the response of the VMGEXIT. */
184         val = sev_es_rd_ghcb_msr();
185         if ((GHCB_RESP_CODE(val) != GHCB_MSR_PSC_RESP) || GHCB_MSR_PSC_RESP_VAL(val))
186                 sev_es_terminate(SEV_TERM_SET_LINUX, GHCB_TERM_PSC);
187
188         /*
189          * Now that page state is changed in the RMP table, validate it so that it is
190          * consistent with the RMP entry.
191          */
192         if (op == SNP_PAGE_STATE_PRIVATE)
193                 pvalidate_4k_page(paddr, paddr, true);
194 }
195
196 void snp_set_page_private(unsigned long paddr)
197 {
198         __page_state_change(paddr, SNP_PAGE_STATE_PRIVATE);
199 }
200
201 void snp_set_page_shared(unsigned long paddr)
202 {
203         __page_state_change(paddr, SNP_PAGE_STATE_SHARED);
204 }
205
206 static bool early_setup_ghcb(void)
207 {
208         if (set_page_decrypted((unsigned long)&boot_ghcb_page))
209                 return false;
210
211         /* Page is now mapped decrypted, clear it */
212         memset(&boot_ghcb_page, 0, sizeof(boot_ghcb_page));
213
214         boot_ghcb = &boot_ghcb_page;
215
216         /* Initialize lookup tables for the instruction decoder */
217         inat_init_tables();
218
219         /* SNP guest requires the GHCB GPA must be registered */
220         if (sev_snp_enabled())
221                 snp_register_ghcb_early(__pa(&boot_ghcb_page));
222
223         return true;
224 }
225
226 static phys_addr_t __snp_accept_memory(struct snp_psc_desc *desc,
227                                        phys_addr_t pa, phys_addr_t pa_end)
228 {
229         struct psc_hdr *hdr;
230         struct psc_entry *e;
231         unsigned int i;
232
233         hdr = &desc->hdr;
234         memset(hdr, 0, sizeof(*hdr));
235
236         e = desc->entries;
237
238         i = 0;
239         while (pa < pa_end && i < VMGEXIT_PSC_MAX_ENTRY) {
240                 hdr->end_entry = i;
241
242                 e->gfn = pa >> PAGE_SHIFT;
243                 e->operation = SNP_PAGE_STATE_PRIVATE;
244                 if (IS_ALIGNED(pa, PMD_SIZE) && (pa_end - pa) >= PMD_SIZE) {
245                         e->pagesize = RMP_PG_SIZE_2M;
246                         pa += PMD_SIZE;
247                 } else {
248                         e->pagesize = RMP_PG_SIZE_4K;
249                         pa += PAGE_SIZE;
250                 }
251
252                 e++;
253                 i++;
254         }
255
256         if (vmgexit_psc(boot_ghcb, desc))
257                 sev_es_terminate(SEV_TERM_SET_LINUX, GHCB_TERM_PSC);
258
259         pvalidate_pages(desc);
260
261         return pa;
262 }
263
264 void snp_accept_memory(phys_addr_t start, phys_addr_t end)
265 {
266         struct snp_psc_desc desc = {};
267         unsigned int i;
268         phys_addr_t pa;
269
270         if (!boot_ghcb && !early_setup_ghcb())
271                 sev_es_terminate(SEV_TERM_SET_LINUX, GHCB_TERM_PSC);
272
273         pa = start;
274         while (pa < end)
275                 pa = __snp_accept_memory(&desc, pa, end);
276 }
277
278 void sev_es_shutdown_ghcb(void)
279 {
280         if (!boot_ghcb)
281                 return;
282
283         if (!sev_es_check_cpu_features())
284                 error("SEV-ES CPU Features missing.");
285
286         /*
287          * This denotes whether to use the GHCB MSR protocol or the GHCB
288          * shared page to perform a GHCB request. Since the GHCB page is
289          * being changed to encrypted, it can't be used to perform GHCB
290          * requests. Clear the boot_ghcb variable so that the GHCB MSR
291          * protocol is used to change the GHCB page over to an encrypted
292          * page.
293          */
294         boot_ghcb = NULL;
295
296         /*
297          * GHCB Page must be flushed from the cache and mapped encrypted again.
298          * Otherwise the running kernel will see strange cache effects when
299          * trying to use that page.
300          */
301         if (set_page_encrypted((unsigned long)&boot_ghcb_page))
302                 error("Can't map GHCB page encrypted");
303
304         /*
305          * GHCB page is mapped encrypted again and flushed from the cache.
306          * Mark it non-present now to catch bugs when #VC exceptions trigger
307          * after this point.
308          */
309         if (set_page_non_present((unsigned long)&boot_ghcb_page))
310                 error("Can't unmap GHCB page");
311 }
312
313 static void __noreturn sev_es_ghcb_terminate(struct ghcb *ghcb, unsigned int set,
314                                              unsigned int reason, u64 exit_info_2)
315 {
316         u64 exit_info_1 = SVM_VMGEXIT_TERM_REASON(set, reason);
317
318         vc_ghcb_invalidate(ghcb);
319         ghcb_set_sw_exit_code(ghcb, SVM_VMGEXIT_TERM_REQUEST);
320         ghcb_set_sw_exit_info_1(ghcb, exit_info_1);
321         ghcb_set_sw_exit_info_2(ghcb, exit_info_2);
322
323         sev_es_wr_ghcb_msr(__pa(ghcb));
324         VMGEXIT();
325
326         while (true)
327                 asm volatile("hlt\n" : : : "memory");
328 }
329
330 bool sev_es_check_ghcb_fault(unsigned long address)
331 {
332         /* Check whether the fault was on the GHCB page */
333         return ((address & PAGE_MASK) == (unsigned long)&boot_ghcb_page);
334 }
335
336 void do_boot_stage2_vc(struct pt_regs *regs, unsigned long exit_code)
337 {
338         struct es_em_ctxt ctxt;
339         enum es_result result;
340
341         if (!boot_ghcb && !early_setup_ghcb())
342                 sev_es_terminate(SEV_TERM_SET_GEN, GHCB_SEV_ES_GEN_REQ);
343
344         vc_ghcb_invalidate(boot_ghcb);
345         result = vc_init_em_ctxt(&ctxt, regs, exit_code);
346         if (result != ES_OK)
347                 goto finish;
348
349         result = vc_check_opcode_bytes(&ctxt, exit_code);
350         if (result != ES_OK)
351                 goto finish;
352
353         switch (exit_code) {
354         case SVM_EXIT_RDTSC:
355         case SVM_EXIT_RDTSCP:
356                 result = vc_handle_rdtsc(boot_ghcb, &ctxt, exit_code);
357                 break;
358         case SVM_EXIT_IOIO:
359                 result = vc_handle_ioio(boot_ghcb, &ctxt);
360                 break;
361         case SVM_EXIT_CPUID:
362                 result = vc_handle_cpuid(boot_ghcb, &ctxt);
363                 break;
364         default:
365                 result = ES_UNSUPPORTED;
366                 break;
367         }
368
369 finish:
370         if (result == ES_OK)
371                 vc_finish_insn(&ctxt);
372         else if (result != ES_RETRY)
373                 sev_es_terminate(SEV_TERM_SET_GEN, GHCB_SEV_ES_GEN_REQ);
374 }
375
376 /*
377  * SNP_FEATURES_IMPL_REQ is the mask of SNP features that will need
378  * guest side implementation for proper functioning of the guest. If any
379  * of these features are enabled in the hypervisor but are lacking guest
380  * side implementation, the behavior of the guest will be undefined. The
381  * guest could fail in non-obvious way making it difficult to debug.
382  *
383  * As the behavior of reserved feature bits is unknown to be on the
384  * safe side add them to the required features mask.
385  */
386 #define SNP_FEATURES_IMPL_REQ   (MSR_AMD64_SNP_VTOM |                   \
387                                  MSR_AMD64_SNP_REFLECT_VC |             \
388                                  MSR_AMD64_SNP_RESTRICTED_INJ |         \
389                                  MSR_AMD64_SNP_ALT_INJ |                \
390                                  MSR_AMD64_SNP_DEBUG_SWAP |             \
391                                  MSR_AMD64_SNP_VMPL_SSS |               \
392                                  MSR_AMD64_SNP_SECURE_TSC |             \
393                                  MSR_AMD64_SNP_VMGEXIT_PARAM |          \
394                                  MSR_AMD64_SNP_VMSA_REG_PROT |          \
395                                  MSR_AMD64_SNP_RESERVED_BIT13 |         \
396                                  MSR_AMD64_SNP_RESERVED_BIT15 |         \
397                                  MSR_AMD64_SNP_RESERVED_MASK)
398
399 /*
400  * SNP_FEATURES_PRESENT is the mask of SNP features that are implemented
401  * by the guest kernel. As and when a new feature is implemented in the
402  * guest kernel, a corresponding bit should be added to the mask.
403  */
404 #define SNP_FEATURES_PRESENT    (MSR_AMD64_SNP_DEBUG_SWAP |     \
405                                  MSR_AMD64_SNP_SECURE_TSC)
406
407 u64 snp_get_unsupported_features(u64 status)
408 {
409         if (!(status & MSR_AMD64_SEV_SNP_ENABLED))
410                 return 0;
411
412         return status & SNP_FEATURES_IMPL_REQ & ~SNP_FEATURES_PRESENT;
413 }
414
415 void snp_check_features(void)
416 {
417         u64 unsupported;
418
419         /*
420          * Terminate the boot if hypervisor has enabled any feature lacking
421          * guest side implementation. Pass on the unsupported features mask through
422          * EXIT_INFO_2 of the GHCB protocol so that those features can be reported
423          * as part of the guest boot failure.
424          */
425         unsupported = snp_get_unsupported_features(sev_status);
426         if (unsupported) {
427                 if (ghcb_version < 2 || (!boot_ghcb && !early_setup_ghcb()))
428                         sev_es_terminate(SEV_TERM_SET_GEN, GHCB_SNP_UNSUPPORTED);
429
430                 sev_es_ghcb_terminate(boot_ghcb, SEV_TERM_SET_GEN,
431                                       GHCB_SNP_UNSUPPORTED, unsupported);
432         }
433 }
434
435 /* Search for Confidential Computing blob in the EFI config table. */
436 static struct cc_blob_sev_info *find_cc_blob_efi(struct boot_params *bp)
437 {
438         unsigned long cfg_table_pa;
439         unsigned int cfg_table_len;
440         int ret;
441
442         ret = efi_get_conf_table(bp, &cfg_table_pa, &cfg_table_len);
443         if (ret)
444                 return NULL;
445
446         return (struct cc_blob_sev_info *)efi_find_vendor_table(bp, cfg_table_pa,
447                                                                 cfg_table_len,
448                                                                 EFI_CC_BLOB_GUID);
449 }
450
451 /*
452  * Initial set up of SNP relies on information provided by the
453  * Confidential Computing blob, which can be passed to the boot kernel
454  * by firmware/bootloader in the following ways:
455  *
456  * - via an entry in the EFI config table
457  * - via a setup_data structure, as defined by the Linux Boot Protocol
458  *
459  * Scan for the blob in that order.
460  */
461 static struct cc_blob_sev_info *find_cc_blob(struct boot_params *bp)
462 {
463         struct cc_blob_sev_info *cc_info;
464
465         cc_info = find_cc_blob_efi(bp);
466         if (cc_info)
467                 goto found_cc_info;
468
469         cc_info = find_cc_blob_setup_data(bp);
470         if (!cc_info)
471                 return NULL;
472
473 found_cc_info:
474         if (cc_info->magic != CC_BLOB_SEV_HDR_MAGIC)
475                 sev_es_terminate(SEV_TERM_SET_GEN, GHCB_SNP_UNSUPPORTED);
476
477         return cc_info;
478 }
479
480 /*
481  * Indicate SNP based on presence of SNP-specific CC blob. Subsequent checks
482  * will verify the SNP CPUID/MSR bits.
483  */
484 static bool early_snp_init(struct boot_params *bp)
485 {
486         struct cc_blob_sev_info *cc_info;
487
488         if (!bp)
489                 return false;
490
491         cc_info = find_cc_blob(bp);
492         if (!cc_info)
493                 return false;
494
495         /*
496          * If a SNP-specific Confidential Computing blob is present, then
497          * firmware/bootloader have indicated SNP support. Verifying this
498          * involves CPUID checks which will be more reliable if the SNP
499          * CPUID table is used. See comments over snp_setup_cpuid_table() for
500          * more details.
501          */
502         setup_cpuid_table(cc_info);
503
504         /*
505          * Record the SVSM Calling Area (CA) address if the guest is not
506          * running at VMPL0. The CA will be used to communicate with the
507          * SVSM and request its services.
508          */
509         svsm_setup_ca(cc_info);
510
511         /*
512          * Pass run-time kernel a pointer to CC info via boot_params so EFI
513          * config table doesn't need to be searched again during early startup
514          * phase.
515          */
516         bp->cc_blob_address = (u32)(unsigned long)cc_info;
517
518         return true;
519 }
520
521 /*
522  * sev_check_cpu_support - Check for SEV support in the CPU capabilities
523  *
524  * Returns < 0 if SEV is not supported, otherwise the position of the
525  * encryption bit in the page table descriptors.
526  */
527 static int sev_check_cpu_support(void)
528 {
529         unsigned int eax, ebx, ecx, edx;
530
531         /* Check for the SME/SEV support leaf */
532         eax = 0x80000000;
533         ecx = 0;
534         native_cpuid(&eax, &ebx, &ecx, &edx);
535         if (eax < 0x8000001f)
536                 return -ENODEV;
537
538         /*
539          * Check for the SME/SEV feature:
540          *   CPUID Fn8000_001F[EAX]
541          *   - Bit 0 - Secure Memory Encryption support
542          *   - Bit 1 - Secure Encrypted Virtualization support
543          *   CPUID Fn8000_001F[EBX]
544          *   - Bits 5:0 - Pagetable bit position used to indicate encryption
545          */
546         eax = 0x8000001f;
547         ecx = 0;
548         native_cpuid(&eax, &ebx, &ecx, &edx);
549         /* Check whether SEV is supported */
550         if (!(eax & BIT(1)))
551                 return -ENODEV;
552
553         return ebx & 0x3f;
554 }
555
556 void sev_enable(struct boot_params *bp)
557 {
558         struct msr m;
559         int bitpos;
560         bool snp;
561
562         /*
563          * bp->cc_blob_address should only be set by boot/compressed kernel.
564          * Initialize it to 0 to ensure that uninitialized values from
565          * buggy bootloaders aren't propagated.
566          */
567         if (bp)
568                 bp->cc_blob_address = 0;
569
570         /*
571          * Do an initial SEV capability check before early_snp_init() which
572          * loads the CPUID page and the same checks afterwards are done
573          * without the hypervisor and are trustworthy.
574          *
575          * If the HV fakes SEV support, the guest will crash'n'burn
576          * which is good enough.
577          */
578
579         if (sev_check_cpu_support() < 0)
580                 return;
581
582         /*
583          * Setup/preliminary detection of SNP. This will be sanity-checked
584          * against CPUID/MSR values later.
585          */
586         snp = early_snp_init(bp);
587
588         /* Now repeat the checks with the SNP CPUID table. */
589
590         bitpos = sev_check_cpu_support();
591         if (bitpos < 0) {
592                 if (snp)
593                         error("SEV-SNP support indicated by CC blob, but not CPUID.");
594                 return;
595         }
596
597         /* Set the SME mask if this is an SEV guest. */
598         boot_rdmsr(MSR_AMD64_SEV, &m);
599         sev_status = m.q;
600         if (!(sev_status & MSR_AMD64_SEV_ENABLED))
601                 return;
602
603         /* Negotiate the GHCB protocol version. */
604         if (sev_status & MSR_AMD64_SEV_ES_ENABLED) {
605                 if (!sev_es_negotiate_protocol())
606                         sev_es_terminate(SEV_TERM_SET_GEN, GHCB_SEV_ES_PROT_UNSUPPORTED);
607         }
608
609         /*
610          * SNP is supported in v2 of the GHCB spec which mandates support for HV
611          * features.
612          */
613         if (sev_status & MSR_AMD64_SEV_SNP_ENABLED) {
614                 u64 hv_features;
615                 int ret;
616
617                 hv_features = get_hv_features();
618                 if (!(hv_features & GHCB_HV_FT_SNP))
619                         sev_es_terminate(SEV_TERM_SET_GEN, GHCB_SNP_UNSUPPORTED);
620
621                 /*
622                  * Enforce running at VMPL0 or with an SVSM.
623                  *
624                  * Use RMPADJUST (see the rmpadjust() function for a description of
625                  * what the instruction does) to update the VMPL1 permissions of a
626                  * page. If the guest is running at VMPL0, this will succeed. If the
627                  * guest is running at any other VMPL, this will fail. Linux SNP guests
628                  * only ever run at a single VMPL level so permission mask changes of a
629                  * lesser-privileged VMPL are a don't-care.
630                  */
631                 ret = rmpadjust((unsigned long)&boot_ghcb_page, RMP_PG_SIZE_4K, 1);
632
633                 /*
634                  * Running at VMPL0 is not required if an SVSM is present and the hypervisor
635                  * supports the required SVSM GHCB events.
636                  */
637                 if (ret &&
638                     !(snp_vmpl && (hv_features & GHCB_HV_FT_SNP_MULTI_VMPL)))
639                         sev_es_terminate(SEV_TERM_SET_LINUX, GHCB_TERM_NOT_VMPL0);
640         }
641
642         if (snp && !(sev_status & MSR_AMD64_SEV_SNP_ENABLED))
643                 error("SEV-SNP supported indicated by CC blob, but not SEV status MSR.");
644
645         sme_me_mask = BIT_ULL(bitpos);
646 }
647
648 /*
649  * sev_get_status - Retrieve the SEV status mask
650  *
651  * Returns 0 if the CPU is not SEV capable, otherwise the value of the
652  * AMD64_SEV MSR.
653  */
654 u64 sev_get_status(void)
655 {
656         struct msr m;
657
658         if (sev_check_cpu_support() < 0)
659                 return 0;
660
661         boot_rdmsr(MSR_AMD64_SEV, &m);
662         return m.q;
663 }
664
665 void sev_prep_identity_maps(unsigned long top_level_pgt)
666 {
667         /*
668          * The Confidential Computing blob is used very early in uncompressed
669          * kernel to find the in-memory CPUID table to handle CPUID
670          * instructions. Make sure an identity-mapping exists so it can be
671          * accessed after switchover.
672          */
673         if (sev_snp_enabled()) {
674                 unsigned long cc_info_pa = boot_params_ptr->cc_blob_address;
675                 struct cc_blob_sev_info *cc_info;
676
677                 kernel_add_identity_map(cc_info_pa, cc_info_pa + sizeof(*cc_info));
678
679                 cc_info = (struct cc_blob_sev_info *)cc_info_pa;
680                 kernel_add_identity_map(cc_info->cpuid_phys, cc_info->cpuid_phys + cc_info->cpuid_len);
681         }
682
683         sev_verify_cbit(top_level_pgt);
684 }
This page took 0.06841 seconds and 4 git commands to generate.