lib/x86_64/svm.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * tools/testing/selftests/kvm/lib/x86_64/svm.c
0004  * Helpers used for nested SVM testing
0005  * Largely inspired from KVM unit test svm.c
0006  *
0007  * Copyright (C) 2020, Red Hat, Inc.
0008  */
0009
0010 #include "test_util.h"
0011 #include "kvm_util.h"
0012 #include "processor.h"
0013 #include "svm_util.h"
0014
0015 #define SEV_DEV_PATH "/dev/sev"
0016
0017 struct gpr64_regs guest_regs;
0018 u64 rflags;
0019
0020 /* Allocate memory regions for nested SVM tests.
0021  *
0022  * Input Args:
0023  *   vm - The VM to allocate guest-virtual addresses in.
0024  *
0025  * Output Args:
0026  *   p_svm_gva - The guest virtual address for the struct svm_test_data.
0027  *
0028  * Return:
0029  *   Pointer to structure with the addresses of the SVM areas.
0030  */
0031 struct svm_test_data *
0032 vcpu_alloc_svm(struct kvm_vm *vm, vm_vaddr_t *p_svm_gva)
0033 {
0034     vm_vaddr_t svm_gva = vm_vaddr_alloc_page(vm);
0035     struct svm_test_data *svm = addr_gva2hva(vm, svm_gva);
0036
0037     svm->vmcb = (void *)vm_vaddr_alloc_page(vm);
0038     svm->vmcb_hva = addr_gva2hva(vm, (uintptr_t)svm->vmcb);
0039     svm->vmcb_gpa = addr_gva2gpa(vm, (uintptr_t)svm->vmcb);
0040
0041     svm->save_area = (void *)vm_vaddr_alloc_page(vm);
0042     svm->save_area_hva = addr_gva2hva(vm, (uintptr_t)svm->save_area);
0043     svm->save_area_gpa = addr_gva2gpa(vm, (uintptr_t)svm->save_area);
0044
0045     svm->msr = (void *)vm_vaddr_alloc_page(vm);
0046     svm->msr_hva = addr_gva2hva(vm, (uintptr_t)svm->msr);
0047     svm->msr_gpa = addr_gva2gpa(vm, (uintptr_t)svm->msr);
0048     memset(svm->msr_hva, 0, getpagesize());
0049
0050     *p_svm_gva = svm_gva;
0051     return svm;
0052 }
0053
0054 static void vmcb_set_seg(struct vmcb_seg *seg, u16 selector,
0055              u64 base, u32 limit, u32 attr)
0056 {
0057     seg->selector = selector;
0058     seg->attrib = attr;
0059     seg->limit = limit;
0060     seg->base = base;
0061 }
0062
0063 /*
0064  * Avoid using memset to clear the vmcb, since libc may not be
0065  * available in L1 (and, even if it is, features that libc memset may
0066  * want to use, like AVX, may not be enabled).
0067  */
0068 static void clear_vmcb(struct vmcb *vmcb)
0069 {
0070     int n = sizeof(*vmcb) / sizeof(u32);
0071
0072     asm volatile ("rep stosl" : "+c"(n), "+D"(vmcb) : "a"(0) : "memory");
0073 }
0074
0075 void generic_svm_setup(struct svm_test_data *svm, void *guest_rip, void *guest_rsp)
0076 {
0077     struct vmcb *vmcb = svm->vmcb;
0078     uint64_t vmcb_gpa = svm->vmcb_gpa;
0079     struct vmcb_save_area *save = &vmcb->save;
0080     struct vmcb_control_area *ctrl = &vmcb->control;
0081     u32 data_seg_attr = 3 | SVM_SELECTOR_S_MASK | SVM_SELECTOR_P_MASK
0082           | SVM_SELECTOR_DB_MASK | SVM_SELECTOR_G_MASK;
0083     u32 code_seg_attr = 9 | SVM_SELECTOR_S_MASK | SVM_SELECTOR_P_MASK
0084         | SVM_SELECTOR_L_MASK | SVM_SELECTOR_G_MASK;
0085     uint64_t efer;
0086
0087     efer = rdmsr(MSR_EFER);
0088     wrmsr(MSR_EFER, efer | EFER_SVME);
0089     wrmsr(MSR_VM_HSAVE_PA, svm->save_area_gpa);
0090
0091     clear_vmcb(vmcb);
0092     asm volatile ("vmsave %0\n\t" : : "a" (vmcb_gpa) : "memory");
0093     vmcb_set_seg(&save->es, get_es(), 0, -1U, data_seg_attr);
0094     vmcb_set_seg(&save->cs, get_cs(), 0, -1U, code_seg_attr);
0095     vmcb_set_seg(&save->ss, get_ss(), 0, -1U, data_seg_attr);
0096     vmcb_set_seg(&save->ds, get_ds(), 0, -1U, data_seg_attr);
0097     vmcb_set_seg(&save->gdtr, 0, get_gdt().address, get_gdt().size, 0);
0098     vmcb_set_seg(&save->idtr, 0, get_idt().address, get_idt().size, 0);
0099
0100     ctrl->asid = 1;
0101     save->cpl = 0;
0102     save->efer = rdmsr(MSR_EFER);
0103     asm volatile ("mov %%cr4, %0" : "=r"(save->cr4) : : "memory");
0104     asm volatile ("mov %%cr3, %0" : "=r"(save->cr3) : : "memory");
0105     asm volatile ("mov %%cr0, %0" : "=r"(save->cr0) : : "memory");
0106     asm volatile ("mov %%dr7, %0" : "=r"(save->dr7) : : "memory");
0107     asm volatile ("mov %%dr6, %0" : "=r"(save->dr6) : : "memory");
0108     asm volatile ("mov %%cr2, %0" : "=r"(save->cr2) : : "memory");
0109     save->g_pat = rdmsr(MSR_IA32_CR_PAT);
0110     save->dbgctl = rdmsr(MSR_IA32_DEBUGCTLMSR);
0111     ctrl->intercept = (1ULL << INTERCEPT_VMRUN) |
0112                 (1ULL << INTERCEPT_VMMCALL);
0113     ctrl->msrpm_base_pa = svm->msr_gpa;
0114
0115     vmcb->save.rip = (u64)guest_rip;
0116     vmcb->save.rsp = (u64)guest_rsp;
0117     guest_regs.rdi = (u64)svm;
0118 }
0119
0120 /*
0121  * save/restore 64-bit general registers except rax, rip, rsp
0122  * which are directly handed through the VMCB guest processor state
0123  */
0124 #define SAVE_GPR_C              \
0125     "xchg %%rbx, guest_regs+0x20\n\t"   \
0126     "xchg %%rcx, guest_regs+0x10\n\t"   \
0127     "xchg %%rdx, guest_regs+0x18\n\t"   \
0128     "xchg %%rbp, guest_regs+0x30\n\t"   \
0129     "xchg %%rsi, guest_regs+0x38\n\t"   \
0130     "xchg %%rdi, guest_regs+0x40\n\t"   \
0131     "xchg %%r8,  guest_regs+0x48\n\t"   \
0132     "xchg %%r9,  guest_regs+0x50\n\t"   \
0133     "xchg %%r10, guest_regs+0x58\n\t"   \
0134     "xchg %%r11, guest_regs+0x60\n\t"   \
0135     "xchg %%r12, guest_regs+0x68\n\t"   \
0136     "xchg %%r13, guest_regs+0x70\n\t"   \
0137     "xchg %%r14, guest_regs+0x78\n\t"   \
0138     "xchg %%r15, guest_regs+0x80\n\t"
0139
0140 #define LOAD_GPR_C      SAVE_GPR_C
0141
0142 /*
0143  * selftests do not use interrupts so we dropped clgi/sti/cli/stgi
0144  * for now. registers involved in LOAD/SAVE_GPR_C are eventually
0145  * unmodified so they do not need to be in the clobber list.
0146  */
0147 void run_guest(struct vmcb *vmcb, uint64_t vmcb_gpa)
0148 {
0149     asm volatile (
0150         "vmload %[vmcb_gpa]\n\t"
0151         "mov rflags, %%r15\n\t" // rflags
0152         "mov %%r15, 0x170(%[vmcb])\n\t"
0153         "mov guest_regs, %%r15\n\t" // rax
0154         "mov %%r15, 0x1f8(%[vmcb])\n\t"
0155         LOAD_GPR_C
0156         "vmrun %[vmcb_gpa]\n\t"
0157         SAVE_GPR_C
0158         "mov 0x170(%[vmcb]), %%r15\n\t" // rflags
0159         "mov %%r15, rflags\n\t"
0160         "mov 0x1f8(%[vmcb]), %%r15\n\t" // rax
0161         "mov %%r15, guest_regs\n\t"
0162         "vmsave %[vmcb_gpa]\n\t"
0163         : : [vmcb] "r" (vmcb), [vmcb_gpa] "a" (vmcb_gpa)
0164         : "r15", "memory");
0165 }
0166
0167 /*
0168  * Open SEV_DEV_PATH if available, otherwise exit the entire program.
0169  *
0170  * Return:
0171  *   The opened file descriptor of /dev/sev.
0172  */
0173 int open_sev_dev_path_or_exit(void)
0174 {
0175     return open_path_or_exit(SEV_DEV_PATH, 0);
0176 }