2008-11-05 17:29:27 +01:00
|
|
|
/*
|
|
|
|
* QEMU KVM support
|
|
|
|
*
|
|
|
|
* Copyright IBM, Corp. 2008
|
|
|
|
*
|
|
|
|
* Authors:
|
|
|
|
* Anthony Liguori <aliguori@us.ibm.com>
|
|
|
|
*
|
|
|
|
* This work is licensed under the terms of the GNU GPL, version 2 or later.
|
|
|
|
* See the COPYING file in the top-level directory.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef QEMU_KVM_H
|
|
|
|
#define QEMU_KVM_H
|
|
|
|
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/queue.h"
|
2012-12-17 06:38:45 +01:00
|
|
|
#include "qom/cpu.h"
|
2015-04-08 13:30:58 +02:00
|
|
|
#include "exec/memattrs.h"
|
2015-07-06 20:15:13 +02:00
|
|
|
#include "hw/irq.h"
|
2008-11-05 17:29:27 +01:00
|
|
|
|
2010-03-17 12:07:54 +01:00
|
|
|
#ifdef CONFIG_KVM
|
|
|
|
#include <linux/kvm.h>
|
i386: kvm: filter CPUID feature words earlier, on cpu.c
cpu.c contains the code that will check if all requested CPU features
are available, so the filtering of KVM features must be there, so we can
implement "check" and "enforce" properly.
The only point where kvm_arch_init_vcpu() is called on i386 is:
- cpu_x86_init()
- x86_cpu_realize() (after cpu_x86_register() is called)
- qemu_init_vcpu()
- qemu_kvm_start_vcpu()
- qemu_kvm_thread_fn() (on a new thread)
- kvm_init_vcpu()
- kvm_arch_init_vcpu()
With this patch, the filtering will be done earlier, at:
- cpu_x86_init()
- cpu_x86_register() (before x86_cpu_realize() is called)
Also, the KVM CPUID filtering will now be done at the same place where
the TCG CPUID feature filtering is done. Later, the code can be changed
to use the same filtering code for the "check" and "enforce" modes, as
now the cpu.c code knows exactly which CPU features are going to be
exposed to the guest (and much earlier).
One thing I was worrying about when doing this is that
kvm_arch_get_supported_cpuid() depends on kvm_irqchip_in_kernel(), and
maybe the 'kvm_kernel_irqchip' global variable wasn't initialized yet at
CPU creation time. But kvm_kernel_irqchip is initialized during
kvm_init(), that is called very early (much earlier than the machine
init function), and kvm_init() is already a requirement to run the
GET_SUPPORTED_CPUID ioctl() (as kvm_init() initializes the kvm_state
global variable).
Side note: it would be nice to keep KVM-specific code inside kvm.c. The
problem is that properly implementing -cpu check/enforce code (that's
inside cpu.c) depends directly on the feature bit filtering done using
kvm_arch_get_supported_cpuid(). Currently -cpu check/enforce is broken
because it simply uses the host CPU feature bits instead of
GET_SUPPORTED_CPUID, and we need to fix that.
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
Signed-off-by: Marcelo Tosatti <mtosatti@redhat.com>
2012-10-04 22:49:05 +02:00
|
|
|
#include <linux/kvm_para.h>
|
2013-01-07 19:20:42 +01:00
|
|
|
#else
|
|
|
|
/* These constants must never be used at runtime if kvm_enabled() is false.
|
|
|
|
* They exist so we don't need #ifdefs around KVM-specific code that already
|
|
|
|
* checks kvm_enabled() properly.
|
|
|
|
*/
|
|
|
|
#define KVM_CPUID_SIGNATURE 0
|
|
|
|
#define KVM_CPUID_FEATURES 0
|
|
|
|
#define KVM_FEATURE_CLOCKSOURCE 0
|
|
|
|
#define KVM_FEATURE_NOP_IO_DELAY 0
|
|
|
|
#define KVM_FEATURE_MMU_OP 0
|
|
|
|
#define KVM_FEATURE_CLOCKSOURCE2 0
|
|
|
|
#define KVM_FEATURE_ASYNC_PF 0
|
|
|
|
#define KVM_FEATURE_STEAL_TIME 0
|
|
|
|
#define KVM_FEATURE_PV_EOI 0
|
2013-01-17 21:59:27 +01:00
|
|
|
#define KVM_FEATURE_CLOCKSOURCE_STABLE_BIT 0
|
2010-03-17 12:07:54 +01:00
|
|
|
#endif
|
2008-11-05 17:29:27 +01:00
|
|
|
|
2013-01-24 06:03:27 +01:00
|
|
|
extern bool kvm_allowed;
|
2012-01-31 19:17:52 +01:00
|
|
|
extern bool kvm_kernel_irqchip;
|
2015-11-16 19:03:06 +01:00
|
|
|
extern bool kvm_split_irqchip;
|
2012-07-26 16:35:11 +02:00
|
|
|
extern bool kvm_async_interrupts_allowed;
|
2013-04-24 22:24:12 +02:00
|
|
|
extern bool kvm_halt_in_kernel_allowed;
|
2014-05-27 14:03:35 +02:00
|
|
|
extern bool kvm_eventfds_allowed;
|
2012-07-26 16:35:14 +02:00
|
|
|
extern bool kvm_irqfds_allowed;
|
2014-10-31 14:38:18 +01:00
|
|
|
extern bool kvm_resamplefds_allowed;
|
2012-07-26 16:35:15 +02:00
|
|
|
extern bool kvm_msi_via_irqfd_allowed;
|
2012-07-26 16:35:16 +02:00
|
|
|
extern bool kvm_gsi_routing_allowed;
|
2013-09-03 10:08:25 +02:00
|
|
|
extern bool kvm_gsi_direct_mapping;
|
2013-05-29 10:27:25 +02:00
|
|
|
extern bool kvm_readonly_mem_allowed;
|
2015-10-15 15:44:50 +02:00
|
|
|
extern bool kvm_direct_msi_allowed;
|
2015-11-06 09:02:46 +01:00
|
|
|
extern bool kvm_ioeventfd_any_length_allowed;
|
2016-10-04 14:28:09 +02:00
|
|
|
extern bool kvm_msi_use_devid;
|
2010-04-19 20:59:30 +02:00
|
|
|
|
|
|
|
#if defined CONFIG_KVM || !defined NEED_CPU_H
|
2012-01-31 19:17:52 +01:00
|
|
|
#define kvm_enabled() (kvm_allowed)
|
2012-07-26 16:35:17 +02:00
|
|
|
/**
|
|
|
|
* kvm_irqchip_in_kernel:
|
|
|
|
*
|
|
|
|
* Returns: true if the user asked us to create an in-kernel
|
|
|
|
* irqchip via the "kernel_irqchip=on" machine option.
|
|
|
|
* What this actually means is architecture and machine model
|
|
|
|
* specific: on PC, for instance, it means that the LAPIC,
|
|
|
|
* IOAPIC and PIT are all in kernel. This function should never
|
|
|
|
* be used from generic target-independent code: use one of the
|
|
|
|
* following functions or some other specific check instead.
|
|
|
|
*/
|
2012-01-31 19:17:52 +01:00
|
|
|
#define kvm_irqchip_in_kernel() (kvm_kernel_irqchip)
|
2012-07-26 16:35:11 +02:00
|
|
|
|
2015-11-16 19:03:06 +01:00
|
|
|
/**
|
|
|
|
* kvm_irqchip_is_split:
|
|
|
|
*
|
|
|
|
* Returns: true if the user asked us to split the irqchip
|
|
|
|
* implementation between user and kernel space. The details are
|
|
|
|
* architecture and machine specific. On PC, it means that the PIC,
|
|
|
|
* IOAPIC, and PIT are in user space while the LAPIC is in the kernel.
|
|
|
|
*/
|
|
|
|
#define kvm_irqchip_is_split() (kvm_split_irqchip)
|
|
|
|
|
2012-07-26 16:35:11 +02:00
|
|
|
/**
|
|
|
|
* kvm_async_interrupts_enabled:
|
|
|
|
*
|
|
|
|
* Returns: true if we can deliver interrupts to KVM
|
|
|
|
* asynchronously (ie by ioctl from any thread at any time)
|
|
|
|
* rather than having to do interrupt delivery synchronously
|
|
|
|
* (where the vcpu must be stopped at a suitable point first).
|
|
|
|
*/
|
|
|
|
#define kvm_async_interrupts_enabled() (kvm_async_interrupts_allowed)
|
|
|
|
|
2013-04-24 22:24:12 +02:00
|
|
|
/**
|
|
|
|
* kvm_halt_in_kernel
|
|
|
|
*
|
|
|
|
* Returns: true if halted cpus should still get a KVM_RUN ioctl to run
|
|
|
|
* inside of kernel space. This only works if MP state is implemented.
|
|
|
|
*/
|
|
|
|
#define kvm_halt_in_kernel() (kvm_halt_in_kernel_allowed)
|
|
|
|
|
2014-05-27 14:03:35 +02:00
|
|
|
/**
|
|
|
|
* kvm_eventfds_enabled:
|
|
|
|
*
|
|
|
|
* Returns: true if we can use eventfds to receive notifications
|
|
|
|
* from a KVM CPU (ie the kernel supports eventds and we are running
|
|
|
|
* with a configuration where it is meaningful to use them).
|
|
|
|
*/
|
|
|
|
#define kvm_eventfds_enabled() (kvm_eventfds_allowed)
|
|
|
|
|
2012-07-26 16:35:14 +02:00
|
|
|
/**
|
|
|
|
* kvm_irqfds_enabled:
|
|
|
|
*
|
|
|
|
* Returns: true if we can use irqfds to inject interrupts into
|
|
|
|
* a KVM CPU (ie the kernel supports irqfds and we are running
|
|
|
|
* with a configuration where it is meaningful to use them).
|
|
|
|
*/
|
|
|
|
#define kvm_irqfds_enabled() (kvm_irqfds_allowed)
|
|
|
|
|
2014-10-31 14:38:18 +01:00
|
|
|
/**
|
|
|
|
* kvm_resamplefds_enabled:
|
|
|
|
*
|
|
|
|
* Returns: true if we can use resamplefds to inject interrupts into
|
|
|
|
* a KVM CPU (ie the kernel supports resamplefds and we are running
|
|
|
|
* with a configuration where it is meaningful to use them).
|
|
|
|
*/
|
|
|
|
#define kvm_resamplefds_enabled() (kvm_resamplefds_allowed)
|
|
|
|
|
2012-07-26 16:35:15 +02:00
|
|
|
/**
|
|
|
|
* kvm_msi_via_irqfd_enabled:
|
|
|
|
*
|
|
|
|
* Returns: true if we can route a PCI MSI (Message Signaled Interrupt)
|
|
|
|
* to a KVM CPU via an irqfd. This requires that the kernel supports
|
|
|
|
* this and that we're running in a configuration that permits it.
|
|
|
|
*/
|
|
|
|
#define kvm_msi_via_irqfd_enabled() (kvm_msi_via_irqfd_allowed)
|
|
|
|
|
2012-07-26 16:35:16 +02:00
|
|
|
/**
|
|
|
|
* kvm_gsi_routing_enabled:
|
|
|
|
*
|
|
|
|
* Returns: true if GSI routing is enabled (ie the kernel supports
|
|
|
|
* it and we're running in a configuration that permits it).
|
|
|
|
*/
|
|
|
|
#define kvm_gsi_routing_enabled() (kvm_gsi_routing_allowed)
|
|
|
|
|
2013-09-03 10:08:25 +02:00
|
|
|
/**
|
|
|
|
* kvm_gsi_direct_mapping:
|
|
|
|
*
|
|
|
|
* Returns: true if GSI direct mapping is enabled.
|
|
|
|
*/
|
|
|
|
#define kvm_gsi_direct_mapping() (kvm_gsi_direct_mapping)
|
|
|
|
|
2013-05-29 10:27:25 +02:00
|
|
|
/**
|
|
|
|
* kvm_readonly_mem_enabled:
|
|
|
|
*
|
|
|
|
* Returns: true if KVM readonly memory is enabled (ie the kernel
|
|
|
|
* supports it and we're running in a configuration that permits it).
|
|
|
|
*/
|
|
|
|
#define kvm_readonly_mem_enabled() (kvm_readonly_mem_allowed)
|
|
|
|
|
2015-10-15 15:44:50 +02:00
|
|
|
/**
|
|
|
|
* kvm_direct_msi_enabled:
|
|
|
|
*
|
|
|
|
* Returns: true if KVM allows direct MSI injection.
|
|
|
|
*/
|
|
|
|
#define kvm_direct_msi_enabled() (kvm_direct_msi_allowed)
|
|
|
|
|
2015-11-06 09:02:46 +01:00
|
|
|
/**
|
|
|
|
* kvm_ioeventfd_any_length_enabled:
|
|
|
|
* Returns: true if KVM allows any length io eventfd.
|
|
|
|
*/
|
|
|
|
#define kvm_ioeventfd_any_length_enabled() (kvm_ioeventfd_any_length_allowed)
|
|
|
|
|
2016-10-04 14:28:09 +02:00
|
|
|
/**
|
|
|
|
* kvm_msi_devid_required:
|
|
|
|
* Returns: true if KVM requires a device id to be provided while
|
|
|
|
* defining an MSI routing entry.
|
|
|
|
*/
|
|
|
|
#define kvm_msi_devid_required() (kvm_msi_use_devid)
|
|
|
|
|
2008-11-05 17:29:27 +01:00
|
|
|
#else
|
2012-01-31 19:17:52 +01:00
|
|
|
#define kvm_enabled() (0)
|
|
|
|
#define kvm_irqchip_in_kernel() (false)
|
2015-12-17 17:16:08 +01:00
|
|
|
#define kvm_irqchip_is_split() (false)
|
2012-07-26 16:35:11 +02:00
|
|
|
#define kvm_async_interrupts_enabled() (false)
|
2013-04-24 22:24:12 +02:00
|
|
|
#define kvm_halt_in_kernel() (false)
|
2014-05-27 14:03:35 +02:00
|
|
|
#define kvm_eventfds_enabled() (false)
|
2012-07-26 16:35:14 +02:00
|
|
|
#define kvm_irqfds_enabled() (false)
|
2015-07-06 20:15:14 +02:00
|
|
|
#define kvm_resamplefds_enabled() (false)
|
2012-07-26 16:35:15 +02:00
|
|
|
#define kvm_msi_via_irqfd_enabled() (false)
|
2012-07-26 16:35:16 +02:00
|
|
|
#define kvm_gsi_routing_allowed() (false)
|
2013-09-03 10:08:25 +02:00
|
|
|
#define kvm_gsi_direct_mapping() (false)
|
2013-05-29 10:27:25 +02:00
|
|
|
#define kvm_readonly_mem_enabled() (false)
|
2015-10-15 15:44:50 +02:00
|
|
|
#define kvm_direct_msi_enabled() (false)
|
2015-11-06 09:02:46 +01:00
|
|
|
#define kvm_ioeventfd_any_length_enabled() (false)
|
2016-10-04 14:28:09 +02:00
|
|
|
#define kvm_msi_devid_required() (false)
|
2008-11-05 17:29:27 +01:00
|
|
|
#endif
|
|
|
|
|
|
|
|
struct kvm_run;
|
2011-10-16 13:23:26 +02:00
|
|
|
struct kvm_lapic_state;
|
2015-01-09 09:04:40 +01:00
|
|
|
struct kvm_irq_routing_entry;
|
2008-11-05 17:29:27 +01:00
|
|
|
|
2011-01-21 21:48:17 +01:00
|
|
|
typedef struct KVMCapabilityInfo {
|
|
|
|
const char *name;
|
|
|
|
int value;
|
|
|
|
} KVMCapabilityInfo;
|
|
|
|
|
|
|
|
#define KVM_CAP_INFO(CAP) { "KVM_CAP_" stringify(CAP), KVM_CAP_##CAP }
|
|
|
|
#define KVM_CAP_LAST_INFO { NULL, 0 }
|
|
|
|
|
2012-05-17 15:32:33 +02:00
|
|
|
struct KVMState;
|
|
|
|
typedef struct KVMState KVMState;
|
|
|
|
extern KVMState *kvm_state;
|
|
|
|
|
2008-11-05 17:29:27 +01:00
|
|
|
/* external API */
|
|
|
|
|
2014-10-31 17:38:32 +01:00
|
|
|
bool kvm_has_free_slot(MachineState *ms);
|
2010-04-01 19:57:11 +02:00
|
|
|
int kvm_has_sync_mmu(void);
|
|
|
|
int kvm_has_vcpu_events(void);
|
|
|
|
int kvm_has_robust_singlestep(void);
|
2010-03-12 15:20:49 +01:00
|
|
|
int kvm_has_debugregs(void);
|
2012-03-02 20:28:48 +01:00
|
|
|
int kvm_has_pit_state2(void);
|
2011-01-10 12:50:05 +01:00
|
|
|
int kvm_has_many_ioeventfds(void);
|
2011-10-15 11:49:47 +02:00
|
|
|
int kvm_has_gsi_routing(void);
|
2012-08-27 08:28:39 +02:00
|
|
|
int kvm_has_intx_set_mask(void);
|
2010-04-01 19:57:11 +02:00
|
|
|
|
2012-12-17 06:38:45 +01:00
|
|
|
int kvm_init_vcpu(CPUState *cpu);
|
2013-05-26 23:46:55 +02:00
|
|
|
int kvm_cpu_exec(CPUState *cpu);
|
2016-05-12 05:48:13 +02:00
|
|
|
int kvm_destroy_vcpu(CPUState *cpu);
|
2008-11-05 17:29:27 +01:00
|
|
|
|
2012-12-17 06:38:45 +01:00
|
|
|
#ifdef NEED_CPU_H
|
2016-03-15 16:58:45 +01:00
|
|
|
#include "cpu.h"
|
2008-11-05 17:29:27 +01:00
|
|
|
|
2010-01-26 12:21:16 +01:00
|
|
|
void kvm_flush_coalesced_mmio_buffer(void);
|
2008-12-09 21:09:57 +01:00
|
|
|
|
2013-06-27 17:12:06 +02:00
|
|
|
int kvm_insert_breakpoint(CPUState *cpu, target_ulong addr,
|
2009-03-12 21:12:48 +01:00
|
|
|
target_ulong len, int type);
|
2013-06-27 17:12:06 +02:00
|
|
|
int kvm_remove_breakpoint(CPUState *cpu, target_ulong addr,
|
2009-03-12 21:12:48 +01:00
|
|
|
target_ulong len, int type);
|
2013-05-27 14:40:48 +02:00
|
|
|
void kvm_remove_all_breakpoints(CPUState *cpu);
|
2013-07-25 20:50:21 +02:00
|
|
|
int kvm_update_guest_debug(CPUState *cpu, unsigned long reinject_trap);
|
2009-03-12 21:12:48 +01:00
|
|
|
|
2013-01-17 09:30:27 +01:00
|
|
|
int kvm_on_sigbus_vcpu(CPUState *cpu, int code, void *addr);
|
2011-02-01 22:15:51 +01:00
|
|
|
int kvm_on_sigbus(int code, void *addr);
|
|
|
|
|
2015-08-11 10:52:46 +02:00
|
|
|
/* interface with exec.c */
|
|
|
|
|
|
|
|
void phys_mem_set_alloc(void *(*alloc)(size_t, uint64_t *align));
|
|
|
|
|
2008-11-05 17:29:27 +01:00
|
|
|
/* internal API */
|
|
|
|
|
2008-11-13 20:21:00 +01:00
|
|
|
int kvm_ioctl(KVMState *s, int type, ...);
|
2008-11-05 17:29:27 +01:00
|
|
|
|
2008-11-13 20:21:00 +01:00
|
|
|
int kvm_vm_ioctl(KVMState *s, int type, ...);
|
2008-11-05 17:29:27 +01:00
|
|
|
|
2012-10-31 06:06:49 +01:00
|
|
|
int kvm_vcpu_ioctl(CPUState *cpu, int type, ...);
|
2008-11-05 17:29:27 +01:00
|
|
|
|
2014-02-26 18:20:00 +01:00
|
|
|
/**
|
|
|
|
* kvm_device_ioctl - call an ioctl on a kvm device
|
|
|
|
* @fd: The KVM device file descriptor as returned from KVM_CREATE_DEVICE
|
|
|
|
* @type: The device-ctrl ioctl number
|
|
|
|
*
|
|
|
|
* Returns: -errno on error, nonnegative on success
|
|
|
|
*/
|
|
|
|
int kvm_device_ioctl(int fd, int type, ...);
|
|
|
|
|
2015-03-12 13:53:49 +01:00
|
|
|
/**
|
|
|
|
* kvm_vm_check_attr - check for existence of a specific vm attribute
|
|
|
|
* @s: The KVMState pointer
|
|
|
|
* @group: the group
|
|
|
|
* @attr: the attribute of that group to query for
|
|
|
|
*
|
|
|
|
* Returns: 1 if the attribute exists
|
|
|
|
* 0 if the attribute either does not exist or if the vm device
|
|
|
|
* interface is unavailable
|
|
|
|
*/
|
|
|
|
int kvm_vm_check_attr(KVMState *s, uint32_t group, uint64_t attr);
|
|
|
|
|
2015-09-24 02:29:36 +02:00
|
|
|
/**
|
|
|
|
* kvm_device_check_attr - check for existence of a specific device attribute
|
|
|
|
* @fd: The device file descriptor
|
|
|
|
* @group: the group
|
|
|
|
* @attr: the attribute of that group to query for
|
|
|
|
*
|
|
|
|
* Returns: 1 if the attribute exists
|
|
|
|
* 0 if the attribute either does not exist or if the vm device
|
|
|
|
* interface is unavailable
|
|
|
|
*/
|
|
|
|
int kvm_device_check_attr(int fd, uint32_t group, uint64_t attr);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* kvm_device_access - set or get value of a specific vm attribute
|
|
|
|
* @fd: The device file descriptor
|
|
|
|
* @group: the group
|
|
|
|
* @attr: the attribute of that group to set or get
|
|
|
|
* @val: pointer to a storage area for the value
|
|
|
|
* @write: true for set and false for get operation
|
|
|
|
*
|
|
|
|
* This function is not allowed to fail. Use kvm_device_check_attr()
|
|
|
|
* in order to check for the availability of optional attributes.
|
|
|
|
*/
|
|
|
|
void kvm_device_access(int fd, int group, uint64_t attr,
|
|
|
|
void *val, bool write);
|
|
|
|
|
2014-02-26 18:20:00 +01:00
|
|
|
/**
|
|
|
|
* kvm_create_device - create a KVM device for the device control API
|
|
|
|
* @KVMState: The KVMState pointer
|
|
|
|
* @type: The KVM device type (see Documentation/virtual/kvm/devices in the
|
|
|
|
* kernel source)
|
|
|
|
* @test: If true, only test if device can be created, but don't actually
|
|
|
|
* create the device.
|
|
|
|
*
|
|
|
|
* Returns: -errno on error, nonnegative on success: @test ? 0 : device fd;
|
|
|
|
*/
|
|
|
|
int kvm_create_device(KVMState *s, uint64_t type, bool test);
|
|
|
|
|
2016-03-30 18:27:24 +02:00
|
|
|
/**
|
|
|
|
* kvm_device_supported - probe whether KVM supports specific device
|
|
|
|
*
|
|
|
|
* @vmfd: The fd handler for VM
|
|
|
|
* @type: type of device
|
|
|
|
*
|
|
|
|
* @return: true if supported, otherwise false.
|
|
|
|
*/
|
|
|
|
bool kvm_device_supported(int vmfd, uint64_t type);
|
2014-02-26 18:20:00 +01:00
|
|
|
|
2008-11-05 17:29:27 +01:00
|
|
|
/* Arch specific hooks */
|
|
|
|
|
2011-01-21 21:48:17 +01:00
|
|
|
extern const KVMCapabilityInfo kvm_arch_required_capabilities[];
|
|
|
|
|
2012-10-31 06:57:49 +01:00
|
|
|
void kvm_arch_pre_run(CPUState *cpu, struct kvm_run *run);
|
2015-04-08 13:30:58 +02:00
|
|
|
MemTxAttrs kvm_arch_post_run(CPUState *cpu, struct kvm_run *run);
|
2008-11-05 17:29:27 +01:00
|
|
|
|
2012-10-31 06:57:49 +01:00
|
|
|
int kvm_arch_handle_exit(CPUState *cpu, struct kvm_run *run);
|
2008-11-05 17:29:27 +01:00
|
|
|
|
2012-10-31 06:57:49 +01:00
|
|
|
int kvm_arch_process_async_events(CPUState *cpu);
|
2010-05-04 14:45:27 +02:00
|
|
|
|
2012-10-31 06:57:49 +01:00
|
|
|
int kvm_arch_get_registers(CPUState *cpu);
|
2008-11-05 17:29:27 +01:00
|
|
|
|
2010-03-01 19:10:30 +01:00
|
|
|
/* state subset only touched by the VCPU itself during runtime */
|
|
|
|
#define KVM_PUT_RUNTIME_STATE 1
|
|
|
|
/* state subset modified during VCPU reset */
|
|
|
|
#define KVM_PUT_RESET_STATE 2
|
|
|
|
/* full state set, modified during initialization or on vmload */
|
|
|
|
#define KVM_PUT_FULL_STATE 3
|
|
|
|
|
2012-10-31 06:57:49 +01:00
|
|
|
int kvm_arch_put_registers(CPUState *cpu, int level);
|
2008-11-05 17:29:27 +01:00
|
|
|
|
2015-02-04 16:43:51 +01:00
|
|
|
int kvm_arch_init(MachineState *ms, KVMState *s);
|
2008-11-05 17:29:27 +01:00
|
|
|
|
2012-10-31 06:57:49 +01:00
|
|
|
int kvm_arch_init_vcpu(CPUState *cpu);
|
2008-11-05 17:29:27 +01:00
|
|
|
|
2016-04-26 15:41:04 +02:00
|
|
|
bool kvm_vcpu_id_is_valid(int vcpu_id);
|
|
|
|
|
2013-01-22 21:25:01 +01:00
|
|
|
/* Returns VCPU ID to be used on KVM_CREATE_VCPU ioctl() */
|
|
|
|
unsigned long kvm_arch_vcpu_id(CPUState *cpu);
|
|
|
|
|
2017-02-08 12:48:54 +01:00
|
|
|
#ifdef TARGET_I386
|
|
|
|
#define KVM_HAVE_MCE_INJECTION 1
|
|
|
|
void kvm_arch_on_sigbus_vcpu(CPUState *cpu, int code, void *addr);
|
|
|
|
#endif
|
2010-10-11 20:31:21 +02:00
|
|
|
|
2011-10-15 11:49:47 +02:00
|
|
|
void kvm_arch_init_irq_routing(KVMState *s);
|
|
|
|
|
2015-01-09 09:04:40 +01:00
|
|
|
int kvm_arch_fixup_msi_route(struct kvm_irq_routing_entry *route,
|
2015-10-15 15:44:52 +02:00
|
|
|
uint64_t address, uint32_t data, PCIDevice *dev);
|
2015-01-09 09:04:40 +01:00
|
|
|
|
2016-07-14 07:56:31 +02:00
|
|
|
/* Notify arch about newly added MSI routes */
|
|
|
|
int kvm_arch_add_msi_route_post(struct kvm_irq_routing_entry *route,
|
|
|
|
int vector, PCIDevice *dev);
|
|
|
|
/* Notify arch about released MSI routes */
|
|
|
|
int kvm_arch_release_virq_post(int virq);
|
|
|
|
|
2015-06-02 15:56:23 +02:00
|
|
|
int kvm_arch_msi_data_to_gsi(uint32_t data);
|
|
|
|
|
2012-07-26 16:35:12 +02:00
|
|
|
int kvm_set_irq(KVMState *s, int irq, int level);
|
2012-05-16 20:41:10 +02:00
|
|
|
int kvm_irqchip_send_msi(KVMState *s, MSIMessage msg);
|
2011-10-15 11:49:47 +02:00
|
|
|
|
2012-05-17 15:32:32 +02:00
|
|
|
void kvm_irqchip_add_irq_route(KVMState *s, int gsi, int irqchip, int pin);
|
2011-10-15 11:49:47 +02:00
|
|
|
|
2011-10-16 13:23:26 +02:00
|
|
|
void kvm_get_apic_state(DeviceState *d, struct kvm_lapic_state *kapic);
|
|
|
|
|
2009-03-12 21:12:48 +01:00
|
|
|
struct kvm_guest_debug;
|
|
|
|
struct kvm_debug_exit_arch;
|
|
|
|
|
|
|
|
struct kvm_sw_breakpoint {
|
|
|
|
target_ulong pc;
|
|
|
|
target_ulong saved_insn;
|
|
|
|
int use_count;
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_ENTRY(kvm_sw_breakpoint) entry;
|
2009-03-12 21:12:48 +01:00
|
|
|
};
|
|
|
|
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_HEAD(kvm_sw_breakpoint_head, kvm_sw_breakpoint);
|
2009-03-12 21:12:48 +01:00
|
|
|
|
2012-12-01 05:35:08 +01:00
|
|
|
struct kvm_sw_breakpoint *kvm_find_sw_breakpoint(CPUState *cpu,
|
2009-03-12 21:12:48 +01:00
|
|
|
target_ulong pc);
|
|
|
|
|
2012-12-01 05:35:08 +01:00
|
|
|
int kvm_sw_breakpoints_active(CPUState *cpu);
|
2009-03-12 21:12:48 +01:00
|
|
|
|
2013-06-19 17:37:31 +02:00
|
|
|
int kvm_arch_insert_sw_breakpoint(CPUState *cpu,
|
2009-03-12 21:12:48 +01:00
|
|
|
struct kvm_sw_breakpoint *bp);
|
2013-06-19 17:37:31 +02:00
|
|
|
int kvm_arch_remove_sw_breakpoint(CPUState *cpu,
|
2009-03-12 21:12:48 +01:00
|
|
|
struct kvm_sw_breakpoint *bp);
|
|
|
|
int kvm_arch_insert_hw_breakpoint(target_ulong addr,
|
|
|
|
target_ulong len, int type);
|
|
|
|
int kvm_arch_remove_hw_breakpoint(target_ulong addr,
|
|
|
|
target_ulong len, int type);
|
|
|
|
void kvm_arch_remove_all_hw_breakpoints(void);
|
|
|
|
|
2012-10-31 06:57:49 +01:00
|
|
|
void kvm_arch_update_guest_debug(CPUState *cpu, struct kvm_guest_debug *dbg);
|
2009-03-12 21:12:48 +01:00
|
|
|
|
2012-10-31 06:57:49 +01:00
|
|
|
bool kvm_arch_stop_on_emulation_error(CPUState *cpu);
|
2010-05-10 10:21:34 +02:00
|
|
|
|
2009-05-08 22:33:24 +02:00
|
|
|
int kvm_check_extension(KVMState *s, unsigned int extension);
|
|
|
|
|
2014-07-14 19:15:15 +02:00
|
|
|
int kvm_vm_check_extension(KVMState *s, unsigned int extension);
|
|
|
|
|
2013-10-23 18:19:26 +02:00
|
|
|
#define kvm_vm_enable_cap(s, capability, cap_flags, ...) \
|
|
|
|
({ \
|
|
|
|
struct kvm_enable_cap cap = { \
|
|
|
|
.cap = capability, \
|
|
|
|
.flags = cap_flags, \
|
|
|
|
}; \
|
|
|
|
uint64_t args_tmp[] = { __VA_ARGS__ }; \
|
|
|
|
int i; \
|
2014-05-12 11:51:37 +02:00
|
|
|
for (i = 0; i < (int)ARRAY_SIZE(args_tmp) && \
|
2013-10-23 18:19:26 +02:00
|
|
|
i < ARRAY_SIZE(cap.args); i++) { \
|
|
|
|
cap.args[i] = args_tmp[i]; \
|
|
|
|
} \
|
|
|
|
kvm_vm_ioctl(s, KVM_ENABLE_CAP, &cap); \
|
|
|
|
})
|
|
|
|
|
|
|
|
#define kvm_vcpu_enable_cap(cpu, capability, cap_flags, ...) \
|
|
|
|
({ \
|
|
|
|
struct kvm_enable_cap cap = { \
|
|
|
|
.cap = capability, \
|
|
|
|
.flags = cap_flags, \
|
|
|
|
}; \
|
|
|
|
uint64_t args_tmp[] = { __VA_ARGS__ }; \
|
|
|
|
int i; \
|
2014-05-12 11:51:37 +02:00
|
|
|
for (i = 0; i < (int)ARRAY_SIZE(args_tmp) && \
|
2013-10-23 18:19:26 +02:00
|
|
|
i < ARRAY_SIZE(cap.args); i++) { \
|
|
|
|
cap.args[i] = args_tmp[i]; \
|
|
|
|
} \
|
|
|
|
kvm_vcpu_ioctl(cpu, KVM_ENABLE_CAP, &cap); \
|
|
|
|
})
|
|
|
|
|
2011-06-08 16:11:05 +02:00
|
|
|
uint32_t kvm_arch_get_supported_cpuid(KVMState *env, uint32_t function,
|
2010-06-17 09:18:13 +02:00
|
|
|
uint32_t index, int reg);
|
2009-03-12 21:12:48 +01:00
|
|
|
|
2014-06-18 00:10:31 +02:00
|
|
|
void kvm_set_sigmask_len(KVMState *s, unsigned int sigmask_len);
|
|
|
|
|
2013-04-23 10:29:36 +02:00
|
|
|
#if !defined(CONFIG_USER_ONLY)
|
|
|
|
int kvm_physical_memory_addr_from_host(KVMState *s, void *ram_addr,
|
|
|
|
hwaddr *phys_addr);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#endif /* NEED_CPU_H */
|
|
|
|
|
2013-08-27 13:19:10 +02:00
|
|
|
void kvm_cpu_synchronize_state(CPUState *cpu);
|
2013-04-23 10:29:36 +02:00
|
|
|
void kvm_cpu_synchronize_post_reset(CPUState *cpu);
|
|
|
|
void kvm_cpu_synchronize_post_init(CPUState *cpu);
|
|
|
|
|
2017-02-09 09:41:14 +01:00
|
|
|
void kvm_init_cpu_signals(CPUState *cpu);
|
|
|
|
|
2016-07-14 07:56:30 +02:00
|
|
|
/**
|
|
|
|
* kvm_irqchip_add_msi_route - Add MSI route for specific vector
|
|
|
|
* @s: KVM state
|
|
|
|
* @vector: which vector to add. This can be either MSI/MSIX
|
|
|
|
* vector. The function will automatically detect whether
|
|
|
|
* MSI/MSIX is enabled, and fetch corresponding MSI
|
|
|
|
* message.
|
|
|
|
* @dev: Owner PCI device to add the route. If @dev is specified
|
|
|
|
* as @NULL, an empty MSI message will be inited.
|
|
|
|
* @return: virq (>=0) when success, errno (<0) when failed.
|
|
|
|
*/
|
|
|
|
int kvm_irqchip_add_msi_route(KVMState *s, int vector, PCIDevice *dev);
|
2015-10-15 15:44:52 +02:00
|
|
|
int kvm_irqchip_update_msi_route(KVMState *s, int virq, MSIMessage msg,
|
|
|
|
PCIDevice *dev);
|
2016-07-14 07:56:33 +02:00
|
|
|
void kvm_irqchip_commit_routes(KVMState *s);
|
2012-05-17 15:32:34 +02:00
|
|
|
void kvm_irqchip_release_virq(KVMState *s, int virq);
|
2012-05-17 15:32:36 +02:00
|
|
|
|
2013-07-15 17:45:03 +02:00
|
|
|
int kvm_irqchip_add_adapter_route(KVMState *s, AdapterInfo *adapter);
|
2015-11-10 13:52:42 +01:00
|
|
|
int kvm_irqchip_add_hv_sint_route(KVMState *s, uint32_t vcpu, uint32_t sint);
|
2013-07-15 17:45:03 +02:00
|
|
|
|
2015-07-06 20:15:13 +02:00
|
|
|
int kvm_irqchip_add_irqfd_notifier_gsi(KVMState *s, EventNotifier *n,
|
|
|
|
EventNotifier *rn, int virq);
|
|
|
|
int kvm_irqchip_remove_irqfd_notifier_gsi(KVMState *s, EventNotifier *n,
|
|
|
|
int virq);
|
2015-07-06 20:15:13 +02:00
|
|
|
int kvm_irqchip_add_irqfd_notifier(KVMState *s, EventNotifier *n,
|
|
|
|
EventNotifier *rn, qemu_irq irq);
|
|
|
|
int kvm_irqchip_remove_irqfd_notifier(KVMState *s, EventNotifier *n,
|
|
|
|
qemu_irq irq);
|
|
|
|
void kvm_irqchip_set_qemuirq_gsi(KVMState *s, qemu_irq irq, int gsi);
|
2012-11-14 21:54:02 +01:00
|
|
|
void kvm_pc_gsi_handler(void *opaque, int n, int level);
|
|
|
|
void kvm_pc_setup_irq_routing(bool pci_enabled);
|
2013-04-16 15:58:13 +02:00
|
|
|
void kvm_init_irq_routing(KVMState *s);
|
2014-02-26 18:20:00 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* kvm_arch_irqchip_create:
|
|
|
|
* @KVMState: The KVMState pointer
|
2015-12-17 17:16:08 +01:00
|
|
|
* @MachineState: The MachineState pointer
|
2014-02-26 18:20:00 +01:00
|
|
|
*
|
|
|
|
* Allow architectures to create an in-kernel irq chip themselves.
|
|
|
|
*
|
|
|
|
* Returns: < 0: error
|
|
|
|
* 0: irq chip was not created
|
|
|
|
* > 0: irq chip was created
|
|
|
|
*/
|
2015-12-17 17:16:08 +01:00
|
|
|
int kvm_arch_irqchip_create(MachineState *ms, KVMState *s);
|
2014-05-09 10:06:46 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* kvm_set_one_reg - set a register value in KVM via KVM_SET_ONE_REG ioctl
|
|
|
|
* @id: The register ID
|
|
|
|
* @source: The pointer to the value to be set. It must point to a variable
|
|
|
|
* of the correct type/size for the register being accessed.
|
|
|
|
*
|
|
|
|
* Returns: 0 on success, or a negative errno on failure.
|
|
|
|
*/
|
|
|
|
int kvm_set_one_reg(CPUState *cs, uint64_t id, void *source);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* kvm_get_one_reg - get a register value from KVM via KVM_GET_ONE_REG ioctl
|
|
|
|
* @id: The register ID
|
|
|
|
* @target: The pointer where the value is to be stored. It must point to a
|
|
|
|
* variable of the correct type/size for the register being accessed.
|
|
|
|
*
|
|
|
|
* Returns: 0 on success, or a negative errno on failure.
|
|
|
|
*/
|
|
|
|
int kvm_get_one_reg(CPUState *cs, uint64_t id, void *target);
|
2017-03-20 00:46:43 +01:00
|
|
|
struct ppc_radix_page_info *kvm_get_radix_page_info(void);
|
2016-06-01 11:51:24 +02:00
|
|
|
int kvm_get_max_memslots(void);
|
2008-11-05 17:29:27 +01:00
|
|
|
#endif
|