Commit | Line | Data |
---|---|---|
e83d5887 AS |
1 | /* |
2 | * KVM Microsoft Hyper-V emulation | |
3 | * | |
4 | * derived from arch/x86/kvm/x86.c | |
5 | * | |
6 | * Copyright (C) 2006 Qumranet, Inc. | |
7 | * Copyright (C) 2008 Qumranet, Inc. | |
8 | * Copyright IBM Corporation, 2008 | |
9 | * Copyright 2010 Red Hat, Inc. and/or its affiliates. | |
10 | * Copyright (C) 2015 Andrey Smetanin <asmetanin@virtuozzo.com> | |
11 | * | |
12 | * Authors: | |
13 | * Avi Kivity <avi@qumranet.com> | |
14 | * Yaniv Kamay <yaniv@qumranet.com> | |
15 | * Amit Shah <amit.shah@qumranet.com> | |
16 | * Ben-Ami Yassour <benami@il.ibm.com> | |
17 | * Andrey Smetanin <asmetanin@virtuozzo.com> | |
18 | * | |
19 | * This work is licensed under the terms of the GNU GPL, version 2. See | |
20 | * the COPYING file in the top-level directory. | |
21 | * | |
22 | */ | |
23 | ||
24 | #include "x86.h" | |
25 | #include "lapic.h" | |
26 | #include "hyperv.h" | |
27 | ||
28 | #include <linux/kvm_host.h> | |
29 | #include <trace/events/kvm.h> | |
30 | ||
31 | #include "trace.h" | |
32 | ||
33 | static bool kvm_hv_msr_partition_wide(u32 msr) | |
34 | { | |
35 | bool r = false; | |
36 | ||
37 | switch (msr) { | |
38 | case HV_X64_MSR_GUEST_OS_ID: | |
39 | case HV_X64_MSR_HYPERCALL: | |
40 | case HV_X64_MSR_REFERENCE_TSC: | |
41 | case HV_X64_MSR_TIME_REF_COUNT: | |
e7d9513b AS |
42 | case HV_X64_MSR_CRASH_CTL: |
43 | case HV_X64_MSR_CRASH_P0 ... HV_X64_MSR_CRASH_P4: | |
e83d5887 AS |
44 | r = true; |
45 | break; | |
46 | } | |
47 | ||
48 | return r; | |
49 | } | |
50 | ||
e7d9513b AS |
51 | static int kvm_hv_msr_get_crash_data(struct kvm_vcpu *vcpu, |
52 | u32 index, u64 *pdata) | |
53 | { | |
54 | struct kvm_hv *hv = &vcpu->kvm->arch.hyperv; | |
55 | ||
56 | if (WARN_ON_ONCE(index >= ARRAY_SIZE(hv->hv_crash_param))) | |
57 | return -EINVAL; | |
58 | ||
59 | *pdata = hv->hv_crash_param[index]; | |
60 | return 0; | |
61 | } | |
62 | ||
63 | static int kvm_hv_msr_get_crash_ctl(struct kvm_vcpu *vcpu, u64 *pdata) | |
64 | { | |
65 | struct kvm_hv *hv = &vcpu->kvm->arch.hyperv; | |
66 | ||
67 | *pdata = hv->hv_crash_ctl; | |
68 | return 0; | |
69 | } | |
70 | ||
71 | static int kvm_hv_msr_set_crash_ctl(struct kvm_vcpu *vcpu, u64 data, bool host) | |
72 | { | |
73 | struct kvm_hv *hv = &vcpu->kvm->arch.hyperv; | |
74 | ||
75 | if (host) | |
76 | hv->hv_crash_ctl = data & HV_X64_MSR_CRASH_CTL_NOTIFY; | |
77 | ||
78 | if (!host && (data & HV_X64_MSR_CRASH_CTL_NOTIFY)) { | |
79 | ||
80 | vcpu_debug(vcpu, "hv crash (0x%llx 0x%llx 0x%llx 0x%llx 0x%llx)\n", | |
81 | hv->hv_crash_param[0], | |
82 | hv->hv_crash_param[1], | |
83 | hv->hv_crash_param[2], | |
84 | hv->hv_crash_param[3], | |
85 | hv->hv_crash_param[4]); | |
86 | ||
87 | /* Send notification about crash to user space */ | |
88 | kvm_make_request(KVM_REQ_HV_CRASH, vcpu); | |
89 | } | |
90 | ||
91 | return 0; | |
92 | } | |
93 | ||
94 | static int kvm_hv_msr_set_crash_data(struct kvm_vcpu *vcpu, | |
95 | u32 index, u64 data) | |
96 | { | |
97 | struct kvm_hv *hv = &vcpu->kvm->arch.hyperv; | |
98 | ||
99 | if (WARN_ON_ONCE(index >= ARRAY_SIZE(hv->hv_crash_param))) | |
100 | return -EINVAL; | |
101 | ||
102 | hv->hv_crash_param[index] = data; | |
103 | return 0; | |
104 | } | |
105 | ||
106 | static int kvm_hv_set_msr_pw(struct kvm_vcpu *vcpu, u32 msr, u64 data, | |
107 | bool host) | |
e83d5887 AS |
108 | { |
109 | struct kvm *kvm = vcpu->kvm; | |
110 | struct kvm_hv *hv = &kvm->arch.hyperv; | |
111 | ||
112 | switch (msr) { | |
113 | case HV_X64_MSR_GUEST_OS_ID: | |
114 | hv->hv_guest_os_id = data; | |
115 | /* setting guest os id to zero disables hypercall page */ | |
116 | if (!hv->hv_guest_os_id) | |
117 | hv->hv_hypercall &= ~HV_X64_MSR_HYPERCALL_ENABLE; | |
118 | break; | |
119 | case HV_X64_MSR_HYPERCALL: { | |
120 | u64 gfn; | |
121 | unsigned long addr; | |
122 | u8 instructions[4]; | |
123 | ||
124 | /* if guest os id is not set hypercall should remain disabled */ | |
125 | if (!hv->hv_guest_os_id) | |
126 | break; | |
127 | if (!(data & HV_X64_MSR_HYPERCALL_ENABLE)) { | |
128 | hv->hv_hypercall = data; | |
129 | break; | |
130 | } | |
131 | gfn = data >> HV_X64_MSR_HYPERCALL_PAGE_ADDRESS_SHIFT; | |
132 | addr = gfn_to_hva(kvm, gfn); | |
133 | if (kvm_is_error_hva(addr)) | |
134 | return 1; | |
135 | kvm_x86_ops->patch_hypercall(vcpu, instructions); | |
136 | ((unsigned char *)instructions)[3] = 0xc3; /* ret */ | |
137 | if (__copy_to_user((void __user *)addr, instructions, 4)) | |
138 | return 1; | |
139 | hv->hv_hypercall = data; | |
140 | mark_page_dirty(kvm, gfn); | |
141 | break; | |
142 | } | |
143 | case HV_X64_MSR_REFERENCE_TSC: { | |
144 | u64 gfn; | |
145 | HV_REFERENCE_TSC_PAGE tsc_ref; | |
146 | ||
147 | memset(&tsc_ref, 0, sizeof(tsc_ref)); | |
148 | hv->hv_tsc_page = data; | |
149 | if (!(data & HV_X64_MSR_TSC_REFERENCE_ENABLE)) | |
150 | break; | |
151 | gfn = data >> HV_X64_MSR_TSC_REFERENCE_ADDRESS_SHIFT; | |
152 | if (kvm_write_guest( | |
153 | kvm, | |
154 | gfn << HV_X64_MSR_TSC_REFERENCE_ADDRESS_SHIFT, | |
155 | &tsc_ref, sizeof(tsc_ref))) | |
156 | return 1; | |
157 | mark_page_dirty(kvm, gfn); | |
158 | break; | |
159 | } | |
e7d9513b AS |
160 | case HV_X64_MSR_CRASH_P0 ... HV_X64_MSR_CRASH_P4: |
161 | return kvm_hv_msr_set_crash_data(vcpu, | |
162 | msr - HV_X64_MSR_CRASH_P0, | |
163 | data); | |
164 | case HV_X64_MSR_CRASH_CTL: | |
165 | return kvm_hv_msr_set_crash_ctl(vcpu, data, host); | |
e83d5887 AS |
166 | default: |
167 | vcpu_unimpl(vcpu, "Hyper-V uhandled wrmsr: 0x%x data 0x%llx\n", | |
168 | msr, data); | |
169 | return 1; | |
170 | } | |
171 | return 0; | |
172 | } | |
173 | ||
174 | static int kvm_hv_set_msr(struct kvm_vcpu *vcpu, u32 msr, u64 data) | |
175 | { | |
176 | struct kvm_vcpu_hv *hv = &vcpu->arch.hyperv; | |
177 | ||
178 | switch (msr) { | |
179 | case HV_X64_MSR_APIC_ASSIST_PAGE: { | |
180 | u64 gfn; | |
181 | unsigned long addr; | |
182 | ||
183 | if (!(data & HV_X64_MSR_APIC_ASSIST_PAGE_ENABLE)) { | |
184 | hv->hv_vapic = data; | |
185 | if (kvm_lapic_enable_pv_eoi(vcpu, 0)) | |
186 | return 1; | |
187 | break; | |
188 | } | |
189 | gfn = data >> HV_X64_MSR_APIC_ASSIST_PAGE_ADDRESS_SHIFT; | |
190 | addr = kvm_vcpu_gfn_to_hva(vcpu, gfn); | |
191 | if (kvm_is_error_hva(addr)) | |
192 | return 1; | |
193 | if (__clear_user((void __user *)addr, PAGE_SIZE)) | |
194 | return 1; | |
195 | hv->hv_vapic = data; | |
196 | kvm_vcpu_mark_page_dirty(vcpu, gfn); | |
197 | if (kvm_lapic_enable_pv_eoi(vcpu, | |
198 | gfn_to_gpa(gfn) | KVM_MSR_ENABLED)) | |
199 | return 1; | |
200 | break; | |
201 | } | |
202 | case HV_X64_MSR_EOI: | |
203 | return kvm_hv_vapic_msr_write(vcpu, APIC_EOI, data); | |
204 | case HV_X64_MSR_ICR: | |
205 | return kvm_hv_vapic_msr_write(vcpu, APIC_ICR, data); | |
206 | case HV_X64_MSR_TPR: | |
207 | return kvm_hv_vapic_msr_write(vcpu, APIC_TASKPRI, data); | |
208 | default: | |
209 | vcpu_unimpl(vcpu, "Hyper-V uhandled wrmsr: 0x%x data 0x%llx\n", | |
210 | msr, data); | |
211 | return 1; | |
212 | } | |
213 | ||
214 | return 0; | |
215 | } | |
216 | ||
217 | static int kvm_hv_get_msr_pw(struct kvm_vcpu *vcpu, u32 msr, u64 *pdata) | |
218 | { | |
219 | u64 data = 0; | |
220 | struct kvm *kvm = vcpu->kvm; | |
221 | struct kvm_hv *hv = &kvm->arch.hyperv; | |
222 | ||
223 | switch (msr) { | |
224 | case HV_X64_MSR_GUEST_OS_ID: | |
225 | data = hv->hv_guest_os_id; | |
226 | break; | |
227 | case HV_X64_MSR_HYPERCALL: | |
228 | data = hv->hv_hypercall; | |
229 | break; | |
230 | case HV_X64_MSR_TIME_REF_COUNT: { | |
231 | data = | |
232 | div_u64(get_kernel_ns() + kvm->arch.kvmclock_offset, 100); | |
233 | break; | |
234 | } | |
235 | case HV_X64_MSR_REFERENCE_TSC: | |
236 | data = hv->hv_tsc_page; | |
237 | break; | |
e7d9513b AS |
238 | case HV_X64_MSR_CRASH_P0 ... HV_X64_MSR_CRASH_P4: |
239 | return kvm_hv_msr_get_crash_data(vcpu, | |
240 | msr - HV_X64_MSR_CRASH_P0, | |
241 | pdata); | |
242 | case HV_X64_MSR_CRASH_CTL: | |
243 | return kvm_hv_msr_get_crash_ctl(vcpu, pdata); | |
e83d5887 AS |
244 | default: |
245 | vcpu_unimpl(vcpu, "Hyper-V unhandled rdmsr: 0x%x\n", msr); | |
246 | return 1; | |
247 | } | |
248 | ||
249 | *pdata = data; | |
250 | return 0; | |
251 | } | |
252 | ||
253 | static int kvm_hv_get_msr(struct kvm_vcpu *vcpu, u32 msr, u64 *pdata) | |
254 | { | |
255 | u64 data = 0; | |
256 | struct kvm_vcpu_hv *hv = &vcpu->arch.hyperv; | |
257 | ||
258 | switch (msr) { | |
259 | case HV_X64_MSR_VP_INDEX: { | |
260 | int r; | |
261 | struct kvm_vcpu *v; | |
262 | ||
263 | kvm_for_each_vcpu(r, v, vcpu->kvm) { | |
264 | if (v == vcpu) { | |
265 | data = r; | |
266 | break; | |
267 | } | |
268 | } | |
269 | break; | |
270 | } | |
271 | case HV_X64_MSR_EOI: | |
272 | return kvm_hv_vapic_msr_read(vcpu, APIC_EOI, pdata); | |
273 | case HV_X64_MSR_ICR: | |
274 | return kvm_hv_vapic_msr_read(vcpu, APIC_ICR, pdata); | |
275 | case HV_X64_MSR_TPR: | |
276 | return kvm_hv_vapic_msr_read(vcpu, APIC_TASKPRI, pdata); | |
277 | case HV_X64_MSR_APIC_ASSIST_PAGE: | |
278 | data = hv->hv_vapic; | |
279 | break; | |
280 | default: | |
281 | vcpu_unimpl(vcpu, "Hyper-V unhandled rdmsr: 0x%x\n", msr); | |
282 | return 1; | |
283 | } | |
284 | *pdata = data; | |
285 | return 0; | |
286 | } | |
287 | ||
e7d9513b | 288 | int kvm_hv_set_msr_common(struct kvm_vcpu *vcpu, u32 msr, u64 data, bool host) |
e83d5887 AS |
289 | { |
290 | if (kvm_hv_msr_partition_wide(msr)) { | |
291 | int r; | |
292 | ||
293 | mutex_lock(&vcpu->kvm->lock); | |
e7d9513b | 294 | r = kvm_hv_set_msr_pw(vcpu, msr, data, host); |
e83d5887 AS |
295 | mutex_unlock(&vcpu->kvm->lock); |
296 | return r; | |
297 | } else | |
298 | return kvm_hv_set_msr(vcpu, msr, data); | |
299 | } | |
300 | ||
301 | int kvm_hv_get_msr_common(struct kvm_vcpu *vcpu, u32 msr, u64 *pdata) | |
302 | { | |
303 | if (kvm_hv_msr_partition_wide(msr)) { | |
304 | int r; | |
305 | ||
306 | mutex_lock(&vcpu->kvm->lock); | |
307 | r = kvm_hv_get_msr_pw(vcpu, msr, pdata); | |
308 | mutex_unlock(&vcpu->kvm->lock); | |
309 | return r; | |
310 | } else | |
311 | return kvm_hv_get_msr(vcpu, msr, pdata); | |
312 | } | |
313 | ||
314 | bool kvm_hv_hypercall_enabled(struct kvm *kvm) | |
315 | { | |
316 | return kvm->arch.hyperv.hv_hypercall & HV_X64_MSR_HYPERCALL_ENABLE; | |
317 | } | |
318 | ||
319 | int kvm_hv_hypercall(struct kvm_vcpu *vcpu) | |
320 | { | |
321 | u64 param, ingpa, outgpa, ret; | |
322 | uint16_t code, rep_idx, rep_cnt, res = HV_STATUS_SUCCESS, rep_done = 0; | |
323 | bool fast, longmode; | |
324 | ||
325 | /* | |
326 | * hypercall generates UD from non zero cpl and real mode | |
327 | * per HYPER-V spec | |
328 | */ | |
329 | if (kvm_x86_ops->get_cpl(vcpu) != 0 || !is_protmode(vcpu)) { | |
330 | kvm_queue_exception(vcpu, UD_VECTOR); | |
331 | return 0; | |
332 | } | |
333 | ||
334 | longmode = is_64_bit_mode(vcpu); | |
335 | ||
336 | if (!longmode) { | |
337 | param = ((u64)kvm_register_read(vcpu, VCPU_REGS_RDX) << 32) | | |
338 | (kvm_register_read(vcpu, VCPU_REGS_RAX) & 0xffffffff); | |
339 | ingpa = ((u64)kvm_register_read(vcpu, VCPU_REGS_RBX) << 32) | | |
340 | (kvm_register_read(vcpu, VCPU_REGS_RCX) & 0xffffffff); | |
341 | outgpa = ((u64)kvm_register_read(vcpu, VCPU_REGS_RDI) << 32) | | |
342 | (kvm_register_read(vcpu, VCPU_REGS_RSI) & 0xffffffff); | |
343 | } | |
344 | #ifdef CONFIG_X86_64 | |
345 | else { | |
346 | param = kvm_register_read(vcpu, VCPU_REGS_RCX); | |
347 | ingpa = kvm_register_read(vcpu, VCPU_REGS_RDX); | |
348 | outgpa = kvm_register_read(vcpu, VCPU_REGS_R8); | |
349 | } | |
350 | #endif | |
351 | ||
352 | code = param & 0xffff; | |
353 | fast = (param >> 16) & 0x1; | |
354 | rep_cnt = (param >> 32) & 0xfff; | |
355 | rep_idx = (param >> 48) & 0xfff; | |
356 | ||
357 | trace_kvm_hv_hypercall(code, fast, rep_cnt, rep_idx, ingpa, outgpa); | |
358 | ||
359 | switch (code) { | |
360 | case HV_X64_HV_NOTIFY_LONG_SPIN_WAIT: | |
361 | kvm_vcpu_on_spin(vcpu); | |
362 | break; | |
363 | default: | |
364 | res = HV_STATUS_INVALID_HYPERCALL_CODE; | |
365 | break; | |
366 | } | |
367 | ||
368 | ret = res | (((u64)rep_done & 0xfff) << 32); | |
369 | if (longmode) { | |
370 | kvm_register_write(vcpu, VCPU_REGS_RAX, ret); | |
371 | } else { | |
372 | kvm_register_write(vcpu, VCPU_REGS_RDX, ret >> 32); | |
373 | kvm_register_write(vcpu, VCPU_REGS_RAX, ret & 0xffffffff); | |
374 | } | |
375 | ||
376 | return 1; | |
377 | } |