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);