kvm.h 13.4 KB
Newer Older
Avi Kivity's avatar
Avi Kivity committed
1
2
3
4
5
6
7
8
9
#ifndef __KVM_H
#define __KVM_H

/*
 * 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>
Alexey Dobriyan's avatar
Alexey Dobriyan committed
18
#include <asm/signal.h>
Avi Kivity's avatar
Avi Kivity committed
19
20

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

Avi Kivity's avatar
Avi Kivity committed
23
#define KVM_MAX_VCPUS 4
24
#define KVM_ALIAS_SLOTS 4
Izik Eidus's avatar
Izik Eidus committed
25
#define KVM_MEMORY_SLOTS 8
26
27
/* memory slots that does not exposed to userspace */
#define KVM_PRIVATE_MEM_SLOTS 4
28
29
#define KVM_PERMILLE_MMU_PAGES 20
#define KVM_MIN_ALLOC_MMU_PAGES 64
30
#define KVM_NUM_MMU_PAGES 1024
Avi Kivity's avatar
Avi Kivity committed
31
32
#define KVM_MIN_FREE_MMU_PAGES 5
#define KVM_REFILL_PAGES 25
33
#define KVM_MAX_CPUID_ENTRIES 40
Avi Kivity's avatar
Avi Kivity committed
34

35
36
#define KVM_PIO_PAGE_OFFSET 1

37
38
39
/*
 * vcpu->requests bit members
 */
40
#define KVM_REQ_TLB_FLUSH          0
41

Avi Kivity's avatar
Avi Kivity committed
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
/*
 * Address types:
 *
 *  gva - guest virtual address
 *  gpa - guest physical address
 *  gfn - guest frame number
 *  hva - host virtual address
 *  hpa - host physical address
 *  hfn - host frame number
 */

typedef unsigned long  gva_t;
typedef u64            gpa_t;
typedef unsigned long  gfn_t;

typedef unsigned long  hva_t;
typedef u64            hpa_t;
typedef unsigned long  hfn_t;

61
62
63
64
65
66
67
68
69
70
71
72
73
74
#define NR_PTE_CHAIN_ENTRIES 5

struct kvm_pte_chain {
	u64 *parent_ptes[NR_PTE_CHAIN_ENTRIES];
	struct hlist_node link;
};

/*
 * kvm_mmu_page_role, below, is defined as:
 *
 *   bits 0:3 - total guest paging levels (2-4, or zero for real mode)
 *   bits 4:7 - page table level for this shadow (1-4)
 *   bits 8:9 - page table quadrant for 2-level guests
 *   bit   16 - "metaphysical" - gfn is not a real page (huge page/real mode)
75
 *   bits 17:19 - "access" - the user, writable, and nx bits of a huge page pde
76
77
78
79
80
81
82
83
84
 */
union kvm_mmu_page_role {
	unsigned word;
	struct {
		unsigned glevels : 4;
		unsigned level : 4;
		unsigned quadrant : 2;
		unsigned pad_for_nice_hex_output : 6;
		unsigned metaphysical : 1;
85
		unsigned hugepage_access : 3;
86
87
88
	};
};

Avi Kivity's avatar
Avi Kivity committed
89
90
struct kvm_mmu_page {
	struct list_head link;
91
92
93
94
95
96
97
98
99
	struct hlist_node hash_link;

	/*
	 * The following two entries are used to key the shadow page in the
	 * hash table.
	 */
	gfn_t gfn;
	union kvm_mmu_page_role role;

100
	u64 *spt;
101
102
	/* hold the gfn of each spte inside spt */
	gfn_t *gfns;
Avi Kivity's avatar
Avi Kivity committed
103
104
105
	unsigned long slot_bitmap; /* One bit set per slot which has memory
				    * in this shadow page.
				    */
106
	int multimapped;         /* More than one parent_pte? */
107
	int root_count;          /* Currently serving as active root */
108
109
110
111
	union {
		u64 *parent_pte;               /* !multimapped */
		struct hlist_head parent_ptes; /* multimapped, kvm_pte_chain */
	};
Avi Kivity's avatar
Avi Kivity committed
112
113
114
};

struct kvm_vcpu;
115
extern struct kmem_cache *kvm_vcpu_cache;
Avi Kivity's avatar
Avi Kivity committed
116
117
118
119
120
121
122
123
124
125
126

/*
 * x86 supports 3 paging modes (4-level 64-bit, 3-level 64-bit, and 2-level
 * 32-bit).  The kvm_mmu structure abstracts the details of the current mmu
 * mode.
 */
