kvm_host.h 9.62 KB
Newer Older
1
2
#ifndef __KVM_HOST_H
#define __KVM_HOST_H
Avi Kivity's avatar
Avi Kivity committed
3
4
5
6
7
8
9

/*
 * This work is licensed under the terms of the GNU GPL, version 2.  See
 * the COPYING file in the top-level directory.
 */

#include <linux/types.h>
10
#include <linux/hardirq.h>
Avi Kivity's avatar
Avi Kivity committed
11
12
13
#include <linux/list.h>
#include <linux/mutex.h>
#include <linux/spinlock.h>
Markus Rechberger's avatar
Markus Rechberger committed
14
15
#include <linux/signal.h>
#include <linux/sched.h>
Avi Kivity's avatar
Avi Kivity committed
16
#include <linux/mm.h>
17
#include <linux/preempt.h>
18
#include <linux/marker.h>
Alexey Dobriyan's avatar
Alexey Dobriyan committed
19
#include <asm/signal.h>
Avi Kivity's avatar
Avi Kivity committed
20
21

#include <linux/kvm.h>
Ingo Molnar's avatar
Ingo Molnar committed
22
#include <linux/kvm_para.h>
Avi Kivity's avatar
Avi Kivity committed
23

24
#include <linux/kvm_types.h>
25

26
#include <asm/kvm_host.h>
27

28
29
30
/*
 * vcpu->requests bit members
 */
31
#define KVM_REQ_TLB_FLUSH          0
32
#define KVM_REQ_MIGRATE_TIMER      1
33
#define KVM_REQ_REPORT_TPR_ACCESS  2
34
#define KVM_REQ_MMU_RELOAD         3
35
#define KVM_REQ_TRIPLE_FAULT       4
Avi Kivity's avatar
Avi Kivity committed
36
37

struct kvm_vcpu;
38
extern struct kmem_cache *kvm_vcpu_cache;
Avi Kivity's avatar
Avi Kivity committed
39

40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
/*
 * It would be nice to use something smarter than a linear search, TBD...
 * Thankfully we dont expect many devices to register (famous last words :),
 * so until then it will suffice.  At least its abstracted so we can change
 * in one place.
 */
struct kvm_io_bus {
	int                   dev_count;
#define NR_IOBUS_DEVS 6
	struct kvm_io_device *devs[NR_IOBUS_DEVS];
};

void kvm_io_bus_init(struct kvm_io_bus *bus);
void kvm_io_bus_destroy(struct kvm_io_bus *bus);
struct kvm_io_device *kvm_io_bus_find_dev(struct kvm_io_bus *bus, gpa_t addr);
void kvm_io_bus_register_dev(struct kvm_io_bus *bus,
			     struct kvm_io_device *dev);

58
59
struct kvm_vcpu {
	struct kvm *kvm;
60
#ifdef CONFIG_PREEMPT_NOTIFIERS
61
	struct preempt_notifier preempt_notifier;
62
#endif
63
64
65
66
67
68
69
70
71
72
73
74
75
76
	int vcpu_id;
	struct mutex mutex;
	int   cpu;
	struct kvm_run *run;
	int guest_mode;
	unsigned long requests;
	struct kvm_guest_debug guest_debug;
	int fpu_active;
	int guest_fpu_loaded;
	wait_queue_head_t wq;
	int sigset_active;
	sigset_t sigset;
	struct kvm_vcpu_stat stat;

77
#ifdef CONFIG_HAS_IOMEM
78
79
80
81
82
	int mmio_needed;
	int mmio_read_completed;
	int mmio_is_write;
	int mmio_size;
	unsigned char mmio_data[8];
Avi Kivity's avatar
Avi Kivity committed
83
	gpa_t mmio_phys_addr;
84
#endif
Avi Kivity's avatar
Avi Kivity committed
85

86
87
88
	struct kvm_vcpu_arch arch;
};

