2 * KVM Microsoft Hyper-V emulation
4 * derived from arch/x86/kvm/x86.c
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>
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>
19 * This work is licensed under the terms of the GNU GPL, version 2. See
20 * the COPYING file in the top-level directory.
28 #include <linux/kvm_host.h>
29 #include <trace/events/kvm.h>
33 static bool kvm_hv_msr_partition_wide(u32 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
:
42 case HV_X64_MSR_CRASH_CTL
:
43 case HV_X64_MSR_CRASH_P0
... HV_X64_MSR_CRASH_P4
:
51 static int kvm_hv_msr_get_crash_data(struct kvm_vcpu
*vcpu
,
52 u32 index
, u64
*pdata
)
54 struct kvm_hv
*hv
= &vcpu
->kvm
->arch
.hyperv
;
56 if (WARN_ON_ONCE(index
>= ARRAY_SIZE(hv
->hv_crash_param
)))
59 *pdata
= hv
->hv_crash_param
[index
];
63 static int kvm_hv_msr_get_crash_ctl(struct kvm_vcpu
*vcpu
, u64
*pdata
)
65 struct kvm_hv
*hv
= &vcpu
->kvm
->arch
.hyperv
;
67 *pdata
= hv
->hv_crash_ctl
;
71 static int kvm_hv_msr_set_crash_ctl(struct kvm_vcpu
*vcpu
, u64 data
, bool host
)
73 struct kvm_hv
*hv
= &vcpu
->kvm
->arch
.hyperv
;
76 hv
->hv_crash_ctl
= data
& HV_X64_MSR_CRASH_CTL_NOTIFY
;
78 if (!host
&& (data
& HV_X64_MSR_CRASH_CTL_NOTIFY
)) {
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]);
87 /* Send notification about crash to user space */
88 kvm_make_request(KVM_REQ_HV_CRASH
, vcpu
);
94 static int kvm_hv_msr_set_crash_data(struct kvm_vcpu
*vcpu
,
97 struct kvm_hv
*hv
= &vcpu
->kvm
->arch
.hyperv
;
99 if (WARN_ON_ONCE(index
>= ARRAY_SIZE(hv
->hv_crash_param
)))
102 hv
->hv_crash_param
[index
] = data
;
106 static int kvm_hv_set_msr_pw(struct kvm_vcpu
*vcpu
, u32 msr
, u64 data
,
109 struct kvm
*kvm
= vcpu
->kvm
;
110 struct kvm_hv
*hv
= &kvm
->arch
.hyperv
;
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
;
119 case HV_X64_MSR_HYPERCALL
: {
124 /* if guest os id is not set hypercall should remain disabled */
125 if (!hv
->hv_guest_os_id
)
127 if (!(data
& HV_X64_MSR_HYPERCALL_ENABLE
)) {
128 hv
->hv_hypercall
= data
;
131 gfn
= data
>> HV_X64_MSR_HYPERCALL_PAGE_ADDRESS_SHIFT
;
132 addr
= gfn_to_hva(kvm
, gfn
);
133 if (kvm_is_error_hva(addr
))
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))
139 hv
->hv_hypercall
= data
;
140 mark_page_dirty(kvm
, gfn
);
143 case HV_X64_MSR_REFERENCE_TSC
: {
145 HV_REFERENCE_TSC_PAGE tsc_ref
;
147 memset(&tsc_ref
, 0, sizeof(tsc_ref
));
148 hv
->hv_tsc_page
= data
;
149 if (!(data
& HV_X64_MSR_TSC_REFERENCE_ENABLE
))
151 gfn
= data
>> HV_X64_MSR_TSC_REFERENCE_ADDRESS_SHIFT
;
154 gfn
<< HV_X64_MSR_TSC_REFERENCE_ADDRESS_SHIFT
,
155 &tsc_ref
, sizeof(tsc_ref
)))
157 mark_page_dirty(kvm
, gfn
);
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
,
164 case HV_X64_MSR_CRASH_CTL
:
165 return kvm_hv_msr_set_crash_ctl(vcpu
, data
, host
);
167 vcpu_unimpl(vcpu
, "Hyper-V uhandled wrmsr: 0x%x data 0x%llx\n",
174 static int kvm_hv_set_msr(struct kvm_vcpu
*vcpu
, u32 msr
, u64 data
)
176 struct kvm_vcpu_hv
*hv
= &vcpu
->arch
.hyperv
;
179 case HV_X64_MSR_APIC_ASSIST_PAGE
: {
183 if (!(data
& HV_X64_MSR_APIC_ASSIST_PAGE_ENABLE
)) {
185 if (kvm_lapic_enable_pv_eoi(vcpu
, 0))
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
))
193 if (__clear_user((void __user
*)addr
, PAGE_SIZE
))
196 kvm_vcpu_mark_page_dirty(vcpu
, gfn
);
197 if (kvm_lapic_enable_pv_eoi(vcpu
,
198 gfn_to_gpa(gfn
) | KVM_MSR_ENABLED
))
203 return kvm_hv_vapic_msr_write(vcpu
, APIC_EOI
, data
);
205 return kvm_hv_vapic_msr_write(vcpu
, APIC_ICR
, data
);
207 return kvm_hv_vapic_msr_write(vcpu
, APIC_TASKPRI
, data
);
209 vcpu_unimpl(vcpu
, "Hyper-V uhandled wrmsr: 0x%x data 0x%llx\n",
217 static int kvm_hv_get_msr_pw(struct kvm_vcpu
*vcpu
, u32 msr
, u64
*pdata
)
220 struct kvm
*kvm
= vcpu
->kvm
;
221 struct kvm_hv
*hv
= &kvm
->arch
.hyperv
;
224 case HV_X64_MSR_GUEST_OS_ID
:
225 data
= hv
->hv_guest_os_id
;
227 case HV_X64_MSR_HYPERCALL
:
228 data
= hv
->hv_hypercall
;
230 case HV_X64_MSR_TIME_REF_COUNT
: {
232 div_u64(get_kernel_ns() + kvm
->arch
.kvmclock_offset
, 100);
235 case HV_X64_MSR_REFERENCE_TSC
:
236 data
= hv
->hv_tsc_page
;
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
,
242 case HV_X64_MSR_CRASH_CTL
:
243 return kvm_hv_msr_get_crash_ctl(vcpu
, pdata
);
245 vcpu_unimpl(vcpu
, "Hyper-V unhandled rdmsr: 0x%x\n", msr
);
253 static int kvm_hv_get_msr(struct kvm_vcpu
*vcpu
, u32 msr
, u64
*pdata
)
256 struct kvm_vcpu_hv
*hv
= &vcpu
->arch
.hyperv
;
259 case HV_X64_MSR_VP_INDEX
: {
263 kvm_for_each_vcpu(r
, v
, vcpu
->kvm
) {
272 return kvm_hv_vapic_msr_read(vcpu
, APIC_EOI
, pdata
);
274 return kvm_hv_vapic_msr_read(vcpu
, APIC_ICR
, pdata
);
276 return kvm_hv_vapic_msr_read(vcpu
, APIC_TASKPRI
, pdata
);
277 case HV_X64_MSR_APIC_ASSIST_PAGE
:
281 vcpu_unimpl(vcpu
, "Hyper-V unhandled rdmsr: 0x%x\n", msr
);
288 int kvm_hv_set_msr_common(struct kvm_vcpu
*vcpu
, u32 msr
, u64 data
, bool host
)
290 if (kvm_hv_msr_partition_wide(msr
)) {
293 mutex_lock(&vcpu
->kvm
->lock
);
294 r
= kvm_hv_set_msr_pw(vcpu
, msr
, data
, host
);
295 mutex_unlock(&vcpu
->kvm
->lock
);
298 return kvm_hv_set_msr(vcpu
, msr
, data
);
301 int kvm_hv_get_msr_common(struct kvm_vcpu
*vcpu
, u32 msr
, u64
*pdata
)
303 if (kvm_hv_msr_partition_wide(msr
)) {
306 mutex_lock(&vcpu
->kvm
->lock
);
307 r
= kvm_hv_get_msr_pw(vcpu
, msr
, pdata
);
308 mutex_unlock(&vcpu
->kvm
->lock
);
311 return kvm_hv_get_msr(vcpu
, msr
, pdata
);
314 bool kvm_hv_hypercall_enabled(struct kvm
*kvm
)
316 return kvm
->arch
.hyperv
.hv_hypercall
& HV_X64_MSR_HYPERCALL_ENABLE
;
319 int kvm_hv_hypercall(struct kvm_vcpu
*vcpu
)
321 u64 param
, ingpa
, outgpa
, ret
;
322 uint16_t code
, rep_idx
, rep_cnt
, res
= HV_STATUS_SUCCESS
, rep_done
= 0;
326 * hypercall generates UD from non zero cpl and real mode
329 if (kvm_x86_ops
->get_cpl(vcpu
) != 0 || !is_protmode(vcpu
)) {
330 kvm_queue_exception(vcpu
, UD_VECTOR
);
334 longmode
= is_64_bit_mode(vcpu
);
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);
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
);
352 code
= param
& 0xffff;
353 fast
= (param
>> 16) & 0x1;
354 rep_cnt
= (param
>> 32) & 0xfff;
355 rep_idx
= (param
>> 48) & 0xfff;
357 trace_kvm_hv_hypercall(code
, fast
, rep_cnt
, rep_idx
, ingpa
, outgpa
);
360 case HV_X64_HV_NOTIFY_LONG_SPIN_WAIT
:
361 kvm_vcpu_on_spin(vcpu
);
364 res
= HV_STATUS_INVALID_HYPERCALL_CODE
;
368 ret
= res
| (((u64
)rep_done
& 0xfff) << 32);
370 kvm_register_write(vcpu
, VCPU_REGS_RAX
, ret
);
372 kvm_register_write(vcpu
, VCPU_REGS_RDX
, ret
>> 32);
373 kvm_register_write(vcpu
, VCPU_REGS_RAX
, ret
& 0xffffffff);