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 }