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 16e361a772SThomas Huth * General Public License for more details. 1769e0a03cSPaolo Bonzini * 18e361a772SThomas Huth * You should have received a copy of the GNU General Public License 19e361a772SThomas Huth * along with this program; if not, see <http://www.gnu.org/licenses/>. 20d781e24dSIzik Eidus * 21d781e24dSIzik Eidus * This file contain code under public domain from the hvdos project: 22d781e24dSIzik Eidus * https://github.com/mist64/hvdos 234d98a8e5SPaolo Bonzini * 244d98a8e5SPaolo Bonzini * Parts Copyright (c) 2011 NetApp, Inc. 254d98a8e5SPaolo Bonzini * All rights reserved. 264d98a8e5SPaolo Bonzini * 274d98a8e5SPaolo Bonzini * Redistribution and use in source and binary forms, with or without 284d98a8e5SPaolo Bonzini * modification, are permitted provided that the following conditions 294d98a8e5SPaolo Bonzini * are met: 304d98a8e5SPaolo Bonzini * 1. Redistributions of source code must retain the above copyright 314d98a8e5SPaolo Bonzini * notice, this list of conditions and the following disclaimer. 324d98a8e5SPaolo Bonzini * 2. Redistributions in binary form must reproduce the above copyright 334d98a8e5SPaolo Bonzini * notice, this list of conditions and the following disclaimer in the 344d98a8e5SPaolo Bonzini * documentation and/or other materials provided with the distribution. 354d98a8e5SPaolo Bonzini * 364d98a8e5SPaolo Bonzini * THIS SOFTWARE IS PROVIDED BY NETAPP, INC ``AS IS'' AND 374d98a8e5SPaolo Bonzini * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 384d98a8e5SPaolo Bonzini * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 394d98a8e5SPaolo Bonzini * ARE DISCLAIMED. IN NO EVENT SHALL NETAPP, INC OR CONTRIBUTORS BE LIABLE 404d98a8e5SPaolo Bonzini * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 414d98a8e5SPaolo Bonzini * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 424d98a8e5SPaolo Bonzini * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 434d98a8e5SPaolo Bonzini * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 444d98a8e5SPaolo Bonzini * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 454d98a8e5SPaolo Bonzini * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 464d98a8e5SPaolo Bonzini * SUCH DAMAGE. 4769e0a03cSPaolo Bonzini */ 4854d31236SMarkus Armbruster 4969e0a03cSPaolo Bonzini #include "qemu/osdep.h" 5069e0a03cSPaolo Bonzini #include "qemu-common.h" 5169e0a03cSPaolo Bonzini #include "qemu/error-report.h" 5269e0a03cSPaolo Bonzini 5369e0a03cSPaolo Bonzini #include "sysemu/hvf.h" 5454d31236SMarkus Armbruster #include "sysemu/runstate.h" 5569e0a03cSPaolo Bonzini #include "hvf-i386.h" 5669e0a03cSPaolo Bonzini #include "vmcs.h" 5769e0a03cSPaolo Bonzini #include "vmx.h" 5869e0a03cSPaolo Bonzini #include "x86.h" 5969e0a03cSPaolo Bonzini #include "x86_descr.h" 6069e0a03cSPaolo Bonzini #include "x86_mmu.h" 6169e0a03cSPaolo Bonzini #include "x86_decode.h" 6269e0a03cSPaolo Bonzini #include "x86_emu.h" 6369e0a03cSPaolo Bonzini #include "x86_task.h" 6469e0a03cSPaolo Bonzini #include "x86hvf.h" 6569e0a03cSPaolo Bonzini 6669e0a03cSPaolo Bonzini #include <Hypervisor/hv.h> 6769e0a03cSPaolo Bonzini #include <Hypervisor/hv_vmx.h> 68*3b502b0eSVladislav Yaroshchuk #include <sys/sysctl.h> 6969e0a03cSPaolo Bonzini 7069e0a03cSPaolo Bonzini #include "exec/address-spaces.h" 7169e0a03cSPaolo Bonzini #include "hw/i386/apic_internal.h" 7269e0a03cSPaolo Bonzini #include "qemu/main-loop.h" 73940e43aaSClaudio Fontana #include "qemu/accel.h" 7469e0a03cSPaolo Bonzini #include "target/i386/cpu.h" 7569e0a03cSPaolo Bonzini 76b86f59c7SClaudio Fontana #include "hvf-accel-ops.h" 77b52bcba7SClaudio Fontana 7869e0a03cSPaolo Bonzini HVFState *hvf_state; 7969e0a03cSPaolo Bonzini 8069e0a03cSPaolo Bonzini static void assert_hvf_ok(hv_return_t ret) 8169e0a03cSPaolo Bonzini { 8269e0a03cSPaolo Bonzini if (ret == HV_SUCCESS) { 8369e0a03cSPaolo Bonzini return; 8469e0a03cSPaolo Bonzini } 8569e0a03cSPaolo Bonzini 8669e0a03cSPaolo Bonzini switch (ret) { 8769e0a03cSPaolo Bonzini case HV_ERROR: 882d9178d9SLaurent Vivier error_report("Error: HV_ERROR"); 8969e0a03cSPaolo Bonzini break; 9069e0a03cSPaolo Bonzini case HV_BUSY: 912d9178d9SLaurent Vivier error_report("Error: HV_BUSY"); 9269e0a03cSPaolo Bonzini break; 9369e0a03cSPaolo Bonzini case HV_BAD_ARGUMENT: 942d9178d9SLaurent Vivier error_report("Error: HV_BAD_ARGUMENT"); 9569e0a03cSPaolo Bonzini break; 9669e0a03cSPaolo Bonzini case HV_NO_RESOURCES: 972d9178d9SLaurent Vivier error_report("Error: HV_NO_RESOURCES"); 9869e0a03cSPaolo Bonzini break; 9969e0a03cSPaolo Bonzini case HV_NO_DEVICE: 1002d9178d9SLaurent Vivier error_report("Error: HV_NO_DEVICE"); 10169e0a03cSPaolo Bonzini break; 10269e0a03cSPaolo Bonzini case HV_UNSUPPORTED: 1032d9178d9SLaurent Vivier error_report("Error: HV_UNSUPPORTED"); 10469e0a03cSPaolo Bonzini break; 10569e0a03cSPaolo Bonzini default: 1062d9178d9SLaurent Vivier error_report("Unknown Error"); 10769e0a03cSPaolo Bonzini } 10869e0a03cSPaolo Bonzini 10969e0a03cSPaolo Bonzini abort(); 11069e0a03cSPaolo Bonzini } 11169e0a03cSPaolo Bonzini 11269e0a03cSPaolo Bonzini /* Memory slots */ 113fbafbb6dSCameron Esfahani hvf_slot *hvf_find_overlap_slot(uint64_t start, uint64_t size) 11469e0a03cSPaolo Bonzini { 11569e0a03cSPaolo Bonzini hvf_slot *slot; 11669e0a03cSPaolo Bonzini int x; 11769e0a03cSPaolo Bonzini for (x = 0; x < hvf_state->num_slots; ++x) { 11869e0a03cSPaolo Bonzini slot = &hvf_state->slots[x]; 11969e0a03cSPaolo Bonzini if (slot->size && start < (slot->start + slot->size) && 120fbafbb6dSCameron Esfahani (start + size) > slot->start) { 12169e0a03cSPaolo Bonzini return slot; 12269e0a03cSPaolo Bonzini } 12369e0a03cSPaolo Bonzini } 12469e0a03cSPaolo Bonzini return NULL; 12569e0a03cSPaolo Bonzini } 12669e0a03cSPaolo Bonzini 12769e0a03cSPaolo Bonzini struct mac_slot { 12869e0a03cSPaolo Bonzini int present; 12969e0a03cSPaolo Bonzini uint64_t size; 13069e0a03cSPaolo Bonzini uint64_t gpa_start; 13169e0a03cSPaolo Bonzini uint64_t gva; 13269e0a03cSPaolo Bonzini }; 13369e0a03cSPaolo Bonzini 13469e0a03cSPaolo Bonzini struct mac_slot mac_slots[32]; 13569e0a03cSPaolo Bonzini 136fbafbb6dSCameron Esfahani static int do_hvf_set_memory(hvf_slot *slot, hv_memory_flags_t flags) 13769e0a03cSPaolo Bonzini { 13869e0a03cSPaolo Bonzini struct mac_slot *macslot; 13969e0a03cSPaolo Bonzini hv_return_t ret; 14069e0a03cSPaolo Bonzini 14169e0a03cSPaolo Bonzini macslot = &mac_slots[slot->slot_id]; 14269e0a03cSPaolo Bonzini 14369e0a03cSPaolo Bonzini if (macslot->present) { 14469e0a03cSPaolo Bonzini if (macslot->size != slot->size) { 14569e0a03cSPaolo Bonzini macslot->present = 0; 14669e0a03cSPaolo Bonzini ret = hv_vm_unmap(macslot->gpa_start, macslot->size); 14769e0a03cSPaolo Bonzini assert_hvf_ok(ret); 14869e0a03cSPaolo Bonzini } 14969e0a03cSPaolo Bonzini } 15069e0a03cSPaolo Bonzini 15169e0a03cSPaolo Bonzini if (!slot->size) { 15269e0a03cSPaolo Bonzini return 0; 15369e0a03cSPaolo Bonzini } 15469e0a03cSPaolo Bonzini 15569e0a03cSPaolo Bonzini macslot->present = 1; 15669e0a03cSPaolo Bonzini macslot->gpa_start = slot->start; 15769e0a03cSPaolo Bonzini macslot->size = slot->size; 15869e0a03cSPaolo Bonzini ret = hv_vm_map((hv_uvaddr_t)slot->mem, slot->start, slot->size, flags); 15969e0a03cSPaolo Bonzini assert_hvf_ok(ret); 16069e0a03cSPaolo Bonzini return 0; 16169e0a03cSPaolo Bonzini } 16269e0a03cSPaolo Bonzini 16369e0a03cSPaolo Bonzini void hvf_set_phys_mem(MemoryRegionSection *section, bool add) 16469e0a03cSPaolo Bonzini { 16569e0a03cSPaolo Bonzini hvf_slot *mem; 16669e0a03cSPaolo Bonzini MemoryRegion *area = section->mr; 167fbafbb6dSCameron Esfahani bool writeable = !area->readonly && !area->rom_device; 168fbafbb6dSCameron Esfahani hv_memory_flags_t flags; 16969e0a03cSPaolo Bonzini 17069e0a03cSPaolo Bonzini if (!memory_region_is_ram(area)) { 171fbafbb6dSCameron Esfahani if (writeable) { 17269e0a03cSPaolo Bonzini return; 173fbafbb6dSCameron Esfahani } else if (!memory_region_is_romd(area)) { 174fbafbb6dSCameron Esfahani /* 175fbafbb6dSCameron Esfahani * If the memory device is not in romd_mode, then we actually want 176fbafbb6dSCameron Esfahani * to remove the hvf memory slot so all accesses will trap. 177fbafbb6dSCameron Esfahani */ 178fbafbb6dSCameron Esfahani add = false; 179fbafbb6dSCameron Esfahani } 18069e0a03cSPaolo Bonzini } 18169e0a03cSPaolo Bonzini 18269e0a03cSPaolo Bonzini mem = hvf_find_overlap_slot( 18369e0a03cSPaolo Bonzini section->offset_within_address_space, 184fbafbb6dSCameron Esfahani int128_get64(section->size)); 18569e0a03cSPaolo Bonzini 18669e0a03cSPaolo Bonzini if (mem && add) { 18769e0a03cSPaolo Bonzini if (mem->size == int128_get64(section->size) && 18869e0a03cSPaolo Bonzini mem->start == section->offset_within_address_space && 18969e0a03cSPaolo Bonzini mem->mem == (memory_region_get_ram_ptr(area) + 19069e0a03cSPaolo Bonzini section->offset_within_region)) { 19169e0a03cSPaolo Bonzini return; /* Same region was attempted to register, go away. */ 19269e0a03cSPaolo Bonzini } 19369e0a03cSPaolo Bonzini } 19469e0a03cSPaolo Bonzini 19569e0a03cSPaolo Bonzini /* Region needs to be reset. set the size to 0 and remap it. */ 19669e0a03cSPaolo Bonzini if (mem) { 19769e0a03cSPaolo Bonzini mem->size = 0; 198fbafbb6dSCameron Esfahani if (do_hvf_set_memory(mem, 0)) { 1992d9178d9SLaurent Vivier error_report("Failed to reset overlapping slot"); 20069e0a03cSPaolo Bonzini abort(); 20169e0a03cSPaolo Bonzini } 20269e0a03cSPaolo Bonzini } 20369e0a03cSPaolo Bonzini 20469e0a03cSPaolo Bonzini if (!add) { 20569e0a03cSPaolo Bonzini return; 20669e0a03cSPaolo Bonzini } 20769e0a03cSPaolo Bonzini 208fbafbb6dSCameron Esfahani if (area->readonly || 209fbafbb6dSCameron Esfahani (!memory_region_is_ram(area) && memory_region_is_romd(area))) { 210fbafbb6dSCameron Esfahani flags = HV_MEMORY_READ | HV_MEMORY_EXEC; 211fbafbb6dSCameron Esfahani } else { 212fbafbb6dSCameron Esfahani flags = HV_MEMORY_READ | HV_MEMORY_WRITE | HV_MEMORY_EXEC; 213fbafbb6dSCameron Esfahani } 214fbafbb6dSCameron Esfahani 21569e0a03cSPaolo Bonzini /* Now make a new slot. */ 21669e0a03cSPaolo Bonzini int x; 21769e0a03cSPaolo Bonzini 21869e0a03cSPaolo Bonzini for (x = 0; x < hvf_state->num_slots; ++x) { 21969e0a03cSPaolo Bonzini mem = &hvf_state->slots[x]; 22069e0a03cSPaolo Bonzini if (!mem->size) { 22169e0a03cSPaolo Bonzini break; 22269e0a03cSPaolo Bonzini } 22369e0a03cSPaolo Bonzini } 22469e0a03cSPaolo Bonzini 22569e0a03cSPaolo Bonzini if (x == hvf_state->num_slots) { 2262d9178d9SLaurent Vivier error_report("No free slots"); 22769e0a03cSPaolo Bonzini abort(); 22869e0a03cSPaolo Bonzini } 22969e0a03cSPaolo Bonzini 23069e0a03cSPaolo Bonzini mem->size = int128_get64(section->size); 23169e0a03cSPaolo Bonzini mem->mem = memory_region_get_ram_ptr(area) + section->offset_within_region; 23269e0a03cSPaolo Bonzini mem->start = section->offset_within_address_space; 23369e0a03cSPaolo Bonzini mem->region = area; 23469e0a03cSPaolo Bonzini 235fbafbb6dSCameron Esfahani if (do_hvf_set_memory(mem, flags)) { 2362d9178d9SLaurent Vivier error_report("Error registering new memory slot"); 23769e0a03cSPaolo Bonzini abort(); 23869e0a03cSPaolo Bonzini } 23969e0a03cSPaolo Bonzini } 24069e0a03cSPaolo Bonzini 24169e0a03cSPaolo Bonzini void vmx_update_tpr(CPUState *cpu) 24269e0a03cSPaolo Bonzini { 24369e0a03cSPaolo Bonzini /* TODO: need integrate APIC handling */ 24469e0a03cSPaolo Bonzini X86CPU *x86_cpu = X86_CPU(cpu); 24569e0a03cSPaolo Bonzini int tpr = cpu_get_apic_tpr(x86_cpu->apic_state) << 4; 24669e0a03cSPaolo Bonzini int irr = apic_get_highest_priority_irr(x86_cpu->apic_state); 24769e0a03cSPaolo Bonzini 24869e0a03cSPaolo Bonzini wreg(cpu->hvf_fd, HV_X86_TPR, tpr); 24969e0a03cSPaolo Bonzini if (irr == -1) { 25069e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_TPR_THRESHOLD, 0); 25169e0a03cSPaolo Bonzini } else { 25269e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_TPR_THRESHOLD, (irr > tpr) ? tpr >> 4 : 25369e0a03cSPaolo Bonzini irr >> 4); 25469e0a03cSPaolo Bonzini } 25569e0a03cSPaolo Bonzini } 25669e0a03cSPaolo Bonzini 257583ae161SRoman Bolshakov static void update_apic_tpr(CPUState *cpu) 25869e0a03cSPaolo Bonzini { 25969e0a03cSPaolo Bonzini X86CPU *x86_cpu = X86_CPU(cpu); 26069e0a03cSPaolo Bonzini int tpr = rreg(cpu->hvf_fd, HV_X86_TPR) >> 4; 26169e0a03cSPaolo Bonzini cpu_set_apic_tpr(x86_cpu->apic_state, tpr); 26269e0a03cSPaolo Bonzini } 26369e0a03cSPaolo Bonzini 26469e0a03cSPaolo Bonzini #define VECTORING_INFO_VECTOR_MASK 0xff 26569e0a03cSPaolo Bonzini 26669e0a03cSPaolo Bonzini void hvf_handle_io(CPUArchState *env, uint16_t port, void *buffer, 26769e0a03cSPaolo Bonzini int direction, int size, int count) 26869e0a03cSPaolo Bonzini { 26969e0a03cSPaolo Bonzini int i; 27069e0a03cSPaolo Bonzini uint8_t *ptr = buffer; 27169e0a03cSPaolo Bonzini 27269e0a03cSPaolo Bonzini for (i = 0; i < count; i++) { 27369e0a03cSPaolo Bonzini address_space_rw(&address_space_io, port, MEMTXATTRS_UNSPECIFIED, 27469e0a03cSPaolo Bonzini ptr, size, 27569e0a03cSPaolo Bonzini direction); 27669e0a03cSPaolo Bonzini ptr += size; 27769e0a03cSPaolo Bonzini } 27869e0a03cSPaolo Bonzini } 27969e0a03cSPaolo Bonzini 28069e0a03cSPaolo Bonzini static void do_hvf_cpu_synchronize_state(CPUState *cpu, run_on_cpu_data arg) 28169e0a03cSPaolo Bonzini { 282eae009deSRoman Bolshakov if (!cpu->vcpu_dirty) { 283eae009deSRoman Bolshakov hvf_get_registers(cpu); 284eae009deSRoman Bolshakov cpu->vcpu_dirty = true; 285eae009deSRoman Bolshakov } 28669e0a03cSPaolo Bonzini } 28769e0a03cSPaolo Bonzini 288eae009deSRoman Bolshakov void hvf_cpu_synchronize_state(CPUState *cpu) 28969e0a03cSPaolo Bonzini { 290eae009deSRoman Bolshakov if (!cpu->vcpu_dirty) { 291eae009deSRoman Bolshakov run_on_cpu(cpu, do_hvf_cpu_synchronize_state, RUN_ON_CPU_NULL); 29269e0a03cSPaolo Bonzini } 29369e0a03cSPaolo Bonzini } 29469e0a03cSPaolo Bonzini 295eae009deSRoman Bolshakov static void do_hvf_cpu_synchronize_post_reset(CPUState *cpu, 296eae009deSRoman Bolshakov run_on_cpu_data arg) 29769e0a03cSPaolo Bonzini { 298eae009deSRoman Bolshakov hvf_put_registers(cpu); 299eae009deSRoman Bolshakov cpu->vcpu_dirty = false; 30069e0a03cSPaolo Bonzini } 30169e0a03cSPaolo Bonzini 302eae009deSRoman Bolshakov void hvf_cpu_synchronize_post_reset(CPUState *cpu) 30369e0a03cSPaolo Bonzini { 304eae009deSRoman Bolshakov run_on_cpu(cpu, do_hvf_cpu_synchronize_post_reset, RUN_ON_CPU_NULL); 30569e0a03cSPaolo Bonzini } 30669e0a03cSPaolo Bonzini 307583ae161SRoman Bolshakov static void do_hvf_cpu_synchronize_post_init(CPUState *cpu, 308583ae161SRoman Bolshakov run_on_cpu_data arg) 30969e0a03cSPaolo Bonzini { 310eae009deSRoman Bolshakov hvf_put_registers(cpu); 311eae009deSRoman Bolshakov cpu->vcpu_dirty = false; 31269e0a03cSPaolo Bonzini } 31369e0a03cSPaolo Bonzini 314eae009deSRoman Bolshakov void hvf_cpu_synchronize_post_init(CPUState *cpu) 31569e0a03cSPaolo Bonzini { 316eae009deSRoman Bolshakov run_on_cpu(cpu, do_hvf_cpu_synchronize_post_init, RUN_ON_CPU_NULL); 31769e0a03cSPaolo Bonzini } 31869e0a03cSPaolo Bonzini 3195536c98eSRoman Bolshakov static void do_hvf_cpu_synchronize_pre_loadvm(CPUState *cpu, 3205536c98eSRoman Bolshakov run_on_cpu_data arg) 3215536c98eSRoman Bolshakov { 3225536c98eSRoman Bolshakov cpu->vcpu_dirty = true; 3235536c98eSRoman Bolshakov } 3245536c98eSRoman Bolshakov 3255536c98eSRoman Bolshakov void hvf_cpu_synchronize_pre_loadvm(CPUState *cpu) 3265536c98eSRoman Bolshakov { 3275536c98eSRoman Bolshakov run_on_cpu(cpu, do_hvf_cpu_synchronize_pre_loadvm, RUN_ON_CPU_NULL); 3285536c98eSRoman Bolshakov } 3295536c98eSRoman Bolshakov 330ff2de166SPaolo Bonzini static bool ept_emulation_fault(hvf_slot *slot, uint64_t gpa, uint64_t ept_qual) 33169e0a03cSPaolo Bonzini { 33269e0a03cSPaolo Bonzini int read, write; 33369e0a03cSPaolo Bonzini 33469e0a03cSPaolo Bonzini /* EPT fault on an instruction fetch doesn't make sense here */ 33569e0a03cSPaolo Bonzini if (ept_qual & EPT_VIOLATION_INST_FETCH) { 33669e0a03cSPaolo Bonzini return false; 33769e0a03cSPaolo Bonzini } 33869e0a03cSPaolo Bonzini 33969e0a03cSPaolo Bonzini /* EPT fault must be a read fault or a write fault */ 34069e0a03cSPaolo Bonzini read = ept_qual & EPT_VIOLATION_DATA_READ ? 1 : 0; 34169e0a03cSPaolo Bonzini write = ept_qual & EPT_VIOLATION_DATA_WRITE ? 1 : 0; 34269e0a03cSPaolo Bonzini if ((read | write) == 0) { 34369e0a03cSPaolo Bonzini return false; 34469e0a03cSPaolo Bonzini } 34569e0a03cSPaolo Bonzini 34669e0a03cSPaolo Bonzini if (write && slot) { 34769e0a03cSPaolo Bonzini if (slot->flags & HVF_SLOT_LOG) { 34869e0a03cSPaolo Bonzini memory_region_set_dirty(slot->region, gpa - slot->start, 1); 34969e0a03cSPaolo Bonzini hv_vm_protect((hv_gpaddr_t)slot->start, (size_t)slot->size, 35069e0a03cSPaolo Bonzini HV_MEMORY_READ | HV_MEMORY_WRITE); 35169e0a03cSPaolo Bonzini } 35269e0a03cSPaolo Bonzini } 35369e0a03cSPaolo Bonzini 35469e0a03cSPaolo Bonzini /* 35569e0a03cSPaolo Bonzini * The EPT violation must have been caused by accessing a 35669e0a03cSPaolo Bonzini * guest-physical address that is a translation of a guest-linear 35769e0a03cSPaolo Bonzini * address. 35869e0a03cSPaolo Bonzini */ 35969e0a03cSPaolo Bonzini if ((ept_qual & EPT_VIOLATION_GLA_VALID) == 0 || 36069e0a03cSPaolo Bonzini (ept_qual & EPT_VIOLATION_XLAT_VALID) == 0) { 36169e0a03cSPaolo Bonzini return false; 36269e0a03cSPaolo Bonzini } 36369e0a03cSPaolo Bonzini 364fbafbb6dSCameron Esfahani if (!slot) { 365fbafbb6dSCameron Esfahani return true; 366fbafbb6dSCameron Esfahani } 367fbafbb6dSCameron Esfahani if (!memory_region_is_ram(slot->region) && 368fbafbb6dSCameron Esfahani !(read && memory_region_is_romd(slot->region))) { 369fbafbb6dSCameron Esfahani return true; 370fbafbb6dSCameron Esfahani } 371fbafbb6dSCameron Esfahani return false; 37269e0a03cSPaolo Bonzini } 37369e0a03cSPaolo Bonzini 37469e0a03cSPaolo Bonzini static void hvf_set_dirty_tracking(MemoryRegionSection *section, bool on) 37569e0a03cSPaolo Bonzini { 37669e0a03cSPaolo Bonzini hvf_slot *slot; 37769e0a03cSPaolo Bonzini 37869e0a03cSPaolo Bonzini slot = hvf_find_overlap_slot( 37969e0a03cSPaolo Bonzini section->offset_within_address_space, 380fbafbb6dSCameron Esfahani int128_get64(section->size)); 38169e0a03cSPaolo Bonzini 38269e0a03cSPaolo Bonzini /* protect region against writes; begin tracking it */ 38369e0a03cSPaolo Bonzini if (on) { 38469e0a03cSPaolo Bonzini slot->flags |= HVF_SLOT_LOG; 38569e0a03cSPaolo Bonzini hv_vm_protect((hv_gpaddr_t)slot->start, (size_t)slot->size, 38669e0a03cSPaolo Bonzini HV_MEMORY_READ); 38769e0a03cSPaolo Bonzini /* stop tracking region*/ 38869e0a03cSPaolo Bonzini } else { 38969e0a03cSPaolo Bonzini slot->flags &= ~HVF_SLOT_LOG; 39069e0a03cSPaolo Bonzini hv_vm_protect((hv_gpaddr_t)slot->start, (size_t)slot->size, 39169e0a03cSPaolo Bonzini HV_MEMORY_READ | HV_MEMORY_WRITE); 39269e0a03cSPaolo Bonzini } 39369e0a03cSPaolo Bonzini } 39469e0a03cSPaolo Bonzini 39569e0a03cSPaolo Bonzini static void hvf_log_start(MemoryListener *listener, 39669e0a03cSPaolo Bonzini MemoryRegionSection *section, int old, int new) 39769e0a03cSPaolo Bonzini { 39869e0a03cSPaolo Bonzini if (old != 0) { 39969e0a03cSPaolo Bonzini return; 40069e0a03cSPaolo Bonzini } 40169e0a03cSPaolo Bonzini 40269e0a03cSPaolo Bonzini hvf_set_dirty_tracking(section, 1); 40369e0a03cSPaolo Bonzini } 40469e0a03cSPaolo Bonzini 40569e0a03cSPaolo Bonzini static void hvf_log_stop(MemoryListener *listener, 40669e0a03cSPaolo Bonzini MemoryRegionSection *section, int old, int new) 40769e0a03cSPaolo Bonzini { 40869e0a03cSPaolo Bonzini if (new != 0) { 40969e0a03cSPaolo Bonzini return; 41069e0a03cSPaolo Bonzini } 41169e0a03cSPaolo Bonzini 41269e0a03cSPaolo Bonzini hvf_set_dirty_tracking(section, 0); 41369e0a03cSPaolo Bonzini } 41469e0a03cSPaolo Bonzini 41569e0a03cSPaolo Bonzini static void hvf_log_sync(MemoryListener *listener, 41669e0a03cSPaolo Bonzini MemoryRegionSection *section) 41769e0a03cSPaolo Bonzini { 41869e0a03cSPaolo Bonzini /* 41969e0a03cSPaolo Bonzini * sync of dirty pages is handled elsewhere; just make sure we keep 42069e0a03cSPaolo Bonzini * tracking the region. 42169e0a03cSPaolo Bonzini */ 42269e0a03cSPaolo Bonzini hvf_set_dirty_tracking(section, 1); 42369e0a03cSPaolo Bonzini } 42469e0a03cSPaolo Bonzini 42569e0a03cSPaolo Bonzini static void hvf_region_add(MemoryListener *listener, 42669e0a03cSPaolo Bonzini MemoryRegionSection *section) 42769e0a03cSPaolo Bonzini { 42869e0a03cSPaolo Bonzini hvf_set_phys_mem(section, true); 42969e0a03cSPaolo Bonzini } 43069e0a03cSPaolo Bonzini 43169e0a03cSPaolo Bonzini static void hvf_region_del(MemoryListener *listener, 43269e0a03cSPaolo Bonzini MemoryRegionSection *section) 43369e0a03cSPaolo Bonzini { 43469e0a03cSPaolo Bonzini hvf_set_phys_mem(section, false); 43569e0a03cSPaolo Bonzini } 43669e0a03cSPaolo Bonzini 43769e0a03cSPaolo Bonzini static MemoryListener hvf_memory_listener = { 43869e0a03cSPaolo Bonzini .priority = 10, 43969e0a03cSPaolo Bonzini .region_add = hvf_region_add, 44069e0a03cSPaolo Bonzini .region_del = hvf_region_del, 44169e0a03cSPaolo Bonzini .log_start = hvf_log_start, 44269e0a03cSPaolo Bonzini .log_stop = hvf_log_stop, 44369e0a03cSPaolo Bonzini .log_sync = hvf_log_sync, 44469e0a03cSPaolo Bonzini }; 44569e0a03cSPaolo Bonzini 44669e0a03cSPaolo Bonzini void hvf_vcpu_destroy(CPUState *cpu) 44769e0a03cSPaolo Bonzini { 448fe76b09cSRoman Bolshakov X86CPU *x86_cpu = X86_CPU(cpu); 449fe76b09cSRoman Bolshakov CPUX86State *env = &x86_cpu->env; 450fe76b09cSRoman Bolshakov 45169e0a03cSPaolo Bonzini hv_return_t ret = hv_vcpu_destroy((hv_vcpuid_t)cpu->hvf_fd); 452fe76b09cSRoman Bolshakov g_free(env->hvf_mmio_buf); 45369e0a03cSPaolo Bonzini assert_hvf_ok(ret); 45469e0a03cSPaolo Bonzini } 45569e0a03cSPaolo Bonzini 45669e0a03cSPaolo Bonzini static void dummy_signal(int sig) 45769e0a03cSPaolo Bonzini { 45869e0a03cSPaolo Bonzini } 45969e0a03cSPaolo Bonzini 460*3b502b0eSVladislav Yaroshchuk static void init_tsc_freq(CPUX86State *env) 461*3b502b0eSVladislav Yaroshchuk { 462*3b502b0eSVladislav Yaroshchuk size_t length; 463*3b502b0eSVladislav Yaroshchuk uint64_t tsc_freq; 464*3b502b0eSVladislav Yaroshchuk 465*3b502b0eSVladislav Yaroshchuk if (env->tsc_khz != 0) { 466*3b502b0eSVladislav Yaroshchuk return; 467*3b502b0eSVladislav Yaroshchuk } 468*3b502b0eSVladislav Yaroshchuk 469*3b502b0eSVladislav Yaroshchuk length = sizeof(uint64_t); 470*3b502b0eSVladislav Yaroshchuk if (sysctlbyname("machdep.tsc.frequency", &tsc_freq, &length, NULL, 0)) { 471*3b502b0eSVladislav Yaroshchuk return; 472*3b502b0eSVladislav Yaroshchuk } 473*3b502b0eSVladislav Yaroshchuk env->tsc_khz = tsc_freq / 1000; /* Hz to KHz */ 474*3b502b0eSVladislav Yaroshchuk } 475*3b502b0eSVladislav Yaroshchuk 476*3b502b0eSVladislav Yaroshchuk static void init_apic_bus_freq(CPUX86State *env) 477*3b502b0eSVladislav Yaroshchuk { 478*3b502b0eSVladislav Yaroshchuk size_t length; 479*3b502b0eSVladislav Yaroshchuk uint64_t bus_freq; 480*3b502b0eSVladislav Yaroshchuk 481*3b502b0eSVladislav Yaroshchuk if (env->apic_bus_freq != 0) { 482*3b502b0eSVladislav Yaroshchuk return; 483*3b502b0eSVladislav Yaroshchuk } 484*3b502b0eSVladislav Yaroshchuk 485*3b502b0eSVladislav Yaroshchuk length = sizeof(uint64_t); 486*3b502b0eSVladislav Yaroshchuk if (sysctlbyname("hw.busfrequency", &bus_freq, &length, NULL, 0)) { 487*3b502b0eSVladislav Yaroshchuk return; 488*3b502b0eSVladislav Yaroshchuk } 489*3b502b0eSVladislav Yaroshchuk env->apic_bus_freq = bus_freq; 490*3b502b0eSVladislav Yaroshchuk } 491*3b502b0eSVladislav Yaroshchuk 492*3b502b0eSVladislav Yaroshchuk static inline bool tsc_is_known(CPUX86State *env) 493*3b502b0eSVladislav Yaroshchuk { 494*3b502b0eSVladislav Yaroshchuk return env->tsc_khz != 0; 495*3b502b0eSVladislav Yaroshchuk } 496*3b502b0eSVladislav Yaroshchuk 497*3b502b0eSVladislav Yaroshchuk static inline bool apic_bus_freq_is_known(CPUX86State *env) 498*3b502b0eSVladislav Yaroshchuk { 499*3b502b0eSVladislav Yaroshchuk return env->apic_bus_freq != 0; 500*3b502b0eSVladislav Yaroshchuk } 501*3b502b0eSVladislav Yaroshchuk 50269e0a03cSPaolo Bonzini int hvf_init_vcpu(CPUState *cpu) 50369e0a03cSPaolo Bonzini { 50469e0a03cSPaolo Bonzini 50569e0a03cSPaolo Bonzini X86CPU *x86cpu = X86_CPU(cpu); 50669e0a03cSPaolo Bonzini CPUX86State *env = &x86cpu->env; 50769e0a03cSPaolo Bonzini int r; 50869e0a03cSPaolo Bonzini 50969e0a03cSPaolo Bonzini /* init cpu signals */ 51069e0a03cSPaolo Bonzini sigset_t set; 51169e0a03cSPaolo Bonzini struct sigaction sigact; 51269e0a03cSPaolo Bonzini 51369e0a03cSPaolo Bonzini memset(&sigact, 0, sizeof(sigact)); 51469e0a03cSPaolo Bonzini sigact.sa_handler = dummy_signal; 51569e0a03cSPaolo Bonzini sigaction(SIG_IPI, &sigact, NULL); 51669e0a03cSPaolo Bonzini 51769e0a03cSPaolo Bonzini pthread_sigmask(SIG_BLOCK, NULL, &set); 51869e0a03cSPaolo Bonzini sigdelset(&set, SIG_IPI); 51969e0a03cSPaolo Bonzini 52069e0a03cSPaolo Bonzini init_emu(); 52169e0a03cSPaolo Bonzini init_decoder(); 52269e0a03cSPaolo Bonzini 52369e0a03cSPaolo Bonzini hvf_state->hvf_caps = g_new0(struct hvf_vcpu_caps, 1); 524fe76b09cSRoman Bolshakov env->hvf_mmio_buf = g_new(char, 4096); 52569e0a03cSPaolo Bonzini 526*3b502b0eSVladislav Yaroshchuk if (x86cpu->vmware_cpuid_freq) { 527*3b502b0eSVladislav Yaroshchuk init_tsc_freq(env); 528*3b502b0eSVladislav Yaroshchuk init_apic_bus_freq(env); 529*3b502b0eSVladislav Yaroshchuk 530*3b502b0eSVladislav Yaroshchuk if (!tsc_is_known(env) || !apic_bus_freq_is_known(env)) { 531*3b502b0eSVladislav Yaroshchuk error_report("vmware-cpuid-freq: feature couldn't be enabled"); 532*3b502b0eSVladislav Yaroshchuk } 533*3b502b0eSVladislav Yaroshchuk } 534*3b502b0eSVladislav Yaroshchuk 53569e0a03cSPaolo Bonzini r = hv_vcpu_create((hv_vcpuid_t *)&cpu->hvf_fd, HV_VCPU_DEFAULT); 53669e0a03cSPaolo Bonzini cpu->vcpu_dirty = 1; 53769e0a03cSPaolo Bonzini assert_hvf_ok(r); 53869e0a03cSPaolo Bonzini 53969e0a03cSPaolo Bonzini if (hv_vmx_read_capability(HV_VMX_CAP_PINBASED, 54069e0a03cSPaolo Bonzini &hvf_state->hvf_caps->vmx_cap_pinbased)) { 54169e0a03cSPaolo Bonzini abort(); 54269e0a03cSPaolo Bonzini } 54369e0a03cSPaolo Bonzini if (hv_vmx_read_capability(HV_VMX_CAP_PROCBASED, 54469e0a03cSPaolo Bonzini &hvf_state->hvf_caps->vmx_cap_procbased)) { 54569e0a03cSPaolo Bonzini abort(); 54669e0a03cSPaolo Bonzini } 54769e0a03cSPaolo Bonzini if (hv_vmx_read_capability(HV_VMX_CAP_PROCBASED2, 54869e0a03cSPaolo Bonzini &hvf_state->hvf_caps->vmx_cap_procbased2)) { 54969e0a03cSPaolo Bonzini abort(); 55069e0a03cSPaolo Bonzini } 55169e0a03cSPaolo Bonzini if (hv_vmx_read_capability(HV_VMX_CAP_ENTRY, 55269e0a03cSPaolo Bonzini &hvf_state->hvf_caps->vmx_cap_entry)) { 55369e0a03cSPaolo Bonzini abort(); 55469e0a03cSPaolo Bonzini } 55569e0a03cSPaolo Bonzini 55669e0a03cSPaolo Bonzini /* set VMCS control fields */ 55769e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_PIN_BASED_CTLS, 55869e0a03cSPaolo Bonzini cap2ctrl(hvf_state->hvf_caps->vmx_cap_pinbased, 55969e0a03cSPaolo Bonzini VMCS_PIN_BASED_CTLS_EXTINT | 56069e0a03cSPaolo Bonzini VMCS_PIN_BASED_CTLS_NMI | 56169e0a03cSPaolo Bonzini VMCS_PIN_BASED_CTLS_VNMI)); 56269e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_PRI_PROC_BASED_CTLS, 56369e0a03cSPaolo Bonzini cap2ctrl(hvf_state->hvf_caps->vmx_cap_procbased, 56469e0a03cSPaolo Bonzini VMCS_PRI_PROC_BASED_CTLS_HLT | 56569e0a03cSPaolo Bonzini VMCS_PRI_PROC_BASED_CTLS_MWAIT | 56669e0a03cSPaolo Bonzini VMCS_PRI_PROC_BASED_CTLS_TSC_OFFSET | 56769e0a03cSPaolo Bonzini VMCS_PRI_PROC_BASED_CTLS_TPR_SHADOW) | 56869e0a03cSPaolo Bonzini VMCS_PRI_PROC_BASED_CTLS_SEC_CONTROL); 56969e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_SEC_PROC_BASED_CTLS, 57069e0a03cSPaolo Bonzini cap2ctrl(hvf_state->hvf_caps->vmx_cap_procbased2, 57169e0a03cSPaolo Bonzini VMCS_PRI_PROC_BASED2_CTLS_APIC_ACCESSES)); 57269e0a03cSPaolo Bonzini 57369e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_ENTRY_CTLS, cap2ctrl(hvf_state->hvf_caps->vmx_cap_entry, 57469e0a03cSPaolo Bonzini 0)); 57569e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_EXCEPTION_BITMAP, 0); /* Double fault */ 57669e0a03cSPaolo Bonzini 57769e0a03cSPaolo Bonzini wvmcs(cpu->hvf_fd, VMCS_TPR_THRESHOLD, 0); 57869e0a03cSPaolo Bonzini 57969e0a03cSPaolo Bonzini x86cpu = X86_CPU(cpu); 5805b8063c4SLiran Alon x86cpu->env.xsave_buf = qemu_memalign(4096, 4096); 58169e0a03cSPaolo Bonzini 58269e0a03cSPaolo Bonzini hv_vcpu_enable_native_msr(cpu->hvf_fd, MSR_STAR, 1); 58369e0a03cSPaolo Bonzini hv_vcpu_enable_native_msr(cpu->hvf_fd, MSR_LSTAR, 1); 58469e0a03cSPaolo Bonzini hv_vcpu_enable_native_msr(cpu->hvf_fd, MSR_CSTAR, 1); 58569e0a03cSPaolo Bonzini hv_vcpu_enable_native_msr(cpu->hvf_fd, MSR_FMASK, 1); 58669e0a03cSPaolo Bonzini hv_vcpu_enable_native_msr(cpu->hvf_fd, MSR_FSBASE, 1); 58769e0a03cSPaolo Bonzini hv_vcpu_enable_native_msr(cpu->hvf_fd, MSR_GSBASE, 1); 58869e0a03cSPaolo Bonzini hv_vcpu_enable_native_msr(cpu->hvf_fd, MSR_KERNELGSBASE, 1); 58969e0a03cSPaolo Bonzini hv_vcpu_enable_native_msr(cpu->hvf_fd, MSR_TSC_AUX, 1); 5909fedbbeeSCameron Esfahani hv_vcpu_enable_native_msr(cpu->hvf_fd, MSR_IA32_TSC, 1); 59169e0a03cSPaolo Bonzini hv_vcpu_enable_native_msr(cpu->hvf_fd, MSR_IA32_SYSENTER_CS, 1); 59269e0a03cSPaolo Bonzini hv_vcpu_enable_native_msr(cpu->hvf_fd, MSR_IA32_SYSENTER_EIP, 1); 59369e0a03cSPaolo Bonzini hv_vcpu_enable_native_msr(cpu->hvf_fd, MSR_IA32_SYSENTER_ESP, 1); 59469e0a03cSPaolo Bonzini 59569e0a03cSPaolo Bonzini return 0; 59669e0a03cSPaolo Bonzini } 59769e0a03cSPaolo Bonzini 59869e0a03cSPaolo Bonzini static void hvf_store_events(CPUState *cpu, uint32_t ins_len, uint64_t idtvec_info) 59969e0a03cSPaolo Bonzini { 60069e0a03cSPaolo Bonzini X86CPU *x86_cpu = X86_CPU(cpu); 60169e0a03cSPaolo Bonzini CPUX86State *env = &x86_cpu->env; 60269e0a03cSPaolo Bonzini 603fd13f23bSLiran Alon env->exception_nr = -1; 604fd13f23bSLiran Alon env->exception_pending = 0; 605fd13f23bSLiran Alon env->exception_injected = 0; 60669e0a03cSPaolo Bonzini env->interrupt_injected = -1; 60769e0a03cSPaolo Bonzini env->nmi_injected = false; 60864bef038SCameron Esfahani env->ins_len = 0; 60964bef038SCameron Esfahani env->has_error_code = false; 61069e0a03cSPaolo Bonzini if (idtvec_info & VMCS_IDT_VEC_VALID) { 61169e0a03cSPaolo Bonzini switch (idtvec_info & VMCS_IDT_VEC_TYPE) { 61269e0a03cSPaolo Bonzini case VMCS_IDT_VEC_HWINTR: 61369e0a03cSPaolo Bonzini case VMCS_IDT_VEC_SWINTR: 61469e0a03cSPaolo Bonzini env->interrupt_injected = idtvec_info & VMCS_IDT_VEC_VECNUM; 61569e0a03cSPaolo Bonzini break; 61669e0a03cSPaolo Bonzini case VMCS_IDT_VEC_NMI: 61769e0a03cSPaolo Bonzini env->nmi_injected = true; 61869e0a03cSPaolo Bonzini break; 61969e0a03cSPaolo Bonzini case VMCS_IDT_VEC_HWEXCEPTION: 62069e0a03cSPaolo Bonzini case VMCS_IDT_VEC_SWEXCEPTION: 621fd13f23bSLiran Alon env->exception_nr = idtvec_info & VMCS_IDT_VEC_VECNUM; 622fd13f23bSLiran Alon env->exception_injected = 1; 62369e0a03cSPaolo Bonzini break; 62469e0a03cSPaolo Bonzini case VMCS_IDT_VEC_PRIV_SWEXCEPTION: 62569e0a03cSPaolo Bonzini default: 62669e0a03cSPaolo Bonzini abort(); 62769e0a03cSPaolo Bonzini } 62869e0a03cSPaolo Bonzini if ((idtvec_info & VMCS_IDT_VEC_TYPE) == VMCS_IDT_VEC_SWEXCEPTION || 62969e0a03cSPaolo Bonzini (idtvec_info & VMCS_IDT_VEC_TYPE) == VMCS_IDT_VEC_SWINTR) { 63069e0a03cSPaolo Bonzini env->ins_len = ins_len; 63169e0a03cSPaolo Bonzini } 63264bef038SCameron Esfahani if (idtvec_info & VMCS_IDT_VEC_ERRCODE_VALID) { 63369e0a03cSPaolo Bonzini env->has_error_code = true; 63469e0a03cSPaolo Bonzini env->error_code = rvmcs(cpu->hvf_fd, VMCS_IDT_VECTORING_ERROR); 63569e0a03cSPaolo Bonzini } 63669e0a03cSPaolo Bonzini } 63769e0a03cSPaolo Bonzini if ((rvmcs(cpu->hvf_fd, VMCS_GUEST_INTERRUPTIBILITY) & 63869e0a03cSPaolo Bonzini VMCS_INTERRUPTIBILITY_NMI_BLOCKING)) { 63969e0a03cSPaolo Bonzini env->hflags2 |= HF2_NMI_MASK; 64069e0a03cSPaolo Bonzini } else { 64169e0a03cSPaolo Bonzini env->hflags2 &= ~HF2_NMI_MASK; 64269e0a03cSPaolo Bonzini } 64369e0a03cSPaolo Bonzini if (rvmcs(cpu->hvf_fd, VMCS_GUEST_INTERRUPTIBILITY) & 64469e0a03cSPaolo Bonzini (VMCS_INTERRUPTIBILITY_STI_BLOCKING | 64569e0a03cSPaolo Bonzini VMCS_INTERRUPTIBILITY_MOVSS_BLOCKING)) { 64669e0a03cSPaolo Bonzini env->hflags |= HF_INHIBIT_IRQ_MASK; 64769e0a03cSPaolo Bonzini } else { 64869e0a03cSPaolo Bonzini env->hflags &= ~HF_INHIBIT_IRQ_MASK; 64969e0a03cSPaolo Bonzini } 65069e0a03cSPaolo Bonzini } 65169e0a03cSPaolo Bonzini 652*3b502b0eSVladislav Yaroshchuk static void hvf_cpu_x86_cpuid(CPUX86State *env, uint32_t index, uint32_t count, 653*3b502b0eSVladislav Yaroshchuk uint32_t *eax, uint32_t *ebx, 654*3b502b0eSVladislav Yaroshchuk uint32_t *ecx, uint32_t *edx) 655*3b502b0eSVladislav Yaroshchuk { 656*3b502b0eSVladislav Yaroshchuk /* 657*3b502b0eSVladislav Yaroshchuk * A wrapper extends cpu_x86_cpuid with 0x40000000 and 0x40000010 leafs, 658*3b502b0eSVladislav Yaroshchuk * leafs 0x40000001-0x4000000F are filled with zeros 659*3b502b0eSVladislav Yaroshchuk * Provides vmware-cpuid-freq support to hvf 660*3b502b0eSVladislav Yaroshchuk * 661*3b502b0eSVladislav Yaroshchuk * Note: leaf 0x40000000 not exposes HVF, 662*3b502b0eSVladislav Yaroshchuk * leaving hypervisor signature empty 663*3b502b0eSVladislav Yaroshchuk */ 664*3b502b0eSVladislav Yaroshchuk 665*3b502b0eSVladislav Yaroshchuk if (index < 0x40000000 || index > 0x40000010 || 666*3b502b0eSVladislav Yaroshchuk !tsc_is_known(env) || !apic_bus_freq_is_known(env)) { 667*3b502b0eSVladislav Yaroshchuk 668*3b502b0eSVladislav Yaroshchuk cpu_x86_cpuid(env, index, count, eax, ebx, ecx, edx); 669*3b502b0eSVladislav Yaroshchuk return; 670*3b502b0eSVladislav Yaroshchuk } 671*3b502b0eSVladislav Yaroshchuk 672*3b502b0eSVladislav Yaroshchuk switch (index) { 673*3b502b0eSVladislav Yaroshchuk case 0x40000000: 674*3b502b0eSVladislav Yaroshchuk *eax = 0x40000010; /* Max available cpuid leaf */ 675*3b502b0eSVladislav Yaroshchuk *ebx = 0; /* Leave signature empty */ 676*3b502b0eSVladislav Yaroshchuk *ecx = 0; 677*3b502b0eSVladislav Yaroshchuk *edx = 0; 678*3b502b0eSVladislav Yaroshchuk break; 679*3b502b0eSVladislav Yaroshchuk case 0x40000010: 680*3b502b0eSVladislav Yaroshchuk *eax = env->tsc_khz; 681*3b502b0eSVladislav Yaroshchuk *ebx = env->apic_bus_freq / 1000; /* Hz to KHz */ 682*3b502b0eSVladislav Yaroshchuk *ecx = 0; 683*3b502b0eSVladislav Yaroshchuk *edx = 0; 684*3b502b0eSVladislav Yaroshchuk break; 685*3b502b0eSVladislav Yaroshchuk default: 686*3b502b0eSVladislav Yaroshchuk *eax = 0; 687*3b502b0eSVladislav Yaroshchuk *ebx = 0; 688*3b502b0eSVladislav Yaroshchuk *ecx = 0; 689*3b502b0eSVladislav Yaroshchuk *edx = 0; 690*3b502b0eSVladislav Yaroshchuk break; 691*3b502b0eSVladislav Yaroshchuk } 692*3b502b0eSVladislav Yaroshchuk } 693*3b502b0eSVladislav Yaroshchuk 69469e0a03cSPaolo Bonzini int hvf_vcpu_exec(CPUState *cpu) 69569e0a03cSPaolo Bonzini { 69669e0a03cSPaolo Bonzini X86CPU *x86_cpu = X86_CPU(cpu); 69769e0a03cSPaolo Bonzini CPUX86State *env = &x86_cpu->env; 69869e0a03cSPaolo Bonzini int ret = 0; 69969e0a03cSPaolo Bonzini uint64_t rip = 0; 70069e0a03cSPaolo Bonzini 70169e0a03cSPaolo Bonzini if (hvf_process_events(cpu)) { 70269e0a03cSPaolo Bonzini return EXCP_HLT; 70369e0a03cSPaolo Bonzini } 70469e0a03cSPaolo Bonzini 70569e0a03cSPaolo Bonzini do { 70669e0a03cSPaolo Bonzini if (cpu->vcpu_dirty) { 70769e0a03cSPaolo Bonzini hvf_put_registers(cpu); 70869e0a03cSPaolo Bonzini cpu->vcpu_dirty = false; 70969e0a03cSPaolo Bonzini } 71069e0a03cSPaolo Bonzini 71169e0a03cSPaolo Bonzini if (hvf_inject_interrupts(cpu)) { 71269e0a03cSPaolo Bonzini return EXCP_INTERRUPT; 71369e0a03cSPaolo Bonzini } 71469e0a03cSPaolo Bonzini vmx_update_tpr(cpu); 71569e0a03cSPaolo Bonzini 71669e0a03cSPaolo Bonzini qemu_mutex_unlock_iothread(); 71769e0a03cSPaolo Bonzini if (!cpu_is_bsp(X86_CPU(cpu)) && cpu->halted) { 71869e0a03cSPaolo Bonzini qemu_mutex_lock_iothread(); 71969e0a03cSPaolo Bonzini return EXCP_HLT; 72069e0a03cSPaolo Bonzini } 72169e0a03cSPaolo Bonzini 72269e0a03cSPaolo Bonzini hv_return_t r = hv_vcpu_run(cpu->hvf_fd); 72369e0a03cSPaolo Bonzini assert_hvf_ok(r); 72469e0a03cSPaolo Bonzini 72569e0a03cSPaolo Bonzini /* handle VMEXIT */ 72669e0a03cSPaolo Bonzini uint64_t exit_reason = rvmcs(cpu->hvf_fd, VMCS_EXIT_REASON); 72769e0a03cSPaolo Bonzini uint64_t exit_qual = rvmcs(cpu->hvf_fd, VMCS_EXIT_QUALIFICATION); 72869e0a03cSPaolo Bonzini uint32_t ins_len = (uint32_t)rvmcs(cpu->hvf_fd, 72969e0a03cSPaolo Bonzini VMCS_EXIT_INSTRUCTION_LENGTH); 73069e0a03cSPaolo Bonzini 73169e0a03cSPaolo Bonzini uint64_t idtvec_info = rvmcs(cpu->hvf_fd, VMCS_IDT_VECTORING_INFO); 73269e0a03cSPaolo Bonzini 73369e0a03cSPaolo Bonzini hvf_store_events(cpu, ins_len, idtvec_info); 73469e0a03cSPaolo Bonzini rip = rreg(cpu->hvf_fd, HV_X86_RIP); 735967f4da2SRoman Bolshakov env->eflags = rreg(cpu->hvf_fd, HV_X86_RFLAGS); 73669e0a03cSPaolo Bonzini 73769e0a03cSPaolo Bonzini qemu_mutex_lock_iothread(); 73869e0a03cSPaolo Bonzini 73969e0a03cSPaolo Bonzini update_apic_tpr(cpu); 74069e0a03cSPaolo Bonzini current_cpu = cpu; 74169e0a03cSPaolo Bonzini 74269e0a03cSPaolo Bonzini ret = 0; 74369e0a03cSPaolo Bonzini switch (exit_reason) { 74469e0a03cSPaolo Bonzini case EXIT_REASON_HLT: { 74569e0a03cSPaolo Bonzini macvm_set_rip(cpu, rip + ins_len); 74669e0a03cSPaolo Bonzini if (!((cpu->interrupt_request & CPU_INTERRUPT_HARD) && 747967f4da2SRoman Bolshakov (env->eflags & IF_MASK)) 74869e0a03cSPaolo Bonzini && !(cpu->interrupt_request & CPU_INTERRUPT_NMI) && 74969e0a03cSPaolo Bonzini !(idtvec_info & VMCS_IDT_VEC_VALID)) { 75069e0a03cSPaolo Bonzini cpu->halted = 1; 75169e0a03cSPaolo Bonzini ret = EXCP_HLT; 7523b9c59daSChen Zhang break; 75369e0a03cSPaolo Bonzini } 75469e0a03cSPaolo Bonzini ret = EXCP_INTERRUPT; 75569e0a03cSPaolo Bonzini break; 75669e0a03cSPaolo Bonzini } 75769e0a03cSPaolo Bonzini case EXIT_REASON_MWAIT: { 75869e0a03cSPaolo Bonzini ret = EXCP_INTERRUPT; 75969e0a03cSPaolo Bonzini break; 76069e0a03cSPaolo Bonzini } 761fbafbb6dSCameron Esfahani /* Need to check if MMIO or unmapped fault */ 76269e0a03cSPaolo Bonzini case EXIT_REASON_EPT_FAULT: 76369e0a03cSPaolo Bonzini { 76469e0a03cSPaolo Bonzini hvf_slot *slot; 765ff2de166SPaolo Bonzini uint64_t gpa = rvmcs(cpu->hvf_fd, VMCS_GUEST_PHYSICAL_ADDRESS); 76669e0a03cSPaolo Bonzini 76769e0a03cSPaolo Bonzini if (((idtvec_info & VMCS_IDT_VEC_VALID) == 0) && 76869e0a03cSPaolo Bonzini ((exit_qual & EXIT_QUAL_NMIUDTI) != 0)) { 76969e0a03cSPaolo Bonzini vmx_set_nmi_blocking(cpu); 77069e0a03cSPaolo Bonzini } 77169e0a03cSPaolo Bonzini 772fbafbb6dSCameron Esfahani slot = hvf_find_overlap_slot(gpa, 1); 77369e0a03cSPaolo Bonzini /* mmio */ 77469e0a03cSPaolo Bonzini if (ept_emulation_fault(slot, gpa, exit_qual)) { 77569e0a03cSPaolo Bonzini struct x86_decode decode; 77669e0a03cSPaolo Bonzini 77769e0a03cSPaolo Bonzini load_regs(cpu); 77869e0a03cSPaolo Bonzini decode_instruction(env, &decode); 77969e0a03cSPaolo Bonzini exec_instruction(env, &decode); 78069e0a03cSPaolo Bonzini store_regs(cpu); 78169e0a03cSPaolo Bonzini break; 78269e0a03cSPaolo Bonzini } 78369e0a03cSPaolo Bonzini break; 78469e0a03cSPaolo Bonzini } 78569e0a03cSPaolo Bonzini case EXIT_REASON_INOUT: 78669e0a03cSPaolo Bonzini { 78769e0a03cSPaolo Bonzini uint32_t in = (exit_qual & 8) != 0; 78869e0a03cSPaolo Bonzini uint32_t size = (exit_qual & 7) + 1; 78969e0a03cSPaolo Bonzini uint32_t string = (exit_qual & 16) != 0; 79069e0a03cSPaolo Bonzini uint32_t port = exit_qual >> 16; 79169e0a03cSPaolo Bonzini /*uint32_t rep = (exit_qual & 0x20) != 0;*/ 79269e0a03cSPaolo Bonzini 79369e0a03cSPaolo Bonzini if (!string && in) { 79469e0a03cSPaolo Bonzini uint64_t val = 0; 79569e0a03cSPaolo Bonzini load_regs(cpu); 79669e0a03cSPaolo Bonzini hvf_handle_io(env, port, &val, 0, size, 1); 79769e0a03cSPaolo Bonzini if (size == 1) { 79869e0a03cSPaolo Bonzini AL(env) = val; 79969e0a03cSPaolo Bonzini } else if (size == 2) { 80069e0a03cSPaolo Bonzini AX(env) = val; 80169e0a03cSPaolo Bonzini } else if (size == 4) { 80269e0a03cSPaolo Bonzini RAX(env) = (uint32_t)val; 80369e0a03cSPaolo Bonzini } else { 804da20f5cdSPaolo Bonzini RAX(env) = (uint64_t)val; 80569e0a03cSPaolo Bonzini } 8065d32173fSRoman Bolshakov env->eip += ins_len; 80769e0a03cSPaolo Bonzini store_regs(cpu); 80869e0a03cSPaolo Bonzini break; 80969e0a03cSPaolo Bonzini } else if (!string && !in) { 81069e0a03cSPaolo Bonzini RAX(env) = rreg(cpu->hvf_fd, HV_X86_RAX); 81169e0a03cSPaolo Bonzini hvf_handle_io(env, port, &RAX(env), 1, size, 1); 81269e0a03cSPaolo Bonzini macvm_set_rip(cpu, rip + ins_len); 81369e0a03cSPaolo Bonzini break; 81469e0a03cSPaolo Bonzini } 81569e0a03cSPaolo Bonzini struct x86_decode decode; 81669e0a03cSPaolo Bonzini 81769e0a03cSPaolo Bonzini load_regs(cpu); 81869e0a03cSPaolo Bonzini decode_instruction(env, &decode); 819e62963bfSPaolo Bonzini assert(ins_len == decode.len); 82069e0a03cSPaolo Bonzini exec_instruction(env, &decode); 82169e0a03cSPaolo Bonzini store_regs(cpu); 82269e0a03cSPaolo Bonzini 82369e0a03cSPaolo Bonzini break; 82469e0a03cSPaolo Bonzini } 82569e0a03cSPaolo Bonzini case EXIT_REASON_CPUID: { 82669e0a03cSPaolo Bonzini uint32_t rax = (uint32_t)rreg(cpu->hvf_fd, HV_X86_RAX); 82769e0a03cSPaolo Bonzini uint32_t rbx = (uint32_t)rreg(cpu->hvf_fd, HV_X86_RBX); 82869e0a03cSPaolo Bonzini uint32_t rcx = (uint32_t)rreg(cpu->hvf_fd, HV_X86_RCX); 82969e0a03cSPaolo Bonzini uint32_t rdx = (uint32_t)rreg(cpu->hvf_fd, HV_X86_RDX); 83069e0a03cSPaolo Bonzini 831*3b502b0eSVladislav Yaroshchuk hvf_cpu_x86_cpuid(env, rax, rcx, &rax, &rbx, &rcx, &rdx); 83269e0a03cSPaolo Bonzini 83369e0a03cSPaolo Bonzini wreg(cpu->hvf_fd, HV_X86_RAX, rax); 83469e0a03cSPaolo Bonzini wreg(cpu->hvf_fd, HV_X86_RBX, rbx); 83569e0a03cSPaolo Bonzini wreg(cpu->hvf_fd, HV_X86_RCX, rcx); 83669e0a03cSPaolo Bonzini wreg(cpu->hvf_fd, HV_X86_RDX, rdx); 83769e0a03cSPaolo Bonzini 83869e0a03cSPaolo Bonzini macvm_set_rip(cpu, rip + ins_len); 83969e0a03cSPaolo Bonzini break; 84069e0a03cSPaolo Bonzini } 84169e0a03cSPaolo Bonzini case EXIT_REASON_XSETBV: { 84269e0a03cSPaolo Bonzini X86CPU *x86_cpu = X86_CPU(cpu); 84369e0a03cSPaolo Bonzini CPUX86State *env = &x86_cpu->env; 84469e0a03cSPaolo Bonzini uint32_t eax = (uint32_t)rreg(cpu->hvf_fd, HV_X86_RAX); 84569e0a03cSPaolo Bonzini uint32_t ecx = (uint32_t)rreg(cpu->hvf_fd, HV_X86_RCX); 84669e0a03cSPaolo Bonzini uint32_t edx = (uint32_t)rreg(cpu->hvf_fd, HV_X86_RDX); 84769e0a03cSPaolo Bonzini 84869e0a03cSPaolo Bonzini if (ecx) { 84969e0a03cSPaolo Bonzini macvm_set_rip(cpu, rip + ins_len); 85069e0a03cSPaolo Bonzini break; 85169e0a03cSPaolo Bonzini } 85269e0a03cSPaolo Bonzini env->xcr0 = ((uint64_t)edx << 32) | eax; 85369e0a03cSPaolo Bonzini wreg(cpu->hvf_fd, HV_X86_XCR0, env->xcr0 | 1); 85469e0a03cSPaolo Bonzini macvm_set_rip(cpu, rip + ins_len); 85569e0a03cSPaolo Bonzini break; 85669e0a03cSPaolo Bonzini } 85769e0a03cSPaolo Bonzini case EXIT_REASON_INTR_WINDOW: 85869e0a03cSPaolo Bonzini vmx_clear_int_window_exiting(cpu); 85969e0a03cSPaolo Bonzini ret = EXCP_INTERRUPT; 86069e0a03cSPaolo Bonzini break; 86169e0a03cSPaolo Bonzini case EXIT_REASON_NMI_WINDOW: 86269e0a03cSPaolo Bonzini vmx_clear_nmi_window_exiting(cpu); 86369e0a03cSPaolo Bonzini ret = EXCP_INTERRUPT; 86469e0a03cSPaolo Bonzini break; 86569e0a03cSPaolo Bonzini case EXIT_REASON_EXT_INTR: 86669e0a03cSPaolo Bonzini /* force exit and allow io handling */ 86769e0a03cSPaolo Bonzini ret = EXCP_INTERRUPT; 86869e0a03cSPaolo Bonzini break; 86969e0a03cSPaolo Bonzini case EXIT_REASON_RDMSR: 87069e0a03cSPaolo Bonzini case EXIT_REASON_WRMSR: 87169e0a03cSPaolo Bonzini { 87269e0a03cSPaolo Bonzini load_regs(cpu); 87369e0a03cSPaolo Bonzini if (exit_reason == EXIT_REASON_RDMSR) { 87469e0a03cSPaolo Bonzini simulate_rdmsr(cpu); 87569e0a03cSPaolo Bonzini } else { 87669e0a03cSPaolo Bonzini simulate_wrmsr(cpu); 87769e0a03cSPaolo Bonzini } 8785d32173fSRoman Bolshakov env->eip += ins_len; 87969e0a03cSPaolo Bonzini store_regs(cpu); 88069e0a03cSPaolo Bonzini break; 88169e0a03cSPaolo Bonzini } 88269e0a03cSPaolo Bonzini case EXIT_REASON_CR_ACCESS: { 88369e0a03cSPaolo Bonzini int cr; 88469e0a03cSPaolo Bonzini int reg; 88569e0a03cSPaolo Bonzini 88669e0a03cSPaolo Bonzini load_regs(cpu); 88769e0a03cSPaolo Bonzini cr = exit_qual & 15; 88869e0a03cSPaolo Bonzini reg = (exit_qual >> 8) & 15; 88969e0a03cSPaolo Bonzini 89069e0a03cSPaolo Bonzini switch (cr) { 89169e0a03cSPaolo Bonzini case 0x0: { 89269e0a03cSPaolo Bonzini macvm_set_cr0(cpu->hvf_fd, RRX(env, reg)); 89369e0a03cSPaolo Bonzini break; 89469e0a03cSPaolo Bonzini } 89569e0a03cSPaolo Bonzini case 4: { 89669e0a03cSPaolo Bonzini macvm_set_cr4(cpu->hvf_fd, RRX(env, reg)); 89769e0a03cSPaolo Bonzini break; 89869e0a03cSPaolo Bonzini } 89969e0a03cSPaolo Bonzini case 8: { 90069e0a03cSPaolo Bonzini X86CPU *x86_cpu = X86_CPU(cpu); 90169e0a03cSPaolo Bonzini if (exit_qual & 0x10) { 90269e0a03cSPaolo Bonzini RRX(env, reg) = cpu_get_apic_tpr(x86_cpu->apic_state); 90369e0a03cSPaolo Bonzini } else { 90469e0a03cSPaolo Bonzini int tpr = RRX(env, reg); 90569e0a03cSPaolo Bonzini cpu_set_apic_tpr(x86_cpu->apic_state, tpr); 90669e0a03cSPaolo Bonzini ret = EXCP_INTERRUPT; 90769e0a03cSPaolo Bonzini } 90869e0a03cSPaolo Bonzini break; 90969e0a03cSPaolo Bonzini } 91069e0a03cSPaolo Bonzini default: 9112d9178d9SLaurent Vivier error_report("Unrecognized CR %d", cr); 91269e0a03cSPaolo Bonzini abort(); 91369e0a03cSPaolo Bonzini } 9145d32173fSRoman Bolshakov env->eip += ins_len; 91569e0a03cSPaolo Bonzini store_regs(cpu); 91669e0a03cSPaolo Bonzini break; 91769e0a03cSPaolo Bonzini } 91869e0a03cSPaolo Bonzini case EXIT_REASON_APIC_ACCESS: { /* TODO */ 91969e0a03cSPaolo Bonzini struct x86_decode decode; 92069e0a03cSPaolo Bonzini 92169e0a03cSPaolo Bonzini load_regs(cpu); 92269e0a03cSPaolo Bonzini decode_instruction(env, &decode); 92369e0a03cSPaolo Bonzini exec_instruction(env, &decode); 92469e0a03cSPaolo Bonzini store_regs(cpu); 92569e0a03cSPaolo Bonzini break; 92669e0a03cSPaolo Bonzini } 92769e0a03cSPaolo Bonzini case EXIT_REASON_TPR: { 92869e0a03cSPaolo Bonzini ret = 1; 92969e0a03cSPaolo Bonzini break; 93069e0a03cSPaolo Bonzini } 93169e0a03cSPaolo Bonzini case EXIT_REASON_TASK_SWITCH: { 93269e0a03cSPaolo Bonzini uint64_t vinfo = rvmcs(cpu->hvf_fd, VMCS_IDT_VECTORING_INFO); 93369e0a03cSPaolo Bonzini x68_segment_selector sel = {.sel = exit_qual & 0xffff}; 93469e0a03cSPaolo Bonzini vmx_handle_task_switch(cpu, sel, (exit_qual >> 30) & 0x3, 93569e0a03cSPaolo Bonzini vinfo & VMCS_INTR_VALID, vinfo & VECTORING_INFO_VECTOR_MASK, vinfo 93669e0a03cSPaolo Bonzini & VMCS_INTR_T_MASK); 93769e0a03cSPaolo Bonzini break; 93869e0a03cSPaolo Bonzini } 93969e0a03cSPaolo Bonzini case EXIT_REASON_TRIPLE_FAULT: { 94069e0a03cSPaolo Bonzini qemu_system_reset_request(SHUTDOWN_CAUSE_GUEST_RESET); 94169e0a03cSPaolo Bonzini ret = EXCP_INTERRUPT; 94269e0a03cSPaolo Bonzini break; 94369e0a03cSPaolo Bonzini } 94469e0a03cSPaolo Bonzini case EXIT_REASON_RDPMC: 94569e0a03cSPaolo Bonzini wreg(cpu->hvf_fd, HV_X86_RAX, 0); 94669e0a03cSPaolo Bonzini wreg(cpu->hvf_fd, HV_X86_RDX, 0); 94769e0a03cSPaolo Bonzini macvm_set_rip(cpu, rip + ins_len); 94869e0a03cSPaolo Bonzini break; 94969e0a03cSPaolo Bonzini case VMX_REASON_VMCALL: 950fd13f23bSLiran Alon env->exception_nr = EXCP0D_GPF; 951fd13f23bSLiran Alon env->exception_injected = 1; 95269e0a03cSPaolo Bonzini env->has_error_code = true; 95369e0a03cSPaolo Bonzini env->error_code = 0; 95469e0a03cSPaolo Bonzini break; 95569e0a03cSPaolo Bonzini default: 9562d9178d9SLaurent Vivier error_report("%llx: unhandled exit %llx", rip, exit_reason); 95769e0a03cSPaolo Bonzini } 95869e0a03cSPaolo Bonzini } while (ret == 0); 95969e0a03cSPaolo Bonzini 96069e0a03cSPaolo Bonzini return ret; 96169e0a03cSPaolo Bonzini } 96269e0a03cSPaolo Bonzini 96392cc3aaaSRoman Bolshakov bool hvf_allowed; 96469e0a03cSPaolo Bonzini 96569e0a03cSPaolo Bonzini static int hvf_accel_init(MachineState *ms) 96669e0a03cSPaolo Bonzini { 96769e0a03cSPaolo Bonzini int x; 96869e0a03cSPaolo Bonzini hv_return_t ret; 96969e0a03cSPaolo Bonzini HVFState *s; 97069e0a03cSPaolo Bonzini 97169e0a03cSPaolo Bonzini ret = hv_vm_create(HV_VM_DEFAULT); 97269e0a03cSPaolo Bonzini assert_hvf_ok(ret); 97369e0a03cSPaolo Bonzini 97469e0a03cSPaolo Bonzini s = g_new0(HVFState, 1); 97569e0a03cSPaolo Bonzini 97669e0a03cSPaolo Bonzini s->num_slots = 32; 97769e0a03cSPaolo Bonzini for (x = 0; x < s->num_slots; ++x) { 97869e0a03cSPaolo Bonzini s->slots[x].size = 0; 97969e0a03cSPaolo Bonzini s->slots[x].slot_id = x; 98069e0a03cSPaolo Bonzini } 98169e0a03cSPaolo Bonzini 98269e0a03cSPaolo Bonzini hvf_state = s; 98369e0a03cSPaolo Bonzini memory_listener_register(&hvf_memory_listener, &address_space_memory); 98469e0a03cSPaolo Bonzini return 0; 98569e0a03cSPaolo Bonzini } 98669e0a03cSPaolo Bonzini 98769e0a03cSPaolo Bonzini static void hvf_accel_class_init(ObjectClass *oc, void *data) 98869e0a03cSPaolo Bonzini { 98969e0a03cSPaolo Bonzini AccelClass *ac = ACCEL_CLASS(oc); 99069e0a03cSPaolo Bonzini ac->name = "HVF"; 99169e0a03cSPaolo Bonzini ac->init_machine = hvf_accel_init; 99269e0a03cSPaolo Bonzini ac->allowed = &hvf_allowed; 99369e0a03cSPaolo Bonzini } 99469e0a03cSPaolo Bonzini 99569e0a03cSPaolo Bonzini static const TypeInfo hvf_accel_type = { 99669e0a03cSPaolo Bonzini .name = TYPE_HVF_ACCEL, 99769e0a03cSPaolo Bonzini .parent = TYPE_ACCEL, 99869e0a03cSPaolo Bonzini .class_init = hvf_accel_class_init, 99969e0a03cSPaolo Bonzini }; 100069e0a03cSPaolo Bonzini 100169e0a03cSPaolo Bonzini static void hvf_type_init(void) 100269e0a03cSPaolo Bonzini { 100369e0a03cSPaolo Bonzini type_register_static(&hvf_accel_type); 100469e0a03cSPaolo Bonzini } 100569e0a03cSPaolo Bonzini 100669e0a03cSPaolo Bonzini type_init(hvf_type_init); 1007