ef5554f47486934077f07039a88ccfd5dd8fef16
[linux-3.10.git] / include / linux / kvm_host.h
1 #ifndef __KVM_HOST_H
2 #define __KVM_HOST_H
3
4 /*
5  * This work is licensed under the terms of the GNU GPL, version 2.  See
6  * the COPYING file in the top-level directory.
7  */
8
9 #include <linux/types.h>
10 #include <linux/hardirq.h>
11 #include <linux/list.h>
12 #include <linux/mutex.h>
13 #include <linux/spinlock.h>
14 #include <linux/signal.h>
15 #include <linux/sched.h>
16 #include <linux/bug.h>
17 #include <linux/mm.h>
18 #include <linux/mmu_notifier.h>
19 #include <linux/preempt.h>
20 #include <linux/msi.h>
21 #include <linux/slab.h>
22 #include <linux/rcupdate.h>
23 #include <linux/ratelimit.h>
24 #include <asm/signal.h>
25
26 #include <linux/kvm.h>
27 #include <linux/kvm_para.h>
28
29 #include <linux/kvm_types.h>
30
31 #include <asm/kvm_host.h>
32
33 #ifndef KVM_MMIO_SIZE
34 #define KVM_MMIO_SIZE 8
35 #endif
36
37 /*
38  * If we support unaligned MMIO, at most one fragment will be split into two:
39  */
40 #ifdef KVM_UNALIGNED_MMIO
41 #  define KVM_EXTRA_MMIO_FRAGMENTS 1
42 #else
43 #  define KVM_EXTRA_MMIO_FRAGMENTS 0
44 #endif
45
46 #define KVM_USER_MMIO_SIZE 8
47
48 #define KVM_MAX_MMIO_FRAGMENTS \
49         (KVM_MMIO_SIZE / KVM_USER_MMIO_SIZE + KVM_EXTRA_MMIO_FRAGMENTS)
50
51 #define KVM_PFN_ERR_FAULT       (-EFAULT)
52
53 /*
54  * vcpu->requests bit members
55  */
56 #define KVM_REQ_TLB_FLUSH          0
57 #define KVM_REQ_MIGRATE_TIMER      1
58 #define KVM_REQ_REPORT_TPR_ACCESS  2
59 #define KVM_REQ_MMU_RELOAD         3
60 #define KVM_REQ_TRIPLE_FAULT       4
61 #define KVM_REQ_PENDING_TIMER      5
62 #define KVM_REQ_UNHALT             6
63 #define KVM_REQ_MMU_SYNC           7
64 #define KVM_REQ_CLOCK_UPDATE       8
65 #define KVM_REQ_KICK               9
66 #define KVM_REQ_DEACTIVATE_FPU    10
67 #define KVM_REQ_EVENT             11
68 #define KVM_REQ_APF_HALT          12
69 #define KVM_REQ_STEAL_UPDATE      13
70 #define KVM_REQ_NMI               14
71 #define KVM_REQ_IMMEDIATE_EXIT    15
72 #define KVM_REQ_PMU               16
73 #define KVM_REQ_PMI               17
74
75 #define KVM_USERSPACE_IRQ_SOURCE_ID     0
76
77 struct kvm;
78 struct kvm_vcpu;
79 extern struct kmem_cache *kvm_vcpu_cache;
80
81 struct kvm_io_range {
82         gpa_t addr;
83         int len;
84         struct kvm_io_device *dev;
85 };
86
87 #define NR_IOBUS_DEVS 1000
88
89 struct kvm_io_bus {
90         int                   dev_count;
91         struct kvm_io_range range[];
92 };
93
94 enum kvm_bus {
95         KVM_MMIO_BUS,
96         KVM_PIO_BUS,
97         KVM_NR_BUSES
98 };
99
100 int kvm_io_bus_write(struct kvm *kvm, enum kvm_bus bus_idx, gpa_t addr,
101                      int len, const void *val);
102 int kvm_io_bus_read(struct kvm *kvm, enum kvm_bus bus_idx, gpa_t addr, int len,
103                     void *val);
104 int kvm_io_bus_register_dev(struct kvm *kvm, enum kvm_bus bus_idx, gpa_t addr,
105                             int len, struct kvm_io_device *dev);
106 int kvm_io_bus_unregister_dev(struct kvm *kvm, enum kvm_bus bus_idx,
107                               struct kvm_io_device *dev);
108
109 #ifdef CONFIG_KVM_ASYNC_PF
110 struct kvm_async_pf {
111         struct work_struct work;
112         struct list_head link;
113         struct list_head queue;
114         struct kvm_vcpu *vcpu;
115         struct mm_struct *mm;
116         gva_t gva;
117         unsigned long addr;
118         struct kvm_arch_async_pf arch;
119         struct page *page;
120         bool done;
121 };
122
123 void kvm_clear_async_pf_completion_queue(struct kvm_vcpu *vcpu);
124 void kvm_check_async_pf_completion(struct kvm_vcpu *vcpu);
125 int kvm_setup_async_pf(struct kvm_vcpu *vcpu, gva_t gva, gfn_t gfn,
126                        struct kvm_arch_async_pf *arch);
127 int kvm_async_pf_wakeup_all(struct kvm_vcpu *vcpu);
128 #endif
129
130 enum {
131         OUTSIDE_GUEST_MODE,
132         IN_GUEST_MODE,
133         EXITING_GUEST_MODE,
134         READING_SHADOW_PAGE_TABLES,
135 };
136
137 /*
138  * Sometimes a large or cross-page mmio needs to be broken up into separate
139  * exits for userspace servicing.
140  */
141 struct kvm_mmio_fragment {
142         gpa_t gpa;
143         void *data;
144         unsigned len;
145 };
146
147 struct kvm_vcpu {
148         struct kvm *kvm;
149 #ifdef CONFIG_PREEMPT_NOTIFIERS
150         struct preempt_notifier preempt_notifier;
151 #endif
152         int cpu;
153         int vcpu_id;
154         int srcu_idx;
155         int mode;
156         unsigned long requests;
157         unsigned long guest_debug;
158
159         struct mutex mutex;
160         struct kvm_run *run;
161
162         int fpu_active;
163         int guest_fpu_loaded, guest_xcr0_loaded;
164         wait_queue_head_t wq;
165         struct pid *pid;
166         int sigset_active;
167         sigset_t sigset;
168         struct kvm_vcpu_stat stat;
169
170 #ifdef CONFIG_HAS_IOMEM
171         int mmio_needed;
172         int mmio_read_completed;
173         int mmio_is_write;
174         int mmio_cur_fragment;
175         int mmio_nr_fragments;
176         struct kvm_mmio_fragment mmio_fragments[KVM_MAX_MMIO_FRAGMENTS];
177 #endif
178
179 #ifdef CONFIG_KVM_ASYNC_PF
180         struct {
181                 u32 queued;
182                 struct list_head queue;
183                 struct list_head done;
184                 spinlock_t lock;
185         } async_pf;
186 #endif
187
188 #ifdef CONFIG_HAVE_KVM_CPU_RELAX_INTERCEPT
189         /*
190          * Cpu relax intercept or pause loop exit optimization
191          * in_spin_loop: set when a vcpu does a pause loop exit
192          *  or cpu relax intercepted.
193          * dy_eligible: indicates whether vcpu is eligible for directed yield.
194          */
195         struct {
196                 bool in_spin_loop;
197                 bool dy_eligible;
198         } spin_loop;
199 #endif
200         struct kvm_vcpu_arch arch;
201 };
202
203 static inline int kvm_vcpu_exiting_guest_mode(struct kvm_vcpu *vcpu)
204 {
205         return cmpxchg(&vcpu->mode, IN_GUEST_MODE, EXITING_GUEST_MODE);
206 }
207
208 /*
209  * Some of the bitops functions do not support too long bitmaps.
210  * This number must be determined not to exceed such limits.
211  */
212 #define KVM_MEM_MAX_NR_PAGES ((1UL << 31) - 1)
213
214 struct kvm_memory_slot {
215         gfn_t base_gfn;
216         unsigned long npages;
217         unsigned long flags;
218         unsigned long *dirty_bitmap;
219         struct kvm_arch_memory_slot arch;
220         unsigned long userspace_addr;
221         int user_alloc;
222         int id;
223 };
224
225 static inline unsigned long kvm_dirty_bitmap_bytes(struct kvm_memory_slot *memslot)
226 {
227         return ALIGN(memslot->npages, BITS_PER_LONG) / 8;
228 }
229
230 struct kvm_kernel_irq_routing_entry {
231         u32 gsi;
232         u32 type;
233         int (*set)(struct kvm_kernel_irq_routing_entry *e,
234                    struct kvm *kvm, int irq_source_id, int level);
235         union {
236                 struct {
237                         unsigned irqchip;
238                         unsigned pin;
239                 } irqchip;
240                 struct msi_msg msi;
241         };
242         struct hlist_node link;
243 };
244
245 #ifdef __KVM_HAVE_IOAPIC
246
247 struct kvm_irq_routing_table {
248         int chip[KVM_NR_IRQCHIPS][KVM_IOAPIC_NUM_PINS];
249         struct kvm_kernel_irq_routing_entry *rt_entries;
250         u32 nr_rt_entries;
251         /*
252          * Array indexed by gsi. Each entry contains list of irq chips
253          * the gsi is connected to.
254          */
255         struct hlist_head map[0];
256 };
257
258 #else
259
260 struct kvm_irq_routing_table {};
261
262 #endif
263
264 #ifndef KVM_MEM_SLOTS_NUM
265 #define KVM_MEM_SLOTS_NUM (KVM_MEMORY_SLOTS + KVM_PRIVATE_MEM_SLOTS)
266 #endif
267
268 /*
269  * Note:
270  * memslots are not sorted by id anymore, please use id_to_memslot()
271  * to get the memslot by its id.
272  */
273 struct kvm_memslots {
274         u64 generation;
275         struct kvm_memory_slot memslots[KVM_MEM_SLOTS_NUM];
276         /* The mapping table from slot id to the index in memslots[]. */
277         int id_to_index[KVM_MEM_SLOTS_NUM];
278 };
279
280 struct kvm {
281         spinlock_t mmu_lock;
282         struct mutex slots_lock;
283         struct mm_struct *mm; /* userspace tied to this vm */
284         struct kvm_memslots *memslots;
285         struct srcu_struct srcu;
286 #ifdef CONFIG_KVM_APIC_ARCHITECTURE
287         u32 bsp_vcpu_id;
288 #endif
289         struct kvm_vcpu *vcpus[KVM_MAX_VCPUS];
290         atomic_t online_vcpus;
291         int last_boosted_vcpu;
292         struct list_head vm_list;
293         struct mutex lock;
294         struct kvm_io_bus *buses[KVM_NR_BUSES];
295 #ifdef CONFIG_HAVE_KVM_EVENTFD
296         struct {
297                 spinlock_t        lock;
298                 struct list_head  items;
299         } irqfds;
300         struct list_head ioeventfds;
301 #endif
302         struct kvm_vm_stat stat;
303         struct kvm_arch arch;
304         atomic_t users_count;
305 #ifdef KVM_COALESCED_MMIO_PAGE_OFFSET
306         struct kvm_coalesced_mmio_ring *coalesced_mmio_ring;
307         spinlock_t ring_lock;
308         struct list_head coalesced_zones;
309 #endif
310
311         struct mutex irq_lock;
312 #ifdef CONFIG_HAVE_KVM_IRQCHIP
313         /*
314          * Update side is protected by irq_lock and,
315          * if configured, irqfds.lock.
316          */
317         struct kvm_irq_routing_table __rcu *irq_routing;
318         struct hlist_head mask_notifier_list;
319         struct hlist_head irq_ack_notifier_list;
320 #endif
321
322 #if defined(CONFIG_MMU_NOTIFIER) && defined(KVM_ARCH_WANT_MMU_NOTIFIER)
323         struct mmu_notifier mmu_notifier;
324         unsigned long mmu_notifier_seq;
325         long mmu_notifier_count;
326 #endif
327         long tlbs_dirty;
328 };
329
330 #define kvm_err(fmt, ...) \
331         pr_err("kvm [%i]: " fmt, task_pid_nr(current), ## __VA_ARGS__)
332 #define kvm_info(fmt, ...) \
333         pr_info("kvm [%i]: " fmt, task_pid_nr(current), ## __VA_ARGS__)
334 #define kvm_debug(fmt, ...) \
335         pr_debug("kvm [%i]: " fmt, task_pid_nr(current), ## __VA_ARGS__)
336 #define kvm_pr_unimpl(fmt, ...) \
337         pr_err_ratelimited("kvm [%i]: " fmt, \
338                            task_tgid_nr(current), ## __VA_ARGS__)
339
340 /* The guest did something we don't support. */
341 #define vcpu_unimpl(vcpu, fmt, ...)                                     \
342         kvm_pr_unimpl("vcpu%i " fmt, (vcpu)->vcpu_id, ## __VA_ARGS__)
343
344 static inline struct kvm_vcpu *kvm_get_vcpu(struct kvm *kvm, int i)
345 {
346         smp_rmb();
347         return kvm->vcpus[i];
348 }
349
350 #define kvm_for_each_vcpu(idx, vcpup, kvm) \
351         for (idx = 0; \
352              idx < atomic_read(&kvm->online_vcpus) && \
353              (vcpup = kvm_get_vcpu(kvm, idx)) != NULL; \
354              idx++)
355
356 #define kvm_for_each_memslot(memslot, slots)    \
357         for (memslot = &slots->memslots[0];     \
358               memslot < slots->memslots + KVM_MEM_SLOTS_NUM && memslot->npages;\
359                 memslot++)
360
361 int kvm_vcpu_init(struct kvm_vcpu *vcpu, struct kvm *kvm, unsigned id);
362 void kvm_vcpu_uninit(struct kvm_vcpu *vcpu);
363
364 void vcpu_load(struct kvm_vcpu *vcpu);
365 void vcpu_put(struct kvm_vcpu *vcpu);
366
367 int kvm_init(void *opaque, unsigned vcpu_size, unsigned vcpu_align,
368                   struct module *module);
369 void kvm_exit(void);
370
371 void kvm_get_kvm(struct kvm *kvm);
372 void kvm_put_kvm(struct kvm *kvm);
373 void update_memslots(struct kvm_memslots *slots, struct kvm_memory_slot *new);
374
375 static inline struct kvm_memslots *kvm_memslots(struct kvm *kvm)
376 {
377         return rcu_dereference_check(kvm->memslots,
378                         srcu_read_lock_held(&kvm->srcu)
379                         || lockdep_is_held(&kvm->slots_lock));
380 }
381
382 static inline struct kvm_memory_slot *
383 id_to_memslot(struct kvm_memslots *slots, int id)
384 {
385         int index = slots->id_to_index[id];
386         struct kvm_memory_slot *slot;
387
388         slot = &slots->memslots[index];
389
390         WARN_ON(slot->id != id);
391         return slot;
392 }
393
394 extern struct page *bad_page;
395
396 int is_error_page(struct page *page);
397 int is_error_pfn(pfn_t pfn);
398 int is_hwpoison_pfn(pfn_t pfn);
399 int is_noslot_pfn(pfn_t pfn);
400 int is_invalid_pfn(pfn_t pfn);
401 int kvm_is_error_hva(unsigned long addr);
402 int kvm_set_memory_region(struct kvm *kvm,
403                           struct kvm_userspace_memory_region *mem,
404                           int user_alloc);
405 int __kvm_set_memory_region(struct kvm *kvm,
406                             struct kvm_userspace_memory_region *mem,
407                             int user_alloc);
408 void kvm_arch_free_memslot(struct kvm_memory_slot *free,
409                            struct kvm_memory_slot *dont);
410 int kvm_arch_create_memslot(struct kvm_memory_slot *slot, unsigned long npages);
411 int kvm_arch_prepare_memory_region(struct kvm *kvm,
412                                 struct kvm_memory_slot *memslot,
413                                 struct kvm_memory_slot old,
414                                 struct kvm_userspace_memory_region *mem,
415                                 int user_alloc);
416 void kvm_arch_commit_memory_region(struct kvm *kvm,
417                                 struct kvm_userspace_memory_region *mem,
418                                 struct kvm_memory_slot old,
419                                 int user_alloc);
420 bool kvm_largepages_enabled(void);
421 void kvm_disable_largepages(void);
422 void kvm_arch_flush_shadow(struct kvm *kvm);
423
424 int gfn_to_page_many_atomic(struct kvm *kvm, gfn_t gfn, struct page **pages,
425                             int nr_pages);
426
427 struct page *get_bad_page(void);
428 struct page *gfn_to_page(struct kvm *kvm, gfn_t gfn);
429 unsigned long gfn_to_hva(struct kvm *kvm, gfn_t gfn);
430 void kvm_release_page_clean(struct page *page);
431 void kvm_release_page_dirty(struct page *page);
432 void kvm_set_page_dirty(struct page *page);
433 void kvm_set_page_accessed(struct page *page);
434
435 pfn_t hva_to_pfn_atomic(unsigned long addr);
436 pfn_t gfn_to_pfn_atomic(struct kvm *kvm, gfn_t gfn);
437 pfn_t gfn_to_pfn_async(struct kvm *kvm, gfn_t gfn, bool *async,
438                        bool write_fault, bool *writable);
439 pfn_t gfn_to_pfn(struct kvm *kvm, gfn_t gfn);
440 pfn_t gfn_to_pfn_prot(struct kvm *kvm, gfn_t gfn, bool write_fault,
441                       bool *writable);
442 pfn_t gfn_to_pfn_memslot(struct kvm_memory_slot *slot, gfn_t gfn);
443 void kvm_release_pfn_dirty(pfn_t);
444 void kvm_release_pfn_clean(pfn_t pfn);
445 void kvm_set_pfn_dirty(pfn_t pfn);
446 void kvm_set_pfn_accessed(pfn_t pfn);
447 void kvm_get_pfn(pfn_t pfn);
448
449 int kvm_read_guest_page(struct kvm *kvm, gfn_t gfn, void *data, int offset,
450                         int len);
451 int kvm_read_guest_atomic(struct kvm *kvm, gpa_t gpa, void *data,
452                           unsigned long len);
453 int kvm_read_guest(struct kvm *kvm, gpa_t gpa, void *data, unsigned long len);
454 int kvm_read_guest_cached(struct kvm *kvm, struct gfn_to_hva_cache *ghc,
455                            void *data, unsigned long len);
456 int kvm_write_guest_page(struct kvm *kvm, gfn_t gfn, const void *data,
457                          int offset, int len);
458 int kvm_write_guest(struct kvm *kvm, gpa_t gpa, const void *data,
459                     unsigned long len);
460 int kvm_write_guest_cached(struct kvm *kvm, struct gfn_to_hva_cache *ghc,
461                            void *data, unsigned long len);
462 int kvm_gfn_to_hva_cache_init(struct kvm *kvm, struct gfn_to_hva_cache *ghc,
463                               gpa_t gpa);
464 int kvm_clear_guest_page(struct kvm *kvm, gfn_t gfn, int offset, int len);
465 int kvm_clear_guest(struct kvm *kvm, gpa_t gpa, unsigned long len);
466 struct kvm_memory_slot *gfn_to_memslot(struct kvm *kvm, gfn_t gfn);
467 int kvm_is_visible_gfn(struct kvm *kvm, gfn_t gfn);
468 unsigned long kvm_host_page_size(struct kvm *kvm, gfn_t gfn);
469 void mark_page_dirty(struct kvm *kvm, gfn_t gfn);
470 void mark_page_dirty_in_slot(struct kvm *kvm, struct kvm_memory_slot *memslot,
471                              gfn_t gfn);
472
473 void kvm_vcpu_block(struct kvm_vcpu *vcpu);
474 void kvm_vcpu_kick(struct kvm_vcpu *vcpu);
475 bool kvm_vcpu_yield_to(struct kvm_vcpu *target);
476 void kvm_vcpu_on_spin(struct kvm_vcpu *vcpu);
477 void kvm_resched(struct kvm_vcpu *vcpu);
478 void kvm_load_guest_fpu(struct kvm_vcpu *vcpu);
479 void kvm_put_guest_fpu(struct kvm_vcpu *vcpu);
480
481 void kvm_flush_remote_tlbs(struct kvm *kvm);
482 void kvm_reload_remote_mmus(struct kvm *kvm);
483
484 long kvm_arch_dev_ioctl(struct file *filp,
485                         unsigned int ioctl, unsigned long arg);
486 long kvm_arch_vcpu_ioctl(struct file *filp,
487                          unsigned int ioctl, unsigned long arg);
488 int kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf);
489
490 int kvm_dev_ioctl_check_extension(long ext);
491
492 int kvm_get_dirty_log(struct kvm *kvm,
493                         struct kvm_dirty_log *log, int *is_dirty);
494 int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm,
495                                 struct kvm_dirty_log *log);
496
497 int kvm_vm_ioctl_set_memory_region(struct kvm *kvm,
498                                    struct
499                                    kvm_userspace_memory_region *mem,
500                                    int user_alloc);
501 int kvm_vm_ioctl_irq_line(struct kvm *kvm, struct kvm_irq_level *irq_level);
502 long kvm_arch_vm_ioctl(struct file *filp,
503                        unsigned int ioctl, unsigned long arg);
504
505 int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu);
506 int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu);
507
508 int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu,
509                                     struct kvm_translation *tr);
510
511 int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs);
512 int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs);
513 int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu,
514                                   struct kvm_sregs *sregs);
515 int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu,
516                                   struct kvm_sregs *sregs);
517 int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu,
518                                     struct kvm_mp_state *mp_state);
519 int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu,
520                                     struct kvm_mp_state *mp_state);
521 int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu,
522                                         struct kvm_guest_debug *dbg);
523 int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run);
524
525 int kvm_arch_init(void *opaque);
526 void kvm_arch_exit(void);
527
528 int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu);
529 void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu);
530
531 void kvm_arch_vcpu_free(struct kvm_vcpu *vcpu);
532 void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu);
533 void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu);
534 struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm, unsigned int id);
535 int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu);
536 void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu);
537
538 int kvm_arch_vcpu_reset(struct kvm_vcpu *vcpu);
539 int kvm_arch_hardware_enable(void *garbage);
540 void kvm_arch_hardware_disable(void *garbage);
541 int kvm_arch_hardware_setup(void);
542 void kvm_arch_hardware_unsetup(void);
543 void kvm_arch_check_processor_compat(void *rtn);
544 int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu);
545 int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu);
546
547 void kvm_free_physmem(struct kvm *kvm);
548
549 void *kvm_kvzalloc(unsigned long size);
550 void kvm_kvfree(const void *addr);
551
552 #ifndef __KVM_HAVE_ARCH_VM_ALLOC
553 static inline struct kvm *kvm_arch_alloc_vm(void)
554 {
555         return kzalloc(sizeof(struct kvm), GFP_KERNEL);
556 }
557
558 static inline void kvm_arch_free_vm(struct kvm *kvm)
559 {
560         kfree(kvm);
561 }
562 #endif
563
564 static inline wait_queue_head_t *kvm_arch_vcpu_wq(struct kvm_vcpu *vcpu)
565 {
566 #ifdef __KVM_HAVE_ARCH_WQP
567         return vcpu->arch.wqp;
568 #else
569         return &vcpu->wq;
570 #endif
571 }
572
573 int kvm_arch_init_vm(struct kvm *kvm, unsigned long type);
574 void kvm_arch_destroy_vm(struct kvm *kvm);
575 void kvm_free_all_assigned_devices(struct kvm *kvm);
576 void kvm_arch_sync_events(struct kvm *kvm);
577
578 int kvm_cpu_has_pending_timer(struct kvm_vcpu *vcpu);
579 void kvm_vcpu_kick(struct kvm_vcpu *vcpu);
580
581 bool kvm_is_mmio_pfn(pfn_t pfn);
582
583 struct kvm_irq_ack_notifier {
584         struct hlist_node link;
585         unsigned gsi;
586         void (*irq_acked)(struct kvm_irq_ack_notifier *kian);
587 };
588
589 struct kvm_assigned_dev_kernel {
590         struct kvm_irq_ack_notifier ack_notifier;
591         struct list_head list;
592         int assigned_dev_id;
593         int host_segnr;
594         int host_busnr;
595         int host_devfn;
596         unsigned int entries_nr;
597         int host_irq;
598         bool host_irq_disabled;
599         bool pci_2_3;
600         struct msix_entry *host_msix_entries;
601         int guest_irq;
602         struct msix_entry *guest_msix_entries;
603         unsigned long irq_requested_type;
604         int irq_source_id;
605         int flags;
606         struct pci_dev *dev;
607         struct kvm *kvm;
608         spinlock_t intx_lock;
609         spinlock_t intx_mask_lock;
610         char irq_name[32];
611         struct pci_saved_state *pci_saved_state;
612 };
613
614 struct kvm_irq_mask_notifier {
615         void (*func)(struct kvm_irq_mask_notifier *kimn, bool masked);
616         int irq;
617         struct hlist_node link;
618 };
619
620 void kvm_register_irq_mask_notifier(struct kvm *kvm, int irq,
621                                     struct kvm_irq_mask_notifier *kimn);
622 void kvm_unregister_irq_mask_notifier(struct kvm *kvm, int irq,
623                                       struct kvm_irq_mask_notifier *kimn);
624 void kvm_fire_mask_notifiers(struct kvm *kvm, unsigned irqchip, unsigned pin,
625                              bool mask);
626
627 #ifdef __KVM_HAVE_IOAPIC
628 void kvm_get_intr_delivery_bitmask(struct kvm_ioapic *ioapic,
629                                    union kvm_ioapic_redirect_entry *entry,
630                                    unsigned long *deliver_bitmask);
631 #endif
632 int kvm_set_irq(struct kvm *kvm, int irq_source_id, u32 irq, int level);
633 int kvm_set_msi(struct kvm_kernel_irq_routing_entry *irq_entry, struct kvm *kvm,
634                 int irq_source_id, int level);
635 void kvm_notify_acked_irq(struct kvm *kvm, unsigned irqchip, unsigned pin);
636 void kvm_register_irq_ack_notifier(struct kvm *kvm,
637                                    struct kvm_irq_ack_notifier *kian);
638 void kvm_unregister_irq_ack_notifier(struct kvm *kvm,
639                                    struct kvm_irq_ack_notifier *kian);
640 int kvm_request_irq_source_id(struct kvm *kvm);
641 void kvm_free_irq_source_id(struct kvm *kvm, int irq_source_id);
642
643 /* For vcpu->arch.iommu_flags */
644 #define KVM_IOMMU_CACHE_COHERENCY       0x1
645
646 #ifdef CONFIG_IOMMU_API
647 int kvm_iommu_map_pages(struct kvm *kvm, struct kvm_memory_slot *slot);
648 void kvm_iommu_unmap_pages(struct kvm *kvm, struct kvm_memory_slot *slot);
649 int kvm_iommu_map_guest(struct kvm *kvm);
650 int kvm_iommu_unmap_guest(struct kvm *kvm);
651 int kvm_assign_device(struct kvm *kvm,
652                       struct kvm_assigned_dev_kernel *assigned_dev);
653 int kvm_deassign_device(struct kvm *kvm,
654                         struct kvm_assigned_dev_kernel *assigned_dev);
655 #else /* CONFIG_IOMMU_API */
656 static inline int kvm_iommu_map_pages(struct kvm *kvm,
657                                       struct kvm_memory_slot *slot)
658 {
659         return 0;
660 }
661
662 static inline void kvm_iommu_unmap_pages(struct kvm *kvm,
663                                          struct kvm_memory_slot *slot)
664 {
665 }
666
667 static inline int kvm_iommu_map_guest(struct kvm *kvm)
668 {
669         return -ENODEV;
670 }
671
672 static inline int kvm_iommu_unmap_guest(struct kvm *kvm)
673 {
674         return 0;
675 }
676
677 static inline int kvm_assign_device(struct kvm *kvm,
678                 struct kvm_assigned_dev_kernel *assigned_dev)
679 {
680         return 0;
681 }
682
683 static inline int kvm_deassign_device(struct kvm *kvm,
684                 struct kvm_assigned_dev_kernel *assigned_dev)
685 {
686         return 0;
687 }
688 #endif /* CONFIG_IOMMU_API */
689
690 static inline void kvm_guest_enter(void)
691 {
692         BUG_ON(preemptible());
693         account_system_vtime(current);
694         current->flags |= PF_VCPU;
695         /* KVM does not hold any references to rcu protected data when it
696          * switches CPU into a guest mode. In fact switching to a guest mode
697          * is very similar to exiting to userspase from rcu point of view. In
698          * addition CPU may stay in a guest mode for quite a long time (up to
699          * one time slice). Lets treat guest mode as quiescent state, just like
700          * we do with user-mode execution.
701          */
702         rcu_virt_note_context_switch(smp_processor_id());
703 }
704
705 static inline void kvm_guest_exit(void)
706 {
707         account_system_vtime(current);
708         current->flags &= ~PF_VCPU;
709 }
710
711 /*
712  * search_memslots() and __gfn_to_memslot() are here because they are
713  * used in non-modular code in arch/powerpc/kvm/book3s_hv_rm_mmu.c.
714  * gfn_to_memslot() itself isn't here as an inline because that would
715  * bloat other code too much.
716  */
717 static inline struct kvm_memory_slot *
718 search_memslots(struct kvm_memslots *slots, gfn_t gfn)
719 {
720         struct kvm_memory_slot *memslot;
721
722         kvm_for_each_memslot(memslot, slots)
723                 if (gfn >= memslot->base_gfn &&
724                       gfn < memslot->base_gfn + memslot->npages)
725                         return memslot;
726
727         return NULL;
728 }
729
730 static inline struct kvm_memory_slot *
731 __gfn_to_memslot(struct kvm_memslots *slots, gfn_t gfn)
732 {
733         return search_memslots(slots, gfn);
734 }
735
736 static inline int memslot_id(struct kvm *kvm, gfn_t gfn)
737 {
738         return gfn_to_memslot(kvm, gfn)->id;
739 }
740
741 static inline gfn_t gfn_to_index(gfn_t gfn, gfn_t base_gfn, int level)
742 {
743         /* KVM_HPAGE_GFN_SHIFT(PT_PAGE_TABLE_LEVEL) must be 0. */
744         return (gfn >> KVM_HPAGE_GFN_SHIFT(level)) -
745                 (base_gfn >> KVM_HPAGE_GFN_SHIFT(level));
746 }
747
748 static inline gfn_t
749 hva_to_gfn_memslot(unsigned long hva, struct kvm_memory_slot *slot)
750 {
751         gfn_t gfn_offset = (hva - slot->userspace_addr) >> PAGE_SHIFT;
752
753         return slot->base_gfn + gfn_offset;
754 }
755
756 static inline unsigned long gfn_to_hva_memslot(struct kvm_memory_slot *slot,
757                                                gfn_t gfn)
758 {
759         return slot->userspace_addr + (gfn - slot->base_gfn) * PAGE_SIZE;
760 }
761
762 static inline gpa_t gfn_to_gpa(gfn_t gfn)
763 {
764         return (gpa_t)gfn << PAGE_SHIFT;
765 }
766
767 static inline gfn_t gpa_to_gfn(gpa_t gpa)
768 {
769         return (gfn_t)(gpa >> PAGE_SHIFT);
770 }
771
772 static inline hpa_t pfn_to_hpa(pfn_t pfn)
773 {
774         return (hpa_t)pfn << PAGE_SHIFT;
775 }
776
777 static inline void kvm_migrate_timers(struct kvm_vcpu *vcpu)
778 {
779         set_bit(KVM_REQ_MIGRATE_TIMER, &vcpu->requests);
780 }
781
782 enum kvm_stat_kind {
783         KVM_STAT_VM,
784         KVM_STAT_VCPU,
785 };
786
787 struct kvm_stats_debugfs_item {
788         const char *name;
789         int offset;
790         enum kvm_stat_kind kind;
791         struct dentry *dentry;
792 };
793 extern struct kvm_stats_debugfs_item debugfs_entries[];
794 extern struct dentry *kvm_debugfs_dir;
795
796 #if defined(CONFIG_MMU_NOTIFIER) && defined(KVM_ARCH_WANT_MMU_NOTIFIER)
797 static inline int mmu_notifier_retry(struct kvm_vcpu *vcpu, unsigned long mmu_seq)
798 {
799         if (unlikely(vcpu->kvm->mmu_notifier_count))
800                 return 1;
801         /*
802          * Ensure the read of mmu_notifier_count happens before the read
803          * of mmu_notifier_seq.  This interacts with the smp_wmb() in
804          * mmu_notifier_invalidate_range_end to make sure that the caller
805          * either sees the old (non-zero) value of mmu_notifier_count or
806          * the new (incremented) value of mmu_notifier_seq.
807          * PowerPC Book3s HV KVM calls this under a per-page lock
808          * rather than under kvm->mmu_lock, for scalability, so
809          * can't rely on kvm->mmu_lock to keep things ordered.
810          */
811         smp_rmb();
812         if (vcpu->kvm->mmu_notifier_seq != mmu_seq)
813                 return 1;
814         return 0;
815 }
816 #endif
817
818 #ifdef KVM_CAP_IRQ_ROUTING
819
820 #define KVM_MAX_IRQ_ROUTES 1024
821
822 int kvm_setup_default_irq_routing(struct kvm *kvm);
823 int kvm_set_irq_routing(struct kvm *kvm,
824                         const struct kvm_irq_routing_entry *entries,
825                         unsigned nr,
826                         unsigned flags);
827 void kvm_free_irq_routing(struct kvm *kvm);
828
829 int kvm_send_userspace_msi(struct kvm *kvm, struct kvm_msi *msi);
830
831 #else
832
833 static inline void kvm_free_irq_routing(struct kvm *kvm) {}
834
835 #endif
836
837 #ifdef CONFIG_HAVE_KVM_EVENTFD
838
839 void kvm_eventfd_init(struct kvm *kvm);
840 int kvm_irqfd(struct kvm *kvm, struct kvm_irqfd *args);
841 void kvm_irqfd_release(struct kvm *kvm);
842 void kvm_irq_routing_update(struct kvm *, struct kvm_irq_routing_table *);
843 int kvm_ioeventfd(struct kvm *kvm, struct kvm_ioeventfd *args);
844
845 #else
846
847 static inline void kvm_eventfd_init(struct kvm *kvm) {}
848
849 static inline int kvm_irqfd(struct kvm *kvm, struct kvm_irqfd *args)
850 {
851         return -EINVAL;
852 }
853
854 static inline void kvm_irqfd_release(struct kvm *kvm) {}
855
856 #ifdef CONFIG_HAVE_KVM_IRQCHIP
857 static inline void kvm_irq_routing_update(struct kvm *kvm,
858                                           struct kvm_irq_routing_table *irq_rt)
859 {
860         rcu_assign_pointer(kvm->irq_routing, irq_rt);
861 }
862 #endif
863
864 static inline int kvm_ioeventfd(struct kvm *kvm, struct kvm_ioeventfd *args)
865 {
866         return -ENOSYS;
867 }
868
869 #endif /* CONFIG_HAVE_KVM_EVENTFD */
870
871 #ifdef CONFIG_KVM_APIC_ARCHITECTURE
872 static inline bool kvm_vcpu_is_bsp(struct kvm_vcpu *vcpu)
873 {
874         return vcpu->kvm->bsp_vcpu_id == vcpu->vcpu_id;
875 }
876
877 bool kvm_vcpu_compatible(struct kvm_vcpu *vcpu);
878
879 #else
880
881 static inline bool kvm_vcpu_compatible(struct kvm_vcpu *vcpu) { return true; }
882
883 #endif
884
885 #ifdef __KVM_HAVE_DEVICE_ASSIGNMENT
886
887 long kvm_vm_ioctl_assigned_device(struct kvm *kvm, unsigned ioctl,
888                                   unsigned long arg);
889
890 #else
891
892 static inline long kvm_vm_ioctl_assigned_device(struct kvm *kvm, unsigned ioctl,
893                                                 unsigned long arg)
894 {
895         return -ENOTTY;
896 }
897
898 #endif
899
900 static inline void kvm_make_request(int req, struct kvm_vcpu *vcpu)
901 {
902         set_bit(req, &vcpu->requests);
903 }
904
905 static inline bool kvm_check_request(int req, struct kvm_vcpu *vcpu)
906 {
907         if (test_bit(req, &vcpu->requests)) {
908                 clear_bit(req, &vcpu->requests);
909                 return true;
910         } else {
911                 return false;
912         }
913 }
914
915 #ifdef CONFIG_HAVE_KVM_CPU_RELAX_INTERCEPT
916
917 static inline void kvm_vcpu_set_in_spin_loop(struct kvm_vcpu *vcpu, bool val)
918 {
919         vcpu->spin_loop.in_spin_loop = val;
920 }
921 static inline void kvm_vcpu_set_dy_eligible(struct kvm_vcpu *vcpu, bool val)
922 {
923         vcpu->spin_loop.dy_eligible = val;
924 }
925
926 #else /* !CONFIG_HAVE_KVM_CPU_RELAX_INTERCEPT */
927
928 static inline void kvm_vcpu_set_in_spin_loop(struct kvm_vcpu *vcpu, bool val)
929 {
930 }
931
932 static inline void kvm_vcpu_set_dy_eligible(struct kvm_vcpu *vcpu, bool val)
933 {
934 }
935
936 static inline bool kvm_vcpu_eligible_for_directed_yield(struct kvm_vcpu *vcpu)
937 {
938         return true;
939 }
940
941 #endif /* CONFIG_HAVE_KVM_CPU_RELAX_INTERCEPT */
942 #endif
943