KVM: selftests: Simplify KVM_ENABLE_CAP helper APIs

Rework the KVM_ENABLE_CAP helpers to take the cap and arg0; literally
every current user, and likely every future user, wants to set 0 or 1
arguments and nothing else.

Signed-off-by: Sean Christopherson <seanjc@google.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>

diff --git a/tools/testing/selftests/kvm/aarch64/psci_test.c b/tools/testing/selftests/kvm/aarch64/psci_test.c
index 024a840..1a351f3 100644 (file)
--- a/tools/testing/selftests/kvm/aarch64/psci_test.c
+++ b/tools/testing/selftests/kvm/aarch64/psci_test.c
@@ -156,15 +156,6 @@ static void host_test_cpu_on(void)
        kvm_vm_free(vm);
 }
 
-static void enable_system_suspend(struct kvm_vm *vm)
-{
-       struct kvm_enable_cap cap = {
-               .cap = KVM_CAP_ARM_SYSTEM_SUSPEND,
-       };
-
-       vm_enable_cap(vm, &cap);
-}
-
 static void guest_test_system_suspend(void)
 {
        uint64_t ret;
@@ -183,7 +174,7 @@ static void host_test_system_suspend(void)
        struct kvm_vm *vm;
 
        vm = setup_vm(guest_test_system_suspend);
-       enable_system_suspend(vm);
+       vm_enable_cap(vm, KVM_CAP_ARM_SYSTEM_SUSPEND, 0);
 
        vcpu_power_off(vm, VCPU_ID_TARGET);
        run = vcpu_state(vm, VCPU_ID_SOURCE);

diff --git a/tools/testing/selftests/kvm/dirty_log_perf_test.c b/tools/testing/selftests/kvm/dirty_log_perf_test.c
index d60a34c..8aaa094 100644 (file)
--- a/tools/testing/selftests/kvm/dirty_log_perf_test.c
+++ b/tools/testing/selftests/kvm/dirty_log_perf_test.c
@@ -213,7 +213,6 @@ static void run_test(enum vm_guest_mode mode, void *arg)
        struct timespec get_dirty_log_total = (struct timespec){0};
        struct timespec vcpu_dirty_total = (struct timespec){0};
        struct timespec avg;
-       struct kvm_enable_cap cap = {};
        struct timespec clear_dirty_log_total = (struct timespec){0};
 
        vm = perf_test_create_vm(mode, nr_vcpus, guest_percpu_mem_size,
@@ -229,11 +228,9 @@ static void run_test(enum vm_guest_mode mode, void *arg)
 
        bitmaps = alloc_bitmaps(p->slots, pages_per_slot);
 
-       if (dirty_log_manual_caps) {
-               cap.cap = KVM_CAP_MANUAL_DIRTY_LOG_PROTECT2;
-               cap.args[0] = dirty_log_manual_caps;
-               vm_enable_cap(vm, &cap);
-       }
+       if (dirty_log_manual_caps)
+               vm_enable_cap(vm, KVM_CAP_MANUAL_DIRTY_LOG_PROTECT2,
+                             dirty_log_manual_caps);
 
        arch_setup_vm(vm, nr_vcpus);
 

diff --git a/tools/testing/selftests/kvm/dirty_log_test.c b/tools/testing/selftests/kvm/dirty_log_test.c
index 5752486..9dfc861 100644 (file)
--- a/tools/testing/selftests/kvm/dirty_log_test.c
+++ b/tools/testing/selftests/kvm/dirty_log_test.c
@@ -217,16 +217,13 @@ static bool clear_log_supported(void)
 
 static void clear_log_create_vm_done(struct kvm_vm *vm)
 {
-       struct kvm_enable_cap cap = {};
        u64 manual_caps;
 
        manual_caps = kvm_check_cap(KVM_CAP_MANUAL_DIRTY_LOG_PROTECT2);
        TEST_ASSERT(manual_caps, "MANUAL_CAPS is zero!");
        manual_caps &= (KVM_DIRTY_LOG_MANUAL_PROTECT_ENABLE |
                        KVM_DIRTY_LOG_INITIALLY_SET);
-       cap.cap = KVM_CAP_MANUAL_DIRTY_LOG_PROTECT2;
-       cap.args[0] = manual_caps;
-       vm_enable_cap(vm, &cap);
+       vm_enable_cap(vm, KVM_CAP_MANUAL_DIRTY_LOG_PROTECT2, manual_caps);
 }
 
 static void dirty_log_collect_dirty_pages(struct kvm_vm *vm, int slot,

diff --git a/tools/testing/selftests/kvm/include/kvm_util_base.h b/tools/testing/selftests/kvm/include/kvm_util_base.h
index f0afc1d..c9d94c9 100644 (file)
--- a/tools/testing/selftests/kvm/include/kvm_util_base.h
+++ b/tools/testing/selftests/kvm/include/kvm_util_base.h
@@ -231,13 +231,17 @@ static inline int vm_check_cap(struct kvm_vm *vm, long cap)
        return ret;
 }
 
-static inline int __vm_enable_cap(struct kvm_vm *vm, struct kvm_enable_cap *cap)
+static inline int __vm_enable_cap(struct kvm_vm *vm, uint32_t cap, uint64_t arg0)
 {
-       return __vm_ioctl(vm, KVM_ENABLE_CAP, cap);
+       struct kvm_enable_cap enable_cap = { .cap = cap, .args = { arg0 } };
+
+       return __vm_ioctl(vm, KVM_ENABLE_CAP, &enable_cap);
 }
-static inline void vm_enable_cap(struct kvm_vm *vm, struct kvm_enable_cap *cap)
+static inline void vm_enable_cap(struct kvm_vm *vm, uint32_t cap, uint64_t arg0)
 {
-       vm_ioctl(vm, KVM_ENABLE_CAP, cap);
+       struct kvm_enable_cap enable_cap = { .cap = cap, .args = { arg0 } };
+
+       vm_ioctl(vm, KVM_ENABLE_CAP, &enable_cap);
 }
 
 void vm_enable_dirty_ring(struct kvm_vm *vm, uint32_t ring_size);
@@ -363,9 +367,11 @@ void vcpu_run_complete_io(struct kvm_vm *vm, uint32_t vcpuid);
 struct kvm_reg_list *vcpu_get_reg_list(struct kvm_vm *vm, uint32_t vcpuid);
 
 static inline void vcpu_enable_cap(struct kvm_vm *vm, uint32_t vcpu_id,
-                                  struct kvm_enable_cap *cap)
+                                  uint32_t cap, uint64_t arg0)
 {
-       vcpu_ioctl(vm, vcpu_id, KVM_ENABLE_CAP, cap);
+       struct kvm_enable_cap enable_cap = { .cap = cap, .args = { arg0 } };
+
+       vcpu_ioctl(vm, vcpu_id, KVM_ENABLE_CAP, &enable_cap);
 }
 
 static inline void vcpu_set_guest_debug(struct kvm_vm *vm, uint32_t vcpuid,

diff --git a/tools/testing/selftests/kvm/lib/kvm_util.c b/tools/testing/selftests/kvm/lib/kvm_util.c
index 2d82b57..8f670ce 100644 (file)
--- a/tools/testing/selftests/kvm/lib/kvm_util.c
+++ b/tools/testing/selftests/kvm/lib/kvm_util.c
@@ -85,11 +85,7 @@ int kvm_check_cap(long cap)
 
 void vm_enable_dirty_ring(struct kvm_vm *vm, uint32_t ring_size)
 {
-       struct kvm_enable_cap cap = { 0 };
-
-       cap.cap = KVM_CAP_DIRTY_LOG_RING;
-       cap.args[0] = ring_size;
-       vm_enable_cap(vm, &cap);
+       vm_enable_cap(vm, KVM_CAP_DIRTY_LOG_RING, ring_size);
        vm->dirty_ring_size = ring_size;
 }
 

diff --git a/tools/testing/selftests/kvm/lib/x86_64/vmx.c b/tools/testing/selftests/kvm/lib/x86_64/vmx.c
index dbfca8e..a12c0e1 100644 (file)
--- a/tools/testing/selftests/kvm/lib/x86_64/vmx.c
+++ b/tools/testing/selftests/kvm/lib/x86_64/vmx.c
@@ -46,12 +46,8 @@ int vcpu_enable_evmcs(struct kvm_vm *vm, int vcpu_id)
 {
        uint16_t evmcs_ver;
 
-       struct kvm_enable_cap enable_evmcs_cap = {
-               .cap = KVM_CAP_HYPERV_ENLIGHTENED_VMCS,
-                .args[0] = (unsigned long)&evmcs_ver
-       };
-
-       vcpu_enable_cap(vm, vcpu_id, &enable_evmcs_cap);
+       vcpu_enable_cap(vm, vcpu_id, KVM_CAP_HYPERV_ENLIGHTENED_VMCS,
+                       (unsigned long)&evmcs_ver);
 
        /* KVM should return supported EVMCS version range */
        TEST_ASSERT(((evmcs_ver >> 8) >= (evmcs_ver & 0xff)) &&

diff --git a/tools/testing/selftests/kvm/x86_64/emulator_error_test.c b/tools/testing/selftests/kvm/x86_64/emulator_error_test.c
index aeb3850..9c156f9 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/emulator_error_test.c
+++ b/tools/testing/selftests/kvm/x86_64/emulator_error_test.c
@@ -161,10 +161,6 @@ static uint64_t process_ucall(struct kvm_vm *vm)
 
 int main(int argc, char *argv[])
 {
-       struct kvm_enable_cap emul_failure_cap = {
-               .cap = KVM_CAP_EXIT_ON_EMULATION_FAILURE,
-               .args[0] = 1,
-       };
        struct kvm_cpuid_entry2 *entry;
        struct kvm_cpuid2 *cpuid;
        struct kvm_vm *vm;
@@ -192,7 +188,7 @@ int main(int argc, char *argv[])
 
        rc = kvm_check_cap(KVM_CAP_EXIT_ON_EMULATION_FAILURE);
        TEST_ASSERT(rc, "KVM_CAP_EXIT_ON_EMULATION_FAILURE is unavailable");
-       vm_enable_cap(vm, &emul_failure_cap);
+       vm_enable_cap(vm, KVM_CAP_EXIT_ON_EMULATION_FAILURE, 1);
 
        vm_userspace_mem_region_add(vm, VM_MEM_SRC_ANONYMOUS,
                                    MEM_REGION_GPA, MEM_REGION_SLOT,

diff --git a/tools/testing/selftests/kvm/x86_64/fix_hypercall_test.c b/tools/testing/selftests/kvm/x86_64/fix_hypercall_test.c
index 1f5c321..81f9f5b 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/fix_hypercall_test.c
+++ b/tools/testing/selftests/kvm/x86_64/fix_hypercall_test.c
@@ -140,15 +140,13 @@ static void test_fix_hypercall(void)
 
 static void test_fix_hypercall_disabled(void)
 {
-       struct kvm_enable_cap cap = {0};
        struct kvm_vm *vm;
 
        vm = vm_create_default(VCPU_ID, 0, guest_main);
        setup_ud_vector(vm);
 
-       cap.cap = KVM_CAP_DISABLE_QUIRKS2;
-       cap.args[0] = KVM_X86_QUIRK_FIX_HYPERCALL_INSN;
-       vm_enable_cap(vm, &cap);
+       vm_enable_cap(vm, KVM_CAP_DISABLE_QUIRKS2,
+                     KVM_X86_QUIRK_FIX_HYPERCALL_INSN);
 
        ud_expected = true;
        sync_global_to_guest(vm, ud_expected);

diff --git a/tools/testing/selftests/kvm/x86_64/hyperv_features.c b/tools/testing/selftests/kvm/x86_64/hyperv_features.c
index 672915c..7ff6e4d 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/hyperv_features.c
+++ b/tools/testing/selftests/kvm/x86_64/hyperv_features.c
@@ -182,10 +182,6 @@ static void guest_test_msrs_access(void)
        };
        struct kvm_cpuid2 *best;
        vm_vaddr_t msr_gva;
-       struct kvm_enable_cap cap = {
-               .cap = KVM_CAP_HYPERV_ENFORCE_CPUID,
-               .args = {1}
-       };
        struct msr_data *msr;
 
        while (true) {
@@ -196,7 +192,7 @@ static void guest_test_msrs_access(void)
                msr = addr_gva2hva(vm, msr_gva);
 
                vcpu_args_set(vm, VCPU_ID, 1, msr_gva);
-               vcpu_enable_cap(vm, VCPU_ID, &cap);
+               vcpu_enable_cap(vm, VCPU_ID, KVM_CAP_HYPERV_ENFORCE_CPUID, 1);
 
                vcpu_set_hv_cpuid(vm, VCPU_ID);
 
@@ -337,9 +333,7 @@ static void guest_test_msrs_access(void)
                         * Remains unavailable even with KVM_CAP_HYPERV_SYNIC2
                         * capability enabled and guest visible CPUID bit unset.
                         */
-                       cap.cap = KVM_CAP_HYPERV_SYNIC2;
-                       cap.args[0] = 0;
-                       vcpu_enable_cap(vm, VCPU_ID, &cap);
+                       vcpu_enable_cap(vm, VCPU_ID, KVM_CAP_HYPERV_SYNIC2, 0);
                        break;
                case 22:
                        feat.eax |= HV_MSR_SYNIC_AVAILABLE;
@@ -518,10 +512,6 @@ static void guest_test_hcalls_access(void)
        struct kvm_cpuid_entry2 dbg = {
                .function = HYPERV_CPUID_SYNDBG_PLATFORM_CAPABILITIES
        };
-       struct kvm_enable_cap cap = {
-               .cap = KVM_CAP_HYPERV_ENFORCE_CPUID,
-               .args = {1}
-       };
        vm_vaddr_t hcall_page, hcall_params;
        struct hcall_data *hcall;
        struct kvm_cpuid2 *best;
@@ -542,7 +532,7 @@ static void guest_test_hcalls_access(void)
                memset(addr_gva2hva(vm, hcall_params), 0x0, getpagesize());
 
                vcpu_args_set(vm, VCPU_ID, 2, addr_gva2gpa(vm, hcall_page), hcall_params);
-               vcpu_enable_cap(vm, VCPU_ID, &cap);
+               vcpu_enable_cap(vm, VCPU_ID, KVM_CAP_HYPERV_ENFORCE_CPUID, 1);
 
                vcpu_set_hv_cpuid(vm, VCPU_ID);
 

diff --git a/tools/testing/selftests/kvm/x86_64/kvm_pv_test.c b/tools/testing/selftests/kvm/x86_64/kvm_pv_test.c
index 04ed975..5eea3ac 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/kvm_pv_test.c
+++ b/tools/testing/selftests/kvm/x86_64/kvm_pv_test.c
@@ -206,7 +206,6 @@ static void enter_guest(struct kvm_vm *vm)
 
 int main(void)
 {
-       struct kvm_enable_cap cap = {0};
        struct kvm_cpuid2 *best;
        struct kvm_vm *vm;
 
@@ -217,9 +216,7 @@ int main(void)
 
        vm = vm_create_default(VCPU_ID, 0, guest_main);
 
-       cap.cap = KVM_CAP_ENFORCE_PV_FEATURE_CPUID;
-       cap.args[0] = 1;
-       vcpu_enable_cap(vm, VCPU_ID, &cap);
+       vcpu_enable_cap(vm, VCPU_ID, KVM_CAP_ENFORCE_PV_FEATURE_CPUID, 1);
 
        best = kvm_get_supported_cpuid();
        clear_kvm_cpuid_features(best);

diff --git a/tools/testing/selftests/kvm/x86_64/max_vcpuid_cap_test.c b/tools/testing/selftests/kvm/x86_64/max_vcpuid_cap_test.c
index c6fd36a..7211fd8 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/max_vcpuid_cap_test.c
+++ b/tools/testing/selftests/kvm/x86_64/max_vcpuid_cap_test.c
@@ -14,7 +14,6 @@
 int main(int argc, char *argv[])
 {
        struct kvm_vm *vm;
-       struct kvm_enable_cap cap = { 0 };
        int ret;
 
        vm = vm_create(0);
@@ -23,21 +22,16 @@ int main(int argc, char *argv[])
        ret = vm_check_cap(vm, KVM_CAP_MAX_VCPU_ID);
 
        /* Try to set KVM_CAP_MAX_VCPU_ID beyond KVM cap */
-       cap.cap = KVM_CAP_MAX_VCPU_ID;
-       cap.args[0] = ret + 1;
-       ret = __vm_enable_cap(vm, &cap);
+       ret = __vm_enable_cap(vm, KVM_CAP_MAX_VCPU_ID, ret + 1);
        TEST_ASSERT(ret < 0,
                    "Setting KVM_CAP_MAX_VCPU_ID beyond KVM cap should fail");
 
        /* Set KVM_CAP_MAX_VCPU_ID */
-       cap.cap = KVM_CAP_MAX_VCPU_ID;
-       cap.args[0] = MAX_VCPU_ID;
-       vm_enable_cap(vm, &cap);
+       vm_enable_cap(vm, KVM_CAP_MAX_VCPU_ID, MAX_VCPU_ID);
 
 
        /* Try to set KVM_CAP_MAX_VCPU_ID again */
-       cap.args[0] = MAX_VCPU_ID + 1;
-       ret = __vm_enable_cap(vm, &cap);
+       ret = __vm_enable_cap(vm, KVM_CAP_MAX_VCPU_ID, MAX_VCPU_ID + 1);
        TEST_ASSERT(ret < 0,
                    "Setting KVM_CAP_MAX_VCPU_ID multiple times should fail");
 

diff --git a/tools/testing/selftests/kvm/x86_64/platform_info_test.c b/tools/testing/selftests/kvm/x86_64/platform_info_test.c
index 1e89688..e79c045 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/platform_info_test.c
+++ b/tools/testing/selftests/kvm/x86_64/platform_info_test.c
@@ -35,22 +35,12 @@ static void guest_code(void)
        }
 }
 
-static void set_msr_platform_info_enabled(struct kvm_vm *vm, bool enable)
-{
-       struct kvm_enable_cap cap = {};
-
-       cap.cap = KVM_CAP_MSR_PLATFORM_INFO;
-       cap.flags = 0;
-       cap.args[0] = (int)enable;
-       vm_enable_cap(vm, &cap);
-}
-
 static void test_msr_platform_info_enabled(struct kvm_vm *vm)
 {
        struct kvm_run *run = vcpu_state(vm, VCPU_ID);
        struct ucall uc;
 
-       set_msr_platform_info_enabled(vm, true);
+       vm_enable_cap(vm, KVM_CAP_MSR_PLATFORM_INFO, true);
        vcpu_run(vm, VCPU_ID);
        TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
                        "Exit_reason other than KVM_EXIT_IO: %u (%s),\n",
@@ -69,7 +59,7 @@ static void test_msr_platform_info_disabled(struct kvm_vm *vm)
 {
        struct kvm_run *run = vcpu_state(vm, VCPU_ID);
 
-       set_msr_platform_info_enabled(vm, false);
+       vm_enable_cap(vm, KVM_CAP_MSR_PLATFORM_INFO, false);
        vcpu_run(vm, VCPU_ID);
        TEST_ASSERT(run->exit_reason == KVM_EXIT_SHUTDOWN,
                        "Exit_reason other than KVM_EXIT_SHUTDOWN: %u (%s)\n",

diff --git a/tools/testing/selftests/kvm/x86_64/pmu_event_filter_test.c b/tools/testing/selftests/kvm/x86_64/pmu_event_filter_test.c
index 84cd5e7..9ec6ba2 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/pmu_event_filter_test.c
+++ b/tools/testing/selftests/kvm/x86_64/pmu_event_filter_test.c
@@ -360,7 +360,6 @@ static void test_pmu_config_disable(void (*guest_code)(void))
 {
        int r;
        struct kvm_vm *vm;
-       struct kvm_enable_cap cap = { 0 };
 
        r = kvm_check_cap(KVM_CAP_PMU_CAPABILITY);
        if (!(r & KVM_PMU_CAP_DISABLE))
@@ -368,9 +367,7 @@ static void test_pmu_config_disable(void (*guest_code)(void))
 
        vm = vm_create_without_vcpus(VM_MODE_DEFAULT, DEFAULT_GUEST_PHY_PAGES);
 
-       cap.cap = KVM_CAP_PMU_CAPABILITY;
-       cap.args[0] = KVM_PMU_CAP_DISABLE;
-       vm_enable_cap(vm, &cap);
+       vm_enable_cap(vm, KVM_CAP_PMU_CAPABILITY, KVM_PMU_CAP_DISABLE);
 
        vm_vcpu_add_default(vm, VCPU_ID, guest_code);
        vm_init_descriptor_tables(vm);

diff --git a/tools/testing/selftests/kvm/x86_64/sev_migrate_tests.c b/tools/testing/selftests/kvm/x86_64/sev_migrate_tests.c
index f127f2f..e814748 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/sev_migrate_tests.c
+++ b/tools/testing/selftests/kvm/x86_64/sev_migrate_tests.c
@@ -82,12 +82,7 @@ static struct kvm_vm *aux_vm_create(bool with_vcpus)
 
 static int __sev_migrate_from(struct kvm_vm *dst, struct kvm_vm *src)
 {
-       struct kvm_enable_cap cap = {
-               .cap = KVM_CAP_VM_MOVE_ENC_CONTEXT_FROM,
-               .args = { src->fd }
-       };
-
-       return __vm_enable_cap(dst, &cap);
+       return __vm_enable_cap(dst, KVM_CAP_VM_MOVE_ENC_CONTEXT_FROM, src->fd);
 }
 
 
@@ -223,12 +218,7 @@ out:
 
 static int __sev_mirror_create(struct kvm_vm *dst, struct kvm_vm *src)
 {
-       struct kvm_enable_cap cap = {
-               .cap = KVM_CAP_VM_COPY_ENC_CONTEXT_FROM,
-               .args = { src->fd }
-       };
-
-       return __vm_enable_cap(dst, &cap);
+       return __vm_enable_cap(dst, KVM_CAP_VM_COPY_ENC_CONTEXT_FROM, src->fd);
 }
 
 

diff --git a/tools/testing/selftests/kvm/x86_64/triple_fault_event_test.c b/tools/testing/selftests/kvm/x86_64/triple_fault_event_test.c
index 6637814..68e0f1c 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/triple_fault_event_test.c
+++ b/tools/testing/selftests/kvm/x86_64/triple_fault_event_test.c
@@ -46,11 +46,6 @@ int main(void)
        vm_vaddr_t vmx_pages_gva;
        struct ucall uc;
 
-       struct kvm_enable_cap cap = {
-               .cap = KVM_CAP_X86_TRIPLE_FAULT_EVENT,
-               .args = {1}
-       };
-
        if (!nested_vmx_supported()) {
                print_skip("Nested VMX not supported");
                exit(KSFT_SKIP);
@@ -62,7 +57,7 @@ int main(void)
        }
 
        vm = vm_create_default(VCPU_ID, 0, (void *) l1_guest_code);
-       vm_enable_cap(vm, &cap);
+       vm_enable_cap(vm, KVM_CAP_X86_TRIPLE_FAULT_EVENT, 1);
 
        run = vcpu_state(vm, VCPU_ID);
        vcpu_alloc_vmx(vm, &vmx_pages_gva);

diff --git a/tools/testing/selftests/kvm/x86_64/userspace_msr_exit_test.c b/tools/testing/selftests/kvm/x86_64/userspace_msr_exit_test.c
index e3e20e8..23e9292 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/userspace_msr_exit_test.c
+++ b/tools/testing/selftests/kvm/x86_64/userspace_msr_exit_test.c
@@ -550,11 +550,8 @@ static void run_guest_then_process_ucall_done(struct kvm_vm *vm)
        process_ucall_done(vm);
 }
 
-static void test_msr_filter_allow(void) {
-       struct kvm_enable_cap cap = {
-               .cap = KVM_CAP_X86_USER_SPACE_MSR,
-               .args[0] = KVM_MSR_EXIT_REASON_FILTER,
-       };
+static void test_msr_filter_allow(void)
+{
        struct kvm_vm *vm;
        int rc;
 
@@ -564,7 +561,7 @@ static void test_msr_filter_allow(void) {
 
        rc = kvm_check_cap(KVM_CAP_X86_USER_SPACE_MSR);
        TEST_ASSERT(rc, "KVM_CAP_X86_USER_SPACE_MSR is available");
-       vm_enable_cap(vm, &cap);
+       vm_enable_cap(vm, KVM_CAP_X86_USER_SPACE_MSR, KVM_MSR_EXIT_REASON_FILTER);
 
        rc = kvm_check_cap(KVM_CAP_X86_MSR_FILTER);
        TEST_ASSERT(rc, "KVM_CAP_X86_MSR_FILTER is available");
@@ -673,13 +670,8 @@ static void handle_wrmsr(struct kvm_run *run)
        }
 }
 
-static void test_msr_filter_deny(void) {
-       struct kvm_enable_cap cap = {
-               .cap = KVM_CAP_X86_USER_SPACE_MSR,
-               .args[0] = KVM_MSR_EXIT_REASON_INVAL |
-                          KVM_MSR_EXIT_REASON_UNKNOWN |
-                          KVM_MSR_EXIT_REASON_FILTER,
-       };
+static void test_msr_filter_deny(void)
+{
        struct kvm_vm *vm;
        struct kvm_run *run;
        int rc;
@@ -691,7 +683,9 @@ static void test_msr_filter_deny(void) {
 
        rc = kvm_check_cap(KVM_CAP_X86_USER_SPACE_MSR);
        TEST_ASSERT(rc, "KVM_CAP_X86_USER_SPACE_MSR is available");
-       vm_enable_cap(vm, &cap);
+       vm_enable_cap(vm, KVM_CAP_X86_USER_SPACE_MSR, KVM_MSR_EXIT_REASON_INVAL |
+                                                     KVM_MSR_EXIT_REASON_UNKNOWN |
+                                                     KVM_MSR_EXIT_REASON_FILTER);
 
        rc = kvm_check_cap(KVM_CAP_X86_MSR_FILTER);
        TEST_ASSERT(rc, "KVM_CAP_X86_MSR_FILTER is available");
@@ -726,11 +720,8 @@ done:
        kvm_vm_free(vm);
 }
 
-static void test_msr_permission_bitmap(void) {
-       struct kvm_enable_cap cap = {
-               .cap = KVM_CAP_X86_USER_SPACE_MSR,
-               .args[0] = KVM_MSR_EXIT_REASON_FILTER,
-       };
+static void test_msr_permission_bitmap(void)
+{
        struct kvm_vm *vm;
        int rc;
 
@@ -740,7 +731,7 @@ static void test_msr_permission_bitmap(void) {
 
        rc = kvm_check_cap(KVM_CAP_X86_USER_SPACE_MSR);
        TEST_ASSERT(rc, "KVM_CAP_X86_USER_SPACE_MSR is available");
-       vm_enable_cap(vm, &cap);
+       vm_enable_cap(vm, KVM_CAP_X86_USER_SPACE_MSR, KVM_MSR_EXIT_REASON_FILTER);
 
        rc = kvm_check_cap(KVM_CAP_X86_MSR_FILTER);
        TEST_ASSERT(rc, "KVM_CAP_X86_MSR_FILTER is available");