arch/x86/kvm/kvm_onhyperv.c

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