qemu-kvm.h

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