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 /**
  47  * \brief The KVM context
  48  *
  49  * The verbose KVM context
  50  */
  51
  52 struct kvm_context {
  53     /// ioctl to use to inject interrupts
  54     int irqchip_inject_ioctl;
  55 #ifdef KVM_CAP_IRQ_ROUTING
  56     struct kvm_irq_routing *irq_routes;
  57     int nr_allocated_irq_routes;
  58 #endif
  59     void *used_gsi_bitmap;
  60     int max_gsi;
  61 };
  62
  63 typedef struct kvm_context *kvm_context_t;
  64
  65 #include "kvm.h"
  66
  67 int kvm_arch_run(CPUState *env);
  68
  69 int handle_halt(CPUState *env);
  70
  71 int handle_shutdown(kvm_context_t kvm, CPUState *env);
  72 void post_kvm_run(kvm_context_t kvm, CPUState *env);
  73 int pre_kvm_run(kvm_context_t kvm, CPUState *env);
  74 int handle_io_window(kvm_context_t kvm);
  75 int try_push_interrupts(kvm_context_t kvm);
  76
  77 void kvm_create_irqchip(kvm_context_t kvm);
  78
  79 /*!
  80  * \brief Start the VCPU
  81  *
  82  * This starts the VCPU and virtualization is started.\n
  83  * \n
  84  * This function will not return until any of these conditions are met:
  85  * - An IO/MMIO handler does not return "0"
  86  * - An exception that neither the guest OS, nor KVM can handle occurs
  87  *
  88  * \note This function will call the callbacks registered in kvm_init()
  89  * to emulate those functions
  90  * \note If you at any point want to interrupt the VCPU, kvm_run() will
  91  * listen to the EINTR signal. This allows you to simulate external interrupts
  92  * and asyncronous IO.
  93  *
  94  * \param kvm Pointer to the current kvm_context
  95  * \param vcpu Which virtual CPU should be started
  96  * \return 0 on success, but you really shouldn't expect this function to
  97  * return except for when an error has occured, or when you have sent it
  98  * an EINTR signal.
  99  */
 100 int kvm_run(CPUState *env);
 101
 102 /*!
 103  * \brief Check if a vcpu is ready for interrupt injection
 104  *
 105  * This checks if vcpu interrupts are not masked by mov ss or sti.
 106  *
 107  * \param kvm Pointer to the current kvm_context
 108  * \param vcpu Which virtual CPU should get dumped
 109  * \return boolean indicating interrupt injection readiness
 110  */
 111 int kvm_is_ready_for_interrupt_injection(CPUState *env);
 112
 113 #if defined(__i386__) || defined(__x86_64__)
 114 /*!
 115  * \brief Simulate an external vectored interrupt
 116  *
 117  * This allows you to simulate an external vectored interrupt.
 118  *
 119  * \param kvm Pointer to the current kvm_context
 120  * \param vcpu Which virtual CPU should get dumped
 121  * \param irq Vector number
 122  * \return 0 on success
 123  */
 124 int kvm_inject_irq(CPUState *env, unsigned irq);
 125 #endif
 126
 127 int kvm_set_irq_level(kvm_context_t kvm, int irq, int level, int *status);
 128
 129 #ifdef KVM_CAP_IRQCHIP
 130 /*!
 131  * \brief Dump in kernel IRQCHIP contents
 132  *
 133  * Dump one of the in kernel irq chip devices, including PIC (master/slave)
 134  * and IOAPIC into a kvm_irqchip structure
 135  *
 136  * \param kvm Pointer to the current kvm_context
 137  * \param chip The irq chip device to be dumped
 138  */
 139 int kvm_get_irqchip(kvm_context_t kvm, struct kvm_irqchip *chip);
 140
 141 /*!
 142  * \brief Set in kernel IRQCHIP contents
 143  *
 144  * Write one of the in kernel irq chip devices, including PIC (master/slave)
 145  * and IOAPIC
 146  *
 147  *
 148  * \param kvm Pointer to the current kvm_context
 149  * \param chip THe irq chip device to be written
 150  */
 151 int kvm_set_irqchip(kvm_context_t kvm, struct kvm_irqchip *chip);
 152
 153 #if defined(__i386__) || defined(__x86_64__)
 154 /*!
 155  * \brief Get in kernel local APIC for vcpu
 156  *
 157  * Save the local apic state including the timer of a virtual CPU
 158  *
 159  * \param kvm Pointer to the current kvm_context
 160  * \param vcpu Which virtual CPU should be accessed
 161  * \param s Local apic state of the specific virtual CPU
 162  */
 163 int kvm_get_lapic(CPUState *env, struct kvm_lapic_state *s);
 164
 165 /*!
 166  * \brief Set in kernel local APIC for vcpu
 167  *
 168  * Restore the local apic state including the timer of a virtual CPU
 169  *
 170  * \param kvm Pointer to the current kvm_context
 171  * \param vcpu Which virtual CPU should be accessed
 172  * \param s Local apic state of the specific virtual CPU
 173  */
 174 int kvm_set_lapic(CPUState *env, struct kvm_lapic_state *s);
 175
 176 #endif
 177
 178 /*!
 179  * \brief Simulate an NMI
 180  *
 181  * This allows you to simulate a non-maskable interrupt.
 182  *
 183  * \param kvm Pointer to the current kvm_context
 184  * \param vcpu Which virtual CPU should get dumped
 185  * \return 0 on success
 186  */
 187 int kvm_inject_nmi(CPUState *env);
 188
 189 #endif
 190
 191 #ifdef KVM_CAP_PIT
 192
 193 #if defined(__i386__) || defined(__x86_64__)
 194 /*!
 195  * \brief Get in kernel PIT of the virtual domain
 196  *
 197  * Save the PIT state.
 198  *
 199  * \param kvm Pointer to the current kvm_context
 200  * \param s PIT state of the virtual domain
 201  */
 202 int kvm_get_pit(kvm_context_t kvm, struct kvm_pit_state *s);
 203
 204 /*!
 205  * \brief Set in kernel PIT of the virtual domain
 206  *
 207  * Restore the PIT state.
 208  * Timer would be retriggerred after restored.
 209  *
 210  * \param kvm Pointer to the current kvm_context
 211  * \param s PIT state of the virtual domain
 212  */
 213 int kvm_set_pit(kvm_context_t kvm, struct kvm_pit_state *s);
 214
 215 int kvm_reinject_control(kvm_context_t kvm, int pit_reinject);
 216
 217 #ifdef KVM_CAP_PIT_STATE2
 218 /*!
 219  * \brief Check for kvm support of kvm_pit_state2
 220  *
 221  * \param kvm Pointer to the current kvm_context
 222  * \return 0 on success
 223  */
 224 int kvm_has_pit_state2(kvm_context_t kvm);
 225
 226 /*!
 227  * \brief Set in kernel PIT state2 of the virtual domain
 228  *
 229  *
 230  * \param kvm Pointer to the current kvm_context
 231  * \param ps2 PIT state2 of the virtual domain
 232  * \return 0 on success
 233  */
 234 int kvm_set_pit2(kvm_context_t kvm, struct kvm_pit_state2 *ps2);
 235
 236 /*!
 237  * \brief Get in kernel PIT state2 of the virtual domain
 238  *
 239  *
 240  * \param kvm Pointer to the current kvm_context
 241  * \param ps2 PIT state2 of the virtual domain
 242  * \return 0 on success
 243  */
 244 int kvm_get_pit2(kvm_context_t kvm, struct kvm_pit_state2 *ps2);
 245
 246 #endif
 247 #endif
 248 #endif
 249
 250 #ifdef KVM_CAP_VAPIC
 251
 252 int kvm_enable_vapic(CPUState *env, uint64_t vapic);
 253
 254 #endif
 255
 256 #ifdef KVM_CAP_DEVICE_ASSIGNMENT
 257 /*!
 258  * \brief Notifies host kernel about a PCI device to be assigned to a guest
 259  *
 260  * Used for PCI device assignment, this function notifies the host
 261  * kernel about the assigning of the physical PCI device to a guest.
 262  *
 263  * \param kvm Pointer to the current kvm_context
 264  * \param assigned_dev Parameters, like bus, devfn number, etc
 265  */
 266 int kvm_assign_pci_device(kvm_context_t kvm,
 267                           struct kvm_assigned_pci_dev *assigned_dev);
 268
 269 /*!
 270  * \brief Assign IRQ for an assigned device
 271  *
 272  * Used for PCI device assignment, this function assigns IRQ numbers for
 273  * an physical device and guest IRQ handling.
 274  *
 275  * \param kvm Pointer to the current kvm_context
 276  * \param assigned_irq Parameters, like dev id, host irq, guest irq, etc
 277  */
 278 int kvm_assign_irq(kvm_context_t kvm, struct kvm_assigned_irq *assigned_irq);
 279
 280 #ifdef KVM_CAP_ASSIGN_DEV_IRQ
 281 /*!
 282  * \brief Deassign IRQ for an assigned device
 283  *
 284  * Used for PCI device assignment, this function deassigns IRQ numbers
 285  * for an assigned device.
 286  *
 287  * \param kvm Pointer to the current kvm_context
 288  * \param assigned_irq Parameters, like dev id, host irq, guest irq, etc
 289  */
 290 int kvm_deassign_irq(kvm_context_t kvm, struct kvm_assigned_irq *assigned_irq);
 291 #endif
 292 #endif
 293
 294 #ifdef KVM_CAP_DEVICE_DEASSIGNMENT
 295 /*!
 296  * \brief Notifies host kernel about a PCI device to be deassigned from a guest
 297  *
 298  * Used for hot remove PCI device, this function notifies the host
 299  * kernel about the deassigning of the physical PCI device from a guest.
 300  *
 301  * \param kvm Pointer to the current kvm_context
 302  * \param assigned_dev Parameters, like bus, devfn number, etc
 303  */
 304 int kvm_deassign_pci_device(kvm_context_t kvm,
 305                             struct kvm_assigned_pci_dev *assigned_dev);
 306 #endif
 307
 308 /*!
 309  * \brief Determines the number of gsis that can be routed
 310  *
 311  * Returns the number of distinct gsis that can be routed by kvm.  This is
 312  * also the number of distinct routes (if a gsi has two routes, than another
 313  * gsi cannot be used...)
 314  *
 315  * \param kvm Pointer to the current kvm_context
 316  */
 317 int kvm_get_gsi_count(kvm_context_t kvm);
 318
 319 /*!
 320  * \brief Clears the temporary irq routing table
 321  *
 322  * Clears the temporary irq routing table.  Nothing is committed to the
 323  * running VM.
 324  *
 325  */
 326 int kvm_clear_gsi_routes(void);
 327
 328 /*!
 329  * \brief Adds an irq route to the temporary irq routing table
 330  *
 331  * Adds an irq route to the temporary irq routing table.  Nothing is
 332  * committed to the running VM.
 333  */
 334 int kvm_add_irq_route(int gsi, int irqchip, int pin);
 335
 336 /*!
 337  * \brief Removes an irq route from the temporary irq routing table
 338  *
 339  * Adds an irq route to the temporary irq routing table.  Nothing is
 340  * committed to the running VM.
 341  */
 342 int kvm_del_irq_route(int gsi, int irqchip, int pin);
 343
 344 struct kvm_irq_routing_entry;
 345 /*!
 346  * \brief Adds a routing entry to the temporary irq routing table
 347  *
 348  * Adds a filled routing entry to the temporary irq routing table. Nothing is
 349  * committed to the running VM.
 350  */
 351 int kvm_add_routing_entry(struct kvm_irq_routing_entry *entry);
 352
 353 /*!
 354  * \brief Removes a routing from the temporary irq routing table
 355  *
 356  * Remove a routing to the temporary irq routing table.  Nothing is
 357  * committed to the running VM.
 358  */
 359 int kvm_del_routing_entry(struct kvm_irq_routing_entry *entry);
 360
 361 /*!
 362  * \brief Updates a routing in the temporary irq routing table
 363  *
 364  * Update a routing in the temporary irq routing table
 365  * with a new value. entry type and GSI can not be changed.
 366  * Nothing is committed to the running VM.
 367  */
 368 int kvm_update_routing_entry(struct kvm_irq_routing_entry *entry,
 369                              struct kvm_irq_routing_entry *newentry);
 370
 371
 372 #ifdef KVM_CAP_DEVICE_MSIX
 373 int kvm_assign_set_msix_nr(kvm_context_t kvm,
 374                            struct kvm_assigned_msix_nr *msix_nr);
 375 int kvm_assign_set_msix_entry(kvm_context_t kvm,
 376                               struct kvm_assigned_msix_entry *entry);
 377 #endif
 378
 379 #else                           /* !CONFIG_KVM */
 380
 381 typedef struct kvm_context *kvm_context_t;
 382
 383 struct kvm_pit_state {
 384 };
 385
 386 #endif                          /* !CONFIG_KVM */
 387
 388
 389 /*!
 390  * \brief Create new KVM context
 391  *
 392  * This creates a new kvm_context. A KVM context is a small area of data that
 393  * holds information about the KVM instance that gets created by this call.\n
 394  * This should always be your first call to KVM.
 395  *
 396  * \param opaque Not used
 397  * \return NULL on failure
 398  */
 399 int kvm_init(void);
 400
 401 int kvm_main_loop(void);
 402 int kvm_init_ap(void);
 403 void kvm_save_lapic(CPUState *env);
 404 void kvm_load_lapic(CPUState *env);
 405
 406 void kvm_hpet_enable_kpit(void);
 407 void kvm_hpet_disable_kpit(void);
 408
 409 void on_vcpu(CPUState *env, void (*func)(void *data), void *data);
 410 void kvm_inject_interrupt(CPUState *env, int mask);
 411 void kvm_update_interrupt_request(CPUState *env);
 412
 413 int kvm_arch_has_work(CPUState *env);
 414 void kvm_arch_process_irqchip_events(CPUState *env);
 415 int kvm_arch_try_push_interrupts(void *opaque);
 416 void kvm_arch_push_nmi(void);
 417 int kvm_set_boot_cpu_id(uint32_t id);
 418
 419 void kvm_tpr_access_report(CPUState *env, uint64_t rip, int is_write);
 420
 421 int kvm_arch_init_irq_routing(void);
 422
 423 #ifdef CONFIG_KVM_DEVICE_ASSIGNMENT
 424 struct ioperm_data;
 425
 426 void kvm_ioperm(CPUState *env, void *data);
 427 void kvm_add_ioperm_data(struct ioperm_data *data);
 428 void kvm_remove_ioperm_data(unsigned long start_port, unsigned long num);
 429 void kvm_arch_do_ioperm(void *_data);
 430 #endif
 431
 432 #ifdef CONFIG_KVM
 433 #include "qemu-queue.h"
 434
 435 extern int kvm_irqchip;
 436 extern int kvm_pit;
 437 extern int kvm_pit_reinject;
 438 extern int kvm_nested;
 439 extern kvm_context_t kvm_context;
 440 extern unsigned int kvm_shadow_memory;
 441
 442 struct ioperm_data {
 443     unsigned long start_port;
 444     unsigned long num;
 445     int turn_on;
 446     QLIST_ENTRY(ioperm_data) entries;
 447 };
 448
 449 int kvm_arch_halt(CPUState *env);
 450 int handle_tpr_access(void *opaque, CPUState *env, uint64_t rip,
 451                       int is_write);
 452
 453 #define qemu_kvm_has_gsi_routing() kvm_has_gsi_routing()
 454 #ifdef TARGET_I386
 455 #define qemu_kvm_has_pit_state2() kvm_has_pit_state2(kvm_context)
 456 #endif
 457 #else
 458 #define kvm_nested 0
 459 #define qemu_kvm_has_gsi_routing() (0)
 460 #ifdef TARGET_I386
 461 #define qemu_kvm_has_pit_state2() (0)
 462 #endif
 463 #endif
 464
 465 #ifdef CONFIG_KVM
 466
 467 typedef struct KVMSlot {
 468     target_phys_addr_t start_addr;
 469     ram_addr_t memory_size;
 470     ram_addr_t phys_offset;
 471     int slot;
 472     int flags;
 473 } KVMSlot;
 474
 475 typedef struct kvm_dirty_log KVMDirtyLog;
 476
 477 struct KVMState {
 478     KVMSlot slots[32];
 479     int fd;
 480     int vmfd;
 481     int coalesced_mmio;
 482 #ifdef KVM_CAP_COALESCED_MMIO
 483     struct kvm_coalesced_mmio_ring *coalesced_mmio_ring;
 484 #endif
 485     int broken_set_mem_region;
 486     int migration_log;
 487     int vcpu_events;
 488     int robust_singlestep;
 489     int debugregs;
 490 #ifdef KVM_CAP_SET_GUEST_DEBUG
 491     QTAILQ_HEAD(, kvm_sw_breakpoint) kvm_sw_breakpoints;
 492 #endif
 493     int irqchip_in_kernel;
 494     int pit_in_kernel;
 495     int xsave, xcrs;
 496     int many_ioeventfds;
 497
 498     struct kvm_context kvm_context;
 499 };
 500
 501 int kvm_tpr_enable_vapic(CPUState *env);
 502
 503 unsigned long kvm_get_thread_id(void);
 504 int kvm_cpu_is_stopped(CPUState *env);
 505
 506 #endif
 507
 508 #endif