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