1 /* Copyright 2008 IBM Corporation
3 * Copyright 2011 Intel Corporation
4 * Copyright 2016 Veertu, Inc.
5 * Copyright 2017 The Android Open Source Project
7 * QEMU Hypervisor.framework support
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of version 2 of the GNU General Public
11 * License as published by the Free Software Foundation.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, see <http://www.gnu.org/licenses/>.
21 * This file contain code under public domain from the hvdos project:
22 * https://github.com/mist64/hvdos
24 * Parts Copyright (c) 2011 NetApp, Inc.
25 * All rights reserved.
27 * Redistribution and use in source and binary forms, with or without
28 * modification, are permitted provided that the following conditions
30 * 1. Redistributions of source code must retain the above copyright
31 * notice, this list of conditions and the following disclaimer.
32 * 2. Redistributions in binary form must reproduce the above copyright
33 * notice, this list of conditions and the following disclaimer in the
34 * documentation and/or other materials provided with the distribution.
36 * THIS SOFTWARE IS PROVIDED BY NETAPP, INC ``AS IS'' AND
37 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
38 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
39 * ARE DISCLAIMED. IN NO EVENT SHALL NETAPP, INC OR CONTRIBUTORS BE LIABLE
40 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
41 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
42 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
43 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
44 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
45 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
49 #include "qemu/osdep.h"
50 #include "qemu/error-report.h"
51 #include "qemu/memalign.h"
52 #include "qapi/error.h"
53 #include "migration/blocker.h"
55 #include "sysemu/hvf.h"
56 #include "sysemu/hvf_int.h"
57 #include "sysemu/runstate.h"
58 #include "sysemu/cpus.h"
63 #include "x86_descr.h"
65 #include "x86_decode.h"
70 #include <Hypervisor/hv.h>
71 #include <Hypervisor/hv_vmx.h>
72 #include <sys/sysctl.h>
74 #include "hw/i386/apic_internal.h"
75 #include "qemu/main-loop.h"
76 #include "qemu/accel.h"
77 #include "target/i386/cpu.h"
79 static Error
*invtsc_mig_blocker
;
81 void vmx_update_tpr(CPUState
*cpu
)
83 /* TODO: need integrate APIC handling */
84 X86CPU
*x86_cpu
= X86_CPU(cpu
);
85 int tpr
= cpu_get_apic_tpr(x86_cpu
->apic_state
) << 4;
86 int irr
= apic_get_highest_priority_irr(x86_cpu
->apic_state
);
88 wreg(cpu
->accel
->fd
, HV_X86_TPR
, tpr
);
90 wvmcs(cpu
->accel
->fd
, VMCS_TPR_THRESHOLD
, 0);
92 wvmcs(cpu
->accel
->fd
, VMCS_TPR_THRESHOLD
, (irr
> tpr
) ? tpr
>> 4 :
97 static void update_apic_tpr(CPUState
*cpu
)
99 X86CPU
*x86_cpu
= X86_CPU(cpu
);
100 int tpr
= rreg(cpu
->accel
->fd
, HV_X86_TPR
) >> 4;
101 cpu_set_apic_tpr(x86_cpu
->apic_state
, tpr
);
104 #define VECTORING_INFO_VECTOR_MASK 0xff
106 void hvf_handle_io(CPUArchState
*env
, uint16_t port
, void *buffer
,
107 int direction
, int size
, int count
)
110 uint8_t *ptr
= buffer
;
112 for (i
= 0; i
< count
; i
++) {
113 address_space_rw(&address_space_io
, port
, MEMTXATTRS_UNSPECIFIED
,
120 static bool ept_emulation_fault(hvf_slot
*slot
, uint64_t gpa
, uint64_t ept_qual
)
124 /* EPT fault on an instruction fetch doesn't make sense here */
125 if (ept_qual
& EPT_VIOLATION_INST_FETCH
) {
129 /* EPT fault must be a read fault or a write fault */
130 read
= ept_qual
& EPT_VIOLATION_DATA_READ
? 1 : 0;
131 write
= ept_qual
& EPT_VIOLATION_DATA_WRITE
? 1 : 0;
132 if ((read
| write
) == 0) {
137 if (slot
->flags
& HVF_SLOT_LOG
) {
138 uint64_t dirty_page_start
= gpa
& ~(TARGET_PAGE_SIZE
- 1u);
139 memory_region_set_dirty(slot
->region
, gpa
- slot
->start
, 1);
140 hv_vm_protect(dirty_page_start
, TARGET_PAGE_SIZE
,
141 HV_MEMORY_READ
| HV_MEMORY_WRITE
| HV_MEMORY_EXEC
);
146 * The EPT violation must have been caused by accessing a
147 * guest-physical address that is a translation of a guest-linear
150 if ((ept_qual
& EPT_VIOLATION_GLA_VALID
) == 0 ||
151 (ept_qual
& EPT_VIOLATION_XLAT_VALID
) == 0) {
158 if (!memory_region_is_ram(slot
->region
) &&
159 !(read
&& memory_region_is_romd(slot
->region
))) {
165 void hvf_arch_vcpu_destroy(CPUState
*cpu
)
167 X86CPU
*x86_cpu
= X86_CPU(cpu
);
168 CPUX86State
*env
= &x86_cpu
->env
;
170 g_free(env
->hvf_mmio_buf
);
173 static void init_tsc_freq(CPUX86State
*env
)
178 if (env
->tsc_khz
!= 0) {
182 length
= sizeof(uint64_t);
183 if (sysctlbyname("machdep.tsc.frequency", &tsc_freq
, &length
, NULL
, 0)) {
186 env
->tsc_khz
= tsc_freq
/ 1000; /* Hz to KHz */
189 static void init_apic_bus_freq(CPUX86State
*env
)
194 if (env
->apic_bus_freq
!= 0) {
198 length
= sizeof(uint64_t);
199 if (sysctlbyname("hw.busfrequency", &bus_freq
, &length
, NULL
, 0)) {
202 env
->apic_bus_freq
= bus_freq
;
205 static inline bool tsc_is_known(CPUX86State
*env
)
207 return env
->tsc_khz
!= 0;
210 static inline bool apic_bus_freq_is_known(CPUX86State
*env
)
212 return env
->apic_bus_freq
!= 0;
215 void hvf_kick_vcpu_thread(CPUState
*cpu
)
217 cpus_kick_thread(cpu
);
218 hv_vcpu_interrupt(&cpu
->accel
->fd
, 1);
221 int hvf_arch_init(void)
226 int hvf_arch_init_vcpu(CPUState
*cpu
)
228 X86CPU
*x86cpu
= X86_CPU(cpu
);
229 CPUX86State
*env
= &x86cpu
->env
;
230 Error
*local_err
= NULL
;
237 hvf_state
->hvf_caps
= g_new0(struct hvf_vcpu_caps
, 1);
238 env
->hvf_mmio_buf
= g_new(char, 4096);
240 if (x86cpu
->vmware_cpuid_freq
) {
242 init_apic_bus_freq(env
);
244 if (!tsc_is_known(env
) || !apic_bus_freq_is_known(env
)) {
245 error_report("vmware-cpuid-freq: feature couldn't be enabled");
249 if ((env
->features
[FEAT_8000_0007_EDX
] & CPUID_APM_INVTSC
) &&
250 invtsc_mig_blocker
== NULL
) {
251 error_setg(&invtsc_mig_blocker
,
252 "State blocked by non-migratable CPU device (invtsc flag)");
253 r
= migrate_add_blocker(&invtsc_mig_blocker
, &local_err
);
255 error_report_err(local_err
);
261 if (hv_vmx_read_capability(HV_VMX_CAP_PINBASED
,
262 &hvf_state
->hvf_caps
->vmx_cap_pinbased
)) {
265 if (hv_vmx_read_capability(HV_VMX_CAP_PROCBASED
,
266 &hvf_state
->hvf_caps
->vmx_cap_procbased
)) {
269 if (hv_vmx_read_capability(HV_VMX_CAP_PROCBASED2
,
270 &hvf_state
->hvf_caps
->vmx_cap_procbased2
)) {
273 if (hv_vmx_read_capability(HV_VMX_CAP_ENTRY
,
274 &hvf_state
->hvf_caps
->vmx_cap_entry
)) {
278 /* set VMCS control fields */
279 wvmcs(cpu
->accel
->fd
, VMCS_PIN_BASED_CTLS
,
280 cap2ctrl(hvf_state
->hvf_caps
->vmx_cap_pinbased
,
281 VMCS_PIN_BASED_CTLS_EXTINT
|
282 VMCS_PIN_BASED_CTLS_NMI
|
283 VMCS_PIN_BASED_CTLS_VNMI
));
284 wvmcs(cpu
->accel
->fd
, VMCS_PRI_PROC_BASED_CTLS
,
285 cap2ctrl(hvf_state
->hvf_caps
->vmx_cap_procbased
,
286 VMCS_PRI_PROC_BASED_CTLS_HLT
|
287 VMCS_PRI_PROC_BASED_CTLS_MWAIT
|
288 VMCS_PRI_PROC_BASED_CTLS_TSC_OFFSET
|
289 VMCS_PRI_PROC_BASED_CTLS_TPR_SHADOW
) |
290 VMCS_PRI_PROC_BASED_CTLS_SEC_CONTROL
);
292 reqCap
= VMCS_PRI_PROC_BASED2_CTLS_APIC_ACCESSES
;
294 /* Is RDTSCP support in CPUID? If so, enable it in the VMCS. */
295 if (hvf_get_supported_cpuid(0x80000001, 0, R_EDX
) & CPUID_EXT2_RDTSCP
) {
296 reqCap
|= VMCS_PRI_PROC_BASED2_CTLS_RDTSCP
;
299 wvmcs(cpu
->accel
->fd
, VMCS_SEC_PROC_BASED_CTLS
,
300 cap2ctrl(hvf_state
->hvf_caps
->vmx_cap_procbased2
, reqCap
));
302 wvmcs(cpu
->accel
->fd
, VMCS_ENTRY_CTLS
,
303 cap2ctrl(hvf_state
->hvf_caps
->vmx_cap_entry
, 0));
304 wvmcs(cpu
->accel
->fd
, VMCS_EXCEPTION_BITMAP
, 0); /* Double fault */
306 wvmcs(cpu
->accel
->fd
, VMCS_TPR_THRESHOLD
, 0);
308 x86cpu
= X86_CPU(cpu
);
309 x86cpu
->env
.xsave_buf_len
= 4096;
310 x86cpu
->env
.xsave_buf
= qemu_memalign(4096, x86cpu
->env
.xsave_buf_len
);
313 * The allocated storage must be large enough for all of the
314 * possible XSAVE state components.
316 assert(hvf_get_supported_cpuid(0xd, 0, R_ECX
) <= x86cpu
->env
.xsave_buf_len
);
318 hv_vcpu_enable_native_msr(cpu
->accel
->fd
, MSR_STAR
, 1);
319 hv_vcpu_enable_native_msr(cpu
->accel
->fd
, MSR_LSTAR
, 1);
320 hv_vcpu_enable_native_msr(cpu
->accel
->fd
, MSR_CSTAR
, 1);
321 hv_vcpu_enable_native_msr(cpu
->accel
->fd
, MSR_FMASK
, 1);
322 hv_vcpu_enable_native_msr(cpu
->accel
->fd
, MSR_FSBASE
, 1);
323 hv_vcpu_enable_native_msr(cpu
->accel
->fd
, MSR_GSBASE
, 1);
324 hv_vcpu_enable_native_msr(cpu
->accel
->fd
, MSR_KERNELGSBASE
, 1);
325 hv_vcpu_enable_native_msr(cpu
->accel
->fd
, MSR_TSC_AUX
, 1);
326 hv_vcpu_enable_native_msr(cpu
->accel
->fd
, MSR_IA32_TSC
, 1);
327 hv_vcpu_enable_native_msr(cpu
->accel
->fd
, MSR_IA32_SYSENTER_CS
, 1);
328 hv_vcpu_enable_native_msr(cpu
->accel
->fd
, MSR_IA32_SYSENTER_EIP
, 1);
329 hv_vcpu_enable_native_msr(cpu
->accel
->fd
, MSR_IA32_SYSENTER_ESP
, 1);
334 static void hvf_store_events(CPUState
*cpu
, uint32_t ins_len
, uint64_t idtvec_info
)
336 X86CPU
*x86_cpu
= X86_CPU(cpu
);
337 CPUX86State
*env
= &x86_cpu
->env
;
339 env
->exception_nr
= -1;
340 env
->exception_pending
= 0;
341 env
->exception_injected
= 0;
342 env
->interrupt_injected
= -1;
343 env
->nmi_injected
= false;
345 env
->has_error_code
= false;
346 if (idtvec_info
& VMCS_IDT_VEC_VALID
) {
347 switch (idtvec_info
& VMCS_IDT_VEC_TYPE
) {
348 case VMCS_IDT_VEC_HWINTR
:
349 case VMCS_IDT_VEC_SWINTR
:
350 env
->interrupt_injected
= idtvec_info
& VMCS_IDT_VEC_VECNUM
;
352 case VMCS_IDT_VEC_NMI
:
353 env
->nmi_injected
= true;
355 case VMCS_IDT_VEC_HWEXCEPTION
:
356 case VMCS_IDT_VEC_SWEXCEPTION
:
357 env
->exception_nr
= idtvec_info
& VMCS_IDT_VEC_VECNUM
;
358 env
->exception_injected
= 1;
360 case VMCS_IDT_VEC_PRIV_SWEXCEPTION
:
364 if ((idtvec_info
& VMCS_IDT_VEC_TYPE
) == VMCS_IDT_VEC_SWEXCEPTION
||
365 (idtvec_info
& VMCS_IDT_VEC_TYPE
) == VMCS_IDT_VEC_SWINTR
) {
366 env
->ins_len
= ins_len
;
368 if (idtvec_info
& VMCS_IDT_VEC_ERRCODE_VALID
) {
369 env
->has_error_code
= true;
370 env
->error_code
= rvmcs(cpu
->accel
->fd
, VMCS_IDT_VECTORING_ERROR
);
373 if ((rvmcs(cpu
->accel
->fd
, VMCS_GUEST_INTERRUPTIBILITY
) &
374 VMCS_INTERRUPTIBILITY_NMI_BLOCKING
)) {
375 env
->hflags2
|= HF2_NMI_MASK
;
377 env
->hflags2
&= ~HF2_NMI_MASK
;
379 if (rvmcs(cpu
->accel
->fd
, VMCS_GUEST_INTERRUPTIBILITY
) &
380 (VMCS_INTERRUPTIBILITY_STI_BLOCKING
|
381 VMCS_INTERRUPTIBILITY_MOVSS_BLOCKING
)) {
382 env
->hflags
|= HF_INHIBIT_IRQ_MASK
;
384 env
->hflags
&= ~HF_INHIBIT_IRQ_MASK
;
388 static void hvf_cpu_x86_cpuid(CPUX86State
*env
, uint32_t index
, uint32_t count
,
389 uint32_t *eax
, uint32_t *ebx
,
390 uint32_t *ecx
, uint32_t *edx
)
393 * A wrapper extends cpu_x86_cpuid with 0x40000000 and 0x40000010 leafs,
394 * leafs 0x40000001-0x4000000F are filled with zeros
395 * Provides vmware-cpuid-freq support to hvf
397 * Note: leaf 0x40000000 not exposes HVF,
398 * leaving hypervisor signature empty
401 if (index
< 0x40000000 || index
> 0x40000010 ||
402 !tsc_is_known(env
) || !apic_bus_freq_is_known(env
)) {
404 cpu_x86_cpuid(env
, index
, count
, eax
, ebx
, ecx
, edx
);
410 *eax
= 0x40000010; /* Max available cpuid leaf */
411 *ebx
= 0; /* Leave signature empty */
417 *ebx
= env
->apic_bus_freq
/ 1000; /* Hz to KHz */
430 int hvf_vcpu_exec(CPUState
*cpu
)
432 X86CPU
*x86_cpu
= X86_CPU(cpu
);
433 CPUX86State
*env
= &x86_cpu
->env
;
437 if (hvf_process_events(cpu
)) {
442 if (cpu
->accel
->dirty
) {
443 hvf_put_registers(cpu
);
444 cpu
->accel
->dirty
= false;
447 if (hvf_inject_interrupts(cpu
)) {
448 return EXCP_INTERRUPT
;
453 if (!cpu_is_bsp(X86_CPU(cpu
)) && cpu
->halted
) {
458 hv_return_t r
= hv_vcpu_run_until(cpu
->accel
->fd
, HV_DEADLINE_FOREVER
);
462 uint64_t exit_reason
= rvmcs(cpu
->accel
->fd
, VMCS_EXIT_REASON
);
463 uint64_t exit_qual
= rvmcs(cpu
->accel
->fd
, VMCS_EXIT_QUALIFICATION
);
464 uint32_t ins_len
= (uint32_t)rvmcs(cpu
->accel
->fd
,
465 VMCS_EXIT_INSTRUCTION_LENGTH
);
467 uint64_t idtvec_info
= rvmcs(cpu
->accel
->fd
, VMCS_IDT_VECTORING_INFO
);
469 hvf_store_events(cpu
, ins_len
, idtvec_info
);
470 rip
= rreg(cpu
->accel
->fd
, HV_X86_RIP
);
471 env
->eflags
= rreg(cpu
->accel
->fd
, HV_X86_RFLAGS
);
475 update_apic_tpr(cpu
);
479 switch (exit_reason
) {
480 case EXIT_REASON_HLT
: {
481 macvm_set_rip(cpu
, rip
+ ins_len
);
482 if (!((cpu
->interrupt_request
& CPU_INTERRUPT_HARD
) &&
483 (env
->eflags
& IF_MASK
))
484 && !(cpu
->interrupt_request
& CPU_INTERRUPT_NMI
) &&
485 !(idtvec_info
& VMCS_IDT_VEC_VALID
)) {
490 ret
= EXCP_INTERRUPT
;
493 case EXIT_REASON_MWAIT
: {
494 ret
= EXCP_INTERRUPT
;
497 /* Need to check if MMIO or unmapped fault */
498 case EXIT_REASON_EPT_FAULT
:
501 uint64_t gpa
= rvmcs(cpu
->accel
->fd
, VMCS_GUEST_PHYSICAL_ADDRESS
);
503 if (((idtvec_info
& VMCS_IDT_VEC_VALID
) == 0) &&
504 ((exit_qual
& EXIT_QUAL_NMIUDTI
) != 0)) {
505 vmx_set_nmi_blocking(cpu
);
508 slot
= hvf_find_overlap_slot(gpa
, 1);
510 if (ept_emulation_fault(slot
, gpa
, exit_qual
)) {
511 struct x86_decode decode
;
514 decode_instruction(env
, &decode
);
515 exec_instruction(env
, &decode
);
521 case EXIT_REASON_INOUT
:
523 uint32_t in
= (exit_qual
& 8) != 0;
524 uint32_t size
= (exit_qual
& 7) + 1;
525 uint32_t string
= (exit_qual
& 16) != 0;
526 uint32_t port
= exit_qual
>> 16;
527 /*uint32_t rep = (exit_qual & 0x20) != 0;*/
532 hvf_handle_io(env
, port
, &val
, 0, size
, 1);
535 } else if (size
== 2) {
537 } else if (size
== 4) {
538 RAX(env
) = (uint32_t)val
;
540 RAX(env
) = (uint64_t)val
;
545 } else if (!string
&& !in
) {
546 RAX(env
) = rreg(cpu
->accel
->fd
, HV_X86_RAX
);
547 hvf_handle_io(env
, port
, &RAX(env
), 1, size
, 1);
548 macvm_set_rip(cpu
, rip
+ ins_len
);
551 struct x86_decode decode
;
554 decode_instruction(env
, &decode
);
555 assert(ins_len
== decode
.len
);
556 exec_instruction(env
, &decode
);
561 case EXIT_REASON_CPUID
: {
562 uint32_t rax
= (uint32_t)rreg(cpu
->accel
->fd
, HV_X86_RAX
);
563 uint32_t rbx
= (uint32_t)rreg(cpu
->accel
->fd
, HV_X86_RBX
);
564 uint32_t rcx
= (uint32_t)rreg(cpu
->accel
->fd
, HV_X86_RCX
);
565 uint32_t rdx
= (uint32_t)rreg(cpu
->accel
->fd
, HV_X86_RDX
);
568 /* CPUID1.ecx.OSXSAVE needs to know CR4 */
569 env
->cr
[4] = rvmcs(cpu
->accel
->fd
, VMCS_GUEST_CR4
);
571 hvf_cpu_x86_cpuid(env
, rax
, rcx
, &rax
, &rbx
, &rcx
, &rdx
);
573 wreg(cpu
->accel
->fd
, HV_X86_RAX
, rax
);
574 wreg(cpu
->accel
->fd
, HV_X86_RBX
, rbx
);
575 wreg(cpu
->accel
->fd
, HV_X86_RCX
, rcx
);
576 wreg(cpu
->accel
->fd
, HV_X86_RDX
, rdx
);
578 macvm_set_rip(cpu
, rip
+ ins_len
);
581 case EXIT_REASON_XSETBV
: {
582 X86CPU
*x86_cpu
= X86_CPU(cpu
);
583 CPUX86State
*env
= &x86_cpu
->env
;
584 uint32_t eax
= (uint32_t)rreg(cpu
->accel
->fd
, HV_X86_RAX
);
585 uint32_t ecx
= (uint32_t)rreg(cpu
->accel
->fd
, HV_X86_RCX
);
586 uint32_t edx
= (uint32_t)rreg(cpu
->accel
->fd
, HV_X86_RDX
);
589 macvm_set_rip(cpu
, rip
+ ins_len
);
592 env
->xcr0
= ((uint64_t)edx
<< 32) | eax
;
593 wreg(cpu
->accel
->fd
, HV_X86_XCR0
, env
->xcr0
| 1);
594 macvm_set_rip(cpu
, rip
+ ins_len
);
597 case EXIT_REASON_INTR_WINDOW
:
598 vmx_clear_int_window_exiting(cpu
);
599 ret
= EXCP_INTERRUPT
;
601 case EXIT_REASON_NMI_WINDOW
:
602 vmx_clear_nmi_window_exiting(cpu
);
603 ret
= EXCP_INTERRUPT
;
605 case EXIT_REASON_EXT_INTR
:
606 /* force exit and allow io handling */
607 ret
= EXCP_INTERRUPT
;
609 case EXIT_REASON_RDMSR
:
610 case EXIT_REASON_WRMSR
:
613 if (exit_reason
== EXIT_REASON_RDMSR
) {
622 case EXIT_REASON_CR_ACCESS
: {
628 reg
= (exit_qual
>> 8) & 15;
632 macvm_set_cr0(cpu
->accel
->fd
, RRX(env
, reg
));
636 macvm_set_cr4(cpu
->accel
->fd
, RRX(env
, reg
));
640 X86CPU
*x86_cpu
= X86_CPU(cpu
);
641 if (exit_qual
& 0x10) {
642 RRX(env
, reg
) = cpu_get_apic_tpr(x86_cpu
->apic_state
);
644 int tpr
= RRX(env
, reg
);
645 cpu_set_apic_tpr(x86_cpu
->apic_state
, tpr
);
646 ret
= EXCP_INTERRUPT
;
651 error_report("Unrecognized CR %d", cr
);
658 case EXIT_REASON_APIC_ACCESS
: { /* TODO */
659 struct x86_decode decode
;
662 decode_instruction(env
, &decode
);
663 exec_instruction(env
, &decode
);
667 case EXIT_REASON_TPR
: {
671 case EXIT_REASON_TASK_SWITCH
: {
672 uint64_t vinfo
= rvmcs(cpu
->accel
->fd
, VMCS_IDT_VECTORING_INFO
);
673 x68_segment_selector sel
= {.sel
= exit_qual
& 0xffff};
674 vmx_handle_task_switch(cpu
, sel
, (exit_qual
>> 30) & 0x3,
675 vinfo
& VMCS_INTR_VALID
, vinfo
& VECTORING_INFO_VECTOR_MASK
, vinfo
679 case EXIT_REASON_TRIPLE_FAULT
: {
680 qemu_system_reset_request(SHUTDOWN_CAUSE_GUEST_RESET
);
681 ret
= EXCP_INTERRUPT
;
684 case EXIT_REASON_RDPMC
:
685 wreg(cpu
->accel
->fd
, HV_X86_RAX
, 0);
686 wreg(cpu
->accel
->fd
, HV_X86_RDX
, 0);
687 macvm_set_rip(cpu
, rip
+ ins_len
);
689 case VMX_REASON_VMCALL
:
690 env
->exception_nr
= EXCP0D_GPF
;
691 env
->exception_injected
= 1;
692 env
->has_error_code
= true;
696 error_report("%llx: unhandled exit %llx", rip
, exit_reason
);
703 int hvf_arch_insert_sw_breakpoint(CPUState
*cpu
, struct hvf_sw_breakpoint
*bp
)
708 int hvf_arch_remove_sw_breakpoint(CPUState
*cpu
, struct hvf_sw_breakpoint
*bp
)
713 int hvf_arch_insert_hw_breakpoint(vaddr addr
, vaddr len
, int type
)
718 int hvf_arch_remove_hw_breakpoint(vaddr addr
, vaddr len
, int type
)
723 void hvf_arch_remove_all_hw_breakpoints(void)
727 void hvf_arch_update_guest_debug(CPUState
*cpu
)
731 bool hvf_arch_supports_guest_debug(void)