Loading...
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * KVM L1 hypervisor optimizations on Hyper-V.
4 */
5
6#include <linux/kvm_host.h>
7#include <asm/mshyperv.h>
8
9#include "hyperv.h"
10#include "kvm_onhyperv.h"
11
12static int kvm_fill_hv_flush_list_func(struct hv_guest_mapping_flush_list *flush,
13 void *data)
14{
15 struct kvm_tlb_range *range = data;
16
17 return hyperv_fill_flush_guest_mapping_list(flush, range->start_gfn,
18 range->pages);
19}
20
21static inline int hv_remote_flush_root_tdp(hpa_t root_tdp,
22 struct kvm_tlb_range *range)
23{
24 if (range)
25 return hyperv_flush_guest_mapping_range(root_tdp,
26 kvm_fill_hv_flush_list_func, (void *)range);
27 else
28 return hyperv_flush_guest_mapping(root_tdp);
29}
30
31int hv_remote_flush_tlb_with_range(struct kvm *kvm,
32 struct kvm_tlb_range *range)
33{
34 struct kvm_arch *kvm_arch = &kvm->arch;
35 struct kvm_vcpu *vcpu;
36 int ret = 0, nr_unique_valid_roots;
37 unsigned long i;
38 hpa_t root;
39
40 spin_lock(&kvm_arch->hv_root_tdp_lock);
41
42 if (!VALID_PAGE(kvm_arch->hv_root_tdp)) {
43 nr_unique_valid_roots = 0;
44
45 /*
46 * Flush all valid roots, and see if all vCPUs have converged
47 * on a common root, in which case future flushes can skip the
48 * loop and flush the common root.
49 */
50 kvm_for_each_vcpu(i, vcpu, kvm) {
51 root = vcpu->arch.hv_root_tdp;
52 if (!VALID_PAGE(root) || root == kvm_arch->hv_root_tdp)
53 continue;
54
55 /*
56 * Set the tracked root to the first valid root. Keep
57 * this root for the entirety of the loop even if more
58 * roots are encountered as a low effort optimization
59 * to avoid flushing the same (first) root again.
60 */
61 if (++nr_unique_valid_roots == 1)
62 kvm_arch->hv_root_tdp = root;
63
64 if (!ret)
65 ret = hv_remote_flush_root_tdp(root, range);
66
67 /*
68 * Stop processing roots if a failure occurred and
69 * multiple valid roots have already been detected.
70 */
71 if (ret && nr_unique_valid_roots > 1)
72 break;
73 }
74
75 /*
76 * The optimized flush of a single root can't be used if there
77 * are multiple valid roots (obviously).
78 */
79 if (nr_unique_valid_roots > 1)
80 kvm_arch->hv_root_tdp = INVALID_PAGE;
81 } else {
82 ret = hv_remote_flush_root_tdp(kvm_arch->hv_root_tdp, range);
83 }
84
85 spin_unlock(&kvm_arch->hv_root_tdp_lock);
86 return ret;
87}
88EXPORT_SYMBOL_GPL(hv_remote_flush_tlb_with_range);
89
90int hv_remote_flush_tlb(struct kvm *kvm)
91{
92 return hv_remote_flush_tlb_with_range(kvm, NULL);
93}
94EXPORT_SYMBOL_GPL(hv_remote_flush_tlb);
95
96void hv_track_root_tdp(struct kvm_vcpu *vcpu, hpa_t root_tdp)
97{
98 struct kvm_arch *kvm_arch = &vcpu->kvm->arch;
99
100 if (kvm_x86_ops.tlb_remote_flush == hv_remote_flush_tlb) {
101 spin_lock(&kvm_arch->hv_root_tdp_lock);
102 vcpu->arch.hv_root_tdp = root_tdp;
103 if (root_tdp != kvm_arch->hv_root_tdp)
104 kvm_arch->hv_root_tdp = INVALID_PAGE;
105 spin_unlock(&kvm_arch->hv_root_tdp_lock);
106 }
107}
108EXPORT_SYMBOL_GPL(hv_track_root_tdp);
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * KVM L1 hypervisor optimizations on Hyper-V.
4 */
5
6#include <linux/kvm_host.h>
7#include <asm/mshyperv.h>
8
9#include "hyperv.h"
10#include "kvm_onhyperv.h"
11
12static int kvm_fill_hv_flush_list_func(struct hv_guest_mapping_flush_list *flush,
13 void *data)
14{
15 struct kvm_tlb_range *range = data;
16
17 return hyperv_fill_flush_guest_mapping_list(flush, range->start_gfn,
18 range->pages);
19}
20
21static inline int hv_remote_flush_root_tdp(hpa_t root_tdp,
22 struct kvm_tlb_range *range)
23{
24 if (range)
25 return hyperv_flush_guest_mapping_range(root_tdp,
26 kvm_fill_hv_flush_list_func, (void *)range);
27 else
28 return hyperv_flush_guest_mapping(root_tdp);
29}
30
31int hv_remote_flush_tlb_with_range(struct kvm *kvm,
32 struct kvm_tlb_range *range)
33{
34 struct kvm_arch *kvm_arch = &kvm->arch;
35 struct kvm_vcpu *vcpu;
36 int ret = 0, i, nr_unique_valid_roots;
37 hpa_t root;
38
39 spin_lock(&kvm_arch->hv_root_tdp_lock);
40
41 if (!VALID_PAGE(kvm_arch->hv_root_tdp)) {
42 nr_unique_valid_roots = 0;
43
44 /*
45 * Flush all valid roots, and see if all vCPUs have converged
46 * on a common root, in which case future flushes can skip the
47 * loop and flush the common root.
48 */
49 kvm_for_each_vcpu(i, vcpu, kvm) {
50 root = vcpu->arch.hv_root_tdp;
51 if (!VALID_PAGE(root) || root == kvm_arch->hv_root_tdp)
52 continue;
53
54 /*
55 * Set the tracked root to the first valid root. Keep
56 * this root for the entirety of the loop even if more
57 * roots are encountered as a low effort optimization
58 * to avoid flushing the same (first) root again.
59 */
60 if (++nr_unique_valid_roots == 1)
61 kvm_arch->hv_root_tdp = root;
62
63 if (!ret)
64 ret = hv_remote_flush_root_tdp(root, range);
65
66 /*
67 * Stop processing roots if a failure occurred and
68 * multiple valid roots have already been detected.
69 */
70 if (ret && nr_unique_valid_roots > 1)
71 break;
72 }
73
74 /*
75 * The optimized flush of a single root can't be used if there
76 * are multiple valid roots (obviously).
77 */
78 if (nr_unique_valid_roots > 1)
79 kvm_arch->hv_root_tdp = INVALID_PAGE;
80 } else {
81 ret = hv_remote_flush_root_tdp(kvm_arch->hv_root_tdp, range);
82 }
83
84 spin_unlock(&kvm_arch->hv_root_tdp_lock);
85 return ret;
86}
87EXPORT_SYMBOL_GPL(hv_remote_flush_tlb_with_range);
88
89int hv_remote_flush_tlb(struct kvm *kvm)
90{
91 return hv_remote_flush_tlb_with_range(kvm, NULL);
92}
93EXPORT_SYMBOL_GPL(hv_remote_flush_tlb);