← Back to branch summary

~vcs-imports/qemu/git

« back to all changes in this revision

Viewing changes to kvm.h

  • Committer: Blue Swirl
  • Date: 2009-08-31 15:14:40 UTC
  • Revision ID: git-v1:528e93a9787ccfc59582a44035f5f342caf5b84f
Fix breakage due to __thread

Thread-local storage is not supported on all hosts.

Signed-off-by: Blue Swirl <blauwirbel@gmail.com>

Show diffs side-by-side

added added

removed removed

Lines of Context:
kvm.h
 
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
 
 
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
int kvm_get_mp_state(CPUState *env);
 
78
int kvm_put_mp_state(CPUState *env);
 
79
 
 
80
/* Arch specific hooks */
 
81
 
 
82
int kvm_arch_post_run(CPUState *env, struct kvm_run *run);
 
83
 
 
84
int kvm_arch_handle_exit(CPUState *env, struct kvm_run *run);
 
85
 
 
86
int kvm_arch_pre_run(CPUState *env, struct kvm_run *run);
 
87
 
 
88
int kvm_arch_get_registers(CPUState *env);
 
89
 
 
90
int kvm_arch_put_registers(CPUState *env);
 
91
 
 
92
int kvm_arch_init(KVMState *s, int smp_cpus);
 
93
 
 
94
int kvm_arch_init_vcpu(CPUState *env);
 
95
 
 
96
struct kvm_guest_debug;
 
97
struct kvm_debug_exit_arch;
 
98
 
 
99
struct kvm_sw_breakpoint {
 
100
    target_ulong pc;
 
101
    target_ulong saved_insn;
 
102
    int use_count;
 
103
    TAILQ_ENTRY(kvm_sw_breakpoint) entry;
 
104
};
 
105
 
 
106
TAILQ_HEAD(kvm_sw_breakpoint_head, kvm_sw_breakpoint);
 
107
 
 
108
int kvm_arch_debug(struct kvm_debug_exit_arch *arch_info);
 
109
 
 
110
struct kvm_sw_breakpoint *kvm_find_sw_breakpoint(CPUState *env,
 
111
                                                 target_ulong pc);
 
112
 
 
113
int kvm_sw_breakpoints_active(CPUState *env);
 
114
 
 
115
int kvm_arch_insert_sw_breakpoint(CPUState *current_env,
 
116
                                  struct kvm_sw_breakpoint *bp);
 
117
int kvm_arch_remove_sw_breakpoint(CPUState *current_env,
 
118
                                  struct kvm_sw_breakpoint *bp);
 
119
int kvm_arch_insert_hw_breakpoint(target_ulong addr,
 
120
                                  target_ulong len, int type);
 
121
int kvm_arch_remove_hw_breakpoint(target_ulong addr,
 
122
                                  target_ulong len, int type);
 
123
void kvm_arch_remove_all_hw_breakpoints(void);
 
124
 
 
125
void kvm_arch_update_guest_debug(CPUState *env, struct kvm_guest_debug *dbg);
 
126
 
 
127
int kvm_check_extension(KVMState *s, unsigned int extension);
 
128
 
 
129
uint32_t kvm_arch_get_supported_cpuid(CPUState *env, uint32_t function,
 
130
                                      int reg);
 
131
void kvm_cpu_synchronize_state(CPUState *env);
 
132
 
 
133
/* generic hooks - to be moved/refactored once there are more users */
 
134
 
 
135
static inline void cpu_synchronize_state(CPUState *env)
 
136
{
 
137
    if (kvm_enabled()) {
 
138
        kvm_cpu_synchronize_state(env);
 
139
    }
 
140
}
 
141
 
 
142
#endif