drivers/kvm/kvm.h

   1 #ifndef __KVM_H
   2 #define __KVM_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 <asm/signal.h>
  19
  20 #include <linux/kvm.h>
  21 #include <linux/kvm_para.h>
  22
  23 #define KVM_MAX_VCPUS 4
  24 #define KVM_ALIAS_SLOTS 4
  25 #define KVM_MEMORY_SLOTS 8
  26 /* memory slots that does not exposed to userspace */
  27 #define KVM_PRIVATE_MEM_SLOTS 4
  28 #define KVM_PERMILLE_MMU_PAGES 20
  29 #define KVM_MIN_ALLOC_MMU_PAGES 64
  30 #define KVM_NUM_MMU_PAGES 1024
  31 #define KVM_MIN_FREE_MMU_PAGES 5
  32 #define KVM_REFILL_PAGES 25
  33 #define KVM_MAX_CPUID_ENTRIES 40
  34
  35 #define KVM_PIO_PAGE_OFFSET 1
  36
  37 /*
  38  * vcpu->requests bit members
  39  */
  40 #define KVM_REQ_TLB_FLUSH          0
  41
  42 /*
  43  * Address types:
  44  *
  45  *  gva - guest virtual address
  46  *  gpa - guest physical address
  47  *  gfn - guest frame number
  48  *  hva - host virtual address
  49  *  hpa - host physical address
  50  *  hfn - host frame number
  51  */
  52
  53 typedef unsigned long  gva_t;
  54 typedef u64            gpa_t;
  55 typedef unsigned long  gfn_t;
  56
  57 typedef unsigned long  hva_t;
  58 typedef u64            hpa_t;
  59 typedef unsigned long  hfn_t;
  60
  61 #define NR_PTE_CHAIN_ENTRIES 5
  62
  63 struct kvm_pte_chain {
  64         u64 *parent_ptes[NR_PTE_CHAIN_ENTRIES];
  65         struct hlist_node link;
  66 };
  67
  68 /*
  69  * kvm_mmu_page_role, below, is defined as:
  70  *
  71  *   bits 0:3 - total guest paging levels (2-4, or zero for real mode)
  72  *   bits 4:7 - page table level for this shadow (1-4)
  73  *   bits 8:9 - page table quadrant for 2-level guests
  74  *   bit   16 - "metaphysical" - gfn is not a real page (huge page/real mode)
  75  *   bits 17:19 - "access" - the user, writable, and nx bits of a huge page pde
  76  */
  77 union kvm_mmu_page_role {
  78         unsigned word;
  79         struct {
  80                 unsigned glevels : 4;
  81                 unsigned level : 4;
  82                 unsigned quadrant : 2;
  83                 unsigned pad_for_nice_hex_output : 6;
  84                 unsigned metaphysical : 1;
  85                 unsigned hugepage_access : 3;
  86         };
  87 };
  88
  89 struct kvm_mmu_page {
  90         struct list_head link;
  91         struct hlist_node hash_link;
  92
  93         /*
  94          * The following two entries are used to key the shadow page in the
  95          * hash table.
  96          */
  97         gfn_t gfn;
  98         union kvm_mmu_page_role role;
  99
 100         u64 *spt;
 101         /* hold the gfn of each spte inside spt */
 102         gfn_t *gfns;
 103         unsigned long slot_bitmap; /* One bit set per slot which has memory
 104                                     * in this shadow page.
 105                                     */
 106         int multimapped;         /* More than one parent_pte? */
 107         int root_count;          /* Currently serving as active root */
 108         union {
 109                 u64 *parent_pte;               /* !multimapped */
 110                 struct hlist_head parent_ptes; /* multimapped, kvm_pte_chain */
 111         };
 112 };
 113
 114 struct kvm_vcpu;
 115 extern struct kmem_cache *kvm_vcpu_cache;
 116
 117 /*
 118  * x86 supports 3 paging modes (4-level 64-bit, 3-level 64-bit, and 2-level
 119  * 32-bit).  The kvm_mmu structure abstracts the details of the current mmu
 120  * mode.
 121  */
 122 struct kvm_mmu {
 123         void (*new_cr3)(struct kvm_vcpu *vcpu);
 124         int (*page_fault)(struct kvm_vcpu *vcpu, gva_t gva, u32 err);
 125         void (*free)(struct kvm_vcpu *vcpu);
 126         gpa_t (*gva_to_gpa)(struct kvm_vcpu *vcpu, gva_t gva);
 127         void (*prefetch_page)(struct kvm_vcpu *vcpu,
 128                               struct kvm_mmu_page *page);
 129         hpa_t root_hpa;
 130         int root_level;
 131         int shadow_root_level;
 132
 133         u64 *pae_root;
 134 };
 135
 136 #define KVM_NR_MEM_OBJS 40
 137
 138 /*
 139  * We don't want allocation failures within the mmu code, so we preallocate
 140  * enough memory for a single page fault in a cache.
 141  */
 142 struct kvm_mmu_memory_cache {
 143         int nobjs;
 144         void *objects[KVM_NR_MEM_OBJS];
 145 };
 146
 147 struct kvm_guest_debug {
 148         int enabled;
 149         unsigned long bp[4];
 150         int singlestep;
 151 };
 152
 153 struct kvm_pio_request {
 154         unsigned long count;
 155         int cur_count;
 156         struct page *guest_pages[2];
 157         unsigned guest_page_offset;
 158         int in;
 159         int port;
 160         int size;
 161         int string;
 162         int down;
 163         int rep;
 164 };
 165
 166 struct kvm_vcpu_stat {
 167         u32 pf_fixed;
 168         u32 pf_guest;
 169         u32 tlb_flush;
 170         u32 invlpg;
 171
 172         u32 exits;
 173         u32 io_exits;
 174         u32 mmio_exits;
 175         u32 signal_exits;
 176         u32 irq_window_exits;
 177         u32 halt_exits;
 178         u32 halt_wakeup;
 179         u32 request_irq_exits;
 180         u32 irq_exits;
 181         u32 host_state_reload;
 182         u32 efer_reload;
 183         u32 fpu_reload;
 184         u32 insn_emulation;
 185         u32 insn_emulation_fail;
 186 };
 187
 188 struct kvm_io_device {
 189         void (*read)(struct kvm_io_device *this,
 190                      gpa_t addr,
 191                      int len,
 192                      void *val);
 193         void (*write)(struct kvm_io_device *this,
 194                       gpa_t addr,
 195                       int len,
 196                       const void *val);
 197         int (*in_range)(struct kvm_io_device *this, gpa_t addr);
 198         void (*destructor)(struct kvm_io_device *this);
 199
 200         void             *private;
 201 };
 202
 203 static inline void kvm_iodevice_read(struct kvm_io_device *dev,
 204                                      gpa_t addr,
 205                                      int len,
 206                                      void *val)
 207 {
 208         dev->read(dev, addr, len, val);
 209 }
 210
 211 static inline void kvm_iodevice_write(struct kvm_io_device *dev,
 212                                       gpa_t addr,
 213                                       int len,
 214                                       const void *val)
 215 {
 216         dev->write(dev, addr, len, val);
 217 }
 218
 219 static inline int kvm_iodevice_inrange(struct kvm_io_device *dev, gpa_t addr)
 220 {
 221         return dev->in_range(dev, addr);
 222 }
 223
 224 static inline void kvm_iodevice_destructor(struct kvm_io_device *dev)
 225 {
 226         if (dev->destructor)
 227                 dev->destructor(dev);
 228 }
 229
 230 /*
 231  * It would be nice to use something smarter than a linear search, TBD...
 232  * Thankfully we dont expect many devices to register (famous last words :),
 233  * so until then it will suffice.  At least its abstracted so we can change
 234  * in one place.
 235  */
 236 struct kvm_io_bus {
 237         int                   dev_count;
 238 #define NR_IOBUS_DEVS 6
 239         struct kvm_io_device *devs[NR_IOBUS_DEVS];
 240 };
 241
 242 void kvm_io_bus_init(struct kvm_io_bus *bus);
 243 void kvm_io_bus_destroy(struct kvm_io_bus *bus);
 244 struct kvm_io_device *kvm_io_bus_find_dev(struct kvm_io_bus *bus, gpa_t addr);
 245 void kvm_io_bus_register_dev(struct kvm_io_bus *bus,
 246                              struct kvm_io_device *dev);
 247
 248 #ifdef CONFIG_HAS_IOMEM
 249 #define KVM_VCPU_MMIO                   \
 250         int mmio_needed;                \
 251         int mmio_read_completed;        \
 252         int mmio_is_write;              \
 253         int mmio_size;                  \
 254         unsigned char mmio_data[8];     \
 255         gpa_t mmio_phys_addr;
 256
 257 #else
 258 #define KVM_VCPU_MMIO
 259
 260 #endif
 261
 262 #define KVM_VCPU_COMM                                   \
 263         struct kvm *kvm;                                \
 264         struct preempt_notifier preempt_notifier;       \
 265         int vcpu_id;                                    \
 266         struct mutex mutex;                             \
 267         int   cpu;                                      \
 268         struct kvm_run *run;                            \
 269         int guest_mode;                                 \
 270         unsigned long requests;                         \
 271         struct kvm_guest_debug guest_debug;             \
 272         int fpu_active;                                 \
 273         int guest_fpu_loaded;                           \
 274         wait_queue_head_t wq;                           \
 275         int sigset_active;                              \
 276         sigset_t sigset;                                \
 277         struct kvm_vcpu_stat stat;                      \
 278         KVM_VCPU_MMIO
 279
 280 struct kvm_mem_alias {
 281         gfn_t base_gfn;
 282         unsigned long npages;
 283         gfn_t target_gfn;
 284 };
 285
 286 struct kvm_memory_slot {
 287         gfn_t base_gfn;
 288         unsigned long npages;
 289         unsigned long flags;
 290         unsigned long *rmap;
 291         unsigned long *dirty_bitmap;
 292         unsigned long userspace_addr;
 293         int user_alloc;
 294 };
 295
 296 struct kvm_vm_stat {
 297         u32 mmu_shadow_zapped;
 298         u32 mmu_pte_write;
 299         u32 mmu_pte_updated;
 300         u32 mmu_pde_zapped;
 301         u32 mmu_flooded;
 302         u32 mmu_recycled;
 303 };
 304
 305 struct kvm {
 306         struct mutex lock; /* protects everything except vcpus */
 307         int naliases;
 308         struct kvm_mem_alias aliases[KVM_ALIAS_SLOTS];
 309         int nmemslots;
 310         struct kvm_memory_slot memslots[KVM_MEMORY_SLOTS +
 311                                         KVM_PRIVATE_MEM_SLOTS];
 312         /*
 313          * Hash table of struct kvm_mmu_page.
 314          */
 315         struct list_head active_mmu_pages;
 316         unsigned int n_free_mmu_pages;
 317         unsigned int n_requested_mmu_pages;
 318         unsigned int n_alloc_mmu_pages;
 319         struct hlist_head mmu_page_hash[KVM_NUM_MMU_PAGES];
 320         struct kvm_vcpu *vcpus[KVM_MAX_VCPUS];
 321         struct list_head vm_list;
 322         struct file *filp;
 323         struct kvm_io_bus mmio_bus;
 324         struct kvm_io_bus pio_bus;
 325         struct kvm_pic *vpic;
 326         struct kvm_ioapic *vioapic;
 327         int round_robin_prev_vcpu;
 328         unsigned int tss_addr;
 329         struct page *apic_access_page;
 330         struct kvm_vm_stat stat;
 331 };
 332
 333 static inline struct kvm_pic *pic_irqchip(struct kvm *kvm)
 334 {
 335         return kvm->vpic;
 336 }
 337
 338 static inline struct kvm_ioapic *ioapic_irqchip(struct kvm *kvm)
 339 {
 340         return kvm->vioapic;
 341 }
 342
 343 static inline int irqchip_in_kernel(struct kvm *kvm)
 344 {
 345         return pic_irqchip(kvm) != NULL;
 346 }
 347
 348 struct descriptor_table {
 349         u16 limit;
 350         unsigned long base;
 351 } __attribute__((packed));
 352
 353 /* The guest did something we don't support. */
 354 #define pr_unimpl(vcpu, fmt, ...)                                       \
 355  do {                                                                   \
 356         if (printk_ratelimit())                                         \
 357                 printk(KERN_ERR "kvm: %i: cpu%i " fmt,                  \
 358                        current->tgid, (vcpu)->vcpu_id , ## __VA_ARGS__); \
 359  } while (0)
 360
 361 #define kvm_printf(kvm, fmt ...) printk(KERN_DEBUG fmt)
 362 #define vcpu_printf(vcpu, fmt...) kvm_printf(vcpu->kvm, fmt)
 363
 364 int kvm_vcpu_init(struct kvm_vcpu *vcpu, struct kvm *kvm, unsigned id);
 365 void kvm_vcpu_uninit(struct kvm_vcpu *vcpu);
 366
 367 void vcpu_load(struct kvm_vcpu *vcpu);
 368 void vcpu_put(struct kvm_vcpu *vcpu);
 369
 370 void decache_vcpus_on_cpu(int cpu);
 371
 372
 373 int kvm_init(void *opaque, unsigned int vcpu_size,
 374                   struct module *module);
 375 void kvm_exit(void);
 376
 377 hpa_t gpa_to_hpa(struct kvm *kvm, gpa_t gpa);
 378 #define HPA_MSB ((sizeof(hpa_t) * 8) - 1)
 379 #define HPA_ERR_MASK ((hpa_t)1 << HPA_MSB)
 380 static inline int is_error_hpa(hpa_t hpa) { return hpa >> HPA_MSB; }
 381 hpa_t gva_to_hpa(struct kvm_vcpu *vcpu, gva_t gva);
 382 struct page *gva_to_page(struct kvm_vcpu *vcpu, gva_t gva);
 383
 384 extern struct page *bad_page;
 385
 386 int is_error_page(struct page *page);
 387 int kvm_is_error_hva(unsigned long addr);
 388 int kvm_set_memory_region(struct kvm *kvm,
 389                           struct kvm_userspace_memory_region *mem,
 390                           int user_alloc);
 391 int __kvm_set_memory_region(struct kvm *kvm,
 392                             struct kvm_userspace_memory_region *mem,
 393                             int user_alloc);
 394 gfn_t unalias_gfn(struct kvm *kvm, gfn_t gfn);
 395 struct page *gfn_to_page(struct kvm *kvm, gfn_t gfn);
 396 void kvm_release_page_clean(struct page *page);
 397 void kvm_release_page_dirty(struct page *page);
 398 int kvm_read_guest_page(struct kvm *kvm, gfn_t gfn, void *data, int offset,
 399                         int len);
 400 int kvm_read_guest(struct kvm *kvm, gpa_t gpa, void *data, unsigned long len);
 401 int kvm_write_guest_page(struct kvm *kvm, gfn_t gfn, const void *data,
 402                          int offset, int len);
 403 int kvm_write_guest(struct kvm *kvm, gpa_t gpa, const void *data,
 404                     unsigned long len);
 405 int kvm_clear_guest_page(struct kvm *kvm, gfn_t gfn, int offset, int len);
 406 int kvm_clear_guest(struct kvm *kvm, gpa_t gpa, unsigned long len);
 407 struct kvm_memory_slot *gfn_to_memslot(struct kvm *kvm, gfn_t gfn);
 408 int kvm_is_visible_gfn(struct kvm *kvm, gfn_t gfn);
 409 void mark_page_dirty(struct kvm *kvm, gfn_t gfn);
 410
 411 void kvm_vcpu_block(struct kvm_vcpu *vcpu);
 412 void kvm_resched(struct kvm_vcpu *vcpu);
 413 void kvm_load_guest_fpu(struct kvm_vcpu *vcpu);
 414 void kvm_put_guest_fpu(struct kvm_vcpu *vcpu);
 415 void kvm_flush_remote_tlbs(struct kvm *kvm);
 416
 417 long kvm_arch_dev_ioctl(struct file *filp,
 418                         unsigned int ioctl, unsigned long arg);
 419 long kvm_arch_vcpu_ioctl(struct file *filp,
 420                          unsigned int ioctl, unsigned long arg);
 421 void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu);
 422 void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu);
 423
 424 int kvm_dev_ioctl_check_extension(long ext);
 425
 426 int kvm_get_dirty_log(struct kvm *kvm,
 427                         struct kvm_dirty_log *log, int *is_dirty);
 428 int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm,
 429                                 struct kvm_dirty_log *log);
 430
 431 int kvm_vm_ioctl_set_memory_region(struct kvm *kvm,
 432                                    struct
 433                                    kvm_userspace_memory_region *mem,
 434                                    int user_alloc);
 435 long kvm_arch_vm_ioctl(struct file *filp,
 436                        unsigned int ioctl, unsigned long arg);
 437 void kvm_arch_destroy_vm(struct kvm *kvm);
 438
 439 int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu);
 440 int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu);
 441
 442 int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu,
 443                                     struct kvm_translation *tr);
 444
 445 int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs);
 446 int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs);
 447 int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu,
 448                                   struct kvm_sregs *sregs);
 449 int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu,
 450                                   struct kvm_sregs *sregs);
 451 int kvm_arch_vcpu_ioctl_debug_guest(struct kvm_vcpu *vcpu,
 452                                     struct kvm_debug_guest *dbg);
 453 int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run);
 454
 455 int kvm_arch_init(void *opaque);
 456 void kvm_arch_exit(void);
 457
 458 int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu);
 459 void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu);
 460
 461 void kvm_arch_vcpu_free(struct kvm_vcpu *vcpu);
 462 void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu);
 463 void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu);
 464 struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm, unsigned int id);
 465 void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu);
 466
 467 int kvm_arch_vcpu_reset(struct kvm_vcpu *vcpu);
 468 void kvm_arch_hardware_enable(void *garbage);
 469 void kvm_arch_hardware_disable(void *garbage);
 470 int kvm_arch_hardware_setup(void);
 471 void kvm_arch_hardware_unsetup(void);
 472 void kvm_arch_check_processor_compat(void *rtn);
 473
 474 void kvm_free_physmem(struct kvm *kvm);
 475
 476 struct  kvm *kvm_arch_create_vm(void);
 477 void kvm_arch_destroy_vm(struct kvm *kvm);
 478
 479 static inline void kvm_guest_enter(void)
 480 {
 481         account_system_vtime(current);
 482         current->flags |= PF_VCPU;
 483 }
 484
 485 static inline void kvm_guest_exit(void)
 486 {
 487         account_system_vtime(current);
 488         current->flags &= ~PF_VCPU;
 489 }
 490
 491 static inline int memslot_id(struct kvm *kvm, struct kvm_memory_slot *slot)
 492 {
 493         return slot - kvm->memslots;
 494 }
 495
 496
 497 enum kvm_stat_kind {
 498         KVM_STAT_VM,
 499         KVM_STAT_VCPU,
 500 };
 501
 502 struct kvm_stats_debugfs_item {
 503         const char *name;
 504         int offset;
 505         enum kvm_stat_kind kind;
 506         struct dentry *dentry;
 507 };
 508 extern struct kvm_stats_debugfs_item debugfs_entries[];
 509
 510 #endif