169e0a03cSPaolo Bonzini /* Copyright 2008 IBM Corporation 269e0a03cSPaolo Bonzini * 2008 Red Hat, Inc. 369e0a03cSPaolo Bonzini * Copyright 2011 Intel Corporation 469e0a03cSPaolo Bonzini * Copyright 2016 Veertu, Inc. 569e0a03cSPaolo Bonzini * Copyright 2017 The Android Open Source Project 669e0a03cSPaolo Bonzini * 769e0a03cSPaolo Bonzini * QEMU Hypervisor.framework support 869e0a03cSPaolo Bonzini * 969e0a03cSPaolo Bonzini * This program is free software; you can redistribute it and/or 1069e0a03cSPaolo Bonzini * modify it under the terms of version 2 of the GNU General Public 1169e0a03cSPaolo Bonzini * License as published by the Free Software Foundation. 1269e0a03cSPaolo Bonzini * 1369e0a03cSPaolo Bonzini * This program is distributed in the hope that it will be useful, 1469e0a03cSPaolo Bonzini * but WITHOUT ANY WARRANTY; without even the implied warranty of 1569e0a03cSPaolo Bonzini * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 1669e0a03cSPaolo Bonzini * Lesser General Public License for more details. 1769e0a03cSPaolo Bonzini * 1869e0a03cSPaolo Bonzini * You should have received a copy of the GNU Lesser General Public 1969e0a03cSPaolo Bonzini * License along with this program; if not, see <http://www.gnu.org/licenses/>. 2069e0a03cSPaolo Bonzini */ 2169e0a03cSPaolo Bonzini #include "qemu/osdep.h" 2269e0a03cSPaolo Bonzini #include "qemu-common.h" 2369e0a03cSPaolo Bonzini #include "qemu/error-report.h" 2469e0a03cSPaolo Bonzini 2569e0a03cSPaolo Bonzini #include "sysemu/hvf.h" 2669e0a03cSPaolo Bonzini #include "hvf-i386.h" 2769e0a03cSPaolo Bonzini #include "vmcs.h" 2869e0a03cSPaolo Bonzini #include "vmx.h" 2969e0a03cSPaolo Bonzini #include "x86.h" 3069e0a03cSPaolo Bonzini #include "x86_descr.h" 3169e0a03cSPaolo Bonzini #include "x86_mmu.h" 3269e0a03cSPaolo Bonzini #include "x86_decode.h" 3369e0a03cSPaolo Bonzini #include "x86_emu.h" 3469e0a03cSPaolo Bonzini #include "x86_task.h" 3569e0a03cSPaolo Bonzini #include "x86hvf.h" 3669e0a03cSPaolo Bonzini 3769e0a03cSPaolo Bonzini #include <Hypervisor/hv.h> 3869e0a03cSPaolo Bonzini #include <Hypervisor/hv_vmx.h> 3969e0a03cSPaolo Bonzini 4069e0a03cSPaolo Bonzini #include "exec/address-spaces.h" 4169e0a03cSPaolo Bonzini #include "exec/exec-all.h" 4269e0a03cSPaolo Bonzini #include "exec/ioport.h" 4369e0a03cSPaolo Bonzini #include "hw/i386/apic_internal.h" 4469e0a03cSPaolo Bonzini #include "hw/boards.h" 4569e0a03cSPaolo Bonzini #include "qemu/main-loop.h" 4669e0a03cSPaolo Bonzini #include "strings.h" 4769e0a03cSPaolo Bonzini #include "sysemu/accel.h" 4869e0a03cSPaolo Bonzini #include "sysemu/sysemu.h" 4969e0a03cSPaolo Bonzini #include "target/i386/cpu.h" 5069e0a03cSPaolo Bonzini 5169e0a03cSPaolo Bonzini pthread_rwlock_t mem_lock = PTHREAD_RWLOCK_INITIALIZER; 5269e0a03cSPaolo Bonzini HVFState *hvf_state; 5369e0a03cSPaolo Bonzini int hvf_disabled = 1; 5469e0a03cSPaolo Bonzini 5569e0a03cSPaolo Bonzini static void assert_hvf_ok(hv_return_t ret) 5669e0a03cSPaolo Bonzini { 5769e0a03cSPaolo Bonzini if (ret == HV_SUCCESS) { 5869e0a03cSPaolo Bonzini return; 5969e0a03cSPaolo Bonzini } 6069e0a03cSPaolo Bonzini 6169e0a03cSPaolo Bonzini switch (ret) { 6269e0a03cSPaolo Bonzini case HV_ERROR: 6369e0a03cSPaolo Bonzini error_report("Error: HV_ERROR\n"); 6469e0a03cSPaolo Bonzini break; 6569e0a03cSPaolo Bonzini case HV_BUSY: 6669e0a03cSPaolo Bonzini error_report("Error: HV_BUSY\n"); 6769e0a03cSPaolo Bonzini break; 6869e0a03cSPaolo Bonzini case HV_BAD_ARGUMENT: 6969e0a03cSPaolo Bonzini error_report("Error: HV_BAD_ARGUMENT\n"); 7069e0a03cSPaolo Bonzini break; 7169e0a03cSPaolo Bonzini case HV_NO_RESOURCES: 7269e0a03cSPaolo Bonzini error_report("Error: HV_NO_RESOURCES\n"); 7369e0a03cSPaolo Bonzini break; 7469e0a03cSPaolo Bonzini case HV_NO_DEVICE: 7569e0a03cSPaolo Bonzini error_report("Error: HV_NO_DEVICE\n"); 7669e0a03cSPaolo Bonzini break; 7769e0a03cSPaolo Bonzini case HV_UNSUPPORTED: 7869e0a03cSPaolo Bonzini error_report("Error: HV_UNSUPPORTED\n"); 7969e0a03cSPaolo Bonzini break; 8069e0a03cSPaolo Bonzini default: 8169e0a03cSPaolo Bonzini error_report("Unknown Error\n"); 8269e0a03cSPaolo Bonzini } 8369e0a03cSPaolo Bonzini 8469e0a03cSPaolo Bonzini abort(); 8569e0a03cSPaolo Bonzini } 8669e0a03cSPaolo Bonzini 8769e0a03cSPaolo Bonzini /* Memory slots */ 8869e0a03cSPaolo Bonzini hvf_slot *hvf_find_overlap_slot(uint64_t start, uint64_t end) 8969e0a03cSPaolo Bonzini { 9069e0a03cSPaolo Bonzini hvf_slot *slot; 9169e0a03cSPaolo Bonzini int x; 9269e0a03cSPaolo Bonzini for (x = 0; x < hvf_state->num_slots; ++x) { 9369e0a03cSPaolo Bonzini slot = &hvf_state->slots[x]; 9469e0a03cSPaolo Bonzini if (slot->size && start < (slot->start + slot->size) && 9569e0a03cSPaolo Bonzini end > slot->start) { 9669e0a03cSPaolo Bonzini return slot; 9769e0a03cSPaolo Bonzini } 9869e0a03cSPaolo Bonzini } 9969e0a03cSPaolo Bonzini return NULL; 10069e0a03cSPaolo Bonzini } 10169e0a03cSPaolo Bonzini 10269e0a03cSPaolo Bonzini struct mac_slot { 10369e0a03cSPaolo Bonzini int present; 10469e0a03cSPaolo Bonzini uint64_t size; 10569e0a03cSPaolo Bonzini uint64_t gpa_start; 10669e0a03cSPaolo Bonzini uint64_t gva; 10769e0a03cSPaolo Bonzini }; 10869e0a03cSPaolo Bonzini 10969e0a03cSPaolo Bonzini struct mac_slot mac_slots[32]; 11069e0a03cSPaolo Bonzini #define ALIGN(x, y) (((x) + (y) - 1) & ~((y) - 1)) 11169e0a03cSPaolo Bonzini 11269e0a03cSPaolo Bonzini static int do_hvf_set_memory(hvf_slot *slot) 11369e0a03cSPaolo Bonzini { 11469e0a03cSPaolo Bonzini struct mac_slot *macslot; 11569e0a03cSPaolo Bonzini hv_memory_flags_t flags; 11669e0a03cSPaolo Bonzini hv_return_t ret; 11769e0a03cSPaolo Bonzini 11869e0a03cSPaolo Bonzini macslot = &mac_slots[slot->slot_id]; 11969e0a03cSPaolo Bonzini 12069e0a03cSPaolo Bonzini if (macslot->present) { 12169e0a03cSPaolo Bonzini if (macslot->size != slot->size) { 12269e0a03cSPaolo Bonzini macslot->present = 0; 12369e0a03cSPaolo Bonzini ret = hv_vm_unmap(macslot->gpa_start, macslot->size); 12469e0a03cSPaolo Bonzini assert_hvf_ok(ret); 12569e0a03cSPaolo Bonzini } 12669e0a03cSPaolo Bonzini } 12769e0a03cSPaolo Bonzini 12869e0a03cSPaolo Bonzini if (!slot->size) { 12969e0a03cSPaolo Bonzini return 0; 13069e0a03cSPaolo Bonzini } 13169e0a03cSPaolo Bonzini 13269e0a03cSPaolo Bonzini flags = HV_MEMORY_READ | HV_MEMORY_WRITE | HV_MEMORY_EXEC; 13369e0a03cSPaolo Bonzini 13469e0a03cSPaolo Bonzini macslot->present = 1; 13569e0a03cSPaolo Bonzini macslot->gpa_start = slot->start; 13669e0a03cSPaolo Bonzini macslot->size = slot->size; 13769e0a03cSPaolo Bonzini ret = hv_vm_map((hv_uvaddr_t)slot->mem, slot->start, slot->size, flags); 13869e0a03cSPaolo Bonzini assert_hvf_ok(ret); 13969e0a03cSPaolo Bonzini return 0; 14069e0a03cSPaolo Bonzini } 14169e0a03cSPaolo Bonzini 14269e0a03cSPaolo Bonzini void hvf_set_phys_mem(MemoryRegionSection *section, bool add) 14369e0a03cSPaolo Bonzini { 14469e0a03cSPaolo Bonzini hvf_slot *mem; 14569e0a03cSPaolo Bonzini MemoryRegion *area = section->mr; 14669e0a03cSPaolo Bonzini 14769e0a03cSPaolo Bonzini if (!memory_region_is_ram(area)) { 14869e0a03cSPaolo Bonzini return; 14969e0a03cSPaolo Bonzini } 15069e0a03cSPaolo Bonzini 15169e0a03cSPaolo Bonzini mem = hvf_find_overlap_slot( 15269e0a03cSPaolo Bonzini section->offset_within_address_space, 15369e0a03cSPaolo Bonzini section->offset_within_address_space + int128_get64(section->size)); 15469e0a03cSPaolo Bonzini 15569e0a03cSPaolo Bonzini if (mem && add) { 15669e0a03cSPaolo Bonzini if (mem->size == int128_get64(section->size) && 15769e0a03cSPaolo Bonzini mem->start == section->offset_within_address_space && 15869e0a03cSPaolo Bonzini mem->mem == (memory_region_get_ram_ptr(area) + 15969e0a03cSPaolo Bonzini section->offset_within_region)) { 16069e0a03cSPaolo Bonzini return; /* Same region was attempted to register, go away. */ 16169e0a03cSPaolo Bonzini } 16269e0a03cSPaolo Bonzini } 16369e0a03cSPaolo Bonzini 16469e0a03cSPaolo Bonzini /* Region needs to be reset. set the size to 0 and remap it. */ 16569e0a03cSPaolo Bonzini if (mem) { 16669e0a03cSPaolo Bonzini mem->size = 0; 16769e0a03cSPaolo Bonzini if (do_hvf_set_memory(mem)) { 16869e0a03cSPaolo Bonzini error_report("Failed to reset overlapping slot\n"); 16969e0a03cSPaolo Bonzini abort(); 17069e0a03cSPaolo Bonzini } 17169e0a03cSPaolo Bonzini } 17269e0a03cSPaolo Bonzini 17369e0a03cSPaolo Bonzini if (!add) { 17469e0a03cSPaolo Bonzini return; 17569e0a03cSPaolo Bonzini } 17669e0a03cSPaolo Bonzini 17769e0a03cSPaolo Bonzini /* Now make a new slot. */ 17869e0a03cSPaolo Bonzini int x; 17969e0a03cSPaolo Bonzini 18069e0a03cSPaolo Bonzini for (x = 0; x < hvf_state->num_slots; ++x) { 18169e0a03cSPaolo Bonzini mem = &hvf_state->slots[x]; 18269e0a03cSPaolo Bonzini if (!mem->size) { 18369e0a03cSPaolo Bonzini break; 18469e0a03cSPaolo Bonzini } 18569e0a03cSPaolo Bonzini } 18669e0a03cSPaolo Bonzini 18769e0a03cSPaolo Bonzini if (x == hvf_state->num_slots) { 18869e0a03cSPaolo Bonzini error_report("No free slots\n"); 18969e0a03cSPaolo Bonzini abort(); 19069e0a03cSPaolo Bonzini } 19169e0a03cSPaolo Bonzini 19269e0a03cSPaolo Bonzini mem->size = int128_get64(section->size); 19369e0a03cSPaolo Bonzini mem->mem = memory_region_get_ram_ptr(area) + section->offset_within_region; 19469e0a03cSPaolo Bonzini mem->start = section->offset_within_address_space; 19569e0a03cSPaolo Bonzini mem->region = area; 19669e0a03cSPaolo Bonzini 19769e0a03cSPaolo Bonzini if (do_hvf_set_memory(mem)) { 19869e0a03cSPaolo Bonzini error_report("Error registering new memory slot\n"); 19969e0a03cSPaolo Bonzini abort(); 20069e0a03cSPaolo Bonzini } 20169e0a03cSPaolo Bonzini } 20269e0a03cSPaolo Bonzini 20369e0a03cSPaolo Bonzini void vmx_update_tpr(CPUState *cpu) 20469e0a03cSPaolo Bonzini { 20569e0a03cSPaolo Bonzini /* TODO: need integrate APIC handling */ 20669e0a03cSPaolo Bonzini X86CPU *x86_cpu = X86_CPU(cpu); 20769e0a03cSPaolo Bonzini int tpr = cpu_get_apic_tpr(x86_cpu->apic_state) << 4; 20869e0a03cSPaolo Bonzini int irr = apic_get_highest_priority_irr(x86_cpu->apic_state); 20969e0a03cSPaolo Bonzini 21069e0a03cSPaolo Bonzini wreg(cpu->hvf_fd, HV_X86_TPR, tpr); 21169e0a03cSPaolo Bonzini if (irr == -1) { 21269e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_TPR_THRESHOLD, 0); 21369e0a03cSPaolo Bonzini } else { 21469e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_TPR_THRESHOLD, (irr > tpr) ? tpr >> 4 : 21569e0a03cSPaolo Bonzini irr >> 4); 21669e0a03cSPaolo Bonzini } 21769e0a03cSPaolo Bonzini } 21869e0a03cSPaolo Bonzini 21969e0a03cSPaolo Bonzini void update_apic_tpr(CPUState *cpu) 22069e0a03cSPaolo Bonzini { 22169e0a03cSPaolo Bonzini X86CPU *x86_cpu = X86_CPU(cpu); 22269e0a03cSPaolo Bonzini int tpr = rreg(cpu->hvf_fd, HV_X86_TPR) >> 4; 22369e0a03cSPaolo Bonzini cpu_set_apic_tpr(x86_cpu->apic_state, tpr); 22469e0a03cSPaolo Bonzini } 22569e0a03cSPaolo Bonzini 22669e0a03cSPaolo Bonzini #define VECTORING_INFO_VECTOR_MASK 0xff 22769e0a03cSPaolo Bonzini 22869e0a03cSPaolo Bonzini static void hvf_handle_interrupt(CPUState * cpu, int mask) 22969e0a03cSPaolo Bonzini { 23069e0a03cSPaolo Bonzini cpu->interrupt_request |= mask; 23169e0a03cSPaolo Bonzini if (!qemu_cpu_is_self(cpu)) { 23269e0a03cSPaolo Bonzini qemu_cpu_kick(cpu); 23369e0a03cSPaolo Bonzini } 23469e0a03cSPaolo Bonzini } 23569e0a03cSPaolo Bonzini 23669e0a03cSPaolo Bonzini void hvf_handle_io(CPUArchState *env, uint16_t port, void *buffer, 23769e0a03cSPaolo Bonzini int direction, int size, int count) 23869e0a03cSPaolo Bonzini { 23969e0a03cSPaolo Bonzini int i; 24069e0a03cSPaolo Bonzini uint8_t *ptr = buffer; 24169e0a03cSPaolo Bonzini 24269e0a03cSPaolo Bonzini for (i = 0; i < count; i++) { 24369e0a03cSPaolo Bonzini address_space_rw(&address_space_io, port, MEMTXATTRS_UNSPECIFIED, 24469e0a03cSPaolo Bonzini ptr, size, 24569e0a03cSPaolo Bonzini direction); 24669e0a03cSPaolo Bonzini ptr += size; 24769e0a03cSPaolo Bonzini } 24869e0a03cSPaolo Bonzini } 24969e0a03cSPaolo Bonzini 25069e0a03cSPaolo Bonzini /* TODO: synchronize vcpu state */ 25169e0a03cSPaolo Bonzini static void do_hvf_cpu_synchronize_state(CPUState *cpu, run_on_cpu_data arg) 25269e0a03cSPaolo Bonzini { 25369e0a03cSPaolo Bonzini CPUState *cpu_state = cpu; 25469e0a03cSPaolo Bonzini if (cpu_state->vcpu_dirty == 0) { 25569e0a03cSPaolo Bonzini hvf_get_registers(cpu_state); 25669e0a03cSPaolo Bonzini } 25769e0a03cSPaolo Bonzini 25869e0a03cSPaolo Bonzini cpu_state->vcpu_dirty = 1; 25969e0a03cSPaolo Bonzini } 26069e0a03cSPaolo Bonzini 26169e0a03cSPaolo Bonzini void hvf_cpu_synchronize_state(CPUState *cpu_state) 26269e0a03cSPaolo Bonzini { 26369e0a03cSPaolo Bonzini if (cpu_state->vcpu_dirty == 0) { 26469e0a03cSPaolo Bonzini run_on_cpu(cpu_state, do_hvf_cpu_synchronize_state, RUN_ON_CPU_NULL); 26569e0a03cSPaolo Bonzini } 26669e0a03cSPaolo Bonzini } 26769e0a03cSPaolo Bonzini 26869e0a03cSPaolo Bonzini static void do_hvf_cpu_synchronize_post_reset(CPUState *cpu, run_on_cpu_data arg) 26969e0a03cSPaolo Bonzini { 27069e0a03cSPaolo Bonzini CPUState *cpu_state = cpu; 27169e0a03cSPaolo Bonzini hvf_put_registers(cpu_state); 27269e0a03cSPaolo Bonzini cpu_state->vcpu_dirty = false; 27369e0a03cSPaolo Bonzini } 27469e0a03cSPaolo Bonzini 27569e0a03cSPaolo Bonzini void hvf_cpu_synchronize_post_reset(CPUState *cpu_state) 27669e0a03cSPaolo Bonzini { 27769e0a03cSPaolo Bonzini run_on_cpu(cpu_state, do_hvf_cpu_synchronize_post_reset, RUN_ON_CPU_NULL); 27869e0a03cSPaolo Bonzini } 27969e0a03cSPaolo Bonzini 28069e0a03cSPaolo Bonzini void _hvf_cpu_synchronize_post_init(CPUState *cpu, run_on_cpu_data arg) 28169e0a03cSPaolo Bonzini { 28269e0a03cSPaolo Bonzini CPUState *cpu_state = cpu; 28369e0a03cSPaolo Bonzini hvf_put_registers(cpu_state); 28469e0a03cSPaolo Bonzini cpu_state->vcpu_dirty = false; 28569e0a03cSPaolo Bonzini } 28669e0a03cSPaolo Bonzini 28769e0a03cSPaolo Bonzini void hvf_cpu_synchronize_post_init(CPUState *cpu_state) 28869e0a03cSPaolo Bonzini { 28969e0a03cSPaolo Bonzini run_on_cpu(cpu_state, _hvf_cpu_synchronize_post_init, RUN_ON_CPU_NULL); 29069e0a03cSPaolo Bonzini } 29169e0a03cSPaolo Bonzini 292ff2de166SPaolo Bonzini static bool ept_emulation_fault(hvf_slot *slot, uint64_t gpa, uint64_t ept_qual) 29369e0a03cSPaolo Bonzini { 29469e0a03cSPaolo Bonzini int read, write; 29569e0a03cSPaolo Bonzini 29669e0a03cSPaolo Bonzini /* EPT fault on an instruction fetch doesn't make sense here */ 29769e0a03cSPaolo Bonzini if (ept_qual & EPT_VIOLATION_INST_FETCH) { 29869e0a03cSPaolo Bonzini return false; 29969e0a03cSPaolo Bonzini } 30069e0a03cSPaolo Bonzini 30169e0a03cSPaolo Bonzini /* EPT fault must be a read fault or a write fault */ 30269e0a03cSPaolo Bonzini read = ept_qual & EPT_VIOLATION_DATA_READ ? 1 : 0; 30369e0a03cSPaolo Bonzini write = ept_qual & EPT_VIOLATION_DATA_WRITE ? 1 : 0; 30469e0a03cSPaolo Bonzini if ((read | write) == 0) { 30569e0a03cSPaolo Bonzini return false; 30669e0a03cSPaolo Bonzini } 30769e0a03cSPaolo Bonzini 30869e0a03cSPaolo Bonzini if (write && slot) { 30969e0a03cSPaolo Bonzini if (slot->flags & HVF_SLOT_LOG) { 31069e0a03cSPaolo Bonzini memory_region_set_dirty(slot->region, gpa - slot->start, 1); 31169e0a03cSPaolo Bonzini hv_vm_protect((hv_gpaddr_t)slot->start, (size_t)slot->size, 31269e0a03cSPaolo Bonzini HV_MEMORY_READ | HV_MEMORY_WRITE); 31369e0a03cSPaolo Bonzini } 31469e0a03cSPaolo Bonzini } 31569e0a03cSPaolo Bonzini 31669e0a03cSPaolo Bonzini /* 31769e0a03cSPaolo Bonzini * The EPT violation must have been caused by accessing a 31869e0a03cSPaolo Bonzini * guest-physical address that is a translation of a guest-linear 31969e0a03cSPaolo Bonzini * address. 32069e0a03cSPaolo Bonzini */ 32169e0a03cSPaolo Bonzini if ((ept_qual & EPT_VIOLATION_GLA_VALID) == 0 || 32269e0a03cSPaolo Bonzini (ept_qual & EPT_VIOLATION_XLAT_VALID) == 0) { 32369e0a03cSPaolo Bonzini return false; 32469e0a03cSPaolo Bonzini } 32569e0a03cSPaolo Bonzini 32669e0a03cSPaolo Bonzini return !slot; 32769e0a03cSPaolo Bonzini } 32869e0a03cSPaolo Bonzini 32969e0a03cSPaolo Bonzini static void hvf_set_dirty_tracking(MemoryRegionSection *section, bool on) 33069e0a03cSPaolo Bonzini { 33169e0a03cSPaolo Bonzini hvf_slot *slot; 33269e0a03cSPaolo Bonzini 33369e0a03cSPaolo Bonzini slot = hvf_find_overlap_slot( 33469e0a03cSPaolo Bonzini section->offset_within_address_space, 33569e0a03cSPaolo Bonzini section->offset_within_address_space + int128_get64(section->size)); 33669e0a03cSPaolo Bonzini 33769e0a03cSPaolo Bonzini /* protect region against writes; begin tracking it */ 33869e0a03cSPaolo Bonzini if (on) { 33969e0a03cSPaolo Bonzini slot->flags |= HVF_SLOT_LOG; 34069e0a03cSPaolo Bonzini hv_vm_protect((hv_gpaddr_t)slot->start, (size_t)slot->size, 34169e0a03cSPaolo Bonzini HV_MEMORY_READ); 34269e0a03cSPaolo Bonzini /* stop tracking region*/ 34369e0a03cSPaolo Bonzini } else { 34469e0a03cSPaolo Bonzini slot->flags &= ~HVF_SLOT_LOG; 34569e0a03cSPaolo Bonzini hv_vm_protect((hv_gpaddr_t)slot->start, (size_t)slot->size, 34669e0a03cSPaolo Bonzini HV_MEMORY_READ | HV_MEMORY_WRITE); 34769e0a03cSPaolo Bonzini } 34869e0a03cSPaolo Bonzini } 34969e0a03cSPaolo Bonzini 35069e0a03cSPaolo Bonzini static void hvf_log_start(MemoryListener *listener, 35169e0a03cSPaolo Bonzini MemoryRegionSection *section, int old, int new) 35269e0a03cSPaolo Bonzini { 35369e0a03cSPaolo Bonzini if (old != 0) { 35469e0a03cSPaolo Bonzini return; 35569e0a03cSPaolo Bonzini } 35669e0a03cSPaolo Bonzini 35769e0a03cSPaolo Bonzini hvf_set_dirty_tracking(section, 1); 35869e0a03cSPaolo Bonzini } 35969e0a03cSPaolo Bonzini 36069e0a03cSPaolo Bonzini static void hvf_log_stop(MemoryListener *listener, 36169e0a03cSPaolo Bonzini MemoryRegionSection *section, int old, int new) 36269e0a03cSPaolo Bonzini { 36369e0a03cSPaolo Bonzini if (new != 0) { 36469e0a03cSPaolo Bonzini return; 36569e0a03cSPaolo Bonzini } 36669e0a03cSPaolo Bonzini 36769e0a03cSPaolo Bonzini hvf_set_dirty_tracking(section, 0); 36869e0a03cSPaolo Bonzini } 36969e0a03cSPaolo Bonzini 37069e0a03cSPaolo Bonzini static void hvf_log_sync(MemoryListener *listener, 37169e0a03cSPaolo Bonzini MemoryRegionSection *section) 37269e0a03cSPaolo Bonzini { 37369e0a03cSPaolo Bonzini /* 37469e0a03cSPaolo Bonzini * sync of dirty pages is handled elsewhere; just make sure we keep 37569e0a03cSPaolo Bonzini * tracking the region. 37669e0a03cSPaolo Bonzini */ 37769e0a03cSPaolo Bonzini hvf_set_dirty_tracking(section, 1); 37869e0a03cSPaolo Bonzini } 37969e0a03cSPaolo Bonzini 38069e0a03cSPaolo Bonzini static void hvf_region_add(MemoryListener *listener, 38169e0a03cSPaolo Bonzini MemoryRegionSection *section) 38269e0a03cSPaolo Bonzini { 38369e0a03cSPaolo Bonzini hvf_set_phys_mem(section, true); 38469e0a03cSPaolo Bonzini } 38569e0a03cSPaolo Bonzini 38669e0a03cSPaolo Bonzini static void hvf_region_del(MemoryListener *listener, 38769e0a03cSPaolo Bonzini MemoryRegionSection *section) 38869e0a03cSPaolo Bonzini { 38969e0a03cSPaolo Bonzini hvf_set_phys_mem(section, false); 39069e0a03cSPaolo Bonzini } 39169e0a03cSPaolo Bonzini 39269e0a03cSPaolo Bonzini static MemoryListener hvf_memory_listener = { 39369e0a03cSPaolo Bonzini .priority = 10, 39469e0a03cSPaolo Bonzini .region_add = hvf_region_add, 39569e0a03cSPaolo Bonzini .region_del = hvf_region_del, 39669e0a03cSPaolo Bonzini .log_start = hvf_log_start, 39769e0a03cSPaolo Bonzini .log_stop = hvf_log_stop, 39869e0a03cSPaolo Bonzini .log_sync = hvf_log_sync, 39969e0a03cSPaolo Bonzini }; 40069e0a03cSPaolo Bonzini 40169e0a03cSPaolo Bonzini void hvf_reset_vcpu(CPUState *cpu) { 40269e0a03cSPaolo Bonzini 40369e0a03cSPaolo Bonzini /* TODO: this shouldn't be needed; there is already a call to 40469e0a03cSPaolo Bonzini * cpu_synchronize_all_post_reset in vl.c 40569e0a03cSPaolo Bonzini */ 40669e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_ENTRY_CTLS, 0); 40769e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_GUEST_IA32_EFER, 0); 40869e0a03cSPaolo Bonzini macvm_set_cr0(cpu->hvf_fd, 0x60000010); 40969e0a03cSPaolo Bonzini 41069e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_CR4_MASK, CR4_VMXE_MASK); 41169e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_CR4_SHADOW, 0x0); 41269e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_GUEST_CR4, CR4_VMXE_MASK); 41369e0a03cSPaolo Bonzini 41469e0a03cSPaolo Bonzini /* set VMCS guest state fields */ 41569e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_GUEST_CS_SELECTOR, 0xf000); 41669e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_GUEST_CS_LIMIT, 0xffff); 41769e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_GUEST_CS_ACCESS_RIGHTS, 0x9b); 41869e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_GUEST_CS_BASE, 0xffff0000); 41969e0a03cSPaolo Bonzini 42069e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_GUEST_DS_SELECTOR, 0); 42169e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_GUEST_DS_LIMIT, 0xffff); 42269e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_GUEST_DS_ACCESS_RIGHTS, 0x93); 42369e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_GUEST_DS_BASE, 0); 42469e0a03cSPaolo Bonzini 42569e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_GUEST_ES_SELECTOR, 0); 42669e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_GUEST_ES_LIMIT, 0xffff); 42769e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_GUEST_ES_ACCESS_RIGHTS, 0x93); 42869e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_GUEST_ES_BASE, 0); 42969e0a03cSPaolo Bonzini 43069e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_GUEST_FS_SELECTOR, 0); 43169e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_GUEST_FS_LIMIT, 0xffff); 43269e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_GUEST_FS_ACCESS_RIGHTS, 0x93); 43369e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_GUEST_FS_BASE, 0); 43469e0a03cSPaolo Bonzini 43569e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_GUEST_GS_SELECTOR, 0); 43669e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_GUEST_GS_LIMIT, 0xffff); 43769e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_GUEST_GS_ACCESS_RIGHTS, 0x93); 43869e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_GUEST_GS_BASE, 0); 43969e0a03cSPaolo Bonzini 44069e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_GUEST_SS_SELECTOR, 0); 44169e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_GUEST_SS_LIMIT, 0xffff); 44269e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_GUEST_SS_ACCESS_RIGHTS, 0x93); 44369e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_GUEST_SS_BASE, 0); 44469e0a03cSPaolo Bonzini 44569e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_GUEST_LDTR_SELECTOR, 0); 44669e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_GUEST_LDTR_LIMIT, 0); 44769e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_GUEST_LDTR_ACCESS_RIGHTS, 0x10000); 44869e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_GUEST_LDTR_BASE, 0); 44969e0a03cSPaolo Bonzini 45069e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_GUEST_TR_SELECTOR, 0); 45169e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_GUEST_TR_LIMIT, 0); 45269e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_GUEST_TR_ACCESS_RIGHTS, 0x83); 45369e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_GUEST_TR_BASE, 0); 45469e0a03cSPaolo Bonzini 45569e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_GUEST_GDTR_LIMIT, 0); 45669e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_GUEST_GDTR_BASE, 0); 45769e0a03cSPaolo Bonzini 45869e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_GUEST_IDTR_LIMIT, 0); 45969e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_GUEST_IDTR_BASE, 0); 46069e0a03cSPaolo Bonzini 46169e0a03cSPaolo Bonzini /*wvmcs(cpu->hvf_fd, VMCS_GUEST_CR2, 0x0);*/ 46269e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_GUEST_CR3, 0x0); 46369e0a03cSPaolo Bonzini 46469e0a03cSPaolo Bonzini wreg(cpu->hvf_fd, HV_X86_RIP, 0xfff0); 46569e0a03cSPaolo Bonzini wreg(cpu->hvf_fd, HV_X86_RDX, 0x623); 46669e0a03cSPaolo Bonzini wreg(cpu->hvf_fd, HV_X86_RFLAGS, 0x2); 46769e0a03cSPaolo Bonzini wreg(cpu->hvf_fd, HV_X86_RSP, 0x0); 46869e0a03cSPaolo Bonzini wreg(cpu->hvf_fd, HV_X86_RAX, 0x0); 46969e0a03cSPaolo Bonzini wreg(cpu->hvf_fd, HV_X86_RBX, 0x0); 47069e0a03cSPaolo Bonzini wreg(cpu->hvf_fd, HV_X86_RCX, 0x0); 47169e0a03cSPaolo Bonzini wreg(cpu->hvf_fd, HV_X86_RSI, 0x0); 47269e0a03cSPaolo Bonzini wreg(cpu->hvf_fd, HV_X86_RDI, 0x0); 47369e0a03cSPaolo Bonzini wreg(cpu->hvf_fd, HV_X86_RBP, 0x0); 47469e0a03cSPaolo Bonzini 47569e0a03cSPaolo Bonzini for (int i = 0; i < 8; i++) { 47669e0a03cSPaolo Bonzini wreg(cpu->hvf_fd, HV_X86_R8 + i, 0x0); 47769e0a03cSPaolo Bonzini } 47869e0a03cSPaolo Bonzini 47969e0a03cSPaolo Bonzini hv_vm_sync_tsc(0); 48069e0a03cSPaolo Bonzini cpu->halted = 0; 48169e0a03cSPaolo Bonzini hv_vcpu_invalidate_tlb(cpu->hvf_fd); 48269e0a03cSPaolo Bonzini hv_vcpu_flush(cpu->hvf_fd); 48369e0a03cSPaolo Bonzini } 48469e0a03cSPaolo Bonzini 48569e0a03cSPaolo Bonzini void hvf_vcpu_destroy(CPUState *cpu) 48669e0a03cSPaolo Bonzini { 48769e0a03cSPaolo Bonzini hv_return_t ret = hv_vcpu_destroy((hv_vcpuid_t)cpu->hvf_fd); 48869e0a03cSPaolo Bonzini assert_hvf_ok(ret); 48969e0a03cSPaolo Bonzini } 49069e0a03cSPaolo Bonzini 49169e0a03cSPaolo Bonzini static void dummy_signal(int sig) 49269e0a03cSPaolo Bonzini { 49369e0a03cSPaolo Bonzini } 49469e0a03cSPaolo Bonzini 49569e0a03cSPaolo Bonzini int hvf_init_vcpu(CPUState *cpu) 49669e0a03cSPaolo Bonzini { 49769e0a03cSPaolo Bonzini 49869e0a03cSPaolo Bonzini X86CPU *x86cpu = X86_CPU(cpu); 49969e0a03cSPaolo Bonzini CPUX86State *env = &x86cpu->env; 50069e0a03cSPaolo Bonzini int r; 50169e0a03cSPaolo Bonzini 50269e0a03cSPaolo Bonzini /* init cpu signals */ 50369e0a03cSPaolo Bonzini sigset_t set; 50469e0a03cSPaolo Bonzini struct sigaction sigact; 50569e0a03cSPaolo Bonzini 50669e0a03cSPaolo Bonzini memset(&sigact, 0, sizeof(sigact)); 50769e0a03cSPaolo Bonzini sigact.sa_handler = dummy_signal; 50869e0a03cSPaolo Bonzini sigaction(SIG_IPI, &sigact, NULL); 50969e0a03cSPaolo Bonzini 51069e0a03cSPaolo Bonzini pthread_sigmask(SIG_BLOCK, NULL, &set); 51169e0a03cSPaolo Bonzini sigdelset(&set, SIG_IPI); 51269e0a03cSPaolo Bonzini 51369e0a03cSPaolo Bonzini init_emu(); 51469e0a03cSPaolo Bonzini init_decoder(); 51569e0a03cSPaolo Bonzini 51669e0a03cSPaolo Bonzini hvf_state->hvf_caps = g_new0(struct hvf_vcpu_caps, 1); 51769e0a03cSPaolo Bonzini env->hvf_emul = g_new0(HVFX86EmulatorState, 1); 51869e0a03cSPaolo Bonzini 51969e0a03cSPaolo Bonzini r = hv_vcpu_create((hv_vcpuid_t *)&cpu->hvf_fd, HV_VCPU_DEFAULT); 52069e0a03cSPaolo Bonzini cpu->vcpu_dirty = 1; 52169e0a03cSPaolo Bonzini assert_hvf_ok(r); 52269e0a03cSPaolo Bonzini 52369e0a03cSPaolo Bonzini if (hv_vmx_read_capability(HV_VMX_CAP_PINBASED, 52469e0a03cSPaolo Bonzini &hvf_state->hvf_caps->vmx_cap_pinbased)) { 52569e0a03cSPaolo Bonzini abort(); 52669e0a03cSPaolo Bonzini } 52769e0a03cSPaolo Bonzini if (hv_vmx_read_capability(HV_VMX_CAP_PROCBASED, 52869e0a03cSPaolo Bonzini &hvf_state->hvf_caps->vmx_cap_procbased)) { 52969e0a03cSPaolo Bonzini abort(); 53069e0a03cSPaolo Bonzini } 53169e0a03cSPaolo Bonzini if (hv_vmx_read_capability(HV_VMX_CAP_PROCBASED2, 53269e0a03cSPaolo Bonzini &hvf_state->hvf_caps->vmx_cap_procbased2)) { 53369e0a03cSPaolo Bonzini abort(); 53469e0a03cSPaolo Bonzini } 53569e0a03cSPaolo Bonzini if (hv_vmx_read_capability(HV_VMX_CAP_ENTRY, 53669e0a03cSPaolo Bonzini &hvf_state->hvf_caps->vmx_cap_entry)) { 53769e0a03cSPaolo Bonzini abort(); 53869e0a03cSPaolo Bonzini } 53969e0a03cSPaolo Bonzini 54069e0a03cSPaolo Bonzini /* set VMCS control fields */ 54169e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_PIN_BASED_CTLS, 54269e0a03cSPaolo Bonzini cap2ctrl(hvf_state->hvf_caps->vmx_cap_pinbased, 54369e0a03cSPaolo Bonzini VMCS_PIN_BASED_CTLS_EXTINT | 54469e0a03cSPaolo Bonzini VMCS_PIN_BASED_CTLS_NMI | 54569e0a03cSPaolo Bonzini VMCS_PIN_BASED_CTLS_VNMI)); 54669e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_PRI_PROC_BASED_CTLS, 54769e0a03cSPaolo Bonzini cap2ctrl(hvf_state->hvf_caps->vmx_cap_procbased, 54869e0a03cSPaolo Bonzini VMCS_PRI_PROC_BASED_CTLS_HLT | 54969e0a03cSPaolo Bonzini VMCS_PRI_PROC_BASED_CTLS_MWAIT | 55069e0a03cSPaolo Bonzini VMCS_PRI_PROC_BASED_CTLS_TSC_OFFSET | 55169e0a03cSPaolo Bonzini VMCS_PRI_PROC_BASED_CTLS_TPR_SHADOW) | 55269e0a03cSPaolo Bonzini VMCS_PRI_PROC_BASED_CTLS_SEC_CONTROL); 55369e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_SEC_PROC_BASED_CTLS, 55469e0a03cSPaolo Bonzini cap2ctrl(hvf_state->hvf_caps->vmx_cap_procbased2, 55569e0a03cSPaolo Bonzini VMCS_PRI_PROC_BASED2_CTLS_APIC_ACCESSES)); 55669e0a03cSPaolo Bonzini 55769e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_ENTRY_CTLS, cap2ctrl(hvf_state->hvf_caps->vmx_cap_entry, 55869e0a03cSPaolo Bonzini 0)); 55969e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_EXCEPTION_BITMAP, 0); /* Double fault */ 56069e0a03cSPaolo Bonzini 56169e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_TPR_THRESHOLD, 0); 56269e0a03cSPaolo Bonzini 56369e0a03cSPaolo Bonzini hvf_reset_vcpu(cpu); 56469e0a03cSPaolo Bonzini 56569e0a03cSPaolo Bonzini x86cpu = X86_CPU(cpu); 56669e0a03cSPaolo Bonzini x86cpu->env.kvm_xsave_buf = qemu_memalign(4096, 4096); 56769e0a03cSPaolo Bonzini 56869e0a03cSPaolo Bonzini hv_vcpu_enable_native_msr(cpu->hvf_fd, MSR_STAR, 1); 56969e0a03cSPaolo Bonzini hv_vcpu_enable_native_msr(cpu->hvf_fd, MSR_LSTAR, 1); 57069e0a03cSPaolo Bonzini hv_vcpu_enable_native_msr(cpu->hvf_fd, MSR_CSTAR, 1); 57169e0a03cSPaolo Bonzini hv_vcpu_enable_native_msr(cpu->hvf_fd, MSR_FMASK, 1); 57269e0a03cSPaolo Bonzini hv_vcpu_enable_native_msr(cpu->hvf_fd, MSR_FSBASE, 1); 57369e0a03cSPaolo Bonzini hv_vcpu_enable_native_msr(cpu->hvf_fd, MSR_GSBASE, 1); 57469e0a03cSPaolo Bonzini hv_vcpu_enable_native_msr(cpu->hvf_fd, MSR_KERNELGSBASE, 1); 57569e0a03cSPaolo Bonzini hv_vcpu_enable_native_msr(cpu->hvf_fd, MSR_TSC_AUX, 1); 57669e0a03cSPaolo Bonzini /*hv_vcpu_enable_native_msr(cpu->hvf_fd, MSR_IA32_TSC, 1);*/ 57769e0a03cSPaolo Bonzini hv_vcpu_enable_native_msr(cpu->hvf_fd, MSR_IA32_SYSENTER_CS, 1); 57869e0a03cSPaolo Bonzini hv_vcpu_enable_native_msr(cpu->hvf_fd, MSR_IA32_SYSENTER_EIP, 1); 57969e0a03cSPaolo Bonzini hv_vcpu_enable_native_msr(cpu->hvf_fd, MSR_IA32_SYSENTER_ESP, 1); 58069e0a03cSPaolo Bonzini 58169e0a03cSPaolo Bonzini return 0; 58269e0a03cSPaolo Bonzini } 58369e0a03cSPaolo Bonzini 58469e0a03cSPaolo Bonzini void hvf_disable(int shouldDisable) 58569e0a03cSPaolo Bonzini { 58669e0a03cSPaolo Bonzini hvf_disabled = shouldDisable; 58769e0a03cSPaolo Bonzini } 58869e0a03cSPaolo Bonzini 58969e0a03cSPaolo Bonzini static void hvf_store_events(CPUState *cpu, uint32_t ins_len, uint64_t idtvec_info) 59069e0a03cSPaolo Bonzini { 59169e0a03cSPaolo Bonzini X86CPU *x86_cpu = X86_CPU(cpu); 59269e0a03cSPaolo Bonzini CPUX86State *env = &x86_cpu->env; 59369e0a03cSPaolo Bonzini 59469e0a03cSPaolo Bonzini env->exception_injected = -1; 59569e0a03cSPaolo Bonzini env->interrupt_injected = -1; 59669e0a03cSPaolo Bonzini env->nmi_injected = false; 59769e0a03cSPaolo Bonzini if (idtvec_info & VMCS_IDT_VEC_VALID) { 59869e0a03cSPaolo Bonzini switch (idtvec_info & VMCS_IDT_VEC_TYPE) { 59969e0a03cSPaolo Bonzini case VMCS_IDT_VEC_HWINTR: 60069e0a03cSPaolo Bonzini case VMCS_IDT_VEC_SWINTR: 60169e0a03cSPaolo Bonzini env->interrupt_injected = idtvec_info & VMCS_IDT_VEC_VECNUM; 60269e0a03cSPaolo Bonzini break; 60369e0a03cSPaolo Bonzini case VMCS_IDT_VEC_NMI: 60469e0a03cSPaolo Bonzini env->nmi_injected = true; 60569e0a03cSPaolo Bonzini break; 60669e0a03cSPaolo Bonzini case VMCS_IDT_VEC_HWEXCEPTION: 60769e0a03cSPaolo Bonzini case VMCS_IDT_VEC_SWEXCEPTION: 60869e0a03cSPaolo Bonzini env->exception_injected = idtvec_info & VMCS_IDT_VEC_VECNUM; 60969e0a03cSPaolo Bonzini break; 61069e0a03cSPaolo Bonzini case VMCS_IDT_VEC_PRIV_SWEXCEPTION: 61169e0a03cSPaolo Bonzini default: 61269e0a03cSPaolo Bonzini abort(); 61369e0a03cSPaolo Bonzini } 61469e0a03cSPaolo Bonzini if ((idtvec_info & VMCS_IDT_VEC_TYPE) == VMCS_IDT_VEC_SWEXCEPTION || 61569e0a03cSPaolo Bonzini (idtvec_info & VMCS_IDT_VEC_TYPE) == VMCS_IDT_VEC_SWINTR) { 61669e0a03cSPaolo Bonzini env->ins_len = ins_len; 61769e0a03cSPaolo Bonzini } 61869e0a03cSPaolo Bonzini if (idtvec_info & VMCS_INTR_DEL_ERRCODE) { 61969e0a03cSPaolo Bonzini env->has_error_code = true; 62069e0a03cSPaolo Bonzini env->error_code = rvmcs(cpu->hvf_fd, VMCS_IDT_VECTORING_ERROR); 62169e0a03cSPaolo Bonzini } 62269e0a03cSPaolo Bonzini } 62369e0a03cSPaolo Bonzini if ((rvmcs(cpu->hvf_fd, VMCS_GUEST_INTERRUPTIBILITY) & 62469e0a03cSPaolo Bonzini VMCS_INTERRUPTIBILITY_NMI_BLOCKING)) { 62569e0a03cSPaolo Bonzini env->hflags2 |= HF2_NMI_MASK; 62669e0a03cSPaolo Bonzini } else { 62769e0a03cSPaolo Bonzini env->hflags2 &= ~HF2_NMI_MASK; 62869e0a03cSPaolo Bonzini } 62969e0a03cSPaolo Bonzini if (rvmcs(cpu->hvf_fd, VMCS_GUEST_INTERRUPTIBILITY) & 63069e0a03cSPaolo Bonzini (VMCS_INTERRUPTIBILITY_STI_BLOCKING | 63169e0a03cSPaolo Bonzini VMCS_INTERRUPTIBILITY_MOVSS_BLOCKING)) { 63269e0a03cSPaolo Bonzini env->hflags |= HF_INHIBIT_IRQ_MASK; 63369e0a03cSPaolo Bonzini } else { 63469e0a03cSPaolo Bonzini env->hflags &= ~HF_INHIBIT_IRQ_MASK; 63569e0a03cSPaolo Bonzini } 63669e0a03cSPaolo Bonzini } 63769e0a03cSPaolo Bonzini 63869e0a03cSPaolo Bonzini int hvf_vcpu_exec(CPUState *cpu) 63969e0a03cSPaolo Bonzini { 64069e0a03cSPaolo Bonzini X86CPU *x86_cpu = X86_CPU(cpu); 64169e0a03cSPaolo Bonzini CPUX86State *env = &x86_cpu->env; 64269e0a03cSPaolo Bonzini int ret = 0; 64369e0a03cSPaolo Bonzini uint64_t rip = 0; 64469e0a03cSPaolo Bonzini 64569e0a03cSPaolo Bonzini cpu->halted = 0; 64669e0a03cSPaolo Bonzini 64769e0a03cSPaolo Bonzini if (hvf_process_events(cpu)) { 64869e0a03cSPaolo Bonzini return EXCP_HLT; 64969e0a03cSPaolo Bonzini } 65069e0a03cSPaolo Bonzini 65169e0a03cSPaolo Bonzini do { 65269e0a03cSPaolo Bonzini if (cpu->vcpu_dirty) { 65369e0a03cSPaolo Bonzini hvf_put_registers(cpu); 65469e0a03cSPaolo Bonzini cpu->vcpu_dirty = false; 65569e0a03cSPaolo Bonzini } 65669e0a03cSPaolo Bonzini 65769e0a03cSPaolo Bonzini if (hvf_inject_interrupts(cpu)) { 65869e0a03cSPaolo Bonzini return EXCP_INTERRUPT; 65969e0a03cSPaolo Bonzini } 66069e0a03cSPaolo Bonzini vmx_update_tpr(cpu); 66169e0a03cSPaolo Bonzini 66269e0a03cSPaolo Bonzini qemu_mutex_unlock_iothread(); 66369e0a03cSPaolo Bonzini if (!cpu_is_bsp(X86_CPU(cpu)) && cpu->halted) { 66469e0a03cSPaolo Bonzini qemu_mutex_lock_iothread(); 66569e0a03cSPaolo Bonzini return EXCP_HLT; 66669e0a03cSPaolo Bonzini } 66769e0a03cSPaolo Bonzini 66869e0a03cSPaolo Bonzini hv_return_t r = hv_vcpu_run(cpu->hvf_fd); 66969e0a03cSPaolo Bonzini assert_hvf_ok(r); 67069e0a03cSPaolo Bonzini 67169e0a03cSPaolo Bonzini /* handle VMEXIT */ 67269e0a03cSPaolo Bonzini uint64_t exit_reason = rvmcs(cpu->hvf_fd, VMCS_EXIT_REASON); 67369e0a03cSPaolo Bonzini uint64_t exit_qual = rvmcs(cpu->hvf_fd, VMCS_EXIT_QUALIFICATION); 67469e0a03cSPaolo Bonzini uint32_t ins_len = (uint32_t)rvmcs(cpu->hvf_fd, 67569e0a03cSPaolo Bonzini VMCS_EXIT_INSTRUCTION_LENGTH); 67669e0a03cSPaolo Bonzini 67769e0a03cSPaolo Bonzini uint64_t idtvec_info = rvmcs(cpu->hvf_fd, VMCS_IDT_VECTORING_INFO); 67869e0a03cSPaolo Bonzini 67969e0a03cSPaolo Bonzini hvf_store_events(cpu, ins_len, idtvec_info); 68069e0a03cSPaolo Bonzini rip = rreg(cpu->hvf_fd, HV_X86_RIP); 68169e0a03cSPaolo Bonzini RFLAGS(env) = rreg(cpu->hvf_fd, HV_X86_RFLAGS); 68269e0a03cSPaolo Bonzini env->eflags = RFLAGS(env); 68369e0a03cSPaolo Bonzini 68469e0a03cSPaolo Bonzini qemu_mutex_lock_iothread(); 68569e0a03cSPaolo Bonzini 68669e0a03cSPaolo Bonzini update_apic_tpr(cpu); 68769e0a03cSPaolo Bonzini current_cpu = cpu; 68869e0a03cSPaolo Bonzini 68969e0a03cSPaolo Bonzini ret = 0; 69069e0a03cSPaolo Bonzini switch (exit_reason) { 69169e0a03cSPaolo Bonzini case EXIT_REASON_HLT: { 69269e0a03cSPaolo Bonzini macvm_set_rip(cpu, rip + ins_len); 69369e0a03cSPaolo Bonzini if (!((cpu->interrupt_request & CPU_INTERRUPT_HARD) && 69469e0a03cSPaolo Bonzini (EFLAGS(env) & IF_MASK)) 69569e0a03cSPaolo Bonzini && !(cpu->interrupt_request & CPU_INTERRUPT_NMI) && 69669e0a03cSPaolo Bonzini !(idtvec_info & VMCS_IDT_VEC_VALID)) { 69769e0a03cSPaolo Bonzini cpu->halted = 1; 69869e0a03cSPaolo Bonzini ret = EXCP_HLT; 69969e0a03cSPaolo Bonzini } 70069e0a03cSPaolo Bonzini ret = EXCP_INTERRUPT; 70169e0a03cSPaolo Bonzini break; 70269e0a03cSPaolo Bonzini } 70369e0a03cSPaolo Bonzini case EXIT_REASON_MWAIT: { 70469e0a03cSPaolo Bonzini ret = EXCP_INTERRUPT; 70569e0a03cSPaolo Bonzini break; 70669e0a03cSPaolo Bonzini } 70769e0a03cSPaolo Bonzini /* Need to check if MMIO or unmmaped fault */ 70869e0a03cSPaolo Bonzini case EXIT_REASON_EPT_FAULT: 70969e0a03cSPaolo Bonzini { 71069e0a03cSPaolo Bonzini hvf_slot *slot; 711ff2de166SPaolo Bonzini uint64_t gpa = rvmcs(cpu->hvf_fd, VMCS_GUEST_PHYSICAL_ADDRESS); 71269e0a03cSPaolo Bonzini 71369e0a03cSPaolo Bonzini if (((idtvec_info & VMCS_IDT_VEC_VALID) == 0) && 71469e0a03cSPaolo Bonzini ((exit_qual & EXIT_QUAL_NMIUDTI) != 0)) { 71569e0a03cSPaolo Bonzini vmx_set_nmi_blocking(cpu); 71669e0a03cSPaolo Bonzini } 71769e0a03cSPaolo Bonzini 71869e0a03cSPaolo Bonzini slot = hvf_find_overlap_slot(gpa, gpa); 71969e0a03cSPaolo Bonzini /* mmio */ 72069e0a03cSPaolo Bonzini if (ept_emulation_fault(slot, gpa, exit_qual)) { 72169e0a03cSPaolo Bonzini struct x86_decode decode; 72269e0a03cSPaolo Bonzini 72369e0a03cSPaolo Bonzini load_regs(cpu); 72469e0a03cSPaolo Bonzini env->hvf_emul->fetch_rip = rip; 72569e0a03cSPaolo Bonzini 72669e0a03cSPaolo Bonzini decode_instruction(env, &decode); 72769e0a03cSPaolo Bonzini exec_instruction(env, &decode); 72869e0a03cSPaolo Bonzini store_regs(cpu); 72969e0a03cSPaolo Bonzini break; 73069e0a03cSPaolo Bonzini } 73169e0a03cSPaolo Bonzini break; 73269e0a03cSPaolo Bonzini } 73369e0a03cSPaolo Bonzini case EXIT_REASON_INOUT: 73469e0a03cSPaolo Bonzini { 73569e0a03cSPaolo Bonzini uint32_t in = (exit_qual & 8) != 0; 73669e0a03cSPaolo Bonzini uint32_t size = (exit_qual & 7) + 1; 73769e0a03cSPaolo Bonzini uint32_t string = (exit_qual & 16) != 0; 73869e0a03cSPaolo Bonzini uint32_t port = exit_qual >> 16; 73969e0a03cSPaolo Bonzini /*uint32_t rep = (exit_qual & 0x20) != 0;*/ 74069e0a03cSPaolo Bonzini 74169e0a03cSPaolo Bonzini if (!string && in) { 74269e0a03cSPaolo Bonzini uint64_t val = 0; 74369e0a03cSPaolo Bonzini load_regs(cpu); 74469e0a03cSPaolo Bonzini hvf_handle_io(env, port, &val, 0, size, 1); 74569e0a03cSPaolo Bonzini if (size == 1) { 74669e0a03cSPaolo Bonzini AL(env) = val; 74769e0a03cSPaolo Bonzini } else if (size == 2) { 74869e0a03cSPaolo Bonzini AX(env) = val; 74969e0a03cSPaolo Bonzini } else if (size == 4) { 75069e0a03cSPaolo Bonzini RAX(env) = (uint32_t)val; 75169e0a03cSPaolo Bonzini } else { 752*da20f5cdSPaolo Bonzini RAX(env) = (uint64_t)val; 75369e0a03cSPaolo Bonzini } 75469e0a03cSPaolo Bonzini RIP(env) += ins_len; 75569e0a03cSPaolo Bonzini store_regs(cpu); 75669e0a03cSPaolo Bonzini break; 75769e0a03cSPaolo Bonzini } else if (!string && !in) { 75869e0a03cSPaolo Bonzini RAX(env) = rreg(cpu->hvf_fd, HV_X86_RAX); 75969e0a03cSPaolo Bonzini hvf_handle_io(env, port, &RAX(env), 1, size, 1); 76069e0a03cSPaolo Bonzini macvm_set_rip(cpu, rip + ins_len); 76169e0a03cSPaolo Bonzini break; 76269e0a03cSPaolo Bonzini } 76369e0a03cSPaolo Bonzini struct x86_decode decode; 76469e0a03cSPaolo Bonzini 76569e0a03cSPaolo Bonzini load_regs(cpu); 76669e0a03cSPaolo Bonzini env->hvf_emul->fetch_rip = rip; 76769e0a03cSPaolo Bonzini 76869e0a03cSPaolo Bonzini decode_instruction(env, &decode); 769e62963bfSPaolo Bonzini assert(ins_len == decode.len); 77069e0a03cSPaolo Bonzini exec_instruction(env, &decode); 77169e0a03cSPaolo Bonzini store_regs(cpu); 77269e0a03cSPaolo Bonzini 77369e0a03cSPaolo Bonzini break; 77469e0a03cSPaolo Bonzini } 77569e0a03cSPaolo Bonzini case EXIT_REASON_CPUID: { 77669e0a03cSPaolo Bonzini uint32_t rax = (uint32_t)rreg(cpu->hvf_fd, HV_X86_RAX); 77769e0a03cSPaolo Bonzini uint32_t rbx = (uint32_t)rreg(cpu->hvf_fd, HV_X86_RBX); 77869e0a03cSPaolo Bonzini uint32_t rcx = (uint32_t)rreg(cpu->hvf_fd, HV_X86_RCX); 77969e0a03cSPaolo Bonzini uint32_t rdx = (uint32_t)rreg(cpu->hvf_fd, HV_X86_RDX); 78069e0a03cSPaolo Bonzini 78169e0a03cSPaolo Bonzini cpu_x86_cpuid(env, rax, rcx, &rax, &rbx, &rcx, &rdx); 78269e0a03cSPaolo Bonzini 78369e0a03cSPaolo Bonzini wreg(cpu->hvf_fd, HV_X86_RAX, rax); 78469e0a03cSPaolo Bonzini wreg(cpu->hvf_fd, HV_X86_RBX, rbx); 78569e0a03cSPaolo Bonzini wreg(cpu->hvf_fd, HV_X86_RCX, rcx); 78669e0a03cSPaolo Bonzini wreg(cpu->hvf_fd, HV_X86_RDX, rdx); 78769e0a03cSPaolo Bonzini 78869e0a03cSPaolo Bonzini macvm_set_rip(cpu, rip + ins_len); 78969e0a03cSPaolo Bonzini break; 79069e0a03cSPaolo Bonzini } 79169e0a03cSPaolo Bonzini case EXIT_REASON_XSETBV: { 79269e0a03cSPaolo Bonzini X86CPU *x86_cpu = X86_CPU(cpu); 79369e0a03cSPaolo Bonzini CPUX86State *env = &x86_cpu->env; 79469e0a03cSPaolo Bonzini uint32_t eax = (uint32_t)rreg(cpu->hvf_fd, HV_X86_RAX); 79569e0a03cSPaolo Bonzini uint32_t ecx = (uint32_t)rreg(cpu->hvf_fd, HV_X86_RCX); 79669e0a03cSPaolo Bonzini uint32_t edx = (uint32_t)rreg(cpu->hvf_fd, HV_X86_RDX); 79769e0a03cSPaolo Bonzini 79869e0a03cSPaolo Bonzini if (ecx) { 79969e0a03cSPaolo Bonzini macvm_set_rip(cpu, rip + ins_len); 80069e0a03cSPaolo Bonzini break; 80169e0a03cSPaolo Bonzini } 80269e0a03cSPaolo Bonzini env->xcr0 = ((uint64_t)edx << 32) | eax; 80369e0a03cSPaolo Bonzini wreg(cpu->hvf_fd, HV_X86_XCR0, env->xcr0 | 1); 80469e0a03cSPaolo Bonzini macvm_set_rip(cpu, rip + ins_len); 80569e0a03cSPaolo Bonzini break; 80669e0a03cSPaolo Bonzini } 80769e0a03cSPaolo Bonzini case EXIT_REASON_INTR_WINDOW: 80869e0a03cSPaolo Bonzini vmx_clear_int_window_exiting(cpu); 80969e0a03cSPaolo Bonzini ret = EXCP_INTERRUPT; 81069e0a03cSPaolo Bonzini break; 81169e0a03cSPaolo Bonzini case EXIT_REASON_NMI_WINDOW: 81269e0a03cSPaolo Bonzini vmx_clear_nmi_window_exiting(cpu); 81369e0a03cSPaolo Bonzini ret = EXCP_INTERRUPT; 81469e0a03cSPaolo Bonzini break; 81569e0a03cSPaolo Bonzini case EXIT_REASON_EXT_INTR: 81669e0a03cSPaolo Bonzini /* force exit and allow io handling */ 81769e0a03cSPaolo Bonzini ret = EXCP_INTERRUPT; 81869e0a03cSPaolo Bonzini break; 81969e0a03cSPaolo Bonzini case EXIT_REASON_RDMSR: 82069e0a03cSPaolo Bonzini case EXIT_REASON_WRMSR: 82169e0a03cSPaolo Bonzini { 82269e0a03cSPaolo Bonzini load_regs(cpu); 82369e0a03cSPaolo Bonzini if (exit_reason == EXIT_REASON_RDMSR) { 82469e0a03cSPaolo Bonzini simulate_rdmsr(cpu); 82569e0a03cSPaolo Bonzini } else { 82669e0a03cSPaolo Bonzini simulate_wrmsr(cpu); 82769e0a03cSPaolo Bonzini } 82869e0a03cSPaolo Bonzini RIP(env) += rvmcs(cpu->hvf_fd, VMCS_EXIT_INSTRUCTION_LENGTH); 82969e0a03cSPaolo Bonzini store_regs(cpu); 83069e0a03cSPaolo Bonzini break; 83169e0a03cSPaolo Bonzini } 83269e0a03cSPaolo Bonzini case EXIT_REASON_CR_ACCESS: { 83369e0a03cSPaolo Bonzini int cr; 83469e0a03cSPaolo Bonzini int reg; 83569e0a03cSPaolo Bonzini 83669e0a03cSPaolo Bonzini load_regs(cpu); 83769e0a03cSPaolo Bonzini cr = exit_qual & 15; 83869e0a03cSPaolo Bonzini reg = (exit_qual >> 8) & 15; 83969e0a03cSPaolo Bonzini 84069e0a03cSPaolo Bonzini switch (cr) { 84169e0a03cSPaolo Bonzini case 0x0: { 84269e0a03cSPaolo Bonzini macvm_set_cr0(cpu->hvf_fd, RRX(env, reg)); 84369e0a03cSPaolo Bonzini break; 84469e0a03cSPaolo Bonzini } 84569e0a03cSPaolo Bonzini case 4: { 84669e0a03cSPaolo Bonzini macvm_set_cr4(cpu->hvf_fd, RRX(env, reg)); 84769e0a03cSPaolo Bonzini break; 84869e0a03cSPaolo Bonzini } 84969e0a03cSPaolo Bonzini case 8: { 85069e0a03cSPaolo Bonzini X86CPU *x86_cpu = X86_CPU(cpu); 85169e0a03cSPaolo Bonzini if (exit_qual & 0x10) { 85269e0a03cSPaolo Bonzini RRX(env, reg) = cpu_get_apic_tpr(x86_cpu->apic_state); 85369e0a03cSPaolo Bonzini } else { 85469e0a03cSPaolo Bonzini int tpr = RRX(env, reg); 85569e0a03cSPaolo Bonzini cpu_set_apic_tpr(x86_cpu->apic_state, tpr); 85669e0a03cSPaolo Bonzini ret = EXCP_INTERRUPT; 85769e0a03cSPaolo Bonzini } 85869e0a03cSPaolo Bonzini break; 85969e0a03cSPaolo Bonzini } 86069e0a03cSPaolo Bonzini default: 86169e0a03cSPaolo Bonzini error_report("Unrecognized CR %d\n", cr); 86269e0a03cSPaolo Bonzini abort(); 86369e0a03cSPaolo Bonzini } 86469e0a03cSPaolo Bonzini RIP(env) += ins_len; 86569e0a03cSPaolo Bonzini store_regs(cpu); 86669e0a03cSPaolo Bonzini break; 86769e0a03cSPaolo Bonzini } 86869e0a03cSPaolo Bonzini case EXIT_REASON_APIC_ACCESS: { /* TODO */ 86969e0a03cSPaolo Bonzini struct x86_decode decode; 87069e0a03cSPaolo Bonzini 87169e0a03cSPaolo Bonzini load_regs(cpu); 87269e0a03cSPaolo Bonzini env->hvf_emul->fetch_rip = rip; 87369e0a03cSPaolo Bonzini 87469e0a03cSPaolo Bonzini decode_instruction(env, &decode); 87569e0a03cSPaolo Bonzini exec_instruction(env, &decode); 87669e0a03cSPaolo Bonzini store_regs(cpu); 87769e0a03cSPaolo Bonzini break; 87869e0a03cSPaolo Bonzini } 87969e0a03cSPaolo Bonzini case EXIT_REASON_TPR: { 88069e0a03cSPaolo Bonzini ret = 1; 88169e0a03cSPaolo Bonzini break; 88269e0a03cSPaolo Bonzini } 88369e0a03cSPaolo Bonzini case EXIT_REASON_TASK_SWITCH: { 88469e0a03cSPaolo Bonzini uint64_t vinfo = rvmcs(cpu->hvf_fd, VMCS_IDT_VECTORING_INFO); 88569e0a03cSPaolo Bonzini x68_segment_selector sel = {.sel = exit_qual & 0xffff}; 88669e0a03cSPaolo Bonzini vmx_handle_task_switch(cpu, sel, (exit_qual >> 30) & 0x3, 88769e0a03cSPaolo Bonzini vinfo & VMCS_INTR_VALID, vinfo & VECTORING_INFO_VECTOR_MASK, vinfo 88869e0a03cSPaolo Bonzini & VMCS_INTR_T_MASK); 88969e0a03cSPaolo Bonzini break; 89069e0a03cSPaolo Bonzini } 89169e0a03cSPaolo Bonzini case EXIT_REASON_TRIPLE_FAULT: { 89269e0a03cSPaolo Bonzini qemu_system_reset_request(SHUTDOWN_CAUSE_GUEST_RESET); 89369e0a03cSPaolo Bonzini ret = EXCP_INTERRUPT; 89469e0a03cSPaolo Bonzini break; 89569e0a03cSPaolo Bonzini } 89669e0a03cSPaolo Bonzini case EXIT_REASON_RDPMC: 89769e0a03cSPaolo Bonzini wreg(cpu->hvf_fd, HV_X86_RAX, 0); 89869e0a03cSPaolo Bonzini wreg(cpu->hvf_fd, HV_X86_RDX, 0); 89969e0a03cSPaolo Bonzini macvm_set_rip(cpu, rip + ins_len); 90069e0a03cSPaolo Bonzini break; 90169e0a03cSPaolo Bonzini case VMX_REASON_VMCALL: 90269e0a03cSPaolo Bonzini env->exception_injected = EXCP0D_GPF; 90369e0a03cSPaolo Bonzini env->has_error_code = true; 90469e0a03cSPaolo Bonzini env->error_code = 0; 90569e0a03cSPaolo Bonzini break; 90669e0a03cSPaolo Bonzini default: 90769e0a03cSPaolo Bonzini error_report("%llx: unhandled exit %llx\n", rip, exit_reason); 90869e0a03cSPaolo Bonzini } 90969e0a03cSPaolo Bonzini } while (ret == 0); 91069e0a03cSPaolo Bonzini 91169e0a03cSPaolo Bonzini return ret; 91269e0a03cSPaolo Bonzini } 91369e0a03cSPaolo Bonzini 91469e0a03cSPaolo Bonzini static bool hvf_allowed; 91569e0a03cSPaolo Bonzini 91669e0a03cSPaolo Bonzini static int hvf_accel_init(MachineState *ms) 91769e0a03cSPaolo Bonzini { 91869e0a03cSPaolo Bonzini int x; 91969e0a03cSPaolo Bonzini hv_return_t ret; 92069e0a03cSPaolo Bonzini HVFState *s; 92169e0a03cSPaolo Bonzini 92269e0a03cSPaolo Bonzini hvf_disable(0); 92369e0a03cSPaolo Bonzini ret = hv_vm_create(HV_VM_DEFAULT); 92469e0a03cSPaolo Bonzini assert_hvf_ok(ret); 92569e0a03cSPaolo Bonzini 92669e0a03cSPaolo Bonzini s = g_new0(HVFState, 1); 92769e0a03cSPaolo Bonzini 92869e0a03cSPaolo Bonzini s->num_slots = 32; 92969e0a03cSPaolo Bonzini for (x = 0; x < s->num_slots; ++x) { 93069e0a03cSPaolo Bonzini s->slots[x].size = 0; 93169e0a03cSPaolo Bonzini s->slots[x].slot_id = x; 93269e0a03cSPaolo Bonzini } 93369e0a03cSPaolo Bonzini 93469e0a03cSPaolo Bonzini hvf_state = s; 93569e0a03cSPaolo Bonzini cpu_interrupt_handler = hvf_handle_interrupt; 93669e0a03cSPaolo Bonzini memory_listener_register(&hvf_memory_listener, &address_space_memory); 93769e0a03cSPaolo Bonzini return 0; 93869e0a03cSPaolo Bonzini } 93969e0a03cSPaolo Bonzini 94069e0a03cSPaolo Bonzini static void hvf_accel_class_init(ObjectClass *oc, void *data) 94169e0a03cSPaolo Bonzini { 94269e0a03cSPaolo Bonzini AccelClass *ac = ACCEL_CLASS(oc); 94369e0a03cSPaolo Bonzini ac->name = "HVF"; 94469e0a03cSPaolo Bonzini ac->init_machine = hvf_accel_init; 94569e0a03cSPaolo Bonzini ac->allowed = &hvf_allowed; 94669e0a03cSPaolo Bonzini } 94769e0a03cSPaolo Bonzini 94869e0a03cSPaolo Bonzini static const TypeInfo hvf_accel_type = { 94969e0a03cSPaolo Bonzini .name = TYPE_HVF_ACCEL, 95069e0a03cSPaolo Bonzini .parent = TYPE_ACCEL, 95169e0a03cSPaolo Bonzini .class_init = hvf_accel_class_init, 95269e0a03cSPaolo Bonzini }; 95369e0a03cSPaolo Bonzini 95469e0a03cSPaolo Bonzini static void hvf_type_init(void) 95569e0a03cSPaolo Bonzini { 95669e0a03cSPaolo Bonzini type_register_static(&hvf_accel_type); 95769e0a03cSPaolo Bonzini } 95869e0a03cSPaolo Bonzini 95969e0a03cSPaolo Bonzini type_init(hvf_type_init); 960