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 #ifndef __ASM_ENCRYPTED_STATE_H 9 #define __ASM_ENCRYPTED_STATE_H 10 11 #include <linux/types.h> 12 #include <linux/sev-guest.h> 13 14 #include <asm/insn.h> 15 #include <asm/sev-common.h> 16 #include <asm/coco.h> 17 #include <asm/set_memory.h> 18 #include <asm/svm.h> 19 20 #define GHCB_PROTOCOL_MIN 1ULL 21 #define GHCB_PROTOCOL_MAX 2ULL 22 #define GHCB_DEFAULT_USAGE 0ULL 23 24 #define VMGEXIT() { asm volatile("rep; vmmcall\n\r"); } 25 26 struct boot_params; 27 28 enum es_result { 29 ES_OK, /* All good */ 30 ES_UNSUPPORTED, /* Requested operation not supported */ 31 ES_VMM_ERROR, /* Unexpected state from the VMM */ 32 ES_DECODE_FAILED, /* Instruction decoding failed */ 33 ES_EXCEPTION, /* Instruction caused exception */ 34 ES_RETRY, /* Retry instruction emulation */ 35 }; 36 37 struct es_fault_info { 38 unsigned long vector; 39 unsigned long error_code; 40 unsigned long cr2; 41 }; 42 43 struct pt_regs; 44 45 /* ES instruction emulation context */ 46 struct es_em_ctxt { 47 struct pt_regs *regs; 48 struct insn insn; 49 struct es_fault_info fi; 50 }; 51 52 /* 53 * AMD SEV Confidential computing blob structure. The structure is 54 * defined in OVMF UEFI firmware header: 55 * https://github.com/tianocore/edk2/blob/master/OvmfPkg/Include/Guid/ConfidentialComputingSevSnpBlob.h 56 */ 57 #define CC_BLOB_SEV_HDR_MAGIC 0x45444d41 58 struct cc_blob_sev_info { 59 u32 magic; 60 u16 version; 61 u16 reserved; 62 u64 secrets_phys; 63 u32 secrets_len; 64 u32 rsvd1; 65 u64 cpuid_phys; 66 u32 cpuid_len; 67 u32 rsvd2; 68 } __packed; 69 70 void do_vc_no_ghcb(struct pt_regs *regs, unsigned long exit_code); 71 72 static inline u64 lower_bits(u64 val, unsigned int bits) 73 { 74 u64 mask = (1ULL << bits) - 1; 75 76 return (val & mask); 77 } 78 79 struct real_mode_header; 80 enum stack_type; 81 82 /* Early IDT entry points for #VC handler */ 83 extern void vc_no_ghcb(void); 84 extern void vc_boot_ghcb(void); 85 extern bool handle_vc_boot_ghcb(struct pt_regs *regs); 86 87 /* 88 * Individual entries of the SNP CPUID table, as defined by the SNP 89 * Firmware ABI, Revision 0.9, Section 7.1, Table 14. 90 */ 91 struct snp_cpuid_fn { 92 u32 eax_in; 93 u32 ecx_in; 94 u64 xcr0_in; 95 u64 xss_in; 96 u32 eax; 97 u32 ebx; 98 u32 ecx; 99 u32 edx; 100 u64 __reserved; 101 } __packed; 102 103 /* 104 * SNP CPUID table, as defined by the SNP Firmware ABI, Revision 0.9, 105 * Section 8.14.2.6. Also noted there is the SNP firmware-enforced limit 106 * of 64 entries per CPUID table. 107 */ 108 #define SNP_CPUID_COUNT_MAX 64 109 110 struct snp_cpuid_table { 111 u32 count; 112 u32 __reserved1; 113 u64 __reserved2; 114 struct snp_cpuid_fn fn[SNP_CPUID_COUNT_MAX]; 115 } __packed; 116 117 /* PVALIDATE return codes */ 118 #define PVALIDATE_FAIL_SIZEMISMATCH 6 119 120 /* Software defined (when rFlags.CF = 1) */ 121 #define PVALIDATE_FAIL_NOUPDATE 255 122 123 /* RMUPDATE detected 4K page and 2MB page overlap. */ 124 #define RMPUPDATE_FAIL_OVERLAP 4 125 126 /* PSMASH failed due to concurrent access by another CPU */ 127 #define PSMASH_FAIL_INUSE 3 128 129 /* RMP page size */ 130 #define RMP_PG_SIZE_4K 0 131 #define RMP_PG_SIZE_2M 1 132 #define RMP_TO_PG_LEVEL(level) (((level) == RMP_PG_SIZE_4K) ? PG_LEVEL_4K : PG_LEVEL_2M) 133 #define PG_LEVEL_TO_RMP(level) (((level) == PG_LEVEL_4K) ? RMP_PG_SIZE_4K : RMP_PG_SIZE_2M) 134 135 struct rmp_state { 136 u64 gpa; 137 u8 assigned; 138 u8 pagesize; 139 u8 immutable; 140 u8 rsvd; 141 u32 asid; 142 } __packed; 143 144 #define RMPADJUST_VMSA_PAGE_BIT BIT(16) 145 146 /* SNP Guest message request */ 147 struct snp_req_data { 148 unsigned long req_gpa; 149 unsigned long resp_gpa; 150 unsigned long data_gpa; 151 unsigned int data_npages; 152 }; 153 154 #define MAX_AUTHTAG_LEN 32 155 #define AUTHTAG_LEN 16 156 #define AAD_LEN 48 157 #define MSG_HDR_VER 1 158 159 #define SNP_REQ_MAX_RETRY_DURATION (60*HZ) 160 #define SNP_REQ_RETRY_DELAY (2*HZ) 161 162 /* See SNP spec SNP_GUEST_REQUEST section for the structure */ 163 enum msg_type { 164 SNP_MSG_TYPE_INVALID = 0, 165 SNP_MSG_CPUID_REQ, 166 SNP_MSG_CPUID_RSP, 167 SNP_MSG_KEY_REQ, 168 SNP_MSG_KEY_RSP, 169 SNP_MSG_REPORT_REQ, 170 SNP_MSG_REPORT_RSP, 171 SNP_MSG_EXPORT_REQ, 172 SNP_MSG_EXPORT_RSP, 173 SNP_MSG_IMPORT_REQ, 174 SNP_MSG_IMPORT_RSP, 175 SNP_MSG_ABSORB_REQ, 176 SNP_MSG_ABSORB_RSP, 177 SNP_MSG_VMRK_REQ, 178 SNP_MSG_VMRK_RSP, 179 180 SNP_MSG_TSC_INFO_REQ = 17, 181 SNP_MSG_TSC_INFO_RSP, 182 183 SNP_MSG_TYPE_MAX 184 }; 185 186 enum aead_algo { 187 SNP_AEAD_INVALID, 188 SNP_AEAD_AES_256_GCM, 189 }; 190 191 struct snp_guest_msg_hdr { 192 u8 authtag[MAX_AUTHTAG_LEN]; 193 u64 msg_seqno; 194 u8 rsvd1[8]; 195 u8 algo; 196 u8 hdr_version; 197 u16 hdr_sz; 198 u8 msg_type; 199 u8 msg_version; 200 u16 msg_sz; 201 u32 rsvd2; 202 u8 msg_vmpck; 203 u8 rsvd3[35]; 204 } __packed; 205 206 struct snp_guest_msg { 207 struct snp_guest_msg_hdr hdr; 208 u8 payload[PAGE_SIZE - sizeof(struct snp_guest_msg_hdr)]; 209 } __packed; 210 211 #define SNP_TSC_INFO_REQ_SZ 128 212 213 struct snp_tsc_info_req { 214 u8 rsvd[SNP_TSC_INFO_REQ_SZ]; 215 } __packed; 216 217 struct snp_tsc_info_resp { 218 u32 status; 219 u32 rsvd1; 220 u64 tsc_scale; 221 u64 tsc_offset; 222 u32 tsc_factor; 223 u8 rsvd2[100]; 224 } __packed; 225 226 /* 227 * Obtain the mean TSC frequency by decreasing the nominal TSC frequency with 228 * TSC_FACTOR as documented in the SNP Firmware ABI specification: 229 * 230 * GUEST_TSC_FREQ * (1 - (TSC_FACTOR * 0.00001)) 231 * 232 * which is equivalent to: 233 * 234 * GUEST_TSC_FREQ -= (GUEST_TSC_FREQ * TSC_FACTOR) / 100000; 235 */ 236 #define SNP_SCALE_TSC_FREQ(freq, factor) ((freq) - (freq) * (factor) / 100000) 237 238 struct snp_guest_req { 239 void *req_buf; 240 size_t req_sz; 241 242 void *resp_buf; 243 size_t resp_sz; 244 245 u64 exit_code; 246 u64 exitinfo2; 247 unsigned int vmpck_id; 248 u8 msg_version; 249 u8 msg_type; 250 251 struct snp_req_data input; 252 void *certs_data; 253 }; 254 255 /* 256 * The secrets page contains 96-bytes of reserved field that can be used by 257 * the guest OS. The guest OS uses the area to save the message sequence 258 * number for each VMPCK. 259 * 260 * See the GHCB spec section Secret page layout for the format for this area. 261 */ 262 struct secrets_os_area { 263 u32 msg_seqno_0; 264 u32 msg_seqno_1; 265 u32 msg_seqno_2; 266 u32 msg_seqno_3; 267 u64 ap_jump_table_pa; 268 u8 rsvd[40]; 269 u8 guest_usage[32]; 270 } __packed; 271 272 #define VMPCK_KEY_LEN 32 273 274 /* See the SNP spec version 0.9 for secrets page format */ 275 struct snp_secrets_page { 276 u32 version; 277 u32 imien : 1, 278 rsvd1 : 31; 279 u32 fms; 280 u32 rsvd2; 281 u8 gosvw[16]; 282 u8 vmpck0[VMPCK_KEY_LEN]; 283 u8 vmpck1[VMPCK_KEY_LEN]; 284 u8 vmpck2[VMPCK_KEY_LEN]; 285 u8 vmpck3[VMPCK_KEY_LEN]; 286 struct secrets_os_area os_area; 287 288 u8 vmsa_tweak_bitmap[64]; 289 290 /* SVSM fields */ 291 u64 svsm_base; 292 u64 svsm_size; 293 u64 svsm_caa; 294 u32 svsm_max_version; 295 u8 svsm_guest_vmpl; 296 u8 rsvd3[3]; 297 298 /* The percentage decrease from nominal to mean TSC frequency. */ 299 u32 tsc_factor; 300 301 /* Remainder of page */ 302 u8 rsvd4[3740]; 303 } __packed; 304 305 struct snp_msg_desc { 306 /* request and response are in unencrypted memory */ 307 struct snp_guest_msg *request, *response; 308 309 /* 310 * Avoid information leakage by double-buffering shared messages 311 * in fields that are in regular encrypted memory. 312 */ 313 struct snp_guest_msg secret_request, secret_response; 314 315 struct snp_secrets_page *secrets; 316 317 struct aesgcm_ctx *ctx; 318 319 u32 *os_area_msg_seqno; 320 u8 *vmpck; 321 int vmpck_id; 322 }; 323 324 /* 325 * The SVSM Calling Area (CA) related structures. 326 */ 327 struct svsm_ca { 328 u8 call_pending; 329 u8 mem_available; 330 u8 rsvd1[6]; 331 332 u8 svsm_buffer[PAGE_SIZE - 8]; 333 }; 334 335 #define SVSM_SUCCESS 0 336 #define SVSM_ERR_INCOMPLETE 0x80000000 337 #define SVSM_ERR_UNSUPPORTED_PROTOCOL 0x80000001 338 #define SVSM_ERR_UNSUPPORTED_CALL 0x80000002 339 #define SVSM_ERR_INVALID_ADDRESS 0x80000003 340 #define SVSM_ERR_INVALID_FORMAT 0x80000004 341 #define SVSM_ERR_INVALID_PARAMETER 0x80000005 342 #define SVSM_ERR_INVALID_REQUEST 0x80000006 343 #define SVSM_ERR_BUSY 0x80000007 344 #define SVSM_PVALIDATE_FAIL_SIZEMISMATCH 0x80001006 345 346 /* 347 * The SVSM PVALIDATE related structures 348 */ 349 struct svsm_pvalidate_entry { 350 u64 page_size : 2, 351 action : 1, 352 ignore_cf : 1, 353 rsvd : 8, 354 pfn : 52; 355 }; 356 357 struct svsm_pvalidate_call { 358 u16 num_entries; 359 u16 cur_index; 360 361 u8 rsvd1[4]; 362 363 struct svsm_pvalidate_entry entry[]; 364 }; 365 366 #define SVSM_PVALIDATE_MAX_COUNT ((sizeof_field(struct svsm_ca, svsm_buffer) - \ 367 offsetof(struct svsm_pvalidate_call, entry)) / \ 368 sizeof(struct svsm_pvalidate_entry)) 369 370 /* 371 * The SVSM Attestation related structures 372 */ 373 struct svsm_loc_entry { 374 u64 pa; 375 u32 len; 376 u8 rsvd[4]; 377 }; 378 379 struct svsm_attest_call { 380 struct svsm_loc_entry report_buf; 381 struct svsm_loc_entry nonce; 382 struct svsm_loc_entry manifest_buf; 383 struct svsm_loc_entry certificates_buf; 384 385 /* For attesting a single service */ 386 u8 service_guid[16]; 387 u32 service_manifest_ver; 388 u8 rsvd[4]; 389 }; 390 391 /* PTE descriptor used for the prepare_pte_enc() operations. */ 392 struct pte_enc_desc { 393 pte_t *kpte; 394 int pte_level; 395 bool encrypt; 396 /* pfn of the kpte above */ 397 unsigned long pfn; 398 /* physical address of @pfn */ 399 unsigned long pa; 400 /* virtual address of @pfn */ 401 void *va; 402 /* memory covered by the pte */ 403 unsigned long size; 404 pgprot_t new_pgprot; 405 }; 406 407 /* 408 * SVSM protocol structure 409 */ 410 struct svsm_call { 411 struct svsm_ca *caa; 412 u64 rax; 413 u64 rcx; 414 u64 rdx; 415 u64 r8; 416 u64 r9; 417 u64 rax_out; 418 u64 rcx_out; 419 u64 rdx_out; 420 u64 r8_out; 421 u64 r9_out; 422 }; 423 424 #define SVSM_CORE_CALL(x) ((0ULL << 32) | (x)) 425 #define SVSM_CORE_REMAP_CA 0 426 #define SVSM_CORE_PVALIDATE 1 427 #define SVSM_CORE_CREATE_VCPU 2 428 #define SVSM_CORE_DELETE_VCPU 3 429 430 #define SVSM_ATTEST_CALL(x) ((1ULL << 32) | (x)) 431 #define SVSM_ATTEST_SERVICES 0 432 #define SVSM_ATTEST_SINGLE_SERVICE 1 433 434 #define SVSM_VTPM_CALL(x) ((2ULL << 32) | (x)) 435 #define SVSM_VTPM_QUERY 0 436 #define SVSM_VTPM_CMD 1 437 438 #ifdef CONFIG_AMD_MEM_ENCRYPT 439 440 extern u8 snp_vmpl; 441 442 extern void __sev_es_ist_enter(struct pt_regs *regs); 443 extern void __sev_es_ist_exit(void); 444 static __always_inline void sev_es_ist_enter(struct pt_regs *regs) 445 { 446 if (cc_vendor == CC_VENDOR_AMD && 447 cc_platform_has(CC_ATTR_GUEST_STATE_ENCRYPT)) 448 __sev_es_ist_enter(regs); 449 } 450 static __always_inline void sev_es_ist_exit(void) 451 { 452 if (cc_vendor == CC_VENDOR_AMD && 453 cc_platform_has(CC_ATTR_GUEST_STATE_ENCRYPT)) 454 __sev_es_ist_exit(); 455 } 456 extern int sev_es_setup_ap_jump_table(struct real_mode_header *rmh); 457 extern void __sev_es_nmi_complete(void); 458 static __always_inline void sev_es_nmi_complete(void) 459 { 460 if (cc_vendor == CC_VENDOR_AMD && 461 cc_platform_has(CC_ATTR_GUEST_STATE_ENCRYPT)) 462 __sev_es_nmi_complete(); 463 } 464 extern int __init sev_es_efi_map_ghcbs_cas(pgd_t *pgd); 465 extern void sev_enable(struct boot_params *bp); 466 467 /* 468 * RMPADJUST modifies the RMP permissions of a page of a lesser- 469 * privileged (numerically higher) VMPL. 470 * 471 * If the guest is running at a higher-privilege than the privilege 472 * level the instruction is targeting, the instruction will succeed, 473 * otherwise, it will fail. 474 */ 475 static inline int rmpadjust(unsigned long vaddr, bool rmp_psize, unsigned long attrs) 476 { 477 int rc; 478 479 /* "rmpadjust" mnemonic support in binutils 2.36 and newer */ 480 asm volatile(".byte 0xF3,0x0F,0x01,0xFE\n\t" 481 : "=a"(rc) 482 : "a"(vaddr), "c"(rmp_psize), "d"(attrs) 483 : "memory", "cc"); 484 485 return rc; 486 } 487 static inline int pvalidate(unsigned long vaddr, bool rmp_psize, bool validate) 488 { 489 bool no_rmpupdate; 490 int rc; 491 492 /* "pvalidate" mnemonic support in binutils 2.36 and newer */ 493 asm volatile(".byte 0xF2, 0x0F, 0x01, 0xFF\n\t" 494 CC_SET(c) 495 : CC_OUT(c) (no_rmpupdate), "=a"(rc) 496 : "a"(vaddr), "c"(rmp_psize), "d"(validate) 497 : "memory", "cc"); 498 499 if (no_rmpupdate) 500 return PVALIDATE_FAIL_NOUPDATE; 501 502 return rc; 503 } 504 505 void setup_ghcb(void); 506 void early_snp_set_memory_private(unsigned long vaddr, unsigned long paddr, 507 unsigned long npages); 508 void early_snp_set_memory_shared(unsigned long vaddr, unsigned long paddr, 509 unsigned long npages); 510 void snp_set_memory_shared(unsigned long vaddr, unsigned long npages); 511 void snp_set_memory_private(unsigned long vaddr, unsigned long npages); 512 void snp_set_wakeup_secondary_cpu(void); 513 bool snp_init(struct boot_params *bp); 514 void __noreturn snp_abort(void); 515 void snp_dmi_setup(void); 516 int snp_issue_svsm_attest_req(u64 call_id, struct svsm_call *call, struct svsm_attest_call *input); 517 void snp_accept_memory(phys_addr_t start, phys_addr_t end); 518 u64 snp_get_unsupported_features(u64 status); 519 u64 sev_get_status(void); 520 void sev_show_status(void); 521 void snp_update_svsm_ca(void); 522 int prepare_pte_enc(struct pte_enc_desc *d); 523 void set_pte_enc_mask(pte_t *kpte, unsigned long pfn, pgprot_t new_prot); 524 void snp_kexec_finish(void); 525 void snp_kexec_begin(void); 526 527 int snp_msg_init(struct snp_msg_desc *mdesc, int vmpck_id); 528 struct snp_msg_desc *snp_msg_alloc(void); 529 void snp_msg_free(struct snp_msg_desc *mdesc); 530 int snp_send_guest_request(struct snp_msg_desc *mdesc, struct snp_guest_req *req); 531 532 int snp_svsm_vtpm_send_command(u8 *buffer); 533 534 void __init snp_secure_tsc_prepare(void); 535 void __init snp_secure_tsc_init(void); 536 537 static __always_inline void vc_ghcb_invalidate(struct ghcb *ghcb) 538 { 539 ghcb->save.sw_exit_code = 0; 540 __builtin_memset(ghcb->save.valid_bitmap, 0, sizeof(ghcb->save.valid_bitmap)); 541 } 542 543 void vc_forward_exception(struct es_em_ctxt *ctxt); 544 545 /* I/O parameters for CPUID-related helpers */ 546 struct cpuid_leaf { 547 u32 fn; 548 u32 subfn; 549 u32 eax; 550 u32 ebx; 551 u32 ecx; 552 u32 edx; 553 }; 554 555 int snp_cpuid(struct ghcb *ghcb, struct es_em_ctxt *ctxt, struct cpuid_leaf *leaf); 556 557 void __noreturn sev_es_terminate(unsigned int set, unsigned int reason); 558 enum es_result sev_es_ghcb_hv_call(struct ghcb *ghcb, 559 struct es_em_ctxt *ctxt, 560 u64 exit_code, u64 exit_info_1, 561 u64 exit_info_2); 562 563 extern struct ghcb *boot_ghcb; 564 565 #else /* !CONFIG_AMD_MEM_ENCRYPT */ 566 567 #define snp_vmpl 0 568 static inline void sev_es_ist_enter(struct pt_regs *regs) { } 569 static inline void sev_es_ist_exit(void) { } 570 static inline int sev_es_setup_ap_jump_table(struct real_mode_header *rmh) { return 0; } 571 static inline void sev_es_nmi_complete(void) { } 572 static inline int sev_es_efi_map_ghcbs_cas(pgd_t *pgd) { return 0; } 573 static inline void sev_enable(struct boot_params *bp) { } 574 static inline int pvalidate(unsigned long vaddr, bool rmp_psize, bool validate) { return 0; } 575 static inline int rmpadjust(unsigned long vaddr, bool rmp_psize, unsigned long attrs) { return 0; } 576 static inline void setup_ghcb(void) { } 577 static inline void __init 578 early_snp_set_memory_private(unsigned long vaddr, unsigned long paddr, unsigned long npages) { } 579 static inline void __init 580 early_snp_set_memory_shared(unsigned long vaddr, unsigned long paddr, unsigned long npages) { } 581 static inline void snp_set_memory_shared(unsigned long vaddr, unsigned long npages) { } 582 static inline void snp_set_memory_private(unsigned long vaddr, unsigned long npages) { } 583 static inline void snp_set_wakeup_secondary_cpu(void) { } 584 static inline bool snp_init(struct boot_params *bp) { return false; } 585 static inline void snp_abort(void) { } 586 static inline void snp_dmi_setup(void) { } 587 static inline int snp_issue_svsm_attest_req(u64 call_id, struct svsm_call *call, struct svsm_attest_call *input) 588 { 589 return -ENOTTY; 590 } 591 static inline void snp_accept_memory(phys_addr_t start, phys_addr_t end) { } 592 static inline u64 snp_get_unsupported_features(u64 status) { return 0; } 593 static inline u64 sev_get_status(void) { return 0; } 594 static inline void sev_show_status(void) { } 595 static inline void snp_update_svsm_ca(void) { } 596 static inline int prepare_pte_enc(struct pte_enc_desc *d) { return 0; } 597 static inline void set_pte_enc_mask(pte_t *kpte, unsigned long pfn, pgprot_t new_prot) { } 598 static inline void snp_kexec_finish(void) { } 599 static inline void snp_kexec_begin(void) { } 600 static inline int snp_msg_init(struct snp_msg_desc *mdesc, int vmpck_id) { return -1; } 601 static inline struct snp_msg_desc *snp_msg_alloc(void) { return NULL; } 602 static inline void snp_msg_free(struct snp_msg_desc *mdesc) { } 603 static inline int snp_send_guest_request(struct snp_msg_desc *mdesc, 604 struct snp_guest_req *req) { return -ENODEV; } 605 static inline int snp_svsm_vtpm_send_command(u8 *buffer) { return -ENODEV; } 606 static inline void __init snp_secure_tsc_prepare(void) { } 607 static inline void __init snp_secure_tsc_init(void) { } 608 609 #endif /* CONFIG_AMD_MEM_ENCRYPT */ 610 611 #ifdef CONFIG_KVM_AMD_SEV 612 bool snp_probe_rmptable_info(void); 613 int snp_rmptable_init(void); 614 int snp_lookup_rmpentry(u64 pfn, bool *assigned, int *level); 615 void snp_dump_hva_rmpentry(unsigned long address); 616 int psmash(u64 pfn); 617 int rmp_make_private(u64 pfn, u64 gpa, enum pg_level level, u32 asid, bool immutable); 618 int rmp_make_shared(u64 pfn, enum pg_level level); 619 void snp_leak_pages(u64 pfn, unsigned int npages); 620 void kdump_sev_callback(void); 621 void snp_fixup_e820_tables(void); 622 623 static inline void sev_evict_cache(void *va, int npages) 624 { 625 volatile u8 val __always_unused; 626 u8 *bytes = va; 627 int page_idx; 628 629 /* 630 * For SEV guests, a read from the first/last cache-lines of a 4K page 631 * using the guest key is sufficient to cause a flush of all cache-lines 632 * associated with that 4K page without incurring all the overhead of a 633 * full CLFLUSH sequence. 634 */ 635 for (page_idx = 0; page_idx < npages; page_idx++) { 636 val = bytes[page_idx * PAGE_SIZE]; 637 val = bytes[page_idx * PAGE_SIZE + PAGE_SIZE - 1]; 638 } 639 } 640 #else 641 static inline bool snp_probe_rmptable_info(void) { return false; } 642 static inline int snp_rmptable_init(void) { return -ENOSYS; } 643 static inline int snp_lookup_rmpentry(u64 pfn, bool *assigned, int *level) { return -ENODEV; } 644 static inline void snp_dump_hva_rmpentry(unsigned long address) {} 645 static inline int psmash(u64 pfn) { return -ENODEV; } 646 static inline int rmp_make_private(u64 pfn, u64 gpa, enum pg_level level, u32 asid, 647 bool immutable) 648 { 649 return -ENODEV; 650 } 651 static inline int rmp_make_shared(u64 pfn, enum pg_level level) { return -ENODEV; } 652 static inline void snp_leak_pages(u64 pfn, unsigned int npages) {} 653 static inline void kdump_sev_callback(void) { } 654 static inline void snp_fixup_e820_tables(void) {} 655 static inline void sev_evict_cache(void *va, int npages) {} 656 #endif 657 658 #endif 659