libkvm-all.h

   1 /** \file libkvm.h
   2  * libkvm API
   3  */
   4
   5 #ifndef LIBKVM_H
   6 #define LIBKVM_H
   7
   8 #if defined(__s390__)
   9 #include <asm/ptrace.h>
  10 #endif
  11
  12 #include <stdint.h>
  13
  14 #ifndef __user
  15 #define __user /* temporary, until installed via make headers_install */
  16 #endif
  17
  18 #include <linux/kvm.h>
  19
  20 #include <signal.h>
  21
  22 /* FIXME: share this number with kvm */
  23 /* FIXME: or dynamically alloc/realloc regions */
  24 #ifdef __s390__
  25 #define KVM_MAX_NUM_MEM_REGIONS 1u
  26 #define MAX_VCPUS 64
  27 #define LIBKVM_S390_ORIGIN (0UL)
  28 #elif defined(__ia64__)
  29 #define KVM_MAX_NUM_MEM_REGIONS 32u
  30 #define MAX_VCPUS 256
  31 #else
  32 #define KVM_MAX_NUM_MEM_REGIONS 32u
  33 #define MAX_VCPUS 16
  34 #endif
  35
  36 /* kvm abi verison variable */
  37 extern int kvm_abi;
  38
  39 /**
  40  * \brief The KVM context
  41  *
  42  * The verbose KVM context
  43  */
  44
  45 struct kvm_context {
  46         /// Filedescriptor to /dev/kvm
  47         int fd;
  48         int vm_fd;
  49         /// Callbacks that KVM uses to emulate various unvirtualizable functionality
  50         struct kvm_callbacks *callbacks;
  51         void *opaque;
  52         /// is dirty pages logging enabled for all regions or not
  53         int dirty_pages_log_all;
  54         /// do not create in-kernel irqchip if set
  55         int no_irqchip_creation;
  56         /// in-kernel irqchip status
  57         int irqchip_in_kernel;
  58         /// ioctl to use to inject interrupts
  59         int irqchip_inject_ioctl;
  60         /// do not create in-kernel pit if set
  61         int no_pit_creation;
  62         /// in-kernel pit status
  63         int pit_in_kernel;
  64         /// in-kernel coalesced mmio
  65         int coalesced_mmio;
  66 #ifdef KVM_CAP_IRQ_ROUTING
  67         struct kvm_irq_routing *irq_routes;
  68         int nr_allocated_irq_routes;
  69 #endif
  70         void *used_gsi_bitmap;
  71         int max_gsi;
  72 };
  73
  74 struct kvm_vcpu_context
  75 {
  76         int fd;
  77         struct kvm_run *run;
  78         struct kvm_context *kvm;
  79         uint32_t id;
  80 };
  81
  82 typedef struct kvm_context *kvm_context_t;
  83 typedef struct kvm_vcpu_context *kvm_vcpu_context_t;
  84
  85 #include "kvm.h"
  86 int kvm_alloc_kernel_memory(kvm_context_t kvm, unsigned long memory,
  87                                                                 void **vm_mem);
  88 int kvm_alloc_userspace_memory(kvm_context_t kvm, unsigned long memory,
  89                                                                 void **vm_mem);
  90
  91 int kvm_arch_create(kvm_context_t kvm, unsigned long phys_mem_bytes,
  92                         void **vm_mem);
  93 int kvm_arch_run(kvm_vcpu_context_t vcpu);
  94
  95
  96 void kvm_show_code(kvm_vcpu_context_t vcpu);
  97
  98 int handle_halt(kvm_vcpu_context_t vcpu);
  99 int handle_shutdown(kvm_context_t kvm, void *env);
 100 void post_kvm_run(kvm_context_t kvm, void *env);
 101 int pre_kvm_run(kvm_context_t kvm, void *env);
 102 int handle_io_window(kvm_context_t kvm);
 103 int handle_debug(kvm_vcpu_context_t vcpu, void *env);
 104 int try_push_interrupts(kvm_context_t kvm);
 105
 106
 107 #if defined(__x86_64__) || defined(__i386__)
 108 struct kvm_msr_list *kvm_get_msr_list(kvm_context_t);
 109 int kvm_get_msrs(kvm_vcpu_context_t, struct kvm_msr_entry *msrs, int n);
 110 int kvm_set_msrs(kvm_vcpu_context_t, struct kvm_msr_entry *msrs, int n);
 111 #endif
 112
 113 /*!
 114  * \brief KVM callbacks structure
 115  *
 116  * This structure holds pointers to various functions that KVM will call
 117  * when it encounters something that cannot be virtualized, such as
 118  * accessing hardware devices via MMIO or regular IO.
 119  */
 120 struct kvm_callbacks {
 121         /// For 8bit IO reads from the guest (Usually when executing 'inb')
 122     int (*inb)(void *opaque, uint16_t addr, uint8_t *data);
 123         /// For 16bit IO reads from the guest (Usually when executing 'inw')
 124     int (*inw)(void *opaque, uint16_t addr, uint16_t *data);
 125         /// For 32bit IO reads from the guest (Usually when executing 'inl')
 126     int (*inl)(void *opaque, uint16_t addr, uint32_t *data);
 127         /// For 8bit IO writes from the guest (Usually when executing 'outb')
 128     int (*outb)(void *opaque, uint16_t addr, uint8_t data);
 129         /// For 16bit IO writes from the guest (Usually when executing 'outw')
 130     int (*outw)(void *opaque, uint16_t addr, uint16_t data);
 131         /// For 32bit IO writes from the guest (Usually when executing 'outl')
 132     int (*outl)(void *opaque, uint16_t addr, uint32_t data);
 133         /// generic memory reads to unmapped memory (For MMIO devices)
 134     int (*mmio_read)(void *opaque, uint64_t addr, uint8_t *data,
 135                                         int len);
 136         /// generic memory writes to unmapped memory (For MMIO devices)
 137     int (*mmio_write)(void *opaque, uint64_t addr, uint8_t *data,
 138                                         int len);
 139 #ifdef KVM_CAP_SET_GUEST_DEBUG
 140     int (*debug)(void *opaque, void *env,
 141                  struct kvm_debug_exit_arch *arch_info);
 142 #endif
 143         /*!
 144          * \brief Called when the VCPU issues an 'hlt' instruction.
 145          *
 146          * Typically, you should yeild here to prevent 100% CPU utilization
 147          * on the host CPU.
 148          */
 149     int (*halt)(void *opaque, kvm_vcpu_context_t vcpu);
 150     int (*shutdown)(void *opaque, void *env);
 151     int (*io_window)(void *opaque);
 152     int (*try_push_interrupts)(void *opaque);
 153 #ifdef KVM_CAP_USER_NMI
 154     void (*push_nmi)(void *opaque);
 155 #endif
 156     void (*post_kvm_run)(void *opaque, void *env);
 157     int (*pre_kvm_run)(void *opaque, void *env);
 158     int (*tpr_access)(void *opaque, kvm_vcpu_context_t vcpu, uint64_t rip, int is_write);
 159 #if defined(__s390__)
 160     int (*s390_handle_intercept)(kvm_context_t context, kvm_vcpu_context_t vcpu,
 161         struct kvm_run *run);
 162     int (*s390_handle_reset)(kvm_context_t context, kvm_vcpu_context_t vcpu,
 163          struct kvm_run *run);
 164 #endif
 165     int (*unhandled)(kvm_context_t context, kvm_vcpu_context_t vcpu,
 166                      uint64_t hw_reason);
 167 };
 168
 169 /*!
 170  * \brief Create new KVM context
 171  *
 172  * This creates a new kvm_context. A KVM context is a small area of data that
 173  * holds information about the KVM instance that gets created by this call.\n
 174  * This should always be your first call to KVM.
 175  *
 176  * \param callbacks Pointer to a valid kvm_callbacks structure
 177  * \param opaque Not used
 178  * \return NULL on failure
 179  */
 180 kvm_context_t kvm_init(struct kvm_callbacks *callbacks,
 181                        void *opaque);
 182
 183 /*!
 184  * \brief Cleanup the KVM context
 185  *
 186  * Should always be called when closing down KVM.\n
 187  * Exception: If kvm_init() fails, this function should not be called, as the
 188  * context would be invalid
 189  *
 190  * \param kvm Pointer to the kvm_context that is to be freed
 191  */
 192 void kvm_finalize(kvm_context_t kvm);
 193
 194 /*!
 195  * \brief Disable the in-kernel IRQCHIP creation
 196  *
 197  * In-kernel irqchip is enabled by default. If userspace irqchip is to be used,
 198  * this should be called prior to kvm_create().
 199  *
 200  * \param kvm Pointer to the kvm_context
 201  */
 202 void kvm_disable_irqchip_creation(kvm_context_t kvm);
 203
 204 /*!
 205  * \brief Disable the in-kernel PIT creation
 206  *
 207  * In-kernel pit is enabled by default. If userspace pit is to be used,
 208  * this should be called prior to kvm_create().
 209  *
 210  *  \param kvm Pointer to the kvm_context
 211  */
 212 void kvm_disable_pit_creation(kvm_context_t kvm);
 213
 214 /*!
 215  * \brief Create new virtual machine
 216  *
 217  * This creates a new virtual machine, maps physical RAM to it, and creates a
 218  * virtual CPU for it.\n
 219  * \n
 220  * Memory gets mapped for addresses 0->0xA0000, 0xC0000->phys_mem_bytes
 221  *
 222  * \param kvm Pointer to the current kvm_context
 223  * \param phys_mem_bytes The amount of physical ram you want the VM to have
 224  * \param phys_mem This pointer will be set to point to the memory that
 225  * kvm_create allocates for physical RAM
 226  * \return 0 on success
 227  */
 228 int kvm_create(kvm_context_t kvm,
 229                unsigned long phys_mem_bytes,
 230                void **phys_mem);
 231 int kvm_create_vm(kvm_context_t kvm);
 232 int kvm_check_extension(kvm_context_t kvm, int ext);
 233 void kvm_create_irqchip(kvm_context_t kvm);
 234
 235 /*!
 236  * \brief Create a new virtual cpu
 237  *
 238  * This creates a new virtual cpu (the first vcpu is created by kvm_create()).
 239  * Should be called from a thread dedicated to the vcpu.
 240  *
 241  * \param kvm kvm context
 242  * \param slot vcpu number (> 0)
 243  * \return 0 on success, -errno on failure
 244  */
 245 kvm_vcpu_context_t kvm_create_vcpu(kvm_context_t kvm, int id);
 246
 247 /*!
 248  * \brief Start the VCPU
 249  *
 250  * This starts the VCPU and virtualization is started.\n
 251  * \n
 252  * This function will not return until any of these conditions are met:
 253  * - An IO/MMIO handler does not return "0"
 254  * - An exception that neither the guest OS, nor KVM can handle occurs
 255  *
 256  * \note This function will call the callbacks registered in kvm_init()
 257  * to emulate those functions
 258  * \note If you at any point want to interrupt the VCPU, kvm_run() will
 259  * listen to the EINTR signal. This allows you to simulate external interrupts
 260  * and asyncronous IO.
 261  *
 262  * \param kvm Pointer to the current kvm_context
 263  * \param vcpu Which virtual CPU should be started
 264  * \return 0 on success, but you really shouldn't expect this function to
 265  * return except for when an error has occured, or when you have sent it
 266  * an EINTR signal.
 267  */
 268 int kvm_run(kvm_vcpu_context_t vcpu, void *env);
 269
 270 /*!
 271  * \brief Get interrupt flag from on last exit to userspace
 272  *
 273  * This gets the CPU interrupt flag as it was on the last exit to userspace.
 274  *
 275  * \param kvm Pointer to the current kvm_context
 276  * \param vcpu Which virtual CPU should get dumped
 277  * \return interrupt flag value (0 or 1)
 278  */
 279 int kvm_get_interrupt_flag(kvm_vcpu_context_t vcpu);
 280
 281 /*!
 282  * \brief Get the value of the APIC_BASE msr as of last exit to userspace
 283  *
 284  * This gets the APIC_BASE msr as it was on the last exit to userspace.
 285  *
 286  * \param kvm Pointer to the current kvm_context
 287  * \param vcpu Which virtual CPU should get dumped
 288  * \return APIC_BASE msr contents
 289  */
 290 uint64_t kvm_get_apic_base(kvm_vcpu_context_t vcpu);
 291
 292 /*!
 293  * \brief Check if a vcpu is ready for interrupt injection
 294  *
 295  * This checks if vcpu interrupts are not masked by mov ss or sti.
 296  *
 297  * \param kvm Pointer to the current kvm_context
 298  * \param vcpu Which virtual CPU should get dumped
 299  * \return boolean indicating interrupt injection readiness
 300  */
 301 int kvm_is_ready_for_interrupt_injection(kvm_vcpu_context_t vcpu);
 302
 303 /*!
 304  * \brief Read VCPU registers
 305  *
 306  * This gets the GP registers from the VCPU and outputs them
 307  * into a kvm_regs structure
 308  *
 309  * \note This function returns a \b copy of the VCPUs registers.\n
 310  * If you wish to modify the VCPUs GP registers, you should call kvm_set_regs()
 311  *
 312  * \param kvm Pointer to the current kvm_context
 313  * \param vcpu Which virtual CPU should get dumped
 314  * \param regs Pointer to a kvm_regs which will be populated with the VCPUs
 315  * registers values
 316  * \return 0 on success
 317  */
 318 int kvm_get_regs(kvm_vcpu_context_t vcpu, struct kvm_regs *regs);
 319
 320 /*!
 321  * \brief Write VCPU registers
 322  *
 323  * This sets the GP registers on the VCPU from a kvm_regs structure
 324  *
 325  * \note When this function returns, the regs pointer and the data it points to
 326  * can be discarded
 327  * \param kvm Pointer to the current kvm_context
 328  * \param vcpu Which virtual CPU should get dumped
 329  * \param regs Pointer to a kvm_regs which will be populated with the VCPUs
 330  * registers values
 331  * \return 0 on success
 332  */
 333 int kvm_set_regs(kvm_vcpu_context_t vcpu, struct kvm_regs *regs);
 334 /*!
 335  * \brief Read VCPU fpu registers
 336  *
 337  * This gets the FPU registers from the VCPU and outputs them
 338  * into a kvm_fpu structure
 339  *
 340  * \note This function returns a \b copy of the VCPUs registers.\n
 341  * If you wish to modify the VCPU FPU registers, you should call kvm_set_fpu()
 342  *
 343  * \param kvm Pointer to the current kvm_context
 344  * \param vcpu Which virtual CPU should get dumped
 345  * \param fpu Pointer to a kvm_fpu which will be populated with the VCPUs
 346  * fpu registers values
 347  * \return 0 on success
 348  */
 349 int kvm_get_fpu(kvm_vcpu_context_t vcpu, struct kvm_fpu *fpu);
 350
 351 /*!
 352  * \brief Write VCPU fpu registers
 353  *
 354  * This sets the FPU registers on the VCPU from a kvm_fpu structure
 355  *
 356  * \note When this function returns, the fpu pointer and the data it points to
 357  * can be discarded
 358  * \param kvm Pointer to the current kvm_context
 359  * \param vcpu Which virtual CPU should get dumped
 360  * \param fpu Pointer to a kvm_fpu which holds the new vcpu fpu state
 361  * \return 0 on success
 362  */
 363 int kvm_set_fpu(kvm_vcpu_context_t vcpu, struct kvm_fpu *fpu);
 364
 365 /*!
 366  * \brief Read VCPU system registers
 367  *
 368  * This gets the non-GP registers from the VCPU and outputs them
 369  * into a kvm_sregs structure
 370  *
 371  * \note This function returns a \b copy of the VCPUs registers.\n
 372  * If you wish to modify the VCPUs non-GP registers, you should call
 373  * kvm_set_sregs()
 374  *
 375  * \param kvm Pointer to the current kvm_context
 376  * \param vcpu Which virtual CPU should get dumped
 377  * \param regs Pointer to a kvm_sregs which will be populated with the VCPUs
 378  * registers values
 379  * \return 0 on success
 380  */
 381 int kvm_get_sregs(kvm_vcpu_context_t vcpu, struct kvm_sregs *regs);
 382
 383 /*!
 384  * \brief Write VCPU system registers
 385  *
 386  * This sets the non-GP registers on the VCPU from a kvm_sregs structure
 387  *
 388  * \note When this function returns, the regs pointer and the data it points to
 389  * can be discarded
 390  * \param kvm Pointer to the current kvm_context
 391  * \param vcpu Which virtual CPU should get dumped
 392  * \param regs Pointer to a kvm_sregs which will be populated with the VCPUs
 393  * registers values
 394  * \return 0 on success
 395  */
 396 int kvm_set_sregs(kvm_vcpu_context_t vcpu, struct kvm_sregs *regs);
 397
 398 #ifdef KVM_CAP_MP_STATE
 399 /*!
 400  *  * \brief Read VCPU MP state
 401  *
 402  */
 403 int kvm_get_mpstate(kvm_vcpu_context_t vcpu, struct kvm_mp_state *mp_state);
 404
 405 /*!
 406  *  * \brief Write VCPU MP state
 407  *
 408  */
 409 int kvm_set_mpstate(kvm_vcpu_context_t vcpu, struct kvm_mp_state *mp_state);
 410 /*!
 411  *  * \brief Reset VCPU MP state
 412  *
 413  */
 414 static inline int kvm_reset_mpstate(kvm_vcpu_context_t vcpu)
 415 {
 416     struct kvm_mp_state mp_state = {.mp_state = KVM_MP_STATE_UNINITIALIZED};
 417     return kvm_set_mpstate(vcpu, &mp_state);
 418 }
 419 #endif
 420
 421 /*!
 422  * \brief Simulate an external vectored interrupt
 423  *
 424  * This allows you to simulate an external vectored interrupt.
 425  *
 426  * \param kvm Pointer to the current kvm_context
 427  * \param vcpu Which virtual CPU should get dumped
 428  * \param irq Vector number
 429  * \return 0 on success
 430  */
 431 int kvm_inject_irq(kvm_vcpu_context_t vcpu, unsigned irq);
 432
 433 #ifdef KVM_CAP_SET_GUEST_DEBUG
 434 int kvm_set_guest_debug(kvm_vcpu_context_t, struct kvm_guest_debug *dbg);
 435 #endif
 436
 437 #if defined(__i386__) || defined(__x86_64__)
 438 /*!
 439  * \brief Setup a vcpu's cpuid instruction emulation
 440  *
 441  * Set up a table of cpuid function to cpuid outputs.\n
 442  *
 443  * \param kvm Pointer to the current kvm_context
 444  * \param vcpu Which virtual CPU should be initialized
 445  * \param nent number of entries to be installed
 446  * \param entries cpuid function entries table
 447  * \return 0 on success, or -errno on error
 448  */
 449 int kvm_setup_cpuid(kvm_vcpu_context_t vcpu, int nent,
 450                     struct kvm_cpuid_entry *entries);
 451
 452 /*!
 453  * \brief Setup a vcpu's cpuid instruction emulation
 454  *
 455  * Set up a table of cpuid function to cpuid outputs.
 456  * This call replaces the older kvm_setup_cpuid interface by adding a few
 457  * parameters to support cpuid functions that have sub-leaf values.
 458  *
 459  * \param kvm Pointer to the current kvm_context
 460  * \param vcpu Which virtual CPU should be initialized
 461  * \param nent number of entries to be installed
 462  * \param entries cpuid function entries table
 463  * \return 0 on success, or -errno on error
 464  */
 465 int kvm_setup_cpuid2(kvm_vcpu_context_t vcpu, int nent,
 466                      struct kvm_cpuid_entry2 *entries);
 467
 468 /*!
 469  * \brief Setting the number of shadow pages to be allocated to the vm
 470  *
 471  * \param kvm pointer to kvm_context
 472  * \param nrshadow_pages number of pages to be allocated
 473  */
 474 int kvm_set_shadow_pages(kvm_context_t kvm, unsigned int nrshadow_pages);
 475
 476 /*!
 477  * \brief Getting the number of shadow pages that are allocated to the vm
 478  *
 479  * \param kvm pointer to kvm_context
 480  * \param nrshadow_pages number of pages to be allocated
 481  */
 482 int kvm_get_shadow_pages(kvm_context_t kvm , unsigned int *nrshadow_pages);
 483
 484 /*!
 485  * \brief Set up cr8 for next time the vcpu is executed
 486  *
 487  * This is a fast setter for cr8, which will be applied when the
 488  * vcpu next enters guest mode.
 489  *
 490  * \param kvm Pointer to the current kvm_context
 491  * \param vcpu Which virtual CPU should get dumped
 492  * \param cr8 next cr8 value
 493  */
 494 void kvm_set_cr8(kvm_vcpu_context_t vcpu, uint64_t cr8);
 495
 496 /*!
 497  * \brief Get cr8 for sync tpr in qemu apic emulation
 498  *
 499  * This is a getter for cr8, which used to sync with the tpr in qemu
 500  * apic emualtion.
 501  *
 502  * \param kvm Pointer to the current kvm_context
 503  * \param vcpu Which virtual CPU should get dumped
 504  */
 505 __u64 kvm_get_cr8(kvm_vcpu_context_t vcpu);
 506 #endif
 507
 508 /*!
 509  * \brief Set a vcpu's signal mask for guest mode
 510  *
 511  * A vcpu can have different signals blocked in guest mode and user mode.
 512  * This allows guest execution to be interrupted on a signal, without requiring
 513  * that the signal be delivered to a signal handler (the signal can be
 514  * dequeued using sigwait(2).
 515  *
 516  * \param kvm Pointer to the current kvm_context
 517  * \param vcpu Which virtual CPU should be initialized
 518  * \param sigset signal mask for guest mode
 519  * \return 0 on success, or -errno on error
 520  */
 521 int kvm_set_signal_mask(kvm_vcpu_context_t vcpu, const sigset_t *sigset);
 522
 523 /*!
 524  * \brief Dump VCPU registers
 525  *
 526  * This dumps some of the information that KVM has about a virtual CPU, namely:
 527  * - GP Registers
 528  *
 529  * A much more verbose version of this is available as kvm_dump_vcpu()
 530  *
 531  * \param kvm Pointer to the current kvm_context
 532  * \param vcpu Which virtual CPU should get dumped
 533  * \return 0 on success
 534  */
 535 void kvm_show_regs(kvm_vcpu_context_t vcpu);
 536
 537
 538 void *kvm_create_phys_mem(kvm_context_t, unsigned long phys_start,
 539                           unsigned long len, int log, int writable);
 540 void kvm_destroy_phys_mem(kvm_context_t, unsigned long phys_start,
 541                           unsigned long len);
 542 void kvm_unregister_memory_area(kvm_context_t, uint64_t phys_start,
 543                                 unsigned long len);
 544
 545 int kvm_is_containing_region(kvm_context_t kvm, unsigned long phys_start, unsigned long size);
 546 int kvm_register_phys_mem(kvm_context_t kvm,
 547                         unsigned long phys_start, void *userspace_addr,
 548                         unsigned long len, int log);
 549 int kvm_get_dirty_pages(kvm_context_t, unsigned long phys_addr, void *buf);
 550 int kvm_get_dirty_pages_range(kvm_context_t kvm, unsigned long phys_addr,
 551                               unsigned long end_addr, void*opaque,
 552                               int (*cb)(unsigned long start, unsigned long len,
 553                                         void*bitmap, void *opaque));
 554 int kvm_register_coalesced_mmio(kvm_context_t kvm,
 555                                 uint64_t addr, uint32_t size);
 556 int kvm_unregister_coalesced_mmio(kvm_context_t kvm,
 557                                   uint64_t addr, uint32_t size);
 558
 559 /*!
 560  * \brief Create a memory alias
 561  *
 562  * Aliases a portion of physical memory to another portion.  If the guest
 563  * accesses the alias region, it will behave exactly as if it accessed
 564  * the target memory.
 565  */
 566 int kvm_create_memory_alias(kvm_context_t,
 567                             uint64_t phys_start, uint64_t len,
 568                             uint64_t target_phys);
 569
 570 /*!
 571  * \brief Destroy a memory alias
 572  *
 573  * Removes an alias created with kvm_create_memory_alias().
 574  */
 575 int kvm_destroy_memory_alias(kvm_context_t, uint64_t phys_start);
 576
 577 /*!
 578  * \brief Get a bitmap of guest ram pages which are allocated to the guest.
 579  *
 580  * \param kvm Pointer to the current kvm_context
 581  * \param phys_addr Memory slot phys addr
 582  * \param bitmap Long aligned address of a big enough bitmap (one bit per page)
 583  */
 584 int kvm_get_mem_map(kvm_context_t kvm, unsigned long phys_addr, void *bitmap);
 585 int kvm_get_mem_map_range(kvm_context_t kvm, unsigned long phys_addr,
 586                            unsigned long len, void *buf, void *opaque,
 587                            int (*cb)(unsigned long start,unsigned long len,
 588                                      void* bitmap, void* opaque));
 589 int kvm_set_irq_level(kvm_context_t kvm, int irq, int level, int *status);
 590
 591 int kvm_dirty_pages_log_enable_slot(kvm_context_t kvm,
 592                                     uint64_t phys_start,
 593                                     uint64_t len);
 594 int kvm_dirty_pages_log_disable_slot(kvm_context_t kvm,
 595                                      uint64_t phys_start,
 596                                      uint64_t len);
 597 /*!
 598  * \brief Enable dirty-pages-logging for all memory regions
 599  *
 600  * \param kvm Pointer to the current kvm_context
 601  */
 602 int kvm_dirty_pages_log_enable_all(kvm_context_t kvm);
 603
 604 /*!
 605  * \brief Disable dirty-page-logging for some memory regions
 606  *
 607  * Disable dirty-pages-logging for those memory regions that were
 608  * created with dirty-page-logging disabled.
 609  *
 610  * \param kvm Pointer to the current kvm_context
 611  */
 612 int kvm_dirty_pages_log_reset(kvm_context_t kvm);
 613
 614 /*!
 615  * \brief Query whether in kernel irqchip is used
 616  *
 617  * \param kvm Pointer to the current kvm_context
 618  */
 619 int kvm_irqchip_in_kernel(kvm_context_t kvm);
 620
 621 #ifdef KVM_CAP_IRQCHIP
 622 /*!
 623  * \brief Dump in kernel IRQCHIP contents
 624  *
 625  * Dump one of the in kernel irq chip devices, including PIC (master/slave)
 626  * and IOAPIC into a kvm_irqchip structure
 627  *
 628  * \param kvm Pointer to the current kvm_context
 629  * \param chip The irq chip device to be dumped
 630  */
 631 int kvm_get_irqchip(kvm_context_t kvm, struct kvm_irqchip *chip);
 632
 633 /*!
 634  * \brief Set in kernel IRQCHIP contents
 635  *
 636  * Write one of the in kernel irq chip devices, including PIC (master/slave)
 637  * and IOAPIC
 638  *
 639  *
 640  * \param kvm Pointer to the current kvm_context
 641  * \param chip THe irq chip device to be written
 642  */
 643 int kvm_set_irqchip(kvm_context_t kvm, struct kvm_irqchip *chip);
 644
 645 #if defined(__i386__) || defined(__x86_64__)
 646 /*!
 647  * \brief Get in kernel local APIC for vcpu
 648  *
 649  * Save the local apic state including the timer of a virtual CPU
 650  *
 651  * \param kvm Pointer to the current kvm_context
 652  * \param vcpu Which virtual CPU should be accessed
 653  * \param s Local apic state of the specific virtual CPU
 654  */
 655 int kvm_get_lapic(kvm_vcpu_context_t vcpu, struct kvm_lapic_state *s);
 656
 657 /*!
 658  * \brief Set in kernel local APIC for vcpu
 659  *
 660  * Restore the local apic state including the timer of a virtual CPU
 661  *
 662  * \param kvm Pointer to the current kvm_context
 663  * \param vcpu Which virtual CPU should be accessed
 664  * \param s Local apic state of the specific virtual CPU
 665  */
 666 int kvm_set_lapic(kvm_vcpu_context_t vcpu, struct kvm_lapic_state *s);
 667
 668 #endif
 669
 670 /*!
 671  * \brief Simulate an NMI
 672  *
 673  * This allows you to simulate a non-maskable interrupt.
 674  *
 675  * \param kvm Pointer to the current kvm_context
 676  * \param vcpu Which virtual CPU should get dumped
 677  * \return 0 on success
 678  */
 679 int kvm_inject_nmi(kvm_vcpu_context_t vcpu);
 680
 681 #endif
 682
 683 /*!
 684  * \brief Query wheather in kernel pit is used
 685  *
 686  *  \param kvm Pointer to the current kvm_context
 687  */
 688 int kvm_pit_in_kernel(kvm_context_t kvm);
 689
 690 /*!
 691  * \brief Initialize coalesced MMIO
 692  *
 693  * Check for coalesced MMIO capability and store in context
 694  *
 695  * \param kvm Pointer to the current kvm_context
 696  */
 697 int kvm_init_coalesced_mmio(kvm_context_t kvm);
 698
 699 #ifdef KVM_CAP_PIT
 700
 701 #if defined(__i386__) || defined(__x86_64__)
 702 /*!
 703  * \brief Get in kernel PIT of the virtual domain
 704  *
 705  * Save the PIT state.
 706  *
 707  * \param kvm Pointer to the current kvm_context
 708  * \param s PIT state of the virtual domain
 709  */
 710 int kvm_get_pit(kvm_context_t kvm, struct kvm_pit_state *s);
 711
 712 /*!
 713  * \brief Set in kernel PIT of the virtual domain
 714  *
 715  * Restore the PIT state.
 716  * Timer would be retriggerred after restored.
 717  *
 718  * \param kvm Pointer to the current kvm_context
 719  * \param s PIT state of the virtual domain
 720  */
 721 int kvm_set_pit(kvm_context_t kvm, struct kvm_pit_state *s);
 722 #endif
 723
 724 int kvm_reinject_control(kvm_context_t kvm, int pit_reinject);
 725
 726 #endif
 727
 728 #ifdef KVM_CAP_VAPIC
 729
 730 /*!
 731  * \brief Enable kernel tpr access reporting
 732  *
 733  * When tpr access reporting is enabled, the kernel will call the
 734  * ->tpr_access() callback every time the guest vcpu accesses the tpr.
 735  *
 736  * \param kvm Pointer to the current kvm_context
 737  * \param vcpu vcpu to enable tpr access reporting on
 738  */
 739 int kvm_enable_tpr_access_reporting(kvm_vcpu_context_t vcpu);
 740
 741 /*!
 742  * \brief Disable kernel tpr access reporting
 743  *
 744  * Undoes the effect of kvm_enable_tpr_access_reporting().
 745  *
 746  * \param kvm Pointer to the current kvm_context
 747  * \param vcpu vcpu to disable tpr access reporting on
 748  */
 749 int kvm_disable_tpr_access_reporting(kvm_vcpu_context_t vcpu);
 750
 751 int kvm_enable_vapic(kvm_vcpu_context_t vcpu, uint64_t vapic);
 752
 753 #endif
 754
 755 #if defined(__s390__)
 756 int kvm_s390_initial_reset(kvm_context_t kvm, int slot);
 757 int kvm_s390_interrupt(kvm_context_t kvm, int slot,
 758         struct kvm_s390_interrupt *kvmint);
 759 int kvm_s390_set_initial_psw(kvm_context_t kvm, int slot, psw_t psw);
 760 int kvm_s390_store_status(kvm_context_t kvm, int slot, unsigned long addr);
 761 #endif
 762
 763 #ifdef KVM_CAP_DEVICE_ASSIGNMENT
 764 /*!
 765  * \brief Notifies host kernel about a PCI device to be assigned to a guest
 766  *
 767  * Used for PCI device assignment, this function notifies the host
 768  * kernel about the assigning of the physical PCI device to a guest.
 769  *
 770  * \param kvm Pointer to the current kvm_context
 771  * \param assigned_dev Parameters, like bus, devfn number, etc
 772  */
 773 int kvm_assign_pci_device(kvm_context_t kvm,
 774                           struct kvm_assigned_pci_dev *assigned_dev);
 775
 776 /*!
 777  * \brief Assign IRQ for an assigned device
 778  *
 779  * Used for PCI device assignment, this function assigns IRQ numbers for
 780  * an physical device and guest IRQ handling.
 781  *
 782  * \param kvm Pointer to the current kvm_context
 783  * \param assigned_irq Parameters, like dev id, host irq, guest irq, etc
 784  */
 785 int kvm_assign_irq(kvm_context_t kvm,
 786                    struct kvm_assigned_irq *assigned_irq);
 787
 788 #ifdef KVM_CAP_ASSIGN_DEV_IRQ
 789 /*!
 790  * \brief Deassign IRQ for an assigned device
 791  *
 792  * Used for PCI device assignment, this function deassigns IRQ numbers
 793  * for an assigned device.
 794  *
 795  * \param kvm Pointer to the current kvm_context
 796  * \param assigned_irq Parameters, like dev id, host irq, guest irq, etc
 797  */
 798 int kvm_deassign_irq(kvm_context_t kvm,
 799                    struct kvm_assigned_irq *assigned_irq);
 800 #endif
 801 #endif
 802
 803 /*!
 804  * \brief Determines whether destroying memory regions is allowed
 805  *
 806  * KVM before 2.6.29 had a bug when destroying memory regions.
 807  *
 808  * \param kvm Pointer to the current kvm_context
 809  */
 810 int kvm_destroy_memory_region_works(kvm_context_t kvm);
 811
 812 #ifdef KVM_CAP_DEVICE_DEASSIGNMENT
 813 /*!
 814  * \brief Notifies host kernel about a PCI device to be deassigned from a guest
 815  *
 816  * Used for hot remove PCI device, this function notifies the host
 817  * kernel about the deassigning of the physical PCI device from a guest.
 818  *
 819  * \param kvm Pointer to the current kvm_context
 820  * \param assigned_dev Parameters, like bus, devfn number, etc
 821  */
 822 int kvm_deassign_pci_device(kvm_context_t kvm,
 823                             struct kvm_assigned_pci_dev *assigned_dev);
 824 #endif
 825
 826 /*!
 827  * \brief Checks whether the generic irq routing capability is present
 828  *
 829  * Checks whether kvm can reroute interrupts among the various interrupt
 830  * controllers.
 831  *
 832  * \param kvm Pointer to the current kvm_context
 833  */
 834 int kvm_has_gsi_routing(kvm_context_t kvm);
 835
 836 /*!
 837  * \brief Determines the number of gsis that can be routed
 838  *
 839  * Returns the number of distinct gsis that can be routed by kvm.  This is
 840  * also the number of distinct routes (if a gsi has two routes, than another
 841  * gsi cannot be used...)
 842  *
 843  * \param kvm Pointer to the current kvm_context
 844  */
 845 int kvm_get_gsi_count(kvm_context_t kvm);
 846
 847 /*!
 848  * \brief Clears the temporary irq routing table
 849  *
 850  * Clears the temporary irq routing table.  Nothing is committed to the
 851  * running VM.
 852  *
 853  * \param kvm Pointer to the current kvm_context
 854  */
 855 int kvm_clear_gsi_routes(kvm_context_t kvm);
 856
 857 /*!
 858  * \brief Adds an irq route to the temporary irq routing table
 859  *
 860  * Adds an irq route to the temporary irq routing table.  Nothing is
 861  * committed to the running VM.
 862  *
 863  * \param kvm Pointer to the current kvm_context
 864  */
 865 int kvm_add_irq_route(kvm_context_t kvm, int gsi, int irqchip, int pin);
 866
 867 /*!
 868  * \brief Removes an irq route from the temporary irq routing table
 869  *
 870  * Adds an irq route to the temporary irq routing table.  Nothing is
 871  * committed to the running VM.
 872  *
 873  * \param kvm Pointer to the current kvm_context
 874  */
 875 int kvm_del_irq_route(kvm_context_t kvm, int gsi, int irqchip, int pin);
 876
 877 struct kvm_irq_routing_entry;
 878 /*!
 879  * \brief Adds a routing entry to the temporary irq routing table
 880  *
 881  * Adds a filled routing entry to the temporary irq routing table. Nothing is
 882  * committed to the running VM.
 883  *
 884  * \param kvm Pointer to the current kvm_context
 885  */
 886 int kvm_add_routing_entry(kvm_context_t kvm,
 887                           struct kvm_irq_routing_entry* entry);
 888
 889 /*!
 890  * \brief Removes a routing from the temporary irq routing table
 891  *
 892  * Remove a routing to the temporary irq routing table.  Nothing is
 893  * committed to the running VM.
 894  *
 895  * \param kvm Pointer to the current kvm_context
 896  */
 897 int kvm_del_routing_entry(kvm_context_t kvm,
 898                           struct kvm_irq_routing_entry* entry);
 899
 900 /*!
 901  * \brief Commit the temporary irq routing table
 902  *
 903  * Commit the temporary irq routing table to the running VM.
 904  *
 905  * \param kvm Pointer to the current kvm_context
 906  */
 907 int kvm_commit_irq_routes(kvm_context_t kvm);
 908
 909 /*!
 910  * \brief Get unused GSI number for irq routing table
 911  *
 912  * Get unused GSI number for irq routing table
 913  *
 914  * \param kvm Pointer to the current kvm_context
 915  */
 916 int kvm_get_irq_route_gsi(kvm_context_t kvm);
 917
 918 /*!
 919  * \brief Create a file descriptor for injecting interrupts
 920  *
 921  * Creates an eventfd based file-descriptor that maps to a specific GSI
 922  * in the guest.  eventfd compliant signaling (write() from userspace, or
 923  * eventfd_signal() from kernelspace) will cause the GSI to inject
 924  * itself into the guest at the next available window.
 925  *
 926  * \param kvm Pointer to the current kvm_context
 927  * \param gsi GSI to assign to this fd
 928  * \param flags reserved, must be zero
 929  */
 930 int kvm_irqfd(kvm_context_t kvm, int gsi, int flags);
 931
 932 #ifdef KVM_CAP_DEVICE_MSIX
 933 int kvm_assign_set_msix_nr(kvm_context_t kvm,
 934                            struct kvm_assigned_msix_nr *msix_nr);
 935 int kvm_assign_set_msix_entry(kvm_context_t kvm,
 936                               struct kvm_assigned_msix_entry *entry);
 937 #endif
 938
 939 uint32_t kvm_get_supported_cpuid(kvm_context_t kvm, uint32_t function, int reg);
 940
 941 #endif