Statistics
| Branch: | Revision:

root / kvm.h @ caa5af0f

History | View | Annotate | Download (3.8 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 "config.h"
18
#include "qemu-queue.h"
19

    
20
#ifdef CONFIG_KVM
21
extern int kvm_allowed;
22

    
23
#define kvm_enabled() (kvm_allowed)
24
#else
25
#define kvm_enabled() (0)
26
#endif
27

    
28
struct kvm_run;
29

    
30
/* external API */
31

    
32
int kvm_init(int smp_cpus);
33

    
34
int kvm_init_vcpu(CPUState *env);
35

    
36
int kvm_cpu_exec(CPUState *env);
37

    
38
void kvm_set_phys_mem(target_phys_addr_t start_addr,
39
                      ram_addr_t size,
40
                      ram_addr_t phys_offset);
41

    
42
int kvm_physical_sync_dirty_bitmap(target_phys_addr_t start_addr,
43
                                   target_phys_addr_t end_addr);
44

    
45
int kvm_log_start(target_phys_addr_t phys_addr, ram_addr_t size);
46
int kvm_log_stop(target_phys_addr_t phys_addr, ram_addr_t size);
47
int kvm_set_migration_log(int enable);
48

    
49
int kvm_has_sync_mmu(void);
50

    
51
void kvm_setup_guest_memory(void *start, size_t size);
52

    
53
int kvm_coalesce_mmio_region(target_phys_addr_t start, ram_addr_t size);
54
int kvm_uncoalesce_mmio_region(target_phys_addr_t start, ram_addr_t size);
55

    
56
int kvm_insert_breakpoint(CPUState *current_env, target_ulong addr,
57
                          target_ulong len, int type);
58
int kvm_remove_breakpoint(CPUState *current_env, target_ulong addr,
59
                          target_ulong len, int type);
60
void kvm_remove_all_breakpoints(CPUState *current_env);
61
int kvm_update_guest_debug(CPUState *env, unsigned long reinject_trap);
62

    
63
int kvm_pit_in_kernel(void);
64
int kvm_irqchip_in_kernel(void);
65

    
66
/* internal API */
67

    
68
struct KVMState;
69
typedef struct KVMState KVMState;
70

    
71
int kvm_ioctl(KVMState *s, int type, ...);
72

    
73
int kvm_vm_ioctl(KVMState *s, int type, ...);
74

    
75
int kvm_vcpu_ioctl(CPUState *env, int type, ...);
76

    
77
/* Arch specific hooks */
78

    
79
int kvm_arch_post_run(CPUState *env, struct kvm_run *run);
80

    
81
int kvm_arch_handle_exit(CPUState *env, struct kvm_run *run);
82

    
83
int kvm_arch_pre_run(CPUState *env, struct kvm_run *run);
84

    
85
int kvm_arch_get_registers(CPUState *env);
86

    
87
int kvm_arch_put_registers(CPUState *env);
88

    
89
int kvm_arch_init(KVMState *s, int smp_cpus);
90

    
91
int kvm_arch_init_vcpu(CPUState *env);
92

    
93
void kvm_arch_reset_vcpu(CPUState *env);
94

    
95
struct kvm_guest_debug;
96
struct kvm_debug_exit_arch;
97

    
98
struct kvm_sw_breakpoint {
99
    target_ulong pc;
100
    target_ulong saved_insn;
101
    int use_count;
102
    QTAILQ_ENTRY(kvm_sw_breakpoint) entry;
103
};
104

    
105
QTAILQ_HEAD(kvm_sw_breakpoint_head, kvm_sw_breakpoint);
106

    
107
int kvm_arch_debug(struct kvm_debug_exit_arch *arch_info);
108

    
109
struct kvm_sw_breakpoint *kvm_find_sw_breakpoint(CPUState *env,
110
                                                 target_ulong pc);
111

    
112
int kvm_sw_breakpoints_active(CPUState *env);
113

    
114
int kvm_arch_insert_sw_breakpoint(CPUState *current_env,
115
                                  struct kvm_sw_breakpoint *bp);
116
int kvm_arch_remove_sw_breakpoint(CPUState *current_env,
117
                                  struct kvm_sw_breakpoint *bp);
118
int kvm_arch_insert_hw_breakpoint(target_ulong addr,
119
                                  target_ulong len, int type);
120
int kvm_arch_remove_hw_breakpoint(target_ulong addr,
121
                                  target_ulong len, int type);
122
void kvm_arch_remove_all_hw_breakpoints(void);
123

    
124
void kvm_arch_update_guest_debug(CPUState *env, struct kvm_guest_debug *dbg);
125

    
126
int kvm_check_extension(KVMState *s, unsigned int extension);
127

    
128
uint32_t kvm_arch_get_supported_cpuid(CPUState *env, uint32_t function,
129
                                      int reg);
130
void kvm_cpu_synchronize_state(CPUState *env);
131

    
132
/* generic hooks - to be moved/refactored once there are more users */
133

    
134
static inline void cpu_synchronize_state(CPUState *env)
135
{
136
    if (kvm_enabled()) {
137
        kvm_cpu_synchronize_state(env);
138
    }
139
}
140

    
141
#endif