kvm_host.h 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810
  1. #ifndef __KVM_HOST_H
  2. #define __KVM_HOST_H
  3. /*
  4. * This work is licensed under the terms of the GNU GPL, version 2. See
  5. * the COPYING file in the top-level directory.
  6. */
  7. #include <linux/types.h>
  8. #include <linux/hardirq.h>
  9. #include <linux/list.h>
  10. #include <linux/mutex.h>
  11. #include <linux/spinlock.h>
  12. #include <linux/signal.h>
  13. #include <linux/sched.h>
  14. #include <linux/mm.h>
  15. #include <linux/mmu_notifier.h>
  16. #include <linux/preempt.h>
  17. #include <linux/msi.h>
  18. #include <linux/slab.h>
  19. #include <linux/rcupdate.h>
  20. #include <linux/ratelimit.h>
  21. #include <asm/signal.h>
  22. #include <linux/kvm.h>
  23. #include <linux/kvm_para.h>
  24. #include <linux/kvm_types.h>
  25. #include <asm/kvm_host.h>
  26. #ifndef KVM_MMIO_SIZE
  27. #define KVM_MMIO_SIZE 8
  28. #endif
  29. /*
  30. * vcpu->requests bit members
  31. */
  32. #define KVM_REQ_TLB_FLUSH 0
  33. #define KVM_REQ_MIGRATE_TIMER 1
  34. #define KVM_REQ_REPORT_TPR_ACCESS 2
  35. #define KVM_REQ_MMU_RELOAD 3
  36. #define KVM_REQ_TRIPLE_FAULT 4
  37. #define KVM_REQ_PENDING_TIMER 5
  38. #define KVM_REQ_UNHALT 6
  39. #define KVM_REQ_MMU_SYNC 7
  40. #define KVM_REQ_CLOCK_UPDATE 8
  41. #define KVM_REQ_KICK 9
  42. #define KVM_REQ_DEACTIVATE_FPU 10
  43. #define KVM_REQ_EVENT 11
  44. #define KVM_REQ_APF_HALT 12
  45. #define KVM_REQ_STEAL_UPDATE 13
  46. #define KVM_REQ_NMI 14
  47. #define KVM_REQ_IMMEDIATE_EXIT 15
  48. #define KVM_REQ_PMU 16
  49. #define KVM_REQ_PMI 17
  50. #define KVM_USERSPACE_IRQ_SOURCE_ID 0
  51. struct kvm;
  52. struct kvm_vcpu;
  53. extern struct kmem_cache *kvm_vcpu_cache;
  54. struct kvm_io_range {
  55. gpa_t addr;
  56. int len;
  57. struct kvm_io_device *dev;
  58. };
  59. struct kvm_io_bus {
  60. int dev_count;
  61. #define NR_IOBUS_DEVS 300
  62. struct kvm_io_range range[NR_IOBUS_DEVS];
  63. };
  64. enum kvm_bus {
  65. KVM_MMIO_BUS,
  66. KVM_PIO_BUS,
  67. KVM_NR_BUSES
  68. };
  69. int kvm_io_bus_write(struct kvm *kvm, enum kvm_bus bus_idx, gpa_t addr,
  70. int len, const void *val);
  71. int kvm_io_bus_read(struct kvm *kvm, enum kvm_bus bus_idx, gpa_t addr, int len,
  72. void *val);
  73. int kvm_io_bus_register_dev(struct kvm *kvm, enum kvm_bus bus_idx, gpa_t addr,
  74. int len, struct kvm_io_device *dev);
  75. int kvm_io_bus_unregister_dev(struct kvm *kvm, enum kvm_bus bus_idx,
  76. struct kvm_io_device *dev);
  77. #ifdef CONFIG_KVM_ASYNC_PF
  78. struct kvm_async_pf {
  79. struct work_struct work;
  80. struct list_head link;
  81. struct list_head queue;
  82. struct kvm_vcpu *vcpu;
  83. struct mm_struct *mm;
  84. gva_t gva;
  85. unsigned long addr;
  86. struct kvm_arch_async_pf arch;
  87. struct page *page;
  88. bool done;
  89. };
  90. void kvm_clear_async_pf_completion_queue(struct kvm_vcpu *vcpu);
  91. void kvm_check_async_pf_completion(struct kvm_vcpu *vcpu);
  92. int kvm_setup_async_pf(struct kvm_vcpu *vcpu, gva_t gva, gfn_t gfn,
  93. struct kvm_arch_async_pf *arch);
  94. int kvm_async_pf_wakeup_all(struct kvm_vcpu *vcpu);
  95. #endif
  96. enum {
  97. OUTSIDE_GUEST_MODE,
  98. IN_GUEST_MODE,
  99. EXITING_GUEST_MODE
  100. };
  101. struct kvm_vcpu {
  102. struct kvm *kvm;
  103. #ifdef CONFIG_PREEMPT_NOTIFIERS
  104. struct preempt_notifier preempt_notifier;
  105. #endif
  106. int cpu;
  107. int vcpu_id;
  108. int srcu_idx;
  109. int mode;
  110. unsigned long requests;
  111. unsigned long guest_debug;
  112. struct mutex mutex;
  113. struct kvm_run *run;
  114. int fpu_active;
  115. int guest_fpu_loaded, guest_xcr0_loaded;
  116. wait_queue_head_t wq;
  117. struct pid *pid;
  118. int sigset_active;
  119. sigset_t sigset;
  120. struct kvm_vcpu_stat stat;
  121. #ifdef CONFIG_HAS_IOMEM
  122. int mmio_needed;
  123. int mmio_read_completed;
  124. int mmio_is_write;
  125. int mmio_size;
  126. int mmio_index;
  127. unsigned char mmio_data[KVM_MMIO_SIZE];
  128. gpa_t mmio_phys_addr;
  129. #endif
  130. #ifdef CONFIG_KVM_ASYNC_PF
  131. struct {
  132. u32 queued;
  133. struct list_head queue;
  134. struct list_head done;
  135. spinlock_t lock;
  136. } async_pf;
  137. #endif
  138. struct kvm_vcpu_arch arch;
  139. };
  140. static inline int kvm_vcpu_exiting_guest_mode(struct kvm_vcpu *vcpu)
  141. {
  142. return cmpxchg(&vcpu->mode, IN_GUEST_MODE, EXITING_GUEST_MODE);
  143. }
  144. /*
  145. * Some of the bitops functions do not support too long bitmaps.
  146. * This number must be determined not to exceed such limits.
  147. */
  148. #define KVM_MEM_MAX_NR_PAGES ((1UL << 31) - 1)
  149. struct kvm_lpage_info {
  150. unsigned long rmap_pde;
  151. int write_count;
  152. };
  153. struct kvm_memory_slot {
  154. gfn_t base_gfn;
  155. unsigned long npages;
  156. unsigned long flags;
  157. unsigned long *rmap;
  158. unsigned long *dirty_bitmap;
  159. unsigned long *dirty_bitmap_head;
  160. unsigned long nr_dirty_pages;
  161. struct kvm_lpage_info *lpage_info[KVM_NR_PAGE_SIZES - 1];
  162. unsigned long userspace_addr;
  163. int user_alloc;
  164. int id;
  165. };
  166. static inline unsigned long kvm_dirty_bitmap_bytes(struct kvm_memory_slot *memslot)
  167. {
  168. return ALIGN(memslot->npages, BITS_PER_LONG) / 8;
  169. }
  170. struct kvm_kernel_irq_routing_entry {
  171. u32 gsi;
  172. u32 type;
  173. int (*set)(struct kvm_kernel_irq_routing_entry *e,
  174. struct kvm *kvm, int irq_source_id, int level);
  175. union {
  176. struct {
  177. unsigned irqchip;
  178. unsigned pin;
  179. } irqchip;
  180. struct msi_msg msi;
  181. };
  182. struct hlist_node link;
  183. };
  184. #ifdef __KVM_HAVE_IOAPIC
  185. struct kvm_irq_routing_table {
  186. int chip[KVM_NR_IRQCHIPS][KVM_IOAPIC_NUM_PINS];
  187. struct kvm_kernel_irq_routing_entry *rt_entries;
  188. u32 nr_rt_entries;
  189. /*
  190. * Array indexed by gsi. Each entry contains list of irq chips
  191. * the gsi is connected to.
  192. */
  193. struct hlist_head map[0];
  194. };
  195. #else
  196. struct kvm_irq_routing_table {};
  197. #endif
  198. #ifndef KVM_MEM_SLOTS_NUM
  199. #define KVM_MEM_SLOTS_NUM (KVM_MEMORY_SLOTS + KVM_PRIVATE_MEM_SLOTS)
  200. #endif
  201. /*
  202. * Note:
  203. * memslots are not sorted by id anymore, please use id_to_memslot()
  204. * to get the memslot by its id.
  205. */
  206. struct kvm_memslots {
  207. u64 generation;
  208. struct kvm_memory_slot memslots[KVM_MEM_SLOTS_NUM];
  209. /* The mapping table from slot id to the index in memslots[]. */
  210. int id_to_index[KVM_MEM_SLOTS_NUM];
  211. };
  212. struct kvm {
  213. spinlock_t mmu_lock;
  214. struct mutex slots_lock;
  215. struct mm_struct *mm; /* userspace tied to this vm */
  216. struct kvm_memslots *memslots;
  217. struct srcu_struct srcu;
  218. #ifdef CONFIG_KVM_APIC_ARCHITECTURE
  219. u32 bsp_vcpu_id;
  220. #endif
  221. struct kvm_vcpu *vcpus[KVM_MAX_VCPUS];
  222. atomic_t online_vcpus;
  223. int last_boosted_vcpu;
  224. struct list_head vm_list;
  225. struct mutex lock;
  226. struct kvm_io_bus *buses[KVM_NR_BUSES];
  227. #ifdef CONFIG_HAVE_KVM_EVENTFD
  228. struct {
  229. spinlock_t lock;
  230. struct list_head items;
  231. } irqfds;
  232. struct list_head ioeventfds;
  233. #endif
  234. struct kvm_vm_stat stat;
  235. struct kvm_arch arch;
  236. atomic_t users_count;
  237. #ifdef KVM_COALESCED_MMIO_PAGE_OFFSET
  238. struct kvm_coalesced_mmio_ring *coalesced_mmio_ring;
  239. spinlock_t ring_lock;
  240. struct list_head coalesced_zones;
  241. #endif
  242. struct mutex irq_lock;
  243. #ifdef CONFIG_HAVE_KVM_IRQCHIP
  244. /*
  245. * Update side is protected by irq_lock and,
  246. * if configured, irqfds.lock.
  247. */
  248. struct kvm_irq_routing_table __rcu *irq_routing;
  249. struct hlist_head mask_notifier_list;
  250. struct hlist_head irq_ack_notifier_list;
  251. #endif
  252. #ifdef KVM_ARCH_WANT_MMU_NOTIFIER
  253. struct mmu_notifier mmu_notifier;
  254. unsigned long mmu_notifier_seq;
  255. long mmu_notifier_count;
  256. #endif
  257. long tlbs_dirty;
  258. };
  259. /* The guest did something we don't support. */
  260. #define pr_unimpl(vcpu, fmt, ...) \
  261. pr_err_ratelimited("kvm: %i: cpu%i " fmt, \
  262. current->tgid, (vcpu)->vcpu_id , ## __VA_ARGS__)
  263. #define kvm_printf(kvm, fmt ...) printk(KERN_DEBUG fmt)
  264. #define vcpu_printf(vcpu, fmt...) kvm_printf(vcpu->kvm, fmt)
  265. static inline struct kvm_vcpu *kvm_get_vcpu(struct kvm *kvm, int i)
  266. {
  267. smp_rmb();
  268. return kvm->vcpus[i];
  269. }
  270. #define kvm_for_each_vcpu(idx, vcpup, kvm) \
  271. for (idx = 0; \
  272. idx < atomic_read(&kvm->online_vcpus) && \
  273. (vcpup = kvm_get_vcpu(kvm, idx)) != NULL; \
  274. idx++)
  275. #define kvm_for_each_memslot(memslot, slots) \
  276. for (memslot = &slots->memslots[0]; \
  277. memslot < slots->memslots + KVM_MEM_SLOTS_NUM && memslot->npages;\
  278. memslot++)
  279. int kvm_vcpu_init(struct kvm_vcpu *vcpu, struct kvm *kvm, unsigned id);
  280. void kvm_vcpu_uninit(struct kvm_vcpu *vcpu);
  281. void vcpu_load(struct kvm_vcpu *vcpu);
  282. void vcpu_put(struct kvm_vcpu *vcpu);
  283. int kvm_init(void *opaque, unsigned vcpu_size, unsigned vcpu_align,
  284. struct module *module);
  285. void kvm_exit(void);
  286. void kvm_get_kvm(struct kvm *kvm);
  287. void kvm_put_kvm(struct kvm *kvm);
  288. void update_memslots(struct kvm_memslots *slots, struct kvm_memory_slot *new);
  289. static inline struct kvm_memslots *kvm_memslots(struct kvm *kvm)
  290. {
  291. return rcu_dereference_check(kvm->memslots,
  292. srcu_read_lock_held(&kvm->srcu)
  293. || lockdep_is_held(&kvm->slots_lock));
  294. }
  295. static inline struct kvm_memory_slot *
  296. id_to_memslot(struct kvm_memslots *slots, int id)
  297. {
  298. int index = slots->id_to_index[id];
  299. struct kvm_memory_slot *slot;
  300. slot = &slots->memslots[index];
  301. WARN_ON(slot->id != id);
  302. return slot;
  303. }
  304. #define HPA_MSB ((sizeof(hpa_t) * 8) - 1)
  305. #define HPA_ERR_MASK ((hpa_t)1 << HPA_MSB)
  306. static inline int is_error_hpa(hpa_t hpa) { return hpa >> HPA_MSB; }
  307. extern struct page *bad_page;
  308. extern struct page *fault_page;
  309. extern pfn_t bad_pfn;
  310. extern pfn_t fault_pfn;
  311. int is_error_page(struct page *page);
  312. int is_error_pfn(pfn_t pfn);
  313. int is_hwpoison_pfn(pfn_t pfn);
  314. int is_fault_pfn(pfn_t pfn);
  315. int is_noslot_pfn(pfn_t pfn);
  316. int is_invalid_pfn(pfn_t pfn);
  317. int kvm_is_error_hva(unsigned long addr);
  318. int kvm_set_memory_region(struct kvm *kvm,
  319. struct kvm_userspace_memory_region *mem,
  320. int user_alloc);
  321. int __kvm_set_memory_region(struct kvm *kvm,
  322. struct kvm_userspace_memory_region *mem,
  323. int user_alloc);
  324. int kvm_arch_prepare_memory_region(struct kvm *kvm,
  325. struct kvm_memory_slot *memslot,
  326. struct kvm_memory_slot old,
  327. struct kvm_userspace_memory_region *mem,
  328. int user_alloc);
  329. void kvm_arch_commit_memory_region(struct kvm *kvm,
  330. struct kvm_userspace_memory_region *mem,
  331. struct kvm_memory_slot old,
  332. int user_alloc);
  333. void kvm_disable_largepages(void);
  334. void kvm_arch_flush_shadow(struct kvm *kvm);
  335. int gfn_to_page_many_atomic(struct kvm *kvm, gfn_t gfn, struct page **pages,
  336. int nr_pages);
  337. struct page *gfn_to_page(struct kvm *kvm, gfn_t gfn);
  338. unsigned long gfn_to_hva(struct kvm *kvm, gfn_t gfn);
  339. void kvm_release_page_clean(struct page *page);
  340. void kvm_release_page_dirty(struct page *page);
  341. void kvm_set_page_dirty(struct page *page);
  342. void kvm_set_page_accessed(struct page *page);
  343. pfn_t hva_to_pfn_atomic(struct kvm *kvm, unsigned long addr);
  344. pfn_t gfn_to_pfn_atomic(struct kvm *kvm, gfn_t gfn);
  345. pfn_t gfn_to_pfn_async(struct kvm *kvm, gfn_t gfn, bool *async,
  346. bool write_fault, bool *writable);
  347. pfn_t gfn_to_pfn(struct kvm *kvm, gfn_t gfn);
  348. pfn_t gfn_to_pfn_prot(struct kvm *kvm, gfn_t gfn, bool write_fault,
  349. bool *writable);
  350. pfn_t gfn_to_pfn_memslot(struct kvm *kvm,
  351. struct kvm_memory_slot *slot, gfn_t gfn);
  352. void kvm_release_pfn_dirty(pfn_t);
  353. void kvm_release_pfn_clean(pfn_t pfn);
  354. void kvm_set_pfn_dirty(pfn_t pfn);
  355. void kvm_set_pfn_accessed(pfn_t pfn);
  356. void kvm_get_pfn(pfn_t pfn);
  357. int kvm_read_guest_page(struct kvm *kvm, gfn_t gfn, void *data, int offset,
  358. int len);
  359. int kvm_read_guest_atomic(struct kvm *kvm, gpa_t gpa, void *data,
  360. unsigned long len);
  361. int kvm_read_guest(struct kvm *kvm, gpa_t gpa, void *data, unsigned long len);
  362. int kvm_read_guest_cached(struct kvm *kvm, struct gfn_to_hva_cache *ghc,
  363. void *data, unsigned long len);
  364. int kvm_write_guest_page(struct kvm *kvm, gfn_t gfn, const void *data,
  365. int offset, int len);
  366. int kvm_write_guest(struct kvm *kvm, gpa_t gpa, const void *data,
  367. unsigned long len);
  368. int kvm_write_guest_cached(struct kvm *kvm, struct gfn_to_hva_cache *ghc,
  369. void *data, unsigned long len);
  370. int kvm_gfn_to_hva_cache_init(struct kvm *kvm, struct gfn_to_hva_cache *ghc,
  371. gpa_t gpa);
  372. int kvm_clear_guest_page(struct kvm *kvm, gfn_t gfn, int offset, int len);
  373. int kvm_clear_guest(struct kvm *kvm, gpa_t gpa, unsigned long len);
  374. struct kvm_memory_slot *gfn_to_memslot(struct kvm *kvm, gfn_t gfn);
  375. int kvm_is_visible_gfn(struct kvm *kvm, gfn_t gfn);
  376. unsigned long kvm_host_page_size(struct kvm *kvm, gfn_t gfn);
  377. void mark_page_dirty(struct kvm *kvm, gfn_t gfn);
  378. void mark_page_dirty_in_slot(struct kvm *kvm, struct kvm_memory_slot *memslot,
  379. gfn_t gfn);
  380. void kvm_vcpu_block(struct kvm_vcpu *vcpu);
  381. void kvm_vcpu_on_spin(struct kvm_vcpu *vcpu);
  382. void kvm_resched(struct kvm_vcpu *vcpu);
  383. void kvm_load_guest_fpu(struct kvm_vcpu *vcpu);
  384. void kvm_put_guest_fpu(struct kvm_vcpu *vcpu);
  385. void kvm_flush_remote_tlbs(struct kvm *kvm);
  386. void kvm_reload_remote_mmus(struct kvm *kvm);
  387. long kvm_arch_dev_ioctl(struct file *filp,
  388. unsigned int ioctl, unsigned long arg);
  389. long kvm_arch_vcpu_ioctl(struct file *filp,
  390. unsigned int ioctl, unsigned long arg);
  391. int kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf);
  392. int kvm_dev_ioctl_check_extension(long ext);
  393. int kvm_get_dirty_log(struct kvm *kvm,
  394. struct kvm_dirty_log *log, int *is_dirty);
  395. int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm,
  396. struct kvm_dirty_log *log);
  397. int kvm_vm_ioctl_set_memory_region(struct kvm *kvm,
  398. struct
  399. kvm_userspace_memory_region *mem,
  400. int user_alloc);
  401. long kvm_arch_vm_ioctl(struct file *filp,
  402. unsigned int ioctl, unsigned long arg);
  403. int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu);
  404. int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu);
  405. int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu,
  406. struct kvm_translation *tr);
  407. int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs);
  408. int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs);
  409. int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu,
  410. struct kvm_sregs *sregs);
  411. int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu,
  412. struct kvm_sregs *sregs);
  413. int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu,
  414. struct kvm_mp_state *mp_state);
  415. int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu,
  416. struct kvm_mp_state *mp_state);
  417. int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu,
  418. struct kvm_guest_debug *dbg);
  419. int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run);
  420. int kvm_arch_init(void *opaque);
  421. void kvm_arch_exit(void);
  422. int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu);
  423. void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu);
  424. void kvm_arch_vcpu_free(struct kvm_vcpu *vcpu);
  425. void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu);
  426. void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu);
  427. struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm, unsigned int id);
  428. int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu);
  429. void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu);
  430. int kvm_arch_vcpu_reset(struct kvm_vcpu *vcpu);
  431. int kvm_arch_hardware_enable(void *garbage);
  432. void kvm_arch_hardware_disable(void *garbage);
  433. int kvm_arch_hardware_setup(void);
  434. void kvm_arch_hardware_unsetup(void);
  435. void kvm_arch_check_processor_compat(void *rtn);
  436. int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu);
  437. void kvm_free_physmem(struct kvm *kvm);
  438. #ifndef __KVM_HAVE_ARCH_VM_ALLOC
  439. static inline struct kvm *kvm_arch_alloc_vm(void)
  440. {
  441. return kzalloc(sizeof(struct kvm), GFP_KERNEL);
  442. }
  443. static inline void kvm_arch_free_vm(struct kvm *kvm)
  444. {
  445. kfree(kvm);
  446. }
  447. #endif
  448. int kvm_arch_init_vm(struct kvm *kvm, unsigned long type);
  449. void kvm_arch_destroy_vm(struct kvm *kvm);
  450. void kvm_free_all_assigned_devices(struct kvm *kvm);
  451. void kvm_arch_sync_events(struct kvm *kvm);
  452. int kvm_cpu_has_pending_timer(struct kvm_vcpu *vcpu);
  453. void kvm_vcpu_kick(struct kvm_vcpu *vcpu);
  454. int kvm_is_mmio_pfn(pfn_t pfn);
  455. struct kvm_irq_ack_notifier {
  456. struct hlist_node link;
  457. unsigned gsi;
  458. void (*irq_acked)(struct kvm_irq_ack_notifier *kian);
  459. };
  460. struct kvm_assigned_dev_kernel {
  461. struct kvm_irq_ack_notifier ack_notifier;
  462. struct list_head list;
  463. int assigned_dev_id;
  464. int host_segnr;
  465. int host_busnr;
  466. int host_devfn;
  467. unsigned int entries_nr;
  468. int host_irq;
  469. bool host_irq_disabled;
  470. struct msix_entry *host_msix_entries;
  471. int guest_irq;
  472. struct msix_entry *guest_msix_entries;
  473. unsigned long irq_requested_type;
  474. int irq_source_id;
  475. int flags;
  476. struct pci_dev *dev;
  477. struct kvm *kvm;
  478. spinlock_t intx_lock;
  479. char irq_name[32];
  480. struct pci_saved_state *pci_saved_state;
  481. };
  482. struct kvm_irq_mask_notifier {
  483. void (*func)(struct kvm_irq_mask_notifier *kimn, bool masked);
  484. int irq;
  485. struct hlist_node link;
  486. };
  487. void kvm_register_irq_mask_notifier(struct kvm *kvm, int irq,
  488. struct kvm_irq_mask_notifier *kimn);
  489. void kvm_unregister_irq_mask_notifier(struct kvm *kvm, int irq,
  490. struct kvm_irq_mask_notifier *kimn);
  491. void kvm_fire_mask_notifiers(struct kvm *kvm, unsigned irqchip, unsigned pin,
  492. bool mask);
  493. #ifdef __KVM_HAVE_IOAPIC
  494. void kvm_get_intr_delivery_bitmask(struct kvm_ioapic *ioapic,
  495. union kvm_ioapic_redirect_entry *entry,
  496. unsigned long *deliver_bitmask);
  497. #endif
  498. int kvm_set_irq(struct kvm *kvm, int irq_source_id, u32 irq, int level);
  499. int kvm_set_msi(struct kvm_kernel_irq_routing_entry *irq_entry, struct kvm *kvm,
  500. int irq_source_id, int level);
  501. void kvm_notify_acked_irq(struct kvm *kvm, unsigned irqchip, unsigned pin);
  502. void kvm_register_irq_ack_notifier(struct kvm *kvm,
  503. struct kvm_irq_ack_notifier *kian);
  504. void kvm_unregister_irq_ack_notifier(struct kvm *kvm,
  505. struct kvm_irq_ack_notifier *kian);
  506. int kvm_request_irq_source_id(struct kvm *kvm);
  507. void kvm_free_irq_source_id(struct kvm *kvm, int irq_source_id);
  508. /* For vcpu->arch.iommu_flags */
  509. #define KVM_IOMMU_CACHE_COHERENCY 0x1
  510. #ifdef CONFIG_IOMMU_API
  511. int kvm_iommu_map_pages(struct kvm *kvm, struct kvm_memory_slot *slot);
  512. int kvm_iommu_map_guest(struct kvm *kvm);
  513. int kvm_iommu_unmap_guest(struct kvm *kvm);
  514. int kvm_assign_device(struct kvm *kvm,
  515. struct kvm_assigned_dev_kernel *assigned_dev);
  516. int kvm_deassign_device(struct kvm *kvm,
  517. struct kvm_assigned_dev_kernel *assigned_dev);
  518. #else /* CONFIG_IOMMU_API */
  519. static inline int kvm_iommu_map_pages(struct kvm *kvm,
  520. struct kvm_memory_slot *slot)
  521. {
  522. return 0;
  523. }
  524. static inline int kvm_iommu_map_guest(struct kvm *kvm)
  525. {
  526. return -ENODEV;
  527. }
  528. static inline int kvm_iommu_unmap_guest(struct kvm *kvm)
  529. {
  530. return 0;
  531. }
  532. static inline int kvm_assign_device(struct kvm *kvm,
  533. struct kvm_assigned_dev_kernel *assigned_dev)
  534. {
  535. return 0;
  536. }
  537. static inline int kvm_deassign_device(struct kvm *kvm,
  538. struct kvm_assigned_dev_kernel *assigned_dev)
  539. {
  540. return 0;
  541. }
  542. #endif /* CONFIG_IOMMU_API */
  543. static inline void kvm_guest_enter(void)
  544. {
  545. BUG_ON(preemptible());
  546. account_system_vtime(current);
  547. current->flags |= PF_VCPU;
  548. /* KVM does not hold any references to rcu protected data when it
  549. * switches CPU into a guest mode. In fact switching to a guest mode
  550. * is very similar to exiting to userspase from rcu point of view. In
  551. * addition CPU may stay in a guest mode for quite a long time (up to
  552. * one time slice). Lets treat guest mode as quiescent state, just like
  553. * we do with user-mode execution.
  554. */
  555. rcu_virt_note_context_switch(smp_processor_id());
  556. }
  557. static inline void kvm_guest_exit(void)
  558. {
  559. account_system_vtime(current);
  560. current->flags &= ~PF_VCPU;
  561. }
  562. static inline int memslot_id(struct kvm *kvm, gfn_t gfn)
  563. {
  564. return gfn_to_memslot(kvm, gfn)->id;
  565. }
  566. static inline unsigned long gfn_to_hva_memslot(struct kvm_memory_slot *slot,
  567. gfn_t gfn)
  568. {
  569. return slot->userspace_addr + (gfn - slot->base_gfn) * PAGE_SIZE;
  570. }
  571. static inline gpa_t gfn_to_gpa(gfn_t gfn)
  572. {
  573. return (gpa_t)gfn << PAGE_SHIFT;
  574. }
  575. static inline gfn_t gpa_to_gfn(gpa_t gpa)
  576. {
  577. return (gfn_t)(gpa >> PAGE_SHIFT);
  578. }
  579. static inline hpa_t pfn_to_hpa(pfn_t pfn)
  580. {
  581. return (hpa_t)pfn << PAGE_SHIFT;
  582. }
  583. static inline void kvm_migrate_timers(struct kvm_vcpu *vcpu)
  584. {
  585. set_bit(KVM_REQ_MIGRATE_TIMER, &vcpu->requests);
  586. }
  587. enum kvm_stat_kind {
  588. KVM_STAT_VM,
  589. KVM_STAT_VCPU,
  590. };
  591. struct kvm_stats_debugfs_item {
  592. const char *name;
  593. int offset;
  594. enum kvm_stat_kind kind;
  595. struct dentry *dentry;
  596. };
  597. extern struct kvm_stats_debugfs_item debugfs_entries[];
  598. extern struct dentry *kvm_debugfs_dir;
  599. #ifdef KVM_ARCH_WANT_MMU_NOTIFIER
  600. static inline int mmu_notifier_retry(struct kvm_vcpu *vcpu, unsigned long mmu_seq)
  601. {
  602. if (unlikely(vcpu->kvm->mmu_notifier_count))
  603. return 1;
  604. /*
  605. * Ensure the read of mmu_notifier_count happens before the read
  606. * of mmu_notifier_seq. This interacts with the smp_wmb() in
  607. * mmu_notifier_invalidate_range_end to make sure that the caller
  608. * either sees the old (non-zero) value of mmu_notifier_count or
  609. * the new (incremented) value of mmu_notifier_seq.
  610. * PowerPC Book3s HV KVM calls this under a per-page lock
  611. * rather than under kvm->mmu_lock, for scalability, so
  612. * can't rely on kvm->mmu_lock to keep things ordered.
  613. */
  614. smp_rmb();
  615. if (vcpu->kvm->mmu_notifier_seq != mmu_seq)
  616. return 1;
  617. return 0;
  618. }
  619. #endif
  620. #ifdef CONFIG_HAVE_KVM_IRQCHIP
  621. #define KVM_MAX_IRQ_ROUTES 1024
  622. int kvm_setup_default_irq_routing(struct kvm *kvm);
  623. int kvm_set_irq_routing(struct kvm *kvm,
  624. const struct kvm_irq_routing_entry *entries,
  625. unsigned nr,
  626. unsigned flags);
  627. void kvm_free_irq_routing(struct kvm *kvm);
  628. #else
  629. static inline void kvm_free_irq_routing(struct kvm *kvm) {}
  630. #endif
  631. #ifdef CONFIG_HAVE_KVM_EVENTFD
  632. void kvm_eventfd_init(struct kvm *kvm);
  633. int kvm_irqfd(struct kvm *kvm, int fd, int gsi, int flags);
  634. void kvm_irqfd_release(struct kvm *kvm);
  635. void kvm_irq_routing_update(struct kvm *, struct kvm_irq_routing_table *);
  636. int kvm_ioeventfd(struct kvm *kvm, struct kvm_ioeventfd *args);
  637. #else
  638. static inline void kvm_eventfd_init(struct kvm *kvm) {}
  639. static inline int kvm_irqfd(struct kvm *kvm, int fd, int gsi, int flags)
  640. {
  641. return -EINVAL;
  642. }
  643. static inline void kvm_irqfd_release(struct kvm *kvm) {}
  644. #ifdef CONFIG_HAVE_KVM_IRQCHIP
  645. static inline void kvm_irq_routing_update(struct kvm *kvm,
  646. struct kvm_irq_routing_table *irq_rt)
  647. {
  648. rcu_assign_pointer(kvm->irq_routing, irq_rt);
  649. }
  650. #endif
  651. static inline int kvm_ioeventfd(struct kvm *kvm, struct kvm_ioeventfd *args)
  652. {
  653. return -ENOSYS;
  654. }
  655. #endif /* CONFIG_HAVE_KVM_EVENTFD */
  656. #ifdef CONFIG_KVM_APIC_ARCHITECTURE
  657. static inline bool kvm_vcpu_is_bsp(struct kvm_vcpu *vcpu)
  658. {
  659. return vcpu->kvm->bsp_vcpu_id == vcpu->vcpu_id;
  660. }
  661. #endif
  662. #ifdef __KVM_HAVE_DEVICE_ASSIGNMENT
  663. long kvm_vm_ioctl_assigned_device(struct kvm *kvm, unsigned ioctl,
  664. unsigned long arg);
  665. #else
  666. static inline long kvm_vm_ioctl_assigned_device(struct kvm *kvm, unsigned ioctl,
  667. unsigned long arg)
  668. {
  669. return -ENOTTY;
  670. }
  671. #endif
  672. static inline void kvm_make_request(int req, struct kvm_vcpu *vcpu)
  673. {
  674. set_bit(req, &vcpu->requests);
  675. }
  676. static inline bool kvm_check_request(int req, struct kvm_vcpu *vcpu)
  677. {
  678. if (test_bit(req, &vcpu->requests)) {
  679. clear_bit(req, &vcpu->requests);
  680. return true;
  681. } else {
  682. return false;
  683. }
  684. }
  685. #endif