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 
hv_common_free(void)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 
hv_common_init(void)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 
hv_common_cpu_init(unsigned int cpu)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 
hv_common_cpu_die(unsigned int cpu)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 */
hv_query_ext_cap(u64 cap_query)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 
hv_setup_dma_ops(struct device * dev,bool coherent)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 
hv_is_hibernation_supported(void)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  */
__hv_read_ref_counter(void)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 
hv_is_isolation_supported(void)259 bool __weak hv_is_isolation_supported(void)
260 {
261 	return false;
262 }
263 EXPORT_SYMBOL_GPL(hv_is_isolation_supported);
264 
hv_isolation_type_snp(void)265 bool __weak hv_isolation_type_snp(void)
266 {
267 	return false;
268 }
269 EXPORT_SYMBOL_GPL(hv_isolation_type_snp);
270 
hv_setup_vmbus_handler(void (* handler)(void))271 void __weak hv_setup_vmbus_handler(void (*handler)(void))
272 {
273 }
274 EXPORT_SYMBOL_GPL(hv_setup_vmbus_handler);
275 
hv_remove_vmbus_handler(void)276 void __weak hv_remove_vmbus_handler(void)
277 {
278 }
279 EXPORT_SYMBOL_GPL(hv_remove_vmbus_handler);
280 
hv_setup_kexec_handler(void (* handler)(void))281 void __weak hv_setup_kexec_handler(void (*handler)(void))
282 {
283 }
284 EXPORT_SYMBOL_GPL(hv_setup_kexec_handler);
285 
hv_remove_kexec_handler(void)286 void __weak hv_remove_kexec_handler(void)
287 {
288 }
289 EXPORT_SYMBOL_GPL(hv_remove_kexec_handler);
290 
hv_setup_crash_handler(void (* handler)(struct pt_regs * regs))291 void __weak hv_setup_crash_handler(void (*handler)(struct pt_regs *regs))
292 {
293 }
294 EXPORT_SYMBOL_GPL(hv_setup_crash_handler);
295 
hv_remove_crash_handler(void)296 void __weak hv_remove_crash_handler(void)
297 {
298 }
299 EXPORT_SYMBOL_GPL(hv_remove_crash_handler);
300 
hyperv_cleanup(void)301 void __weak hyperv_cleanup(void)
302 {
303 }
304 EXPORT_SYMBOL_GPL(hyperv_cleanup);
305 
hv_ghcb_hypercall(u64 control,void * input,void * output,u32 input_size)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 
hv_map_memory(void * addr,unsigned long size)312 void __weak *hv_map_memory(void *addr, unsigned long size)
313 {
314 	return NULL;
315 }
316 EXPORT_SYMBOL_GPL(hv_map_memory);
317 
hv_unmap_memory(void * addr)318 void __weak hv_unmap_memory(void *addr)
319 {
320 }
321 EXPORT_SYMBOL_GPL(hv_unmap_memory);
322