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