Avi Kivity's avatar
Avi Kivity committed
89
90
91
92
struct kvm_memory_slot {
	gfn_t base_gfn;
	unsigned long npages;
	unsigned long flags;
93
	unsigned long *rmap;
Avi Kivity's avatar
Avi Kivity committed
94
	unsigned long *dirty_bitmap;
Marcelo Tosatti's avatar
Marcelo Tosatti committed
95
96
97
98
	struct {
		unsigned long rmap_pde;
		int write_count;
	} *lpage_info;
99
	unsigned long userspace_addr;
100
	int user_alloc;
Avi Kivity's avatar
Avi Kivity committed
101
102
103
};

struct kvm {
104
105
	struct mutex lock; /* protects the vcpus array and APIC accesses */
	spinlock_t mmu_lock;
106
	struct rw_semaphore slots_lock;
107
	struct mm_struct *mm; /* userspace tied to this vm */
Avi Kivity's avatar
Avi Kivity committed
108
	int nmemslots;
109
110
	struct kvm_memory_slot memslots[KVM_MEMORY_SLOTS +
					KVM_PRIVATE_MEM_SLOTS];
111
	struct kvm_vcpu *vcpus[KVM_MAX_VCPUS];
112
	struct list_head vm_list;
113
	struct kvm_io_bus mmio_bus;
114
	struct kvm_io_bus pio_bus;
115
	struct kvm_vm_stat stat;
116
	struct kvm_arch arch;
Izik Eidus's avatar
Izik Eidus committed
117
	atomic_t users_count;
Avi Kivity's avatar
Avi Kivity committed
118
119
};

