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 pr_info("Hyper-V: enabling crash_kexec_post_notifiers\n"); 85 } 86 87 /* 88 * Allocate the per-CPU state for the hypercall input arg. 89 * If this allocation fails, we will not be able to setup 90 * (per-CPU) hypercall input page and thus this failure is 91 * fatal on Hyper-V. 92 */ 93 hyperv_pcpu_input_arg = alloc_percpu(void *); 94 BUG_ON(!hyperv_pcpu_input_arg); 95 96 /* Allocate the per-CPU state for output arg for root */ 97 if (hv_root_partition) { 98 hyperv_pcpu_output_arg = alloc_percpu(void *); 99 BUG_ON(!hyperv_pcpu_output_arg); 100 } 101 102 hv_vp_index = kmalloc_array(num_possible_cpus(), sizeof(*hv_vp_index), 103 GFP_KERNEL); 104 if (!hv_vp_index) { 105 hv_common_free(); 106 return -ENOMEM; 107 } 108 109 for (i = 0; i < num_possible_cpus(); i++) 110 hv_vp_index[i] = VP_INVAL; 111 112 return 0; 113 } 114 115 /* 116 * Hyper-V specific initialization and die code for 117 * individual CPUs that is common across all architectures. 118 * Called by the CPU hotplug mechanism. 119 */ 120 121 int hv_common_cpu_init(unsigned int cpu) 122 { 123 void **inputarg, **outputarg; 124 u64 msr_vp_index; 125 gfp_t flags; 126 int pgcount = hv_root_partition ? 2 : 1; 127 128 /* hv_cpu_init() can be called with IRQs disabled from hv_resume() */ 129 flags = irqs_disabled() ? GFP_ATOMIC : GFP_KERNEL; 130 131 inputarg = (void **)this_cpu_ptr(hyperv_pcpu_input_arg); 132 *inputarg = kmalloc(pgcount * HV_HYP_PAGE_SIZE, flags); 133 if (!(*inputarg)) 134 return -ENOMEM; 135 136 if (hv_root_partition) { 137 outputarg = (void **)this_cpu_ptr(hyperv_pcpu_output_arg); 138 *outputarg = (char *)(*inputarg) + HV_HYP_PAGE_SIZE; 139 } 140 141 msr_vp_index = hv_get_register(HV_REGISTER_VP_INDEX); 142 143 hv_vp_index[cpu] = msr_vp_index; 144 145 if (msr_vp_index > hv_max_vp_index) 146 hv_max_vp_index = msr_vp_index; 147 148 return 0; 149 } 150 151 int hv_common_cpu_die(unsigned int cpu) 152 { 153 unsigned long flags; 154 void **inputarg, **outputarg; 155 void *mem; 156 157 local_irq_save(flags); 158 159 inputarg = (void **)this_cpu_ptr(hyperv_pcpu_input_arg); 160 mem = *inputarg; 161 *inputarg = NULL; 162 163 if (hv_root_partition) { 164 outputarg = (void **)this_cpu_ptr(hyperv_pcpu_output_arg); 165 *outputarg = NULL; 166 } 167 168 local_irq_restore(flags); 169 170 kfree(mem); 171 172 return 0; 173 } 174 175 /* Bit mask of the extended capability to query: see HV_EXT_CAPABILITY_xxx */ 176 bool hv_query_ext_cap(u64 cap_query) 177 { 178 /* 179 * The address of the 'hv_extended_cap' variable will be used as an 180 * output parameter to the hypercall below and so it should be 181 * compatible with 'virt_to_phys'. Which means, it's address should be 182 * directly mapped. Use 'static' to keep it compatible; stack variables 183 * can be virtually mapped, making them incompatible with 184 * 'virt_to_phys'. 185 * Hypercall input/output addresses should also be 8-byte aligned. 186 */ 187 static u64 hv_extended_cap __aligned(8); 188 static bool hv_extended_cap_queried; 189 u64 status; 190 191 /* 192 * Querying extended capabilities is an extended hypercall. Check if the 193 * partition supports extended hypercall, first. 194 */ 195 if (!(ms_hyperv.priv_high & HV_ENABLE_EXTENDED_HYPERCALLS)) 196 return false; 197 198 /* Extended capabilities do not change at runtime. */ 199 if (hv_extended_cap_queried) 200 return hv_extended_cap & cap_query; 201 202 status = hv_do_hypercall(HV_EXT_CALL_QUERY_CAPABILITIES, NULL, 203 &hv_extended_cap); 204 205 /* 206 * The query extended capabilities hypercall should not fail under 207 * any normal circumstances. Avoid repeatedly making the hypercall, on 208 * error. 209 */ 210 hv_extended_cap_queried = true; 211 if (!hv_result_success(status)) { 212 pr_err("Hyper-V: Extended query capabilities hypercall failed 0x%llx\n", 213 status); 214 return false; 215 } 216 217 return hv_extended_cap & cap_query; 218 } 219 EXPORT_SYMBOL_GPL(hv_query_ext_cap); 220 221 bool hv_is_hibernation_supported(void) 222 { 223 return !hv_root_partition && acpi_sleep_state_supported(ACPI_STATE_S4); 224 } 225 EXPORT_SYMBOL_GPL(hv_is_hibernation_supported); 226 227 /* 228 * Default function to read the Hyper-V reference counter, independent 229 * of whether Hyper-V enlightened clocks/timers are being used. But on 230 * architectures where it is used, Hyper-V enlightenment code in 231 * hyperv_timer.c may override this function. 232 */ 233 static u64 __hv_read_ref_counter(void) 234 { 235 return hv_get_register(HV_REGISTER_TIME_REF_COUNT); 236 } 237 238 u64 (*hv_read_reference_counter)(void) = __hv_read_ref_counter; 239 EXPORT_SYMBOL_GPL(hv_read_reference_counter); 240 241 /* These __weak functions provide default "no-op" behavior and 242 * may be overridden by architecture specific versions. Architectures 243 * for which the default "no-op" behavior is sufficient can leave 244 * them unimplemented and not be cluttered with a bunch of stub 245 * functions in arch-specific code. 246 */ 247 248 bool __weak hv_is_isolation_supported(void) 249 { 250 return false; 251 } 252 EXPORT_SYMBOL_GPL(hv_is_isolation_supported); 253 254 bool __weak hv_isolation_type_snp(void) 255 { 256 return false; 257 } 258 EXPORT_SYMBOL_GPL(hv_isolation_type_snp); 259 260 void __weak hv_setup_vmbus_handler(void (*handler)(void)) 261 { 262 } 263 EXPORT_SYMBOL_GPL(hv_setup_vmbus_handler); 264 265 void __weak hv_remove_vmbus_handler(void) 266 { 267 } 268 EXPORT_SYMBOL_GPL(hv_remove_vmbus_handler); 269 270 void __weak hv_setup_kexec_handler(void (*handler)(void)) 271 { 272 } 273 EXPORT_SYMBOL_GPL(hv_setup_kexec_handler); 274 275 void __weak hv_remove_kexec_handler(void) 276 { 277 } 278 EXPORT_SYMBOL_GPL(hv_remove_kexec_handler); 279 280 void __weak hv_setup_crash_handler(void (*handler)(struct pt_regs *regs)) 281 { 282 } 283 EXPORT_SYMBOL_GPL(hv_setup_crash_handler); 284 285 void __weak hv_remove_crash_handler(void) 286 { 287 } 288 EXPORT_SYMBOL_GPL(hv_remove_crash_handler); 289 290 void __weak hyperv_cleanup(void) 291 { 292 } 293 EXPORT_SYMBOL_GPL(hyperv_cleanup); 294 295 u64 __weak hv_ghcb_hypercall(u64 control, void *input, void *output, u32 input_size) 296 { 297 return HV_STATUS_INVALID_PARAMETER; 298 } 299 EXPORT_SYMBOL_GPL(hv_ghcb_hypercall); 300 301 void __weak *hv_map_memory(void *addr, unsigned long size) 302 { 303 return NULL; 304 } 305 EXPORT_SYMBOL_GPL(hv_map_memory); 306 307 void __weak hv_unmap_memory(void *addr) 308 { 309 } 310 EXPORT_SYMBOL_GPL(hv_unmap_memory); 311