struct kvm_mmu {
	void (*new_cr3)(struct kvm_vcpu *vcpu);
	int (*page_fault)(struct kvm_vcpu *vcpu, gva_t gva, u32 err);
	void (*free)(struct kvm_vcpu *vcpu);
	gpa_t (*gva_to_gpa)(struct kvm_vcpu *vcpu, gva_t gva);
127
128
	void (*prefetch_page)(struct kvm_vcpu *vcpu,
			      struct kvm_mmu_page *page);
Avi Kivity's avatar
Avi Kivity committed
129
130
131
	hpa_t root_hpa;
	int root_level;
	int shadow_root_level;
132
133

	u64 *pae_root;
Avi Kivity's avatar
Avi Kivity committed
134
135
};

136
#define KVM_NR_MEM_OBJS 40
137

Hollis Blanchard's avatar
Hollis Blanchard committed
138
139
140
141
/*
 * We don't want allocation failures within the mmu code, so we preallocate
 * enough memory for a single page fault in a cache.
 */
142
143
144
145
146
struct kvm_mmu_memory_cache {
	int nobjs;
	void *objects[KVM_NR_MEM_OBJS];
};

Avi Kivity's avatar
Avi Kivity committed
147
148
149
150
151
152
struct kvm_guest_debug {
	int enabled;
	unsigned long bp[4];
	int singlestep;
};

153
154
155
156
157
158
struct kvm_pio_request {
	unsigned long count;
	int cur_count;
	struct page *guest_pages[2];
	unsigned guest_page_offset;
	int in;
159
	int port;
160
161
162
163
164
165
	int size;
	int string;
	int down;
	int rep;
};

166
struct kvm_vcpu_stat {
Avi Kivity's avatar
Avi Kivity committed
167
168
169
170
171
172
173
174
175
176
177
	u32 pf_fixed;
	u32 pf_guest;
	u32 tlb_flush;
	u32 invlpg;

	u32 exits;
	u32 io_exits;
	u32 mmio_exits;
	u32 signal_exits;
	u32 irq_window_exits;
	u32 halt_exits;
Eddie Dong's avatar
Eddie Dong committed
178
	u32 halt_wakeup;
Avi Kivity's avatar
Avi Kivity committed
179
180
	u32 request_irq_exits;
	u32 irq_exits;
181
	u32 host_state_reload;
182
	u32 efer_reload;
Avi Kivity's avatar
Avi Kivity committed
183
	u32 fpu_reload;
184
185
	u32 insn_emulation;
	u32 insn_emulation_fail;
Avi Kivity's avatar
Avi Kivity committed
186
187
};

188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
struct kvm_io_device {
	void (*read)(struct kvm_io_device *this,
		     gpa_t addr,
		     int len,
		     void *val);
	void (*write)(struct kvm_io_device *this,
		      gpa_t addr,
		      int len,
		      const void *val);
	int (*in_range)(struct kvm_io_device *this, gpa_t addr);
	void (*destructor)(struct kvm_io_device *this);

	void             *private;
};

static inline void kvm_iodevice_read(struct kvm_io_device *dev,
				     gpa_t addr,
				     int len,
				     void *val)
{
	dev->read(dev, addr, len, val);
}

static inline void kvm_iodevice_write(struct kvm_io_device *dev,
				      gpa_t addr,
				      int len,
				      const void *val)
{
	dev->write(dev, addr, len, val);
}

static inline int kvm_iodevice_inrange(struct kvm_io_device *dev, gpa_t addr)
{
	return dev->in_range(dev, addr);
}

static inline void kvm_iodevice_destructor(struct kvm_io_device *dev)
{
226
227
	if (dev->destructor)
		dev->destructor(dev);
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
}