120
121
122
123
124
125
/* The guest did something we don't support. */
#define pr_unimpl(vcpu, fmt, ...)					\
 do {									\
	if (printk_ratelimit())						\
		printk(KERN_ERR "kvm: %i: cpu%i " fmt,			\
		       current->tgid, (vcpu)->vcpu_id , ## __VA_ARGS__); \
Mike Day's avatar
Mike Day committed
126
 } while (0)
127

Avi Kivity's avatar
Avi Kivity committed
128
129
130
#define kvm_printf(kvm, fmt ...) printk(KERN_DEBUG fmt)
#define vcpu_printf(vcpu, fmt...) kvm_printf(vcpu->kvm, fmt)

131
132
133
int kvm_vcpu_init(struct kvm_vcpu *vcpu, struct kvm *kvm, unsigned id);
void kvm_vcpu_uninit(struct kvm_vcpu *vcpu);

134
135
136
void vcpu_load(struct kvm_vcpu *vcpu);
void vcpu_put(struct kvm_vcpu *vcpu);

137
138
void decache_vcpus_on_cpu(int cpu);

139

140
int kvm_init(void *opaque, unsigned int vcpu_size,
141
		  struct module *module);
142
void kvm_exit(void);
Avi Kivity's avatar
Avi Kivity committed
143

Izik Eidus's avatar
Izik Eidus committed
144
145
146
void kvm_get_kvm(struct kvm *kvm);
void kvm_put_kvm(struct kvm *kvm);

Avi Kivity's avatar
Avi Kivity committed
147
148
149
#define HPA_MSB ((sizeof(hpa_t) * 8) - 1)
#define HPA_ERR_MASK ((hpa_t)1 << HPA_MSB)
static inline int is_error_hpa(hpa_t hpa) { return hpa >> HPA_MSB; }
150
struct page *gva_to_page(struct kvm_vcpu *vcpu, gva_t gva);
Avi Kivity's avatar
Avi Kivity committed
151

152
extern struct page *bad_page;
153
extern pfn_t bad_pfn;
Avi Kivity's avatar
Avi Kivity committed
154

155
int is_error_page(struct page *page);
156
int is_error_pfn(pfn_t pfn);
Izik Eidus's avatar
Izik Eidus committed
157
int kvm_is_error_hva(unsigned long addr);
158
159
160
int kvm_set_memory_region(struct kvm *kvm,
			  struct kvm_userspace_memory_region *mem,
			  int user_alloc);
161
162
163
int __kvm_set_memory_region(struct kvm *kvm,
			    struct kvm_userspace_memory_region *mem,
			    int user_alloc);
164
165
166
167
int kvm_arch_set_memory_region(struct kvm *kvm,
				struct kvm_userspace_memory_region *mem,
				struct kvm_memory_slot old,
				int user_alloc);
168
gfn_t unalias_gfn(struct kvm *kvm, gfn_t gfn);
Avi Kivity's avatar
Avi Kivity committed
169
struct page *gfn_to_page(struct kvm *kvm, gfn_t gfn);
Marcelo Tosatti's avatar
Marcelo Tosatti committed
170
unsigned long gfn_to_hva(struct kvm *kvm, gfn_t gfn);
171
172
void kvm_release_page_clean(struct page *page);
void kvm_release_page_dirty(struct page *page);
173
174
175
176
177
178
179
180
181
182
void kvm_set_page_dirty(struct page *page);
void kvm_set_page_accessed(struct page *page);

pfn_t gfn_to_pfn(struct kvm *kvm, gfn_t gfn);
void kvm_release_pfn_dirty(pfn_t);
void kvm_release_pfn_clean(pfn_t pfn);
void kvm_set_pfn_dirty(pfn_t pfn);
void kvm_set_pfn_accessed(pfn_t pfn);
void kvm_get_pfn(pfn_t pfn);

183
184
int kvm_read_guest_page(struct kvm *kvm, gfn_t gfn, void *data, int offset,
			int len);
185
186
int kvm_read_guest_atomic(struct kvm *kvm, gpa_t gpa, void *data,
			  unsigned long len);
187
188
189
190
191
192
193
int kvm_read_guest(struct kvm *kvm, gpa_t gpa, void *data, unsigned long len);
int kvm_write_guest_page(struct kvm *kvm, gfn_t gfn, const void *data,
			 int offset, int len);
int kvm_write_guest(struct kvm *kvm, gpa_t gpa, const void *data,
		    unsigned long len);
int kvm_clear_guest_page(struct kvm *kvm, gfn_t gfn, int offset, int len);
int kvm_clear_guest(struct kvm *kvm, gpa_t gpa, unsigned long len);
Avi Kivity's avatar
Avi Kivity committed
194
struct kvm_memory_slot *gfn_to_memslot(struct kvm *kvm, gfn_t gfn);
195
int kvm_is_visible_gfn(struct kvm *kvm, gfn_t gfn);
Avi Kivity's avatar
Avi Kivity committed
196
197
void mark_page_dirty(struct kvm *kvm, gfn_t gfn);

198
void kvm_vcpu_block(struct kvm_vcpu *vcpu);
Avi Kivity's avatar
Avi Kivity committed
199
void kvm_resched(struct kvm_vcpu *vcpu);
200
201
void kvm_load_guest_fpu(struct kvm_vcpu *vcpu);
void kvm_put_guest_fpu(struct kvm_vcpu *vcpu);
202
void kvm_flush_remote_tlbs(struct kvm *kvm);
203
void kvm_reload_remote_mmus(struct kvm *kvm);
Avi Kivity's avatar
Avi Kivity committed
204

205
206
long kvm_arch_dev_ioctl(struct file *filp,
			unsigned int ioctl, unsigned long arg);
207
208
209
210
long kvm_arch_vcpu_ioctl(struct file *filp,
			 unsigned int ioctl, unsigned long arg);
void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu);
void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu);
211
212
213

int kvm_dev_ioctl_check_extension(long ext);

214
215
216
217
218
int kvm_get_dirty_log(struct kvm *kvm,
			struct kvm_dirty_log *log, int *is_dirty);
int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm,
				struct kvm_dirty_log *log);

219
220
221
222
223
224
225
int kvm_vm_ioctl_set_memory_region(struct kvm *kvm,
				   struct
				   kvm_userspace_memory_region *mem,
				   int user_alloc);
