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