Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 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 | |
Wu Fengguang | 2044892d | 2009-12-24 09:04:16 +0800 | [diff] [blame] | 26 | 2. File descriptors |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 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 |
Wu Fengguang | 2044892d | 2009-12-24 09:04:16 +0800 | [diff] [blame] | 31 | handle will create a VM file descriptor which can be used to issue VM |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 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 | |
Avi Kivity | 2e2602c | 2010-07-07 14:09:39 +0300 | [diff] [blame] | 129 | Note: if kvm indicates supports MCE (KVM_CAP_MCE), then the MCE bank MSRs are |
| 130 | not returned in the MSR list, as different vcpus can have a different number |
| 131 | of banks, as set via the KVM_X86_SETUP_MCE ioctl. |
| 132 | |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 133 | 4.4 KVM_CHECK_EXTENSION |
| 134 | |
| 135 | Capability: basic |
| 136 | Architectures: all |
| 137 | Type: system ioctl |
| 138 | Parameters: extension identifier (KVM_CAP_*) |
| 139 | Returns: 0 if unsupported; 1 (or some other positive integer) if supported |
| 140 | |
| 141 | The API allows the application to query about extensions to the core |
| 142 | kvm API. Userspace passes an extension identifier (an integer) and |
| 143 | receives an integer that describes the extension availability. |
| 144 | Generally 0 means no and 1 means yes, but some extensions may report |
| 145 | additional information in the integer return value. |
| 146 | |
| 147 | 4.5 KVM_GET_VCPU_MMAP_SIZE |
| 148 | |
| 149 | Capability: basic |
| 150 | Architectures: all |
| 151 | Type: system ioctl |
| 152 | Parameters: none |
| 153 | Returns: size of vcpu mmap area, in bytes |
| 154 | |
| 155 | The KVM_RUN ioctl (cf.) communicates with userspace via a shared |
| 156 | memory region. This ioctl returns the size of that region. See the |
| 157 | KVM_RUN documentation for details. |
| 158 | |
| 159 | 4.6 KVM_SET_MEMORY_REGION |
| 160 | |
| 161 | Capability: basic |
| 162 | Architectures: all |
| 163 | Type: vm ioctl |
| 164 | Parameters: struct kvm_memory_region (in) |
| 165 | Returns: 0 on success, -1 on error |
| 166 | |
Avi Kivity | b74a07b | 2010-06-21 11:48:05 +0300 | [diff] [blame] | 167 | This ioctl is obsolete and has been removed. |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 168 | |
| 169 | 4.6 KVM_CREATE_VCPU |
| 170 | |
| 171 | Capability: basic |
| 172 | Architectures: all |
| 173 | Type: vm ioctl |
| 174 | Parameters: vcpu id (apic id on x86) |
| 175 | Returns: vcpu fd on success, -1 on error |
| 176 | |
| 177 | This API adds a vcpu to a virtual machine. The vcpu id is a small integer |
| 178 | in the range [0, max_vcpus). |
| 179 | |
| 180 | 4.7 KVM_GET_DIRTY_LOG (vm ioctl) |
| 181 | |
| 182 | Capability: basic |
| 183 | Architectures: x86 |
| 184 | Type: vm ioctl |
| 185 | Parameters: struct kvm_dirty_log (in/out) |
| 186 | Returns: 0 on success, -1 on error |
| 187 | |
| 188 | /* for KVM_GET_DIRTY_LOG */ |
| 189 | struct kvm_dirty_log { |
| 190 | __u32 slot; |
| 191 | __u32 padding; |
| 192 | union { |
| 193 | void __user *dirty_bitmap; /* one bit per page */ |
| 194 | __u64 padding; |
| 195 | }; |
| 196 | }; |
| 197 | |
| 198 | Given a memory slot, return a bitmap containing any pages dirtied |
| 199 | since the last call to this ioctl. Bit 0 is the first page in the |
| 200 | memory slot. Ensure the entire structure is cleared to avoid padding |
| 201 | issues. |
| 202 | |
| 203 | 4.8 KVM_SET_MEMORY_ALIAS |
| 204 | |
| 205 | Capability: basic |
| 206 | Architectures: x86 |
| 207 | Type: vm ioctl |
| 208 | Parameters: struct kvm_memory_alias (in) |
| 209 | Returns: 0 (success), -1 (error) |
| 210 | |
Avi Kivity | a1f4d395 | 2010-06-21 11:44:20 +0300 | [diff] [blame] | 211 | This ioctl is obsolete and has been removed. |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 212 | |
| 213 | 4.9 KVM_RUN |
| 214 | |
| 215 | Capability: basic |
| 216 | Architectures: all |
| 217 | Type: vcpu ioctl |
| 218 | Parameters: none |
| 219 | Returns: 0 on success, -1 on error |
| 220 | Errors: |
| 221 | EINTR: an unmasked signal is pending |
| 222 | |
| 223 | This ioctl is used to run a guest virtual cpu. While there are no |
| 224 | explicit parameters, there is an implicit parameter block that can be |
| 225 | obtained by mmap()ing the vcpu fd at offset 0, with the size given by |
| 226 | KVM_GET_VCPU_MMAP_SIZE. The parameter block is formatted as a 'struct |
| 227 | kvm_run' (see below). |
| 228 | |
| 229 | 4.10 KVM_GET_REGS |
| 230 | |
| 231 | Capability: basic |
| 232 | Architectures: all |
| 233 | Type: vcpu ioctl |
| 234 | Parameters: struct kvm_regs (out) |
| 235 | Returns: 0 on success, -1 on error |
| 236 | |
| 237 | Reads the general purpose registers from the vcpu. |
| 238 | |
| 239 | /* x86 */ |
| 240 | struct kvm_regs { |
| 241 | /* out (KVM_GET_REGS) / in (KVM_SET_REGS) */ |
| 242 | __u64 rax, rbx, rcx, rdx; |
| 243 | __u64 rsi, rdi, rsp, rbp; |
| 244 | __u64 r8, r9, r10, r11; |
| 245 | __u64 r12, r13, r14, r15; |
| 246 | __u64 rip, rflags; |
| 247 | }; |
| 248 | |
| 249 | 4.11 KVM_SET_REGS |
| 250 | |
| 251 | Capability: basic |
| 252 | Architectures: all |
| 253 | Type: vcpu ioctl |
| 254 | Parameters: struct kvm_regs (in) |
| 255 | Returns: 0 on success, -1 on error |
| 256 | |
| 257 | Writes the general purpose registers into the vcpu. |
| 258 | |
| 259 | See KVM_GET_REGS for the data structure. |
| 260 | |
| 261 | 4.12 KVM_GET_SREGS |
| 262 | |
| 263 | Capability: basic |
| 264 | Architectures: x86 |
| 265 | Type: vcpu ioctl |
| 266 | Parameters: struct kvm_sregs (out) |
| 267 | Returns: 0 on success, -1 on error |
| 268 | |
| 269 | Reads special registers from the vcpu. |
| 270 | |
| 271 | /* x86 */ |
| 272 | struct kvm_sregs { |
| 273 | struct kvm_segment cs, ds, es, fs, gs, ss; |
| 274 | struct kvm_segment tr, ldt; |
| 275 | struct kvm_dtable gdt, idt; |
| 276 | __u64 cr0, cr2, cr3, cr4, cr8; |
| 277 | __u64 efer; |
| 278 | __u64 apic_base; |
| 279 | __u64 interrupt_bitmap[(KVM_NR_INTERRUPTS + 63) / 64]; |
| 280 | }; |
| 281 | |
| 282 | interrupt_bitmap is a bitmap of pending external interrupts. At most |
| 283 | one bit may be set. This interrupt has been acknowledged by the APIC |
| 284 | but not yet injected into the cpu core. |
| 285 | |
| 286 | 4.13 KVM_SET_SREGS |
| 287 | |
| 288 | Capability: basic |
| 289 | Architectures: x86 |
| 290 | Type: vcpu ioctl |
| 291 | Parameters: struct kvm_sregs (in) |
| 292 | Returns: 0 on success, -1 on error |
| 293 | |
| 294 | Writes special registers into the vcpu. See KVM_GET_SREGS for the |
| 295 | data structures. |
| 296 | |
| 297 | 4.14 KVM_TRANSLATE |
| 298 | |
| 299 | Capability: basic |
| 300 | Architectures: x86 |
| 301 | Type: vcpu ioctl |
| 302 | Parameters: struct kvm_translation (in/out) |
| 303 | Returns: 0 on success, -1 on error |
| 304 | |
| 305 | Translates a virtual address according to the vcpu's current address |
| 306 | translation mode. |
| 307 | |
| 308 | struct kvm_translation { |
| 309 | /* in */ |
| 310 | __u64 linear_address; |
| 311 | |
| 312 | /* out */ |
| 313 | __u64 physical_address; |
| 314 | __u8 valid; |
| 315 | __u8 writeable; |
| 316 | __u8 usermode; |
| 317 | __u8 pad[5]; |
| 318 | }; |
| 319 | |
| 320 | 4.15 KVM_INTERRUPT |
| 321 | |
| 322 | Capability: basic |
Alexander Graf | 6f7a2bd | 2010-08-31 02:03:32 +0200 | [diff] [blame] | 323 | Architectures: x86, ppc |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 324 | Type: vcpu ioctl |
| 325 | Parameters: struct kvm_interrupt (in) |
| 326 | Returns: 0 on success, -1 on error |
| 327 | |
| 328 | Queues a hardware interrupt vector to be injected. This is only |
Alexander Graf | 6f7a2bd | 2010-08-31 02:03:32 +0200 | [diff] [blame] | 329 | useful if in-kernel local APIC or equivalent is not used. |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 330 | |
| 331 | /* for KVM_INTERRUPT */ |
| 332 | struct kvm_interrupt { |
| 333 | /* in */ |
| 334 | __u32 irq; |
| 335 | }; |
| 336 | |
Alexander Graf | 6f7a2bd | 2010-08-31 02:03:32 +0200 | [diff] [blame] | 337 | X86: |
| 338 | |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 339 | Note 'irq' is an interrupt vector, not an interrupt pin or line. |
| 340 | |
Alexander Graf | 6f7a2bd | 2010-08-31 02:03:32 +0200 | [diff] [blame] | 341 | PPC: |
| 342 | |
| 343 | Queues an external interrupt to be injected. This ioctl is overleaded |
| 344 | with 3 different irq values: |
| 345 | |
| 346 | a) KVM_INTERRUPT_SET |
| 347 | |
| 348 | This injects an edge type external interrupt into the guest once it's ready |
| 349 | to receive interrupts. When injected, the interrupt is done. |
| 350 | |
| 351 | b) KVM_INTERRUPT_UNSET |
| 352 | |
| 353 | This unsets any pending interrupt. |
| 354 | |
| 355 | Only available with KVM_CAP_PPC_UNSET_IRQ. |
| 356 | |
| 357 | c) KVM_INTERRUPT_SET_LEVEL |
| 358 | |
| 359 | This injects a level type external interrupt into the guest context. The |
| 360 | interrupt stays pending until a specific ioctl with KVM_INTERRUPT_UNSET |
| 361 | is triggered. |
| 362 | |
| 363 | Only available with KVM_CAP_PPC_IRQ_LEVEL. |
| 364 | |
| 365 | Note that any value for 'irq' other than the ones stated above is invalid |
| 366 | and incurs unexpected behavior. |
| 367 | |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 368 | 4.16 KVM_DEBUG_GUEST |
| 369 | |
| 370 | Capability: basic |
| 371 | Architectures: none |
| 372 | Type: vcpu ioctl |
| 373 | Parameters: none) |
| 374 | Returns: -1 on error |
| 375 | |
| 376 | Support for this has been removed. Use KVM_SET_GUEST_DEBUG instead. |
| 377 | |
| 378 | 4.17 KVM_GET_MSRS |
| 379 | |
| 380 | Capability: basic |
| 381 | Architectures: x86 |
| 382 | Type: vcpu ioctl |
| 383 | Parameters: struct kvm_msrs (in/out) |
| 384 | Returns: 0 on success, -1 on error |
| 385 | |
| 386 | Reads model-specific registers from the vcpu. Supported msr indices can |
| 387 | be obtained using KVM_GET_MSR_INDEX_LIST. |
| 388 | |
| 389 | struct kvm_msrs { |
| 390 | __u32 nmsrs; /* number of msrs in entries */ |
| 391 | __u32 pad; |
| 392 | |
| 393 | struct kvm_msr_entry entries[0]; |
| 394 | }; |
| 395 | |
| 396 | struct kvm_msr_entry { |
| 397 | __u32 index; |
| 398 | __u32 reserved; |
| 399 | __u64 data; |
| 400 | }; |
| 401 | |
| 402 | Application code should set the 'nmsrs' member (which indicates the |
| 403 | size of the entries array) and the 'index' member of each array entry. |
| 404 | kvm will fill in the 'data' member. |
| 405 | |
| 406 | 4.18 KVM_SET_MSRS |
| 407 | |
| 408 | Capability: basic |
| 409 | Architectures: x86 |
| 410 | Type: vcpu ioctl |
| 411 | Parameters: struct kvm_msrs (in) |
| 412 | Returns: 0 on success, -1 on error |
| 413 | |
| 414 | Writes model-specific registers to the vcpu. See KVM_GET_MSRS for the |
| 415 | data structures. |
| 416 | |
| 417 | Application code should set the 'nmsrs' member (which indicates the |
| 418 | size of the entries array), and the 'index' and 'data' members of each |
| 419 | array entry. |
| 420 | |
| 421 | 4.19 KVM_SET_CPUID |
| 422 | |
| 423 | Capability: basic |
| 424 | Architectures: x86 |
| 425 | Type: vcpu ioctl |
| 426 | Parameters: struct kvm_cpuid (in) |
| 427 | Returns: 0 on success, -1 on error |
| 428 | |
| 429 | Defines the vcpu responses to the cpuid instruction. Applications |
| 430 | should use the KVM_SET_CPUID2 ioctl if available. |
| 431 | |
| 432 | |
| 433 | struct kvm_cpuid_entry { |
| 434 | __u32 function; |
| 435 | __u32 eax; |
| 436 | __u32 ebx; |
| 437 | __u32 ecx; |
| 438 | __u32 edx; |
| 439 | __u32 padding; |
| 440 | }; |
| 441 | |
| 442 | /* for KVM_SET_CPUID */ |
| 443 | struct kvm_cpuid { |
| 444 | __u32 nent; |
| 445 | __u32 padding; |
| 446 | struct kvm_cpuid_entry entries[0]; |
| 447 | }; |
| 448 | |
| 449 | 4.20 KVM_SET_SIGNAL_MASK |
| 450 | |
| 451 | Capability: basic |
| 452 | Architectures: x86 |
| 453 | Type: vcpu ioctl |
| 454 | Parameters: struct kvm_signal_mask (in) |
| 455 | Returns: 0 on success, -1 on error |
| 456 | |
| 457 | Defines which signals are blocked during execution of KVM_RUN. This |
| 458 | signal mask temporarily overrides the threads signal mask. Any |
| 459 | unblocked signal received (except SIGKILL and SIGSTOP, which retain |
| 460 | their traditional behaviour) will cause KVM_RUN to return with -EINTR. |
| 461 | |
| 462 | Note the signal will only be delivered if not blocked by the original |
| 463 | signal mask. |
| 464 | |
| 465 | /* for KVM_SET_SIGNAL_MASK */ |
| 466 | struct kvm_signal_mask { |
| 467 | __u32 len; |
| 468 | __u8 sigset[0]; |
| 469 | }; |
| 470 | |
| 471 | 4.21 KVM_GET_FPU |
| 472 | |
| 473 | Capability: basic |
| 474 | Architectures: x86 |
| 475 | Type: vcpu ioctl |
| 476 | Parameters: struct kvm_fpu (out) |
| 477 | Returns: 0 on success, -1 on error |
| 478 | |
| 479 | Reads the floating point state from the vcpu. |
| 480 | |
| 481 | /* for KVM_GET_FPU and KVM_SET_FPU */ |
| 482 | struct kvm_fpu { |
| 483 | __u8 fpr[8][16]; |
| 484 | __u16 fcw; |
| 485 | __u16 fsw; |
| 486 | __u8 ftwx; /* in fxsave format */ |
| 487 | __u8 pad1; |
| 488 | __u16 last_opcode; |
| 489 | __u64 last_ip; |
| 490 | __u64 last_dp; |
| 491 | __u8 xmm[16][16]; |
| 492 | __u32 mxcsr; |
| 493 | __u32 pad2; |
| 494 | }; |
| 495 | |
| 496 | 4.22 KVM_SET_FPU |
| 497 | |
| 498 | Capability: basic |
| 499 | Architectures: x86 |
| 500 | Type: vcpu ioctl |
| 501 | Parameters: struct kvm_fpu (in) |
| 502 | Returns: 0 on success, -1 on error |
| 503 | |
| 504 | Writes the floating point state to the vcpu. |
| 505 | |
| 506 | /* for KVM_GET_FPU and KVM_SET_FPU */ |
| 507 | struct kvm_fpu { |
| 508 | __u8 fpr[8][16]; |
| 509 | __u16 fcw; |
| 510 | __u16 fsw; |
| 511 | __u8 ftwx; /* in fxsave format */ |
| 512 | __u8 pad1; |
| 513 | __u16 last_opcode; |
| 514 | __u64 last_ip; |
| 515 | __u64 last_dp; |
| 516 | __u8 xmm[16][16]; |
| 517 | __u32 mxcsr; |
| 518 | __u32 pad2; |
| 519 | }; |
| 520 | |
Avi Kivity | 5dadbfd | 2009-08-23 17:08:04 +0300 | [diff] [blame] | 521 | 4.23 KVM_CREATE_IRQCHIP |
| 522 | |
| 523 | Capability: KVM_CAP_IRQCHIP |
| 524 | Architectures: x86, ia64 |
| 525 | Type: vm ioctl |
| 526 | Parameters: none |
| 527 | Returns: 0 on success, -1 on error |
| 528 | |
| 529 | Creates an interrupt controller model in the kernel. On x86, creates a virtual |
| 530 | ioapic, a virtual PIC (two PICs, nested), and sets up future vcpus to have a |
| 531 | local APIC. IRQ routing for GSIs 0-15 is set to both PIC and IOAPIC; GSI 16-23 |
| 532 | only go to the IOAPIC. On ia64, a IOSAPIC is created. |
| 533 | |
| 534 | 4.24 KVM_IRQ_LINE |
| 535 | |
| 536 | Capability: KVM_CAP_IRQCHIP |
| 537 | Architectures: x86, ia64 |
| 538 | Type: vm ioctl |
| 539 | Parameters: struct kvm_irq_level |
| 540 | Returns: 0 on success, -1 on error |
| 541 | |
| 542 | Sets the level of a GSI input to the interrupt controller model in the kernel. |
| 543 | Requires that an interrupt controller model has been previously created with |
| 544 | KVM_CREATE_IRQCHIP. Note that edge-triggered interrupts require the level |
| 545 | to be set to 1 and then back to 0. |
| 546 | |
| 547 | struct kvm_irq_level { |
| 548 | union { |
| 549 | __u32 irq; /* GSI */ |
| 550 | __s32 status; /* not used for KVM_IRQ_LEVEL */ |
| 551 | }; |
| 552 | __u32 level; /* 0 or 1 */ |
| 553 | }; |
| 554 | |
| 555 | 4.25 KVM_GET_IRQCHIP |
| 556 | |
| 557 | Capability: KVM_CAP_IRQCHIP |
| 558 | Architectures: x86, ia64 |
| 559 | Type: vm ioctl |
| 560 | Parameters: struct kvm_irqchip (in/out) |
| 561 | Returns: 0 on success, -1 on error |
| 562 | |
| 563 | Reads the state of a kernel interrupt controller created with |
| 564 | KVM_CREATE_IRQCHIP into a buffer provided by the caller. |
| 565 | |
| 566 | struct kvm_irqchip { |
| 567 | __u32 chip_id; /* 0 = PIC1, 1 = PIC2, 2 = IOAPIC */ |
| 568 | __u32 pad; |
| 569 | union { |
| 570 | char dummy[512]; /* reserving space */ |
| 571 | struct kvm_pic_state pic; |
| 572 | struct kvm_ioapic_state ioapic; |
| 573 | } chip; |
| 574 | }; |
| 575 | |
| 576 | 4.26 KVM_SET_IRQCHIP |
| 577 | |
| 578 | Capability: KVM_CAP_IRQCHIP |
| 579 | Architectures: x86, ia64 |
| 580 | Type: vm ioctl |
| 581 | Parameters: struct kvm_irqchip (in) |
| 582 | Returns: 0 on success, -1 on error |
| 583 | |
| 584 | Sets the state of a kernel interrupt controller created with |
| 585 | KVM_CREATE_IRQCHIP from a buffer provided by the caller. |
| 586 | |
| 587 | struct kvm_irqchip { |
| 588 | __u32 chip_id; /* 0 = PIC1, 1 = PIC2, 2 = IOAPIC */ |
| 589 | __u32 pad; |
| 590 | union { |
| 591 | char dummy[512]; /* reserving space */ |
| 592 | struct kvm_pic_state pic; |
| 593 | struct kvm_ioapic_state ioapic; |
| 594 | } chip; |
| 595 | }; |
| 596 | |
Ed Swierk | ffde22a | 2009-10-15 15:21:43 -0700 | [diff] [blame] | 597 | 4.27 KVM_XEN_HVM_CONFIG |
| 598 | |
| 599 | Capability: KVM_CAP_XEN_HVM |
| 600 | Architectures: x86 |
| 601 | Type: vm ioctl |
| 602 | Parameters: struct kvm_xen_hvm_config (in) |
| 603 | Returns: 0 on success, -1 on error |
| 604 | |
| 605 | Sets the MSR that the Xen HVM guest uses to initialize its hypercall |
| 606 | page, and provides the starting address and size of the hypercall |
| 607 | blobs in userspace. When the guest writes the MSR, kvm copies one |
| 608 | page of a blob (32- or 64-bit, depending on the vcpu mode) to guest |
| 609 | memory. |
| 610 | |
| 611 | struct kvm_xen_hvm_config { |
| 612 | __u32 flags; |
| 613 | __u32 msr; |
| 614 | __u64 blob_addr_32; |
| 615 | __u64 blob_addr_64; |
| 616 | __u8 blob_size_32; |
| 617 | __u8 blob_size_64; |
| 618 | __u8 pad2[30]; |
| 619 | }; |
| 620 | |
Glauber Costa | afbcf7a | 2009-10-16 15:28:36 -0400 | [diff] [blame] | 621 | 4.27 KVM_GET_CLOCK |
| 622 | |
| 623 | Capability: KVM_CAP_ADJUST_CLOCK |
| 624 | Architectures: x86 |
| 625 | Type: vm ioctl |
| 626 | Parameters: struct kvm_clock_data (out) |
| 627 | Returns: 0 on success, -1 on error |
| 628 | |
| 629 | Gets the current timestamp of kvmclock as seen by the current guest. In |
| 630 | conjunction with KVM_SET_CLOCK, it is used to ensure monotonicity on scenarios |
| 631 | such as migration. |
| 632 | |
| 633 | struct kvm_clock_data { |
| 634 | __u64 clock; /* kvmclock current value */ |
| 635 | __u32 flags; |
| 636 | __u32 pad[9]; |
| 637 | }; |
| 638 | |
| 639 | 4.28 KVM_SET_CLOCK |
| 640 | |
| 641 | Capability: KVM_CAP_ADJUST_CLOCK |
| 642 | Architectures: x86 |
| 643 | Type: vm ioctl |
| 644 | Parameters: struct kvm_clock_data (in) |
| 645 | Returns: 0 on success, -1 on error |
| 646 | |
Wu Fengguang | 2044892d | 2009-12-24 09:04:16 +0800 | [diff] [blame] | 647 | Sets the current timestamp of kvmclock to the value specified in its parameter. |
Glauber Costa | afbcf7a | 2009-10-16 15:28:36 -0400 | [diff] [blame] | 648 | In conjunction with KVM_GET_CLOCK, it is used to ensure monotonicity on scenarios |
| 649 | such as migration. |
| 650 | |
| 651 | struct kvm_clock_data { |
| 652 | __u64 clock; /* kvmclock current value */ |
| 653 | __u32 flags; |
| 654 | __u32 pad[9]; |
| 655 | }; |
| 656 | |
Jan Kiszka | 3cfc309 | 2009-11-12 01:04:25 +0100 | [diff] [blame] | 657 | 4.29 KVM_GET_VCPU_EVENTS |
| 658 | |
| 659 | Capability: KVM_CAP_VCPU_EVENTS |
Jan Kiszka | 48005f6 | 2010-02-19 19:38:07 +0100 | [diff] [blame] | 660 | Extended by: KVM_CAP_INTR_SHADOW |
Jan Kiszka | 3cfc309 | 2009-11-12 01:04:25 +0100 | [diff] [blame] | 661 | Architectures: x86 |
| 662 | Type: vm ioctl |
| 663 | Parameters: struct kvm_vcpu_event (out) |
| 664 | Returns: 0 on success, -1 on error |
| 665 | |
| 666 | Gets currently pending exceptions, interrupts, and NMIs as well as related |
| 667 | states of the vcpu. |
| 668 | |
| 669 | struct kvm_vcpu_events { |
| 670 | struct { |
| 671 | __u8 injected; |
| 672 | __u8 nr; |
| 673 | __u8 has_error_code; |
| 674 | __u8 pad; |
| 675 | __u32 error_code; |
| 676 | } exception; |
| 677 | struct { |
| 678 | __u8 injected; |
| 679 | __u8 nr; |
| 680 | __u8 soft; |
Jan Kiszka | 48005f6 | 2010-02-19 19:38:07 +0100 | [diff] [blame] | 681 | __u8 shadow; |
Jan Kiszka | 3cfc309 | 2009-11-12 01:04:25 +0100 | [diff] [blame] | 682 | } interrupt; |
| 683 | struct { |
| 684 | __u8 injected; |
| 685 | __u8 pending; |
| 686 | __u8 masked; |
| 687 | __u8 pad; |
| 688 | } nmi; |
| 689 | __u32 sipi_vector; |
Jan Kiszka | dab4b91 | 2009-12-06 18:24:15 +0100 | [diff] [blame] | 690 | __u32 flags; |
Jan Kiszka | 3cfc309 | 2009-11-12 01:04:25 +0100 | [diff] [blame] | 691 | }; |
| 692 | |
Jan Kiszka | 48005f6 | 2010-02-19 19:38:07 +0100 | [diff] [blame] | 693 | KVM_VCPUEVENT_VALID_SHADOW may be set in the flags field to signal that |
| 694 | interrupt.shadow contains a valid state. Otherwise, this field is undefined. |
| 695 | |
Jan Kiszka | 3cfc309 | 2009-11-12 01:04:25 +0100 | [diff] [blame] | 696 | 4.30 KVM_SET_VCPU_EVENTS |
| 697 | |
| 698 | Capability: KVM_CAP_VCPU_EVENTS |
Jan Kiszka | 48005f6 | 2010-02-19 19:38:07 +0100 | [diff] [blame] | 699 | Extended by: KVM_CAP_INTR_SHADOW |
Jan Kiszka | 3cfc309 | 2009-11-12 01:04:25 +0100 | [diff] [blame] | 700 | Architectures: x86 |
| 701 | Type: vm ioctl |
| 702 | Parameters: struct kvm_vcpu_event (in) |
| 703 | Returns: 0 on success, -1 on error |
| 704 | |
| 705 | Set pending exceptions, interrupts, and NMIs as well as related states of the |
| 706 | vcpu. |
| 707 | |
| 708 | See KVM_GET_VCPU_EVENTS for the data structure. |
| 709 | |
Jan Kiszka | dab4b91 | 2009-12-06 18:24:15 +0100 | [diff] [blame] | 710 | Fields that may be modified asynchronously by running VCPUs can be excluded |
| 711 | from the update. These fields are nmi.pending and sipi_vector. Keep the |
| 712 | corresponding bits in the flags field cleared to suppress overwriting the |
| 713 | current in-kernel state. The bits are: |
| 714 | |
| 715 | KVM_VCPUEVENT_VALID_NMI_PENDING - transfer nmi.pending to the kernel |
| 716 | KVM_VCPUEVENT_VALID_SIPI_VECTOR - transfer sipi_vector |
| 717 | |
Jan Kiszka | 48005f6 | 2010-02-19 19:38:07 +0100 | [diff] [blame] | 718 | If KVM_CAP_INTR_SHADOW is available, KVM_VCPUEVENT_VALID_SHADOW can be set in |
| 719 | the flags field to signal that interrupt.shadow contains a valid state and |
| 720 | shall be written into the VCPU. |
| 721 | |
Jan Kiszka | a1efbe7 | 2010-02-15 10:45:43 +0100 | [diff] [blame] | 722 | 4.32 KVM_GET_DEBUGREGS |
| 723 | |
| 724 | Capability: KVM_CAP_DEBUGREGS |
| 725 | Architectures: x86 |
| 726 | Type: vm ioctl |
| 727 | Parameters: struct kvm_debugregs (out) |
| 728 | Returns: 0 on success, -1 on error |
| 729 | |
| 730 | Reads debug registers from the vcpu. |
| 731 | |
| 732 | struct kvm_debugregs { |
| 733 | __u64 db[4]; |
| 734 | __u64 dr6; |
| 735 | __u64 dr7; |
| 736 | __u64 flags; |
| 737 | __u64 reserved[9]; |
| 738 | }; |
| 739 | |
| 740 | 4.33 KVM_SET_DEBUGREGS |
| 741 | |
| 742 | Capability: KVM_CAP_DEBUGREGS |
| 743 | Architectures: x86 |
| 744 | Type: vm ioctl |
| 745 | Parameters: struct kvm_debugregs (in) |
| 746 | Returns: 0 on success, -1 on error |
| 747 | |
| 748 | Writes debug registers into the vcpu. |
| 749 | |
| 750 | See KVM_GET_DEBUGREGS for the data structure. The flags field is unused |
| 751 | yet and must be cleared on entry. |
| 752 | |
Avi Kivity | 0f2d8f4 | 2010-03-25 12:16:48 +0200 | [diff] [blame] | 753 | 4.34 KVM_SET_USER_MEMORY_REGION |
| 754 | |
| 755 | Capability: KVM_CAP_USER_MEM |
| 756 | Architectures: all |
| 757 | Type: vm ioctl |
| 758 | Parameters: struct kvm_userspace_memory_region (in) |
| 759 | Returns: 0 on success, -1 on error |
| 760 | |
| 761 | struct kvm_userspace_memory_region { |
| 762 | __u32 slot; |
| 763 | __u32 flags; |
| 764 | __u64 guest_phys_addr; |
| 765 | __u64 memory_size; /* bytes */ |
| 766 | __u64 userspace_addr; /* start of the userspace allocated memory */ |
| 767 | }; |
| 768 | |
| 769 | /* for kvm_memory_region::flags */ |
| 770 | #define KVM_MEM_LOG_DIRTY_PAGES 1UL |
| 771 | |
| 772 | This ioctl allows the user to create or modify a guest physical memory |
| 773 | slot. When changing an existing slot, it may be moved in the guest |
| 774 | physical memory space, or its flags may be modified. It may not be |
| 775 | resized. Slots may not overlap in guest physical address space. |
| 776 | |
| 777 | Memory for the region is taken starting at the address denoted by the |
| 778 | field userspace_addr, which must point at user addressable memory for |
| 779 | the entire memory slot size. Any object may back this memory, including |
| 780 | anonymous memory, ordinary files, and hugetlbfs. |
| 781 | |
| 782 | It is recommended that the lower 21 bits of guest_phys_addr and userspace_addr |
| 783 | be identical. This allows large pages in the guest to be backed by large |
| 784 | pages in the host. |
| 785 | |
| 786 | The flags field supports just one flag, KVM_MEM_LOG_DIRTY_PAGES, which |
| 787 | instructs kvm to keep track of writes to memory within the slot. See |
| 788 | the KVM_GET_DIRTY_LOG ioctl. |
| 789 | |
| 790 | When the KVM_CAP_SYNC_MMU capability, changes in the backing of the memory |
| 791 | region are automatically reflected into the guest. For example, an mmap() |
| 792 | that affects the region will be made visible immediately. Another example |
| 793 | is madvise(MADV_DROP). |
| 794 | |
| 795 | It is recommended to use this API instead of the KVM_SET_MEMORY_REGION ioctl. |
| 796 | The KVM_SET_MEMORY_REGION does not allow fine grained control over memory |
| 797 | allocation and is deprecated. |
Jan Kiszka | 3cfc309 | 2009-11-12 01:04:25 +0100 | [diff] [blame] | 798 | |
Avi Kivity | 8a5416d | 2010-03-25 12:27:30 +0200 | [diff] [blame] | 799 | 4.35 KVM_SET_TSS_ADDR |
| 800 | |
| 801 | Capability: KVM_CAP_SET_TSS_ADDR |
| 802 | Architectures: x86 |
| 803 | Type: vm ioctl |
| 804 | Parameters: unsigned long tss_address (in) |
| 805 | Returns: 0 on success, -1 on error |
| 806 | |
| 807 | This ioctl defines the physical address of a three-page region in the guest |
| 808 | physical address space. The region must be within the first 4GB of the |
| 809 | guest physical address space and must not conflict with any memory slot |
| 810 | or any mmio address. The guest may malfunction if it accesses this memory |
| 811 | region. |
| 812 | |
| 813 | This ioctl is required on Intel-based hosts. This is needed on Intel hardware |
| 814 | because of a quirk in the virtualization implementation (see the internals |
| 815 | documentation when it pops into existence). |
| 816 | |
Alexander Graf | 71fbfd5 | 2010-03-24 21:48:29 +0100 | [diff] [blame] | 817 | 4.36 KVM_ENABLE_CAP |
| 818 | |
| 819 | Capability: KVM_CAP_ENABLE_CAP |
| 820 | Architectures: ppc |
| 821 | Type: vcpu ioctl |
| 822 | Parameters: struct kvm_enable_cap (in) |
| 823 | Returns: 0 on success; -1 on error |
| 824 | |
| 825 | +Not all extensions are enabled by default. Using this ioctl the application |
| 826 | can enable an extension, making it available to the guest. |
| 827 | |
| 828 | On systems that do not support this ioctl, it always fails. On systems that |
| 829 | do support it, it only works for extensions that are supported for enablement. |
| 830 | |
| 831 | To check if a capability can be enabled, the KVM_CHECK_EXTENSION ioctl should |
| 832 | be used. |
| 833 | |
| 834 | struct kvm_enable_cap { |
| 835 | /* in */ |
| 836 | __u32 cap; |
| 837 | |
| 838 | The capability that is supposed to get enabled. |
| 839 | |
| 840 | __u32 flags; |
| 841 | |
| 842 | A bitfield indicating future enhancements. Has to be 0 for now. |
| 843 | |
| 844 | __u64 args[4]; |
| 845 | |
| 846 | Arguments for enabling a feature. If a feature needs initial values to |
| 847 | function properly, this is the place to put them. |
| 848 | |
| 849 | __u8 pad[64]; |
| 850 | }; |
| 851 | |
Avi Kivity | b843f06 | 2010-04-25 15:51:46 +0300 | [diff] [blame] | 852 | 4.37 KVM_GET_MP_STATE |
| 853 | |
| 854 | Capability: KVM_CAP_MP_STATE |
| 855 | Architectures: x86, ia64 |
| 856 | Type: vcpu ioctl |
| 857 | Parameters: struct kvm_mp_state (out) |
| 858 | Returns: 0 on success; -1 on error |
| 859 | |
| 860 | struct kvm_mp_state { |
| 861 | __u32 mp_state; |
| 862 | }; |
| 863 | |
| 864 | Returns the vcpu's current "multiprocessing state" (though also valid on |
| 865 | uniprocessor guests). |
| 866 | |
| 867 | Possible values are: |
| 868 | |
| 869 | - KVM_MP_STATE_RUNNABLE: the vcpu is currently running |
| 870 | - KVM_MP_STATE_UNINITIALIZED: the vcpu is an application processor (AP) |
| 871 | which has not yet received an INIT signal |
| 872 | - KVM_MP_STATE_INIT_RECEIVED: the vcpu has received an INIT signal, and is |
| 873 | now ready for a SIPI |
| 874 | - KVM_MP_STATE_HALTED: the vcpu has executed a HLT instruction and |
| 875 | is waiting for an interrupt |
| 876 | - KVM_MP_STATE_SIPI_RECEIVED: the vcpu has just received a SIPI (vector |
| 877 | accesible via KVM_GET_VCPU_EVENTS) |
| 878 | |
| 879 | This ioctl is only useful after KVM_CREATE_IRQCHIP. Without an in-kernel |
| 880 | irqchip, the multiprocessing state must be maintained by userspace. |
| 881 | |
| 882 | 4.38 KVM_SET_MP_STATE |
| 883 | |
| 884 | Capability: KVM_CAP_MP_STATE |
| 885 | Architectures: x86, ia64 |
| 886 | Type: vcpu ioctl |
| 887 | Parameters: struct kvm_mp_state (in) |
| 888 | Returns: 0 on success; -1 on error |
| 889 | |
| 890 | Sets the vcpu's current "multiprocessing state"; see KVM_GET_MP_STATE for |
| 891 | arguments. |
| 892 | |
| 893 | This ioctl is only useful after KVM_CREATE_IRQCHIP. Without an in-kernel |
| 894 | irqchip, the multiprocessing state must be maintained by userspace. |
| 895 | |
Avi Kivity | 47dbb84 | 2010-04-29 12:08:56 +0300 | [diff] [blame] | 896 | 4.39 KVM_SET_IDENTITY_MAP_ADDR |
| 897 | |
| 898 | Capability: KVM_CAP_SET_IDENTITY_MAP_ADDR |
| 899 | Architectures: x86 |
| 900 | Type: vm ioctl |
| 901 | Parameters: unsigned long identity (in) |
| 902 | Returns: 0 on success, -1 on error |
| 903 | |
| 904 | This ioctl defines the physical address of a one-page region in the guest |
| 905 | physical address space. The region must be within the first 4GB of the |
| 906 | guest physical address space and must not conflict with any memory slot |
| 907 | or any mmio address. The guest may malfunction if it accesses this memory |
| 908 | region. |
| 909 | |
| 910 | This ioctl is required on Intel-based hosts. This is needed on Intel hardware |
| 911 | because of a quirk in the virtualization implementation (see the internals |
| 912 | documentation when it pops into existence). |
| 913 | |
Avi Kivity | 57bc24c | 2010-04-29 12:12:57 +0300 | [diff] [blame] | 914 | 4.40 KVM_SET_BOOT_CPU_ID |
| 915 | |
| 916 | Capability: KVM_CAP_SET_BOOT_CPU_ID |
| 917 | Architectures: x86, ia64 |
| 918 | Type: vm ioctl |
| 919 | Parameters: unsigned long vcpu_id |
| 920 | Returns: 0 on success, -1 on error |
| 921 | |
| 922 | Define which vcpu is the Bootstrap Processor (BSP). Values are the same |
| 923 | as the vcpu id in KVM_CREATE_VCPU. If this ioctl is not called, the default |
| 924 | is vcpu 0. |
| 925 | |
Sheng Yang | 2d5b5a6 | 2010-06-13 17:29:39 +0800 | [diff] [blame] | 926 | 4.41 KVM_GET_XSAVE |
| 927 | |
| 928 | Capability: KVM_CAP_XSAVE |
| 929 | Architectures: x86 |
| 930 | Type: vcpu ioctl |
| 931 | Parameters: struct kvm_xsave (out) |
| 932 | Returns: 0 on success, -1 on error |
| 933 | |
| 934 | struct kvm_xsave { |
| 935 | __u32 region[1024]; |
| 936 | }; |
| 937 | |
| 938 | This ioctl would copy current vcpu's xsave struct to the userspace. |
| 939 | |
| 940 | 4.42 KVM_SET_XSAVE |
| 941 | |
| 942 | Capability: KVM_CAP_XSAVE |
| 943 | Architectures: x86 |
| 944 | Type: vcpu ioctl |
| 945 | Parameters: struct kvm_xsave (in) |
| 946 | Returns: 0 on success, -1 on error |
| 947 | |
| 948 | struct kvm_xsave { |
| 949 | __u32 region[1024]; |
| 950 | }; |
| 951 | |
| 952 | This ioctl would copy userspace's xsave struct to the kernel. |
| 953 | |
| 954 | 4.43 KVM_GET_XCRS |
| 955 | |
| 956 | Capability: KVM_CAP_XCRS |
| 957 | Architectures: x86 |
| 958 | Type: vcpu ioctl |
| 959 | Parameters: struct kvm_xcrs (out) |
| 960 | Returns: 0 on success, -1 on error |
| 961 | |
| 962 | struct kvm_xcr { |
| 963 | __u32 xcr; |
| 964 | __u32 reserved; |
| 965 | __u64 value; |
| 966 | }; |
| 967 | |
| 968 | struct kvm_xcrs { |
| 969 | __u32 nr_xcrs; |
| 970 | __u32 flags; |
| 971 | struct kvm_xcr xcrs[KVM_MAX_XCRS]; |
| 972 | __u64 padding[16]; |
| 973 | }; |
| 974 | |
| 975 | This ioctl would copy current vcpu's xcrs to the userspace. |
| 976 | |
| 977 | 4.44 KVM_SET_XCRS |
| 978 | |
| 979 | Capability: KVM_CAP_XCRS |
| 980 | Architectures: x86 |
| 981 | Type: vcpu ioctl |
| 982 | Parameters: struct kvm_xcrs (in) |
| 983 | Returns: 0 on success, -1 on error |
| 984 | |
| 985 | struct kvm_xcr { |
| 986 | __u32 xcr; |
| 987 | __u32 reserved; |
| 988 | __u64 value; |
| 989 | }; |
| 990 | |
| 991 | struct kvm_xcrs { |
| 992 | __u32 nr_xcrs; |
| 993 | __u32 flags; |
| 994 | struct kvm_xcr xcrs[KVM_MAX_XCRS]; |
| 995 | __u64 padding[16]; |
| 996 | }; |
| 997 | |
| 998 | This ioctl would set vcpu's xcr to the value userspace specified. |
| 999 | |
Avi Kivity | d153513 | 2010-07-14 09:45:21 +0300 | [diff] [blame] | 1000 | 4.45 KVM_GET_SUPPORTED_CPUID |
| 1001 | |
| 1002 | Capability: KVM_CAP_EXT_CPUID |
| 1003 | Architectures: x86 |
| 1004 | Type: system ioctl |
| 1005 | Parameters: struct kvm_cpuid2 (in/out) |
| 1006 | Returns: 0 on success, -1 on error |
| 1007 | |
| 1008 | struct kvm_cpuid2 { |
| 1009 | __u32 nent; |
| 1010 | __u32 padding; |
| 1011 | struct kvm_cpuid_entry2 entries[0]; |
| 1012 | }; |
| 1013 | |
| 1014 | #define KVM_CPUID_FLAG_SIGNIFCANT_INDEX 1 |
| 1015 | #define KVM_CPUID_FLAG_STATEFUL_FUNC 2 |
| 1016 | #define KVM_CPUID_FLAG_STATE_READ_NEXT 4 |
| 1017 | |
| 1018 | struct kvm_cpuid_entry2 { |
| 1019 | __u32 function; |
| 1020 | __u32 index; |
| 1021 | __u32 flags; |
| 1022 | __u32 eax; |
| 1023 | __u32 ebx; |
| 1024 | __u32 ecx; |
| 1025 | __u32 edx; |
| 1026 | __u32 padding[3]; |
| 1027 | }; |
| 1028 | |
| 1029 | This ioctl returns x86 cpuid features which are supported by both the hardware |
| 1030 | and kvm. Userspace can use the information returned by this ioctl to |
| 1031 | construct cpuid information (for KVM_SET_CPUID2) that is consistent with |
| 1032 | hardware, kernel, and userspace capabilities, and with user requirements (for |
| 1033 | example, the user may wish to constrain cpuid to emulate older hardware, |
| 1034 | or for feature consistency across a cluster). |
| 1035 | |
| 1036 | Userspace invokes KVM_GET_SUPPORTED_CPUID by passing a kvm_cpuid2 structure |
| 1037 | with the 'nent' field indicating the number of entries in the variable-size |
| 1038 | array 'entries'. If the number of entries is too low to describe the cpu |
| 1039 | capabilities, an error (E2BIG) is returned. If the number is too high, |
| 1040 | the 'nent' field is adjusted and an error (ENOMEM) is returned. If the |
| 1041 | number is just right, the 'nent' field is adjusted to the number of valid |
| 1042 | entries in the 'entries' array, which is then filled. |
| 1043 | |
| 1044 | The entries returned are the host cpuid as returned by the cpuid instruction, |
Avi Kivity | c39cbd2 | 2010-09-12 16:39:11 +0200 | [diff] [blame] | 1045 | with unknown or unsupported features masked out. Some features (for example, |
| 1046 | x2apic), may not be present in the host cpu, but are exposed by kvm if it can |
| 1047 | emulate them efficiently. The fields in each entry are defined as follows: |
Avi Kivity | d153513 | 2010-07-14 09:45:21 +0300 | [diff] [blame] | 1048 | |
| 1049 | function: the eax value used to obtain the entry |
| 1050 | index: the ecx value used to obtain the entry (for entries that are |
| 1051 | affected by ecx) |
| 1052 | flags: an OR of zero or more of the following: |
| 1053 | KVM_CPUID_FLAG_SIGNIFCANT_INDEX: |
| 1054 | if the index field is valid |
| 1055 | KVM_CPUID_FLAG_STATEFUL_FUNC: |
| 1056 | if cpuid for this function returns different values for successive |
| 1057 | invocations; there will be several entries with the same function, |
| 1058 | all with this flag set |
| 1059 | KVM_CPUID_FLAG_STATE_READ_NEXT: |
| 1060 | for KVM_CPUID_FLAG_STATEFUL_FUNC entries, set if this entry is |
| 1061 | the first entry to be read by a cpu |
| 1062 | eax, ebx, ecx, edx: the values returned by the cpuid instruction for |
| 1063 | this function/index combination |
| 1064 | |
Alexander Graf | 15711e9 | 2010-07-29 14:48:08 +0200 | [diff] [blame] | 1065 | 4.46 KVM_PPC_GET_PVINFO |
| 1066 | |
| 1067 | Capability: KVM_CAP_PPC_GET_PVINFO |
| 1068 | Architectures: ppc |
| 1069 | Type: vm ioctl |
| 1070 | Parameters: struct kvm_ppc_pvinfo (out) |
| 1071 | Returns: 0 on success, !0 on error |
| 1072 | |
| 1073 | struct kvm_ppc_pvinfo { |
| 1074 | __u32 flags; |
| 1075 | __u32 hcall[4]; |
| 1076 | __u8 pad[108]; |
| 1077 | }; |
| 1078 | |
| 1079 | This ioctl fetches PV specific information that need to be passed to the guest |
| 1080 | using the device tree or other means from vm context. |
| 1081 | |
| 1082 | For now the only implemented piece of information distributed here is an array |
| 1083 | of 4 instructions that make up a hypercall. |
| 1084 | |
| 1085 | If any additional field gets added to this structure later on, a bit for that |
| 1086 | additional piece of information will be set in the flags bitmap. |
| 1087 | |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 1088 | 5. The kvm_run structure |
| 1089 | |
| 1090 | Application code obtains a pointer to the kvm_run structure by |
| 1091 | mmap()ing a vcpu fd. From that point, application code can control |
| 1092 | execution by changing fields in kvm_run prior to calling the KVM_RUN |
| 1093 | ioctl, and obtain information about the reason KVM_RUN returned by |
| 1094 | looking up structure members. |
| 1095 | |
| 1096 | struct kvm_run { |
| 1097 | /* in */ |
| 1098 | __u8 request_interrupt_window; |
| 1099 | |
| 1100 | Request that KVM_RUN return when it becomes possible to inject external |
| 1101 | interrupts into the guest. Useful in conjunction with KVM_INTERRUPT. |
| 1102 | |
| 1103 | __u8 padding1[7]; |
| 1104 | |
| 1105 | /* out */ |
| 1106 | __u32 exit_reason; |
| 1107 | |
| 1108 | When KVM_RUN has returned successfully (return value 0), this informs |
| 1109 | application code why KVM_RUN has returned. Allowable values for this |
| 1110 | field are detailed below. |
| 1111 | |
| 1112 | __u8 ready_for_interrupt_injection; |
| 1113 | |
| 1114 | If request_interrupt_window has been specified, this field indicates |
| 1115 | an interrupt can be injected now with KVM_INTERRUPT. |
| 1116 | |
| 1117 | __u8 if_flag; |
| 1118 | |
| 1119 | The value of the current interrupt flag. Only valid if in-kernel |
| 1120 | local APIC is not used. |
| 1121 | |
| 1122 | __u8 padding2[2]; |
| 1123 | |
| 1124 | /* in (pre_kvm_run), out (post_kvm_run) */ |
| 1125 | __u64 cr8; |
| 1126 | |
| 1127 | The value of the cr8 register. Only valid if in-kernel local APIC is |
| 1128 | not used. Both input and output. |
| 1129 | |
| 1130 | __u64 apic_base; |
| 1131 | |
| 1132 | The value of the APIC BASE msr. Only valid if in-kernel local |
| 1133 | APIC is not used. Both input and output. |
| 1134 | |
| 1135 | union { |
| 1136 | /* KVM_EXIT_UNKNOWN */ |
| 1137 | struct { |
| 1138 | __u64 hardware_exit_reason; |
| 1139 | } hw; |
| 1140 | |
| 1141 | If exit_reason is KVM_EXIT_UNKNOWN, the vcpu has exited due to unknown |
| 1142 | reasons. Further architecture-specific information is available in |
| 1143 | hardware_exit_reason. |
| 1144 | |
| 1145 | /* KVM_EXIT_FAIL_ENTRY */ |
| 1146 | struct { |
| 1147 | __u64 hardware_entry_failure_reason; |
| 1148 | } fail_entry; |
| 1149 | |
| 1150 | If exit_reason is KVM_EXIT_FAIL_ENTRY, the vcpu could not be run due |
| 1151 | to unknown reasons. Further architecture-specific information is |
| 1152 | available in hardware_entry_failure_reason. |
| 1153 | |
| 1154 | /* KVM_EXIT_EXCEPTION */ |
| 1155 | struct { |
| 1156 | __u32 exception; |
| 1157 | __u32 error_code; |
| 1158 | } ex; |
| 1159 | |
| 1160 | Unused. |
| 1161 | |
| 1162 | /* KVM_EXIT_IO */ |
| 1163 | struct { |
| 1164 | #define KVM_EXIT_IO_IN 0 |
| 1165 | #define KVM_EXIT_IO_OUT 1 |
| 1166 | __u8 direction; |
| 1167 | __u8 size; /* bytes */ |
| 1168 | __u16 port; |
| 1169 | __u32 count; |
| 1170 | __u64 data_offset; /* relative to kvm_run start */ |
| 1171 | } io; |
| 1172 | |
Wu Fengguang | 2044892d | 2009-12-24 09:04:16 +0800 | [diff] [blame] | 1173 | If exit_reason is KVM_EXIT_IO, then the vcpu has |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 1174 | executed a port I/O instruction which could not be satisfied by kvm. |
| 1175 | data_offset describes where the data is located (KVM_EXIT_IO_OUT) or |
| 1176 | where kvm expects application code to place the data for the next |
Wu Fengguang | 2044892d | 2009-12-24 09:04:16 +0800 | [diff] [blame] | 1177 | KVM_RUN invocation (KVM_EXIT_IO_IN). Data format is a packed array. |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 1178 | |
| 1179 | struct { |
| 1180 | struct kvm_debug_exit_arch arch; |
| 1181 | } debug; |
| 1182 | |
| 1183 | Unused. |
| 1184 | |
| 1185 | /* KVM_EXIT_MMIO */ |
| 1186 | struct { |
| 1187 | __u64 phys_addr; |
| 1188 | __u8 data[8]; |
| 1189 | __u32 len; |
| 1190 | __u8 is_write; |
| 1191 | } mmio; |
| 1192 | |
Wu Fengguang | 2044892d | 2009-12-24 09:04:16 +0800 | [diff] [blame] | 1193 | If exit_reason is KVM_EXIT_MMIO, then the vcpu has |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 1194 | executed a memory-mapped I/O instruction which could not be satisfied |
| 1195 | by kvm. The 'data' member contains the written data if 'is_write' is |
| 1196 | true, and should be filled by application code otherwise. |
| 1197 | |
Alexander Graf | ad0a048 | 2010-03-24 21:48:30 +0100 | [diff] [blame] | 1198 | NOTE: For KVM_EXIT_IO, KVM_EXIT_MMIO and KVM_EXIT_OSI, the corresponding |
| 1199 | operations are complete (and guest state is consistent) only after userspace |
| 1200 | has re-entered the kernel with KVM_RUN. The kernel side will first finish |
Marcelo Tosatti | 6796134 | 2010-02-13 16:10:26 -0200 | [diff] [blame] | 1201 | incomplete operations and then check for pending signals. Userspace |
| 1202 | can re-enter the guest with an unmasked signal pending to complete |
| 1203 | pending operations. |
| 1204 | |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 1205 | /* KVM_EXIT_HYPERCALL */ |
| 1206 | struct { |
| 1207 | __u64 nr; |
| 1208 | __u64 args[6]; |
| 1209 | __u64 ret; |
| 1210 | __u32 longmode; |
| 1211 | __u32 pad; |
| 1212 | } hypercall; |
| 1213 | |
Avi Kivity | 647dc49 | 2010-04-01 14:39:21 +0300 | [diff] [blame] | 1214 | Unused. This was once used for 'hypercall to userspace'. To implement |
| 1215 | such functionality, use KVM_EXIT_IO (x86) or KVM_EXIT_MMIO (all except s390). |
| 1216 | Note KVM_EXIT_IO is significantly faster than KVM_EXIT_MMIO. |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 1217 | |
| 1218 | /* KVM_EXIT_TPR_ACCESS */ |
| 1219 | struct { |
| 1220 | __u64 rip; |
| 1221 | __u32 is_write; |
| 1222 | __u32 pad; |
| 1223 | } tpr_access; |
| 1224 | |
| 1225 | To be documented (KVM_TPR_ACCESS_REPORTING). |
| 1226 | |
| 1227 | /* KVM_EXIT_S390_SIEIC */ |
| 1228 | struct { |
| 1229 | __u8 icptcode; |
| 1230 | __u64 mask; /* psw upper half */ |
| 1231 | __u64 addr; /* psw lower half */ |
| 1232 | __u16 ipa; |
| 1233 | __u32 ipb; |
| 1234 | } s390_sieic; |
| 1235 | |
| 1236 | s390 specific. |
| 1237 | |
| 1238 | /* KVM_EXIT_S390_RESET */ |
| 1239 | #define KVM_S390_RESET_POR 1 |
| 1240 | #define KVM_S390_RESET_CLEAR 2 |
| 1241 | #define KVM_S390_RESET_SUBSYSTEM 4 |
| 1242 | #define KVM_S390_RESET_CPU_INIT 8 |
| 1243 | #define KVM_S390_RESET_IPL 16 |
| 1244 | __u64 s390_reset_flags; |
| 1245 | |
| 1246 | s390 specific. |
| 1247 | |
| 1248 | /* KVM_EXIT_DCR */ |
| 1249 | struct { |
| 1250 | __u32 dcrn; |
| 1251 | __u32 data; |
| 1252 | __u8 is_write; |
| 1253 | } dcr; |
| 1254 | |
| 1255 | powerpc specific. |
| 1256 | |
Alexander Graf | ad0a048 | 2010-03-24 21:48:30 +0100 | [diff] [blame] | 1257 | /* KVM_EXIT_OSI */ |
| 1258 | struct { |
| 1259 | __u64 gprs[32]; |
| 1260 | } osi; |
| 1261 | |
| 1262 | MOL uses a special hypercall interface it calls 'OSI'. To enable it, we catch |
| 1263 | hypercalls and exit with this exit struct that contains all the guest gprs. |
| 1264 | |
| 1265 | If exit_reason is KVM_EXIT_OSI, then the vcpu has triggered such a hypercall. |
| 1266 | Userspace can now handle the hypercall and when it's done modify the gprs as |
| 1267 | necessary. Upon guest entry all guest GPRs will then be replaced by the values |
| 1268 | in this struct. |
| 1269 | |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 1270 | /* Fix the size of the union. */ |
| 1271 | char padding[256]; |
| 1272 | }; |
| 1273 | }; |