tools/testing/selftests/kvm/x86_64/svm_int_ctl_test.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * svm_int_ctl_test
   4  *
   5  * Copyright (C) 2021, Red Hat, Inc.
   6  *
   7  * Nested SVM testing: test simultaneous use of V_IRQ from L1 and L0.
   8  */
   9
  10 #include "test_util.h"
  11 #include "kvm_util.h"
  12 #include "processor.h"
  13 #include "svm_util.h"
  14 #include "apic.h"
  15
  16 bool vintr_irq_called;
  17 bool intr_irq_called;
  18
  19 #define VINTR_IRQ_NUMBER 0x20
  20 #define INTR_IRQ_NUMBER 0x30
  21
  22 static void vintr_irq_handler(struct ex_regs *regs)
  23 {
  24         vintr_irq_called = true;
  25 }
  26
  27 static void intr_irq_handler(struct ex_regs *regs)
  28 {
  29         x2apic_write_reg(APIC_EOI, 0x00);
  30         intr_irq_called = true;
  31 }
  32
  33 static void l2_guest_code(struct svm_test_data *svm)
  34 {
  35         /* This code raises interrupt INTR_IRQ_NUMBER in the L1's LAPIC,
  36          * and since L1 didn't enable virtual interrupt masking,
  37          * L2 should receive it and not L1.
  38          *
  39          * L2 also has virtual interrupt 'VINTR_IRQ_NUMBER' pending in V_IRQ
  40          * so it should also receive it after the following 'sti'.
  41          */
  42         x2apic_write_reg(APIC_ICR,
  43                 APIC_DEST_SELF | APIC_INT_ASSERT | INTR_IRQ_NUMBER);
  44
  45         __asm__ __volatile__(
  46                 "sti\n"
  47                 "nop\n"
  48         );
  49
  50         GUEST_ASSERT(vintr_irq_called);
  51         GUEST_ASSERT(intr_irq_called);
  52
  53         __asm__ __volatile__(
  54                 "vmcall\n"
  55         );
  56 }
  57
  58 static void l1_guest_code(struct svm_test_data *svm)
  59 {
  60         #define L2_GUEST_STACK_SIZE 64
  61         unsigned long l2_guest_stack[L2_GUEST_STACK_SIZE];
  62         struct vmcb *vmcb = svm->vmcb;
  63
  64         x2apic_enable();
  65
  66         /* Prepare for L2 execution. */
  67         generic_svm_setup(svm, l2_guest_code,
  68                           &l2_guest_stack[L2_GUEST_STACK_SIZE]);
  69
  70         /* No virtual interrupt masking */
  71         vmcb->control.int_ctl &= ~V_INTR_MASKING_MASK;
  72
  73         /* No intercepts for real and virtual interrupts */
  74         vmcb->control.intercept &= ~(BIT(INTERCEPT_INTR) | BIT(INTERCEPT_VINTR));
  75
  76         /* Make a virtual interrupt VINTR_IRQ_NUMBER pending */
  77         vmcb->control.int_ctl |= V_IRQ_MASK | (0x1 << V_INTR_PRIO_SHIFT);
  78         vmcb->control.int_vector = VINTR_IRQ_NUMBER;
  79
  80         run_guest(vmcb, svm->vmcb_gpa);
  81         GUEST_ASSERT(vmcb->control.exit_code == SVM_EXIT_VMMCALL);
  82         GUEST_DONE();
  83 }
  84
  85 int main(int argc, char *argv[])
  86 {
  87         struct kvm_vcpu *vcpu;
  88         vm_vaddr_t svm_gva;
  89         struct kvm_vm *vm;
  90         struct ucall uc;
  91
  92         TEST_REQUIRE(kvm_cpu_has(X86_FEATURE_SVM));
  93
  94         vm = vm_create_with_one_vcpu(&vcpu, l1_guest_code);
  95
  96         vm_install_exception_handler(vm, VINTR_IRQ_NUMBER, vintr_irq_handler);
  97         vm_install_exception_handler(vm, INTR_IRQ_NUMBER, intr_irq_handler);
  98
  99         vcpu_alloc_svm(vm, &svm_gva);
 100         vcpu_args_set(vcpu, 1, svm_gva);
 101
 102         vcpu_run(vcpu);
 103         TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
 104
 105         switch (get_ucall(vcpu, &uc)) {
 106         case UCALL_ABORT:
 107                 REPORT_GUEST_ASSERT(uc);
 108                 break;
 109                 /* NOT REACHED */
 110         case UCALL_DONE:
 111                 goto done;
 112         default:
 113                 TEST_FAIL("Unknown ucall 0x%lx.", uc.cmd);
 114         }
 115 done:
 116         kvm_vm_free(vm);
 117         return 0;
 118 }