drivers/hv/hv_common.c

   1 // SPDX-License-Identifier: GPL-2.0
   2
   3 /*
   4  * Architecture neutral utility routines for interacting with
   5  * Hyper-V. This file is specifically for code that must be
   6  * built-in to the kernel image when CONFIG_HYPERV is set
   7  * (vs. being in a module) because it is called from architecture
   8  * specific code under arch/.
   9  *
  10  * Copyright (C) 2021, Microsoft, Inc.
  11  *
  12  * Author : Michael Kelley <mikelley@microsoft.com>
  13  */
  14
  15 #include <linux/types.h>
  16 #include <linux/acpi.h>
  17 #include <linux/export.h>
  18 #include <linux/bitfield.h>
  19 #include <linux/cpumask.h>
  20 #include <linux/panic_notifier.h>
  21 #include <linux/ptrace.h>
  22 #include <linux/slab.h>
  23 #include <asm/hyperv-tlfs.h>
  24 #include <asm/mshyperv.h>
  25
  26 /*
  27  * hv_root_partition and ms_hyperv are defined here with other Hyper-V
  28  * specific globals so they are shared across all architectures and are
  29  * built only when CONFIG_HYPERV is defined.  But on x86,
  30  * ms_hyperv_init_platform() is built even when CONFIG_HYPERV is not
  31  * defined, and it uses these two variables.  So mark them as __weak
  32  * here, allowing for an overriding definition in the module containing
  33  * ms_hyperv_init_platform().
  34  */
  35 bool __weak hv_root_partition;
  36 EXPORT_SYMBOL_GPL(hv_root_partition);
  37
  38 struct ms_hyperv_info __weak ms_hyperv;
  39 EXPORT_SYMBOL_GPL(ms_hyperv);
  40
  41 u32 *hv_vp_index;
  42 EXPORT_SYMBOL_GPL(hv_vp_index);
  43
  44 u32 hv_max_vp_index;
  45 EXPORT_SYMBOL_GPL(hv_max_vp_index);
  46
  47 void  __percpu **hyperv_pcpu_input_arg;
  48 EXPORT_SYMBOL_GPL(hyperv_pcpu_input_arg);
  49
  50 void  __percpu **hyperv_pcpu_output_arg;
  51 EXPORT_SYMBOL_GPL(hyperv_pcpu_output_arg);
  52
  53 /*
  54  * Hyper-V specific initialization and shutdown code that is
  55  * common across all architectures.  Called from architecture
  56  * specific initialization functions.
  57  */
  58
  59 void __init hv_common_free(void)
  60 {
  61         kfree(hv_vp_index);
  62         hv_vp_index = NULL;
  63
  64         free_percpu(hyperv_pcpu_output_arg);
  65         hyperv_pcpu_output_arg = NULL;
  66
  67         free_percpu(hyperv_pcpu_input_arg);
  68         hyperv_pcpu_input_arg = NULL;
  69 }
  70
  71 int __init hv_common_init(void)
  72 {
  73         int i;
  74
  75         /*
  76          * Hyper-V expects to get crash register data or kmsg when
  77          * crash enlightment is available and system crashes. Set
  78          * crash_kexec_post_notifiers to be true to make sure that
  79          * calling crash enlightment interface before running kdump
  80          * kernel.
  81          */
  82         if (ms_hyperv.misc_features & HV_FEATURE_GUEST_CRASH_MSR_AVAILABLE)
  83                 crash_kexec_post_notifiers = true;
  84
  85         /*
  86          * Allocate the per-CPU state for the hypercall input arg.
  87          * If this allocation fails, we will not be able to setup
  88          * (per-CPU) hypercall input page and thus this failure is
  89          * fatal on Hyper-V.
  90          */
  91         hyperv_pcpu_input_arg = alloc_percpu(void  *);
  92         BUG_ON(!hyperv_pcpu_input_arg);
  93
  94         /* Allocate the per-CPU state for output arg for root */
  95         if (hv_root_partition) {
  96                 hyperv_pcpu_output_arg = alloc_percpu(void *);
  97                 BUG_ON(!hyperv_pcpu_output_arg);
  98         }
  99
 100         hv_vp_index = kmalloc_array(num_possible_cpus(), sizeof(*hv_vp_index),
 101                                     GFP_KERNEL);
 102         if (!hv_vp_index) {
 103                 hv_common_free();
 104                 return -ENOMEM;
 105         }
 106
 107         for (i = 0; i < num_possible_cpus(); i++)
 108                 hv_vp_index[i] = VP_INVAL;
 109
 110         return 0;
 111 }
 112
 113 /*
 114  * Hyper-V specific initialization and die code for
 115  * individual CPUs that is common across all architectures.
 116  * Called by the CPU hotplug mechanism.
 117  */
 118
 119 int hv_common_cpu_init(unsigned int cpu)
 120 {
 121         void **inputarg, **outputarg;
 122         u64 msr_vp_index;
 123         gfp_t flags;
 124         int pgcount = hv_root_partition ? 2 : 1;
 125
 126         /* hv_cpu_init() can be called with IRQs disabled from hv_resume() */
 127         flags = irqs_disabled() ? GFP_ATOMIC : GFP_KERNEL;
 128
 129         inputarg = (void **)this_cpu_ptr(hyperv_pcpu_input_arg);
 130         *inputarg = kmalloc(pgcount * HV_HYP_PAGE_SIZE, flags);
 131         if (!(*inputarg))
 132                 return -ENOMEM;
 133
 134         if (hv_root_partition) {
 135                 outputarg = (void **)this_cpu_ptr(hyperv_pcpu_output_arg);
 136                 *outputarg = (char *)(*inputarg) + HV_HYP_PAGE_SIZE;
 137         }
 138
 139         msr_vp_index = hv_get_register(HV_REGISTER_VP_INDEX);
 140
 141         hv_vp_index[cpu] = msr_vp_index;
 142
 143         if (msr_vp_index > hv_max_vp_index)
 144                 hv_max_vp_index = msr_vp_index;
 145
 146         return 0;
 147 }
 148
 149 int hv_common_cpu_die(unsigned int cpu)
 150 {
 151         unsigned long flags;
 152         void **inputarg, **outputarg;
 153         void *mem;
 154
 155         local_irq_save(flags);
 156
 157         inputarg = (void **)this_cpu_ptr(hyperv_pcpu_input_arg);
 158         mem = *inputarg;
 159         *inputarg = NULL;
 160
 161         if (hv_root_partition) {
 162                 outputarg = (void **)this_cpu_ptr(hyperv_pcpu_output_arg);
 163                 *outputarg = NULL;
 164         }
 165
 166         local_irq_restore(flags);
 167
 168         kfree(mem);
 169
 170         return 0;
 171 }
 172
 173 /* Bit mask of the extended capability to query: see HV_EXT_CAPABILITY_xxx */
 174 bool hv_query_ext_cap(u64 cap_query)
 175 {
 176         /*
 177          * The address of the 'hv_extended_cap' variable will be used as an
 178          * output parameter to the hypercall below and so it should be
 179          * compatible with 'virt_to_phys'. Which means, it's address should be
 180          * directly mapped. Use 'static' to keep it compatible; stack variables
 181          * can be virtually mapped, making them incompatible with
 182          * 'virt_to_phys'.
 183          * Hypercall input/output addresses should also be 8-byte aligned.
 184          */
 185         static u64 hv_extended_cap __aligned(8);
 186         static bool hv_extended_cap_queried;
 187         u64 status;
 188
 189         /*
 190          * Querying extended capabilities is an extended hypercall. Check if the
 191          * partition supports extended hypercall, first.
 192          */
 193         if (!(ms_hyperv.priv_high & HV_ENABLE_EXTENDED_HYPERCALLS))
 194                 return false;
 195
 196         /* Extended capabilities do not change at runtime. */
 197         if (hv_extended_cap_queried)
 198                 return hv_extended_cap & cap_query;
 199
 200         status = hv_do_hypercall(HV_EXT_CALL_QUERY_CAPABILITIES, NULL,
 201                                  &hv_extended_cap);
 202
 203         /*
 204          * The query extended capabilities hypercall should not fail under
 205          * any normal circumstances. Avoid repeatedly making the hypercall, on
 206          * error.
 207          */
 208         hv_extended_cap_queried = true;
 209         if (!hv_result_success(status)) {
 210                 pr_err("Hyper-V: Extended query capabilities hypercall failed 0x%llx\n",
 211                        status);
 212                 return false;
 213         }
 214
 215         return hv_extended_cap & cap_query;
 216 }
 217 EXPORT_SYMBOL_GPL(hv_query_ext_cap);
 218
 219 bool hv_is_hibernation_supported(void)
 220 {
 221         return !hv_root_partition && acpi_sleep_state_supported(ACPI_STATE_S4);
 222 }
 223 EXPORT_SYMBOL_GPL(hv_is_hibernation_supported);
 224
 225 /*
 226  * Default function to read the Hyper-V reference counter, independent
 227  * of whether Hyper-V enlightened clocks/timers are being used. But on
 228  * architectures where it is used, Hyper-V enlightenment code in
 229  * hyperv_timer.c may override this function.
 230  */
 231 static u64 __hv_read_ref_counter(void)
 232 {
 233         return hv_get_register(HV_REGISTER_TIME_REF_COUNT);
 234 }
 235
 236 u64 (*hv_read_reference_counter)(void) = __hv_read_ref_counter;
 237 EXPORT_SYMBOL_GPL(hv_read_reference_counter);
 238
 239 /* These __weak functions provide default "no-op" behavior and
 240  * may be overridden by architecture specific versions. Architectures
 241  * for which the default "no-op" behavior is sufficient can leave
 242  * them unimplemented and not be cluttered with a bunch of stub
 243  * functions in arch-specific code.
 244  */
 245
 246 bool __weak hv_is_isolation_supported(void)
 247 {
 248         return false;
 249 }
 250 EXPORT_SYMBOL_GPL(hv_is_isolation_supported);
 251
 252 void __weak hv_setup_vmbus_handler(void (*handler)(void))
 253 {
 254 }
 255 EXPORT_SYMBOL_GPL(hv_setup_vmbus_handler);
 256
 257 void __weak hv_remove_vmbus_handler(void)
 258 {
 259 }
 260 EXPORT_SYMBOL_GPL(hv_remove_vmbus_handler);
 261
 262 void __weak hv_setup_kexec_handler(void (*handler)(void))
 263 {
 264 }
 265 EXPORT_SYMBOL_GPL(hv_setup_kexec_handler);
 266
 267 void __weak hv_remove_kexec_handler(void)
 268 {
 269 }
 270 EXPORT_SYMBOL_GPL(hv_remove_kexec_handler);
 271
 272 void __weak hv_setup_crash_handler(void (*handler)(struct pt_regs *regs))
 273 {
 274 }
 275 EXPORT_SYMBOL_GPL(hv_setup_crash_handler);
 276
 277 void __weak hv_remove_crash_handler(void)
 278 {
 279 }
 280 EXPORT_SYMBOL_GPL(hv_remove_crash_handler);
 281
 282 void __weak hyperv_cleanup(void)
 283 {
 284 }
 285 EXPORT_SYMBOL_GPL(hyperv_cleanup);