/*
 * 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);

248
249
250
251
252
253
254
#ifdef CONFIG_HAS_IOMEM
#define KVM_VCPU_MMIO 			\
	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
255
256
	gpa_t mmio_phys_addr;

257
258
#else
#define KVM_VCPU_MMIO
Avi Kivity's avatar
Avi Kivity committed
259

260
#endif
Avi Kivity's avatar
Avi Kivity committed
261

262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
#define KVM_VCPU_COMM 					\
	struct kvm *kvm; 				\
	struct preempt_notifier preempt_notifier;	\
	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;				\
277
	struct kvm_vcpu_stat stat;			\
278
	KVM_VCPU_MMIO
Avi Kivity's avatar
Avi Kivity committed
279

280
281
282
283
284
285
struct kvm_mem_alias {
	gfn_t base_gfn;
	unsigned long npages;
	gfn_t target_gfn;
};

Avi Kivity's avatar
Avi Kivity committed
286
287
288
289
struct kvm_memory_slot {
	gfn_t base_gfn;
	unsigned long npages;
	unsigned long flags;
290
	unsigned long *rmap;
Avi Kivity's avatar
Avi Kivity committed
291
	unsigned long *dirty_bitmap;
292
	unsigned long userspace_addr;
293
	int user_alloc;
Avi Kivity's avatar
Avi Kivity committed
294
295
};

296
struct kvm_vm_stat {
Avi Kivity's avatar
Avi Kivity committed
297
298
299
300
301
302
	u32 mmu_shadow_zapped;
	u32 mmu_pte_write;
	u32 mmu_pte_updated;
	u32 mmu_pde_zapped;
	u32 mmu_flooded;
	u32 mmu_recycled;
303
	u32 remote_tlb_flush;
304
305
};

Avi Kivity's avatar
Avi Kivity committed
306
struct kvm {
Shaohua Li's avatar
Shaohua Li committed
307
	struct mutex lock; /* protects everything except vcpus */
308
309
	int naliases;
	struct kvm_mem_alias aliases[KVM_ALIAS_SLOTS];
Avi Kivity's avatar
Avi Kivity committed
310
	int nmemslots;
311
312
	struct kvm_memory_slot memslots[KVM_MEMORY_SLOTS +
					KVM_PRIVATE_MEM_SLOTS];
313
314
315
	/*
	 * Hash table of struct kvm_mmu_page.
	 */
Avi Kivity's avatar
Avi Kivity committed
316
	struct list_head active_mmu_pages;
317
318
319
	unsigned int n_free_mmu_pages;
	unsigned int n_requested_mmu_pages;
	unsigned int n_alloc_mmu_pages;
320
	struct hlist_head mmu_page_hash[KVM_NUM_MMU_PAGES];
321
	struct kvm_vcpu *vcpus[KVM_MAX_VCPUS];
322
	struct list_head vm_list;
Avi Kivity's avatar
Avi Kivity committed
323
	struct file *filp;
324
	struct kvm_io_bus mmio_bus;
325
	struct kvm_io_bus pio_bus;
326
	struct kvm_pic *vpic;
Eddie Dong's avatar
Eddie Dong committed
327
	struct kvm_ioapic *vioapic;
328
	int round_robin_prev_vcpu;
329
	unsigned int tss_addr;
330
	struct page *apic_access_page;
331
	struct kvm_vm_stat stat;
Avi Kivity's avatar
Avi Kivity committed
332
333
};

334
335
336
337
338
static inline struct kvm_pic *pic_irqchip(struct kvm *kvm)
{
	return kvm->vpic;
}

Eddie Dong's avatar
Eddie Dong committed
339
340
341
342
343
static inline struct kvm_ioapic *ioapic_irqchip(struct kvm *kvm)
{
	return kvm->vioapic;
}

344
345
static inline int irqchip_in_kernel(struct kvm *kvm)
{
Joe Perches's avatar
Joe Perches committed
346
	return pic_irqchip(kvm) != NULL;
347
348
}

Avi Kivity's avatar
Avi Kivity committed
349
350
351
352
353
struct descriptor_table {
	u16 limit;
	unsigned long base;
} __attribute__((packed));

