Statistics
| Branch: | Revision:

root / kvm.h @ c958a8bd

History | View | Annotate | Download (4.7 kB)

1
/*
2
 * QEMU KVM support
3
 *
4
 * Copyright IBM, Corp. 2008
5
 *
6
 * Authors:
7
 *  Anthony Liguori   <aliguori@us.ibm.com>
8
 *
9
 * This work is licensed under the terms of the GNU GPL, version 2 or later.
10
 * See the COPYING file in the top-level directory.
11
 *
12
 */
13

    
14
#ifndef QEMU_KVM_H
15
#define QEMU_KVM_H
16

    
17
#include <errno.h>
18
#include "config-host.h"
19
#include "qemu-queue.h"
20

    
21
#ifdef CONFIG_KVM
22
#include <linux/kvm.h>
23
#endif
24

    
25
extern int kvm_allowed;
26

    
27
#if defined CONFIG_KVM || !defined NEED_CPU_H
28
#define kvm_enabled() (kvm_allowed)
29
#else
30
#define kvm_enabled() (0)
31
#endif
32

    
33
struct kvm_run;
34

    
35
/* external API */
36

    
37
int kvm_init(int smp_cpus);
38

    
39
int kvm_has_sync_mmu(void);
40
int kvm_has_vcpu_events(void);
41
int kvm_has_robust_singlestep(void);
42
int kvm_has_debugregs(void);
43

    
44
#ifdef NEED_CPU_H
45
int kvm_init_vcpu(CPUState *env);
46

    
47
int kvm_cpu_exec(CPUState *env);
48

    
49
#if !defined(CONFIG_USER_ONLY)
50
int kvm_log_start(target_phys_addr_t phys_addr, ram_addr_t size);
51
int kvm_log_stop(target_phys_addr_t phys_addr, ram_addr_t size);
52

    
53
void kvm_setup_guest_memory(void *start, size_t size);
54

    
55
int kvm_coalesce_mmio_region(target_phys_addr_t start, ram_addr_t size);
56
int kvm_uncoalesce_mmio_region(target_phys_addr_t start, ram_addr_t size);
57
void kvm_flush_coalesced_mmio_buffer(void);
58
#endif
59

    
60
int kvm_insert_breakpoint(CPUState *current_env, target_ulong addr,
61
                          target_ulong len, int type);
62
int kvm_remove_breakpoint(CPUState *current_env, target_ulong addr,
63
                          target_ulong len, int type);
64
void kvm_remove_all_breakpoints(CPUState *current_env);
65
int kvm_update_guest_debug(CPUState *env, unsigned long reinject_trap);
66
#ifndef _WIN32
67
int kvm_set_signal_mask(CPUState *env, const sigset_t *sigset);
68
#endif
69

    
70
int kvm_pit_in_kernel(void);
71
int kvm_irqchip_in_kernel(void);
72

    
73
/* internal API */
74

    
75
struct KVMState;
76
typedef struct KVMState KVMState;
77

    
78
int kvm_ioctl(KVMState *s, int type, ...);
79

    
80
int kvm_vm_ioctl(KVMState *s, int type, ...);
81

    
82
int kvm_vcpu_ioctl(CPUState *env, int type, ...);
83

    
84
/* Arch specific hooks */
85

    
86
int kvm_arch_post_run(CPUState *env, struct kvm_run *run);
87

    
88
int kvm_arch_handle_exit(CPUState *env, struct kvm_run *run);
89

    
90
int kvm_arch_pre_run(CPUState *env, struct kvm_run *run);
91

    
92
int kvm_arch_process_irqchip_events(CPUState *env);
93

    
94
int kvm_arch_get_registers(CPUState *env);
95

    
96
/* state subset only touched by the VCPU itself during runtime */
97
#define KVM_PUT_RUNTIME_STATE   1
98
/* state subset modified during VCPU reset */
99
#define KVM_PUT_RESET_STATE     2
100
/* full state set, modified during initialization or on vmload */
101
#define KVM_PUT_FULL_STATE      3
102

    
103
int kvm_arch_put_registers(CPUState *env, int level);
104

    
105
int kvm_arch_init(KVMState *s, int smp_cpus);
106

    
107
int kvm_arch_init_vcpu(CPUState *env);
108

    
109
void kvm_arch_reset_vcpu(CPUState *env);
110

    
111
struct kvm_guest_debug;
112
struct kvm_debug_exit_arch;
113

    
114
struct kvm_sw_breakpoint {
115
    target_ulong pc;
116
    target_ulong saved_insn;
117
    int use_count;
118
    QTAILQ_ENTRY(kvm_sw_breakpoint) entry;
119
};
120

    
121
QTAILQ_HEAD(kvm_sw_breakpoint_head, kvm_sw_breakpoint);
122

    
123
int kvm_arch_debug(struct kvm_debug_exit_arch *arch_info);
124

    
125
struct kvm_sw_breakpoint *kvm_find_sw_breakpoint(CPUState *env,
126
                                                 target_ulong pc);
127

    
128
int kvm_sw_breakpoints_active(CPUState *env);
129

    
130
int kvm_arch_insert_sw_breakpoint(CPUState *current_env,
131
                                  struct kvm_sw_breakpoint *bp);
132
int kvm_arch_remove_sw_breakpoint(CPUState *current_env,
133
                                  struct kvm_sw_breakpoint *bp);
134
int kvm_arch_insert_hw_breakpoint(target_ulong addr,
135
                                  target_ulong len, int type);
136
int kvm_arch_remove_hw_breakpoint(target_ulong addr,
137
                                  target_ulong len, int type);
138
void kvm_arch_remove_all_hw_breakpoints(void);
139

    
140
void kvm_arch_update_guest_debug(CPUState *env, struct kvm_guest_debug *dbg);
141

    
142
bool kvm_arch_stop_on_emulation_error(CPUState *env);
143

    
144
int kvm_check_extension(KVMState *s, unsigned int extension);
145

    
146
uint32_t kvm_arch_get_supported_cpuid(CPUState *env, uint32_t function,
147
                                      uint32_t index, int reg);
148
void kvm_cpu_synchronize_state(CPUState *env);
149
void kvm_cpu_synchronize_post_reset(CPUState *env);
150
void kvm_cpu_synchronize_post_init(CPUState *env);
151

    
152
/* generic hooks - to be moved/refactored once there are more users */
153

    
154
static inline void cpu_synchronize_state(CPUState *env)
155
{
156
    if (kvm_enabled()) {
157
        kvm_cpu_synchronize_state(env);
158
    }
159
}
160

    
161
static inline void cpu_synchronize_post_reset(CPUState *env)
162
{
163
    if (kvm_enabled()) {
164
        kvm_cpu_synchronize_post_reset(env);
165
    }
166
}
167

    
168
static inline void cpu_synchronize_post_init(CPUState *env)
169
{
170
    if (kvm_enabled()) {
171
        kvm_cpu_synchronize_post_init(env);
172
    }
173
}
174

    
175
#endif
176

    
177
int kvm_set_ioeventfd_pio_word(int fd, uint16_t adr, uint16_t val, bool assign);
178
#endif