| /* SPDX-License-Identifier: GPL-2.0-only */ | |
| /* | |
| * Helpers used for SEV guests | |
| * | |
| */ | |
| #ifndef SELFTEST_KVM_SEV_H | |
| #define SELFTEST_KVM_SEV_H | |
| #include <stdint.h> | |
| #include <stdbool.h> | |
| #include "linux/psp-sev.h" | |
| #include "kvm_util.h" | |
| #include "svm_util.h" | |
| #include "processor.h" | |
| enum sev_guest_state { | |
| SEV_GUEST_STATE_UNINITIALIZED = 0, | |
| SEV_GUEST_STATE_LAUNCH_UPDATE, | |
| SEV_GUEST_STATE_LAUNCH_SECRET, | |
| SEV_GUEST_STATE_RUNNING, | |
| }; | |
| #define SEV_POLICY_NO_DBG (1UL << 0) | |
| #define SEV_POLICY_ES (1UL << 2) | |
| #define SNP_POLICY_SMT (1ULL << 16) | |
| #define SNP_POLICY_RSVD_MBO (1ULL << 17) | |
| #define SNP_POLICY_DBG (1ULL << 19) | |
| #define GHCB_MSR_TERM_REQ 0x100 | |
| static inline bool is_sev_snp_vm(struct kvm_vm *vm) | |
| { | |
| return vm->type == KVM_X86_SNP_VM; | |
| } | |
| static inline bool is_sev_es_vm(struct kvm_vm *vm) | |
| { | |
| return is_sev_snp_vm(vm) || vm->type == KVM_X86_SEV_ES_VM; | |
| } | |
| static inline bool is_sev_vm(struct kvm_vm *vm) | |
| { | |
| return is_sev_es_vm(vm) || vm->type == KVM_X86_SEV_VM; | |
| } | |
| void sev_vm_launch(struct kvm_vm *vm, u32 policy); | |
| void sev_vm_launch_measure(struct kvm_vm *vm, u8 *measurement); | |
| void sev_vm_launch_finish(struct kvm_vm *vm); | |
| void snp_vm_launch_start(struct kvm_vm *vm, u64 policy); | |
| void snp_vm_launch_update(struct kvm_vm *vm); | |
| void snp_vm_launch_finish(struct kvm_vm *vm); | |
| struct kvm_vm *vm_sev_create_with_one_vcpu(u32 type, void *guest_code, | |
| struct kvm_vcpu **cpu); | |
| void vm_sev_launch(struct kvm_vm *vm, u64 policy, u8 *measurement); | |
| kvm_static_assert(SEV_RET_SUCCESS == 0); | |
| /* | |
| * A SEV-SNP VM requires the policy reserved bit to always be set. | |
| * The SMT policy bit is also required to be set based on SMT being | |
| * available and active on the system. | |
| */ | |
| static inline u64 snp_default_policy(void) | |
| { | |
| return SNP_POLICY_RSVD_MBO | (is_smt_on() ? SNP_POLICY_SMT : 0); | |
| } | |
| /* | |
| * The KVM_MEMORY_ENCRYPT_OP uAPI is utter garbage and takes an "unsigned long" | |
| * instead of a proper struct. The size of the parameter is embedded in the | |
| * ioctl number, i.e. is ABI and thus immutable. Hack around the mess by | |
| * creating an overlay to pass in an "unsigned long" without a cast (casting | |
| * will make the compiler unhappy due to dereferencing an aliased pointer). | |
| */ | |
| #define __vm_sev_ioctl(vm, cmd, arg) \ | |
| ({ \ | |
| int r; \ | |
| \ | |
| union { \ | |
| struct kvm_sev_cmd c; \ | |
| unsigned long raw; \ | |
| } sev_cmd = { .c = { \ | |
| .id = (cmd), \ | |
| .data = (u64)(arg), \ | |
| .sev_fd = (vm)->arch.sev_fd, \ | |
| } }; \ | |
| \ | |
| r = __vm_ioctl(vm, KVM_MEMORY_ENCRYPT_OP, &sev_cmd.raw); \ | |
| r ?: sev_cmd.c.error; \ | |
| }) | |
| #define vm_sev_ioctl(vm, cmd, arg) \ | |
| ({ \ | |
| int ret = __vm_sev_ioctl(vm, cmd, arg); \ | |
| \ | |
| __TEST_ASSERT_VM_VCPU_IOCTL(!ret, #cmd, ret, vm); \ | |
| }) | |
| void sev_vm_init(struct kvm_vm *vm); | |
| void sev_es_vm_init(struct kvm_vm *vm); | |
| void snp_vm_init(struct kvm_vm *vm); | |
| static inline void vmgexit(void) | |
| { | |
| __asm__ __volatile__("rep; vmmcall"); | |
| } | |
| static inline void sev_register_encrypted_memory(struct kvm_vm *vm, | |
| struct userspace_mem_region *region) | |
| { | |
| struct kvm_enc_region range = { | |
| .addr = region->region.userspace_addr, | |
| .size = region->region.memory_size, | |
| }; | |
| vm_ioctl(vm, KVM_MEMORY_ENCRYPT_REG_REGION, &range); | |
| } | |
| static inline void sev_launch_update_data(struct kvm_vm *vm, gpa_t gpa, | |
| u64 size) | |
| { | |
| struct kvm_sev_launch_update_data update_data = { | |
| .uaddr = (unsigned long)addr_gpa2hva(vm, gpa), | |
| .len = size, | |
| }; | |
| vm_sev_ioctl(vm, KVM_SEV_LAUNCH_UPDATE_DATA, &update_data); | |
| } | |
| static inline void snp_launch_update_data(struct kvm_vm *vm, gpa_t gpa, | |
| u64 hva, u64 size, u8 type) | |
| { | |
| struct kvm_sev_snp_launch_update update_data = { | |
| .uaddr = hva, | |
| .gfn_start = gpa >> PAGE_SHIFT, | |
| .len = size, | |
| .type = type, | |
| }; | |
| vm_sev_ioctl(vm, KVM_SEV_SNP_LAUNCH_UPDATE, &update_data); | |
| } | |
| static inline void sev_dbg_crypt_memory(struct kvm_vm *vm, unsigned int cmd, | |
| void *dst, void *src, unsigned int len) | |
| { | |
| struct kvm_sev_dbg dbg = { | |
| .src_uaddr = (unsigned long)src, | |
| .dst_uaddr = (unsigned long)dst, | |
| .len = len, | |
| }; | |
| vm_sev_ioctl(vm, cmd, &dbg); | |
| } | |
| static inline void sev_decrypt_memory(struct kvm_vm *vm, void *dst, void *src, | |
| unsigned int len) | |
| { | |
| sev_dbg_crypt_memory(vm, KVM_SEV_DBG_DECRYPT, dst, src, len); | |
| } | |
| static inline void sev_encrypt_memory(struct kvm_vm *vm, void *dst, void *src, | |
| unsigned int len) | |
| { | |
| sev_dbg_crypt_memory(vm, KVM_SEV_DBG_ENCRYPT, dst, src, len); | |
| } | |
| #endif /* SELFTEST_KVM_SEV_H */ |