354
355
356
357
358
359
/* 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
360
 } while (0)
361

Avi Kivity's avatar
Avi Kivity committed
362
363
364
#define kvm_printf(kvm, fmt ...) printk(KERN_DEBUG fmt)
#define vcpu_printf(vcpu, fmt...) kvm_printf(vcpu->kvm, fmt)

365
366
367
int kvm_vcpu_init(struct kvm_vcpu *vcpu, struct kvm *kvm, unsigned id);
void kvm_vcpu_uninit(struct kvm_vcpu *vcpu);

368
369
370
void vcpu_load(struct kvm_vcpu *vcpu);
void vcpu_put(struct kvm_vcpu *vcpu);

371
372
void decache_vcpus_on_cpu(int cpu);

373

374
int kvm_init(void *opaque, unsigned int vcpu_size,
375
		  struct module *module);
376
void kvm_exit(void);
Avi Kivity's avatar
Avi Kivity committed
377

378
hpa_t gpa_to_hpa(struct kvm *kvm, gpa_t gpa);
Avi Kivity's avatar
Avi Kivity committed
379
380
381
382
#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; }
hpa_t gva_to_hpa(struct kvm_vcpu *vcpu, gva_t gva);
383
struct page *gva_to_page(struct kvm_vcpu *vcpu, gva_t gva);
Avi Kivity's avatar
Avi Kivity committed
384

385
extern struct page *bad_page;
Avi Kivity's avatar
Avi Kivity committed
386

387
int is_error_page(struct page *page);
Izik Eidus's avatar
Izik Eidus committed
388
int kvm_is_error_hva(unsigned long addr);
389
390
391
int kvm_set_memory_region(struct kvm *kvm,
			  struct kvm_userspace_memory_region *mem,
			  int user_alloc);
392
393
394
int __kvm_set_memory_region(struct kvm *kvm,
			    struct kvm_userspace_memory_region *mem,
			    int user_alloc);
395
396
397
398
int kvm_arch_set_memory_region(struct kvm *kvm,
				struct kvm_userspace_memory_region *mem,
				struct kvm_memory_slot old,
				int user_alloc);
399
gfn_t unalias_gfn(struct kvm *kvm, gfn_t gfn);
Avi Kivity's avatar
Avi Kivity committed
400
struct page *gfn_to_page(struct kvm *kvm, gfn_t gfn);
401
402
void kvm_release_page_clean(struct page *page);
void kvm_release_page_dirty(struct page *page);
403
404
405
406
407
408
409
410
411
int kvm_read_guest_page(struct kvm *kvm, gfn_t gfn, void *data, int offset,
			int len);
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
412
struct kvm_memory_slot *gfn_to_memslot(struct kvm *kvm, gfn_t gfn);
413
int kvm_is_visible_gfn(struct kvm *kvm, gfn_t gfn);
Avi Kivity's avatar
Avi Kivity committed
414
415
void mark_page_dirty(struct kvm *kvm, gfn_t gfn);

416
void kvm_vcpu_block(struct kvm_vcpu *vcpu);
Avi Kivity's avatar
Avi Kivity committed
417
void kvm_resched(struct kvm_vcpu *vcpu);
418
419
void kvm_load_guest_fpu(struct kvm_vcpu *vcpu);
void kvm_put_guest_fpu(struct kvm_vcpu *vcpu);
420
void kvm_flush_remote_tlbs(struct kvm *kvm);
Avi Kivity's avatar
Avi Kivity committed
421

422
423
long kvm_arch_dev_ioctl(struct file *filp,
			unsigned int ioctl, unsigned long arg);
424
425
426
427
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);
428
429
430

int kvm_dev_ioctl_check_extension(long ext);

431
432
433
434
435
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);

436
437
438
439
440
441
442
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);
443

444
445
446
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);

447
448
449
int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu,
				    struct kvm_translation *tr);

450
451
452
453
454
455
456
457
458
459
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);
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);

460
461
int kvm_arch_init(void *opaque);
void kvm_arch_exit(void);
462

463
464
465
466
467
468
469
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);
470
int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu);
471
void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu);
472
473
474
475
476
477
478
479

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);

480
481
482
483
void kvm_free_physmem(struct kvm *kvm);

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

485
486
static inline void kvm_guest_enter(void)
{
487
	account_system_vtime(current);
488
489
490
491
492
	current->flags |= PF_VCPU;
}

static inline void kvm_guest_exit(void)
{
493
	account_system_vtime(current);
494
495
496
	current->flags &= ~PF_VCPU;
}

Avi Kivity's avatar
Avi Kivity committed
497
498
499
500
501
static inline int memslot_id(struct kvm *kvm, struct kvm_memory_slot *slot)
{
	return slot - kvm->memslots;
}

Avi Kivity's avatar
Avi Kivity committed
502
503
504
505
static inline gpa_t gfn_to_gpa(gfn_t gfn)
{
	return (gpa_t)gfn << PAGE_SHIFT;
}
Avi Kivity's avatar
Avi Kivity committed
506

507
508
509
510
511
enum kvm_stat_kind {
	KVM_STAT_VM,
	KVM_STAT_VCPU,
};

512
513
514
struct kvm_stats_debugfs_item {
	const char *name;
	int offset;
515
	enum kvm_stat_kind kind;
516
517
518
519
	struct dentry *dentry;
};
extern struct kvm_stats_debugfs_item debugfs_entries[];

Avi Kivity's avatar
Avi Kivity committed
520
#endif