long kvm_arch_vm_ioctl(struct file *filp,
		       unsigned int ioctl, unsigned long arg);
void kvm_arch_destroy_vm(struct kvm *kvm);
226

227
228
229
int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu);
int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu);

230
231
232
int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu,
				    struct kvm_translation *tr);

233
234
235
236
237
238
int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs);
int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs);
int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu,
				  struct kvm_sregs *sregs);
int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu,
				  struct kvm_sregs *sregs);
239
240
241
242
int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu,
				    struct kvm_mp_state *mp_state);
int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu,
				    struct kvm_mp_state *mp_state);
243
244
245
246
int kvm_arch_vcpu_ioctl_debug_guest(struct kvm_vcpu *vcpu,
				    struct kvm_debug_guest *dbg);
int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run);

247
248
int kvm_arch_init(void *opaque);
void kvm_arch_exit(void);
249

250
251
252
253
254
255
256
int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu);
void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu);

void kvm_arch_vcpu_free(struct kvm_vcpu *vcpu);
void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu);
void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu);
struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm, unsigned int id);
257
int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu);
258
void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu);
259
260
261
262
263
264
265

int kvm_arch_vcpu_reset(struct kvm_vcpu *vcpu);
void kvm_arch_hardware_enable(void *garbage);
void kvm_arch_hardware_disable(void *garbage);
int kvm_arch_hardware_setup(void);
void kvm_arch_hardware_unsetup(void);
void kvm_arch_check_processor_compat(void *rtn);
266
int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu);
267

268
269
270
271
void kvm_free_physmem(struct kvm *kvm);

struct  kvm *kvm_arch_create_vm(void);
void kvm_arch_destroy_vm(struct kvm *kvm);
272

273
274
int kvm_cpu_get_interrupt(struct kvm_vcpu *v);
int kvm_cpu_has_interrupt(struct kvm_vcpu *v);
275
int kvm_cpu_has_pending_timer(struct kvm_vcpu *vcpu);
276
void kvm_vcpu_kick(struct kvm_vcpu *vcpu);
277

278
279
static inline void kvm_guest_enter(void)
{
280
	account_system_vtime(current);
281
282
283
284
285
	current->flags |= PF_VCPU;
}

static inline void kvm_guest_exit(void)
{
286
	account_system_vtime(current);
287
288
289
	current->flags &= ~PF_VCPU;
}

Avi Kivity's avatar
Avi Kivity committed
290
291
292
293
294
static inline int memslot_id(struct kvm *kvm, struct kvm_memory_slot *slot)
{
	return slot - kvm->memslots;
}

Avi Kivity's avatar
Avi Kivity committed
295
296
297
298
static inline gpa_t gfn_to_gpa(gfn_t gfn)
{
	return (gpa_t)gfn << PAGE_SHIFT;
}
Avi Kivity's avatar
Avi Kivity committed
299

300
301
302
303
304
static inline void kvm_migrate_apic_timer(struct kvm_vcpu *vcpu)
{
	set_bit(KVM_REQ_MIGRATE_TIMER, &vcpu->requests);
}

305
306
307
308
309
enum kvm_stat_kind {
	KVM_STAT_VM,
	KVM_STAT_VCPU,
};

310
311
312
struct kvm_stats_debugfs_item {
	const char *name;
	int offset;
313
	enum kvm_stat_kind kind;
314
315
316
	struct dentry *dentry;
};
extern struct kvm_stats_debugfs_item debugfs_entries[];
317
extern struct dentry *kvm_debugfs_dir;
318
319
320
321
322
323
324
325
326
327
328
329

#ifdef CONFIG_KVM_TRACE
int kvm_trace_ioctl(unsigned int ioctl, unsigned long arg);
void kvm_trace_cleanup(void);
#else
static inline
int kvm_trace_ioctl(unsigned int ioctl, unsigned long arg)
{
	return -EINVAL;
}
#define kvm_trace_cleanup() ((void)0)
#endif
330

Avi Kivity's avatar
Avi Kivity committed
331
#endif