Statistics
| Branch: | Revision:

root / kvm.h @ b827df58

History | View | Annotate | Download (3.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 "config.h"
18
#include "sys-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
int kvm_sync_vcpus(void);
36

    
37
int kvm_cpu_exec(CPUState *env);
38

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

    
43
void kvm_physical_sync_dirty_bitmap(target_phys_addr_t start_addr,
44
                                    target_phys_addr_t end_addr);
45

    
46
int kvm_log_start(target_phys_addr_t phys_addr, ram_addr_t size);
47
int kvm_log_stop(target_phys_addr_t phys_addr, ram_addr_t size);
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
/* internal API */
64

    
65
struct KVMState;
66
typedef struct KVMState KVMState;
67

    
68
int kvm_ioctl(KVMState *s, int type, ...);
69

    
70
int kvm_vm_ioctl(KVMState *s, int type, ...);
71

    
72
int kvm_vcpu_ioctl(CPUState *env, int type, ...);
73

    
74
/* Arch specific hooks */
75

    
76
int kvm_arch_post_run(CPUState *env, struct kvm_run *run);
77

    
78
int kvm_arch_handle_exit(CPUState *env, struct kvm_run *run);
79

    
80
int kvm_arch_pre_run(CPUState *env, struct kvm_run *run);
81

    
82
int kvm_arch_get_registers(CPUState *env);
83

    
84
int kvm_arch_put_registers(CPUState *env);
85

    
86
int kvm_arch_init(KVMState *s, int smp_cpus);
87

    
88
int kvm_arch_init_vcpu(CPUState *env);
89

    
90
struct kvm_guest_debug;
91
struct kvm_debug_exit_arch;
92

    
93
struct kvm_sw_breakpoint {
94
    target_ulong pc;
95
    target_ulong saved_insn;
96
    int use_count;
97
    TAILQ_ENTRY(kvm_sw_breakpoint) entry;
98
};
99

    
100
TAILQ_HEAD(kvm_sw_breakpoint_head, kvm_sw_breakpoint);
101

    
102
int kvm_arch_debug(struct kvm_debug_exit_arch *arch_info);
103

    
104
struct kvm_sw_breakpoint *kvm_find_sw_breakpoint(CPUState *env,
105
                                                 target_ulong pc);
106

    
107
int kvm_sw_breakpoints_active(CPUState *env);
108

    
109
int kvm_arch_insert_sw_breakpoint(CPUState *current_env,
110
                                  struct kvm_sw_breakpoint *bp);
111
int kvm_arch_remove_sw_breakpoint(CPUState *current_env,
112
                                  struct kvm_sw_breakpoint *bp);
113
int kvm_arch_insert_hw_breakpoint(target_ulong addr,
114
                                  target_ulong len, int type);
115
int kvm_arch_remove_hw_breakpoint(target_ulong addr,
116
                                  target_ulong len, int type);
117
void kvm_arch_remove_all_hw_breakpoints(void);
118

    
119
void kvm_arch_update_guest_debug(CPUState *env, struct kvm_guest_debug *dbg);
120

    
121
int kvm_check_extension(KVMState *s, unsigned int extension);
122

    
123
uint32_t kvm_arch_get_supported_cpuid(CPUState *env, uint32_t function,
124
                                      int reg);
125

    
126
/* generic hooks - to be moved/refactored once there are more users */
127

    
128
static inline void cpu_synchronize_state(CPUState *env, int modified)
129
{
130
    if (kvm_enabled()) {
131
        if (modified)
132
            kvm_arch_put_registers(env);
133
        else
134
            kvm_arch_get_registers(env);
135
    }
136
}
137

    
138
#endif