840f44a096c96645eeb3db70f0a86177beee8a04
[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 #define KVM_PFN_ERR_HWPOISON    (-EHWPOISON)
53
54 /*
55  * vcpu->requests bit members
56  */
57 #define KVM_REQ_TLB_FLUSH          0
58 #define KVM_REQ_MIGRATE_TIMER      1
59 #define KVM_REQ_REPORT_TPR_ACCESS  2
60 #define KVM_REQ_MMU_RELOAD         3
61 #define KVM_REQ_TRIPLE_FAULT       4
62 #define KVM_REQ_PENDING_TIMER      5
63 #define KVM_REQ_UNHALT             6
64 #define KVM_REQ_MMU_SYNC           7
65 #define KVM_REQ_CLOCK_UPDATE       8
66 #define KVM_REQ_KICK               9
67 #define KVM_REQ_DEACTIVATE_FPU    10
68 #define KVM_REQ_EVENT             11
69 #define KVM_REQ_APF_HALT          12
70 #define KVM_REQ_STEAL_UPDATE      13
71 #define KVM_REQ_NMI               14
72 #define KVM_REQ_IMMEDIATE_EXIT    15
73 #define KVM_REQ_PMU               16
74 #define KVM_REQ_PMI               17
75
76 #define KVM_USERSPACE_IRQ_SOURCE_ID     0
77
78 struct kvm;
79 struct kvm_vcpu;
80 extern struct kmem_cache *kvm_vcpu_cache;
81
82 struct kvm_io_range {
83         gpa_t addr;
84         int len;
85         struct kvm_io_device *dev;
86 };
87
88 #define NR_IOBUS_DEVS 1000
89
90 struct kvm_io_bus {
91         int                   dev_count;
92         struct kvm_io_range range[];
93 };
94
95 enum kvm_bus {
96         KVM_MMIO_BUS,
97         KVM_PIO_BUS,
98         KVM_NR_BUSES
99 };
100
101 int kvm_io_bus_write(struct kvm *kvm, enum kvm_bus bus_idx, gpa_t addr,
102                      int len, const void *val);
103 int kvm_io_bus_read(struct kvm *kvm, enum kvm_bus bus_idx, gpa_t addr, int len,
104                     void *val);
105 int kvm_io_bus_register_dev(struct kvm *kvm, enum kvm_bus bus_idx, gpa_t addr,
106                             int len, struct kvm_io_device *dev);
107 int kvm_io_bus_unregister_dev(struct kvm *kvm, enum kvm_bus bus_idx,
108                               struct kvm_io_device *dev);
109
110 #ifdef CONFIG_KVM_ASYNC_PF
111 struct kvm_async_pf {
112         struct work_struct work;
113         struct list_head link;
114         struct list_head queue;
115         struct kvm_vcpu *vcpu;
116         struct mm_struct *mm;
117         gva_t gva;
118         unsigned long addr;
119         struct kvm_arch_async_pf arch;
120         struct page *page;
121         bool done;
122 };
123
124 void kvm_clear_async_pf_completion_queue(struct kvm_vcpu *vcpu);
125 void kvm_check_async_pf_completion(struct kvm_vcpu *vcpu);
126 int kvm_setup_async_pf(struct kvm_vcpu *vcpu, gva_t gva, gfn_t gfn,
127                        struct kvm_arch_async_pf *arch);
128 int kvm_async_pf_wakeup_all(struct kvm_vcpu *vcpu);
129 #endif
130
131 enum {
132         OUTSIDE_GUEST_MODE,
133         IN_GUEST_MODE,
134         EXITING_GUEST_MODE,
135         READING_SHADOW_PAGE_TABLES,
136 };
137
138 /*
139  * Sometimes a large or cross-page mmio needs to be broken up into separate
140  * exits for userspace servicing.
141  */
142 struct kvm_mmio_fragment {
143         gpa_t gpa;
144         void *data;
145         unsigned len;
146 };
147
148 struct kvm_vcpu {
149         struct kvm *kvm;
150 #ifdef CONFIG_PREEMPT_NOTIFIERS
151         struct preempt_notifier preempt_notifier;
152 #endif
153         int cpu;
154         int vcpu_id;
155         int srcu_idx;
156         int mode;
157         unsigned long requests;
158         unsigned long guest_debug;
159
160         struct mutex mutex;
161         struct kvm_run *run;
162
163         int fpu_active;
164         int guest_fpu_loaded, guest_xcr0_loaded;
165         wait_queue_head_t wq;
166         struct pid *pid;
167         int sigset_active;
168         sigset_t sigset;
169         struct kvm_vcpu_stat stat;
170
171 #ifdef CONFIG_HAS_IOMEM
172         int mmio_needed;
173         int mmio_read_completed;
174         int mmio_is_write;
175         int mmio_cur_fragment;
176         int mmio_nr_fragments;
177         struct kvm_mmio_fragment mmio_fragments[KVM_MAX_MMIO_FRAGMENTS];
178 #endif
179
180 #ifdef CONFIG_KVM_ASYNC_PF
181         struct {
182                 u32 queued;
183                 struct list_head queue;
184                 struct list_head done;
185                 spinlock_t lock;
186         } async_pf;
187 #endif
188
189 #ifdef CONFIG_HAVE_KVM_CPU_RELAX_INTERCEPT
190         /*
191          * Cpu relax intercept or pause loop exit optimization
192          * in_spin_loop: set when a vcpu does a pause loop exit
193          *  or cpu relax intercepted.
194          * dy_eligible: indicates whether vcpu is eligible for directed yield.
195          */
196         struct {
197                 bool in_spin_loop;
198                 bool dy_eligible;
199         } spin_loop;
200 #endif
201         struct kvm_vcpu_arch arch;
202 };
203
204 static inline int kvm_vcpu_exiting_guest_mode(struct kvm_vcpu *vcpu)
205 {
206         return cmpxchg(&vcpu->mode, IN_GUEST_MODE, EXITING_GUEST_MODE);
207 }
208
209 /*
210  * Some of the bitops functions do not support too long bitmaps.
211  * This number must be determined not to exceed such limits.
212  */
213 #define KVM_MEM_MAX_NR_PAGES ((1UL << 31) - 1)
214
215 struct kvm_memory_slot {
216         gfn_t base_gfn;
217         unsigned long npages;
218         unsigned long flags;
219         unsigned long *dirty_bitmap;
220         struct kvm_arch_memory_slot arch;
221         unsigned long userspace_addr;
222         int user_alloc;
223         int id;
224 };
225
226 static inline unsigned long kvm_dirty_bitmap_bytes(struct kvm_memory_slot *memslot)
227 {
228         return ALIGN(memslot->npages, BITS_PER_LONG) / 8;
229 }
230
231 struct kvm_kernel_irq_routing_entry {
232         u32 gsi;
233         u32 type;
234         int (*set)(struct kvm_kernel_irq_routing_entry *e,
235                    struct kvm *kvm, int irq_source_id, int level);
236         union {
237                 struct {
238                         unsigned irqchip;
239                         unsigned pin;
240                 } irqchip;
241                 struct msi_msg msi;
242         };
243         struct hlist_node link;
244 };
245
246 #ifdef __KVM_HAVE_IOAPIC
247
248 struct kvm_irq_routing_table {
249         int chip[KVM_NR_IRQCHIPS][KVM_IOAPIC_NUM_PINS];
250         struct kvm_kernel_irq_routing_entry *rt_entries;
251         u32 nr_rt_entries;
252         /*
253          * Array indexed by gsi. Each entry contains list of irq chips
254          * the gsi is connected to.
255          */
256         struct hlist_head map[0];
257 };
258
259 #else
260
261 struct kvm_irq_routing_table {};
262
263 #endif
264
265 #ifndef KVM_MEM_SLOTS_NUM
266 #define KVM_MEM_SLOTS_NUM (KVM_MEMORY_SLOTS + KVM_PRIVATE_MEM_SLOTS)
267 #endif
268
269 /*
270  * Note:
271  * memslots are not sorted by id anymore, please use id_to_memslot()
272  * to get the memslot by its id.
273  */
274 struct kvm_memslots {
275         u64 generation;
276         struct kvm_memory_slot memslots[KVM_MEM_SLOTS_NUM];
277         /* The mapping table from slot id to the index in memslots[]. */
278         int id_to_index[KVM_MEM_SLOTS_NUM];
279 };
280
281 struct kvm {
282         spinlock_t mmu_lock;
283         struct mutex slots_lock;
284         struct mm_struct *mm; /* userspace tied to this vm */
285         struct kvm_memslots *memslots;
286         struct srcu_struct srcu;
287 #ifdef CONFIG_KVM_APIC_ARCHITECTURE
288         u32 bsp_vcpu_id;
289 #endif
290         struct kvm_vcpu *vcpus[KVM_MAX_VCPUS];
291         atomic_t online_vcpus;
292         int last_boosted_vcpu;
293         struct list_head vm_list;
294         struct mutex lock;
295         struct kvm_io_bus *buses[KVM_NR_BUSES];
296 #ifdef CONFIG_HAVE_KVM_EVENTFD
297         struct {
298                 spinlock_t        lock;
299                 struct list_head  items;
300         } irqfds;
301         struct list_head ioeventfds;
302 #endif
303         struct kvm_vm_stat stat;
304         struct kvm_arch arch;
305         atomic_t users_count;
306 #ifdef KVM_COALESCED_MMIO_PAGE_OFFSET
307         struct kvm_coalesced_mmio_ring *coalesced_mmio_ring;
308         spinlock_t ring_lock;
309         struct list_head coalesced_zones;
310 #endif
311
312         struct mutex irq_lock;
313 #ifdef CONFIG_HAVE_KVM_IRQCHIP
314         /*
315          * Update side is protected by irq_lock and,
316          * if configured, irqfds.lock.
317          */
318         struct kvm_irq_routing_table __rcu *irq_routing;
319         struct hlist_head mask_notifier_list;
320         struct hlist_head irq_ack_notifier_list;
321 #endif
322
323 #if defined(CONFIG_MMU_NOTIFIER) && defined(KVM_ARCH_WANT_MMU_NOTIFIER)
324         struct mmu_notifier mmu_notifier;
325         unsigned long mmu_notifier_seq;
326         long mmu_notifier_count;
327 #endif
328         long tlbs_dirty;
329 };
330
331 #define kvm_err(fmt, ...) \
332         pr_err("kvm [%i]: " fmt, task_pid_nr(current), ## __VA_ARGS__)
333 #define kvm_info(fmt, ...) \
334         pr_info("kvm [%i]: " fmt, task_pid_nr(current), ## __VA_ARGS__)
335 #define kvm_debug(fmt, ...) \
336         pr_debug("kvm [%i]: " fmt, task_pid_nr(current), ## __VA_ARGS__)
337 #define kvm_pr_unimpl(fmt, ...) \
338         pr_err_ratelimited("kvm [%i]: " fmt, \
339                            task_tgid_nr(current), ## __VA_ARGS__)
340
341 /* The guest did something we don't support. */
342 #define vcpu_unimpl(vcpu, fmt, ...)                                     \
343         kvm_pr_unimpl("vcpu%i " fmt, (vcpu)->vcpu_id, ## __VA_ARGS__)
344
345 static inline struct kvm_vcpu *kvm_get_vcpu(struct kvm *kvm, int i)
346 {
347         smp_rmb();
348         return kvm->vcpus[i];
349 }
350
351 #define kvm_for_each_vcpu(idx, vcpup, kvm) \
352         for (idx = 0; \
353              idx < atomic_read(&kvm->online_vcpus) && \
354              (vcpup = kvm_get_vcpu(kvm, idx)) != NULL; \
355              idx++)
356
357 #define kvm_for_each_memslot(memslot, slots)    \
358         for (memslot = &slots->memslots[0];     \
359               memslot < slots->memslots + KVM_MEM_SLOTS_NUM && memslot->npages;\
360                 memslot++)
361
362 int kvm_vcpu_init(struct kvm_vcpu *vcpu, struct kvm *kvm, unsigned id);
363 void kvm_vcpu_uninit(struct kvm_vcpu *vcpu);
364
365 void vcpu_load(struct kvm_vcpu *vcpu);
366 void vcpu_put(struct kvm_vcpu *vcpu);
367
368 int kvm_init(void *opaque, unsigned vcpu_size, unsigned vcpu_align,
369                   struct module *module);
370 void kvm_exit(void);
371
372 void kvm_get_kvm(struct kvm *kvm);
373 void kvm_put_kvm(struct kvm *kvm);
374 void update_memslots(struct kvm_memslots *slots, struct kvm_memory_slot *new);
375
376 static inline struct kvm_memslots *kvm_memslots(struct kvm *kvm)
377 {
378         return rcu_dereference_check(kvm->memslots,
379                         srcu_read_lock_held(&kvm->srcu)
380                         || lockdep_is_held(&kvm->slots_lock));
381 }
382
383 static inline struct kvm_memory_slot *
384 id_to_memslot(struct kvm_memslots *slots, int id)
385 {
386         int index = slots->id_to_index[id];
387         struct kvm_memory_slot *slot;
388
389         slot = &slots->memslots[index];
390
391         WARN_ON(slot->id != id);
392         return slot;
393 }
394
395 extern struct page *bad_page;
396
397 int is_error_page(struct page *page);
398 int is_error_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