xref: /freebsd/sys/dev/hyperv/vmbus/hyperv.c (revision f061a2215f9bf0bea98ac601a34750f89428db67)
1 /*-
2  * Copyright (c) 2009-2012,2016 Microsoft Corp.
3  * Copyright (c) 2012 NetApp Inc.
4  * Copyright (c) 2012 Citrix Inc.
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice unmodified, this list of conditions, and the following
12  *    disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28 
29 /**
30  * Implements low-level interactions with Hypver-V/Azure
31  */
32 #include <sys/cdefs.h>
33 __FBSDID("$FreeBSD$");
34 
35 #include <sys/param.h>
36 #include <sys/kernel.h>
37 #include <sys/malloc.h>
38 #include <sys/pcpu.h>
39 #include <sys/timetc.h>
40 #include <machine/bus.h>
41 #include <machine/md_var.h>
42 #include <vm/vm.h>
43 #include <vm/vm_param.h>
44 #include <vm/pmap.h>
45 
46 #include <dev/hyperv/include/hyperv_busdma.h>
47 #include <dev/hyperv/vmbus/hv_vmbus_priv.h>
48 #include <dev/hyperv/vmbus/hyperv_machdep.h>
49 #include <dev/hyperv/vmbus/hyperv_reg.h>
50 #include <dev/hyperv/vmbus/hyperv_var.h>
51 #include <dev/hyperv/vmbus/vmbus_var.h>
52 
53 #define HYPERV_FREEBSD_BUILD		0ULL
54 #define HYPERV_FREEBSD_VERSION		((uint64_t)__FreeBSD_version)
55 #define HYPERV_FREEBSD_OSID		0ULL
56 
57 #define MSR_HV_GUESTID_BUILD_FREEBSD	\
58 	(HYPERV_FREEBSD_BUILD & MSR_HV_GUESTID_BUILD_MASK)
59 #define MSR_HV_GUESTID_VERSION_FREEBSD	\
60 	((HYPERV_FREEBSD_VERSION << MSR_HV_GUESTID_VERSION_SHIFT) & \
61 	 MSR_HV_GUESTID_VERSION_MASK)
62 #define MSR_HV_GUESTID_OSID_FREEBSD	\
63 	((HYPERV_FREEBSD_OSID << MSR_HV_GUESTID_OSID_SHIFT) & \
64 	 MSR_HV_GUESTID_OSID_MASK)
65 
66 #define MSR_HV_GUESTID_FREEBSD		\
67 	(MSR_HV_GUESTID_BUILD_FREEBSD |	\
68 	 MSR_HV_GUESTID_VERSION_FREEBSD | \
69 	 MSR_HV_GUESTID_OSID_FREEBSD |	\
70 	 MSR_HV_GUESTID_OSTYPE_FREEBSD)
71 
72 struct hypercall_ctx {
73 	void			*hc_addr;
74 	struct hyperv_dma	hc_dma;
75 };
76 
77 static u_int	hyperv_get_timecount(struct timecounter *tc);
78 
79 u_int		hyperv_features;
80 u_int		hyperv_recommends;
81 
82 static u_int	hyperv_pm_features;
83 static u_int	hyperv_features3;
84 
85 static struct timecounter	hyperv_timecounter = {
86 	.tc_get_timecount	= hyperv_get_timecount,
87 	.tc_poll_pps		= NULL,
88 	.tc_counter_mask	= 0xffffffff,
89 	.tc_frequency		= HYPERV_TIMER_FREQ,
90 	.tc_name		= "Hyper-V",
91 	.tc_quality		= 2000,
92 	.tc_flags		= 0,
93 	.tc_priv		= NULL
94 };
95 
96 static struct hypercall_ctx	hypercall_context;
97 
98 static u_int
99 hyperv_get_timecount(struct timecounter *tc __unused)
100 {
101 	return rdmsr(MSR_HV_TIME_REF_COUNT);
102 }
103 
104 /**
105  * @brief Invoke the specified hypercall
106  */
107 static uint64_t
108 hv_vmbus_do_hypercall(uint64_t value, void *input, void *output)
109 {
110 	uint64_t in_paddr = 0, out_paddr = 0;
111 
112 	if (input != NULL)
113 		in_paddr = hv_get_phys_addr(input);
114 	if (output != NULL)
115 		out_paddr = hv_get_phys_addr(output);
116 
117 	return hypercall_md(hypercall_context.hc_addr, value,
118 	    in_paddr, out_paddr);
119 }
120 
121 /**
122  * @brief Post a message using the hypervisor message IPC.
123  * (This involves a hypercall.)
124  */
125 hv_vmbus_status
126 hv_vmbus_post_msg_via_msg_ipc(
127 	hv_vmbus_connection_id	connection_id,
128 	hv_vmbus_msg_type	message_type,
129 	void*			payload,
130 	size_t			payload_size)
131 {
132 	struct alignedinput {
133 	    uint64_t alignment8;
134 	    hv_vmbus_input_post_message msg;
135 	};
136 
137 	hv_vmbus_input_post_message*	aligned_msg;
138 	hv_vmbus_status 		status;
139 	size_t				addr;
140 
141 	if (payload_size > HV_MESSAGE_PAYLOAD_BYTE_COUNT)
142 	    return (EMSGSIZE);
143 
144 	addr = (size_t) malloc(sizeof(struct alignedinput), M_DEVBUF,
145 			    M_ZERO | M_NOWAIT);
146 	KASSERT(addr != 0,
147 	    ("Error VMBUS: malloc failed to allocate message buffer!"));
148 	if (addr == 0)
149 	    return (ENOMEM);
150 
151 	aligned_msg = (hv_vmbus_input_post_message*)
152 	    (HV_ALIGN_UP(addr, HV_HYPERCALL_PARAM_ALIGN));
153 
154 	aligned_msg->connection_id = connection_id;
155 	aligned_msg->message_type = message_type;
156 	aligned_msg->payload_size = payload_size;
157 	memcpy((void*) aligned_msg->payload, payload, payload_size);
158 
159 	status = hv_vmbus_do_hypercall(
160 		    HV_CALL_POST_MESSAGE, aligned_msg, 0) & 0xFFFF;
161 
162 	free((void *) addr, M_DEVBUF);
163 	return (status);
164 }
165 
166 /**
167  * @brief Signal an event on the specified connection using the hypervisor
168  * event IPC. (This involves a hypercall.)
169  */
170 hv_vmbus_status
171 hv_vmbus_signal_event(void *con_id)
172 {
173 	hv_vmbus_status status;
174 
175 	status = hv_vmbus_do_hypercall(
176 		    HV_CALL_SIGNAL_EVENT,
177 		    con_id,
178 		    0) & 0xFFFF;
179 
180 	return (status);
181 }
182 
183 int
184 hyperv_guid2str(const struct hv_guid *guid, char *buf, size_t sz)
185 {
186 	const uint8_t *d = guid->data;
187 
188 	return snprintf(buf, sz, "%02x%02x%02x%02x-"
189 	    "%02x%02x-%02x%02x-%02x%02x-"
190 	    "%02x%02x%02x%02x%02x%02x",
191 	    d[3], d[2], d[1], d[0],
192 	    d[5], d[4], d[7], d[6], d[8], d[9],
193 	    d[10], d[11], d[12], d[13], d[14], d[15]);
194 }
195 
196 static bool
197 hyperv_identify(void)
198 {
199 	u_int regs[4];
200 	unsigned int maxleaf;
201 
202 	if (vm_guest != VM_GUEST_HV)
203 		return (false);
204 
205 	do_cpuid(CPUID_LEAF_HV_MAXLEAF, regs);
206 	maxleaf = regs[0];
207 	if (maxleaf < CPUID_LEAF_HV_LIMITS)
208 		return (false);
209 
210 	do_cpuid(CPUID_LEAF_HV_INTERFACE, regs);
211 	if (regs[0] != CPUID_HV_IFACE_HYPERV)
212 		return (false);
213 
214 	do_cpuid(CPUID_LEAF_HV_FEATURES, regs);
215 	if ((regs[0] & CPUID_HV_MSR_HYPERCALL) == 0) {
216 		/*
217 		 * Hyper-V w/o Hypercall is impossible; someone
218 		 * is faking Hyper-V.
219 		 */
220 		return (false);
221 	}
222 	hyperv_features = regs[0];
223 	hyperv_pm_features = regs[2];
224 	hyperv_features3 = regs[3];
225 
226 	do_cpuid(CPUID_LEAF_HV_IDENTITY, regs);
227 	printf("Hyper-V Version: %d.%d.%d [SP%d]\n",
228 	    regs[1] >> 16, regs[1] & 0xffff, regs[0], regs[2]);
229 
230 	printf("  Features=0x%b\n", hyperv_features,
231 	    "\020"
232 	    "\001VPRUNTIME"	/* MSR_HV_VP_RUNTIME */
233 	    "\002TMREFCNT"	/* MSR_HV_TIME_REF_COUNT */
234 	    "\003SYNIC"		/* MSRs for SynIC */
235 	    "\004SYNTM"		/* MSRs for SynTimer */
236 	    "\005APIC"		/* MSR_HV_{EOI,ICR,TPR} */
237 	    "\006HYPERCALL"	/* MSR_HV_{GUEST_OS_ID,HYPERCALL} */
238 	    "\007VPINDEX"	/* MSR_HV_VP_INDEX */
239 	    "\010RESET"		/* MSR_HV_RESET */
240 	    "\011STATS"		/* MSR_HV_STATS_ */
241 	    "\012REFTSC"	/* MSR_HV_REFERENCE_TSC */
242 	    "\013IDLE"		/* MSR_HV_GUEST_IDLE */
243 	    "\014TMFREQ"	/* MSR_HV_{TSC,APIC}_FREQUENCY */
244 	    "\015DEBUG");	/* MSR_HV_SYNTH_DEBUG_ */
245 	printf("  PM Features=0x%b [C%u]\n",
246 	    (hyperv_pm_features & ~CPUPM_HV_CSTATE_MASK),
247 	    "\020"
248 	    "\005C3HPET",	/* HPET is required for C3 state */
249 	    CPUPM_HV_CSTATE(hyperv_pm_features));
250 	printf("  Features3=0x%b\n", hyperv_features3,
251 	    "\020"
252 	    "\001MWAIT"		/* MWAIT */
253 	    "\002DEBUG"		/* guest debug support */
254 	    "\003PERFMON"	/* performance monitor */
255 	    "\004PCPUDPE"	/* physical CPU dynamic partition event */
256 	    "\005XMMHC"		/* hypercall input through XMM regs */
257 	    "\006IDLE"		/* guest idle support */
258 	    "\007SLEEP"		/* hypervisor sleep support */
259 	    "\010NUMA"		/* NUMA distance query support */
260 	    "\011TMFREQ"	/* timer frequency query (TSC, LAPIC) */
261 	    "\012SYNCMC"	/* inject synthetic machine checks */
262 	    "\013CRASH"		/* MSRs for guest crash */
263 	    "\014DEBUGMSR"	/* MSRs for guest debug */
264 	    "\015NPIEP"		/* NPIEP */
265 	    "\016HVDIS");	/* disabling hypervisor */
266 
267 	do_cpuid(CPUID_LEAF_HV_RECOMMENDS, regs);
268 	hyperv_recommends = regs[0];
269 	if (bootverbose)
270 		printf("  Recommends: %08x %08x\n", regs[0], regs[1]);
271 
272 	do_cpuid(CPUID_LEAF_HV_LIMITS, regs);
273 	if (bootverbose) {
274 		printf("  Limits: Vcpu:%d Lcpu:%d Int:%d\n",
275 		    regs[0], regs[1], regs[2]);
276 	}
277 
278 	if (maxleaf >= CPUID_LEAF_HV_HWFEATURES) {
279 		do_cpuid(CPUID_LEAF_HV_HWFEATURES, regs);
280 		if (bootverbose) {
281 			printf("  HW Features: %08x, AMD: %08x\n",
282 			    regs[0], regs[3]);
283 		}
284 	}
285 
286 	return (true);
287 }
288 
289 static void
290 hyperv_init(void *dummy __unused)
291 {
292 	if (!hyperv_identify()) {
293 		/* Not Hyper-V; reset guest id to the generic one. */
294 		if (vm_guest == VM_GUEST_HV)
295 			vm_guest = VM_GUEST_VM;
296 		return;
297 	}
298 
299 	/* Set guest id */
300 	wrmsr(MSR_HV_GUEST_OS_ID, MSR_HV_GUESTID_FREEBSD);
301 
302 	if (hyperv_features & CPUID_HV_MSR_TIME_REFCNT) {
303 		/* Register Hyper-V timecounter */
304 		tc_init(&hyperv_timecounter);
305 	}
306 }
307 SYSINIT(hyperv_initialize, SI_SUB_HYPERVISOR, SI_ORDER_FIRST, hyperv_init,
308     NULL);
309 
310 static void
311 hypercall_memfree(void)
312 {
313 	hyperv_dmamem_free(&hypercall_context.hc_dma,
314 	    hypercall_context.hc_addr);
315 	hypercall_context.hc_addr = NULL;
316 }
317 
318 static void
319 hypercall_create(void *arg __unused)
320 {
321 	uint64_t hc, hc_orig;
322 
323 	if (vm_guest != VM_GUEST_HV)
324 		return;
325 
326 	hypercall_context.hc_addr = hyperv_dmamem_alloc(NULL, PAGE_SIZE, 0,
327 	    PAGE_SIZE, &hypercall_context.hc_dma, BUS_DMA_WAITOK);
328 	if (hypercall_context.hc_addr == NULL) {
329 		printf("hyperv: Hypercall page allocation failed\n");
330 		/* Can't perform any Hyper-V specific actions */
331 		vm_guest = VM_GUEST_VM;
332 		return;
333 	}
334 
335 	/* Get the 'reserved' bits, which requires preservation. */
336 	hc_orig = rdmsr(MSR_HV_HYPERCALL);
337 
338 	/*
339 	 * Setup the Hypercall page.
340 	 *
341 	 * NOTE: 'reserved' bits MUST be preserved.
342 	 */
343 	hc = ((hypercall_context.hc_dma.hv_paddr >> PAGE_SHIFT) <<
344 	    MSR_HV_HYPERCALL_PGSHIFT) |
345 	    (hc_orig & MSR_HV_HYPERCALL_RSVD_MASK) |
346 	    MSR_HV_HYPERCALL_ENABLE;
347 	wrmsr(MSR_HV_HYPERCALL, hc);
348 
349 	/*
350 	 * Confirm that Hypercall page did get setup.
351 	 */
352 	hc = rdmsr(MSR_HV_HYPERCALL);
353 	if ((hc & MSR_HV_HYPERCALL_ENABLE) == 0) {
354 		printf("hyperv: Hypercall setup failed\n");
355 		hypercall_memfree();
356 		/* Can't perform any Hyper-V specific actions */
357 		vm_guest = VM_GUEST_VM;
358 		return;
359 	}
360 	if (bootverbose)
361 		printf("hyperv: Hypercall created\n");
362 }
363 SYSINIT(hypercall_ctor, SI_SUB_DRIVERS, SI_ORDER_FIRST, hypercall_create, NULL);
364 
365 static void
366 hypercall_destroy(void *arg __unused)
367 {
368 	uint64_t hc;
369 
370 	if (hypercall_context.hc_addr == NULL)
371 		return;
372 
373 	/* Disable Hypercall */
374 	hc = rdmsr(MSR_HV_HYPERCALL);
375 	wrmsr(MSR_HV_HYPERCALL, (hc & MSR_HV_HYPERCALL_RSVD_MASK));
376 	hypercall_memfree();
377 
378 	if (bootverbose)
379 		printf("hyperv: Hypercall destroyed\n");
380 }
381 SYSUNINIT(hypercall_dtor, SI_SUB_DRIVERS, SI_ORDER_FIRST, hypercall_destroy,
382     NULL);
383