arch/x86/hyperv/nested.c

   1 // SPDX-License-Identifier: GPL-2.0
   2
   3 /*
   4  * Hyper-V nested virtualization code.
   5  *
   6  * Copyright (C) 2018, Microsoft, Inc.
   7  *
   8  * Author : Lan Tianyu <Tianyu.Lan@microsoft.com>
   9  */
  10 #define pr_fmt(fmt)  "Hyper-V: " fmt
  11
  12
  13 #include <linux/types.h>
  14 #include <asm/hyperv-tlfs.h>
  15 #include <asm/mshyperv.h>
  16 #include <asm/tlbflush.h>
  17
  18 #include <asm/trace/hyperv.h>
  19
  20 int hyperv_flush_guest_mapping(u64 as)
  21 {
  22         struct hv_guest_mapping_flush **flush_pcpu;
  23         struct hv_guest_mapping_flush *flush;
  24         u64 status;
  25         unsigned long flags;
  26         int ret = -ENOTSUPP;
  27
  28         if (!hv_hypercall_pg)
  29                 goto fault;
  30
  31         local_irq_save(flags);
  32
  33         flush_pcpu = (struct hv_guest_mapping_flush **)
  34                 this_cpu_ptr(hyperv_pcpu_input_arg);
  35
  36         flush = *flush_pcpu;
  37
  38         if (unlikely(!flush)) {
  39                 local_irq_restore(flags);
  40                 goto fault;
  41         }
  42
  43         flush->address_space = as;
  44         flush->flags = 0;
  45
  46         status = hv_do_hypercall(HVCALL_FLUSH_GUEST_PHYSICAL_ADDRESS_SPACE,
  47                                  flush, NULL);
  48         local_irq_restore(flags);
  49
  50         if (!(status & HV_HYPERCALL_RESULT_MASK))
  51                 ret = 0;
  52
  53 fault:
  54         trace_hyperv_nested_flush_guest_mapping(as, ret);
  55         return ret;
  56 }
  57 EXPORT_SYMBOL_GPL(hyperv_flush_guest_mapping);
  58
  59 int hyperv_fill_flush_guest_mapping_list(
  60                 struct hv_guest_mapping_flush_list *flush,
  61                 u64 start_gfn, u64 pages)
  62 {
  63         u64 cur = start_gfn;
  64         u64 additional_pages;
  65         int gpa_n = 0;
  66
  67         do {
  68                 /*
  69                  * If flush requests exceed max flush count, go back to
  70                  * flush tlbs without range.
  71                  */
  72                 if (gpa_n >= HV_MAX_FLUSH_REP_COUNT)
  73                         return -ENOSPC;
  74
  75                 additional_pages = min_t(u64, pages, HV_MAX_FLUSH_PAGES) - 1;
  76
  77                 flush->gpa_list[gpa_n].page.additional_pages = additional_pages;
  78                 flush->gpa_list[gpa_n].page.largepage = false;
  79                 flush->gpa_list[gpa_n].page.basepfn = cur;
  80
  81                 pages -= additional_pages + 1;
  82                 cur += additional_pages + 1;
  83                 gpa_n++;
  84         } while (pages > 0);
  85
  86         return gpa_n;
  87 }
  88 EXPORT_SYMBOL_GPL(hyperv_fill_flush_guest_mapping_list);
  89
  90 int hyperv_flush_guest_mapping_range(u64 as,
  91                 hyperv_fill_flush_list_func fill_flush_list_func, void *data)
  92 {
  93         struct hv_guest_mapping_flush_list **flush_pcpu;
  94         struct hv_guest_mapping_flush_list *flush;
  95         u64 status = 0;
  96         unsigned long flags;
  97         int ret = -ENOTSUPP;
  98         int gpa_n = 0;
  99
 100         if (!hv_hypercall_pg || !fill_flush_list_func)
 101                 goto fault;
 102
 103         local_irq_save(flags);
 104
 105         flush_pcpu = (struct hv_guest_mapping_flush_list **)
 106                 this_cpu_ptr(hyperv_pcpu_input_arg);
 107
 108         flush = *flush_pcpu;
 109         if (unlikely(!flush)) {
 110                 local_irq_restore(flags);
 111                 goto fault;
 112         }
 113
 114         flush->address_space = as;
 115         flush->flags = 0;
 116
 117         gpa_n = fill_flush_list_func(flush, data);
 118         if (gpa_n < 0) {
 119                 local_irq_restore(flags);
 120                 goto fault;
 121         }
 122
 123         status = hv_do_rep_hypercall(HVCALL_FLUSH_GUEST_PHYSICAL_ADDRESS_LIST,
 124                                      gpa_n, 0, flush, NULL);
 125
 126         local_irq_restore(flags);
 127
 128         if (!(status & HV_HYPERCALL_RESULT_MASK))
 129                 ret = 0;
 130         else
 131                 ret = status;
 132 fault:
 133         trace_hyperv_nested_flush_guest_mapping_range(as, ret);
 134         return ret;
 135 }
 136 EXPORT_SYMBOL_GPL(hyperv_flush_guest_mapping_range);