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/vmalloc.h>
  23 #include <linux/rcupdate.h>
  24 #include <linux/ratelimit.h>
  25 #include <linux/err.h>
  26 #include <linux/irqflags.h>
  27 #include <linux/context_tracking.h>
  28 #include <linux/irqbypass.h>
  29 #include <linux/swait.h>
  30 #include <linux/refcount.h>
  31 #include <asm/signal.h>
  32
  33 #include <linux/kvm.h>
  34 #include <linux/kvm_para.h>
  35
  36 #include <linux/kvm_types.h>
  37
  38 #include <asm/kvm_host.h>
  39
  40 #ifndef KVM_MAX_VCPU_ID
  41 #define KVM_MAX_VCPU_ID KVM_MAX_VCPUS
  42 #endif
  43
  44 /*
  45  * The bit 16 ~ bit 31 of kvm_memory_region::flags are internally used
  46  * in kvm, other bits are visible for userspace which are defined in
  47  * include/linux/kvm_h.
  48  */
  49 #define KVM_MEMSLOT_INVALID     (1UL << 16)
  50
  51 /*
  52  * Bit 63 of the memslot generation number is an "update in-progress flag",
  53  * e.g. is temporarily set for the duration of install_new_memslots().
  54  * This flag effectively creates a unique generation number that is used to
  55  * mark cached memslot data, e.g. MMIO accesses, as potentially being stale,
  56  * i.e. may (or may not) have come from the previous memslots generation.
  57  *
  58  * This is necessary because the actual memslots update is not atomic with
  59  * respect to the generation number update.  Updating the generation number
  60  * first would allow a vCPU to cache a spte from the old memslots using the
  61  * new generation number, and updating the generation number after switching
  62  * to the new memslots would allow cache hits using the old generation number
  63  * to reference the defunct memslots.
  64  *
  65  * This mechanism is used to prevent getting hits in KVM's caches while a
  66  * memslot update is in-progress, and to prevent cache hits *after* updating
  67  * the actual generation number against accesses that were inserted into the
  68  * cache *before* the memslots were updated.
  69  */
  70 #define KVM_MEMSLOT_GEN_UPDATE_IN_PROGRESS      BIT_ULL(63)
  71
  72 /* Two fragments for cross MMIO pages. */
  73 #define KVM_MAX_MMIO_FRAGMENTS  2
  74
  75 #ifndef KVM_ADDRESS_SPACE_NUM
  76 #define KVM_ADDRESS_SPACE_NUM   1
  77 #endif
  78
  79 /*
  80  * For the normal pfn, the highest 12 bits should be zero,
  81  * so we can mask bit 62 ~ bit 52  to indicate the error pfn,
  82  * mask bit 63 to indicate the noslot pfn.
  83  */
  84 #define KVM_PFN_ERR_MASK        (0x7ffULL << 52)
  85 #define KVM_PFN_ERR_NOSLOT_MASK (0xfffULL << 52)
  86 #define KVM_PFN_NOSLOT          (0x1ULL << 63)
  87
  88 #define KVM_PFN_ERR_FAULT       (KVM_PFN_ERR_MASK)
  89 #define KVM_PFN_ERR_HWPOISON    (KVM_PFN_ERR_MASK + 1)
  90 #define KVM_PFN_ERR_RO_FAULT    (KVM_PFN_ERR_MASK + 2)
  91
  92 /*
  93  * error pfns indicate that the gfn is in slot but faild to
  94  * translate it to pfn on host.
  95  */
  96 static inline bool is_error_pfn(kvm_pfn_t pfn)
  97 {
  98         return !!(pfn & KVM_PFN_ERR_MASK);
  99 }
 100
 101 /*
 102  * error_noslot pfns indicate that the gfn can not be
 103  * translated to pfn - it is not in slot or failed to
 104  * translate it to pfn.
 105  */
 106 static inline bool is_error_noslot_pfn(kvm_pfn_t pfn)
 107 {
 108         return !!(pfn & KVM_PFN_ERR_NOSLOT_MASK);
 109 }
 110
 111 /* noslot pfn indicates that the gfn is not in slot. */
 112 static inline bool is_noslot_pfn(kvm_pfn_t pfn)
 113 {
 114         return pfn == KVM_PFN_NOSLOT;
 115 }
 116
 117 /*
 118  * architectures with KVM_HVA_ERR_BAD other than PAGE_OFFSET (e.g. s390)
 119  * provide own defines and kvm_is_error_hva
 120  */
 121 #ifndef KVM_HVA_ERR_BAD
 122
 123 #define KVM_HVA_ERR_BAD         (PAGE_OFFSET)
 124 #define KVM_HVA_ERR_RO_BAD      (PAGE_OFFSET + PAGE_SIZE)
 125
 126 static inline bool kvm_is_error_hva(unsigned long addr)
 127 {
 128         return addr >= PAGE_OFFSET;
 129 }
 130
 131 #endif
 132
 133 #define KVM_ERR_PTR_BAD_PAGE    (ERR_PTR(-ENOENT))
 134
 135 static inline bool is_error_page(struct page *page)
 136 {
 137         return IS_ERR(page);
 138 }
 139
 140 #define KVM_REQUEST_MASK           GENMASK(7,0)
 141 #define KVM_REQUEST_NO_WAKEUP      BIT(8)
 142 #define KVM_REQUEST_WAIT           BIT(9)
 143 /*
 144  * Architecture-independent vcpu->requests bit members
 145  * Bits 4-7 are reserved for more arch-independent bits.
 146  */
 147 #define KVM_REQ_TLB_FLUSH         (0 | KVM_REQUEST_WAIT | KVM_REQUEST_NO_WAKEUP)
 148 #define KVM_REQ_MMU_RELOAD        (1 | KVM_REQUEST_WAIT | KVM_REQUEST_NO_WAKEUP)
 149 #define KVM_REQ_PENDING_TIMER     2
 150 #define KVM_REQ_UNHALT            3
 151 #define KVM_REQUEST_ARCH_BASE     8
 152
 153 #define KVM_ARCH_REQ_FLAGS(nr, flags) ({ \
 154         BUILD_BUG_ON((unsigned)(nr) >= (FIELD_SIZEOF(struct kvm_vcpu, requests) * 8) - KVM_REQUEST_ARCH_BASE); \
 155         (unsigned)(((nr) + KVM_REQUEST_ARCH_BASE) | (flags)); \
 156 })
 157 #define KVM_ARCH_REQ(nr)           KVM_ARCH_REQ_FLAGS(nr, 0)
 158
 159 #define KVM_USERSPACE_IRQ_SOURCE_ID             0
 160 #define KVM_IRQFD_RESAMPLE_IRQ_SOURCE_ID        1
 161
 162 extern struct kmem_cache *kvm_vcpu_cache;
 163
 164 extern spinlock_t kvm_lock;
 165 extern struct list_head vm_list;
 166
 167 struct kvm_io_range {
 168         gpa_t addr;
 169         int len;
 170         struct kvm_io_device *dev;
 171 };
 172
 173 #define NR_IOBUS_DEVS 1000
 174
 175 struct kvm_io_bus {
 176         int dev_count;
 177         int ioeventfd_count;
 178         struct kvm_io_range range[];
 179 };
 180
 181 enum kvm_bus {
 182         KVM_MMIO_BUS,
 183         KVM_PIO_BUS,
 184         KVM_VIRTIO_CCW_NOTIFY_BUS,
 185         KVM_FAST_MMIO_BUS,
 186         KVM_NR_BUSES
 187 };
 188
 189 int kvm_io_bus_write(struct kvm_vcpu *vcpu, enum kvm_bus bus_idx, gpa_t addr,
 190                      int len, const void *val);
 191 int kvm_io_bus_write_cookie(struct kvm_vcpu *vcpu, enum kvm_bus bus_idx,
 192                             gpa_t addr, int len, const void *val, long cookie);
 193 int kvm_io_bus_read(struct kvm_vcpu *vcpu, enum kvm_bus bus_idx, gpa_t addr,
 194                     int len, void *val);
 195 int kvm_io_bus_register_dev(struct kvm *kvm, enum kvm_bus bus_idx, gpa_t addr,
 196                             int len, struct kvm_io_device *dev);
 197 void kvm_io_bus_unregister_dev(struct kvm *kvm, enum kvm_bus bus_idx,
 198                                struct kvm_io_device *dev);
 199 struct kvm_io_device *kvm_io_bus_get_dev(struct kvm *kvm, enum kvm_bus bus_idx,
 200                                          gpa_t addr);
 201
 202 #ifdef CONFIG_KVM_ASYNC_PF
 203 struct kvm_async_pf {
 204         struct work_struct work;
 205         struct list_head link;
 206         struct list_head queue;
 207         struct kvm_vcpu *vcpu;
 208         struct mm_struct *mm;
 209         gva_t gva;
 210         unsigned long addr;
 211         struct kvm_arch_async_pf arch;
 212         bool   wakeup_all;
 213 };
 214
 215 void kvm_clear_async_pf_completion_queue(struct kvm_vcpu *vcpu);
 216 void kvm_check_async_pf_completion(struct kvm_vcpu *vcpu);
 217 int kvm_setup_async_pf(struct kvm_vcpu *vcpu, gva_t gva, unsigned long hva,
 218                        struct kvm_arch_async_pf *arch);
 219 int kvm_async_pf_wakeup_all(struct kvm_vcpu *vcpu);
 220 #endif
 221
 222 enum {
 223         OUTSIDE_GUEST_MODE,
 224         IN_GUEST_MODE,
 225         EXITING_GUEST_MODE,
 226         READING_SHADOW_PAGE_TABLES,
 227 };
 228
 229 /*
 230  * Sometimes a large or cross-page mmio needs to be broken up into separate
 231  * exits for userspace servicing.
 232  */
 233 struct kvm_mmio_fragment {
 234         gpa_t gpa;
 235         void *data;
 236         unsigned len;
 237 };
 238
 239 struct kvm_vcpu {
 240         struct kvm *kvm;
 241 #ifdef CONFIG_PREEMPT_NOTIFIERS
 242         struct preempt_notifier preempt_notifier;
 243 #endif
 244         int cpu;
 245         int vcpu_id;
 246         int srcu_idx;
 247         int mode;
 248         u64 requests;
 249         unsigned long guest_debug;
 250
 251         int pre_pcpu;
 252         struct list_head blocked_vcpu_list;
 253
 254         struct mutex mutex;
 255         struct kvm_run *run;
 256
 257         int guest_xcr0_loaded;
 258         struct swait_queue_head wq;
 259         struct pid __rcu *pid;
 260         int sigset_active;
 261         sigset_t sigset;
 262         struct kvm_vcpu_stat stat;
 263         unsigned int halt_poll_ns;
 264         bool valid_wakeup;
 265
 266 #ifdef CONFIG_HAS_IOMEM
 267         int mmio_needed;
 268         int mmio_read_completed;
 269         int mmio_is_write;
 270         int mmio_cur_fragment;
 271         int mmio_nr_fragments;
 272         struct kvm_mmio_fragment mmio_fragments[KVM_MAX_MMIO_FRAGMENTS];
 273 #endif
 274
 275 #ifdef CONFIG_KVM_ASYNC_PF
 276         struct {
 277                 u32 queued;
 278                 struct list_head queue;
 279                 struct list_head done;
 280                 spinlock_t lock;
 281         } async_pf;
 282 #endif
 283
 284 #ifdef CONFIG_HAVE_KVM_CPU_RELAX_INTERCEPT
 285         /*
 286          * Cpu relax intercept or pause loop exit optimization
 287          * in_spin_loop: set when a vcpu does a pause loop exit
 288          *  or cpu relax intercepted.
 289          * dy_eligible: indicates whether vcpu is eligible for directed yield.
 290          */
 291         struct {
 292                 bool in_spin_loop;
 293                 bool dy_eligible;
 294         } spin_loop;
 295 #endif
 296         bool preempted;
 297         struct kvm_vcpu_arch arch;
 298         struct dentry *debugfs_dentry;
 299 };
 300
 301 static inline int kvm_vcpu_exiting_guest_mode(struct kvm_vcpu *vcpu)
 302 {
 303         /*
 304          * The memory barrier ensures a previous write to vcpu->requests cannot
 305          * be reordered with the read of vcpu->mode.  It pairs with the general
 306          * memory barrier following the write of vcpu->mode in VCPU RUN.
 307          */
 308         smp_mb__before_atomic();
 309         return cmpxchg(&vcpu->mode, IN_GUEST_MODE, EXITING_GUEST_MODE);
 310 }
 311
 312 /*
 313  * Some of the bitops functions do not support too long bitmaps.
 314  * This number must be determined not to exceed such limits.
 315  */
 316 #define KVM_MEM_MAX_NR_PAGES ((1UL << 31) - 1)
 317
 318 struct kvm_memory_slot {
 319         gfn_t base_gfn;
 320         unsigned long npages;
 321         unsigned long *dirty_bitmap;
 322         struct kvm_arch_memory_slot arch;
 323         unsigned long userspace_addr;
 324         u32 flags;
 325         short id;
 326 };
 327
 328 static inline unsigned long kvm_dirty_bitmap_bytes(struct kvm_memory_slot *memslot)
 329 {
 330         return ALIGN(memslot->npages, BITS_PER_LONG) / 8;
 331 }
 332
 333 static inline unsigned long *kvm_second_dirty_bitmap(struct kvm_memory_slot *memslot)
 334 {
 335         unsigned long len = kvm_dirty_bitmap_bytes(memslot);
 336
 337         return memslot->dirty_bitmap + len / sizeof(*memslot->dirty_bitmap);
 338 }
 339
 340 struct kvm_s390_adapter_int {
 341         u64 ind_addr;
 342         u64 summary_addr;
 343         u64 ind_offset;
 344         u32 summary_offset;
 345         u32 adapter_id;
 346 };
 347
 348 struct kvm_hv_sint {
 349         u32 vcpu;
 350         u32 sint;
 351 };
 352
 353 struct kvm_kernel_irq_routing_entry {
 354         u32 gsi;
 355         u32 type;
 356         int (*set)(struct kvm_kernel_irq_routing_entry *e,
 357                    struct kvm *kvm, int irq_source_id, int level,
 358                    bool line_status);
 359         union {
 360                 struct {
 361                         unsigned irqchip;
 362                         unsigned pin;
 363                 } irqchip;
 364                 struct {
 365                         u32 address_lo;
 366                         u32 address_hi;
 367                         u32 data;
 368                         u32 flags;
 369                         u32 devid;
 370                 } msi;
 371                 struct kvm_s390_adapter_int adapter;
 372                 struct kvm_hv_sint hv_sint;
 373         };
 374         struct hlist_node link;
 375 };
 376
 377 #ifdef CONFIG_HAVE_KVM_IRQ_ROUTING
 378 struct kvm_irq_routing_table {
 379         int chip[KVM_NR_IRQCHIPS][KVM_IRQCHIP_NUM_PINS];
 380         u32 nr_rt_entries;
 381         /*
 382          * Array indexed by gsi. Each entry contains list of irq chips
 383          * the gsi is connected to.
 384          */
 385         struct hlist_head map[0];
 386 };
 387 #endif
 388
 389 #ifndef KVM_PRIVATE_MEM_SLOTS
 390 #define KVM_PRIVATE_MEM_SLOTS 0
 391 #endif
 392
 393 #ifndef KVM_MEM_SLOTS_NUM
 394 #define KVM_MEM_SLOTS_NUM (KVM_USER_MEM_SLOTS + KVM_PRIVATE_MEM_SLOTS)
 395 #endif
 396
 397 #ifndef __KVM_VCPU_MULTIPLE_ADDRESS_SPACE
 398 static inline int kvm_arch_vcpu_memslots_id(struct kvm_vcpu *vcpu)
 399 {
 400         return 0;
 401 }
 402 #endif
 403
 404 /*
 405  * Note:
 406  * memslots are not sorted by id anymore, please use id_to_memslot()
 407  * to get the memslot by its id.
 408  */
 409 struct kvm_memslots {
 410         u64 generation;
 411         struct kvm_memory_slot memslots[KVM_MEM_SLOTS_NUM];
 412         /* The mapping table from slot id to the index in memslots[]. */
 413         short id_to_index[KVM_MEM_SLOTS_NUM];
 414         atomic_t lru_slot;
 415         int used_slots;
 416 };
 417
 418 struct kvm {
 419         spinlock_t mmu_lock;
 420         struct mutex slots_lock;
 421         struct mm_struct *mm; /* userspace tied to this vm */
 422         struct kvm_memslots __rcu *memslots[KVM_ADDRESS_SPACE_NUM];
 423         struct kvm_vcpu *vcpus[KVM_MAX_VCPUS];
 424
 425         /*
 426          * created_vcpus is protected by kvm->lock, and is incremented
 427          * at the beginning of KVM_CREATE_VCPU.  online_vcpus is only
 428          * incremented after storing the kvm_vcpu pointer in vcpus,
 429          * and is accessed atomically.
 430          */
 431         atomic_t online_vcpus;
 432         int created_vcpus;
 433         int last_boosted_vcpu;
 434         struct list_head vm_list;
 435         struct mutex lock;
 436         struct kvm_io_bus __rcu *buses[KVM_NR_BUSES];
 437 #ifdef CONFIG_HAVE_KVM_EVENTFD
 438         struct {
 439                 spinlock_t        lock;
 440                 struct list_head  items;
 441                 struct list_head  resampler_list;
 442                 struct mutex      resampler_lock;
 443         } irqfds;
 444         struct list_head ioeventfds;
 445 #endif
 446         struct kvm_vm_stat stat;
 447         struct kvm_arch arch;
 448         refcount_t users_count;
 449 #ifdef CONFIG_KVM_MMIO
 450         struct kvm_coalesced_mmio_ring *coalesced_mmio_ring;
 451         spinlock_t ring_lock;
 452         struct list_head coalesced_zones;
 453 #endif
 454
 455         struct mutex irq_lock;
 456 #ifdef CONFIG_HAVE_KVM_IRQCHIP
 457         /*
 458          * Update side is protected by irq_lock.
 459          */
 460         struct kvm_irq_routing_table __rcu *irq_routing;
 461 #endif
 462 #ifdef CONFIG_HAVE_KVM_IRQFD
 463         struct hlist_head irq_ack_notifier_list;
 464 #endif
 465
 466 #if defined(CONFIG_MMU_NOTIFIER) && defined(KVM_ARCH_WANT_MMU_NOTIFIER)
 467         struct mmu_notifier mmu_notifier;
 468         unsigned long mmu_notifier_seq;
 469         long mmu_notifier_count;
 470 #endif
 471         long tlbs_dirty;
 472         struct list_head devices;
 473         bool manual_dirty_log_protect;
 474         struct dentry *debugfs_dentry;
 475         struct kvm_stat_data **debugfs_stat_data;
 476         struct srcu_struct srcu;
 477         struct srcu_struct irq_srcu;
 478         pid_t userspace_pid;
 479 };
 480
 481 #define kvm_err(fmt, ...) \
 482         pr_err("kvm [%i]: " fmt, task_pid_nr(current), ## __VA_ARGS__)
 483 #define kvm_info(fmt, ...) \
 484         pr_info("kvm [%i]: " fmt, task_pid_nr(current), ## __VA_ARGS__)
 485 #define kvm_debug(fmt, ...) \
 486         pr_debug("kvm [%i]: " fmt, task_pid_nr(current), ## __VA_ARGS__)
 487 #define kvm_debug_ratelimited(fmt, ...) \
 488         pr_debug_ratelimited("kvm [%i]: " fmt, task_pid_nr(current), \
 489                              ## __VA_ARGS__)
 490 #define kvm_pr_unimpl(fmt, ...) \
 491         pr_err_ratelimited("kvm [%i]: " fmt, \
 492                            task_tgid_nr(current), ## __VA_ARGS__)
 493
 494 /* The guest did something we don't support. */
 495 #define vcpu_unimpl(vcpu, fmt, ...)                                     \
 496         kvm_pr_unimpl("vcpu%i, guest rIP: 0x%lx " fmt,                  \
 497                         (vcpu)->vcpu_id, kvm_rip_read(vcpu), ## __VA_ARGS__)
 498
 499 #define vcpu_debug(vcpu, fmt, ...)                                      \
 500         kvm_debug("vcpu%i " fmt, (vcpu)->vcpu_id, ## __VA_ARGS__)
 501 #define vcpu_debug_ratelimited(vcpu, fmt, ...)                          \
 502         kvm_debug_ratelimited("vcpu%i " fmt, (vcpu)->vcpu_id,           \
 503                               ## __VA_ARGS__)
 504 #define vcpu_err(vcpu, fmt, ...)                                        \
 505         kvm_err("vcpu%i " fmt, (vcpu)->vcpu_id, ## __VA_ARGS__)
 506
 507 static inline struct kvm_io_bus *kvm_get_bus(struct kvm *kvm, enum kvm_bus idx)
 508 {
 509         return srcu_dereference_check(kvm->buses[idx], &kvm->srcu,
 510                                       lockdep_is_held(&kvm->slots_lock) ||
 511                                       !refcount_read(&kvm->users_count));
 512 }
 513
 514 static inline struct kvm_vcpu *kvm_get_vcpu(struct kvm *kvm, int i)
 515 {
 516         /* Pairs with smp_wmb() in kvm_vm_ioctl_create_vcpu, in case
 517          * the caller has read kvm->online_vcpus before (as is the case
 518          * for kvm_for_each_vcpu, for example).
 519          */
 520         smp_rmb();
 521         return kvm->vcpus[i];
 522 }
 523
 524 #define kvm_for_each_vcpu(idx, vcpup, kvm) \
 525         for (idx = 0; \
 526              idx < atomic_read(&kvm->online_vcpus) && \
 527              (vcpup = kvm_get_vcpu(kvm, idx)) != NULL; \
 528              idx++)
 529
 530 static inline struct kvm_vcpu *kvm_get_vcpu_by_id(struct kvm *kvm, int id)
 531 {
 532         struct kvm_vcpu *vcpu = NULL;
 533         int i;
 534
 535         if (id < 0)
 536                 return NULL;
 537         if (id < KVM_MAX_VCPUS)
 538                 vcpu = kvm_get_vcpu(kvm, id);
 539         if (vcpu && vcpu->vcpu_id == id)
 540                 return vcpu;
 541         kvm_for_each_vcpu(i, vcpu, kvm)
 542                 if (vcpu->vcpu_id == id)
 543                         return vcpu;
 544         return NULL;
 545 }
 546
 547 static inline int kvm_vcpu_get_idx(struct kvm_vcpu *vcpu)
 548 {
 549         struct kvm_vcpu *tmp;
 550         int idx;
 551
 552         kvm_for_each_vcpu(idx, tmp, vcpu->kvm)
 553                 if (tmp == vcpu)
 554                         return idx;
 555         BUG();
 556 }
 557
 558 #define kvm_for_each_memslot(memslot, slots)    \
 559         for (memslot = &slots->memslots[0];     \
 560               memslot < slots->memslots + KVM_MEM_SLOTS_NUM && memslot->npages;\
 561                 memslot++)
 562
 563 int kvm_vcpu_init(struct kvm_vcpu *vcpu, struct kvm *kvm, unsigned id);
 564 void kvm_vcpu_uninit(struct kvm_vcpu *vcpu);
 565
 566 void vcpu_load(struct kvm_vcpu *vcpu);
 567 void vcpu_put(struct kvm_vcpu *vcpu);
 568
 569 #ifdef __KVM_HAVE_IOAPIC
 570 void kvm_arch_post_irq_ack_notifier_list_update(struct kvm *kvm);
 571 void kvm_arch_post_irq_routing_update(struct kvm *kvm);
 572 #else
 573 static inline void kvm_arch_post_irq_ack_notifier_list_update(struct kvm *kvm)
 574 {
 575 }
 576 static inline void kvm_arch_post_irq_routing_update(struct kvm *kvm)
 577 {
 578 }
 579 #endif
 580
 581 #ifdef CONFIG_HAVE_KVM_IRQFD
 582 int kvm_irqfd_init(void);
 583 void kvm_irqfd_exit(void);
 584 #else
 585 static inline int kvm_irqfd_init(void)
 586 {
 587         return 0;
 588 }
 589
 590 static inline void kvm_irqfd_exit(void)
 591 {
 592 }
 593 #endif
 594 int kvm_init(void *opaque, unsigned vcpu_size, unsigned vcpu_align,
 595                   struct module *module);
 596 void kvm_exit(void);
 597
 598 void kvm_get_kvm(struct kvm *kvm);
 599 void kvm_put_kvm(struct kvm *kvm);
 600
 601 static inline struct kvm_memslots *__kvm_memslots(struct kvm *kvm, int as_id)
 602 {
 603         return srcu_dereference_check(kvm->memslots[as_id], &kvm->srcu,
 604                         lockdep_is_held(&kvm->slots_lock) ||
 605                         !refcount_read(&kvm->users_count));
 606 }
 607
 608 static inline struct kvm_memslots *kvm_memslots(struct kvm *kvm)
 609 {
 610         return __kvm_memslots(kvm, 0);
 611 }
 612
 613 static inline struct kvm_memslots *kvm_vcpu_memslots(struct kvm_vcpu *vcpu)
 614 {
 615         int as_id = kvm_arch_vcpu_memslots_id(vcpu);
 616
 617         return __kvm_memslots(vcpu->kvm, as_id);
 618 }
 619
 620 static inline struct kvm_memory_slot *
 621 id_to_memslot(struct kvm_memslots *slots, int id)
 622 {
 623         int index = slots->id_to_index[id];
 624         struct kvm_memory_slot *slot;
 625
 626         slot = &slots->memslots[index];
 627
 628         WARN_ON(slot->id != id);
 629         return slot;
 630 }
 631
 632 /*
 633  * KVM_SET_USER_MEMORY_REGION ioctl allows the following operations:
 634  * - create a new memory slot
 635  * - delete an existing memory slot
 636  * - modify an existing memory slot
 637  *   -- move it in the guest physical memory space
 638  *   -- just change its flags
 639  *
 640  * Since flags can be changed by some of these operations, the following
 641  * differentiation is the best we can do for __kvm_set_memory_region():
 642  */
 643 enum kvm_mr_change {
 644         KVM_MR_CREATE,
 645         KVM_MR_DELETE,
 646         KVM_MR_MOVE,
 647         KVM_MR_FLAGS_ONLY,
 648 };
 649
 650 int kvm_set_memory_region(struct kvm *kvm,
 651                           const struct kvm_userspace_memory_region *mem);
 652 int __kvm_set_memory_region(struct kvm *kvm,
 653                             const struct kvm_userspace_memory_region *mem);
 654 void kvm_arch_free_memslot(struct kvm *kvm, struct kvm_memory_slot *free,
 655                            struct kvm_memory_slot *dont);
 656 int kvm_arch_create_memslot(struct kvm *kvm, struct kvm_memory_slot *slot,
 657                             unsigned long npages);
 658 void kvm_arch_memslots_updated(struct kvm *kvm, u64 gen);
 659 int kvm_arch_prepare_memory_region(struct kvm *kvm,
 660                                 struct kvm_memory_slot *memslot,
 661                                 const struct kvm_userspace_memory_region *mem,
 662                                 enum kvm_mr_change change);
 663 void kvm_arch_commit_memory_region(struct kvm *kvm,
 664                                 const struct kvm_userspace_memory_region *mem,
 665                                 const struct kvm_memory_slot *old,
 666                                 const struct kvm_memory_slot *new,
 667                                 enum kvm_mr_change change);
 668 bool kvm_largepages_enabled(void);
 669 void kvm_disable_largepages(void);
 670 /* flush all memory translations */
 671 void kvm_arch_flush_shadow_all(struct kvm *kvm);
 672 /* flush memory translations pointing to 'slot' */
 673 void kvm_arch_flush_shadow_memslot(struct kvm *kvm,
 674                                    struct kvm_memory_slot *slot);
 675
 676 int gfn_to_page_many_atomic(struct kvm_memory_slot *slot, gfn_t gfn,
 677                             struct page **pages, int nr_pages);
 678
 679 struct page *gfn_to_page(struct kvm *kvm, gfn_t gfn);
 680 unsigned long gfn_to_hva(struct kvm *kvm, gfn_t gfn);
 681 unsigned long gfn_to_hva_prot(struct kvm *kvm, gfn_t gfn, bool *writable);
 682 unsigned long gfn_to_hva_memslot(struct kvm_memory_slot *slot, gfn_t gfn);
 683 unsigned long gfn_to_hva_memslot_prot(struct kvm_memory_slot *slot, gfn_t gfn,
 684                                       bool *writable);
 685 void kvm_release_page_clean(struct page *page);
 686 void kvm_release_page_dirty(struct page *page);
 687 void kvm_set_page_accessed(struct page *page);
 688
 689 kvm_pfn_t gfn_to_pfn_atomic(struct kvm *kvm, gfn_t gfn);
 690 kvm_pfn_t gfn_to_pfn(struct kvm *kvm, gfn_t gfn);
 691 kvm_pfn_t gfn_to_pfn_prot(struct kvm *kvm, gfn_t gfn, bool write_fault,
 692                       bool *writable);
 693 kvm_pfn_t gfn_to_pfn_memslot(struct kvm_memory_slot *slot, gfn_t gfn);
 694 kvm_pfn_t gfn_to_pfn_memslot_atomic(struct kvm_memory_slot *slot, gfn_t gfn);
 695 kvm_pfn_t __gfn_to_pfn_memslot(struct kvm_memory_slot *slot, gfn_t gfn,
 696                                bool atomic, bool *async, bool write_fault,
 697                                bool *writable);
 698
 699 void kvm_release_pfn_clean(kvm_pfn_t pfn);
 700 void kvm_release_pfn_dirty(kvm_pfn_t pfn);
 701 void kvm_set_pfn_dirty(kvm_pfn_t pfn);
 702 void kvm_set_pfn_accessed(kvm_pfn_t pfn);
 703 void kvm_get_pfn(kvm_pfn_t pfn);
 704
 705 int kvm_read_guest_page(struct kvm *kvm, gfn_t gfn, void *data, int offset,
 706                         int len);
 707 int kvm_read_guest_atomic(struct kvm *kvm, gpa_t gpa, void *data,
 708                           unsigned long len);
 709 int kvm_read_guest(struct kvm *kvm, gpa_t gpa, void *data, unsigned long len);
 710 int kvm_read_guest_cached(struct kvm *kvm, struct gfn_to_hva_cache *ghc,
 711                            void *data, unsigned long len);
 712 int kvm_write_guest_page(struct kvm *kvm, gfn_t gfn, const void *data,
 713                          int offset, int len);
 714 int kvm_write_guest(struct kvm *kvm, gpa_t gpa, const void *data,
 715                     unsigned long len);
 716 int kvm_write_guest_cached(struct kvm *kvm, struct gfn_to_hva_cache *ghc,
 717                            void *data, unsigned long len);
 718 int kvm_write_guest_offset_cached(struct kvm *kvm, struct gfn_to_hva_cache *ghc,
 719                                   void *data, unsigned int offset,
 720                                   unsigned long len);
 721 int kvm_gfn_to_hva_cache_init(struct kvm *kvm, struct gfn_to_hva_cache *ghc,
 722                               gpa_t gpa, unsigned long len);
 723 int kvm_clear_guest_page(struct kvm *kvm, gfn_t gfn, int offset, int len);
 724 int kvm_clear_guest(struct kvm *kvm, gpa_t gpa, unsigned long len);
 725 struct kvm_memory_slot *gfn_to_memslot(struct kvm *kvm, gfn_t gfn);
 726 bool kvm_is_visible_gfn(struct kvm *kvm, gfn_t gfn);
 727 unsigned long kvm_host_page_size(struct kvm *kvm, gfn_t gfn);
 728 void mark_page_dirty(struct kvm *kvm, gfn_t gfn);
 729
 730 struct kvm_memslots *kvm_vcpu_memslots(struct kvm_vcpu *vcpu);
 731 struct kvm_memory_slot *kvm_vcpu_gfn_to_memslot(struct kvm_vcpu *vcpu, gfn_t gfn);
 732 kvm_pfn_t kvm_vcpu_gfn_to_pfn_atomic(struct kvm_vcpu *vcpu, gfn_t gfn);
 733 kvm_pfn_t kvm_vcpu_gfn_to_pfn(struct kvm_vcpu *vcpu, gfn_t gfn);
 734 struct page *kvm_vcpu_gfn_to_page(struct kvm_vcpu *vcpu, gfn_t gfn);
 735 unsigned long kvm_vcpu_gfn_to_hva(struct kvm_vcpu *vcpu, gfn_t gfn);
 736 unsigned long kvm_vcpu_gfn_to_hva_prot(struct kvm_vcpu *vcpu, gfn_t gfn, bool *writable);
 737 int kvm_vcpu_read_guest_page(struct kvm_vcpu *vcpu, gfn_t gfn, void *data, int offset,
 738                              int len);
 739 int kvm_vcpu_read_guest_atomic(struct kvm_vcpu *vcpu, gpa_t gpa, void *data,
 740                                unsigned long len);
 741 int kvm_vcpu_read_guest(struct kvm_vcpu *vcpu, gpa_t gpa, void *data,
 742                         unsigned long len);
 743 int kvm_vcpu_write_guest_page(struct kvm_vcpu *vcpu, gfn_t gfn, const void *data,
 744                               int offset, int len);
 745 int kvm_vcpu_write_guest(struct kvm_vcpu *vcpu, gpa_t gpa, const void *data,
 746                          unsigned long len);
 747 void kvm_vcpu_mark_page_dirty(struct kvm_vcpu *vcpu, gfn_t gfn);
 748
 749 void kvm_sigset_activate(struct kvm_vcpu *vcpu);
 750 void kvm_sigset_deactivate(struct kvm_vcpu *vcpu);
 751
 752 void kvm_vcpu_block(struct kvm_vcpu *vcpu);
 753 void kvm_arch_vcpu_blocking(struct kvm_vcpu *vcpu);
 754 void kvm_arch_vcpu_unblocking(struct kvm_vcpu *vcpu);
 755 bool kvm_vcpu_wake_up(struct kvm_vcpu *vcpu);
 756 void kvm_vcpu_kick(struct kvm_vcpu *vcpu);
 757 int kvm_vcpu_yield_to(struct kvm_vcpu *target);
 758 void kvm_vcpu_on_spin(struct kvm_vcpu *vcpu, bool usermode_vcpu_not_eligible);
 759
 760 void kvm_flush_remote_tlbs(struct kvm *kvm);
 761 void kvm_reload_remote_mmus(struct kvm *kvm);
 762
 763 bool kvm_make_vcpus_request_mask(struct kvm *kvm, unsigned int req,
 764                                  unsigned long *vcpu_bitmap, cpumask_var_t tmp);
 765 bool kvm_make_all_cpus_request(struct kvm *kvm, unsigned int req);
 766
 767 long kvm_arch_dev_ioctl(struct file *filp,
 768                         unsigned int ioctl, unsigned long arg);
 769 long kvm_arch_vcpu_ioctl(struct file *filp,
 770                          unsigned int ioctl, unsigned long arg);
 771 vm_fault_t kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf);
 772
 773 int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext);
 774
 775 int kvm_get_dirty_log(struct kvm *kvm,
 776                         struct kvm_dirty_log *log, int *is_dirty);
 777
 778 int kvm_get_dirty_log_protect(struct kvm *kvm,
 779                               struct kvm_dirty_log *log, bool *flush);
 780 int kvm_clear_dirty_log_protect(struct kvm *kvm,
 781                                 struct kvm_clear_dirty_log *log, bool *flush);
 782
 783 void kvm_arch_mmu_enable_log_dirty_pt_masked(struct kvm *kvm,
 784                                         struct kvm_memory_slot *slot,
 785                                         gfn_t gfn_offset,
 786                                         unsigned long mask);
 787
 788 int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm,
 789                                 struct kvm_dirty_log *log);
 790 int kvm_vm_ioctl_clear_dirty_log(struct kvm *kvm,
 791                                   struct kvm_clear_dirty_log *log);
 792
 793 int kvm_vm_ioctl_irq_line(struct kvm *kvm, struct kvm_irq_level *irq_level,
 794                         bool line_status);
 795 int kvm_vm_ioctl_enable_cap(struct kvm *kvm,
 796                             struct kvm_enable_cap *cap);
 797 long kvm_arch_vm_ioctl(struct file *filp,
 798                        unsigned int ioctl, unsigned long arg);
 799
 800 int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu);
 801 int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu);
 802
 803 int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu,
 804                                     struct kvm_translation *tr);
 805
 806 int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs);
 807 int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs);
 808 int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu,
 809                                   struct kvm_sregs *sregs);
 810 int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu,
 811                                   struct kvm_sregs *sregs);
 812 int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu,
 813                                     struct kvm_mp_state *mp_state);
 814 int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu,
 815                                     struct kvm_mp_state *mp_state);
 816 int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu,
 817                                         struct kvm_guest_debug *dbg);
 818 int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run);
 819
 820 int kvm_arch_init(void *opaque);
 821 void kvm_arch_exit(void);
 822
 823 int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu);
 824 void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu);
 825
 826 void kvm_arch_sched_in(struct kvm_vcpu *vcpu, int cpu);
 827
 828 void kvm_arch_vcpu_free(struct kvm_vcpu *vcpu);
 829 void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu);
 830 void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu);
 831 struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm, unsigned int id);
 832 int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu);
 833 void kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu);
 834 void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu);
 835
 836 bool kvm_arch_has_vcpu_debugfs(void);
 837 int kvm_arch_create_vcpu_debugfs(struct kvm_vcpu *vcpu);
 838
 839 int kvm_arch_hardware_enable(void);
 840 void kvm_arch_hardware_disable(void);
 841 int kvm_arch_hardware_setup(void);
 842 void kvm_arch_hardware_unsetup(void);
 843 void kvm_arch_check_processor_compat(void *rtn);
 844 int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu);
 845 bool kvm_arch_vcpu_in_kernel(struct kvm_vcpu *vcpu);
 846 int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu);
 847
 848 #ifndef __KVM_HAVE_ARCH_VM_ALLOC
 849 /*
 850  * All architectures that want to use vzalloc currently also
 851  * need their own kvm_arch_alloc_vm implementation.
 852  */
 853 static inline struct kvm *kvm_arch_alloc_vm(void)
 854 {
 855         return kzalloc(sizeof(struct kvm), GFP_KERNEL);
 856 }
 857
 858 static inline void kvm_arch_free_vm(struct kvm *kvm)
 859 {
 860         kfree(kvm);
 861 }
 862 #endif
 863
 864 #ifndef __KVM_HAVE_ARCH_FLUSH_REMOTE_TLB
 865 static inline int kvm_arch_flush_remote_tlb(struct kvm *kvm)
 866 {
 867         return -ENOTSUPP;
 868 }
 869 #endif
 870
 871 #ifdef __KVM_HAVE_ARCH_NONCOHERENT_DMA
 872 void kvm_arch_register_noncoherent_dma(struct kvm *kvm);
 873 void kvm_arch_unregister_noncoherent_dma(struct kvm *kvm);
 874 bool kvm_arch_has_noncoherent_dma(struct kvm *kvm);
 875 #else
 876 static inline void kvm_arch_register_noncoherent_dma(struct kvm *kvm)
 877 {
 878 }
 879
 880 static inline void kvm_arch_unregister_noncoherent_dma(struct kvm *kvm)
 881 {
 882 }
 883
 884 static inline bool kvm_arch_has_noncoherent_dma(struct kvm *kvm)
 885 {
 886         return false;
 887 }
 888 #endif
 889 #ifdef __KVM_HAVE_ARCH_ASSIGNED_DEVICE
 890 void kvm_arch_start_assignment(struct kvm *kvm);
 891 void kvm_arch_end_assignment(struct kvm *kvm);
 892 bool kvm_arch_has_assigned_device(struct kvm *kvm);
 893 #else
 894 static inline void kvm_arch_start_assignment(struct kvm *kvm)
 895 {
 896 }
 897
 898 static inline void kvm_arch_end_assignment(struct kvm *kvm)
 899 {
 900 }
 901
 902 static inline bool kvm_arch_has_assigned_device(struct kvm *kvm)
 903 {
 904         return false;
 905 }
 906 #endif
 907
 908 static inline struct swait_queue_head *kvm_arch_vcpu_wq(struct kvm_vcpu *vcpu)
 909 {
 910 #ifdef __KVM_HAVE_ARCH_WQP
 911         return vcpu->arch.wqp;
 912 #else
 913         return &vcpu->wq;
 914 #endif
 915 }
 916
 917 #ifdef __KVM_HAVE_ARCH_INTC_INITIALIZED
 918 /*
 919  * returns true if the virtual interrupt controller is initialized and
 920  * ready to accept virtual IRQ. On some architectures the virtual interrupt
 921  * controller is dynamically instantiated and this is not always true.
 922  */
 923 bool kvm_arch_intc_initialized(struct kvm *kvm);
 924 #else
 925 static inline bool kvm_arch_intc_initialized(struct kvm *kvm)
 926 {
 927         return true;
 928 }
 929 #endif
 930
 931 int kvm_arch_init_vm(struct kvm *kvm, unsigned long type);
 932 void kvm_arch_destroy_vm(struct kvm *kvm);
 933 void kvm_arch_sync_events(struct kvm *kvm);
 934
 935 int kvm_cpu_has_pending_timer(struct kvm_vcpu *vcpu);
 936 void kvm_vcpu_kick(struct kvm_vcpu *vcpu);
 937
 938 bool kvm_is_reserved_pfn(kvm_pfn_t pfn);
 939
 940 struct kvm_irq_ack_notifier {
 941         struct hlist_node link;
 942         unsigned gsi;
 943         void (*irq_acked)(struct kvm_irq_ack_notifier *kian);
 944 };
 945
 946 int kvm_irq_map_gsi(struct kvm *kvm,
 947                     struct kvm_kernel_irq_routing_entry *entries, int gsi);
 948 int kvm_irq_map_chip_pin(struct kvm *kvm, unsigned irqchip, unsigned pin);
 949
 950 int kvm_set_irq(struct kvm *kvm, int irq_source_id, u32 irq, int level,
 951                 bool line_status);
 952 int kvm_set_msi(struct kvm_kernel_irq_routing_entry *irq_entry, struct kvm *kvm,
 953                 int irq_source_id, int level, bool line_status);
 954 int kvm_arch_set_irq_inatomic(struct kvm_kernel_irq_routing_entry *e,
 955                                struct kvm *kvm, int irq_source_id,
 956                                int level, bool line_status);
 957 bool kvm_irq_has_notifier(struct kvm *kvm, unsigned irqchip, unsigned pin);
 958 void kvm_notify_acked_gsi(struct kvm *kvm, int gsi);
 959 void kvm_notify_acked_irq(struct kvm *kvm, unsigned irqchip, unsigned pin);
 960 void kvm_register_irq_ack_notifier(struct kvm *kvm,
 961                                    struct kvm_irq_ack_notifier *kian);
 962 void kvm_unregister_irq_ack_notifier(struct kvm *kvm,
 963                                    struct kvm_irq_ack_notifier *kian);
 964 int kvm_request_irq_source_id(struct kvm *kvm);
 965 void kvm_free_irq_source_id(struct kvm *kvm, int irq_source_id);
 966
 967 /*
 968  * search_memslots() and __gfn_to_memslot() are here because they are
 969  * used in non-modular code in arch/powerpc/kvm/book3s_hv_rm_mmu.c.
 970  * gfn_to_memslot() itself isn't here as an inline because that would
 971  * bloat other code too much.
 972  */
 973 static inline struct kvm_memory_slot *
 974 search_memslots(struct kvm_memslots *slots, gfn_t gfn)
 975 {
 976         int start = 0, end = slots->used_slots;
 977         int slot = atomic_read(&slots->lru_slot);
 978         struct kvm_memory_slot *memslots = slots->memslots;
 979
 980         if (gfn >= memslots[slot].base_gfn &&
 981             gfn < memslots[slot].base_gfn + memslots[slot].npages)
 982                 return &memslots[slot];
 983
 984         while (start < end) {
 985                 slot = start + (end - start) / 2;
 986
 987                 if (gfn >= memslots[slot].base_gfn)
 988                         end = slot;
 989                 else
 990                         start = slot + 1;
 991         }
 992
 993         if (gfn >= memslots[start].base_gfn &&
 994             gfn < memslots[start].base_gfn + memslots[start].npages) {
 995                 atomic_set(&slots->lru_slot, start);
 996                 return &memslots[start];
 997         }
 998
 999         return NULL;
1000 }
1001
1002 static inline struct kvm_memory_slot *
1003 __gfn_to_memslot(struct kvm_memslots *slots, gfn_t gfn)
1004 {
1005         return search_memslots(slots, gfn);
1006 }
1007
1008 static inline unsigned long
1009 __gfn_to_hva_memslot(struct kvm_memory_slot *slot, gfn_t gfn)
1010 {
1011         return slot->userspace_addr + (gfn - slot->base_gfn) * PAGE_SIZE;
1012 }
1013
1014 static inline int memslot_id(struct kvm *kvm, gfn_t gfn)
1015 {
1016         return gfn_to_memslot(kvm, gfn)->id;
1017 }
1018
1019 static inline gfn_t
1020 hva_to_gfn_memslot(unsigned long hva, struct kvm_memory_slot *slot)
1021 {
1022         gfn_t gfn_offset = (hva - slot->userspace_addr) >> PAGE_SHIFT;
1023
1024         return slot->base_gfn + gfn_offset;
1025 }
1026
1027 static inline gpa_t gfn_to_gpa(gfn_t gfn)
1028 {
1029         return (gpa_t)gfn << PAGE_SHIFT;
1030 }
1031
1032 static inline gfn_t gpa_to_gfn(gpa_t gpa)
1033 {
1034         return (gfn_t)(gpa >> PAGE_SHIFT);
1035 }
1036
1037 static inline hpa_t pfn_to_hpa(kvm_pfn_t pfn)
1038 {
1039         return (hpa_t)pfn << PAGE_SHIFT;
1040 }
1041
1042 static inline struct page *kvm_vcpu_gpa_to_page(struct kvm_vcpu *vcpu,
1043                                                 gpa_t gpa)
1044 {
1045         return kvm_vcpu_gfn_to_page(vcpu, gpa_to_gfn(gpa));
1046 }
1047
1048 static inline bool kvm_is_error_gpa(struct kvm *kvm, gpa_t gpa)
1049 {
1050         unsigned long hva = gfn_to_hva(kvm, gpa_to_gfn(gpa));
1051
1052         return kvm_is_error_hva(hva);
1053 }
1054
1055 enum kvm_stat_kind {
1056         KVM_STAT_VM,
1057         KVM_STAT_VCPU,
1058 };
1059
1060 struct kvm_stat_data {
1061         int offset;
1062         struct kvm *kvm;
1063 };
1064
1065 struct kvm_stats_debugfs_item {
1066         const char *name;
1067         int offset;
1068         enum kvm_stat_kind kind;
1069 };
1070 extern struct kvm_stats_debugfs_item debugfs_entries[];
1071 extern struct dentry *kvm_debugfs_dir;
1072
1073 #if defined(CONFIG_MMU_NOTIFIER) && defined(KVM_ARCH_WANT_MMU_NOTIFIER)
1074 static inline int mmu_notifier_retry(struct kvm *kvm, unsigned long mmu_seq)
1075 {
1076         if (unlikely(kvm->mmu_notifier_count))
1077                 return 1;
1078         /*
1079          * Ensure the read of mmu_notifier_count happens before the read
1080          * of mmu_notifier_seq.  This interacts with the smp_wmb() in
1081          * mmu_notifier_invalidate_range_end to make sure that the caller
1082          * either sees the old (non-zero) value of mmu_notifier_count or
1083          * the new (incremented) value of mmu_notifier_seq.
1084          * PowerPC Book3s HV KVM calls this under a per-page lock
1085          * rather than under kvm->mmu_lock, for scalability, so
1086          * can't rely on kvm->mmu_lock to keep things ordered.
1087          */
1088         smp_rmb();
1089         if (kvm->mmu_notifier_seq != mmu_seq)
1090                 return 1;
1091         return 0;
1092 }
1093 #endif
1094
1095 #ifdef CONFIG_HAVE_KVM_IRQ_ROUTING
1096
1097 #define KVM_MAX_IRQ_ROUTES 4096 /* might need extension/rework in the future */
1098
1099 bool kvm_arch_can_set_irq_routing(struct kvm *kvm);
1100 int kvm_set_irq_routing(struct kvm *kvm,
1101                         const struct kvm_irq_routing_entry *entries,
1102                         unsigned nr,
1103                         unsigned flags);
1104 int kvm_set_routing_entry(struct kvm *kvm,
1105                           struct kvm_kernel_irq_routing_entry *e,
1106                           const struct kvm_irq_routing_entry *ue);
1107 void kvm_free_irq_routing(struct kvm *kvm);
1108
1109 #else
1110
1111 static inline void kvm_free_irq_routing(struct kvm *kvm) {}
1112
1113 #endif
1114
1115 int kvm_send_userspace_msi(struct kvm *kvm, struct kvm_msi *msi);
1116
1117 #ifdef CONFIG_HAVE_KVM_EVENTFD
1118
1119 void kvm_eventfd_init(struct kvm *kvm);
1120 int kvm_ioeventfd(struct kvm *kvm, struct kvm_ioeventfd *args);
1121
1122 #ifdef CONFIG_HAVE_KVM_IRQFD
1123 int kvm_irqfd(struct kvm *kvm, struct kvm_irqfd *args);
1124 void kvm_irqfd_release(struct kvm *kvm);
1125 void kvm_irq_routing_update(struct kvm *);
1126 #else
1127 static inline int kvm_irqfd(struct kvm *kvm, struct kvm_irqfd *args)
1128 {
1129         return -EINVAL;
1130 }
1131
1132 static inline void kvm_irqfd_release(struct kvm *kvm) {}
1133 #endif
1134
1135 #else
1136
1137 static inline void kvm_eventfd_init(struct kvm *kvm) {}
1138
1139 static inline int kvm_irqfd(struct kvm *kvm, struct kvm_irqfd *args)
1140 {
1141         return -EINVAL;
1142 }
1143
1144 static inline void kvm_irqfd_release(struct kvm *kvm) {}
1145
1146 #ifdef CONFIG_HAVE_KVM_IRQCHIP
1147 static inline void kvm_irq_routing_update(struct kvm *kvm)
1148 {
1149 }
1150 #endif
1151
1152 static inline int kvm_ioeventfd(struct kvm *kvm, struct kvm_ioeventfd *args)
1153 {
1154         return -ENOSYS;
1155 }
1156
1157 #endif /* CONFIG_HAVE_KVM_EVENTFD */
1158
1159 void kvm_arch_irq_routing_update(struct kvm *kvm);
1160
1161 static inline void kvm_make_request(int req, struct kvm_vcpu *vcpu)
1162 {
1163         /*
1164          * Ensure the rest of the request is published to kvm_check_request's
1165          * caller.  Paired with the smp_mb__after_atomic in kvm_check_request.
1166          */
1167         smp_wmb();
1168         set_bit(req & KVM_REQUEST_MASK, (void *)&vcpu->requests);
1169 }
1170
1171 static inline bool kvm_request_pending(struct kvm_vcpu *vcpu)
1172 {
1173         return READ_ONCE(vcpu->requests);
1174 }
1175
1176 static inline bool kvm_test_request(int req, struct kvm_vcpu *vcpu)
1177 {
1178         return test_bit(req & KVM_REQUEST_MASK, (void *)&vcpu->requests);
1179 }
1180
1181 static inline void kvm_clear_request(int req, struct kvm_vcpu *vcpu)
1182 {
1183         clear_bit(req & KVM_REQUEST_MASK, (void *)&vcpu->requests);
1184 }
1185
1186 static inline bool kvm_check_request(int req, struct kvm_vcpu *vcpu)
1187 {
1188         if (kvm_test_request(req, vcpu)) {
1189                 kvm_clear_request(req, vcpu);
1190
1191                 /*
1192                  * Ensure the rest of the request is visible to kvm_check_request's
1193                  * caller.  Paired with the smp_wmb in kvm_make_request.
1194                  */
1195                 smp_mb__after_atomic();
1196                 return true;
1197         } else {
1198                 return false;
1199         }
1200 }
1201
1202 extern bool kvm_rebooting;
1203
1204 extern unsigned int halt_poll_ns;
1205 extern unsigned int halt_poll_ns_grow;
1206 extern unsigned int halt_poll_ns_grow_start;
1207 extern unsigned int halt_poll_ns_shrink;
1208
1209 struct kvm_device {
1210         struct kvm_device_ops *ops;
1211         struct kvm *kvm;
1212         void *private;
1213         struct list_head vm_node;
1214 };
1215
1216 /* create, destroy, and name are mandatory */
1217 struct kvm_device_ops {
1218         const char *name;
1219
1220         /*
1221          * create is called holding kvm->lock and any operations not suitable
1222          * to do while holding the lock should be deferred to init (see
1223          * below).
1224          */
1225         int (*create)(struct kvm_device *dev, u32 type);
1226
1227         /*
1228          * init is called after create if create is successful and is called
1229          * outside of holding kvm->lock.
1230          */
1231         void (*init)(struct kvm_device *dev);
1232
1233         /*
1234          * Destroy is responsible for freeing dev.
1235          *
1236          * Destroy may be called before or after destructors are called
1237          * on emulated I/O regions, depending on whether a reference is
1238          * held by a vcpu or other kvm component that gets destroyed
1239          * after the emulated I/O.
1240          */
1241         void (*destroy)(struct kvm_device *dev);
1242
1243         int (*set_attr)(struct kvm_device *dev, struct kvm_device_attr *attr);
1244         int (*get_attr)(struct kvm_device *dev, struct kvm_device_attr *attr);
1245         int (*has_attr)(struct kvm_device *dev, struct kvm_device_attr *attr);
1246         long (*ioctl)(struct kvm_device *dev, unsigned int ioctl,
1247                       unsigned long arg);
1248 };
1249
1250 void kvm_device_get(struct kvm_device *dev);
1251 void kvm_device_put(struct kvm_device *dev);
1252 struct kvm_device *kvm_device_from_filp(struct file *filp);
1253 int kvm_register_device_ops(struct kvm_device_ops *ops, u32 type);
1254 void kvm_unregister_device_ops(u32 type);
1255
1256 extern struct kvm_device_ops kvm_mpic_ops;
1257 extern struct kvm_device_ops kvm_arm_vgic_v2_ops;
1258 extern struct kvm_device_ops kvm_arm_vgic_v3_ops;
1259
1260 #ifdef CONFIG_HAVE_KVM_CPU_RELAX_INTERCEPT
1261
1262 static inline void kvm_vcpu_set_in_spin_loop(struct kvm_vcpu *vcpu, bool val)
1263 {
1264         vcpu->spin_loop.in_spin_loop = val;
1265 }
1266 static inline void kvm_vcpu_set_dy_eligible(struct kvm_vcpu *vcpu, bool val)
1267 {
1268         vcpu->spin_loop.dy_eligible = val;
1269 }
1270
1271 #else /* !CONFIG_HAVE_KVM_CPU_RELAX_INTERCEPT */
1272
1273 static inline void kvm_vcpu_set_in_spin_loop(struct kvm_vcpu *vcpu, bool val)
1274 {
1275 }
1276
1277 static inline void kvm_vcpu_set_dy_eligible(struct kvm_vcpu *vcpu, bool val)
1278 {
1279 }
1280 #endif /* CONFIG_HAVE_KVM_CPU_RELAX_INTERCEPT */
1281
1282 #ifdef CONFIG_HAVE_KVM_IRQ_BYPASS
1283 bool kvm_arch_has_irq_bypass(void);
1284 int kvm_arch_irq_bypass_add_producer(struct irq_bypass_consumer *,
1285                            struct irq_bypass_producer *);
1286 void kvm_arch_irq_bypass_del_producer(struct irq_bypass_consumer *,
1287                            struct irq_bypass_producer *);
1288 void kvm_arch_irq_bypass_stop(struct irq_bypass_consumer *);
1289 void kvm_arch_irq_bypass_start(struct irq_bypass_consumer *);
1290 int kvm_arch_update_irqfd_routing(struct kvm *kvm, unsigned int host_irq,
1291                                   uint32_t guest_irq, bool set);
1292 #endif /* CONFIG_HAVE_KVM_IRQ_BYPASS */
1293
1294 #ifdef CONFIG_HAVE_KVM_INVALID_WAKEUPS
1295 /* If we wakeup during the poll time, was it a sucessful poll? */
1296 static inline bool vcpu_valid_wakeup(struct kvm_vcpu *vcpu)
1297 {
1298         return vcpu->valid_wakeup;
1299 }
1300
1301 #else
1302 static inline bool vcpu_valid_wakeup(struct kvm_vcpu *vcpu)
1303 {
1304         return true;
1305 }
1306 #endif /* CONFIG_HAVE_KVM_INVALID_WAKEUPS */
1307
1308 #ifdef CONFIG_HAVE_KVM_VCPU_ASYNC_IOCTL
1309 long kvm_arch_vcpu_async_ioctl(struct file *filp,
1310                                unsigned int ioctl, unsigned long arg);
1311 #else
1312 static inline long kvm_arch_vcpu_async_ioctl(struct file *filp,
1313                                              unsigned int ioctl,
1314                                              unsigned long arg)
1315 {
1316         return -ENOIOCTLCMD;
1317 }
1318 #endif /* CONFIG_HAVE_KVM_VCPU_ASYNC_IOCTL */
1319
1320 int kvm_arch_mmu_notifier_invalidate_range(struct kvm *kvm,
1321                 unsigned long start, unsigned long end, bool blockable);
1322
1323 #ifdef CONFIG_HAVE_KVM_VCPU_RUN_PID_CHANGE
1324 int kvm_arch_vcpu_run_pid_change(struct kvm_vcpu *vcpu);
1325 #else
1326 static inline int kvm_arch_vcpu_run_pid_change(struct kvm_vcpu *vcpu)
1327 {
1328         return 0;
1329 }
1330 #endif /* CONFIG_HAVE_KVM_VCPU_RUN_PID_CHANGE */
1331
1332 #endif