home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / kvm_host.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  13.1 KB  |  447 lines
  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/mm.h>
  17. #include <linux/preempt.h>
  18. #include <linux/marker.h>
  19. #include <asm/signal.h>
  20.  
  21. #include <linux/kvm.h>
  22. #include <linux/kvm_para.h>
  23.  
  24. #include <linux/kvm_types.h>
  25.  
  26. #include <asm/kvm_host.h>
  27.  
  28. /*
  29.  * vcpu->requests bit members
  30.  */
  31. #define KVM_REQ_TLB_FLUSH          0
  32. #define KVM_REQ_MIGRATE_TIMER      1
  33. #define KVM_REQ_REPORT_TPR_ACCESS  2
  34. #define KVM_REQ_MMU_RELOAD         3
  35. #define KVM_REQ_TRIPLE_FAULT       4
  36. #define KVM_REQ_PENDING_TIMER      5
  37. #define KVM_REQ_UNHALT             6
  38. #define KVM_REQ_MMU_SYNC           7
  39.  
  40. #define KVM_USERSPACE_IRQ_SOURCE_ID    0
  41.  
  42. struct kvm_vcpu;
  43. extern struct kmem_cache *kvm_vcpu_cache;
  44.  
  45. /*
  46.  * It would be nice to use something smarter than a linear search, TBD...
  47.  * Thankfully we dont expect many devices to register (famous last words :),
  48.  * so until then it will suffice.  At least its abstracted so we can change
  49.  * in one place.
  50.  */
  51. struct kvm_io_bus {
  52.     int                   dev_count;
  53. #define NR_IOBUS_DEVS 6
  54.     struct kvm_io_device *devs[NR_IOBUS_DEVS];
  55. };
  56.  
  57. void kvm_io_bus_init(struct kvm_io_bus *bus);
  58. void kvm_io_bus_destroy(struct kvm_io_bus *bus);
  59. struct kvm_io_device *kvm_io_bus_find_dev(struct kvm_io_bus *bus,
  60.                       gpa_t addr, int len, int is_write);
  61. void kvm_io_bus_register_dev(struct kvm_io_bus *bus,
  62.                  struct kvm_io_device *dev);
  63.  
  64. struct kvm_vcpu {
  65.     struct kvm *kvm;
  66. #ifdef CONFIG_PREEMPT_NOTIFIERS
  67.     struct preempt_notifier preempt_notifier;
  68. #endif
  69.     int vcpu_id;
  70.     struct mutex mutex;
  71.     int   cpu;
  72.     struct kvm_run *run;
  73.     int guest_mode;
  74.     unsigned long requests;
  75.     struct kvm_guest_debug guest_debug;
  76.     int fpu_active;
  77.     int guest_fpu_loaded;
  78.     wait_queue_head_t wq;
  79.     int sigset_active;
  80.     sigset_t sigset;
  81.     struct kvm_vcpu_stat stat;
  82.  
  83. #ifdef CONFIG_HAS_IOMEM
  84.     int mmio_needed;
  85.     int mmio_read_completed;
  86.     int mmio_is_write;
  87.     int mmio_size;
  88.     unsigned char mmio_data[8];
  89.     gpa_t mmio_phys_addr;
  90. #endif
  91.  
  92.     struct kvm_vcpu_arch arch;
  93. };
  94.  
  95. struct kvm_memory_slot {
  96.     gfn_t base_gfn;
  97.     unsigned long npages;
  98.     unsigned long flags;
  99.     unsigned long *rmap;
  100.     unsigned long *dirty_bitmap;
  101.     struct {
  102.         unsigned long rmap_pde;
  103.         int write_count;
  104.     } *lpage_info;
  105.     unsigned long userspace_addr;
  106.     int user_alloc;
  107. };
  108.  
  109. struct kvm {
  110.     struct mutex lock; /* protects the vcpus array and APIC accesses */
  111.     spinlock_t mmu_lock;
  112.     struct rw_semaphore slots_lock;
  113.     struct mm_struct *mm; /* userspace tied to this vm */
  114.     int nmemslots;
  115.     struct kvm_memory_slot memslots[KVM_MEMORY_SLOTS +
  116.                     KVM_PRIVATE_MEM_SLOTS];
  117.     struct kvm_vcpu *vcpus[KVM_MAX_VCPUS];
  118.     struct list_head vm_list;
  119.     struct kvm_io_bus mmio_bus;
  120.     struct kvm_io_bus pio_bus;
  121.     struct kvm_vm_stat stat;
  122.     struct kvm_arch arch;
  123.     atomic_t users_count;
  124. #ifdef KVM_COALESCED_MMIO_PAGE_OFFSET
  125.     struct kvm_coalesced_mmio_dev *coalesced_mmio_dev;
  126.     struct kvm_coalesced_mmio_ring *coalesced_mmio_ring;
  127. #endif
  128.  
  129. #ifdef KVM_ARCH_WANT_MMU_NOTIFIER
  130.     struct mmu_notifier mmu_notifier;
  131.     unsigned long mmu_notifier_seq;
  132.     long mmu_notifier_count;
  133. #endif
  134. };
  135.  
  136. /* The guest did something we don't support. */
  137. #define pr_unimpl(vcpu, fmt, ...)                    \
  138.  do {                                    \
  139.     if (printk_ratelimit())                        \
  140.         printk(KERN_ERR "kvm: %i: cpu%i " fmt,            \
  141.                current->tgid, (vcpu)->vcpu_id , ## __VA_ARGS__); \
  142.  } while (0)
  143.  
  144. #define kvm_printf(kvm, fmt ...) printk(KERN_DEBUG fmt)
  145. #define vcpu_printf(vcpu, fmt...) kvm_printf(vcpu->kvm, fmt)
  146.  
  147. int kvm_vcpu_init(struct kvm_vcpu *vcpu, struct kvm *kvm, unsigned id);
  148. void kvm_vcpu_uninit(struct kvm_vcpu *vcpu);
  149.  
  150. void vcpu_load(struct kvm_vcpu *vcpu);
  151. void vcpu_put(struct kvm_vcpu *vcpu);
  152.  
  153. int kvm_init(void *opaque, unsigned int vcpu_size,
  154.           struct module *module);
  155. void kvm_exit(void);
  156.  
  157. void kvm_get_kvm(struct kvm *kvm);
  158. void kvm_put_kvm(struct kvm *kvm);
  159.  
  160. #define HPA_MSB ((sizeof(hpa_t) * 8) - 1)
  161. #define HPA_ERR_MASK ((hpa_t)1 << HPA_MSB)
  162. static inline int is_error_hpa(hpa_t hpa) { return hpa >> HPA_MSB; }
  163. struct page *gva_to_page(struct kvm_vcpu *vcpu, gva_t gva);
  164.  
  165. extern struct page *bad_page;
  166. extern pfn_t bad_pfn;
  167.  
  168. int is_error_page(struct page *page);
  169. int is_error_pfn(pfn_t pfn);
  170. int kvm_is_error_hva(unsigned long addr);
  171. int kvm_set_memory_region(struct kvm *kvm,
  172.               struct kvm_userspace_memory_region *mem,
  173.               int user_alloc);
  174. int __kvm_set_memory_region(struct kvm *kvm,
  175.                 struct kvm_userspace_memory_region *mem,
  176.                 int user_alloc);
  177. int kvm_arch_set_memory_region(struct kvm *kvm,
  178.                 struct kvm_userspace_memory_region *mem,
  179.                 struct kvm_memory_slot old,
  180.                 int user_alloc);
  181. void kvm_arch_flush_shadow(struct kvm *kvm);
  182. gfn_t unalias_gfn(struct kvm *kvm, gfn_t gfn);
  183. struct page *gfn_to_page(struct kvm *kvm, gfn_t gfn);
  184. unsigned long gfn_to_hva(struct kvm *kvm, gfn_t gfn);
  185. void kvm_release_page_clean(struct page *page);
  186. void kvm_release_page_dirty(struct page *page);
  187. void kvm_set_page_dirty(struct page *page);
  188. void kvm_set_page_accessed(struct page *page);
  189.  
  190. pfn_t gfn_to_pfn(struct kvm *kvm, gfn_t gfn);
  191. void kvm_release_pfn_dirty(pfn_t);
  192. void kvm_release_pfn_clean(pfn_t pfn);
  193. void kvm_set_pfn_dirty(pfn_t pfn);
  194. void kvm_set_pfn_accessed(pfn_t pfn);
  195. void kvm_get_pfn(pfn_t pfn);
  196.  
  197. int kvm_read_guest_page(struct kvm *kvm, gfn_t gfn, void *data, int offset,
  198.             int len);
  199. int kvm_read_guest_atomic(struct kvm *kvm, gpa_t gpa, void *data,
  200.               unsigned long len);
  201. int kvm_read_guest(struct kvm *kvm, gpa_t gpa, void *data, unsigned long len);
  202. int kvm_write_guest_page(struct kvm *kvm, gfn_t gfn, const void *data,
  203.              int offset, int len);
  204. int kvm_write_guest(struct kvm *kvm, gpa_t gpa, const void *data,
  205.             unsigned long len);
  206. int kvm_clear_guest_page(struct kvm *kvm, gfn_t gfn, int offset, int len);
  207. int kvm_clear_guest(struct kvm *kvm, gpa_t gpa, unsigned long len);
  208. struct kvm_memory_slot *gfn_to_memslot(struct kvm *kvm, gfn_t gfn);
  209. int kvm_is_visible_gfn(struct kvm *kvm, gfn_t gfn);
  210. void mark_page_dirty(struct kvm *kvm, gfn_t gfn);
  211.  
  212. void kvm_vcpu_block(struct kvm_vcpu *vcpu);
  213. void kvm_resched(struct kvm_vcpu *vcpu);
  214. void kvm_load_guest_fpu(struct kvm_vcpu *vcpu);
  215. void kvm_put_guest_fpu(struct kvm_vcpu *vcpu);
  216. void kvm_flush_remote_tlbs(struct kvm *kvm);
  217. void kvm_reload_remote_mmus(struct kvm *kvm);
  218.  
  219. long kvm_arch_dev_ioctl(struct file *filp,
  220.             unsigned int ioctl, unsigned long arg);
  221. long kvm_arch_vcpu_ioctl(struct file *filp,
  222.              unsigned int ioctl, unsigned long arg);
  223. void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu);
  224. void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu);
  225.  
  226. int kvm_dev_ioctl_check_extension(long ext);
  227.  
  228. int kvm_get_dirty_log(struct kvm *kvm,
  229.             struct kvm_dirty_log *log, int *is_dirty);
  230. int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm,
  231.                 struct kvm_dirty_log *log);
  232.  
  233. int kvm_vm_ioctl_set_memory_region(struct kvm *kvm,
  234.                    struct
  235.                    kvm_userspace_memory_region *mem,
  236.                    int user_alloc);
  237. long kvm_arch_vm_ioctl(struct file *filp,
  238.                unsigned int ioctl, unsigned long arg);
  239. void kvm_arch_destroy_vm(struct kvm *kvm);
  240.  
  241. int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu);
  242. int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu);
  243.  
  244. int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu,
  245.                     struct kvm_translation *tr);
  246.  
  247. int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs);
  248. int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs);
  249. int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu,
  250.                   struct kvm_sregs *sregs);
  251. int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu,
  252.                   struct kvm_sregs *sregs);
  253. int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu,
  254.                     struct kvm_mp_state *mp_state);
  255. int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu,
  256.                     struct kvm_mp_state *mp_state);
  257. int kvm_arch_vcpu_ioctl_debug_guest(struct kvm_vcpu *vcpu,
  258.                     struct kvm_debug_guest *dbg);
  259. int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run);
  260.  
  261. int kvm_arch_init(void *opaque);
  262. void kvm_arch_exit(void);
  263.  
  264. int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu);
  265. void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu);
  266.  
  267. void kvm_arch_vcpu_free(struct kvm_vcpu *vcpu);
  268. void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu);
  269. void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu);
  270. struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm, unsigned int id);
  271. int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu);
  272. void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu);
  273.  
  274. int kvm_arch_vcpu_reset(struct kvm_vcpu *vcpu);
  275. void kvm_arch_hardware_enable(void *garbage);
  276. void kvm_arch_hardware_disable(void *garbage);
  277. int kvm_arch_hardware_setup(void);
  278. void kvm_arch_hardware_unsetup(void);
  279. void kvm_arch_check_processor_compat(void *rtn);
  280. int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu);
  281.  
  282. void kvm_free_physmem(struct kvm *kvm);
  283.  
  284. struct  kvm *kvm_arch_create_vm(void);
  285. void kvm_arch_destroy_vm(struct kvm *kvm);
  286. void kvm_free_all_assigned_devices(struct kvm *kvm);
  287.  
  288. int kvm_cpu_get_interrupt(struct kvm_vcpu *v);
  289. int kvm_cpu_has_interrupt(struct kvm_vcpu *v);
  290. int kvm_cpu_has_pending_timer(struct kvm_vcpu *vcpu);
  291. void kvm_vcpu_kick(struct kvm_vcpu *vcpu);
  292.  
  293. int kvm_is_mmio_pfn(pfn_t pfn);
  294.  
  295. struct kvm_irq_ack_notifier {
  296.     struct hlist_node link;
  297.     unsigned gsi;
  298.     void (*irq_acked)(struct kvm_irq_ack_notifier *kian);
  299. };
  300.  
  301. struct kvm_assigned_dev_kernel {
  302.     struct kvm_irq_ack_notifier ack_notifier;
  303.     struct work_struct interrupt_work;
  304.     struct list_head list;
  305.     int assigned_dev_id;
  306.     int host_busnr;
  307.     int host_devfn;
  308.     int host_irq;
  309.     int guest_irq;
  310.     int irq_requested;
  311.     int irq_source_id;
  312.     struct pci_dev *dev;
  313.     struct kvm *kvm;
  314. };
  315. void kvm_set_irq(struct kvm *kvm, int irq_source_id, int irq, int level);
  316. void kvm_notify_acked_irq(struct kvm *kvm, unsigned gsi);
  317. void kvm_register_irq_ack_notifier(struct kvm *kvm,
  318.                    struct kvm_irq_ack_notifier *kian);
  319. void kvm_unregister_irq_ack_notifier(struct kvm *kvm,
  320.                      struct kvm_irq_ack_notifier *kian);
  321. int kvm_request_irq_source_id(struct kvm *kvm);
  322. void kvm_free_irq_source_id(struct kvm *kvm, int irq_source_id);
  323.  
  324. #ifdef CONFIG_DMAR
  325. int kvm_iommu_map_pages(struct kvm *kvm, gfn_t base_gfn,
  326.             unsigned long npages);
  327. int kvm_iommu_map_guest(struct kvm *kvm,
  328.             struct kvm_assigned_dev_kernel *assigned_dev);
  329. int kvm_iommu_unmap_guest(struct kvm *kvm);
  330. #else /* CONFIG_DMAR */
  331. static inline int kvm_iommu_map_pages(struct kvm *kvm,
  332.                       gfn_t base_gfn,
  333.                       unsigned long npages)
  334. {
  335.     return 0;
  336. }
  337.  
  338. static inline int kvm_iommu_map_guest(struct kvm *kvm,
  339.                       struct kvm_assigned_dev_kernel
  340.                       *assigned_dev)
  341. {
  342.     return -ENODEV;
  343. }
  344.  
  345. static inline int kvm_iommu_unmap_guest(struct kvm *kvm)
  346. {
  347.     return 0;
  348. }
  349. #endif /* CONFIG_DMAR */
  350.  
  351. static inline void kvm_guest_enter(void)
  352. {
  353.     account_system_vtime(current);
  354.     current->flags |= PF_VCPU;
  355. }
  356.  
  357. static inline void kvm_guest_exit(void)
  358. {
  359.     account_system_vtime(current);
  360.     current->flags &= ~PF_VCPU;
  361. }
  362.  
  363. static inline int memslot_id(struct kvm *kvm, struct kvm_memory_slot *slot)
  364. {
  365.     return slot - kvm->memslots;
  366. }
  367.  
  368. static inline gpa_t gfn_to_gpa(gfn_t gfn)
  369. {
  370.     return (gpa_t)gfn << PAGE_SHIFT;
  371. }
  372.  
  373. static inline hpa_t pfn_to_hpa(pfn_t pfn)
  374. {
  375.     return (hpa_t)pfn << PAGE_SHIFT;
  376. }
  377.  
  378. static inline void kvm_migrate_timers(struct kvm_vcpu *vcpu)
  379. {
  380.     set_bit(KVM_REQ_MIGRATE_TIMER, &vcpu->requests);
  381. }
  382.  
  383. enum kvm_stat_kind {
  384.     KVM_STAT_VM,
  385.     KVM_STAT_VCPU,
  386. };
  387.  
  388. struct kvm_stats_debugfs_item {
  389.     const char *name;
  390.     int offset;
  391.     enum kvm_stat_kind kind;
  392.     struct dentry *dentry;
  393. };
  394. extern struct kvm_stats_debugfs_item debugfs_entries[];
  395. extern struct dentry *kvm_debugfs_dir;
  396.  
  397. #define KVMTRACE_5D(evt, vcpu, d1, d2, d3, d4, d5, name) \
  398.     trace_mark(kvm_trace_##name, "%u %p %u %u %u %u %u %u", KVM_TRC_##evt, \
  399.                         vcpu, 5, d1, d2, d3, d4, d5)
  400. #define KVMTRACE_4D(evt, vcpu, d1, d2, d3, d4, name) \
  401.     trace_mark(kvm_trace_##name, "%u %p %u %u %u %u %u %u", KVM_TRC_##evt, \
  402.                         vcpu, 4, d1, d2, d3, d4, 0)
  403. #define KVMTRACE_3D(evt, vcpu, d1, d2, d3, name) \
  404.     trace_mark(kvm_trace_##name, "%u %p %u %u %u %u %u %u", KVM_TRC_##evt, \
  405.                         vcpu, 3, d1, d2, d3, 0, 0)
  406. #define KVMTRACE_2D(evt, vcpu, d1, d2, name) \
  407.     trace_mark(kvm_trace_##name, "%u %p %u %u %u %u %u %u", KVM_TRC_##evt, \
  408.                         vcpu, 2, d1, d2, 0, 0, 0)
  409. #define KVMTRACE_1D(evt, vcpu, d1, name) \
  410.     trace_mark(kvm_trace_##name, "%u %p %u %u %u %u %u %u", KVM_TRC_##evt, \
  411.                         vcpu, 1, d1, 0, 0, 0, 0)
  412. #define KVMTRACE_0D(evt, vcpu, name) \
  413.     trace_mark(kvm_trace_##name, "%u %p %u %u %u %u %u %u", KVM_TRC_##evt, \
  414.                         vcpu, 0, 0, 0, 0, 0, 0)
  415.  
  416. #ifdef CONFIG_KVM_TRACE
  417. int kvm_trace_ioctl(unsigned int ioctl, unsigned long arg);
  418. void kvm_trace_cleanup(void);
  419. #else
  420. static inline
  421. int kvm_trace_ioctl(unsigned int ioctl, unsigned long arg)
  422. {
  423.     return -EINVAL;
  424. }
  425. #define kvm_trace_cleanup() ((void)0)
  426. #endif
  427.  
  428. #ifdef KVM_ARCH_WANT_MMU_NOTIFIER
  429. static inline int mmu_notifier_retry(struct kvm_vcpu *vcpu, unsigned long mmu_seq)
  430. {
  431.     if (unlikely(vcpu->kvm->mmu_notifier_count))
  432.         return 1;
  433.     /*
  434.      * Both reads happen under the mmu_lock and both values are
  435.      * modified under mmu_lock, so there's no need of smb_rmb()
  436.      * here in between, otherwise mmu_notifier_count should be
  437.      * read before mmu_notifier_seq, see
  438.      * mmu_notifier_invalidate_range_end write side.
  439.      */
  440.     if (vcpu->kvm->mmu_notifier_seq != mmu_seq)
  441.         return 1;
  442.     return 0;
  443. }
  444. #endif
  445.  
  446. #endif
  447.