Documentation/kvm/api.txt

   1 The Definitive KVM (Kernel-based Virtual Machine) API Documentation
   2 ===================================================================
   3
   4 1. General description
   5
   6 The kvm API is a set of ioctls that are issued to control various aspects
   7 of a virtual machine.  The ioctls belong to three classes
   8
   9  - System ioctls: These query and set global attributes which affect the
  10    whole kvm subsystem.  In addition a system ioctl is used to create
  11    virtual machines
  12
  13  - VM ioctls: These query and set attributes that affect an entire virtual
  14    machine, for example memory layout.  In addition a VM ioctl is used to
  15    create virtual cpus (vcpus).
  16
  17    Only run VM ioctls from the same process (address space) that was used
  18    to create the VM.
  19
  20  - vcpu ioctls: These query and set attributes that control the operation
  21    of a single virtual cpu.
  22
  23    Only run vcpu ioctls from the same thread that was used to create the
  24    vcpu.
  25
  26 2. File descritpors
  27
  28 The kvm API is centered around file descriptors.  An initial
  29 open("/dev/kvm") obtains a handle to the kvm subsystem; this handle
  30 can be used to issue system ioctls.  A KVM_CREATE_VM ioctl on this
  31 handle will create a VM file descripror which can be used to issue VM
  32 ioctls.  A KVM_CREATE_VCPU ioctl on a VM fd will create a virtual cpu
  33 and return a file descriptor pointing to it.  Finally, ioctls on a vcpu
  34 fd can be used to control the vcpu, including the important task of
  35 actually running guest code.
  36
  37 In general file descriptors can be migrated among processes by means
  38 of fork() and the SCM_RIGHTS facility of unix domain socket.  These
  39 kinds of tricks are explicitly not supported by kvm.  While they will
  40 not cause harm to the host, their actual behavior is not guaranteed by
  41 the API.  The only supported use is one virtual machine per process,
  42 and one vcpu per thread.
  43
  44 3. Extensions
  45
  46 As of Linux 2.6.22, the KVM ABI has been stabilized: no backward
  47 incompatible change are allowed.  However, there is an extension
  48 facility that allows backward-compatible extensions to the API to be
  49 queried and used.
  50
  51 The extension mechanism is not based on on the Linux version number.
  52 Instead, kvm defines extension identifiers and a facility to query
  53 whether a particular extension identifier is available.  If it is, a
  54 set of ioctls is available for application use.
  55
  56 4. API description
  57
  58 This section describes ioctls that can be used to control kvm guests.
  59 For each ioctl, the following information is provided along with a
  60 description:
  61
  62   Capability: which KVM extension provides this ioctl.  Can be 'basic',
  63       which means that is will be provided by any kernel that supports
  64       API version 12 (see section 4.1), or a KVM_CAP_xyz constant, which
  65       means availability needs to be checked with KVM_CHECK_EXTENSION
  66       (see section 4.4).
  67
  68   Architectures: which instruction set architectures provide this ioctl.
  69       x86 includes both i386 and x86_64.
  70
  71   Type: system, vm, or vcpu.
  72
  73   Parameters: what parameters are accepted by the ioctl.
  74
  75   Returns: the return value.  General error numbers (EBADF, ENOMEM, EINVAL)
  76       are not detailed, but errors with specific meanings are.
  77
  78 4.1 KVM_GET_API_VERSION
  79
  80 Capability: basic
  81 Architectures: all
  82 Type: system ioctl
  83 Parameters: none
  84 Returns: the constant KVM_API_VERSION (=12)
  85
  86 This identifies the API version as the stable kvm API. It is not
  87 expected that this number will change.  However, Linux 2.6.20 and
  88 2.6.21 report earlier versions; these are not documented and not
  89 supported.  Applications should refuse to run if KVM_GET_API_VERSION
  90 returns a value other than 12.  If this check passes, all ioctls
  91 described as 'basic' will be available.
  92
  93 4.2 KVM_CREATE_VM
  94
  95 Capability: basic
  96 Architectures: all
  97 Type: system ioctl
  98 Parameters: none
  99 Returns: a VM fd that can be used to control the new virtual machine.
 100
 101 The new VM has no virtual cpus and no memory.  An mmap() of a VM fd
 102 will access the virtual machine's physical address space; offset zero
 103 corresponds to guest physical address zero.  Use of mmap() on a VM fd
 104 is discouraged if userspace memory allocation (KVM_CAP_USER_MEMORY) is
 105 available.
 106
 107 4.3 KVM_GET_MSR_INDEX_LIST
 108
 109 Capability: basic
 110 Architectures: x86
 111 Type: system
 112 Parameters: struct kvm_msr_list (in/out)
 113 Returns: 0 on success; -1 on error
 114 Errors:
 115   E2BIG:     the msr index list is to be to fit in the array specified by
 116              the user.
 117
 118 struct kvm_msr_list {
 119         __u32 nmsrs; /* number of msrs in entries */
 120         __u32 indices[0];
 121 };
 122
 123 This ioctl returns the guest msrs that are supported.  The list varies
 124 by kvm version and host processor, but does not change otherwise.  The
 125 user fills in the size of the indices array in nmsrs, and in return
 126 kvm adjusts nmsrs to reflect the actual number of msrs and fills in
 127 the indices array with their numbers.
 128
 129 4.4 KVM_CHECK_EXTENSION
 130
 131 Capability: basic
 132 Architectures: all
 133 Type: system ioctl
 134 Parameters: extension identifier (KVM_CAP_*)
 135 Returns: 0 if unsupported; 1 (or some other positive integer) if supported
 136
 137 The API allows the application to query about extensions to the core
 138 kvm API.  Userspace passes an extension identifier (an integer) and
 139 receives an integer that describes the extension availability.
 140 Generally 0 means no and 1 means yes, but some extensions may report
 141 additional information in the integer return value.
 142
 143 4.5 KVM_GET_VCPU_MMAP_SIZE
 144
 145 Capability: basic
 146 Architectures: all
 147 Type: system ioctl
 148 Parameters: none
 149 Returns: size of vcpu mmap area, in bytes
 150
 151 The KVM_RUN ioctl (cf.) communicates with userspace via a shared
 152 memory region.  This ioctl returns the size of that region.  See the
 153 KVM_RUN documentation for details.
 154
 155 4.6 KVM_SET_MEMORY_REGION
 156
 157 Capability: basic
 158 Architectures: all
 159 Type: vm ioctl
 160 Parameters: struct kvm_memory_region (in)
 161 Returns: 0 on success, -1 on error
 162
 163 struct kvm_memory_region {
 164         __u32 slot;
 165         __u32 flags;
 166         __u64 guest_phys_addr;
 167         __u64 memory_size; /* bytes */
 168 };
 169
 170 /* for kvm_memory_region::flags */
 171 #define KVM_MEM_LOG_DIRTY_PAGES  1UL
 172
 173 This ioctl allows the user to create or modify a guest physical memory
 174 slot.  When changing an existing slot, it may be moved in the guest
 175 physical memory space, or its flags may be modified.  It may not be
 176 resized.  Slots may not overlap.
 177
 178 The flags field supports just one flag, KVM_MEM_LOG_DIRTY_PAGES, which
 179 instructs kvm to keep track of writes to memory within the slot.  See
 180 the KVM_GET_DIRTY_LOG ioctl.
 181
 182 It is recommended to use the KVM_SET_USER_MEMORY_REGION ioctl instead
 183 of this API, if available.  This newer API allows placing guest memory
 184 at specified locations in the host address space, yielding better
 185 control and easy access.
 186
 187 4.6 KVM_CREATE_VCPU
 188
 189 Capability: basic
 190 Architectures: all
 191 Type: vm ioctl
 192 Parameters: vcpu id (apic id on x86)
 193 Returns: vcpu fd on success, -1 on error
 194
 195 This API adds a vcpu to a virtual machine.  The vcpu id is a small integer
 196 in the range [0, max_vcpus).
 197
 198 4.7 KVM_GET_DIRTY_LOG (vm ioctl)
 199
 200 Capability: basic
 201 Architectures: x86
 202 Type: vm ioctl
 203 Parameters: struct kvm_dirty_log (in/out)
 204 Returns: 0 on success, -1 on error
 205
 206 /* for KVM_GET_DIRTY_LOG */
 207 struct kvm_dirty_log {
 208         __u32 slot;
 209         __u32 padding;
 210         union {
 211                 void __user *dirty_bitmap; /* one bit per page */
 212                 __u64 padding;
 213         };
 214 };
 215
 216 Given a memory slot, return a bitmap containing any pages dirtied
 217 since the last call to this ioctl.  Bit 0 is the first page in the
 218 memory slot.  Ensure the entire structure is cleared to avoid padding
 219 issues.
 220
 221 4.8 KVM_SET_MEMORY_ALIAS
 222
 223 Capability: basic
 224 Architectures: x86
 225 Type: vm ioctl
 226 Parameters: struct kvm_memory_alias (in)
 227 Returns: 0 (success), -1 (error)
 228
 229 struct kvm_memory_alias {
 230         __u32 slot;  /* this has a different namespace than memory slots */
 231         __u32 flags;
 232         __u64 guest_phys_addr;
 233         __u64 memory_size;
 234         __u64 target_phys_addr;
 235 };
 236
 237 Defines a guest physical address space region as an alias to another
 238 region.  Useful for aliased address, for example the VGA low memory
 239 window. Should not be used with userspace memory.
 240
 241 4.9 KVM_RUN
 242
 243 Capability: basic
 244 Architectures: all
 245 Type: vcpu ioctl
 246 Parameters: none
 247 Returns: 0 on success, -1 on error
 248 Errors:
 249   EINTR:     an unmasked signal is pending
 250
 251 This ioctl is used to run a guest virtual cpu.  While there are no
 252 explicit parameters, there is an implicit parameter block that can be
 253 obtained by mmap()ing the vcpu fd at offset 0, with the size given by
 254 KVM_GET_VCPU_MMAP_SIZE.  The parameter block is formatted as a 'struct
 255 kvm_run' (see below).
 256
 257 4.10 KVM_GET_REGS
 258
 259 Capability: basic
 260 Architectures: all
 261 Type: vcpu ioctl
 262 Parameters: struct kvm_regs (out)
 263 Returns: 0 on success, -1 on error
 264
 265 Reads the general purpose registers from the vcpu.
 266
 267 /* x86 */
 268 struct kvm_regs {
 269         /* out (KVM_GET_REGS) / in (KVM_SET_REGS) */
 270         __u64 rax, rbx, rcx, rdx;
 271         __u64 rsi, rdi, rsp, rbp;
 272         __u64 r8,  r9,  r10, r11;
 273         __u64 r12, r13, r14, r15;
 274         __u64 rip, rflags;
 275 };
 276
 277 4.11 KVM_SET_REGS
 278
 279 Capability: basic
 280 Architectures: all
 281 Type: vcpu ioctl
 282 Parameters: struct kvm_regs (in)
 283 Returns: 0 on success, -1 on error
 284
 285 Writes the general purpose registers into the vcpu.
 286
 287 See KVM_GET_REGS for the data structure.
 288
 289 4.12 KVM_GET_SREGS
 290
 291 Capability: basic
 292 Architectures: x86
 293 Type: vcpu ioctl
 294 Parameters: struct kvm_sregs (out)
 295 Returns: 0 on success, -1 on error
 296
 297 Reads special registers from the vcpu.
 298
 299 /* x86 */
 300 struct kvm_sregs {
 301         struct kvm_segment cs, ds, es, fs, gs, ss;
 302         struct kvm_segment tr, ldt;
 303         struct kvm_dtable gdt, idt;
 304         __u64 cr0, cr2, cr3, cr4, cr8;
 305         __u64 efer;
 306         __u64 apic_base;
 307         __u64 interrupt_bitmap[(KVM_NR_INTERRUPTS + 63) / 64];
 308 };
 309
 310 interrupt_bitmap is a bitmap of pending external interrupts.  At most
 311 one bit may be set.  This interrupt has been acknowledged by the APIC
 312 but not yet injected into the cpu core.
 313
 314 4.13 KVM_SET_SREGS
 315
 316 Capability: basic
 317 Architectures: x86
 318 Type: vcpu ioctl
 319 Parameters: struct kvm_sregs (in)
 320 Returns: 0 on success, -1 on error
 321
 322 Writes special registers into the vcpu.  See KVM_GET_SREGS for the
 323 data structures.
 324
 325 4.14 KVM_TRANSLATE
 326
 327 Capability: basic
 328 Architectures: x86
 329 Type: vcpu ioctl
 330 Parameters: struct kvm_translation (in/out)
 331 Returns: 0 on success, -1 on error
 332
 333 Translates a virtual address according to the vcpu's current address
 334 translation mode.
 335
 336 struct kvm_translation {
 337         /* in */
 338         __u64 linear_address;
 339
 340         /* out */
 341         __u64 physical_address;
 342         __u8  valid;
 343         __u8  writeable;
 344         __u8  usermode;
 345         __u8  pad[5];
 346 };
 347
 348 4.15 KVM_INTERRUPT
 349
 350 Capability: basic
 351 Architectures: x86
 352 Type: vcpu ioctl
 353 Parameters: struct kvm_interrupt (in)
 354 Returns: 0 on success, -1 on error
 355
 356 Queues a hardware interrupt vector to be injected.  This is only
 357 useful if in-kernel local APIC is not used.
 358
 359 /* for KVM_INTERRUPT */
 360 struct kvm_interrupt {
 361         /* in */
 362         __u32 irq;
 363 };
 364
 365 Note 'irq' is an interrupt vector, not an interrupt pin or line.
 366
 367 4.16 KVM_DEBUG_GUEST
 368
 369 Capability: basic
 370 Architectures: none
 371 Type: vcpu ioctl
 372 Parameters: none)
 373 Returns: -1 on error
 374
 375 Support for this has been removed.  Use KVM_SET_GUEST_DEBUG instead.
 376
 377 4.17 KVM_GET_MSRS
 378
 379 Capability: basic
 380 Architectures: x86
 381 Type: vcpu ioctl
 382 Parameters: struct kvm_msrs (in/out)
 383 Returns: 0 on success, -1 on error
 384
 385 Reads model-specific registers from the vcpu.  Supported msr indices can
 386 be obtained using KVM_GET_MSR_INDEX_LIST.
 387
 388 struct kvm_msrs {
 389         __u32 nmsrs; /* number of msrs in entries */
 390         __u32 pad;
 391
 392         struct kvm_msr_entry entries[0];
 393 };
 394
 395 struct kvm_msr_entry {
 396         __u32 index;
 397         __u32 reserved;
 398         __u64 data;
 399 };
 400
 401 Application code should set the 'nmsrs' member (which indicates the
 402 size of the entries array) and the 'index' member of each array entry.
 403 kvm will fill in the 'data' member.
 404
 405 4.18 KVM_SET_MSRS
 406
 407 Capability: basic
 408 Architectures: x86
 409 Type: vcpu ioctl
 410 Parameters: struct kvm_msrs (in)
 411 Returns: 0 on success, -1 on error
 412
 413 Writes model-specific registers to the vcpu.  See KVM_GET_MSRS for the
 414 data structures.
 415
 416 Application code should set the 'nmsrs' member (which indicates the
 417 size of the entries array), and the 'index' and 'data' members of each
 418 array entry.
 419
 420 4.19 KVM_SET_CPUID
 421
 422 Capability: basic
 423 Architectures: x86
 424 Type: vcpu ioctl
 425 Parameters: struct kvm_cpuid (in)
 426 Returns: 0 on success, -1 on error
 427
 428 Defines the vcpu responses to the cpuid instruction.  Applications
 429 should use the KVM_SET_CPUID2 ioctl if available.
 430
 431
 432 struct kvm_cpuid_entry {
 433         __u32 function;
 434         __u32 eax;
 435         __u32 ebx;
 436         __u32 ecx;
 437         __u32 edx;
 438         __u32 padding;
 439 };
 440
 441 /* for KVM_SET_CPUID */
 442 struct kvm_cpuid {
 443         __u32 nent;
 444         __u32 padding;
 445         struct kvm_cpuid_entry entries[0];
 446 };
 447
 448 4.20 KVM_SET_SIGNAL_MASK
 449
 450 Capability: basic
 451 Architectures: x86
 452 Type: vcpu ioctl
 453 Parameters: struct kvm_signal_mask (in)
 454 Returns: 0 on success, -1 on error
 455
 456 Defines which signals are blocked during execution of KVM_RUN.  This
 457 signal mask temporarily overrides the threads signal mask.  Any
 458 unblocked signal received (except SIGKILL and SIGSTOP, which retain
 459 their traditional behaviour) will cause KVM_RUN to return with -EINTR.
 460
 461 Note the signal will only be delivered if not blocked by the original
 462 signal mask.
 463
 464 /* for KVM_SET_SIGNAL_MASK */
 465 struct kvm_signal_mask {
 466         __u32 len;
 467         __u8  sigset[0];
 468 };
 469
 470 4.21 KVM_GET_FPU
 471
 472 Capability: basic
 473 Architectures: x86
 474 Type: vcpu ioctl
 475 Parameters: struct kvm_fpu (out)
 476 Returns: 0 on success, -1 on error
 477
 478 Reads the floating point state from the vcpu.
 479
 480 /* for KVM_GET_FPU and KVM_SET_FPU */
 481 struct kvm_fpu {
 482         __u8  fpr[8][16];
 483         __u16 fcw;
 484         __u16 fsw;
 485         __u8  ftwx;  /* in fxsave format */
 486         __u8  pad1;
 487         __u16 last_opcode;
 488         __u64 last_ip;
 489         __u64 last_dp;
 490         __u8  xmm[16][16];
 491         __u32 mxcsr;
 492         __u32 pad2;
 493 };
 494
 495 4.22 KVM_SET_FPU
 496
 497 Capability: basic
 498 Architectures: x86
 499 Type: vcpu ioctl
 500 Parameters: struct kvm_fpu (in)
 501 Returns: 0 on success, -1 on error
 502
 503 Writes the floating point state to the vcpu.
 504
 505 /* for KVM_GET_FPU and KVM_SET_FPU */
 506 struct kvm_fpu {
 507         __u8  fpr[8][16];
 508         __u16 fcw;
 509         __u16 fsw;
 510         __u8  ftwx;  /* in fxsave format */
 511         __u8  pad1;
 512         __u16 last_opcode;
 513         __u64 last_ip;
 514         __u64 last_dp;
 515         __u8  xmm[16][16];
 516         __u32 mxcsr;
 517         __u32 pad2;
 518 };
 519
 520 4.23 KVM_CREATE_IRQCHIP
 521
 522 Capability: KVM_CAP_IRQCHIP
 523 Architectures: x86, ia64
 524 Type: vm ioctl
 525 Parameters: none
 526 Returns: 0 on success, -1 on error
 527
 528 Creates an interrupt controller model in the kernel.  On x86, creates a virtual
 529 ioapic, a virtual PIC (two PICs, nested), and sets up future vcpus to have a
 530 local APIC.  IRQ routing for GSIs 0-15 is set to both PIC and IOAPIC; GSI 16-23
 531 only go to the IOAPIC.  On ia64, a IOSAPIC is created.
 532
 533 4.24 KVM_IRQ_LINE
 534
 535 Capability: KVM_CAP_IRQCHIP
 536 Architectures: x86, ia64
 537 Type: vm ioctl
 538 Parameters: struct kvm_irq_level
 539 Returns: 0 on success, -1 on error
 540
 541 Sets the level of a GSI input to the interrupt controller model in the kernel.
 542 Requires that an interrupt controller model has been previously created with
 543 KVM_CREATE_IRQCHIP.  Note that edge-triggered interrupts require the level
 544 to be set to 1 and then back to 0.
 545
 546 struct kvm_irq_level {
 547         union {
 548                 __u32 irq;     /* GSI */
 549                 __s32 status;  /* not used for KVM_IRQ_LEVEL */
 550         };
 551         __u32 level;           /* 0 or 1 */
 552 };
 553
 554 4.25 KVM_GET_IRQCHIP
 555
 556 Capability: KVM_CAP_IRQCHIP
 557 Architectures: x86, ia64
 558 Type: vm ioctl
 559 Parameters: struct kvm_irqchip (in/out)
 560 Returns: 0 on success, -1 on error
 561
 562 Reads the state of a kernel interrupt controller created with
 563 KVM_CREATE_IRQCHIP into a buffer provided by the caller.
 564
 565 struct kvm_irqchip {
 566         __u32 chip_id;  /* 0 = PIC1, 1 = PIC2, 2 = IOAPIC */
 567         __u32 pad;
 568         union {
 569                 char dummy[512];  /* reserving space */
 570                 struct kvm_pic_state pic;
 571                 struct kvm_ioapic_state ioapic;
 572         } chip;
 573 };
 574
 575 4.26 KVM_SET_IRQCHIP
 576
 577 Capability: KVM_CAP_IRQCHIP
 578 Architectures: x86, ia64
 579 Type: vm ioctl
 580 Parameters: struct kvm_irqchip (in)
 581 Returns: 0 on success, -1 on error
 582
 583 Sets the state of a kernel interrupt controller created with
 584 KVM_CREATE_IRQCHIP from a buffer provided by the caller.
 585
 586 struct kvm_irqchip {
 587         __u32 chip_id;  /* 0 = PIC1, 1 = PIC2, 2 = IOAPIC */
 588         __u32 pad;
 589         union {
 590                 char dummy[512];  /* reserving space */
 591                 struct kvm_pic_state pic;
 592                 struct kvm_ioapic_state ioapic;
 593         } chip;
 594 };
 595
 596 5. The kvm_run structure
 597
 598 Application code obtains a pointer to the kvm_run structure by
 599 mmap()ing a vcpu fd.  From that point, application code can control
 600 execution by changing fields in kvm_run prior to calling the KVM_RUN
 601 ioctl, and obtain information about the reason KVM_RUN returned by
 602 looking up structure members.
 603
 604 struct kvm_run {
 605         /* in */
 606         __u8 request_interrupt_window;
 607
 608 Request that KVM_RUN return when it becomes possible to inject external
 609 interrupts into the guest.  Useful in conjunction with KVM_INTERRUPT.
 610
 611         __u8 padding1[7];
 612
 613         /* out */
 614         __u32 exit_reason;
 615
 616 When KVM_RUN has returned successfully (return value 0), this informs
 617 application code why KVM_RUN has returned.  Allowable values for this
 618 field are detailed below.
 619
 620         __u8 ready_for_interrupt_injection;
 621
 622 If request_interrupt_window has been specified, this field indicates
 623 an interrupt can be injected now with KVM_INTERRUPT.
 624
 625         __u8 if_flag;
 626
 627 The value of the current interrupt flag.  Only valid if in-kernel
 628 local APIC is not used.
 629
 630         __u8 padding2[2];
 631
 632         /* in (pre_kvm_run), out (post_kvm_run) */
 633         __u64 cr8;
 634
 635 The value of the cr8 register.  Only valid if in-kernel local APIC is
 636 not used.  Both input and output.
 637
 638         __u64 apic_base;
 639
 640 The value of the APIC BASE msr.  Only valid if in-kernel local
 641 APIC is not used.  Both input and output.
 642
 643         union {
 644                 /* KVM_EXIT_UNKNOWN */
 645                 struct {
 646                         __u64 hardware_exit_reason;
 647                 } hw;
 648
 649 If exit_reason is KVM_EXIT_UNKNOWN, the vcpu has exited due to unknown
 650 reasons.  Further architecture-specific information is available in
 651 hardware_exit_reason.
 652
 653                 /* KVM_EXIT_FAIL_ENTRY */
 654                 struct {
 655                         __u64 hardware_entry_failure_reason;
 656                 } fail_entry;
 657
 658 If exit_reason is KVM_EXIT_FAIL_ENTRY, the vcpu could not be run due
 659 to unknown reasons.  Further architecture-specific information is
 660 available in hardware_entry_failure_reason.
 661
 662                 /* KVM_EXIT_EXCEPTION */
 663                 struct {
 664                         __u32 exception;
 665                         __u32 error_code;
 666                 } ex;
 667
 668 Unused.
 669
 670                 /* KVM_EXIT_IO */
 671                 struct {
 672 #define KVM_EXIT_IO_IN  0
 673 #define KVM_EXIT_IO_OUT 1
 674                         __u8 direction;
 675                         __u8 size; /* bytes */
 676                         __u16 port;
 677                         __u32 count;
 678                         __u64 data_offset; /* relative to kvm_run start */
 679                 } io;
 680
 681 If exit_reason is KVM_EXIT_IO_IN or KVM_EXIT_IO_OUT, then the vcpu has
 682 executed a port I/O instruction which could not be satisfied by kvm.
 683 data_offset describes where the data is located (KVM_EXIT_IO_OUT) or
 684 where kvm expects application code to place the data for the next
 685 KVM_RUN invocation (KVM_EXIT_IO_IN).  Data format is a patcked array.
 686
 687                 struct {
 688                         struct kvm_debug_exit_arch arch;
 689                 } debug;
 690
 691 Unused.
 692
 693                 /* KVM_EXIT_MMIO */
 694                 struct {
 695                         __u64 phys_addr;
 696                         __u8  data[8];
 697                         __u32 len;
 698                         __u8  is_write;
 699                 } mmio;
 700
 701 If exit_reason is KVM_EXIT_MMIO or KVM_EXIT_IO_OUT, then the vcpu has
 702 executed a memory-mapped I/O instruction which could not be satisfied
 703 by kvm.  The 'data' member contains the written data if 'is_write' is
 704 true, and should be filled by application code otherwise.
 705
 706                 /* KVM_EXIT_HYPERCALL */
 707                 struct {
 708                         __u64 nr;
 709                         __u64 args[6];
 710                         __u64 ret;
 711                         __u32 longmode;
 712                         __u32 pad;
 713                 } hypercall;
 714
 715 Unused.
 716
 717                 /* KVM_EXIT_TPR_ACCESS */
 718                 struct {
 719                         __u64 rip;
 720                         __u32 is_write;
 721                         __u32 pad;
 722                 } tpr_access;
 723
 724 To be documented (KVM_TPR_ACCESS_REPORTING).
 725
 726                 /* KVM_EXIT_S390_SIEIC */
 727                 struct {
 728                         __u8 icptcode;
 729                         __u64 mask; /* psw upper half */
 730                         __u64 addr; /* psw lower half */
 731                         __u16 ipa;
 732                         __u32 ipb;
 733                 } s390_sieic;
 734
 735 s390 specific.
 736
 737                 /* KVM_EXIT_S390_RESET */
 738 #define KVM_S390_RESET_POR       1
 739 #define KVM_S390_RESET_CLEAR     2
 740 #define KVM_S390_RESET_SUBSYSTEM 4
 741 #define KVM_S390_RESET_CPU_INIT  8
 742 #define KVM_S390_RESET_IPL       16
 743                 __u64 s390_reset_flags;
 744
 745 s390 specific.
 746
 747                 /* KVM_EXIT_DCR */
 748                 struct {
 749                         __u32 dcrn;
 750                         __u32 data;
 751                         __u8  is_write;
 752                 } dcr;
 753
 754 powerpc specific.
 755
 756                 /* Fix the size of the union. */
 757                 char padding[256];
 758         };
 759 };