| // SPDX-License-Identifier: GPL-2.0 | |
| /* | |
| * Hyper-V HvFlushVirtualAddress{List,Space}{,Ex} tests | |
| * | |
| * Copyright (C) 2022, Red Hat, Inc. | |
| * | |
| */ | |
| #include <asm/barrier.h> | |
| #include <pthread.h> | |
| #include <inttypes.h> | |
| #include "kvm_util.h" | |
| #include "processor.h" | |
| #include "hyperv.h" | |
| #include "test_util.h" | |
| #include "vmx.h" | |
| #define WORKER_VCPU_ID_1 2 | |
| #define WORKER_VCPU_ID_2 65 | |
| #define NTRY 100 | |
| #define NTEST_PAGES 2 | |
| struct hv_vpset { | |
| u64 format; | |
| u64 valid_bank_mask; | |
| u64 bank_contents[]; | |
| }; | |
| enum HV_GENERIC_SET_FORMAT { | |
| HV_GENERIC_SET_SPARSE_4K, | |
| HV_GENERIC_SET_ALL, | |
| }; | |
| #define HV_FLUSH_ALL_PROCESSORS BIT(0) | |
| #define HV_FLUSH_ALL_VIRTUAL_ADDRESS_SPACES BIT(1) | |
| #define HV_FLUSH_NON_GLOBAL_MAPPINGS_ONLY BIT(2) | |
| #define HV_FLUSH_USE_EXTENDED_RANGE_FORMAT BIT(3) | |
| /* HvFlushVirtualAddressSpace, HvFlushVirtualAddressList hypercalls */ | |
| struct hv_tlb_flush { | |
| u64 address_space; | |
| u64 flags; | |
| u64 processor_mask; | |
| u64 gva_list[]; | |
| } __packed; | |
| /* HvFlushVirtualAddressSpaceEx, HvFlushVirtualAddressListEx hypercalls */ | |
| struct hv_tlb_flush_ex { | |
| u64 address_space; | |
| u64 flags; | |
| struct hv_vpset hv_vp_set; | |
| u64 gva_list[]; | |
| } __packed; | |
| /* | |
| * Pass the following info to 'workers' and 'sender' | |
| * - Hypercall page's GVA | |
| * - Hypercall page's GPA | |
| * - Test pages GVA | |
| * - GVAs of the test pages' PTEs | |
| */ | |
| struct test_data { | |
| gva_t hcall_gva; | |
| gpa_t hcall_gpa; | |
| gva_t test_pages; | |
| gva_t test_pages_pte[NTEST_PAGES]; | |
| }; | |
| /* 'Worker' vCPU code checking the contents of the test page */ | |
| static void worker_guest_code(gva_t test_data) | |
| { | |
| struct test_data *data = (struct test_data *)test_data; | |
| u32 vcpu_id = rdmsr(HV_X64_MSR_VP_INDEX); | |
| void *exp_page = (void *)data->test_pages + PAGE_SIZE * NTEST_PAGES; | |
| u64 *this_cpu = (u64 *)(exp_page + vcpu_id * sizeof(u64)); | |
| u64 expected, val; | |
| x2apic_enable(); | |
| wrmsr(HV_X64_MSR_GUEST_OS_ID, HYPERV_LINUX_OS_ID); | |
| for (;;) { | |
| cpu_relax(); | |
| expected = READ_ONCE(*this_cpu); | |
| /* | |
| * Make sure the value in the test page is read after reading | |
| * the expectation for the first time. Pairs with wmb() in | |
| * prepare_to_test(). | |
| */ | |
| rmb(); | |
| val = READ_ONCE(*(u64 *)data->test_pages); | |
| /* | |
| * Make sure the value in the test page is read after before | |
| * reading the expectation for the second time. Pairs with wmb() | |
| * post_test(). | |
| */ | |
| rmb(); | |
| /* | |
| * '0' indicates the sender is between iterations, wait until | |
| * the sender is ready for this vCPU to start checking again. | |
| */ | |
| if (!expected) | |
| continue; | |
| /* | |
| * Re-read the per-vCPU byte to ensure the sender didn't move | |
| * onto a new iteration. | |
| */ | |
| if (expected != READ_ONCE(*this_cpu)) | |
| continue; | |
| GUEST_ASSERT(val == expected); | |
| } | |
| } | |
| /* | |
| * Write per-CPU info indicating what each 'worker' CPU is supposed to see in | |
| * test page. '0' means don't check. | |
| */ | |
| static void set_expected_val(void *addr, u64 val, int vcpu_id) | |
| { | |
| void *exp_page = addr + PAGE_SIZE * NTEST_PAGES; | |
| *(u64 *)(exp_page + vcpu_id * sizeof(u64)) = val; | |
| } | |
| /* | |
| * Update PTEs swapping two test pages. | |
| * TODO: use swap()/xchg() when these are provided. | |
| */ | |
| static void swap_two_test_pages(gpa_t pte_gva1, gpa_t pte_gva2) | |
| { | |
| u64 tmp = *(u64 *)pte_gva1; | |
| *(u64 *)pte_gva1 = *(u64 *)pte_gva2; | |
| *(u64 *)pte_gva2 = tmp; | |
| } | |
| /* | |
| * Prepare to test: 'disable' workers by setting the expectation to '0', | |
| * clear hypercall input page and then swap two test pages. | |
| */ | |
| static inline void prepare_to_test(struct test_data *data) | |
| { | |
| /* Clear hypercall input page */ | |
| memset((void *)data->hcall_gva, 0, PAGE_SIZE); | |
| /* 'Disable' workers */ | |
| set_expected_val((void *)data->test_pages, 0x0, WORKER_VCPU_ID_1); | |
| set_expected_val((void *)data->test_pages, 0x0, WORKER_VCPU_ID_2); | |
| /* Make sure workers are 'disabled' before we swap PTEs. */ | |
| wmb(); | |
| /* Make sure workers have enough time to notice */ | |
| udelay(100); | |
| /* Swap test page mappings */ | |
| swap_two_test_pages(data->test_pages_pte[0], data->test_pages_pte[1]); | |
| } | |
| /* | |
| * Finalize the test: check hypercall resule set the expected val for | |
| * 'worker' CPUs and give them some time to test. | |
| */ | |
| static inline void post_test(struct test_data *data, u64 exp1, u64 exp2) | |
| { | |
| /* Make sure we change the expectation after swapping PTEs */ | |
| wmb(); | |
| /* Set the expectation for workers, '0' means don't test */ | |
| set_expected_val((void *)data->test_pages, exp1, WORKER_VCPU_ID_1); | |
| set_expected_val((void *)data->test_pages, exp2, WORKER_VCPU_ID_2); | |
| /* Make sure workers have enough time to test */ | |
| udelay(100); | |
| } | |
| #define TESTVAL1 0x0101010101010101 | |
| #define TESTVAL2 0x0202020202020202 | |
| /* Main vCPU doing the test */ | |
| static void sender_guest_code(gva_t test_data) | |
| { | |
| struct test_data *data = (struct test_data *)test_data; | |
| struct hv_tlb_flush *flush = (struct hv_tlb_flush *)data->hcall_gva; | |
| struct hv_tlb_flush_ex *flush_ex = (struct hv_tlb_flush_ex *)data->hcall_gva; | |
| gpa_t hcall_gpa = data->hcall_gpa; | |
| int i, stage = 1; | |
| wrmsr(HV_X64_MSR_GUEST_OS_ID, HYPERV_LINUX_OS_ID); | |
| wrmsr(HV_X64_MSR_HYPERCALL, data->hcall_gpa); | |
| /* "Slow" hypercalls */ | |
| GUEST_SYNC(stage++); | |
| /* HVCALL_FLUSH_VIRTUAL_ADDRESS_SPACE for WORKER_VCPU_ID_1 */ | |
| for (i = 0; i < NTRY; i++) { | |
| prepare_to_test(data); | |
| flush->flags = HV_FLUSH_ALL_VIRTUAL_ADDRESS_SPACES; | |
| flush->processor_mask = BIT(WORKER_VCPU_ID_1); | |
| hyperv_hypercall(HVCALL_FLUSH_VIRTUAL_ADDRESS_SPACE, hcall_gpa, | |
| hcall_gpa + PAGE_SIZE); | |
| post_test(data, i % 2 ? TESTVAL1 : TESTVAL2, 0x0); | |
| } | |
| GUEST_SYNC(stage++); | |
| /* HVCALL_FLUSH_VIRTUAL_ADDRESS_LIST for WORKER_VCPU_ID_1 */ | |
| for (i = 0; i < NTRY; i++) { | |
| prepare_to_test(data); | |
| flush->flags = HV_FLUSH_ALL_VIRTUAL_ADDRESS_SPACES; | |
| flush->processor_mask = BIT(WORKER_VCPU_ID_1); | |
| flush->gva_list[0] = (u64)data->test_pages; | |
| hyperv_hypercall(HVCALL_FLUSH_VIRTUAL_ADDRESS_LIST | | |
| (1UL << HV_HYPERCALL_REP_COMP_OFFSET), | |
| hcall_gpa, hcall_gpa + PAGE_SIZE); | |
| post_test(data, i % 2 ? TESTVAL1 : TESTVAL2, 0x0); | |
| } | |
| GUEST_SYNC(stage++); | |
| /* HVCALL_FLUSH_VIRTUAL_ADDRESS_SPACE for HV_FLUSH_ALL_PROCESSORS */ | |
| for (i = 0; i < NTRY; i++) { | |
| prepare_to_test(data); | |
| flush->flags = HV_FLUSH_ALL_VIRTUAL_ADDRESS_SPACES | | |
| HV_FLUSH_ALL_PROCESSORS; | |
| flush->processor_mask = 0; | |
| hyperv_hypercall(HVCALL_FLUSH_VIRTUAL_ADDRESS_SPACE, hcall_gpa, | |
| hcall_gpa + PAGE_SIZE); | |
| post_test(data, i % 2 ? TESTVAL1 : TESTVAL2, i % 2 ? TESTVAL1 : TESTVAL2); | |
| } | |
| GUEST_SYNC(stage++); | |
| /* HVCALL_FLUSH_VIRTUAL_ADDRESS_LIST for HV_FLUSH_ALL_PROCESSORS */ | |
| for (i = 0; i < NTRY; i++) { | |
| prepare_to_test(data); | |
| flush->flags = HV_FLUSH_ALL_VIRTUAL_ADDRESS_SPACES | | |
| HV_FLUSH_ALL_PROCESSORS; | |
| flush->gva_list[0] = (u64)data->test_pages; | |
| hyperv_hypercall(HVCALL_FLUSH_VIRTUAL_ADDRESS_LIST | | |
| (1UL << HV_HYPERCALL_REP_COMP_OFFSET), | |
| hcall_gpa, hcall_gpa + PAGE_SIZE); | |
| post_test(data, i % 2 ? TESTVAL1 : TESTVAL2, | |
| i % 2 ? TESTVAL1 : TESTVAL2); | |
| } | |
| GUEST_SYNC(stage++); | |
| /* HVCALL_FLUSH_VIRTUAL_ADDRESS_SPACE_EX for WORKER_VCPU_ID_2 */ | |
| for (i = 0; i < NTRY; i++) { | |
| prepare_to_test(data); | |
| flush_ex->flags = HV_FLUSH_ALL_VIRTUAL_ADDRESS_SPACES; | |
| flush_ex->hv_vp_set.format = HV_GENERIC_SET_SPARSE_4K; | |
| flush_ex->hv_vp_set.valid_bank_mask = BIT_ULL(WORKER_VCPU_ID_2 / 64); | |
| flush_ex->hv_vp_set.bank_contents[0] = BIT_ULL(WORKER_VCPU_ID_2 % 64); | |
| hyperv_hypercall(HVCALL_FLUSH_VIRTUAL_ADDRESS_SPACE_EX | | |
| (1 << HV_HYPERCALL_VARHEAD_OFFSET), | |
| hcall_gpa, hcall_gpa + PAGE_SIZE); | |
| post_test(data, 0x0, i % 2 ? TESTVAL1 : TESTVAL2); | |
| } | |
| GUEST_SYNC(stage++); | |
| /* HVCALL_FLUSH_VIRTUAL_ADDRESS_LIST_EX for WORKER_VCPU_ID_2 */ | |
| for (i = 0; i < NTRY; i++) { | |
| prepare_to_test(data); | |
| flush_ex->flags = HV_FLUSH_ALL_VIRTUAL_ADDRESS_SPACES; | |
| flush_ex->hv_vp_set.format = HV_GENERIC_SET_SPARSE_4K; | |
| flush_ex->hv_vp_set.valid_bank_mask = BIT_ULL(WORKER_VCPU_ID_2 / 64); | |
| flush_ex->hv_vp_set.bank_contents[0] = BIT_ULL(WORKER_VCPU_ID_2 % 64); | |
| /* bank_contents and gva_list occupy the same space, thus [1] */ | |
| flush_ex->gva_list[1] = (u64)data->test_pages; | |
| hyperv_hypercall(HVCALL_FLUSH_VIRTUAL_ADDRESS_LIST_EX | | |
| (1 << HV_HYPERCALL_VARHEAD_OFFSET) | | |
| (1UL << HV_HYPERCALL_REP_COMP_OFFSET), | |
| hcall_gpa, hcall_gpa + PAGE_SIZE); | |
| post_test(data, 0x0, i % 2 ? TESTVAL1 : TESTVAL2); | |
| } | |
| GUEST_SYNC(stage++); | |
| /* HVCALL_FLUSH_VIRTUAL_ADDRESS_SPACE_EX for both vCPUs */ | |
| for (i = 0; i < NTRY; i++) { | |
| prepare_to_test(data); | |
| flush_ex->flags = HV_FLUSH_ALL_VIRTUAL_ADDRESS_SPACES; | |
| flush_ex->hv_vp_set.format = HV_GENERIC_SET_SPARSE_4K; | |
| flush_ex->hv_vp_set.valid_bank_mask = BIT_ULL(WORKER_VCPU_ID_2 / 64) | | |
| BIT_ULL(WORKER_VCPU_ID_1 / 64); | |
| flush_ex->hv_vp_set.bank_contents[0] = BIT_ULL(WORKER_VCPU_ID_1 % 64); | |
| flush_ex->hv_vp_set.bank_contents[1] = BIT_ULL(WORKER_VCPU_ID_2 % 64); | |
| hyperv_hypercall(HVCALL_FLUSH_VIRTUAL_ADDRESS_SPACE_EX | | |
| (2 << HV_HYPERCALL_VARHEAD_OFFSET), | |
| hcall_gpa, hcall_gpa + PAGE_SIZE); | |
| post_test(data, i % 2 ? TESTVAL1 : TESTVAL2, | |
| i % 2 ? TESTVAL1 : TESTVAL2); | |
| } | |
| GUEST_SYNC(stage++); | |
| /* HVCALL_FLUSH_VIRTUAL_ADDRESS_LIST_EX for both vCPUs */ | |
| for (i = 0; i < NTRY; i++) { | |
| prepare_to_test(data); | |
| flush_ex->flags = HV_FLUSH_ALL_VIRTUAL_ADDRESS_SPACES; | |
| flush_ex->hv_vp_set.format = HV_GENERIC_SET_SPARSE_4K; | |
| flush_ex->hv_vp_set.valid_bank_mask = BIT_ULL(WORKER_VCPU_ID_1 / 64) | | |
| BIT_ULL(WORKER_VCPU_ID_2 / 64); | |
| flush_ex->hv_vp_set.bank_contents[0] = BIT_ULL(WORKER_VCPU_ID_1 % 64); | |
| flush_ex->hv_vp_set.bank_contents[1] = BIT_ULL(WORKER_VCPU_ID_2 % 64); | |
| /* bank_contents and gva_list occupy the same space, thus [2] */ | |
| flush_ex->gva_list[2] = (u64)data->test_pages; | |
| hyperv_hypercall(HVCALL_FLUSH_VIRTUAL_ADDRESS_LIST_EX | | |
| (2 << HV_HYPERCALL_VARHEAD_OFFSET) | | |
| (1UL << HV_HYPERCALL_REP_COMP_OFFSET), | |
| hcall_gpa, hcall_gpa + PAGE_SIZE); | |
| post_test(data, i % 2 ? TESTVAL1 : TESTVAL2, | |
| i % 2 ? TESTVAL1 : TESTVAL2); | |
| } | |
| GUEST_SYNC(stage++); | |
| /* HVCALL_FLUSH_VIRTUAL_ADDRESS_SPACE_EX for HV_GENERIC_SET_ALL */ | |
| for (i = 0; i < NTRY; i++) { | |
| prepare_to_test(data); | |
| flush_ex->flags = HV_FLUSH_ALL_VIRTUAL_ADDRESS_SPACES; | |
| flush_ex->hv_vp_set.format = HV_GENERIC_SET_ALL; | |
| hyperv_hypercall(HVCALL_FLUSH_VIRTUAL_ADDRESS_SPACE_EX, | |
| hcall_gpa, hcall_gpa + PAGE_SIZE); | |
| post_test(data, i % 2 ? TESTVAL1 : TESTVAL2, | |
| i % 2 ? TESTVAL1 : TESTVAL2); | |
| } | |
| GUEST_SYNC(stage++); | |
| /* HVCALL_FLUSH_VIRTUAL_ADDRESS_LIST_EX for HV_GENERIC_SET_ALL */ | |
| for (i = 0; i < NTRY; i++) { | |
| prepare_to_test(data); | |
| flush_ex->flags = HV_FLUSH_ALL_VIRTUAL_ADDRESS_SPACES; | |
| flush_ex->hv_vp_set.format = HV_GENERIC_SET_ALL; | |
| flush_ex->gva_list[0] = (u64)data->test_pages; | |
| hyperv_hypercall(HVCALL_FLUSH_VIRTUAL_ADDRESS_LIST_EX | | |
| (1UL << HV_HYPERCALL_REP_COMP_OFFSET), | |
| hcall_gpa, hcall_gpa + PAGE_SIZE); | |
| post_test(data, i % 2 ? TESTVAL1 : TESTVAL2, | |
| i % 2 ? TESTVAL1 : TESTVAL2); | |
| } | |
| /* "Fast" hypercalls */ | |
| GUEST_SYNC(stage++); | |
| /* HVCALL_FLUSH_VIRTUAL_ADDRESS_SPACE for WORKER_VCPU_ID_1 */ | |
| for (i = 0; i < NTRY; i++) { | |
| prepare_to_test(data); | |
| flush->processor_mask = BIT(WORKER_VCPU_ID_1); | |
| hyperv_write_xmm_input(&flush->processor_mask, 1); | |
| hyperv_hypercall(HVCALL_FLUSH_VIRTUAL_ADDRESS_SPACE | | |
| HV_HYPERCALL_FAST_BIT, 0x0, | |
| HV_FLUSH_ALL_VIRTUAL_ADDRESS_SPACES); | |
| post_test(data, i % 2 ? TESTVAL1 : TESTVAL2, 0x0); | |
| } | |
| GUEST_SYNC(stage++); | |
| /* HVCALL_FLUSH_VIRTUAL_ADDRESS_LIST for WORKER_VCPU_ID_1 */ | |
| for (i = 0; i < NTRY; i++) { | |
| prepare_to_test(data); | |
| flush->processor_mask = BIT(WORKER_VCPU_ID_1); | |
| flush->gva_list[0] = (u64)data->test_pages; | |
| hyperv_write_xmm_input(&flush->processor_mask, 1); | |
| hyperv_hypercall(HVCALL_FLUSH_VIRTUAL_ADDRESS_LIST | | |
| HV_HYPERCALL_FAST_BIT | | |
| (1UL << HV_HYPERCALL_REP_COMP_OFFSET), | |
| 0x0, HV_FLUSH_ALL_VIRTUAL_ADDRESS_SPACES); | |
| post_test(data, i % 2 ? TESTVAL1 : TESTVAL2, 0x0); | |
| } | |
| GUEST_SYNC(stage++); | |
| /* HVCALL_FLUSH_VIRTUAL_ADDRESS_SPACE for HV_FLUSH_ALL_PROCESSORS */ | |
| for (i = 0; i < NTRY; i++) { | |
| prepare_to_test(data); | |
| hyperv_write_xmm_input(&flush->processor_mask, 1); | |
| hyperv_hypercall(HVCALL_FLUSH_VIRTUAL_ADDRESS_SPACE | | |
| HV_HYPERCALL_FAST_BIT, 0x0, | |
| HV_FLUSH_ALL_VIRTUAL_ADDRESS_SPACES | | |
| HV_FLUSH_ALL_PROCESSORS); | |
| post_test(data, i % 2 ? TESTVAL1 : TESTVAL2, | |
| i % 2 ? TESTVAL1 : TESTVAL2); | |
| } | |
| GUEST_SYNC(stage++); | |
| /* HVCALL_FLUSH_VIRTUAL_ADDRESS_LIST for HV_FLUSH_ALL_PROCESSORS */ | |
| for (i = 0; i < NTRY; i++) { | |
| prepare_to_test(data); | |
| flush->gva_list[0] = (u64)data->test_pages; | |
| hyperv_write_xmm_input(&flush->processor_mask, 1); | |
| hyperv_hypercall(HVCALL_FLUSH_VIRTUAL_ADDRESS_LIST | | |
| HV_HYPERCALL_FAST_BIT | | |
| (1UL << HV_HYPERCALL_REP_COMP_OFFSET), 0x0, | |
| HV_FLUSH_ALL_VIRTUAL_ADDRESS_SPACES | | |
| HV_FLUSH_ALL_PROCESSORS); | |
| post_test(data, i % 2 ? TESTVAL1 : TESTVAL2, | |
| i % 2 ? TESTVAL1 : TESTVAL2); | |
| } | |
| GUEST_SYNC(stage++); | |
| /* HVCALL_FLUSH_VIRTUAL_ADDRESS_SPACE_EX for WORKER_VCPU_ID_2 */ | |
| for (i = 0; i < NTRY; i++) { | |
| prepare_to_test(data); | |
| flush_ex->hv_vp_set.format = HV_GENERIC_SET_SPARSE_4K; | |
| flush_ex->hv_vp_set.valid_bank_mask = BIT_ULL(WORKER_VCPU_ID_2 / 64); | |
| flush_ex->hv_vp_set.bank_contents[0] = BIT_ULL(WORKER_VCPU_ID_2 % 64); | |
| hyperv_write_xmm_input(&flush_ex->hv_vp_set, 2); | |
| hyperv_hypercall(HVCALL_FLUSH_VIRTUAL_ADDRESS_SPACE_EX | | |
| HV_HYPERCALL_FAST_BIT | | |
| (1 << HV_HYPERCALL_VARHEAD_OFFSET), | |
| 0x0, HV_FLUSH_ALL_VIRTUAL_ADDRESS_SPACES); | |
| post_test(data, 0x0, i % 2 ? TESTVAL1 : TESTVAL2); | |
| } | |
| GUEST_SYNC(stage++); | |
| /* HVCALL_FLUSH_VIRTUAL_ADDRESS_LIST_EX for WORKER_VCPU_ID_2 */ | |
| for (i = 0; i < NTRY; i++) { | |
| prepare_to_test(data); | |
| flush_ex->hv_vp_set.format = HV_GENERIC_SET_SPARSE_4K; | |
| flush_ex->hv_vp_set.valid_bank_mask = BIT_ULL(WORKER_VCPU_ID_2 / 64); | |
| flush_ex->hv_vp_set.bank_contents[0] = BIT_ULL(WORKER_VCPU_ID_2 % 64); | |
| /* bank_contents and gva_list occupy the same space, thus [1] */ | |
| flush_ex->gva_list[1] = (u64)data->test_pages; | |
| hyperv_write_xmm_input(&flush_ex->hv_vp_set, 2); | |
| hyperv_hypercall(HVCALL_FLUSH_VIRTUAL_ADDRESS_LIST_EX | | |
| HV_HYPERCALL_FAST_BIT | | |
| (1 << HV_HYPERCALL_VARHEAD_OFFSET) | | |
| (1UL << HV_HYPERCALL_REP_COMP_OFFSET), | |
| 0x0, HV_FLUSH_ALL_VIRTUAL_ADDRESS_SPACES); | |
| post_test(data, 0x0, i % 2 ? TESTVAL1 : TESTVAL2); | |
| } | |
| GUEST_SYNC(stage++); | |
| /* HVCALL_FLUSH_VIRTUAL_ADDRESS_SPACE_EX for both vCPUs */ | |
| for (i = 0; i < NTRY; i++) { | |
| prepare_to_test(data); | |
| flush_ex->hv_vp_set.format = HV_GENERIC_SET_SPARSE_4K; | |
| flush_ex->hv_vp_set.valid_bank_mask = BIT_ULL(WORKER_VCPU_ID_2 / 64) | | |
| BIT_ULL(WORKER_VCPU_ID_1 / 64); | |
| flush_ex->hv_vp_set.bank_contents[0] = BIT_ULL(WORKER_VCPU_ID_1 % 64); | |
| flush_ex->hv_vp_set.bank_contents[1] = BIT_ULL(WORKER_VCPU_ID_2 % 64); | |
| hyperv_write_xmm_input(&flush_ex->hv_vp_set, 2); | |
| hyperv_hypercall(HVCALL_FLUSH_VIRTUAL_ADDRESS_SPACE_EX | | |
| HV_HYPERCALL_FAST_BIT | | |
| (2 << HV_HYPERCALL_VARHEAD_OFFSET), | |
| 0x0, HV_FLUSH_ALL_VIRTUAL_ADDRESS_SPACES); | |
| post_test(data, i % 2 ? TESTVAL1 : | |
| TESTVAL2, i % 2 ? TESTVAL1 : TESTVAL2); | |
| } | |
| GUEST_SYNC(stage++); | |
| /* HVCALL_FLUSH_VIRTUAL_ADDRESS_LIST_EX for both vCPUs */ | |
| for (i = 0; i < NTRY; i++) { | |
| prepare_to_test(data); | |
| flush_ex->hv_vp_set.format = HV_GENERIC_SET_SPARSE_4K; | |
| flush_ex->hv_vp_set.valid_bank_mask = BIT_ULL(WORKER_VCPU_ID_1 / 64) | | |
| BIT_ULL(WORKER_VCPU_ID_2 / 64); | |
| flush_ex->hv_vp_set.bank_contents[0] = BIT_ULL(WORKER_VCPU_ID_1 % 64); | |
| flush_ex->hv_vp_set.bank_contents[1] = BIT_ULL(WORKER_VCPU_ID_2 % 64); | |
| /* bank_contents and gva_list occupy the same space, thus [2] */ | |
| flush_ex->gva_list[2] = (u64)data->test_pages; | |
| hyperv_write_xmm_input(&flush_ex->hv_vp_set, 3); | |
| hyperv_hypercall(HVCALL_FLUSH_VIRTUAL_ADDRESS_LIST_EX | | |
| HV_HYPERCALL_FAST_BIT | | |
| (2 << HV_HYPERCALL_VARHEAD_OFFSET) | | |
| (1UL << HV_HYPERCALL_REP_COMP_OFFSET), | |
| 0x0, HV_FLUSH_ALL_VIRTUAL_ADDRESS_SPACES); | |
| post_test(data, i % 2 ? TESTVAL1 : TESTVAL2, | |
| i % 2 ? TESTVAL1 : TESTVAL2); | |
| } | |
| GUEST_SYNC(stage++); | |
| /* HVCALL_FLUSH_VIRTUAL_ADDRESS_SPACE_EX for HV_GENERIC_SET_ALL */ | |
| for (i = 0; i < NTRY; i++) { | |
| prepare_to_test(data); | |
| flush_ex->flags = HV_FLUSH_ALL_VIRTUAL_ADDRESS_SPACES; | |
| flush_ex->hv_vp_set.format = HV_GENERIC_SET_ALL; | |
| hyperv_write_xmm_input(&flush_ex->hv_vp_set, 2); | |
| hyperv_hypercall(HVCALL_FLUSH_VIRTUAL_ADDRESS_SPACE_EX | | |
| HV_HYPERCALL_FAST_BIT, | |
| 0x0, HV_FLUSH_ALL_VIRTUAL_ADDRESS_SPACES); | |
| post_test(data, i % 2 ? TESTVAL1 : TESTVAL2, | |
| i % 2 ? TESTVAL1 : TESTVAL2); | |
| } | |
| GUEST_SYNC(stage++); | |
| /* HVCALL_FLUSH_VIRTUAL_ADDRESS_LIST_EX for HV_GENERIC_SET_ALL */ | |
| for (i = 0; i < NTRY; i++) { | |
| prepare_to_test(data); | |
| flush_ex->flags = HV_FLUSH_ALL_VIRTUAL_ADDRESS_SPACES; | |
| flush_ex->hv_vp_set.format = HV_GENERIC_SET_ALL; | |
| flush_ex->gva_list[0] = (u64)data->test_pages; | |
| hyperv_write_xmm_input(&flush_ex->hv_vp_set, 2); | |
| hyperv_hypercall(HVCALL_FLUSH_VIRTUAL_ADDRESS_LIST_EX | | |
| HV_HYPERCALL_FAST_BIT | | |
| (1UL << HV_HYPERCALL_REP_COMP_OFFSET), | |
| 0x0, HV_FLUSH_ALL_VIRTUAL_ADDRESS_SPACES); | |
| post_test(data, i % 2 ? TESTVAL1 : TESTVAL2, | |
| i % 2 ? TESTVAL1 : TESTVAL2); | |
| } | |
| GUEST_DONE(); | |
| } | |
| static void *vcpu_thread(void *arg) | |
| { | |
| struct kvm_vcpu *vcpu = (struct kvm_vcpu *)arg; | |
| struct ucall uc; | |
| int old; | |
| int r; | |
| r = pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &old); | |
| TEST_ASSERT(!r, "pthread_setcanceltype failed on vcpu_id=%u with errno=%d", | |
| vcpu->id, r); | |
| vcpu_run(vcpu); | |
| TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO); | |
| switch (get_ucall(vcpu, &uc)) { | |
| case UCALL_ABORT: | |
| REPORT_GUEST_ASSERT(uc); | |
| /* NOT REACHED */ | |
| default: | |
| TEST_FAIL("Unexpected ucall %lu, vCPU %d", uc.cmd, vcpu->id); | |
| } | |
| return NULL; | |
| } | |
| int main(int argc, char *argv[]) | |
| { | |
| struct kvm_vm *vm; | |
| struct kvm_vcpu *vcpu[3]; | |
| pthread_t threads[2]; | |
| gva_t test_data_page, gva; | |
| gpa_t gpa; | |
| u64 *pte; | |
| struct test_data *data; | |
| struct ucall uc; | |
| int stage = 1, i; | |
| TEST_REQUIRE(kvm_has_cap(KVM_CAP_HYPERV_TLBFLUSH)); | |
| vm = vm_create_with_one_vcpu(&vcpu[0], sender_guest_code); | |
| /* Test data page */ | |
| test_data_page = vm_alloc_page(vm); | |
| data = (struct test_data *)addr_gva2hva(vm, test_data_page); | |
| /* Hypercall input/output */ | |
| data->hcall_gva = vm_alloc_pages(vm, 2); | |
| data->hcall_gpa = addr_gva2gpa(vm, data->hcall_gva); | |
| memset(addr_gva2hva(vm, data->hcall_gva), 0x0, 2 * PAGE_SIZE); | |
| /* | |
| * Test pages: the first one is filled with '0x01's, the second with '0x02's | |
| * and the test will swap their mappings. The third page keeps the indication | |
| * about the current state of mappings. | |
| */ | |
| data->test_pages = vm_alloc_pages(vm, NTEST_PAGES + 1); | |
| for (i = 0; i < NTEST_PAGES; i++) | |
| memset(addr_gva2hva(vm, data->test_pages + PAGE_SIZE * i), | |
| (u8)(i + 1), PAGE_SIZE); | |
| set_expected_val(addr_gva2hva(vm, data->test_pages), 0x0, WORKER_VCPU_ID_1); | |
| set_expected_val(addr_gva2hva(vm, data->test_pages), 0x0, WORKER_VCPU_ID_2); | |
| /* | |
| * Get PTE pointers for test pages and map them inside the guest. | |
| * Use separate page for each PTE for simplicity. | |
| */ | |
| gva = vm_unused_gva_gap(vm, NTEST_PAGES * PAGE_SIZE, KVM_UTIL_MIN_VADDR); | |
| for (i = 0; i < NTEST_PAGES; i++) { | |
| pte = vm_get_pte(vm, data->test_pages + i * PAGE_SIZE); | |
| gpa = addr_hva2gpa(vm, pte); | |
| virt_pg_map(vm, gva + PAGE_SIZE * i, gpa & PAGE_MASK); | |
| data->test_pages_pte[i] = gva + (gpa & ~PAGE_MASK); | |
| } | |
| /* | |
| * Sender vCPU which performs the test: swaps test pages, sets expectation | |
| * for 'workers' and issues TLB flush hypercalls. | |
| */ | |
| vcpu_args_set(vcpu[0], 1, test_data_page); | |
| vcpu_set_hv_cpuid(vcpu[0]); | |
| /* Create worker vCPUs which check the contents of the test pages */ | |
| vcpu[1] = vm_vcpu_add(vm, WORKER_VCPU_ID_1, worker_guest_code); | |
| vcpu_args_set(vcpu[1], 1, test_data_page); | |
| vcpu_set_msr(vcpu[1], HV_X64_MSR_VP_INDEX, WORKER_VCPU_ID_1); | |
| vcpu_set_hv_cpuid(vcpu[1]); | |
| vcpu[2] = vm_vcpu_add(vm, WORKER_VCPU_ID_2, worker_guest_code); | |
| vcpu_args_set(vcpu[2], 1, test_data_page); | |
| vcpu_set_msr(vcpu[2], HV_X64_MSR_VP_INDEX, WORKER_VCPU_ID_2); | |
| vcpu_set_hv_cpuid(vcpu[2]); | |
| kvm_pthread_create(&threads[0], NULL, vcpu_thread, vcpu[1]); | |
| kvm_pthread_create(&threads[1], NULL, vcpu_thread, vcpu[2]); | |
| while (true) { | |
| vcpu_run(vcpu[0]); | |
| TEST_ASSERT_KVM_EXIT_REASON(vcpu[0], KVM_EXIT_IO); | |
| switch (get_ucall(vcpu[0], &uc)) { | |
| case UCALL_SYNC: | |
| TEST_ASSERT(uc.args[1] == stage, | |
| "Unexpected stage: %ld (%d expected)", | |
| uc.args[1], stage); | |
| break; | |
| case UCALL_ABORT: | |
| REPORT_GUEST_ASSERT(uc); | |
| /* NOT REACHED */ | |
| case UCALL_DONE: | |
| goto done; | |
| default: | |
| TEST_FAIL("Unknown ucall %lu", uc.cmd); | |
| } | |
| stage++; | |
| } | |
| done: | |
| kvm_pthread_cancel_join_async(threads[0]); | |
| kvm_pthread_cancel_join_async(threads[1]); | |
| kvm_vm_free(vm); | |
| return 0; | |
| } |