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 |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 5 | ---------------------- |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 6 | |
| 7 | The kvm API is a set of ioctls that are issued to control various aspects |
| 8 | of a virtual machine. The ioctls belong to three classes |
| 9 | |
| 10 | - System ioctls: These query and set global attributes which affect the |
| 11 | whole kvm subsystem. In addition a system ioctl is used to create |
| 12 | virtual machines |
| 13 | |
| 14 | - VM ioctls: These query and set attributes that affect an entire virtual |
| 15 | machine, for example memory layout. In addition a VM ioctl is used to |
| 16 | create virtual cpus (vcpus). |
| 17 | |
| 18 | Only run VM ioctls from the same process (address space) that was used |
| 19 | to create the VM. |
| 20 | |
| 21 | - vcpu ioctls: These query and set attributes that control the operation |
| 22 | of a single virtual cpu. |
| 23 | |
| 24 | Only run vcpu ioctls from the same thread that was used to create the |
| 25 | vcpu. |
| 26 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 27 | |
Wu Fengguang | 2044892d | 2009-12-24 09:04:16 +0800 | [diff] [blame] | 28 | 2. File descriptors |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 29 | ------------------- |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 30 | |
| 31 | The kvm API is centered around file descriptors. An initial |
| 32 | open("/dev/kvm") obtains a handle to the kvm subsystem; this handle |
| 33 | 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] | 34 | 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] | 35 | ioctls. A KVM_CREATE_VCPU ioctl on a VM fd will create a virtual cpu |
| 36 | and return a file descriptor pointing to it. Finally, ioctls on a vcpu |
| 37 | fd can be used to control the vcpu, including the important task of |
| 38 | actually running guest code. |
| 39 | |
| 40 | In general file descriptors can be migrated among processes by means |
| 41 | of fork() and the SCM_RIGHTS facility of unix domain socket. These |
| 42 | kinds of tricks are explicitly not supported by kvm. While they will |
| 43 | not cause harm to the host, their actual behavior is not guaranteed by |
| 44 | the API. The only supported use is one virtual machine per process, |
| 45 | and one vcpu per thread. |
| 46 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 47 | |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 48 | 3. Extensions |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 49 | ------------- |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 50 | |
| 51 | As of Linux 2.6.22, the KVM ABI has been stabilized: no backward |
| 52 | incompatible change are allowed. However, there is an extension |
| 53 | facility that allows backward-compatible extensions to the API to be |
| 54 | queried and used. |
| 55 | |
Masanari Iida | c9f3f2d | 2013-07-18 01:29:12 +0900 | [diff] [blame] | 56 | The extension mechanism is not based on the Linux version number. |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 57 | Instead, kvm defines extension identifiers and a facility to query |
| 58 | whether a particular extension identifier is available. If it is, a |
| 59 | set of ioctls is available for application use. |
| 60 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 61 | |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 62 | 4. API description |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 63 | ------------------ |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 64 | |
| 65 | This section describes ioctls that can be used to control kvm guests. |
| 66 | For each ioctl, the following information is provided along with a |
| 67 | description: |
| 68 | |
| 69 | Capability: which KVM extension provides this ioctl. Can be 'basic', |
| 70 | which means that is will be provided by any kernel that supports |
Michael S. Tsirkin | 7f05db6 | 2014-10-12 11:34:00 +0300 | [diff] [blame] | 71 | API version 12 (see section 4.1), a KVM_CAP_xyz constant, which |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 72 | means availability needs to be checked with KVM_CHECK_EXTENSION |
Michael S. Tsirkin | 7f05db6 | 2014-10-12 11:34:00 +0300 | [diff] [blame] | 73 | (see section 4.4), or 'none' which means that while not all kernels |
| 74 | support this ioctl, there's no capability bit to check its |
| 75 | availability: for kernels that don't support the ioctl, |
| 76 | the ioctl returns -ENOTTY. |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 77 | |
| 78 | Architectures: which instruction set architectures provide this ioctl. |
| 79 | x86 includes both i386 and x86_64. |
| 80 | |
| 81 | Type: system, vm, or vcpu. |
| 82 | |
| 83 | Parameters: what parameters are accepted by the ioctl. |
| 84 | |
| 85 | Returns: the return value. General error numbers (EBADF, ENOMEM, EINVAL) |
| 86 | are not detailed, but errors with specific meanings are. |
| 87 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 88 | |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 89 | 4.1 KVM_GET_API_VERSION |
| 90 | |
| 91 | Capability: basic |
| 92 | Architectures: all |
| 93 | Type: system ioctl |
| 94 | Parameters: none |
| 95 | Returns: the constant KVM_API_VERSION (=12) |
| 96 | |
| 97 | This identifies the API version as the stable kvm API. It is not |
| 98 | expected that this number will change. However, Linux 2.6.20 and |
| 99 | 2.6.21 report earlier versions; these are not documented and not |
| 100 | supported. Applications should refuse to run if KVM_GET_API_VERSION |
| 101 | returns a value other than 12. If this check passes, all ioctls |
| 102 | described as 'basic' will be available. |
| 103 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 104 | |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 105 | 4.2 KVM_CREATE_VM |
| 106 | |
| 107 | Capability: basic |
| 108 | Architectures: all |
| 109 | Type: system ioctl |
Carsten Otte | e08b963 | 2012-01-04 10:25:20 +0100 | [diff] [blame] | 110 | Parameters: machine type identifier (KVM_VM_*) |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 111 | Returns: a VM fd that can be used to control the new virtual machine. |
| 112 | |
| 113 | The new VM has no virtual cpus and no memory. An mmap() of a VM fd |
| 114 | will access the virtual machine's physical address space; offset zero |
| 115 | corresponds to guest physical address zero. Use of mmap() on a VM fd |
| 116 | is discouraged if userspace memory allocation (KVM_CAP_USER_MEMORY) is |
| 117 | available. |
Carsten Otte | e08b963 | 2012-01-04 10:25:20 +0100 | [diff] [blame] | 118 | You most certainly want to use 0 as machine type. |
| 119 | |
| 120 | In order to create user controlled virtual machines on S390, check |
| 121 | KVM_CAP_S390_UCONTROL and use the flag KVM_VM_S390_UCONTROL as |
| 122 | privileged user (CAP_SYS_ADMIN). |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 123 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 124 | |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 125 | 4.3 KVM_GET_MSR_INDEX_LIST |
| 126 | |
| 127 | Capability: basic |
| 128 | Architectures: x86 |
| 129 | Type: system |
| 130 | Parameters: struct kvm_msr_list (in/out) |
| 131 | Returns: 0 on success; -1 on error |
| 132 | Errors: |
| 133 | E2BIG: the msr index list is to be to fit in the array specified by |
| 134 | the user. |
| 135 | |
| 136 | struct kvm_msr_list { |
| 137 | __u32 nmsrs; /* number of msrs in entries */ |
| 138 | __u32 indices[0]; |
| 139 | }; |
| 140 | |
| 141 | This ioctl returns the guest msrs that are supported. The list varies |
| 142 | by kvm version and host processor, but does not change otherwise. The |
| 143 | user fills in the size of the indices array in nmsrs, and in return |
| 144 | kvm adjusts nmsrs to reflect the actual number of msrs and fills in |
| 145 | the indices array with their numbers. |
| 146 | |
Avi Kivity | 2e2602c | 2010-07-07 14:09:39 +0300 | [diff] [blame] | 147 | Note: if kvm indicates supports MCE (KVM_CAP_MCE), then the MCE bank MSRs are |
| 148 | not returned in the MSR list, as different vcpus can have a different number |
| 149 | of banks, as set via the KVM_X86_SETUP_MCE ioctl. |
| 150 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 151 | |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 152 | 4.4 KVM_CHECK_EXTENSION |
| 153 | |
Alexander Graf | 92b591a | 2014-07-14 18:33:08 +0200 | [diff] [blame] | 154 | Capability: basic, KVM_CAP_CHECK_EXTENSION_VM for vm ioctl |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 155 | Architectures: all |
Alexander Graf | 92b591a | 2014-07-14 18:33:08 +0200 | [diff] [blame] | 156 | Type: system ioctl, vm ioctl |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 157 | Parameters: extension identifier (KVM_CAP_*) |
| 158 | Returns: 0 if unsupported; 1 (or some other positive integer) if supported |
| 159 | |
| 160 | The API allows the application to query about extensions to the core |
| 161 | kvm API. Userspace passes an extension identifier (an integer) and |
| 162 | receives an integer that describes the extension availability. |
| 163 | Generally 0 means no and 1 means yes, but some extensions may report |
| 164 | additional information in the integer return value. |
| 165 | |
Alexander Graf | 92b591a | 2014-07-14 18:33:08 +0200 | [diff] [blame] | 166 | Based on their initialization different VMs may have different capabilities. |
| 167 | It is thus encouraged to use the vm ioctl to query for capabilities (available |
| 168 | with KVM_CAP_CHECK_EXTENSION_VM on the vm fd) |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 169 | |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 170 | 4.5 KVM_GET_VCPU_MMAP_SIZE |
| 171 | |
| 172 | Capability: basic |
| 173 | Architectures: all |
| 174 | Type: system ioctl |
| 175 | Parameters: none |
| 176 | Returns: size of vcpu mmap area, in bytes |
| 177 | |
| 178 | The KVM_RUN ioctl (cf.) communicates with userspace via a shared |
| 179 | memory region. This ioctl returns the size of that region. See the |
| 180 | KVM_RUN documentation for details. |
| 181 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 182 | |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 183 | 4.6 KVM_SET_MEMORY_REGION |
| 184 | |
| 185 | Capability: basic |
| 186 | Architectures: all |
| 187 | Type: vm ioctl |
| 188 | Parameters: struct kvm_memory_region (in) |
| 189 | Returns: 0 on success, -1 on error |
| 190 | |
Avi Kivity | b74a07b | 2010-06-21 11:48:05 +0300 | [diff] [blame] | 191 | This ioctl is obsolete and has been removed. |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 192 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 193 | |
Paul Bolle | 68ba697 | 2011-02-15 00:05:59 +0100 | [diff] [blame] | 194 | 4.7 KVM_CREATE_VCPU |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 195 | |
| 196 | Capability: basic |
| 197 | Architectures: all |
| 198 | Type: vm ioctl |
| 199 | Parameters: vcpu id (apic id on x86) |
| 200 | Returns: vcpu fd on success, -1 on error |
| 201 | |
| 202 | This API adds a vcpu to a virtual machine. The vcpu id is a small integer |
Sasha Levin | 8c3ba33 | 2011-07-18 17:17:15 +0300 | [diff] [blame] | 203 | in the range [0, max_vcpus). |
| 204 | |
| 205 | The recommended max_vcpus value can be retrieved using the KVM_CAP_NR_VCPUS of |
| 206 | the KVM_CHECK_EXTENSION ioctl() at run-time. |
| 207 | The maximum possible value for max_vcpus can be retrieved using the |
| 208 | KVM_CAP_MAX_VCPUS of the KVM_CHECK_EXTENSION ioctl() at run-time. |
| 209 | |
Pekka Enberg | 76d2540 | 2011-05-09 22:48:54 +0300 | [diff] [blame] | 210 | If the KVM_CAP_NR_VCPUS does not exist, you should assume that max_vcpus is 4 |
| 211 | cpus max. |
Sasha Levin | 8c3ba33 | 2011-07-18 17:17:15 +0300 | [diff] [blame] | 212 | If the KVM_CAP_MAX_VCPUS does not exist, you should assume that max_vcpus is |
| 213 | same as the value returned from KVM_CAP_NR_VCPUS. |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 214 | |
Paul Mackerras | 371fefd | 2011-06-29 00:23:08 +0000 | [diff] [blame] | 215 | On powerpc using book3s_hv mode, the vcpus are mapped onto virtual |
| 216 | threads in one or more virtual CPU cores. (This is because the |
| 217 | hardware requires all the hardware threads in a CPU core to be in the |
| 218 | same partition.) The KVM_CAP_PPC_SMT capability indicates the number |
| 219 | of vcpus per virtual core (vcore). The vcore id is obtained by |
| 220 | dividing the vcpu id by the number of vcpus per vcore. The vcpus in a |
| 221 | given vcore will always be in the same physical core as each other |
| 222 | (though that might be a different physical core from time to time). |
| 223 | Userspace can control the threading (SMT) mode of the guest by its |
| 224 | allocation of vcpu ids. For example, if userspace wants |
| 225 | single-threaded guest vcpus, it should make all vcpu ids be a multiple |
| 226 | of the number of vcpus per vcore. |
| 227 | |
Carsten Otte | 5b1c149 | 2012-01-04 10:25:23 +0100 | [diff] [blame] | 228 | For virtual cpus that have been created with S390 user controlled virtual |
| 229 | machines, the resulting vcpu fd can be memory mapped at page offset |
| 230 | KVM_S390_SIE_PAGE_OFFSET in order to obtain a memory map of the virtual |
| 231 | cpu's hardware control block. |
| 232 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 233 | |
Paul Bolle | 68ba697 | 2011-02-15 00:05:59 +0100 | [diff] [blame] | 234 | 4.8 KVM_GET_DIRTY_LOG (vm ioctl) |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 235 | |
| 236 | Capability: basic |
| 237 | Architectures: x86 |
| 238 | Type: vm ioctl |
| 239 | Parameters: struct kvm_dirty_log (in/out) |
| 240 | Returns: 0 on success, -1 on error |
| 241 | |
| 242 | /* for KVM_GET_DIRTY_LOG */ |
| 243 | struct kvm_dirty_log { |
| 244 | __u32 slot; |
| 245 | __u32 padding; |
| 246 | union { |
| 247 | void __user *dirty_bitmap; /* one bit per page */ |
| 248 | __u64 padding; |
| 249 | }; |
| 250 | }; |
| 251 | |
| 252 | Given a memory slot, return a bitmap containing any pages dirtied |
| 253 | since the last call to this ioctl. Bit 0 is the first page in the |
| 254 | memory slot. Ensure the entire structure is cleared to avoid padding |
| 255 | issues. |
| 256 | |
Paolo Bonzini | f481b06 | 2015-05-17 17:30:37 +0200 | [diff] [blame] | 257 | If KVM_CAP_MULTI_ADDRESS_SPACE is available, bits 16-31 specifies |
| 258 | the address space for which you want to return the dirty bitmap. |
| 259 | They must be less than the value that KVM_CHECK_EXTENSION returns for |
| 260 | the KVM_CAP_MULTI_ADDRESS_SPACE capability. |
| 261 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 262 | |
Paul Bolle | 68ba697 | 2011-02-15 00:05:59 +0100 | [diff] [blame] | 263 | 4.9 KVM_SET_MEMORY_ALIAS |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 264 | |
| 265 | Capability: basic |
| 266 | Architectures: x86 |
| 267 | Type: vm ioctl |
| 268 | Parameters: struct kvm_memory_alias (in) |
| 269 | Returns: 0 (success), -1 (error) |
| 270 | |
Avi Kivity | a1f4d395 | 2010-06-21 11:44:20 +0300 | [diff] [blame] | 271 | This ioctl is obsolete and has been removed. |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 272 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 273 | |
Paul Bolle | 68ba697 | 2011-02-15 00:05:59 +0100 | [diff] [blame] | 274 | 4.10 KVM_RUN |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 275 | |
| 276 | Capability: basic |
| 277 | Architectures: all |
| 278 | Type: vcpu ioctl |
| 279 | Parameters: none |
| 280 | Returns: 0 on success, -1 on error |
| 281 | Errors: |
| 282 | EINTR: an unmasked signal is pending |
| 283 | |
| 284 | This ioctl is used to run a guest virtual cpu. While there are no |
| 285 | explicit parameters, there is an implicit parameter block that can be |
| 286 | obtained by mmap()ing the vcpu fd at offset 0, with the size given by |
| 287 | KVM_GET_VCPU_MMAP_SIZE. The parameter block is formatted as a 'struct |
| 288 | kvm_run' (see below). |
| 289 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 290 | |
Paul Bolle | 68ba697 | 2011-02-15 00:05:59 +0100 | [diff] [blame] | 291 | 4.11 KVM_GET_REGS |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 292 | |
| 293 | Capability: basic |
Marc Zyngier | 379e04c | 2013-04-02 17:46:31 +0100 | [diff] [blame] | 294 | Architectures: all except ARM, arm64 |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 295 | Type: vcpu ioctl |
| 296 | Parameters: struct kvm_regs (out) |
| 297 | Returns: 0 on success, -1 on error |
| 298 | |
| 299 | Reads the general purpose registers from the vcpu. |
| 300 | |
| 301 | /* x86 */ |
| 302 | struct kvm_regs { |
| 303 | /* out (KVM_GET_REGS) / in (KVM_SET_REGS) */ |
| 304 | __u64 rax, rbx, rcx, rdx; |
| 305 | __u64 rsi, rdi, rsp, rbp; |
| 306 | __u64 r8, r9, r10, r11; |
| 307 | __u64 r12, r13, r14, r15; |
| 308 | __u64 rip, rflags; |
| 309 | }; |
| 310 | |
James Hogan | c2d2c21 | 2014-07-04 15:11:35 +0100 | [diff] [blame] | 311 | /* mips */ |
| 312 | struct kvm_regs { |
| 313 | /* out (KVM_GET_REGS) / in (KVM_SET_REGS) */ |
| 314 | __u64 gpr[32]; |
| 315 | __u64 hi; |
| 316 | __u64 lo; |
| 317 | __u64 pc; |
| 318 | }; |
| 319 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 320 | |
Paul Bolle | 68ba697 | 2011-02-15 00:05:59 +0100 | [diff] [blame] | 321 | 4.12 KVM_SET_REGS |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 322 | |
| 323 | Capability: basic |
Marc Zyngier | 379e04c | 2013-04-02 17:46:31 +0100 | [diff] [blame] | 324 | Architectures: all except ARM, arm64 |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 325 | Type: vcpu ioctl |
| 326 | Parameters: struct kvm_regs (in) |
| 327 | Returns: 0 on success, -1 on error |
| 328 | |
| 329 | Writes the general purpose registers into the vcpu. |
| 330 | |
| 331 | See KVM_GET_REGS for the data structure. |
| 332 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 333 | |
Paul Bolle | 68ba697 | 2011-02-15 00:05:59 +0100 | [diff] [blame] | 334 | 4.13 KVM_GET_SREGS |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 335 | |
| 336 | Capability: basic |
Scott Wood | 5ce941e | 2011-04-27 17:24:21 -0500 | [diff] [blame] | 337 | Architectures: x86, ppc |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 338 | Type: vcpu ioctl |
| 339 | Parameters: struct kvm_sregs (out) |
| 340 | Returns: 0 on success, -1 on error |
| 341 | |
| 342 | Reads special registers from the vcpu. |
| 343 | |
| 344 | /* x86 */ |
| 345 | struct kvm_sregs { |
| 346 | struct kvm_segment cs, ds, es, fs, gs, ss; |
| 347 | struct kvm_segment tr, ldt; |
| 348 | struct kvm_dtable gdt, idt; |
| 349 | __u64 cr0, cr2, cr3, cr4, cr8; |
| 350 | __u64 efer; |
| 351 | __u64 apic_base; |
| 352 | __u64 interrupt_bitmap[(KVM_NR_INTERRUPTS + 63) / 64]; |
| 353 | }; |
| 354 | |
Mihai Caraman | 68e2ffe | 2012-12-11 03:38:23 +0000 | [diff] [blame] | 355 | /* ppc -- see arch/powerpc/include/uapi/asm/kvm.h */ |
Scott Wood | 5ce941e | 2011-04-27 17:24:21 -0500 | [diff] [blame] | 356 | |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 357 | interrupt_bitmap is a bitmap of pending external interrupts. At most |
| 358 | one bit may be set. This interrupt has been acknowledged by the APIC |
| 359 | but not yet injected into the cpu core. |
| 360 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 361 | |
Paul Bolle | 68ba697 | 2011-02-15 00:05:59 +0100 | [diff] [blame] | 362 | 4.14 KVM_SET_SREGS |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 363 | |
| 364 | Capability: basic |
Scott Wood | 5ce941e | 2011-04-27 17:24:21 -0500 | [diff] [blame] | 365 | Architectures: x86, ppc |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 366 | Type: vcpu ioctl |
| 367 | Parameters: struct kvm_sregs (in) |
| 368 | Returns: 0 on success, -1 on error |
| 369 | |
| 370 | Writes special registers into the vcpu. See KVM_GET_SREGS for the |
| 371 | data structures. |
| 372 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 373 | |
Paul Bolle | 68ba697 | 2011-02-15 00:05:59 +0100 | [diff] [blame] | 374 | 4.15 KVM_TRANSLATE |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 375 | |
| 376 | Capability: basic |
| 377 | Architectures: x86 |
| 378 | Type: vcpu ioctl |
| 379 | Parameters: struct kvm_translation (in/out) |
| 380 | Returns: 0 on success, -1 on error |
| 381 | |
| 382 | Translates a virtual address according to the vcpu's current address |
| 383 | translation mode. |
| 384 | |
| 385 | struct kvm_translation { |
| 386 | /* in */ |
| 387 | __u64 linear_address; |
| 388 | |
| 389 | /* out */ |
| 390 | __u64 physical_address; |
| 391 | __u8 valid; |
| 392 | __u8 writeable; |
| 393 | __u8 usermode; |
| 394 | __u8 pad[5]; |
| 395 | }; |
| 396 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 397 | |
Paul Bolle | 68ba697 | 2011-02-15 00:05:59 +0100 | [diff] [blame] | 398 | 4.16 KVM_INTERRUPT |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 399 | |
| 400 | Capability: basic |
James Hogan | c2d2c21 | 2014-07-04 15:11:35 +0100 | [diff] [blame] | 401 | Architectures: x86, ppc, mips |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 402 | Type: vcpu ioctl |
| 403 | Parameters: struct kvm_interrupt (in) |
Steve Rutherford | 1c1a9ce | 2015-07-30 11:27:16 +0200 | [diff] [blame] | 404 | Returns: 0 on success, negative on failure. |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 405 | |
Steve Rutherford | 1c1a9ce | 2015-07-30 11:27:16 +0200 | [diff] [blame] | 406 | Queues a hardware interrupt vector to be injected. |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 407 | |
| 408 | /* for KVM_INTERRUPT */ |
| 409 | struct kvm_interrupt { |
| 410 | /* in */ |
| 411 | __u32 irq; |
| 412 | }; |
| 413 | |
Alexander Graf | 6f7a2bd | 2010-08-31 02:03:32 +0200 | [diff] [blame] | 414 | X86: |
| 415 | |
Steve Rutherford | 1c1a9ce | 2015-07-30 11:27:16 +0200 | [diff] [blame] | 416 | Returns: 0 on success, |
| 417 | -EEXIST if an interrupt is already enqueued |
| 418 | -EINVAL the the irq number is invalid |
| 419 | -ENXIO if the PIC is in the kernel |
| 420 | -EFAULT if the pointer is invalid |
| 421 | |
| 422 | Note 'irq' is an interrupt vector, not an interrupt pin or line. This |
| 423 | ioctl is useful if the in-kernel PIC is not used. |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 424 | |
Alexander Graf | 6f7a2bd | 2010-08-31 02:03:32 +0200 | [diff] [blame] | 425 | PPC: |
| 426 | |
| 427 | Queues an external interrupt to be injected. This ioctl is overleaded |
| 428 | with 3 different irq values: |
| 429 | |
| 430 | a) KVM_INTERRUPT_SET |
| 431 | |
| 432 | This injects an edge type external interrupt into the guest once it's ready |
| 433 | to receive interrupts. When injected, the interrupt is done. |
| 434 | |
| 435 | b) KVM_INTERRUPT_UNSET |
| 436 | |
| 437 | This unsets any pending interrupt. |
| 438 | |
| 439 | Only available with KVM_CAP_PPC_UNSET_IRQ. |
| 440 | |
| 441 | c) KVM_INTERRUPT_SET_LEVEL |
| 442 | |
| 443 | This injects a level type external interrupt into the guest context. The |
| 444 | interrupt stays pending until a specific ioctl with KVM_INTERRUPT_UNSET |
| 445 | is triggered. |
| 446 | |
| 447 | Only available with KVM_CAP_PPC_IRQ_LEVEL. |
| 448 | |
| 449 | Note that any value for 'irq' other than the ones stated above is invalid |
| 450 | and incurs unexpected behavior. |
| 451 | |
James Hogan | c2d2c21 | 2014-07-04 15:11:35 +0100 | [diff] [blame] | 452 | MIPS: |
| 453 | |
| 454 | Queues an external interrupt to be injected into the virtual CPU. A negative |
| 455 | interrupt number dequeues the interrupt. |
| 456 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 457 | |
Paul Bolle | 68ba697 | 2011-02-15 00:05:59 +0100 | [diff] [blame] | 458 | 4.17 KVM_DEBUG_GUEST |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 459 | |
| 460 | Capability: basic |
| 461 | Architectures: none |
| 462 | Type: vcpu ioctl |
| 463 | Parameters: none) |
| 464 | Returns: -1 on error |
| 465 | |
| 466 | Support for this has been removed. Use KVM_SET_GUEST_DEBUG instead. |
| 467 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 468 | |
Paul Bolle | 68ba697 | 2011-02-15 00:05:59 +0100 | [diff] [blame] | 469 | 4.18 KVM_GET_MSRS |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 470 | |
| 471 | Capability: basic |
| 472 | Architectures: x86 |
| 473 | Type: vcpu ioctl |
| 474 | Parameters: struct kvm_msrs (in/out) |
| 475 | Returns: 0 on success, -1 on error |
| 476 | |
| 477 | Reads model-specific registers from the vcpu. Supported msr indices can |
| 478 | be obtained using KVM_GET_MSR_INDEX_LIST. |
| 479 | |
| 480 | struct kvm_msrs { |
| 481 | __u32 nmsrs; /* number of msrs in entries */ |
| 482 | __u32 pad; |
| 483 | |
| 484 | struct kvm_msr_entry entries[0]; |
| 485 | }; |
| 486 | |
| 487 | struct kvm_msr_entry { |
| 488 | __u32 index; |
| 489 | __u32 reserved; |
| 490 | __u64 data; |
| 491 | }; |
| 492 | |
| 493 | Application code should set the 'nmsrs' member (which indicates the |
| 494 | size of the entries array) and the 'index' member of each array entry. |
| 495 | kvm will fill in the 'data' member. |
| 496 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 497 | |
Paul Bolle | 68ba697 | 2011-02-15 00:05:59 +0100 | [diff] [blame] | 498 | 4.19 KVM_SET_MSRS |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 499 | |
| 500 | Capability: basic |
| 501 | Architectures: x86 |
| 502 | Type: vcpu ioctl |
| 503 | Parameters: struct kvm_msrs (in) |
| 504 | Returns: 0 on success, -1 on error |
| 505 | |
| 506 | Writes model-specific registers to the vcpu. See KVM_GET_MSRS for the |
| 507 | data structures. |
| 508 | |
| 509 | Application code should set the 'nmsrs' member (which indicates the |
| 510 | size of the entries array), and the 'index' and 'data' members of each |
| 511 | array entry. |
| 512 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 513 | |
Paul Bolle | 68ba697 | 2011-02-15 00:05:59 +0100 | [diff] [blame] | 514 | 4.20 KVM_SET_CPUID |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 515 | |
| 516 | Capability: basic |
| 517 | Architectures: x86 |
| 518 | Type: vcpu ioctl |
| 519 | Parameters: struct kvm_cpuid (in) |
| 520 | Returns: 0 on success, -1 on error |
| 521 | |
| 522 | Defines the vcpu responses to the cpuid instruction. Applications |
| 523 | should use the KVM_SET_CPUID2 ioctl if available. |
| 524 | |
| 525 | |
| 526 | struct kvm_cpuid_entry { |
| 527 | __u32 function; |
| 528 | __u32 eax; |
| 529 | __u32 ebx; |
| 530 | __u32 ecx; |
| 531 | __u32 edx; |
| 532 | __u32 padding; |
| 533 | }; |
| 534 | |
| 535 | /* for KVM_SET_CPUID */ |
| 536 | struct kvm_cpuid { |
| 537 | __u32 nent; |
| 538 | __u32 padding; |
| 539 | struct kvm_cpuid_entry entries[0]; |
| 540 | }; |
| 541 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 542 | |
Paul Bolle | 68ba697 | 2011-02-15 00:05:59 +0100 | [diff] [blame] | 543 | 4.21 KVM_SET_SIGNAL_MASK |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 544 | |
| 545 | Capability: basic |
James Hogan | 572e092 | 2014-07-04 15:11:33 +0100 | [diff] [blame] | 546 | Architectures: all |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 547 | Type: vcpu ioctl |
| 548 | Parameters: struct kvm_signal_mask (in) |
| 549 | Returns: 0 on success, -1 on error |
| 550 | |
| 551 | Defines which signals are blocked during execution of KVM_RUN. This |
| 552 | signal mask temporarily overrides the threads signal mask. Any |
| 553 | unblocked signal received (except SIGKILL and SIGSTOP, which retain |
| 554 | their traditional behaviour) will cause KVM_RUN to return with -EINTR. |
| 555 | |
| 556 | Note the signal will only be delivered if not blocked by the original |
| 557 | signal mask. |
| 558 | |
| 559 | /* for KVM_SET_SIGNAL_MASK */ |
| 560 | struct kvm_signal_mask { |
| 561 | __u32 len; |
| 562 | __u8 sigset[0]; |
| 563 | }; |
| 564 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 565 | |
Paul Bolle | 68ba697 | 2011-02-15 00:05:59 +0100 | [diff] [blame] | 566 | 4.22 KVM_GET_FPU |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 567 | |
| 568 | Capability: basic |
| 569 | Architectures: x86 |
| 570 | Type: vcpu ioctl |
| 571 | Parameters: struct kvm_fpu (out) |
| 572 | Returns: 0 on success, -1 on error |
| 573 | |
| 574 | Reads the floating point state from the vcpu. |
| 575 | |
| 576 | /* for KVM_GET_FPU and KVM_SET_FPU */ |
| 577 | struct kvm_fpu { |
| 578 | __u8 fpr[8][16]; |
| 579 | __u16 fcw; |
| 580 | __u16 fsw; |
| 581 | __u8 ftwx; /* in fxsave format */ |
| 582 | __u8 pad1; |
| 583 | __u16 last_opcode; |
| 584 | __u64 last_ip; |
| 585 | __u64 last_dp; |
| 586 | __u8 xmm[16][16]; |
| 587 | __u32 mxcsr; |
| 588 | __u32 pad2; |
| 589 | }; |
| 590 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 591 | |
Paul Bolle | 68ba697 | 2011-02-15 00:05:59 +0100 | [diff] [blame] | 592 | 4.23 KVM_SET_FPU |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 593 | |
| 594 | Capability: basic |
| 595 | Architectures: x86 |
| 596 | Type: vcpu ioctl |
| 597 | Parameters: struct kvm_fpu (in) |
| 598 | Returns: 0 on success, -1 on error |
| 599 | |
| 600 | Writes the floating point state to the vcpu. |
| 601 | |
| 602 | /* for KVM_GET_FPU and KVM_SET_FPU */ |
| 603 | struct kvm_fpu { |
| 604 | __u8 fpr[8][16]; |
| 605 | __u16 fcw; |
| 606 | __u16 fsw; |
| 607 | __u8 ftwx; /* in fxsave format */ |
| 608 | __u8 pad1; |
| 609 | __u16 last_opcode; |
| 610 | __u64 last_ip; |
| 611 | __u64 last_dp; |
| 612 | __u8 xmm[16][16]; |
| 613 | __u32 mxcsr; |
| 614 | __u32 pad2; |
| 615 | }; |
| 616 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 617 | |
Paul Bolle | 68ba697 | 2011-02-15 00:05:59 +0100 | [diff] [blame] | 618 | 4.24 KVM_CREATE_IRQCHIP |
Avi Kivity | 5dadbfd | 2009-08-23 17:08:04 +0300 | [diff] [blame] | 619 | |
Cornelia Huck | 8422359 | 2013-07-15 13:36:01 +0200 | [diff] [blame] | 620 | Capability: KVM_CAP_IRQCHIP, KVM_CAP_S390_IRQCHIP (s390) |
Tiejun Chen | c32a427 | 2014-11-20 11:07:18 +0100 | [diff] [blame] | 621 | Architectures: x86, ARM, arm64, s390 |
Avi Kivity | 5dadbfd | 2009-08-23 17:08:04 +0300 | [diff] [blame] | 622 | Type: vm ioctl |
| 623 | Parameters: none |
| 624 | Returns: 0 on success, -1 on error |
| 625 | |
Andre Przywara | ac3d373 | 2014-06-03 10:26:30 +0200 | [diff] [blame] | 626 | Creates an interrupt controller model in the kernel. |
| 627 | On x86, creates a virtual ioapic, a virtual PIC (two PICs, nested), and sets up |
| 628 | future vcpus to have a local APIC. IRQ routing for GSIs 0-15 is set to both |
| 629 | PIC and IOAPIC; GSI 16-23 only go to the IOAPIC. |
| 630 | On ARM/arm64, a GICv2 is created. Any other GIC versions require the usage of |
| 631 | KVM_CREATE_DEVICE, which also supports creating a GICv2. Using |
| 632 | KVM_CREATE_DEVICE is preferred over KVM_CREATE_IRQCHIP for GICv2. |
| 633 | On s390, a dummy irq routing table is created. |
Cornelia Huck | 8422359 | 2013-07-15 13:36:01 +0200 | [diff] [blame] | 634 | |
| 635 | Note that on s390 the KVM_CAP_S390_IRQCHIP vm capability needs to be enabled |
| 636 | before KVM_CREATE_IRQCHIP can be used. |
Avi Kivity | 5dadbfd | 2009-08-23 17:08:04 +0300 | [diff] [blame] | 637 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 638 | |
Paul Bolle | 68ba697 | 2011-02-15 00:05:59 +0100 | [diff] [blame] | 639 | 4.25 KVM_IRQ_LINE |
Avi Kivity | 5dadbfd | 2009-08-23 17:08:04 +0300 | [diff] [blame] | 640 | |
| 641 | Capability: KVM_CAP_IRQCHIP |
Tiejun Chen | c32a427 | 2014-11-20 11:07:18 +0100 | [diff] [blame] | 642 | Architectures: x86, arm, arm64 |
Avi Kivity | 5dadbfd | 2009-08-23 17:08:04 +0300 | [diff] [blame] | 643 | Type: vm ioctl |
| 644 | Parameters: struct kvm_irq_level |
| 645 | Returns: 0 on success, -1 on error |
| 646 | |
| 647 | Sets the level of a GSI input to the interrupt controller model in the kernel. |
Christoffer Dall | 86ce8535 | 2013-01-20 18:28:08 -0500 | [diff] [blame] | 648 | On some architectures it is required that an interrupt controller model has |
| 649 | been previously created with KVM_CREATE_IRQCHIP. Note that edge-triggered |
| 650 | interrupts require the level to be set to 1 and then back to 0. |
| 651 | |
Gabriel L. Somlo | 100943c | 2014-02-27 23:06:17 -0500 | [diff] [blame] | 652 | On real hardware, interrupt pins can be active-low or active-high. This |
| 653 | does not matter for the level field of struct kvm_irq_level: 1 always |
| 654 | means active (asserted), 0 means inactive (deasserted). |
| 655 | |
| 656 | x86 allows the operating system to program the interrupt polarity |
| 657 | (active-low/active-high) for level-triggered interrupts, and KVM used |
| 658 | to consider the polarity. However, due to bitrot in the handling of |
| 659 | active-low interrupts, the above convention is now valid on x86 too. |
| 660 | This is signaled by KVM_CAP_X86_IOAPIC_POLARITY_IGNORED. Userspace |
| 661 | should not present interrupts to the guest as active-low unless this |
| 662 | capability is present (or unless it is not using the in-kernel irqchip, |
| 663 | of course). |
| 664 | |
| 665 | |
Marc Zyngier | 379e04c | 2013-04-02 17:46:31 +0100 | [diff] [blame] | 666 | ARM/arm64 can signal an interrupt either at the CPU level, or at the |
| 667 | in-kernel irqchip (GIC), and for in-kernel irqchip can tell the GIC to |
| 668 | use PPIs designated for specific cpus. The irq field is interpreted |
| 669 | like this: |
Christoffer Dall | 86ce8535 | 2013-01-20 18:28:08 -0500 | [diff] [blame] | 670 | |
| 671 | Â bits: | 31 ... 24 | 23 ... 16 | 15 ... 0 | |
| 672 | field: | irq_type | vcpu_index | irq_id | |
| 673 | |
| 674 | The irq_type field has the following values: |
| 675 | - irq_type[0]: out-of-kernel GIC: irq_id 0 is IRQ, irq_id 1 is FIQ |
| 676 | - irq_type[1]: in-kernel GIC: SPI, irq_id between 32 and 1019 (incl.) |
| 677 | (the vcpu_index field is ignored) |
| 678 | - irq_type[2]: in-kernel GIC: PPI, irq_id between 16 and 31 (incl.) |
| 679 | |
| 680 | (The irq_id field thus corresponds nicely to the IRQ ID in the ARM GIC specs) |
| 681 | |
Gabriel L. Somlo | 100943c | 2014-02-27 23:06:17 -0500 | [diff] [blame] | 682 | In both cases, level is used to assert/deassert the line. |
Avi Kivity | 5dadbfd | 2009-08-23 17:08:04 +0300 | [diff] [blame] | 683 | |
| 684 | struct kvm_irq_level { |
| 685 | union { |
| 686 | __u32 irq; /* GSI */ |
| 687 | __s32 status; /* not used for KVM_IRQ_LEVEL */ |
| 688 | }; |
| 689 | __u32 level; /* 0 or 1 */ |
| 690 | }; |
| 691 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 692 | |
Paul Bolle | 68ba697 | 2011-02-15 00:05:59 +0100 | [diff] [blame] | 693 | 4.26 KVM_GET_IRQCHIP |
Avi Kivity | 5dadbfd | 2009-08-23 17:08:04 +0300 | [diff] [blame] | 694 | |
| 695 | Capability: KVM_CAP_IRQCHIP |
Tiejun Chen | c32a427 | 2014-11-20 11:07:18 +0100 | [diff] [blame] | 696 | Architectures: x86 |
Avi Kivity | 5dadbfd | 2009-08-23 17:08:04 +0300 | [diff] [blame] | 697 | Type: vm ioctl |
| 698 | Parameters: struct kvm_irqchip (in/out) |
| 699 | Returns: 0 on success, -1 on error |
| 700 | |
| 701 | Reads the state of a kernel interrupt controller created with |
| 702 | KVM_CREATE_IRQCHIP into a buffer provided by the caller. |
| 703 | |
| 704 | struct kvm_irqchip { |
| 705 | __u32 chip_id; /* 0 = PIC1, 1 = PIC2, 2 = IOAPIC */ |
| 706 | __u32 pad; |
| 707 | union { |
| 708 | char dummy[512]; /* reserving space */ |
| 709 | struct kvm_pic_state pic; |
| 710 | struct kvm_ioapic_state ioapic; |
| 711 | } chip; |
| 712 | }; |
| 713 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 714 | |
Paul Bolle | 68ba697 | 2011-02-15 00:05:59 +0100 | [diff] [blame] | 715 | 4.27 KVM_SET_IRQCHIP |
Avi Kivity | 5dadbfd | 2009-08-23 17:08:04 +0300 | [diff] [blame] | 716 | |
| 717 | Capability: KVM_CAP_IRQCHIP |
Tiejun Chen | c32a427 | 2014-11-20 11:07:18 +0100 | [diff] [blame] | 718 | Architectures: x86 |
Avi Kivity | 5dadbfd | 2009-08-23 17:08:04 +0300 | [diff] [blame] | 719 | Type: vm ioctl |
| 720 | Parameters: struct kvm_irqchip (in) |
| 721 | Returns: 0 on success, -1 on error |
| 722 | |
| 723 | Sets the state of a kernel interrupt controller created with |
| 724 | KVM_CREATE_IRQCHIP from a buffer provided by the caller. |
| 725 | |
| 726 | struct kvm_irqchip { |
| 727 | __u32 chip_id; /* 0 = PIC1, 1 = PIC2, 2 = IOAPIC */ |
| 728 | __u32 pad; |
| 729 | union { |
| 730 | char dummy[512]; /* reserving space */ |
| 731 | struct kvm_pic_state pic; |
| 732 | struct kvm_ioapic_state ioapic; |
| 733 | } chip; |
| 734 | }; |
| 735 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 736 | |
Paul Bolle | 68ba697 | 2011-02-15 00:05:59 +0100 | [diff] [blame] | 737 | 4.28 KVM_XEN_HVM_CONFIG |
Ed Swierk | ffde22a | 2009-10-15 15:21:43 -0700 | [diff] [blame] | 738 | |
| 739 | Capability: KVM_CAP_XEN_HVM |
| 740 | Architectures: x86 |
| 741 | Type: vm ioctl |
| 742 | Parameters: struct kvm_xen_hvm_config (in) |
| 743 | Returns: 0 on success, -1 on error |
| 744 | |
| 745 | Sets the MSR that the Xen HVM guest uses to initialize its hypercall |
| 746 | page, and provides the starting address and size of the hypercall |
| 747 | blobs in userspace. When the guest writes the MSR, kvm copies one |
| 748 | page of a blob (32- or 64-bit, depending on the vcpu mode) to guest |
| 749 | memory. |
| 750 | |
| 751 | struct kvm_xen_hvm_config { |
| 752 | __u32 flags; |
| 753 | __u32 msr; |
| 754 | __u64 blob_addr_32; |
| 755 | __u64 blob_addr_64; |
| 756 | __u8 blob_size_32; |
| 757 | __u8 blob_size_64; |
| 758 | __u8 pad2[30]; |
| 759 | }; |
| 760 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 761 | |
Paul Bolle | 68ba697 | 2011-02-15 00:05:59 +0100 | [diff] [blame] | 762 | 4.29 KVM_GET_CLOCK |
Glauber Costa | afbcf7a | 2009-10-16 15:28:36 -0400 | [diff] [blame] | 763 | |
| 764 | Capability: KVM_CAP_ADJUST_CLOCK |
| 765 | Architectures: x86 |
| 766 | Type: vm ioctl |
| 767 | Parameters: struct kvm_clock_data (out) |
| 768 | Returns: 0 on success, -1 on error |
| 769 | |
| 770 | Gets the current timestamp of kvmclock as seen by the current guest. In |
| 771 | conjunction with KVM_SET_CLOCK, it is used to ensure monotonicity on scenarios |
| 772 | such as migration. |
| 773 | |
| 774 | struct kvm_clock_data { |
| 775 | __u64 clock; /* kvmclock current value */ |
| 776 | __u32 flags; |
| 777 | __u32 pad[9]; |
| 778 | }; |
| 779 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 780 | |
Paul Bolle | 68ba697 | 2011-02-15 00:05:59 +0100 | [diff] [blame] | 781 | 4.30 KVM_SET_CLOCK |
Glauber Costa | afbcf7a | 2009-10-16 15:28:36 -0400 | [diff] [blame] | 782 | |
| 783 | Capability: KVM_CAP_ADJUST_CLOCK |
| 784 | Architectures: x86 |
| 785 | Type: vm ioctl |
| 786 | Parameters: struct kvm_clock_data (in) |
| 787 | Returns: 0 on success, -1 on error |
| 788 | |
Wu Fengguang | 2044892d | 2009-12-24 09:04:16 +0800 | [diff] [blame] | 789 | 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] | 790 | In conjunction with KVM_GET_CLOCK, it is used to ensure monotonicity on scenarios |
| 791 | such as migration. |
| 792 | |
| 793 | struct kvm_clock_data { |
| 794 | __u64 clock; /* kvmclock current value */ |
| 795 | __u32 flags; |
| 796 | __u32 pad[9]; |
| 797 | }; |
| 798 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 799 | |
Paul Bolle | 68ba697 | 2011-02-15 00:05:59 +0100 | [diff] [blame] | 800 | 4.31 KVM_GET_VCPU_EVENTS |
Jan Kiszka | 3cfc309 | 2009-11-12 01:04:25 +0100 | [diff] [blame] | 801 | |
| 802 | Capability: KVM_CAP_VCPU_EVENTS |
Jan Kiszka | 48005f6 | 2010-02-19 19:38:07 +0100 | [diff] [blame] | 803 | Extended by: KVM_CAP_INTR_SHADOW |
Jan Kiszka | 3cfc309 | 2009-11-12 01:04:25 +0100 | [diff] [blame] | 804 | Architectures: x86 |
| 805 | Type: vm ioctl |
| 806 | Parameters: struct kvm_vcpu_event (out) |
| 807 | Returns: 0 on success, -1 on error |
| 808 | |
| 809 | Gets currently pending exceptions, interrupts, and NMIs as well as related |
| 810 | states of the vcpu. |
| 811 | |
| 812 | struct kvm_vcpu_events { |
| 813 | struct { |
| 814 | __u8 injected; |
| 815 | __u8 nr; |
| 816 | __u8 has_error_code; |
| 817 | __u8 pad; |
| 818 | __u32 error_code; |
| 819 | } exception; |
| 820 | struct { |
| 821 | __u8 injected; |
| 822 | __u8 nr; |
| 823 | __u8 soft; |
Jan Kiszka | 48005f6 | 2010-02-19 19:38:07 +0100 | [diff] [blame] | 824 | __u8 shadow; |
Jan Kiszka | 3cfc309 | 2009-11-12 01:04:25 +0100 | [diff] [blame] | 825 | } interrupt; |
| 826 | struct { |
| 827 | __u8 injected; |
| 828 | __u8 pending; |
| 829 | __u8 masked; |
| 830 | __u8 pad; |
| 831 | } nmi; |
| 832 | __u32 sipi_vector; |
Jan Kiszka | dab4b91 | 2009-12-06 18:24:15 +0100 | [diff] [blame] | 833 | __u32 flags; |
Paolo Bonzini | f077825 | 2015-04-01 15:06:40 +0200 | [diff] [blame] | 834 | struct { |
| 835 | __u8 smm; |
| 836 | __u8 pending; |
| 837 | __u8 smm_inside_nmi; |
| 838 | __u8 latched_init; |
| 839 | } smi; |
Jan Kiszka | 3cfc309 | 2009-11-12 01:04:25 +0100 | [diff] [blame] | 840 | }; |
| 841 | |
Paolo Bonzini | f077825 | 2015-04-01 15:06:40 +0200 | [diff] [blame] | 842 | Only two fields are defined in the flags field: |
Jan Kiszka | 48005f6 | 2010-02-19 19:38:07 +0100 | [diff] [blame] | 843 | |
Paolo Bonzini | f077825 | 2015-04-01 15:06:40 +0200 | [diff] [blame] | 844 | - KVM_VCPUEVENT_VALID_SHADOW may be set in the flags field to signal that |
| 845 | interrupt.shadow contains a valid state. |
| 846 | |
| 847 | - KVM_VCPUEVENT_VALID_SMM may be set in the flags field to signal that |
| 848 | smi contains a valid state. |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 849 | |
Paul Bolle | 68ba697 | 2011-02-15 00:05:59 +0100 | [diff] [blame] | 850 | 4.32 KVM_SET_VCPU_EVENTS |
Jan Kiszka | 3cfc309 | 2009-11-12 01:04:25 +0100 | [diff] [blame] | 851 | |
| 852 | Capability: KVM_CAP_VCPU_EVENTS |
Jan Kiszka | 48005f6 | 2010-02-19 19:38:07 +0100 | [diff] [blame] | 853 | Extended by: KVM_CAP_INTR_SHADOW |
Jan Kiszka | 3cfc309 | 2009-11-12 01:04:25 +0100 | [diff] [blame] | 854 | Architectures: x86 |
| 855 | Type: vm ioctl |
| 856 | Parameters: struct kvm_vcpu_event (in) |
| 857 | Returns: 0 on success, -1 on error |
| 858 | |
| 859 | Set pending exceptions, interrupts, and NMIs as well as related states of the |
| 860 | vcpu. |
| 861 | |
| 862 | See KVM_GET_VCPU_EVENTS for the data structure. |
| 863 | |
Jan Kiszka | dab4b91 | 2009-12-06 18:24:15 +0100 | [diff] [blame] | 864 | Fields that may be modified asynchronously by running VCPUs can be excluded |
Paolo Bonzini | f077825 | 2015-04-01 15:06:40 +0200 | [diff] [blame] | 865 | from the update. These fields are nmi.pending, sipi_vector, smi.smm, |
| 866 | smi.pending. Keep the corresponding bits in the flags field cleared to |
| 867 | suppress overwriting the current in-kernel state. The bits are: |
Jan Kiszka | dab4b91 | 2009-12-06 18:24:15 +0100 | [diff] [blame] | 868 | |
| 869 | KVM_VCPUEVENT_VALID_NMI_PENDING - transfer nmi.pending to the kernel |
| 870 | KVM_VCPUEVENT_VALID_SIPI_VECTOR - transfer sipi_vector |
Paolo Bonzini | f077825 | 2015-04-01 15:06:40 +0200 | [diff] [blame] | 871 | KVM_VCPUEVENT_VALID_SMM - transfer the smi sub-struct. |
Jan Kiszka | dab4b91 | 2009-12-06 18:24:15 +0100 | [diff] [blame] | 872 | |
Jan Kiszka | 48005f6 | 2010-02-19 19:38:07 +0100 | [diff] [blame] | 873 | If KVM_CAP_INTR_SHADOW is available, KVM_VCPUEVENT_VALID_SHADOW can be set in |
| 874 | the flags field to signal that interrupt.shadow contains a valid state and |
| 875 | shall be written into the VCPU. |
| 876 | |
Paolo Bonzini | f077825 | 2015-04-01 15:06:40 +0200 | [diff] [blame] | 877 | KVM_VCPUEVENT_VALID_SMM can only be set if KVM_CAP_X86_SMM is available. |
| 878 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 879 | |
Paul Bolle | 68ba697 | 2011-02-15 00:05:59 +0100 | [diff] [blame] | 880 | 4.33 KVM_GET_DEBUGREGS |
Jan Kiszka | a1efbe7 | 2010-02-15 10:45:43 +0100 | [diff] [blame] | 881 | |
| 882 | Capability: KVM_CAP_DEBUGREGS |
| 883 | Architectures: x86 |
| 884 | Type: vm ioctl |
| 885 | Parameters: struct kvm_debugregs (out) |
| 886 | Returns: 0 on success, -1 on error |
| 887 | |
| 888 | Reads debug registers from the vcpu. |
| 889 | |
| 890 | struct kvm_debugregs { |
| 891 | __u64 db[4]; |
| 892 | __u64 dr6; |
| 893 | __u64 dr7; |
| 894 | __u64 flags; |
| 895 | __u64 reserved[9]; |
| 896 | }; |
| 897 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 898 | |
Paul Bolle | 68ba697 | 2011-02-15 00:05:59 +0100 | [diff] [blame] | 899 | 4.34 KVM_SET_DEBUGREGS |
Jan Kiszka | a1efbe7 | 2010-02-15 10:45:43 +0100 | [diff] [blame] | 900 | |
| 901 | Capability: KVM_CAP_DEBUGREGS |
| 902 | Architectures: x86 |
| 903 | Type: vm ioctl |
| 904 | Parameters: struct kvm_debugregs (in) |
| 905 | Returns: 0 on success, -1 on error |
| 906 | |
| 907 | Writes debug registers into the vcpu. |
| 908 | |
| 909 | See KVM_GET_DEBUGREGS for the data structure. The flags field is unused |
| 910 | yet and must be cleared on entry. |
| 911 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 912 | |
Paul Bolle | 68ba697 | 2011-02-15 00:05:59 +0100 | [diff] [blame] | 913 | 4.35 KVM_SET_USER_MEMORY_REGION |
Avi Kivity | 0f2d8f4 | 2010-03-25 12:16:48 +0200 | [diff] [blame] | 914 | |
| 915 | Capability: KVM_CAP_USER_MEM |
| 916 | Architectures: all |
| 917 | Type: vm ioctl |
| 918 | Parameters: struct kvm_userspace_memory_region (in) |
| 919 | Returns: 0 on success, -1 on error |
| 920 | |
| 921 | struct kvm_userspace_memory_region { |
| 922 | __u32 slot; |
| 923 | __u32 flags; |
| 924 | __u64 guest_phys_addr; |
| 925 | __u64 memory_size; /* bytes */ |
| 926 | __u64 userspace_addr; /* start of the userspace allocated memory */ |
| 927 | }; |
| 928 | |
| 929 | /* for kvm_memory_region::flags */ |
Xiao Guangrong | 4d8b81a | 2012-08-21 11:02:51 +0800 | [diff] [blame] | 930 | #define KVM_MEM_LOG_DIRTY_PAGES (1UL << 0) |
| 931 | #define KVM_MEM_READONLY (1UL << 1) |
Avi Kivity | 0f2d8f4 | 2010-03-25 12:16:48 +0200 | [diff] [blame] | 932 | |
| 933 | This ioctl allows the user to create or modify a guest physical memory |
| 934 | slot. When changing an existing slot, it may be moved in the guest |
| 935 | physical memory space, or its flags may be modified. It may not be |
| 936 | resized. Slots may not overlap in guest physical address space. |
| 937 | |
Paolo Bonzini | f481b06 | 2015-05-17 17:30:37 +0200 | [diff] [blame] | 938 | If KVM_CAP_MULTI_ADDRESS_SPACE is available, bits 16-31 of "slot" |
| 939 | specifies the address space which is being modified. They must be |
| 940 | less than the value that KVM_CHECK_EXTENSION returns for the |
| 941 | KVM_CAP_MULTI_ADDRESS_SPACE capability. Slots in separate address spaces |
| 942 | are unrelated; the restriction on overlapping slots only applies within |
| 943 | each address space. |
| 944 | |
Avi Kivity | 0f2d8f4 | 2010-03-25 12:16:48 +0200 | [diff] [blame] | 945 | Memory for the region is taken starting at the address denoted by the |
| 946 | field userspace_addr, which must point at user addressable memory for |
| 947 | the entire memory slot size. Any object may back this memory, including |
| 948 | anonymous memory, ordinary files, and hugetlbfs. |
| 949 | |
| 950 | It is recommended that the lower 21 bits of guest_phys_addr and userspace_addr |
| 951 | be identical. This allows large pages in the guest to be backed by large |
| 952 | pages in the host. |
| 953 | |
Takuya Yoshikawa | 75d61fb | 2013-01-30 19:40:41 +0900 | [diff] [blame] | 954 | The flags field supports two flags: KVM_MEM_LOG_DIRTY_PAGES and |
| 955 | KVM_MEM_READONLY. The former can be set to instruct KVM to keep track of |
| 956 | writes to memory within the slot. See KVM_GET_DIRTY_LOG ioctl to know how to |
| 957 | use it. The latter can be set, if KVM_CAP_READONLY_MEM capability allows it, |
| 958 | to make a new slot read-only. In this case, writes to this memory will be |
| 959 | posted to userspace as KVM_EXIT_MMIO exits. |
Avi Kivity | 0f2d8f4 | 2010-03-25 12:16:48 +0200 | [diff] [blame] | 960 | |
Jan Kiszka | 7efd8fa | 2012-09-07 13:17:47 +0200 | [diff] [blame] | 961 | When the KVM_CAP_SYNC_MMU capability is available, changes in the backing of |
| 962 | the memory region are automatically reflected into the guest. For example, an |
| 963 | mmap() that affects the region will be made visible immediately. Another |
| 964 | example is madvise(MADV_DROP). |
Avi Kivity | 0f2d8f4 | 2010-03-25 12:16:48 +0200 | [diff] [blame] | 965 | |
| 966 | It is recommended to use this API instead of the KVM_SET_MEMORY_REGION ioctl. |
| 967 | The KVM_SET_MEMORY_REGION does not allow fine grained control over memory |
| 968 | allocation and is deprecated. |
Jan Kiszka | 3cfc309 | 2009-11-12 01:04:25 +0100 | [diff] [blame] | 969 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 970 | |
Paul Bolle | 68ba697 | 2011-02-15 00:05:59 +0100 | [diff] [blame] | 971 | 4.36 KVM_SET_TSS_ADDR |
Avi Kivity | 8a5416d | 2010-03-25 12:27:30 +0200 | [diff] [blame] | 972 | |
| 973 | Capability: KVM_CAP_SET_TSS_ADDR |
| 974 | Architectures: x86 |
| 975 | Type: vm ioctl |
| 976 | Parameters: unsigned long tss_address (in) |
| 977 | Returns: 0 on success, -1 on error |
| 978 | |
| 979 | This ioctl defines the physical address of a three-page region in the guest |
| 980 | physical address space. The region must be within the first 4GB of the |
| 981 | guest physical address space and must not conflict with any memory slot |
| 982 | or any mmio address. The guest may malfunction if it accesses this memory |
| 983 | region. |
| 984 | |
| 985 | This ioctl is required on Intel-based hosts. This is needed on Intel hardware |
| 986 | because of a quirk in the virtualization implementation (see the internals |
| 987 | documentation when it pops into existence). |
| 988 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 989 | |
Paul Bolle | 68ba697 | 2011-02-15 00:05:59 +0100 | [diff] [blame] | 990 | 4.37 KVM_ENABLE_CAP |
Alexander Graf | 71fbfd5 | 2010-03-24 21:48:29 +0100 | [diff] [blame] | 991 | |
Cornelia Huck | d938dc5 | 2013-10-23 18:26:34 +0200 | [diff] [blame] | 992 | Capability: KVM_CAP_ENABLE_CAP, KVM_CAP_ENABLE_CAP_VM |
Nadav Amit | 90de4a1 | 2015-04-13 01:53:41 +0300 | [diff] [blame] | 993 | Architectures: x86 (only KVM_CAP_ENABLE_CAP_VM), |
| 994 | mips (only KVM_CAP_ENABLE_CAP), ppc, s390 |
Cornelia Huck | d938dc5 | 2013-10-23 18:26:34 +0200 | [diff] [blame] | 995 | Type: vcpu ioctl, vm ioctl (with KVM_CAP_ENABLE_CAP_VM) |
Alexander Graf | 71fbfd5 | 2010-03-24 21:48:29 +0100 | [diff] [blame] | 996 | Parameters: struct kvm_enable_cap (in) |
| 997 | Returns: 0 on success; -1 on error |
| 998 | |
| 999 | +Not all extensions are enabled by default. Using this ioctl the application |
| 1000 | can enable an extension, making it available to the guest. |
| 1001 | |
| 1002 | On systems that do not support this ioctl, it always fails. On systems that |
| 1003 | do support it, it only works for extensions that are supported for enablement. |
| 1004 | |
| 1005 | To check if a capability can be enabled, the KVM_CHECK_EXTENSION ioctl should |
| 1006 | be used. |
| 1007 | |
| 1008 | struct kvm_enable_cap { |
| 1009 | /* in */ |
| 1010 | __u32 cap; |
| 1011 | |
| 1012 | The capability that is supposed to get enabled. |
| 1013 | |
| 1014 | __u32 flags; |
| 1015 | |
| 1016 | A bitfield indicating future enhancements. Has to be 0 for now. |
| 1017 | |
| 1018 | __u64 args[4]; |
| 1019 | |
| 1020 | Arguments for enabling a feature. If a feature needs initial values to |
| 1021 | function properly, this is the place to put them. |
| 1022 | |
| 1023 | __u8 pad[64]; |
| 1024 | }; |
| 1025 | |
Cornelia Huck | d938dc5 | 2013-10-23 18:26:34 +0200 | [diff] [blame] | 1026 | The vcpu ioctl should be used for vcpu-specific capabilities, the vm ioctl |
| 1027 | for vm-wide capabilities. |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 1028 | |
Paul Bolle | 68ba697 | 2011-02-15 00:05:59 +0100 | [diff] [blame] | 1029 | 4.38 KVM_GET_MP_STATE |
Avi Kivity | b843f06 | 2010-04-25 15:51:46 +0300 | [diff] [blame] | 1030 | |
| 1031 | Capability: KVM_CAP_MP_STATE |
Alex Bennée | ecccf0c | 2015-03-13 17:02:52 +0000 | [diff] [blame] | 1032 | Architectures: x86, s390, arm, arm64 |
Avi Kivity | b843f06 | 2010-04-25 15:51:46 +0300 | [diff] [blame] | 1033 | Type: vcpu ioctl |
| 1034 | Parameters: struct kvm_mp_state (out) |
| 1035 | Returns: 0 on success; -1 on error |
| 1036 | |
| 1037 | struct kvm_mp_state { |
| 1038 | __u32 mp_state; |
| 1039 | }; |
| 1040 | |
| 1041 | Returns the vcpu's current "multiprocessing state" (though also valid on |
| 1042 | uniprocessor guests). |
| 1043 | |
| 1044 | Possible values are: |
| 1045 | |
Alex Bennée | ecccf0c | 2015-03-13 17:02:52 +0000 | [diff] [blame] | 1046 | - KVM_MP_STATE_RUNNABLE: the vcpu is currently running [x86,arm/arm64] |
Avi Kivity | b843f06 | 2010-04-25 15:51:46 +0300 | [diff] [blame] | 1047 | - KVM_MP_STATE_UNINITIALIZED: the vcpu is an application processor (AP) |
Tiejun Chen | c32a427 | 2014-11-20 11:07:18 +0100 | [diff] [blame] | 1048 | which has not yet received an INIT signal [x86] |
Avi Kivity | b843f06 | 2010-04-25 15:51:46 +0300 | [diff] [blame] | 1049 | - KVM_MP_STATE_INIT_RECEIVED: the vcpu has received an INIT signal, and is |
Tiejun Chen | c32a427 | 2014-11-20 11:07:18 +0100 | [diff] [blame] | 1050 | now ready for a SIPI [x86] |
Avi Kivity | b843f06 | 2010-04-25 15:51:46 +0300 | [diff] [blame] | 1051 | - KVM_MP_STATE_HALTED: the vcpu has executed a HLT instruction and |
Tiejun Chen | c32a427 | 2014-11-20 11:07:18 +0100 | [diff] [blame] | 1052 | is waiting for an interrupt [x86] |
Avi Kivity | b843f06 | 2010-04-25 15:51:46 +0300 | [diff] [blame] | 1053 | - KVM_MP_STATE_SIPI_RECEIVED: the vcpu has just received a SIPI (vector |
Tiejun Chen | c32a427 | 2014-11-20 11:07:18 +0100 | [diff] [blame] | 1054 | accessible via KVM_GET_VCPU_EVENTS) [x86] |
Alex Bennée | ecccf0c | 2015-03-13 17:02:52 +0000 | [diff] [blame] | 1055 | - KVM_MP_STATE_STOPPED: the vcpu is stopped [s390,arm/arm64] |
David Hildenbrand | 6352e4d | 2014-04-10 17:35:00 +0200 | [diff] [blame] | 1056 | - KVM_MP_STATE_CHECK_STOP: the vcpu is in a special error state [s390] |
| 1057 | - KVM_MP_STATE_OPERATING: the vcpu is operating (running or halted) |
| 1058 | [s390] |
| 1059 | - KVM_MP_STATE_LOAD: the vcpu is in a special load/startup state |
| 1060 | [s390] |
Avi Kivity | b843f06 | 2010-04-25 15:51:46 +0300 | [diff] [blame] | 1061 | |
Tiejun Chen | c32a427 | 2014-11-20 11:07:18 +0100 | [diff] [blame] | 1062 | On x86, this ioctl is only useful after KVM_CREATE_IRQCHIP. Without an |
David Hildenbrand | 0b4820d | 2014-05-12 16:05:13 +0200 | [diff] [blame] | 1063 | in-kernel irqchip, the multiprocessing state must be maintained by userspace on |
| 1064 | these architectures. |
Avi Kivity | b843f06 | 2010-04-25 15:51:46 +0300 | [diff] [blame] | 1065 | |
Alex Bennée | ecccf0c | 2015-03-13 17:02:52 +0000 | [diff] [blame] | 1066 | For arm/arm64: |
| 1067 | |
| 1068 | The only states that are valid are KVM_MP_STATE_STOPPED and |
| 1069 | KVM_MP_STATE_RUNNABLE which reflect if the vcpu is paused or not. |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 1070 | |
Paul Bolle | 68ba697 | 2011-02-15 00:05:59 +0100 | [diff] [blame] | 1071 | 4.39 KVM_SET_MP_STATE |
Avi Kivity | b843f06 | 2010-04-25 15:51:46 +0300 | [diff] [blame] | 1072 | |
| 1073 | Capability: KVM_CAP_MP_STATE |
Alex Bennée | ecccf0c | 2015-03-13 17:02:52 +0000 | [diff] [blame] | 1074 | Architectures: x86, s390, arm, arm64 |
Avi Kivity | b843f06 | 2010-04-25 15:51:46 +0300 | [diff] [blame] | 1075 | Type: vcpu ioctl |
| 1076 | Parameters: struct kvm_mp_state (in) |
| 1077 | Returns: 0 on success; -1 on error |
| 1078 | |
| 1079 | Sets the vcpu's current "multiprocessing state"; see KVM_GET_MP_STATE for |
| 1080 | arguments. |
| 1081 | |
Tiejun Chen | c32a427 | 2014-11-20 11:07:18 +0100 | [diff] [blame] | 1082 | On x86, this ioctl is only useful after KVM_CREATE_IRQCHIP. Without an |
David Hildenbrand | 0b4820d | 2014-05-12 16:05:13 +0200 | [diff] [blame] | 1083 | in-kernel irqchip, the multiprocessing state must be maintained by userspace on |
| 1084 | these architectures. |
Avi Kivity | b843f06 | 2010-04-25 15:51:46 +0300 | [diff] [blame] | 1085 | |
Alex Bennée | ecccf0c | 2015-03-13 17:02:52 +0000 | [diff] [blame] | 1086 | For arm/arm64: |
| 1087 | |
| 1088 | The only states that are valid are KVM_MP_STATE_STOPPED and |
| 1089 | KVM_MP_STATE_RUNNABLE which reflect if the vcpu should be paused or not. |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 1090 | |
Paul Bolle | 68ba697 | 2011-02-15 00:05:59 +0100 | [diff] [blame] | 1091 | 4.40 KVM_SET_IDENTITY_MAP_ADDR |
Avi Kivity | 47dbb84 | 2010-04-29 12:08:56 +0300 | [diff] [blame] | 1092 | |
| 1093 | Capability: KVM_CAP_SET_IDENTITY_MAP_ADDR |
| 1094 | Architectures: x86 |
| 1095 | Type: vm ioctl |
| 1096 | Parameters: unsigned long identity (in) |
| 1097 | Returns: 0 on success, -1 on error |
| 1098 | |
| 1099 | This ioctl defines the physical address of a one-page region in the guest |
| 1100 | physical address space. The region must be within the first 4GB of the |
| 1101 | guest physical address space and must not conflict with any memory slot |
| 1102 | or any mmio address. The guest may malfunction if it accesses this memory |
| 1103 | region. |
| 1104 | |
| 1105 | This ioctl is required on Intel-based hosts. This is needed on Intel hardware |
| 1106 | because of a quirk in the virtualization implementation (see the internals |
| 1107 | documentation when it pops into existence). |
| 1108 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 1109 | |
Paul Bolle | 68ba697 | 2011-02-15 00:05:59 +0100 | [diff] [blame] | 1110 | 4.41 KVM_SET_BOOT_CPU_ID |
Avi Kivity | 57bc24c | 2010-04-29 12:12:57 +0300 | [diff] [blame] | 1111 | |
| 1112 | Capability: KVM_CAP_SET_BOOT_CPU_ID |
Tiejun Chen | c32a427 | 2014-11-20 11:07:18 +0100 | [diff] [blame] | 1113 | Architectures: x86 |
Avi Kivity | 57bc24c | 2010-04-29 12:12:57 +0300 | [diff] [blame] | 1114 | Type: vm ioctl |
| 1115 | Parameters: unsigned long vcpu_id |
| 1116 | Returns: 0 on success, -1 on error |
| 1117 | |
| 1118 | Define which vcpu is the Bootstrap Processor (BSP). Values are the same |
| 1119 | as the vcpu id in KVM_CREATE_VCPU. If this ioctl is not called, the default |
| 1120 | is vcpu 0. |
| 1121 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 1122 | |
Paul Bolle | 68ba697 | 2011-02-15 00:05:59 +0100 | [diff] [blame] | 1123 | 4.42 KVM_GET_XSAVE |
Sheng Yang | 2d5b5a6 | 2010-06-13 17:29:39 +0800 | [diff] [blame] | 1124 | |
| 1125 | Capability: KVM_CAP_XSAVE |
| 1126 | Architectures: x86 |
| 1127 | Type: vcpu ioctl |
| 1128 | Parameters: struct kvm_xsave (out) |
| 1129 | Returns: 0 on success, -1 on error |
| 1130 | |
| 1131 | struct kvm_xsave { |
| 1132 | __u32 region[1024]; |
| 1133 | }; |
| 1134 | |
| 1135 | This ioctl would copy current vcpu's xsave struct to the userspace. |
| 1136 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 1137 | |
Paul Bolle | 68ba697 | 2011-02-15 00:05:59 +0100 | [diff] [blame] | 1138 | 4.43 KVM_SET_XSAVE |
Sheng Yang | 2d5b5a6 | 2010-06-13 17:29:39 +0800 | [diff] [blame] | 1139 | |
| 1140 | Capability: KVM_CAP_XSAVE |
| 1141 | Architectures: x86 |
| 1142 | Type: vcpu ioctl |
| 1143 | Parameters: struct kvm_xsave (in) |
| 1144 | Returns: 0 on success, -1 on error |
| 1145 | |
| 1146 | struct kvm_xsave { |
| 1147 | __u32 region[1024]; |
| 1148 | }; |
| 1149 | |
| 1150 | This ioctl would copy userspace's xsave struct to the kernel. |
| 1151 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 1152 | |
Paul Bolle | 68ba697 | 2011-02-15 00:05:59 +0100 | [diff] [blame] | 1153 | 4.44 KVM_GET_XCRS |
Sheng Yang | 2d5b5a6 | 2010-06-13 17:29:39 +0800 | [diff] [blame] | 1154 | |
| 1155 | Capability: KVM_CAP_XCRS |
| 1156 | Architectures: x86 |
| 1157 | Type: vcpu ioctl |
| 1158 | Parameters: struct kvm_xcrs (out) |
| 1159 | Returns: 0 on success, -1 on error |
| 1160 | |
| 1161 | struct kvm_xcr { |
| 1162 | __u32 xcr; |
| 1163 | __u32 reserved; |
| 1164 | __u64 value; |
| 1165 | }; |
| 1166 | |
| 1167 | struct kvm_xcrs { |
| 1168 | __u32 nr_xcrs; |
| 1169 | __u32 flags; |
| 1170 | struct kvm_xcr xcrs[KVM_MAX_XCRS]; |
| 1171 | __u64 padding[16]; |
| 1172 | }; |
| 1173 | |
| 1174 | This ioctl would copy current vcpu's xcrs to the userspace. |
| 1175 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 1176 | |
Paul Bolle | 68ba697 | 2011-02-15 00:05:59 +0100 | [diff] [blame] | 1177 | 4.45 KVM_SET_XCRS |
Sheng Yang | 2d5b5a6 | 2010-06-13 17:29:39 +0800 | [diff] [blame] | 1178 | |
| 1179 | Capability: KVM_CAP_XCRS |
| 1180 | Architectures: x86 |
| 1181 | Type: vcpu ioctl |
| 1182 | Parameters: struct kvm_xcrs (in) |
| 1183 | Returns: 0 on success, -1 on error |
| 1184 | |
| 1185 | struct kvm_xcr { |
| 1186 | __u32 xcr; |
| 1187 | __u32 reserved; |
| 1188 | __u64 value; |
| 1189 | }; |
| 1190 | |
| 1191 | struct kvm_xcrs { |
| 1192 | __u32 nr_xcrs; |
| 1193 | __u32 flags; |
| 1194 | struct kvm_xcr xcrs[KVM_MAX_XCRS]; |
| 1195 | __u64 padding[16]; |
| 1196 | }; |
| 1197 | |
| 1198 | This ioctl would set vcpu's xcr to the value userspace specified. |
| 1199 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 1200 | |
Paul Bolle | 68ba697 | 2011-02-15 00:05:59 +0100 | [diff] [blame] | 1201 | 4.46 KVM_GET_SUPPORTED_CPUID |
Avi Kivity | d153513 | 2010-07-14 09:45:21 +0300 | [diff] [blame] | 1202 | |
| 1203 | Capability: KVM_CAP_EXT_CPUID |
| 1204 | Architectures: x86 |
| 1205 | Type: system ioctl |
| 1206 | Parameters: struct kvm_cpuid2 (in/out) |
| 1207 | Returns: 0 on success, -1 on error |
| 1208 | |
| 1209 | struct kvm_cpuid2 { |
| 1210 | __u32 nent; |
| 1211 | __u32 padding; |
| 1212 | struct kvm_cpuid_entry2 entries[0]; |
| 1213 | }; |
| 1214 | |
Borislav Petkov | 9c15bb1 | 2013-09-22 16:44:50 +0200 | [diff] [blame] | 1215 | #define KVM_CPUID_FLAG_SIGNIFCANT_INDEX BIT(0) |
| 1216 | #define KVM_CPUID_FLAG_STATEFUL_FUNC BIT(1) |
| 1217 | #define KVM_CPUID_FLAG_STATE_READ_NEXT BIT(2) |
Avi Kivity | d153513 | 2010-07-14 09:45:21 +0300 | [diff] [blame] | 1218 | |
| 1219 | struct kvm_cpuid_entry2 { |
| 1220 | __u32 function; |
| 1221 | __u32 index; |
| 1222 | __u32 flags; |
| 1223 | __u32 eax; |
| 1224 | __u32 ebx; |
| 1225 | __u32 ecx; |
| 1226 | __u32 edx; |
| 1227 | __u32 padding[3]; |
| 1228 | }; |
| 1229 | |
| 1230 | This ioctl returns x86 cpuid features which are supported by both the hardware |
| 1231 | and kvm. Userspace can use the information returned by this ioctl to |
| 1232 | construct cpuid information (for KVM_SET_CPUID2) that is consistent with |
| 1233 | hardware, kernel, and userspace capabilities, and with user requirements (for |
| 1234 | example, the user may wish to constrain cpuid to emulate older hardware, |
| 1235 | or for feature consistency across a cluster). |
| 1236 | |
| 1237 | Userspace invokes KVM_GET_SUPPORTED_CPUID by passing a kvm_cpuid2 structure |
| 1238 | with the 'nent' field indicating the number of entries in the variable-size |
| 1239 | array 'entries'. If the number of entries is too low to describe the cpu |
| 1240 | capabilities, an error (E2BIG) is returned. If the number is too high, |
| 1241 | the 'nent' field is adjusted and an error (ENOMEM) is returned. If the |
| 1242 | number is just right, the 'nent' field is adjusted to the number of valid |
| 1243 | entries in the 'entries' array, which is then filled. |
| 1244 | |
| 1245 | 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] | 1246 | with unknown or unsupported features masked out. Some features (for example, |
| 1247 | x2apic), may not be present in the host cpu, but are exposed by kvm if it can |
| 1248 | emulate them efficiently. The fields in each entry are defined as follows: |
Avi Kivity | d153513 | 2010-07-14 09:45:21 +0300 | [diff] [blame] | 1249 | |
| 1250 | function: the eax value used to obtain the entry |
| 1251 | index: the ecx value used to obtain the entry (for entries that are |
| 1252 | affected by ecx) |
| 1253 | flags: an OR of zero or more of the following: |
| 1254 | KVM_CPUID_FLAG_SIGNIFCANT_INDEX: |
| 1255 | if the index field is valid |
| 1256 | KVM_CPUID_FLAG_STATEFUL_FUNC: |
| 1257 | if cpuid for this function returns different values for successive |
| 1258 | invocations; there will be several entries with the same function, |
| 1259 | all with this flag set |
| 1260 | KVM_CPUID_FLAG_STATE_READ_NEXT: |
| 1261 | for KVM_CPUID_FLAG_STATEFUL_FUNC entries, set if this entry is |
| 1262 | the first entry to be read by a cpu |
| 1263 | eax, ebx, ecx, edx: the values returned by the cpuid instruction for |
| 1264 | this function/index combination |
| 1265 | |
Jan Kiszka | 4d25a066 | 2011-12-21 12:28:29 +0100 | [diff] [blame] | 1266 | The TSC deadline timer feature (CPUID leaf 1, ecx[24]) is always returned |
| 1267 | as false, since the feature depends on KVM_CREATE_IRQCHIP for local APIC |
| 1268 | support. Instead it is reported via |
| 1269 | |
| 1270 | ioctl(KVM_CHECK_EXTENSION, KVM_CAP_TSC_DEADLINE_TIMER) |
| 1271 | |
| 1272 | if that returns true and you use KVM_CREATE_IRQCHIP, or if you emulate the |
| 1273 | feature in userspace, then you can enable the feature for KVM_SET_CPUID2. |
| 1274 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 1275 | |
Paul Bolle | 68ba697 | 2011-02-15 00:05:59 +0100 | [diff] [blame] | 1276 | 4.47 KVM_PPC_GET_PVINFO |
Alexander Graf | 15711e9 | 2010-07-29 14:48:08 +0200 | [diff] [blame] | 1277 | |
| 1278 | Capability: KVM_CAP_PPC_GET_PVINFO |
| 1279 | Architectures: ppc |
| 1280 | Type: vm ioctl |
| 1281 | Parameters: struct kvm_ppc_pvinfo (out) |
| 1282 | Returns: 0 on success, !0 on error |
| 1283 | |
| 1284 | struct kvm_ppc_pvinfo { |
| 1285 | __u32 flags; |
| 1286 | __u32 hcall[4]; |
| 1287 | __u8 pad[108]; |
| 1288 | }; |
| 1289 | |
| 1290 | This ioctl fetches PV specific information that need to be passed to the guest |
| 1291 | using the device tree or other means from vm context. |
| 1292 | |
Liu Yu-B13201 | 9202e07 | 2012-07-03 05:48:52 +0000 | [diff] [blame] | 1293 | The hcall array defines 4 instructions that make up a hypercall. |
Alexander Graf | 15711e9 | 2010-07-29 14:48:08 +0200 | [diff] [blame] | 1294 | |
| 1295 | If any additional field gets added to this structure later on, a bit for that |
| 1296 | additional piece of information will be set in the flags bitmap. |
| 1297 | |
Liu Yu-B13201 | 9202e07 | 2012-07-03 05:48:52 +0000 | [diff] [blame] | 1298 | The flags bitmap is defined as: |
| 1299 | |
| 1300 | /* the host supports the ePAPR idle hcall |
| 1301 | #define KVM_PPC_PVINFO_FLAGS_EV_IDLE (1<<0) |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 1302 | |
Paolo Bonzini | e80a4a9 | 2015-06-04 16:32:48 +0200 | [diff] [blame] | 1303 | 4.48 KVM_ASSIGN_PCI_DEVICE (deprecated) |
Jan Kiszka | 49f4817 | 2010-11-16 22:30:07 +0100 | [diff] [blame] | 1304 | |
Michael S. Tsirkin | 7f05db6 | 2014-10-12 11:34:00 +0300 | [diff] [blame] | 1305 | Capability: none |
Tiejun Chen | c32a427 | 2014-11-20 11:07:18 +0100 | [diff] [blame] | 1306 | Architectures: x86 |
Jan Kiszka | 49f4817 | 2010-11-16 22:30:07 +0100 | [diff] [blame] | 1307 | Type: vm ioctl |
| 1308 | Parameters: struct kvm_assigned_pci_dev (in) |
| 1309 | Returns: 0 on success, -1 on error |
| 1310 | |
| 1311 | Assigns a host PCI device to the VM. |
| 1312 | |
| 1313 | struct kvm_assigned_pci_dev { |
| 1314 | __u32 assigned_dev_id; |
| 1315 | __u32 busnr; |
| 1316 | __u32 devfn; |
| 1317 | __u32 flags; |
| 1318 | __u32 segnr; |
| 1319 | union { |
| 1320 | __u32 reserved[11]; |
| 1321 | }; |
| 1322 | }; |
| 1323 | |
| 1324 | The PCI device is specified by the triple segnr, busnr, and devfn. |
| 1325 | Identification in succeeding service requests is done via assigned_dev_id. The |
| 1326 | following flags are specified: |
| 1327 | |
| 1328 | /* Depends on KVM_CAP_IOMMU */ |
| 1329 | #define KVM_DEV_ASSIGN_ENABLE_IOMMU (1 << 0) |
Jan Kiszka | 07700a9 | 2012-02-28 14:19:54 +0100 | [diff] [blame] | 1330 | /* The following two depend on KVM_CAP_PCI_2_3 */ |
| 1331 | #define KVM_DEV_ASSIGN_PCI_2_3 (1 << 1) |
| 1332 | #define KVM_DEV_ASSIGN_MASK_INTX (1 << 2) |
| 1333 | |
| 1334 | If KVM_DEV_ASSIGN_PCI_2_3 is set, the kernel will manage legacy INTx interrupts |
| 1335 | via the PCI-2.3-compliant device-level mask, thus enable IRQ sharing with other |
| 1336 | assigned devices or host devices. KVM_DEV_ASSIGN_MASK_INTX specifies the |
| 1337 | guest's view on the INTx mask, see KVM_ASSIGN_SET_INTX_MASK for details. |
Jan Kiszka | 49f4817 | 2010-11-16 22:30:07 +0100 | [diff] [blame] | 1338 | |
Alex Williamson | 4238737 | 2011-12-20 21:59:03 -0700 | [diff] [blame] | 1339 | The KVM_DEV_ASSIGN_ENABLE_IOMMU flag is a mandatory option to ensure |
| 1340 | isolation of the device. Usages not specifying this flag are deprecated. |
| 1341 | |
Alex Williamson | 3d27e23 | 2011-12-20 21:59:09 -0700 | [diff] [blame] | 1342 | Only PCI header type 0 devices with PCI BAR resources are supported by |
| 1343 | device assignment. The user requesting this ioctl must have read/write |
| 1344 | access to the PCI sysfs resource files associated with the device. |
| 1345 | |
Michael S. Tsirkin | 7f05db6 | 2014-10-12 11:34:00 +0300 | [diff] [blame] | 1346 | Errors: |
| 1347 | ENOTTY: kernel does not support this ioctl |
| 1348 | |
| 1349 | Other error conditions may be defined by individual device types or |
| 1350 | have their standard meanings. |
| 1351 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 1352 | |
Paolo Bonzini | e80a4a9 | 2015-06-04 16:32:48 +0200 | [diff] [blame] | 1353 | 4.49 KVM_DEASSIGN_PCI_DEVICE (deprecated) |
Jan Kiszka | 49f4817 | 2010-11-16 22:30:07 +0100 | [diff] [blame] | 1354 | |
Michael S. Tsirkin | 7f05db6 | 2014-10-12 11:34:00 +0300 | [diff] [blame] | 1355 | Capability: none |
Tiejun Chen | c32a427 | 2014-11-20 11:07:18 +0100 | [diff] [blame] | 1356 | Architectures: x86 |
Jan Kiszka | 49f4817 | 2010-11-16 22:30:07 +0100 | [diff] [blame] | 1357 | Type: vm ioctl |
| 1358 | Parameters: struct kvm_assigned_pci_dev (in) |
| 1359 | Returns: 0 on success, -1 on error |
| 1360 | |
| 1361 | Ends PCI device assignment, releasing all associated resources. |
| 1362 | |
Michael S. Tsirkin | 7f05db6 | 2014-10-12 11:34:00 +0300 | [diff] [blame] | 1363 | See KVM_ASSIGN_PCI_DEVICE for the data structure. Only assigned_dev_id is |
Jan Kiszka | 49f4817 | 2010-11-16 22:30:07 +0100 | [diff] [blame] | 1364 | used in kvm_assigned_pci_dev to identify the device. |
| 1365 | |
Michael S. Tsirkin | 7f05db6 | 2014-10-12 11:34:00 +0300 | [diff] [blame] | 1366 | Errors: |
| 1367 | ENOTTY: kernel does not support this ioctl |
| 1368 | |
| 1369 | Other error conditions may be defined by individual device types or |
| 1370 | have their standard meanings. |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 1371 | |
Paolo Bonzini | e80a4a9 | 2015-06-04 16:32:48 +0200 | [diff] [blame] | 1372 | 4.50 KVM_ASSIGN_DEV_IRQ (deprecated) |
Jan Kiszka | 49f4817 | 2010-11-16 22:30:07 +0100 | [diff] [blame] | 1373 | |
| 1374 | Capability: KVM_CAP_ASSIGN_DEV_IRQ |
Tiejun Chen | c32a427 | 2014-11-20 11:07:18 +0100 | [diff] [blame] | 1375 | Architectures: x86 |
Jan Kiszka | 49f4817 | 2010-11-16 22:30:07 +0100 | [diff] [blame] | 1376 | Type: vm ioctl |
| 1377 | Parameters: struct kvm_assigned_irq (in) |
| 1378 | Returns: 0 on success, -1 on error |
| 1379 | |
| 1380 | Assigns an IRQ to a passed-through device. |
| 1381 | |
| 1382 | struct kvm_assigned_irq { |
| 1383 | __u32 assigned_dev_id; |
Jan Kiszka | 91e3d71 | 2011-06-03 08:51:05 +0200 | [diff] [blame] | 1384 | __u32 host_irq; /* ignored (legacy field) */ |
Jan Kiszka | 49f4817 | 2010-11-16 22:30:07 +0100 | [diff] [blame] | 1385 | __u32 guest_irq; |
| 1386 | __u32 flags; |
| 1387 | union { |
Jan Kiszka | 49f4817 | 2010-11-16 22:30:07 +0100 | [diff] [blame] | 1388 | __u32 reserved[12]; |
| 1389 | }; |
| 1390 | }; |
| 1391 | |
| 1392 | The following flags are defined: |
| 1393 | |
| 1394 | #define KVM_DEV_IRQ_HOST_INTX (1 << 0) |
| 1395 | #define KVM_DEV_IRQ_HOST_MSI (1 << 1) |
| 1396 | #define KVM_DEV_IRQ_HOST_MSIX (1 << 2) |
| 1397 | |
| 1398 | #define KVM_DEV_IRQ_GUEST_INTX (1 << 8) |
| 1399 | #define KVM_DEV_IRQ_GUEST_MSI (1 << 9) |
| 1400 | #define KVM_DEV_IRQ_GUEST_MSIX (1 << 10) |
| 1401 | |
| 1402 | It is not valid to specify multiple types per host or guest IRQ. However, the |
| 1403 | IRQ type of host and guest can differ or can even be null. |
| 1404 | |
Michael S. Tsirkin | 7f05db6 | 2014-10-12 11:34:00 +0300 | [diff] [blame] | 1405 | Errors: |
| 1406 | ENOTTY: kernel does not support this ioctl |
| 1407 | |
| 1408 | Other error conditions may be defined by individual device types or |
| 1409 | have their standard meanings. |
| 1410 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 1411 | |
Paolo Bonzini | e80a4a9 | 2015-06-04 16:32:48 +0200 | [diff] [blame] | 1412 | 4.51 KVM_DEASSIGN_DEV_IRQ (deprecated) |
Jan Kiszka | 49f4817 | 2010-11-16 22:30:07 +0100 | [diff] [blame] | 1413 | |
| 1414 | Capability: KVM_CAP_ASSIGN_DEV_IRQ |
Tiejun Chen | c32a427 | 2014-11-20 11:07:18 +0100 | [diff] [blame] | 1415 | Architectures: x86 |
Jan Kiszka | 49f4817 | 2010-11-16 22:30:07 +0100 | [diff] [blame] | 1416 | Type: vm ioctl |
| 1417 | Parameters: struct kvm_assigned_irq (in) |
| 1418 | Returns: 0 on success, -1 on error |
| 1419 | |
| 1420 | Ends an IRQ assignment to a passed-through device. |
| 1421 | |
| 1422 | See KVM_ASSIGN_DEV_IRQ for the data structure. The target device is specified |
| 1423 | by assigned_dev_id, flags must correspond to the IRQ type specified on |
| 1424 | KVM_ASSIGN_DEV_IRQ. Partial deassignment of host or guest IRQ is allowed. |
| 1425 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 1426 | |
Paul Bolle | 68ba697 | 2011-02-15 00:05:59 +0100 | [diff] [blame] | 1427 | 4.52 KVM_SET_GSI_ROUTING |
Jan Kiszka | 49f4817 | 2010-11-16 22:30:07 +0100 | [diff] [blame] | 1428 | |
| 1429 | Capability: KVM_CAP_IRQ_ROUTING |
Tiejun Chen | c32a427 | 2014-11-20 11:07:18 +0100 | [diff] [blame] | 1430 | Architectures: x86 s390 |
Jan Kiszka | 49f4817 | 2010-11-16 22:30:07 +0100 | [diff] [blame] | 1431 | Type: vm ioctl |
| 1432 | Parameters: struct kvm_irq_routing (in) |
| 1433 | Returns: 0 on success, -1 on error |
| 1434 | |
| 1435 | Sets the GSI routing table entries, overwriting any previously set entries. |
| 1436 | |
| 1437 | struct kvm_irq_routing { |
| 1438 | __u32 nr; |
| 1439 | __u32 flags; |
| 1440 | struct kvm_irq_routing_entry entries[0]; |
| 1441 | }; |
| 1442 | |
| 1443 | No flags are specified so far, the corresponding field must be set to zero. |
| 1444 | |
| 1445 | struct kvm_irq_routing_entry { |
| 1446 | __u32 gsi; |
| 1447 | __u32 type; |
| 1448 | __u32 flags; |
| 1449 | __u32 pad; |
| 1450 | union { |
| 1451 | struct kvm_irq_routing_irqchip irqchip; |
| 1452 | struct kvm_irq_routing_msi msi; |
Cornelia Huck | 8422359 | 2013-07-15 13:36:01 +0200 | [diff] [blame] | 1453 | struct kvm_irq_routing_s390_adapter adapter; |
Andrey Smetanin | 5c919412 | 2015-11-10 15:36:34 +0300 | [diff] [blame] | 1454 | struct kvm_irq_routing_hv_sint hv_sint; |
Jan Kiszka | 49f4817 | 2010-11-16 22:30:07 +0100 | [diff] [blame] | 1455 | __u32 pad[8]; |
| 1456 | } u; |
| 1457 | }; |
| 1458 | |
| 1459 | /* gsi routing entry types */ |
| 1460 | #define KVM_IRQ_ROUTING_IRQCHIP 1 |
| 1461 | #define KVM_IRQ_ROUTING_MSI 2 |
Cornelia Huck | 8422359 | 2013-07-15 13:36:01 +0200 | [diff] [blame] | 1462 | #define KVM_IRQ_ROUTING_S390_ADAPTER 3 |
Andrey Smetanin | 5c919412 | 2015-11-10 15:36:34 +0300 | [diff] [blame] | 1463 | #define KVM_IRQ_ROUTING_HV_SINT 4 |
Jan Kiszka | 49f4817 | 2010-11-16 22:30:07 +0100 | [diff] [blame] | 1464 | |
| 1465 | No flags are specified so far, the corresponding field must be set to zero. |
| 1466 | |
| 1467 | struct kvm_irq_routing_irqchip { |
| 1468 | __u32 irqchip; |
| 1469 | __u32 pin; |
| 1470 | }; |
| 1471 | |
| 1472 | struct kvm_irq_routing_msi { |
| 1473 | __u32 address_lo; |
| 1474 | __u32 address_hi; |
| 1475 | __u32 data; |
| 1476 | __u32 pad; |
| 1477 | }; |
| 1478 | |
Cornelia Huck | 8422359 | 2013-07-15 13:36:01 +0200 | [diff] [blame] | 1479 | struct kvm_irq_routing_s390_adapter { |
| 1480 | __u64 ind_addr; |
| 1481 | __u64 summary_addr; |
| 1482 | __u64 ind_offset; |
| 1483 | __u32 summary_offset; |
| 1484 | __u32 adapter_id; |
| 1485 | }; |
| 1486 | |
Andrey Smetanin | 5c919412 | 2015-11-10 15:36:34 +0300 | [diff] [blame] | 1487 | struct kvm_irq_routing_hv_sint { |
| 1488 | __u32 vcpu; |
| 1489 | __u32 sint; |
| 1490 | }; |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 1491 | |
Paolo Bonzini | e80a4a9 | 2015-06-04 16:32:48 +0200 | [diff] [blame] | 1492 | 4.53 KVM_ASSIGN_SET_MSIX_NR (deprecated) |
Jan Kiszka | 49f4817 | 2010-11-16 22:30:07 +0100 | [diff] [blame] | 1493 | |
Michael S. Tsirkin | 7f05db6 | 2014-10-12 11:34:00 +0300 | [diff] [blame] | 1494 | Capability: none |
Tiejun Chen | c32a427 | 2014-11-20 11:07:18 +0100 | [diff] [blame] | 1495 | Architectures: x86 |
Jan Kiszka | 49f4817 | 2010-11-16 22:30:07 +0100 | [diff] [blame] | 1496 | Type: vm ioctl |
| 1497 | Parameters: struct kvm_assigned_msix_nr (in) |
| 1498 | Returns: 0 on success, -1 on error |
| 1499 | |
Jan Kiszka | 58f0964 | 2011-06-11 12:24:24 +0200 | [diff] [blame] | 1500 | Set the number of MSI-X interrupts for an assigned device. The number is |
| 1501 | reset again by terminating the MSI-X assignment of the device via |
| 1502 | KVM_DEASSIGN_DEV_IRQ. Calling this service more than once at any earlier |
| 1503 | point will fail. |
Jan Kiszka | 49f4817 | 2010-11-16 22:30:07 +0100 | [diff] [blame] | 1504 | |
| 1505 | struct kvm_assigned_msix_nr { |
| 1506 | __u32 assigned_dev_id; |
| 1507 | __u16 entry_nr; |
| 1508 | __u16 padding; |
| 1509 | }; |
| 1510 | |
| 1511 | #define KVM_MAX_MSIX_PER_DEV 256 |
| 1512 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 1513 | |
Paolo Bonzini | e80a4a9 | 2015-06-04 16:32:48 +0200 | [diff] [blame] | 1514 | 4.54 KVM_ASSIGN_SET_MSIX_ENTRY (deprecated) |
Jan Kiszka | 49f4817 | 2010-11-16 22:30:07 +0100 | [diff] [blame] | 1515 | |
Michael S. Tsirkin | 7f05db6 | 2014-10-12 11:34:00 +0300 | [diff] [blame] | 1516 | Capability: none |
Tiejun Chen | c32a427 | 2014-11-20 11:07:18 +0100 | [diff] [blame] | 1517 | Architectures: x86 |
Jan Kiszka | 49f4817 | 2010-11-16 22:30:07 +0100 | [diff] [blame] | 1518 | Type: vm ioctl |
| 1519 | Parameters: struct kvm_assigned_msix_entry (in) |
| 1520 | Returns: 0 on success, -1 on error |
| 1521 | |
| 1522 | Specifies the routing of an MSI-X assigned device interrupt to a GSI. Setting |
| 1523 | the GSI vector to zero means disabling the interrupt. |
| 1524 | |
| 1525 | struct kvm_assigned_msix_entry { |
| 1526 | __u32 assigned_dev_id; |
| 1527 | __u32 gsi; |
| 1528 | __u16 entry; /* The index of entry in the MSI-X table */ |
| 1529 | __u16 padding[3]; |
| 1530 | }; |
| 1531 | |
Michael S. Tsirkin | 7f05db6 | 2014-10-12 11:34:00 +0300 | [diff] [blame] | 1532 | Errors: |
| 1533 | ENOTTY: kernel does not support this ioctl |
| 1534 | |
| 1535 | Other error conditions may be defined by individual device types or |
| 1536 | have their standard meanings. |
| 1537 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 1538 | |
| 1539 | 4.55 KVM_SET_TSC_KHZ |
Joerg Roedel | 92a1f12 | 2011-03-25 09:44:51 +0100 | [diff] [blame] | 1540 | |
| 1541 | Capability: KVM_CAP_TSC_CONTROL |
| 1542 | Architectures: x86 |
| 1543 | Type: vcpu ioctl |
| 1544 | Parameters: virtual tsc_khz |
| 1545 | Returns: 0 on success, -1 on error |
| 1546 | |
| 1547 | Specifies the tsc frequency for the virtual machine. The unit of the |
| 1548 | frequency is KHz. |
| 1549 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 1550 | |
| 1551 | 4.56 KVM_GET_TSC_KHZ |
Joerg Roedel | 92a1f12 | 2011-03-25 09:44:51 +0100 | [diff] [blame] | 1552 | |
| 1553 | Capability: KVM_CAP_GET_TSC_KHZ |
| 1554 | Architectures: x86 |
| 1555 | Type: vcpu ioctl |
| 1556 | Parameters: none |
| 1557 | Returns: virtual tsc-khz on success, negative value on error |
| 1558 | |
| 1559 | Returns the tsc frequency of the guest. The unit of the return value is |
| 1560 | KHz. If the host has unstable tsc this ioctl returns -EIO instead as an |
| 1561 | error. |
| 1562 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 1563 | |
| 1564 | 4.57 KVM_GET_LAPIC |
Avi Kivity | e767793 | 2011-05-11 08:30:51 -0400 | [diff] [blame] | 1565 | |
| 1566 | Capability: KVM_CAP_IRQCHIP |
| 1567 | Architectures: x86 |
| 1568 | Type: vcpu ioctl |
| 1569 | Parameters: struct kvm_lapic_state (out) |
| 1570 | Returns: 0 on success, -1 on error |
| 1571 | |
| 1572 | #define KVM_APIC_REG_SIZE 0x400 |
| 1573 | struct kvm_lapic_state { |
| 1574 | char regs[KVM_APIC_REG_SIZE]; |
| 1575 | }; |
| 1576 | |
| 1577 | Reads the Local APIC registers and copies them into the input argument. The |
| 1578 | data format and layout are the same as documented in the architecture manual. |
| 1579 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 1580 | |
| 1581 | 4.58 KVM_SET_LAPIC |
Avi Kivity | e767793 | 2011-05-11 08:30:51 -0400 | [diff] [blame] | 1582 | |
| 1583 | Capability: KVM_CAP_IRQCHIP |
| 1584 | Architectures: x86 |
| 1585 | Type: vcpu ioctl |
| 1586 | Parameters: struct kvm_lapic_state (in) |
| 1587 | Returns: 0 on success, -1 on error |
| 1588 | |
| 1589 | #define KVM_APIC_REG_SIZE 0x400 |
| 1590 | struct kvm_lapic_state { |
| 1591 | char regs[KVM_APIC_REG_SIZE]; |
| 1592 | }; |
| 1593 | |
Masanari Iida | df5cbb2 | 2014-03-21 10:04:30 +0900 | [diff] [blame] | 1594 | Copies the input argument into the Local APIC registers. The data format |
Avi Kivity | e767793 | 2011-05-11 08:30:51 -0400 | [diff] [blame] | 1595 | and layout are the same as documented in the architecture manual. |
| 1596 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 1597 | |
| 1598 | 4.59 KVM_IOEVENTFD |
Sasha Levin | 55399a0 | 2011-05-28 14:12:30 +0300 | [diff] [blame] | 1599 | |
| 1600 | Capability: KVM_CAP_IOEVENTFD |
| 1601 | Architectures: all |
| 1602 | Type: vm ioctl |
| 1603 | Parameters: struct kvm_ioeventfd (in) |
| 1604 | Returns: 0 on success, !0 on error |
| 1605 | |
| 1606 | This ioctl attaches or detaches an ioeventfd to a legal pio/mmio address |
| 1607 | within the guest. A guest write in the registered address will signal the |
| 1608 | provided event instead of triggering an exit. |
| 1609 | |
| 1610 | struct kvm_ioeventfd { |
| 1611 | __u64 datamatch; |
| 1612 | __u64 addr; /* legal pio/mmio address */ |
Jason Wang | e9ea506 | 2015-09-15 14:41:59 +0800 | [diff] [blame] | 1613 | __u32 len; /* 0, 1, 2, 4, or 8 bytes */ |
Sasha Levin | 55399a0 | 2011-05-28 14:12:30 +0300 | [diff] [blame] | 1614 | __s32 fd; |
| 1615 | __u32 flags; |
| 1616 | __u8 pad[36]; |
| 1617 | }; |
| 1618 | |
Cornelia Huck | 2b83451 | 2013-02-28 12:33:20 +0100 | [diff] [blame] | 1619 | For the special case of virtio-ccw devices on s390, the ioevent is matched |
| 1620 | to a subchannel/virtqueue tuple instead. |
| 1621 | |
Sasha Levin | 55399a0 | 2011-05-28 14:12:30 +0300 | [diff] [blame] | 1622 | The following flags are defined: |
| 1623 | |
| 1624 | #define KVM_IOEVENTFD_FLAG_DATAMATCH (1 << kvm_ioeventfd_flag_nr_datamatch) |
| 1625 | #define KVM_IOEVENTFD_FLAG_PIO (1 << kvm_ioeventfd_flag_nr_pio) |
| 1626 | #define KVM_IOEVENTFD_FLAG_DEASSIGN (1 << kvm_ioeventfd_flag_nr_deassign) |
Cornelia Huck | 2b83451 | 2013-02-28 12:33:20 +0100 | [diff] [blame] | 1627 | #define KVM_IOEVENTFD_FLAG_VIRTIO_CCW_NOTIFY \ |
| 1628 | (1 << kvm_ioeventfd_flag_nr_virtio_ccw_notify) |
Sasha Levin | 55399a0 | 2011-05-28 14:12:30 +0300 | [diff] [blame] | 1629 | |
| 1630 | If datamatch flag is set, the event will be signaled only if the written value |
| 1631 | to the registered address is equal to datamatch in struct kvm_ioeventfd. |
| 1632 | |
Cornelia Huck | 2b83451 | 2013-02-28 12:33:20 +0100 | [diff] [blame] | 1633 | For virtio-ccw devices, addr contains the subchannel id and datamatch the |
| 1634 | virtqueue index. |
| 1635 | |
Jason Wang | e9ea506 | 2015-09-15 14:41:59 +0800 | [diff] [blame] | 1636 | With KVM_CAP_IOEVENTFD_ANY_LENGTH, a zero length ioeventfd is allowed, and |
| 1637 | the kernel will ignore the length of guest write and may get a faster vmexit. |
| 1638 | The speedup may only apply to specific architectures, but the ioeventfd will |
| 1639 | work anyway. |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 1640 | |
| 1641 | 4.60 KVM_DIRTY_TLB |
Scott Wood | dc83b8b | 2011-08-18 15:25:21 -0500 | [diff] [blame] | 1642 | |
| 1643 | Capability: KVM_CAP_SW_TLB |
| 1644 | Architectures: ppc |
| 1645 | Type: vcpu ioctl |
| 1646 | Parameters: struct kvm_dirty_tlb (in) |
| 1647 | Returns: 0 on success, -1 on error |
| 1648 | |
| 1649 | struct kvm_dirty_tlb { |
| 1650 | __u64 bitmap; |
| 1651 | __u32 num_dirty; |
| 1652 | }; |
| 1653 | |
| 1654 | This must be called whenever userspace has changed an entry in the shared |
| 1655 | TLB, prior to calling KVM_RUN on the associated vcpu. |
| 1656 | |
| 1657 | The "bitmap" field is the userspace address of an array. This array |
| 1658 | consists of a number of bits, equal to the total number of TLB entries as |
| 1659 | determined by the last successful call to KVM_CONFIG_TLB, rounded up to the |
| 1660 | nearest multiple of 64. |
| 1661 | |
| 1662 | Each bit corresponds to one TLB entry, ordered the same as in the shared TLB |
| 1663 | array. |
| 1664 | |
| 1665 | The array is little-endian: the bit 0 is the least significant bit of the |
| 1666 | first byte, bit 8 is the least significant bit of the second byte, etc. |
| 1667 | This avoids any complications with differing word sizes. |
| 1668 | |
| 1669 | The "num_dirty" field is a performance hint for KVM to determine whether it |
| 1670 | should skip processing the bitmap and just invalidate everything. It must |
| 1671 | be set to the number of set bits in the bitmap. |
| 1672 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 1673 | |
Paolo Bonzini | e80a4a9 | 2015-06-04 16:32:48 +0200 | [diff] [blame] | 1674 | 4.61 KVM_ASSIGN_SET_INTX_MASK (deprecated) |
Jan Kiszka | 07700a9 | 2012-02-28 14:19:54 +0100 | [diff] [blame] | 1675 | |
| 1676 | Capability: KVM_CAP_PCI_2_3 |
| 1677 | Architectures: x86 |
| 1678 | Type: vm ioctl |
| 1679 | Parameters: struct kvm_assigned_pci_dev (in) |
| 1680 | Returns: 0 on success, -1 on error |
| 1681 | |
| 1682 | Allows userspace to mask PCI INTx interrupts from the assigned device. The |
| 1683 | kernel will not deliver INTx interrupts to the guest between setting and |
| 1684 | clearing of KVM_ASSIGN_SET_INTX_MASK via this interface. This enables use of |
| 1685 | and emulation of PCI 2.3 INTx disable command register behavior. |
| 1686 | |
| 1687 | This may be used for both PCI 2.3 devices supporting INTx disable natively and |
| 1688 | older devices lacking this support. Userspace is responsible for emulating the |
| 1689 | read value of the INTx disable bit in the guest visible PCI command register. |
| 1690 | When modifying the INTx disable state, userspace should precede updating the |
| 1691 | physical device command register by calling this ioctl to inform the kernel of |
| 1692 | the new intended INTx mask state. |
| 1693 | |
| 1694 | Note that the kernel uses the device INTx disable bit to internally manage the |
| 1695 | device interrupt state for PCI 2.3 devices. Reads of this register may |
| 1696 | therefore not match the expected value. Writes should always use the guest |
| 1697 | intended INTx disable value rather than attempting to read-copy-update the |
| 1698 | current physical device state. Races between user and kernel updates to the |
| 1699 | INTx disable bit are handled lazily in the kernel. It's possible the device |
| 1700 | may generate unintended interrupts, but they will not be injected into the |
| 1701 | guest. |
| 1702 | |
| 1703 | See KVM_ASSIGN_DEV_IRQ for the data structure. The target device is specified |
| 1704 | by assigned_dev_id. In the flags field, only KVM_DEV_ASSIGN_MASK_INTX is |
| 1705 | evaluated. |
| 1706 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 1707 | |
David Gibson | 54738c0 | 2011-06-29 00:22:41 +0000 | [diff] [blame] | 1708 | 4.62 KVM_CREATE_SPAPR_TCE |
| 1709 | |
| 1710 | Capability: KVM_CAP_SPAPR_TCE |
| 1711 | Architectures: powerpc |
| 1712 | Type: vm ioctl |
| 1713 | Parameters: struct kvm_create_spapr_tce (in) |
| 1714 | Returns: file descriptor for manipulating the created TCE table |
| 1715 | |
| 1716 | This creates a virtual TCE (translation control entry) table, which |
| 1717 | is an IOMMU for PAPR-style virtual I/O. It is used to translate |
| 1718 | logical addresses used in virtual I/O into guest physical addresses, |
| 1719 | and provides a scatter/gather capability for PAPR virtual I/O. |
| 1720 | |
| 1721 | /* for KVM_CAP_SPAPR_TCE */ |
| 1722 | struct kvm_create_spapr_tce { |
| 1723 | __u64 liobn; |
| 1724 | __u32 window_size; |
| 1725 | }; |
| 1726 | |
| 1727 | The liobn field gives the logical IO bus number for which to create a |
| 1728 | TCE table. The window_size field specifies the size of the DMA window |
| 1729 | which this TCE table will translate - the table will contain one 64 |
| 1730 | bit TCE entry for every 4kiB of the DMA window. |
| 1731 | |
| 1732 | When the guest issues an H_PUT_TCE hcall on a liobn for which a TCE |
| 1733 | table has been created using this ioctl(), the kernel will handle it |
| 1734 | in real mode, updating the TCE table. H_PUT_TCE calls for other |
| 1735 | liobns will cause a vm exit and must be handled by userspace. |
| 1736 | |
| 1737 | The return value is a file descriptor which can be passed to mmap(2) |
| 1738 | to map the created TCE table into userspace. This lets userspace read |
| 1739 | the entries written by kernel-handled H_PUT_TCE calls, and also lets |
| 1740 | userspace update the TCE table directly which is useful in some |
| 1741 | circumstances. |
| 1742 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 1743 | |
Paul Mackerras | aa04b4c | 2011-06-29 00:25:44 +0000 | [diff] [blame] | 1744 | 4.63 KVM_ALLOCATE_RMA |
| 1745 | |
| 1746 | Capability: KVM_CAP_PPC_RMA |
| 1747 | Architectures: powerpc |
| 1748 | Type: vm ioctl |
| 1749 | Parameters: struct kvm_allocate_rma (out) |
| 1750 | Returns: file descriptor for mapping the allocated RMA |
| 1751 | |
| 1752 | This allocates a Real Mode Area (RMA) from the pool allocated at boot |
| 1753 | time by the kernel. An RMA is a physically-contiguous, aligned region |
| 1754 | of memory used on older POWER processors to provide the memory which |
| 1755 | will be accessed by real-mode (MMU off) accesses in a KVM guest. |
| 1756 | POWER processors support a set of sizes for the RMA that usually |
| 1757 | includes 64MB, 128MB, 256MB and some larger powers of two. |
| 1758 | |
| 1759 | /* for KVM_ALLOCATE_RMA */ |
| 1760 | struct kvm_allocate_rma { |
| 1761 | __u64 rma_size; |
| 1762 | }; |
| 1763 | |
| 1764 | The return value is a file descriptor which can be passed to mmap(2) |
| 1765 | to map the allocated RMA into userspace. The mapped area can then be |
| 1766 | passed to the KVM_SET_USER_MEMORY_REGION ioctl to establish it as the |
| 1767 | RMA for a virtual machine. The size of the RMA in bytes (which is |
| 1768 | fixed at host kernel boot time) is returned in the rma_size field of |
| 1769 | the argument structure. |
| 1770 | |
| 1771 | The KVM_CAP_PPC_RMA capability is 1 or 2 if the KVM_ALLOCATE_RMA ioctl |
| 1772 | is supported; 2 if the processor requires all virtual machines to have |
| 1773 | an RMA, or 1 if the processor can use an RMA but doesn't require it, |
| 1774 | because it supports the Virtual RMA (VRMA) facility. |
| 1775 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 1776 | |
Avi Kivity | 3f745f1 | 2011-12-07 12:42:47 +0200 | [diff] [blame] | 1777 | 4.64 KVM_NMI |
| 1778 | |
| 1779 | Capability: KVM_CAP_USER_NMI |
| 1780 | Architectures: x86 |
| 1781 | Type: vcpu ioctl |
| 1782 | Parameters: none |
| 1783 | Returns: 0 on success, -1 on error |
| 1784 | |
| 1785 | Queues an NMI on the thread's vcpu. Note this is well defined only |
| 1786 | when KVM_CREATE_IRQCHIP has not been called, since this is an interface |
| 1787 | between the virtual cpu core and virtual local APIC. After KVM_CREATE_IRQCHIP |
| 1788 | has been called, this interface is completely emulated within the kernel. |
| 1789 | |
| 1790 | To use this to emulate the LINT1 input with KVM_CREATE_IRQCHIP, use the |
| 1791 | following algorithm: |
| 1792 | |
Masanari Iida | 5d4f6f3 | 2015-10-04 00:46:21 +0900 | [diff] [blame] | 1793 | - pause the vcpu |
Avi Kivity | 3f745f1 | 2011-12-07 12:42:47 +0200 | [diff] [blame] | 1794 | - read the local APIC's state (KVM_GET_LAPIC) |
| 1795 | - check whether changing LINT1 will queue an NMI (see the LVT entry for LINT1) |
| 1796 | - if so, issue KVM_NMI |
| 1797 | - resume the vcpu |
| 1798 | |
| 1799 | Some guests configure the LINT1 NMI input to cause a panic, aiding in |
| 1800 | debugging. |
| 1801 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 1802 | |
Alexander Graf | e24ed81 | 2011-09-14 10:02:41 +0200 | [diff] [blame] | 1803 | 4.65 KVM_S390_UCAS_MAP |
Carsten Otte | 27e0393 | 2012-01-04 10:25:21 +0100 | [diff] [blame] | 1804 | |
| 1805 | Capability: KVM_CAP_S390_UCONTROL |
| 1806 | Architectures: s390 |
| 1807 | Type: vcpu ioctl |
| 1808 | Parameters: struct kvm_s390_ucas_mapping (in) |
| 1809 | Returns: 0 in case of success |
| 1810 | |
| 1811 | The parameter is defined like this: |
| 1812 | struct kvm_s390_ucas_mapping { |
| 1813 | __u64 user_addr; |
| 1814 | __u64 vcpu_addr; |
| 1815 | __u64 length; |
| 1816 | }; |
| 1817 | |
| 1818 | This ioctl maps the memory at "user_addr" with the length "length" to |
| 1819 | the vcpu's address space starting at "vcpu_addr". All parameters need to |
Anatol Pomozov | f884ab1 | 2013-05-08 16:56:16 -0700 | [diff] [blame] | 1820 | be aligned by 1 megabyte. |
Carsten Otte | 27e0393 | 2012-01-04 10:25:21 +0100 | [diff] [blame] | 1821 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 1822 | |
Alexander Graf | e24ed81 | 2011-09-14 10:02:41 +0200 | [diff] [blame] | 1823 | 4.66 KVM_S390_UCAS_UNMAP |
Carsten Otte | 27e0393 | 2012-01-04 10:25:21 +0100 | [diff] [blame] | 1824 | |
| 1825 | Capability: KVM_CAP_S390_UCONTROL |
| 1826 | Architectures: s390 |
| 1827 | Type: vcpu ioctl |
| 1828 | Parameters: struct kvm_s390_ucas_mapping (in) |
| 1829 | Returns: 0 in case of success |
| 1830 | |
| 1831 | The parameter is defined like this: |
| 1832 | struct kvm_s390_ucas_mapping { |
| 1833 | __u64 user_addr; |
| 1834 | __u64 vcpu_addr; |
| 1835 | __u64 length; |
| 1836 | }; |
| 1837 | |
| 1838 | This ioctl unmaps the memory in the vcpu's address space starting at |
| 1839 | "vcpu_addr" with the length "length". The field "user_addr" is ignored. |
Anatol Pomozov | f884ab1 | 2013-05-08 16:56:16 -0700 | [diff] [blame] | 1840 | All parameters need to be aligned by 1 megabyte. |
Carsten Otte | 27e0393 | 2012-01-04 10:25:21 +0100 | [diff] [blame] | 1841 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 1842 | |
Alexander Graf | e24ed81 | 2011-09-14 10:02:41 +0200 | [diff] [blame] | 1843 | 4.67 KVM_S390_VCPU_FAULT |
Carsten Otte | ccc7910 | 2012-01-04 10:25:26 +0100 | [diff] [blame] | 1844 | |
| 1845 | Capability: KVM_CAP_S390_UCONTROL |
| 1846 | Architectures: s390 |
| 1847 | Type: vcpu ioctl |
| 1848 | Parameters: vcpu absolute address (in) |
| 1849 | Returns: 0 in case of success |
| 1850 | |
| 1851 | This call creates a page table entry on the virtual cpu's address space |
| 1852 | (for user controlled virtual machines) or the virtual machine's address |
| 1853 | space (for regular virtual machines). This only works for minor faults, |
| 1854 | thus it's recommended to access subject memory page via the user page |
| 1855 | table upfront. This is useful to handle validity intercepts for user |
| 1856 | controlled virtual machines to fault in the virtual cpu's lowcore pages |
| 1857 | prior to calling the KVM_RUN ioctl. |
| 1858 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 1859 | |
Alexander Graf | e24ed81 | 2011-09-14 10:02:41 +0200 | [diff] [blame] | 1860 | 4.68 KVM_SET_ONE_REG |
| 1861 | |
| 1862 | Capability: KVM_CAP_ONE_REG |
| 1863 | Architectures: all |
| 1864 | Type: vcpu ioctl |
| 1865 | Parameters: struct kvm_one_reg (in) |
| 1866 | Returns: 0 on success, negative value on failure |
| 1867 | |
| 1868 | struct kvm_one_reg { |
| 1869 | __u64 id; |
| 1870 | __u64 addr; |
| 1871 | }; |
| 1872 | |
| 1873 | Using this ioctl, a single vcpu register can be set to a specific value |
| 1874 | defined by user space with the passed in struct kvm_one_reg, where id |
| 1875 | refers to the register identifier as described below and addr is a pointer |
| 1876 | to a variable with the respective size. There can be architecture agnostic |
| 1877 | and architecture specific registers. Each have their own range of operation |
| 1878 | and their own constants and width. To keep track of the implemented |
| 1879 | registers, find a list below: |
| 1880 | |
James Hogan | bf5590f | 2014-07-04 15:11:34 +0100 | [diff] [blame] | 1881 | Arch | Register | Width (bits) |
| 1882 | | | |
| 1883 | PPC | KVM_REG_PPC_HIOR | 64 |
| 1884 | PPC | KVM_REG_PPC_IAC1 | 64 |
| 1885 | PPC | KVM_REG_PPC_IAC2 | 64 |
| 1886 | PPC | KVM_REG_PPC_IAC3 | 64 |
| 1887 | PPC | KVM_REG_PPC_IAC4 | 64 |
| 1888 | PPC | KVM_REG_PPC_DAC1 | 64 |
| 1889 | PPC | KVM_REG_PPC_DAC2 | 64 |
| 1890 | PPC | KVM_REG_PPC_DABR | 64 |
| 1891 | PPC | KVM_REG_PPC_DSCR | 64 |
| 1892 | PPC | KVM_REG_PPC_PURR | 64 |
| 1893 | PPC | KVM_REG_PPC_SPURR | 64 |
| 1894 | PPC | KVM_REG_PPC_DAR | 64 |
| 1895 | PPC | KVM_REG_PPC_DSISR | 32 |
| 1896 | PPC | KVM_REG_PPC_AMR | 64 |
| 1897 | PPC | KVM_REG_PPC_UAMOR | 64 |
| 1898 | PPC | KVM_REG_PPC_MMCR0 | 64 |
| 1899 | PPC | KVM_REG_PPC_MMCR1 | 64 |
| 1900 | PPC | KVM_REG_PPC_MMCRA | 64 |
| 1901 | PPC | KVM_REG_PPC_MMCR2 | 64 |
| 1902 | PPC | KVM_REG_PPC_MMCRS | 64 |
| 1903 | PPC | KVM_REG_PPC_SIAR | 64 |
| 1904 | PPC | KVM_REG_PPC_SDAR | 64 |
| 1905 | PPC | KVM_REG_PPC_SIER | 64 |
| 1906 | PPC | KVM_REG_PPC_PMC1 | 32 |
| 1907 | PPC | KVM_REG_PPC_PMC2 | 32 |
| 1908 | PPC | KVM_REG_PPC_PMC3 | 32 |
| 1909 | PPC | KVM_REG_PPC_PMC4 | 32 |
| 1910 | PPC | KVM_REG_PPC_PMC5 | 32 |
| 1911 | PPC | KVM_REG_PPC_PMC6 | 32 |
| 1912 | PPC | KVM_REG_PPC_PMC7 | 32 |
| 1913 | PPC | KVM_REG_PPC_PMC8 | 32 |
| 1914 | PPC | KVM_REG_PPC_FPR0 | 64 |
Paul Mackerras | a8bd19e | 2012-09-25 20:32:30 +0000 | [diff] [blame] | 1915 | ... |
James Hogan | bf5590f | 2014-07-04 15:11:34 +0100 | [diff] [blame] | 1916 | PPC | KVM_REG_PPC_FPR31 | 64 |
| 1917 | PPC | KVM_REG_PPC_VR0 | 128 |
Paul Mackerras | a8bd19e | 2012-09-25 20:32:30 +0000 | [diff] [blame] | 1918 | ... |
James Hogan | bf5590f | 2014-07-04 15:11:34 +0100 | [diff] [blame] | 1919 | PPC | KVM_REG_PPC_VR31 | 128 |
| 1920 | PPC | KVM_REG_PPC_VSR0 | 128 |
Paul Mackerras | a8bd19e | 2012-09-25 20:32:30 +0000 | [diff] [blame] | 1921 | ... |
James Hogan | bf5590f | 2014-07-04 15:11:34 +0100 | [diff] [blame] | 1922 | PPC | KVM_REG_PPC_VSR31 | 128 |
| 1923 | PPC | KVM_REG_PPC_FPSCR | 64 |
| 1924 | PPC | KVM_REG_PPC_VSCR | 32 |
| 1925 | PPC | KVM_REG_PPC_VPA_ADDR | 64 |
| 1926 | PPC | KVM_REG_PPC_VPA_SLB | 128 |
| 1927 | PPC | KVM_REG_PPC_VPA_DTL | 128 |
| 1928 | PPC | KVM_REG_PPC_EPCR | 32 |
| 1929 | PPC | KVM_REG_PPC_EPR | 32 |
| 1930 | PPC | KVM_REG_PPC_TCR | 32 |
| 1931 | PPC | KVM_REG_PPC_TSR | 32 |
| 1932 | PPC | KVM_REG_PPC_OR_TSR | 32 |
| 1933 | PPC | KVM_REG_PPC_CLEAR_TSR | 32 |
| 1934 | PPC | KVM_REG_PPC_MAS0 | 32 |
| 1935 | PPC | KVM_REG_PPC_MAS1 | 32 |
| 1936 | PPC | KVM_REG_PPC_MAS2 | 64 |
| 1937 | PPC | KVM_REG_PPC_MAS7_3 | 64 |
| 1938 | PPC | KVM_REG_PPC_MAS4 | 32 |
| 1939 | PPC | KVM_REG_PPC_MAS6 | 32 |
| 1940 | PPC | KVM_REG_PPC_MMUCFG | 32 |
| 1941 | PPC | KVM_REG_PPC_TLB0CFG | 32 |
| 1942 | PPC | KVM_REG_PPC_TLB1CFG | 32 |
| 1943 | PPC | KVM_REG_PPC_TLB2CFG | 32 |
| 1944 | PPC | KVM_REG_PPC_TLB3CFG | 32 |
| 1945 | PPC | KVM_REG_PPC_TLB0PS | 32 |
| 1946 | PPC | KVM_REG_PPC_TLB1PS | 32 |
| 1947 | PPC | KVM_REG_PPC_TLB2PS | 32 |
| 1948 | PPC | KVM_REG_PPC_TLB3PS | 32 |
| 1949 | PPC | KVM_REG_PPC_EPTCFG | 32 |
| 1950 | PPC | KVM_REG_PPC_ICP_STATE | 64 |
| 1951 | PPC | KVM_REG_PPC_TB_OFFSET | 64 |
| 1952 | PPC | KVM_REG_PPC_SPMC1 | 32 |
| 1953 | PPC | KVM_REG_PPC_SPMC2 | 32 |
| 1954 | PPC | KVM_REG_PPC_IAMR | 64 |
| 1955 | PPC | KVM_REG_PPC_TFHAR | 64 |
| 1956 | PPC | KVM_REG_PPC_TFIAR | 64 |
| 1957 | PPC | KVM_REG_PPC_TEXASR | 64 |
| 1958 | PPC | KVM_REG_PPC_FSCR | 64 |
| 1959 | PPC | KVM_REG_PPC_PSPB | 32 |
| 1960 | PPC | KVM_REG_PPC_EBBHR | 64 |
| 1961 | PPC | KVM_REG_PPC_EBBRR | 64 |
| 1962 | PPC | KVM_REG_PPC_BESCR | 64 |
| 1963 | PPC | KVM_REG_PPC_TAR | 64 |
| 1964 | PPC | KVM_REG_PPC_DPDES | 64 |
| 1965 | PPC | KVM_REG_PPC_DAWR | 64 |
| 1966 | PPC | KVM_REG_PPC_DAWRX | 64 |
| 1967 | PPC | KVM_REG_PPC_CIABR | 64 |
| 1968 | PPC | KVM_REG_PPC_IC | 64 |
| 1969 | PPC | KVM_REG_PPC_VTB | 64 |
| 1970 | PPC | KVM_REG_PPC_CSIGR | 64 |
| 1971 | PPC | KVM_REG_PPC_TACR | 64 |
| 1972 | PPC | KVM_REG_PPC_TCSCR | 64 |
| 1973 | PPC | KVM_REG_PPC_PID | 64 |
| 1974 | PPC | KVM_REG_PPC_ACOP | 64 |
| 1975 | PPC | KVM_REG_PPC_VRSAVE | 32 |
Paolo Bonzini | cc568ea | 2014-08-05 09:55:22 +0200 | [diff] [blame] | 1976 | PPC | KVM_REG_PPC_LPCR | 32 |
| 1977 | PPC | KVM_REG_PPC_LPCR_64 | 64 |
James Hogan | bf5590f | 2014-07-04 15:11:34 +0100 | [diff] [blame] | 1978 | PPC | KVM_REG_PPC_PPR | 64 |
| 1979 | PPC | KVM_REG_PPC_ARCH_COMPAT | 32 |
| 1980 | PPC | KVM_REG_PPC_DABRX | 32 |
| 1981 | PPC | KVM_REG_PPC_WORT | 64 |
Bharat Bhushan | bc8a4e5 | 2014-08-13 14:40:06 +0530 | [diff] [blame] | 1982 | PPC | KVM_REG_PPC_SPRG9 | 64 |
| 1983 | PPC | KVM_REG_PPC_DBSR | 32 |
James Hogan | bf5590f | 2014-07-04 15:11:34 +0100 | [diff] [blame] | 1984 | PPC | KVM_REG_PPC_TM_GPR0 | 64 |
Michael Neuling | 3b78347 | 2013-09-03 11:13:12 +1000 | [diff] [blame] | 1985 | ... |
James Hogan | bf5590f | 2014-07-04 15:11:34 +0100 | [diff] [blame] | 1986 | PPC | KVM_REG_PPC_TM_GPR31 | 64 |
| 1987 | PPC | KVM_REG_PPC_TM_VSR0 | 128 |
Michael Neuling | 3b78347 | 2013-09-03 11:13:12 +1000 | [diff] [blame] | 1988 | ... |
James Hogan | bf5590f | 2014-07-04 15:11:34 +0100 | [diff] [blame] | 1989 | PPC | KVM_REG_PPC_TM_VSR63 | 128 |
| 1990 | PPC | KVM_REG_PPC_TM_CR | 64 |
| 1991 | PPC | KVM_REG_PPC_TM_LR | 64 |
| 1992 | PPC | KVM_REG_PPC_TM_CTR | 64 |
| 1993 | PPC | KVM_REG_PPC_TM_FPSCR | 64 |
| 1994 | PPC | KVM_REG_PPC_TM_AMR | 64 |
| 1995 | PPC | KVM_REG_PPC_TM_PPR | 64 |
| 1996 | PPC | KVM_REG_PPC_TM_VRSAVE | 64 |
| 1997 | PPC | KVM_REG_PPC_TM_VSCR | 32 |
| 1998 | PPC | KVM_REG_PPC_TM_DSCR | 64 |
| 1999 | PPC | KVM_REG_PPC_TM_TAR | 64 |
James Hogan | c2d2c21 | 2014-07-04 15:11:35 +0100 | [diff] [blame] | 2000 | | | |
| 2001 | MIPS | KVM_REG_MIPS_R0 | 64 |
| 2002 | ... |
| 2003 | MIPS | KVM_REG_MIPS_R31 | 64 |
| 2004 | MIPS | KVM_REG_MIPS_HI | 64 |
| 2005 | MIPS | KVM_REG_MIPS_LO | 64 |
| 2006 | MIPS | KVM_REG_MIPS_PC | 64 |
| 2007 | MIPS | KVM_REG_MIPS_CP0_INDEX | 32 |
| 2008 | MIPS | KVM_REG_MIPS_CP0_CONTEXT | 64 |
| 2009 | MIPS | KVM_REG_MIPS_CP0_USERLOCAL | 64 |
| 2010 | MIPS | KVM_REG_MIPS_CP0_PAGEMASK | 32 |
| 2011 | MIPS | KVM_REG_MIPS_CP0_WIRED | 32 |
| 2012 | MIPS | KVM_REG_MIPS_CP0_HWRENA | 32 |
| 2013 | MIPS | KVM_REG_MIPS_CP0_BADVADDR | 64 |
| 2014 | MIPS | KVM_REG_MIPS_CP0_COUNT | 32 |
| 2015 | MIPS | KVM_REG_MIPS_CP0_ENTRYHI | 64 |
| 2016 | MIPS | KVM_REG_MIPS_CP0_COMPARE | 32 |
| 2017 | MIPS | KVM_REG_MIPS_CP0_STATUS | 32 |
| 2018 | MIPS | KVM_REG_MIPS_CP0_CAUSE | 32 |
| 2019 | MIPS | KVM_REG_MIPS_CP0_EPC | 64 |
James Hogan | 1068eaa | 2014-06-26 13:56:52 +0100 | [diff] [blame] | 2020 | MIPS | KVM_REG_MIPS_CP0_PRID | 32 |
James Hogan | c2d2c21 | 2014-07-04 15:11:35 +0100 | [diff] [blame] | 2021 | MIPS | KVM_REG_MIPS_CP0_CONFIG | 32 |
| 2022 | MIPS | KVM_REG_MIPS_CP0_CONFIG1 | 32 |
| 2023 | MIPS | KVM_REG_MIPS_CP0_CONFIG2 | 32 |
| 2024 | MIPS | KVM_REG_MIPS_CP0_CONFIG3 | 32 |
James Hogan | c771607 | 2014-06-26 15:11:29 +0100 | [diff] [blame] | 2025 | MIPS | KVM_REG_MIPS_CP0_CONFIG4 | 32 |
| 2026 | MIPS | KVM_REG_MIPS_CP0_CONFIG5 | 32 |
James Hogan | c2d2c21 | 2014-07-04 15:11:35 +0100 | [diff] [blame] | 2027 | MIPS | KVM_REG_MIPS_CP0_CONFIG7 | 32 |
| 2028 | MIPS | KVM_REG_MIPS_CP0_ERROREPC | 64 |
| 2029 | MIPS | KVM_REG_MIPS_COUNT_CTL | 64 |
| 2030 | MIPS | KVM_REG_MIPS_COUNT_RESUME | 64 |
| 2031 | MIPS | KVM_REG_MIPS_COUNT_HZ | 64 |
James Hogan | 379245c | 2014-12-02 15:48:24 +0000 | [diff] [blame] | 2032 | MIPS | KVM_REG_MIPS_FPR_32(0..31) | 32 |
| 2033 | MIPS | KVM_REG_MIPS_FPR_64(0..31) | 64 |
James Hogan | ab86bd6 | 2014-12-02 15:48:24 +0000 | [diff] [blame] | 2034 | MIPS | KVM_REG_MIPS_VEC_128(0..31) | 128 |
James Hogan | 379245c | 2014-12-02 15:48:24 +0000 | [diff] [blame] | 2035 | MIPS | KVM_REG_MIPS_FCR_IR | 32 |
| 2036 | MIPS | KVM_REG_MIPS_FCR_CSR | 32 |
James Hogan | ab86bd6 | 2014-12-02 15:48:24 +0000 | [diff] [blame] | 2037 | MIPS | KVM_REG_MIPS_MSA_IR | 32 |
| 2038 | MIPS | KVM_REG_MIPS_MSA_CSR | 32 |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 2039 | |
Christoffer Dall | 749cf76c | 2013-01-20 18:28:06 -0500 | [diff] [blame] | 2040 | ARM registers are mapped using the lower 32 bits. The upper 16 of that |
| 2041 | is the register group type, or coprocessor number: |
| 2042 | |
| 2043 | ARM core registers have the following id bit patterns: |
Christoffer Dall | aa404dd | 2013-04-22 18:57:46 -0700 | [diff] [blame] | 2044 | 0x4020 0000 0010 <index into the kvm_regs struct:16> |
Christoffer Dall | 749cf76c | 2013-01-20 18:28:06 -0500 | [diff] [blame] | 2045 | |
Christoffer Dall | 1138245 | 2013-01-20 18:28:10 -0500 | [diff] [blame] | 2046 | ARM 32-bit CP15 registers have the following id bit patterns: |
Christoffer Dall | aa404dd | 2013-04-22 18:57:46 -0700 | [diff] [blame] | 2047 | 0x4020 0000 000F <zero:1> <crn:4> <crm:4> <opc1:4> <opc2:3> |
Christoffer Dall | 1138245 | 2013-01-20 18:28:10 -0500 | [diff] [blame] | 2048 | |
| 2049 | ARM 64-bit CP15 registers have the following id bit patterns: |
Christoffer Dall | aa404dd | 2013-04-22 18:57:46 -0700 | [diff] [blame] | 2050 | 0x4030 0000 000F <zero:1> <zero:4> <crm:4> <opc1:4> <zero:3> |
Christoffer Dall | 749cf76c | 2013-01-20 18:28:06 -0500 | [diff] [blame] | 2051 | |
Christoffer Dall | c27581e | 2013-01-20 18:28:10 -0500 | [diff] [blame] | 2052 | ARM CCSIDR registers are demultiplexed by CSSELR value: |
Christoffer Dall | aa404dd | 2013-04-22 18:57:46 -0700 | [diff] [blame] | 2053 | 0x4020 0000 0011 00 <csselr:8> |
Christoffer Dall | 749cf76c | 2013-01-20 18:28:06 -0500 | [diff] [blame] | 2054 | |
Rusty Russell | 4fe21e4 | 2013-01-20 18:28:11 -0500 | [diff] [blame] | 2055 | ARM 32-bit VFP control registers have the following id bit patterns: |
Christoffer Dall | aa404dd | 2013-04-22 18:57:46 -0700 | [diff] [blame] | 2056 | 0x4020 0000 0012 1 <regno:12> |
Rusty Russell | 4fe21e4 | 2013-01-20 18:28:11 -0500 | [diff] [blame] | 2057 | |
| 2058 | ARM 64-bit FP registers have the following id bit patterns: |
Christoffer Dall | aa404dd | 2013-04-22 18:57:46 -0700 | [diff] [blame] | 2059 | 0x4030 0000 0012 0 <regno:12> |
Rusty Russell | 4fe21e4 | 2013-01-20 18:28:11 -0500 | [diff] [blame] | 2060 | |
Marc Zyngier | 379e04c | 2013-04-02 17:46:31 +0100 | [diff] [blame] | 2061 | |
| 2062 | arm64 registers are mapped using the lower 32 bits. The upper 16 of |
| 2063 | that is the register group type, or coprocessor number: |
| 2064 | |
| 2065 | arm64 core/FP-SIMD registers have the following id bit patterns. Note |
| 2066 | that the size of the access is variable, as the kvm_regs structure |
| 2067 | contains elements ranging from 32 to 128 bits. The index is a 32bit |
| 2068 | value in the kvm_regs structure seen as a 32bit array. |
| 2069 | 0x60x0 0000 0010 <index into the kvm_regs struct:16> |
| 2070 | |
| 2071 | arm64 CCSIDR registers are demultiplexed by CSSELR value: |
| 2072 | 0x6020 0000 0011 00 <csselr:8> |
| 2073 | |
| 2074 | arm64 system registers have the following id bit patterns: |
| 2075 | 0x6030 0000 0013 <op0:2> <op1:3> <crn:4> <crm:4> <op2:3> |
| 2076 | |
James Hogan | c2d2c21 | 2014-07-04 15:11:35 +0100 | [diff] [blame] | 2077 | |
| 2078 | MIPS registers are mapped using the lower 32 bits. The upper 16 of that is |
| 2079 | the register group type: |
| 2080 | |
| 2081 | MIPS core registers (see above) have the following id bit patterns: |
| 2082 | 0x7030 0000 0000 <reg:16> |
| 2083 | |
| 2084 | MIPS CP0 registers (see KVM_REG_MIPS_CP0_* above) have the following id bit |
| 2085 | patterns depending on whether they're 32-bit or 64-bit registers: |
| 2086 | 0x7020 0000 0001 00 <reg:5> <sel:3> (32-bit) |
| 2087 | 0x7030 0000 0001 00 <reg:5> <sel:3> (64-bit) |
| 2088 | |
| 2089 | MIPS KVM control registers (see above) have the following id bit patterns: |
| 2090 | 0x7030 0000 0002 <reg:16> |
| 2091 | |
James Hogan | 379245c | 2014-12-02 15:48:24 +0000 | [diff] [blame] | 2092 | MIPS FPU registers (see KVM_REG_MIPS_FPR_{32,64}() above) have the following |
| 2093 | id bit patterns depending on the size of the register being accessed. They are |
| 2094 | always accessed according to the current guest FPU mode (Status.FR and |
| 2095 | Config5.FRE), i.e. as the guest would see them, and they become unpredictable |
James Hogan | ab86bd6 | 2014-12-02 15:48:24 +0000 | [diff] [blame] | 2096 | if the guest FPU mode is changed. MIPS SIMD Architecture (MSA) vector |
| 2097 | registers (see KVM_REG_MIPS_VEC_128() above) have similar patterns as they |
| 2098 | overlap the FPU registers: |
James Hogan | 379245c | 2014-12-02 15:48:24 +0000 | [diff] [blame] | 2099 | 0x7020 0000 0003 00 <0:3> <reg:5> (32-bit FPU registers) |
| 2100 | 0x7030 0000 0003 00 <0:3> <reg:5> (64-bit FPU registers) |
James Hogan | ab86bd6 | 2014-12-02 15:48:24 +0000 | [diff] [blame] | 2101 | 0x7040 0000 0003 00 <0:3> <reg:5> (128-bit MSA vector registers) |
James Hogan | 379245c | 2014-12-02 15:48:24 +0000 | [diff] [blame] | 2102 | |
| 2103 | MIPS FPU control registers (see KVM_REG_MIPS_FCR_{IR,CSR} above) have the |
| 2104 | following id bit patterns: |
| 2105 | 0x7020 0000 0003 01 <0:3> <reg:5> |
| 2106 | |
James Hogan | ab86bd6 | 2014-12-02 15:48:24 +0000 | [diff] [blame] | 2107 | MIPS MSA control registers (see KVM_REG_MIPS_MSA_{IR,CSR} above) have the |
| 2108 | following id bit patterns: |
| 2109 | 0x7020 0000 0003 02 <0:3> <reg:5> |
| 2110 | |
James Hogan | c2d2c21 | 2014-07-04 15:11:35 +0100 | [diff] [blame] | 2111 | |
Alexander Graf | e24ed81 | 2011-09-14 10:02:41 +0200 | [diff] [blame] | 2112 | 4.69 KVM_GET_ONE_REG |
| 2113 | |
| 2114 | Capability: KVM_CAP_ONE_REG |
| 2115 | Architectures: all |
| 2116 | Type: vcpu ioctl |
| 2117 | Parameters: struct kvm_one_reg (in and out) |
| 2118 | Returns: 0 on success, negative value on failure |
| 2119 | |
| 2120 | This ioctl allows to receive the value of a single register implemented |
| 2121 | in a vcpu. The register to read is indicated by the "id" field of the |
| 2122 | kvm_one_reg struct passed in. On success, the register value can be found |
| 2123 | at the memory location pointed to by "addr". |
| 2124 | |
| 2125 | The list of registers accessible using this interface is identical to the |
Bharat Bhushan | 2e23270 | 2012-08-15 17:37:13 +0000 | [diff] [blame] | 2126 | list in 4.68. |
Alexander Graf | e24ed81 | 2011-09-14 10:02:41 +0200 | [diff] [blame] | 2127 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 2128 | |
Eric B Munson | 1c0b28c | 2012-03-10 14:37:27 -0500 | [diff] [blame] | 2129 | 4.70 KVM_KVMCLOCK_CTRL |
| 2130 | |
| 2131 | Capability: KVM_CAP_KVMCLOCK_CTRL |
| 2132 | Architectures: Any that implement pvclocks (currently x86 only) |
| 2133 | Type: vcpu ioctl |
| 2134 | Parameters: None |
| 2135 | Returns: 0 on success, -1 on error |
| 2136 | |
| 2137 | This signals to the host kernel that the specified guest is being paused by |
| 2138 | userspace. The host will set a flag in the pvclock structure that is checked |
| 2139 | from the soft lockup watchdog. The flag is part of the pvclock structure that |
| 2140 | is shared between guest and host, specifically the second bit of the flags |
| 2141 | field of the pvclock_vcpu_time_info structure. It will be set exclusively by |
| 2142 | the host and read/cleared exclusively by the guest. The guest operation of |
| 2143 | checking and clearing the flag must an atomic operation so |
| 2144 | load-link/store-conditional, or equivalent must be used. There are two cases |
| 2145 | where the guest will clear the flag: when the soft lockup watchdog timer resets |
| 2146 | itself or when a soft lockup is detected. This ioctl can be called any time |
| 2147 | after pausing the vcpu, but before it is resumed. |
| 2148 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 2149 | |
Jan Kiszka | 07975ad | 2012-03-29 21:14:12 +0200 | [diff] [blame] | 2150 | 4.71 KVM_SIGNAL_MSI |
| 2151 | |
| 2152 | Capability: KVM_CAP_SIGNAL_MSI |
| 2153 | Architectures: x86 |
| 2154 | Type: vm ioctl |
| 2155 | Parameters: struct kvm_msi (in) |
| 2156 | Returns: >0 on delivery, 0 if guest blocked the MSI, and -1 on error |
| 2157 | |
| 2158 | Directly inject a MSI message. Only valid with in-kernel irqchip that handles |
| 2159 | MSI messages. |
| 2160 | |
| 2161 | struct kvm_msi { |
| 2162 | __u32 address_lo; |
| 2163 | __u32 address_hi; |
| 2164 | __u32 data; |
| 2165 | __u32 flags; |
| 2166 | __u8 pad[16]; |
| 2167 | }; |
| 2168 | |
| 2169 | No flags are defined so far. The corresponding field must be 0. |
| 2170 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 2171 | |
Jan Kiszka | 0589ff6 | 2012-04-24 16:40:16 +0200 | [diff] [blame] | 2172 | 4.71 KVM_CREATE_PIT2 |
| 2173 | |
| 2174 | Capability: KVM_CAP_PIT2 |
| 2175 | Architectures: x86 |
| 2176 | Type: vm ioctl |
| 2177 | Parameters: struct kvm_pit_config (in) |
| 2178 | Returns: 0 on success, -1 on error |
| 2179 | |
| 2180 | Creates an in-kernel device model for the i8254 PIT. This call is only valid |
| 2181 | after enabling in-kernel irqchip support via KVM_CREATE_IRQCHIP. The following |
| 2182 | parameters have to be passed: |
| 2183 | |
| 2184 | struct kvm_pit_config { |
| 2185 | __u32 flags; |
| 2186 | __u32 pad[15]; |
| 2187 | }; |
| 2188 | |
| 2189 | Valid flags are: |
| 2190 | |
| 2191 | #define KVM_PIT_SPEAKER_DUMMY 1 /* emulate speaker port stub */ |
| 2192 | |
Jan Kiszka | b6ddf05 | 2012-04-24 16:40:17 +0200 | [diff] [blame] | 2193 | PIT timer interrupts may use a per-VM kernel thread for injection. If it |
| 2194 | exists, this thread will have a name of the following pattern: |
| 2195 | |
| 2196 | kvm-pit/<owner-process-pid> |
| 2197 | |
| 2198 | When running a guest with elevated priorities, the scheduling parameters of |
| 2199 | this thread may have to be adjusted accordingly. |
| 2200 | |
Jan Kiszka | 0589ff6 | 2012-04-24 16:40:16 +0200 | [diff] [blame] | 2201 | This IOCTL replaces the obsolete KVM_CREATE_PIT. |
| 2202 | |
| 2203 | |
| 2204 | 4.72 KVM_GET_PIT2 |
| 2205 | |
| 2206 | Capability: KVM_CAP_PIT_STATE2 |
| 2207 | Architectures: x86 |
| 2208 | Type: vm ioctl |
| 2209 | Parameters: struct kvm_pit_state2 (out) |
| 2210 | Returns: 0 on success, -1 on error |
| 2211 | |
| 2212 | Retrieves the state of the in-kernel PIT model. Only valid after |
| 2213 | KVM_CREATE_PIT2. The state is returned in the following structure: |
| 2214 | |
| 2215 | struct kvm_pit_state2 { |
| 2216 | struct kvm_pit_channel_state channels[3]; |
| 2217 | __u32 flags; |
| 2218 | __u32 reserved[9]; |
| 2219 | }; |
| 2220 | |
| 2221 | Valid flags are: |
| 2222 | |
| 2223 | /* disable PIT in HPET legacy mode */ |
| 2224 | #define KVM_PIT_FLAGS_HPET_LEGACY 0x00000001 |
| 2225 | |
| 2226 | This IOCTL replaces the obsolete KVM_GET_PIT. |
| 2227 | |
| 2228 | |
| 2229 | 4.73 KVM_SET_PIT2 |
| 2230 | |
| 2231 | Capability: KVM_CAP_PIT_STATE2 |
| 2232 | Architectures: x86 |
| 2233 | Type: vm ioctl |
| 2234 | Parameters: struct kvm_pit_state2 (in) |
| 2235 | Returns: 0 on success, -1 on error |
| 2236 | |
| 2237 | Sets the state of the in-kernel PIT model. Only valid after KVM_CREATE_PIT2. |
| 2238 | See KVM_GET_PIT2 for details on struct kvm_pit_state2. |
| 2239 | |
| 2240 | This IOCTL replaces the obsolete KVM_SET_PIT. |
| 2241 | |
| 2242 | |
Benjamin Herrenschmidt | 5b74716 | 2012-04-26 19:43:42 +0000 | [diff] [blame] | 2243 | 4.74 KVM_PPC_GET_SMMU_INFO |
| 2244 | |
| 2245 | Capability: KVM_CAP_PPC_GET_SMMU_INFO |
| 2246 | Architectures: powerpc |
| 2247 | Type: vm ioctl |
| 2248 | Parameters: None |
| 2249 | Returns: 0 on success, -1 on error |
| 2250 | |
| 2251 | This populates and returns a structure describing the features of |
| 2252 | the "Server" class MMU emulation supported by KVM. |
Stefan Huber | cc22c35 | 2013-06-05 12:24:37 +0200 | [diff] [blame] | 2253 | This can in turn be used by userspace to generate the appropriate |
Benjamin Herrenschmidt | 5b74716 | 2012-04-26 19:43:42 +0000 | [diff] [blame] | 2254 | device-tree properties for the guest operating system. |
| 2255 | |
Carlos Garcia | c98be0c | 2014-04-04 22:31:00 -0400 | [diff] [blame] | 2256 | The structure contains some global information, followed by an |
Benjamin Herrenschmidt | 5b74716 | 2012-04-26 19:43:42 +0000 | [diff] [blame] | 2257 | array of supported segment page sizes: |
| 2258 | |
| 2259 | struct kvm_ppc_smmu_info { |
| 2260 | __u64 flags; |
| 2261 | __u32 slb_size; |
| 2262 | __u32 pad; |
| 2263 | struct kvm_ppc_one_seg_page_size sps[KVM_PPC_PAGE_SIZES_MAX_SZ]; |
| 2264 | }; |
| 2265 | |
| 2266 | The supported flags are: |
| 2267 | |
| 2268 | - KVM_PPC_PAGE_SIZES_REAL: |
| 2269 | When that flag is set, guest page sizes must "fit" the backing |
| 2270 | store page sizes. When not set, any page size in the list can |
| 2271 | be used regardless of how they are backed by userspace. |
| 2272 | |
| 2273 | - KVM_PPC_1T_SEGMENTS |
| 2274 | The emulated MMU supports 1T segments in addition to the |
| 2275 | standard 256M ones. |
| 2276 | |
| 2277 | The "slb_size" field indicates how many SLB entries are supported |
| 2278 | |
| 2279 | The "sps" array contains 8 entries indicating the supported base |
| 2280 | page sizes for a segment in increasing order. Each entry is defined |
| 2281 | as follow: |
| 2282 | |
| 2283 | struct kvm_ppc_one_seg_page_size { |
| 2284 | __u32 page_shift; /* Base page shift of segment (or 0) */ |
| 2285 | __u32 slb_enc; /* SLB encoding for BookS */ |
| 2286 | struct kvm_ppc_one_page_size enc[KVM_PPC_PAGE_SIZES_MAX_SZ]; |
| 2287 | }; |
| 2288 | |
| 2289 | An entry with a "page_shift" of 0 is unused. Because the array is |
| 2290 | organized in increasing order, a lookup can stop when encoutering |
| 2291 | such an entry. |
| 2292 | |
| 2293 | The "slb_enc" field provides the encoding to use in the SLB for the |
| 2294 | page size. The bits are in positions such as the value can directly |
| 2295 | be OR'ed into the "vsid" argument of the slbmte instruction. |
| 2296 | |
| 2297 | The "enc" array is a list which for each of those segment base page |
| 2298 | size provides the list of supported actual page sizes (which can be |
| 2299 | only larger or equal to the base page size), along with the |
Anatol Pomozov | f884ab1 | 2013-05-08 16:56:16 -0700 | [diff] [blame] | 2300 | corresponding encoding in the hash PTE. Similarly, the array is |
Benjamin Herrenschmidt | 5b74716 | 2012-04-26 19:43:42 +0000 | [diff] [blame] | 2301 | 8 entries sorted by increasing sizes and an entry with a "0" shift |
| 2302 | is an empty entry and a terminator: |
| 2303 | |
| 2304 | struct kvm_ppc_one_page_size { |
| 2305 | __u32 page_shift; /* Page shift (or 0) */ |
| 2306 | __u32 pte_enc; /* Encoding in the HPTE (>>12) */ |
| 2307 | }; |
| 2308 | |
| 2309 | The "pte_enc" field provides a value that can OR'ed into the hash |
| 2310 | PTE's RPN field (ie, it needs to be shifted left by 12 to OR it |
| 2311 | into the hash PTE second double word). |
| 2312 | |
Alex Williamson | f36992e | 2012-06-29 09:56:16 -0600 | [diff] [blame] | 2313 | 4.75 KVM_IRQFD |
| 2314 | |
| 2315 | Capability: KVM_CAP_IRQFD |
Eric Auger | 174178f | 2015-03-04 11:14:36 +0100 | [diff] [blame] | 2316 | Architectures: x86 s390 arm arm64 |
Alex Williamson | f36992e | 2012-06-29 09:56:16 -0600 | [diff] [blame] | 2317 | Type: vm ioctl |
| 2318 | Parameters: struct kvm_irqfd (in) |
| 2319 | Returns: 0 on success, -1 on error |
| 2320 | |
| 2321 | Allows setting an eventfd to directly trigger a guest interrupt. |
| 2322 | kvm_irqfd.fd specifies the file descriptor to use as the eventfd and |
| 2323 | kvm_irqfd.gsi specifies the irqchip pin toggled by this event. When |
Masanari Iida | 1718003 | 2013-12-22 01:21:23 +0900 | [diff] [blame] | 2324 | an event is triggered on the eventfd, an interrupt is injected into |
Alex Williamson | f36992e | 2012-06-29 09:56:16 -0600 | [diff] [blame] | 2325 | the guest using the specified gsi pin. The irqfd is removed using |
| 2326 | the KVM_IRQFD_FLAG_DEASSIGN flag, specifying both kvm_irqfd.fd |
| 2327 | and kvm_irqfd.gsi. |
| 2328 | |
Alex Williamson | 7a84428 | 2012-09-21 11:58:03 -0600 | [diff] [blame] | 2329 | With KVM_CAP_IRQFD_RESAMPLE, KVM_IRQFD supports a de-assert and notify |
| 2330 | mechanism allowing emulation of level-triggered, irqfd-based |
| 2331 | interrupts. When KVM_IRQFD_FLAG_RESAMPLE is set the user must pass an |
| 2332 | additional eventfd in the kvm_irqfd.resamplefd field. When operating |
| 2333 | in resample mode, posting of an interrupt through kvm_irq.fd asserts |
| 2334 | the specified gsi in the irqchip. When the irqchip is resampled, such |
Masanari Iida | 1718003 | 2013-12-22 01:21:23 +0900 | [diff] [blame] | 2335 | as from an EOI, the gsi is de-asserted and the user is notified via |
Alex Williamson | 7a84428 | 2012-09-21 11:58:03 -0600 | [diff] [blame] | 2336 | kvm_irqfd.resamplefd. It is the user's responsibility to re-queue |
| 2337 | the interrupt if the device making use of it still requires service. |
| 2338 | Note that closing the resamplefd is not sufficient to disable the |
| 2339 | irqfd. The KVM_IRQFD_FLAG_RESAMPLE is only necessary on assignment |
| 2340 | and need not be specified with KVM_IRQFD_FLAG_DEASSIGN. |
| 2341 | |
Eric Auger | 174178f | 2015-03-04 11:14:36 +0100 | [diff] [blame] | 2342 | On ARM/ARM64, the gsi field in the kvm_irqfd struct specifies the Shared |
| 2343 | Peripheral Interrupt (SPI) index, such that the GIC interrupt ID is |
| 2344 | given by gsi + 32. |
| 2345 | |
Linus Torvalds | 5fecc9d | 2012-07-24 12:01:20 -0700 | [diff] [blame] | 2346 | 4.76 KVM_PPC_ALLOCATE_HTAB |
Paul Mackerras | 32fad28 | 2012-05-04 02:32:53 +0000 | [diff] [blame] | 2347 | |
| 2348 | Capability: KVM_CAP_PPC_ALLOC_HTAB |
| 2349 | Architectures: powerpc |
| 2350 | Type: vm ioctl |
| 2351 | Parameters: Pointer to u32 containing hash table order (in/out) |
| 2352 | Returns: 0 on success, -1 on error |
| 2353 | |
| 2354 | This requests the host kernel to allocate an MMU hash table for a |
| 2355 | guest using the PAPR paravirtualization interface. This only does |
| 2356 | anything if the kernel is configured to use the Book 3S HV style of |
| 2357 | virtualization. Otherwise the capability doesn't exist and the ioctl |
| 2358 | returns an ENOTTY error. The rest of this description assumes Book 3S |
| 2359 | HV. |
| 2360 | |
| 2361 | There must be no vcpus running when this ioctl is called; if there |
| 2362 | are, it will do nothing and return an EBUSY error. |
| 2363 | |
| 2364 | The parameter is a pointer to a 32-bit unsigned integer variable |
| 2365 | containing the order (log base 2) of the desired size of the hash |
| 2366 | table, which must be between 18 and 46. On successful return from the |
| 2367 | ioctl, it will have been updated with the order of the hash table that |
| 2368 | was allocated. |
| 2369 | |
| 2370 | If no hash table has been allocated when any vcpu is asked to run |
| 2371 | (with the KVM_RUN ioctl), the host kernel will allocate a |
| 2372 | default-sized hash table (16 MB). |
| 2373 | |
| 2374 | If this ioctl is called when a hash table has already been allocated, |
| 2375 | the kernel will clear out the existing hash table (zero all HPTEs) and |
| 2376 | return the hash table order in the parameter. (If the guest is using |
| 2377 | the virtualized real-mode area (VRMA) facility, the kernel will |
| 2378 | re-create the VMRA HPTEs on the next KVM_RUN of any vcpu.) |
| 2379 | |
Cornelia Huck | 416ad65 | 2012-10-02 16:25:37 +0200 | [diff] [blame] | 2380 | 4.77 KVM_S390_INTERRUPT |
| 2381 | |
| 2382 | Capability: basic |
| 2383 | Architectures: s390 |
| 2384 | Type: vm ioctl, vcpu ioctl |
| 2385 | Parameters: struct kvm_s390_interrupt (in) |
| 2386 | Returns: 0 on success, -1 on error |
| 2387 | |
| 2388 | Allows to inject an interrupt to the guest. Interrupts can be floating |
| 2389 | (vm ioctl) or per cpu (vcpu ioctl), depending on the interrupt type. |
| 2390 | |
| 2391 | Interrupt parameters are passed via kvm_s390_interrupt: |
| 2392 | |
| 2393 | struct kvm_s390_interrupt { |
| 2394 | __u32 type; |
| 2395 | __u32 parm; |
| 2396 | __u64 parm64; |
| 2397 | }; |
| 2398 | |
| 2399 | type can be one of the following: |
| 2400 | |
David Hildenbrand | 2822545 | 2014-10-15 16:48:16 +0200 | [diff] [blame] | 2401 | KVM_S390_SIGP_STOP (vcpu) - sigp stop; optional flags in parm |
Cornelia Huck | 416ad65 | 2012-10-02 16:25:37 +0200 | [diff] [blame] | 2402 | KVM_S390_PROGRAM_INT (vcpu) - program check; code in parm |
| 2403 | KVM_S390_SIGP_SET_PREFIX (vcpu) - sigp set prefix; prefix address in parm |
| 2404 | KVM_S390_RESTART (vcpu) - restart |
Thomas Huth | e029ae5 | 2014-03-26 16:11:54 +0100 | [diff] [blame] | 2405 | KVM_S390_INT_CLOCK_COMP (vcpu) - clock comparator interrupt |
| 2406 | KVM_S390_INT_CPU_TIMER (vcpu) - CPU timer interrupt |
Cornelia Huck | 416ad65 | 2012-10-02 16:25:37 +0200 | [diff] [blame] | 2407 | KVM_S390_INT_VIRTIO (vm) - virtio external interrupt; external interrupt |
| 2408 | parameters in parm and parm64 |
| 2409 | KVM_S390_INT_SERVICE (vm) - sclp external interrupt; sclp parameter in parm |
| 2410 | KVM_S390_INT_EMERGENCY (vcpu) - sigp emergency; source cpu in parm |
| 2411 | KVM_S390_INT_EXTERNAL_CALL (vcpu) - sigp external call; source cpu in parm |
Cornelia Huck | d8346b7 | 2012-12-20 15:32:08 +0100 | [diff] [blame] | 2412 | KVM_S390_INT_IO(ai,cssid,ssid,schid) (vm) - compound value to indicate an |
| 2413 | I/O interrupt (ai - adapter interrupt; cssid,ssid,schid - subchannel); |
| 2414 | I/O interruption parameters in parm (subchannel) and parm64 (intparm, |
| 2415 | interruption subclass) |
Cornelia Huck | 48a3e95 | 2012-12-20 15:32:09 +0100 | [diff] [blame] | 2416 | KVM_S390_MCHK (vm, vcpu) - machine check interrupt; cr 14 bits in parm, |
| 2417 | machine check interrupt code in parm64 (note that |
| 2418 | machine checks needing further payload are not |
| 2419 | supported by this ioctl) |
Cornelia Huck | 416ad65 | 2012-10-02 16:25:37 +0200 | [diff] [blame] | 2420 | |
| 2421 | Note that the vcpu ioctl is asynchronous to vcpu execution. |
| 2422 | |
Paul Mackerras | a293292 | 2012-11-19 22:57:20 +0000 | [diff] [blame] | 2423 | 4.78 KVM_PPC_GET_HTAB_FD |
| 2424 | |
| 2425 | Capability: KVM_CAP_PPC_HTAB_FD |
| 2426 | Architectures: powerpc |
| 2427 | Type: vm ioctl |
| 2428 | Parameters: Pointer to struct kvm_get_htab_fd (in) |
| 2429 | Returns: file descriptor number (>= 0) on success, -1 on error |
| 2430 | |
| 2431 | This returns a file descriptor that can be used either to read out the |
| 2432 | entries in the guest's hashed page table (HPT), or to write entries to |
| 2433 | initialize the HPT. The returned fd can only be written to if the |
| 2434 | KVM_GET_HTAB_WRITE bit is set in the flags field of the argument, and |
| 2435 | can only be read if that bit is clear. The argument struct looks like |
| 2436 | this: |
| 2437 | |
| 2438 | /* For KVM_PPC_GET_HTAB_FD */ |
| 2439 | struct kvm_get_htab_fd { |
| 2440 | __u64 flags; |
| 2441 | __u64 start_index; |
| 2442 | __u64 reserved[2]; |
| 2443 | }; |
| 2444 | |
| 2445 | /* Values for kvm_get_htab_fd.flags */ |
| 2446 | #define KVM_GET_HTAB_BOLTED_ONLY ((__u64)0x1) |
| 2447 | #define KVM_GET_HTAB_WRITE ((__u64)0x2) |
| 2448 | |
| 2449 | The `start_index' field gives the index in the HPT of the entry at |
| 2450 | which to start reading. It is ignored when writing. |
| 2451 | |
| 2452 | Reads on the fd will initially supply information about all |
| 2453 | "interesting" HPT entries. Interesting entries are those with the |
| 2454 | bolted bit set, if the KVM_GET_HTAB_BOLTED_ONLY bit is set, otherwise |
| 2455 | all entries. When the end of the HPT is reached, the read() will |
| 2456 | return. If read() is called again on the fd, it will start again from |
| 2457 | the beginning of the HPT, but will only return HPT entries that have |
| 2458 | changed since they were last read. |
| 2459 | |
| 2460 | Data read or written is structured as a header (8 bytes) followed by a |
| 2461 | series of valid HPT entries (16 bytes) each. The header indicates how |
| 2462 | many valid HPT entries there are and how many invalid entries follow |
| 2463 | the valid entries. The invalid entries are not represented explicitly |
| 2464 | in the stream. The header format is: |
| 2465 | |
| 2466 | struct kvm_get_htab_header { |
| 2467 | __u32 index; |
| 2468 | __u16 n_valid; |
| 2469 | __u16 n_invalid; |
| 2470 | }; |
| 2471 | |
| 2472 | Writes to the fd create HPT entries starting at the index given in the |
| 2473 | header; first `n_valid' valid entries with contents from the data |
| 2474 | written, then `n_invalid' invalid entries, invalidating any previously |
| 2475 | valid entries found. |
| 2476 | |
Scott Wood | 852b6d5 | 2013-04-12 14:08:42 +0000 | [diff] [blame] | 2477 | 4.79 KVM_CREATE_DEVICE |
| 2478 | |
| 2479 | Capability: KVM_CAP_DEVICE_CTRL |
| 2480 | Type: vm ioctl |
| 2481 | Parameters: struct kvm_create_device (in/out) |
| 2482 | Returns: 0 on success, -1 on error |
| 2483 | Errors: |
| 2484 | ENODEV: The device type is unknown or unsupported |
| 2485 | EEXIST: Device already created, and this type of device may not |
| 2486 | be instantiated multiple times |
| 2487 | |
| 2488 | Other error conditions may be defined by individual device types or |
| 2489 | have their standard meanings. |
| 2490 | |
| 2491 | Creates an emulated device in the kernel. The file descriptor returned |
| 2492 | in fd can be used with KVM_SET/GET/HAS_DEVICE_ATTR. |
| 2493 | |
| 2494 | If the KVM_CREATE_DEVICE_TEST flag is set, only test whether the |
| 2495 | device type is supported (not necessarily whether it can be created |
| 2496 | in the current vm). |
| 2497 | |
| 2498 | Individual devices should not define flags. Attributes should be used |
| 2499 | for specifying any behavior that is not implied by the device type |
| 2500 | number. |
| 2501 | |
| 2502 | struct kvm_create_device { |
| 2503 | __u32 type; /* in: KVM_DEV_TYPE_xxx */ |
| 2504 | __u32 fd; /* out: device handle */ |
| 2505 | __u32 flags; /* in: KVM_CREATE_DEVICE_xxx */ |
| 2506 | }; |
| 2507 | |
| 2508 | 4.80 KVM_SET_DEVICE_ATTR/KVM_GET_DEVICE_ATTR |
| 2509 | |
Dominik Dingel | f206165 | 2014-04-09 13:13:00 +0200 | [diff] [blame] | 2510 | Capability: KVM_CAP_DEVICE_CTRL, KVM_CAP_VM_ATTRIBUTES for vm device |
| 2511 | Type: device ioctl, vm ioctl |
Scott Wood | 852b6d5 | 2013-04-12 14:08:42 +0000 | [diff] [blame] | 2512 | Parameters: struct kvm_device_attr |
| 2513 | Returns: 0 on success, -1 on error |
| 2514 | Errors: |
| 2515 | ENXIO: The group or attribute is unknown/unsupported for this device |
| 2516 | EPERM: The attribute cannot (currently) be accessed this way |
| 2517 | (e.g. read-only attribute, or attribute that only makes |
| 2518 | sense when the device is in a different state) |
| 2519 | |
| 2520 | Other error conditions may be defined by individual device types. |
| 2521 | |
| 2522 | Gets/sets a specified piece of device configuration and/or state. The |
| 2523 | semantics are device-specific. See individual device documentation in |
| 2524 | the "devices" directory. As with ONE_REG, the size of the data |
| 2525 | transferred is defined by the particular attribute. |
| 2526 | |
| 2527 | struct kvm_device_attr { |
| 2528 | __u32 flags; /* no flags currently defined */ |
| 2529 | __u32 group; /* device-defined */ |
| 2530 | __u64 attr; /* group-defined */ |
| 2531 | __u64 addr; /* userspace address of attr data */ |
| 2532 | }; |
| 2533 | |
| 2534 | 4.81 KVM_HAS_DEVICE_ATTR |
| 2535 | |
Dominik Dingel | f206165 | 2014-04-09 13:13:00 +0200 | [diff] [blame] | 2536 | Capability: KVM_CAP_DEVICE_CTRL, KVM_CAP_VM_ATTRIBUTES for vm device |
| 2537 | Type: device ioctl, vm ioctl |
Scott Wood | 852b6d5 | 2013-04-12 14:08:42 +0000 | [diff] [blame] | 2538 | Parameters: struct kvm_device_attr |
| 2539 | Returns: 0 on success, -1 on error |
| 2540 | Errors: |
| 2541 | ENXIO: The group or attribute is unknown/unsupported for this device |
| 2542 | |
| 2543 | Tests whether a device supports a particular attribute. A successful |
| 2544 | return indicates the attribute is implemented. It does not necessarily |
| 2545 | indicate that the attribute can be read or written in the device's |
| 2546 | current state. "addr" is ignored. |
Alex Williamson | f36992e | 2012-06-29 09:56:16 -0600 | [diff] [blame] | 2547 | |
Alexey Kardashevskiy | d8968f1 | 2013-06-19 11:42:07 +1000 | [diff] [blame] | 2548 | 4.82 KVM_ARM_VCPU_INIT |
Christoffer Dall | 749cf76c | 2013-01-20 18:28:06 -0500 | [diff] [blame] | 2549 | |
| 2550 | Capability: basic |
Marc Zyngier | 379e04c | 2013-04-02 17:46:31 +0100 | [diff] [blame] | 2551 | Architectures: arm, arm64 |
Christoffer Dall | 749cf76c | 2013-01-20 18:28:06 -0500 | [diff] [blame] | 2552 | Type: vcpu ioctl |
Anup Patel | beb11fc | 2013-12-12 21:42:24 +0530 | [diff] [blame] | 2553 | Parameters: struct kvm_vcpu_init (in) |
Christoffer Dall | 749cf76c | 2013-01-20 18:28:06 -0500 | [diff] [blame] | 2554 | Returns: 0 on success; -1 on error |
| 2555 | Errors: |
| 2556 | Â EINVAL: Â Â Â the target is unknown, or the combination of features is invalid. |
| 2557 | Â ENOENT: Â Â Â a features bit specified is unknown. |
| 2558 | |
| 2559 | This tells KVM what type of CPU to present to the guest, and what |
| 2560 | optional features it should have. Â This will cause a reset of the cpu |
| 2561 | registers to their initial values. Â If this is not called, KVM_RUN will |
| 2562 | return ENOEXEC for that vcpu. |
| 2563 | |
| 2564 | Note that because some registers reflect machine topology, all vcpus |
| 2565 | should be created before this ioctl is invoked. |
| 2566 | |
Christoffer Dall | f7fa034d | 2014-10-16 16:40:53 +0200 | [diff] [blame] | 2567 | Userspace can call this function multiple times for a given vcpu, including |
| 2568 | after the vcpu has been run. This will reset the vcpu to its initial |
| 2569 | state. All calls to this function after the initial call must use the same |
| 2570 | target and same set of feature flags, otherwise EINVAL will be returned. |
| 2571 | |
Marc Zyngier | aa024c2f | 2013-01-20 18:28:13 -0500 | [diff] [blame] | 2572 | Possible features: |
| 2573 | - KVM_ARM_VCPU_POWER_OFF: Starts the CPU in a power-off state. |
Christoffer Dall | 3ad8b3d | 2014-10-16 16:14:43 +0200 | [diff] [blame] | 2574 | Depends on KVM_CAP_ARM_PSCI. If not set, the CPU will be powered on |
| 2575 | and execute guest code when KVM_RUN is called. |
Marc Zyngier | 379e04c | 2013-04-02 17:46:31 +0100 | [diff] [blame] | 2576 | - KVM_ARM_VCPU_EL1_32BIT: Starts the CPU in a 32bit mode. |
| 2577 | Depends on KVM_CAP_ARM_EL1_32BIT (arm64 only). |
Anup Patel | 50bb0c9 | 2014-04-29 11:24:17 +0530 | [diff] [blame] | 2578 | - KVM_ARM_VCPU_PSCI_0_2: Emulate PSCI v0.2 for the CPU. |
| 2579 | Depends on KVM_CAP_ARM_PSCI_0_2. |
Marc Zyngier | aa024c2f | 2013-01-20 18:28:13 -0500 | [diff] [blame] | 2580 | |
Christoffer Dall | 749cf76c | 2013-01-20 18:28:06 -0500 | [diff] [blame] | 2581 | |
Anup Patel | 740edfc | 2013-09-30 14:20:08 +0530 | [diff] [blame] | 2582 | 4.83 KVM_ARM_PREFERRED_TARGET |
| 2583 | |
| 2584 | Capability: basic |
| 2585 | Architectures: arm, arm64 |
| 2586 | Type: vm ioctl |
| 2587 | Parameters: struct struct kvm_vcpu_init (out) |
| 2588 | Returns: 0 on success; -1 on error |
| 2589 | Errors: |
Christoffer Dall | a7265fb | 2013-10-15 17:43:00 -0700 | [diff] [blame] | 2590 | ENODEV: no preferred target available for the host |
Anup Patel | 740edfc | 2013-09-30 14:20:08 +0530 | [diff] [blame] | 2591 | |
| 2592 | This queries KVM for preferred CPU target type which can be emulated |
| 2593 | by KVM on underlying host. |
| 2594 | |
| 2595 | The ioctl returns struct kvm_vcpu_init instance containing information |
| 2596 | about preferred CPU target type and recommended features for it. The |
| 2597 | kvm_vcpu_init->features bitmap returned will have feature bits set if |
| 2598 | the preferred target recommends setting these features, but this is |
| 2599 | not mandatory. |
| 2600 | |
| 2601 | The information returned by this ioctl can be used to prepare an instance |
| 2602 | of struct kvm_vcpu_init for KVM_ARM_VCPU_INIT ioctl which will result in |
| 2603 | in VCPU matching underlying host. |
| 2604 | |
| 2605 | |
| 2606 | 4.84 KVM_GET_REG_LIST |
Christoffer Dall | 749cf76c | 2013-01-20 18:28:06 -0500 | [diff] [blame] | 2607 | |
| 2608 | Capability: basic |
James Hogan | c2d2c21 | 2014-07-04 15:11:35 +0100 | [diff] [blame] | 2609 | Architectures: arm, arm64, mips |
Christoffer Dall | 749cf76c | 2013-01-20 18:28:06 -0500 | [diff] [blame] | 2610 | Type: vcpu ioctl |
| 2611 | Parameters: struct kvm_reg_list (in/out) |
| 2612 | Returns: 0 on success; -1 on error |
| 2613 | Errors: |
| 2614 | Â E2BIG: Â Â Â Â the reg index list is too big to fit in the array specified by |
| 2615 | Â Â Â Â Â Â Â Â Â Â Â Â the user (the number required will be written into n). |
| 2616 | |
| 2617 | struct kvm_reg_list { |
| 2618 | __u64 n; /* number of registers in reg[] */ |
| 2619 | __u64 reg[0]; |
| 2620 | }; |
| 2621 | |
| 2622 | This ioctl returns the guest registers that are supported for the |
| 2623 | KVM_GET_ONE_REG/KVM_SET_ONE_REG calls. |
| 2624 | |
Christoffer Dall | ce01e4e | 2013-09-23 14:55:56 -0700 | [diff] [blame] | 2625 | |
| 2626 | 4.85 KVM_ARM_SET_DEVICE_ADDR (deprecated) |
Christoffer Dall | 3401d546 | 2013-01-23 13:18:04 -0500 | [diff] [blame] | 2627 | |
| 2628 | Capability: KVM_CAP_ARM_SET_DEVICE_ADDR |
Marc Zyngier | 379e04c | 2013-04-02 17:46:31 +0100 | [diff] [blame] | 2629 | Architectures: arm, arm64 |
Christoffer Dall | 3401d546 | 2013-01-23 13:18:04 -0500 | [diff] [blame] | 2630 | Type: vm ioctl |
| 2631 | Parameters: struct kvm_arm_device_address (in) |
| 2632 | Returns: 0 on success, -1 on error |
| 2633 | Errors: |
| 2634 | ENODEV: The device id is unknown |
| 2635 | ENXIO: Device not supported on current system |
| 2636 | EEXIST: Address already set |
| 2637 | E2BIG: Address outside guest physical address space |
Christoffer Dall | 330690c | 2013-01-21 19:36:13 -0500 | [diff] [blame] | 2638 | EBUSY: Address overlaps with other device range |
Christoffer Dall | 3401d546 | 2013-01-23 13:18:04 -0500 | [diff] [blame] | 2639 | |
| 2640 | struct kvm_arm_device_addr { |
| 2641 | __u64 id; |
| 2642 | __u64 addr; |
| 2643 | }; |
| 2644 | |
| 2645 | Specify a device address in the guest's physical address space where guests |
| 2646 | can access emulated or directly exposed devices, which the host kernel needs |
| 2647 | to know about. The id field is an architecture specific identifier for a |
| 2648 | specific device. |
| 2649 | |
Marc Zyngier | 379e04c | 2013-04-02 17:46:31 +0100 | [diff] [blame] | 2650 | ARM/arm64 divides the id field into two parts, a device id and an |
| 2651 | address type id specific to the individual device. |
Christoffer Dall | 3401d546 | 2013-01-23 13:18:04 -0500 | [diff] [blame] | 2652 | |
| 2653 | Â bits: | 63 ... 32 | 31 ... 16 | 15 ... 0 | |
| 2654 | field: | 0x00000000 | device id | addr type id | |
| 2655 | |
Marc Zyngier | 379e04c | 2013-04-02 17:46:31 +0100 | [diff] [blame] | 2656 | ARM/arm64 currently only require this when using the in-kernel GIC |
| 2657 | support for the hardware VGIC features, using KVM_ARM_DEVICE_VGIC_V2 |
| 2658 | as the device id. When setting the base address for the guest's |
| 2659 | mapping of the VGIC virtual CPU and distributor interface, the ioctl |
| 2660 | must be called after calling KVM_CREATE_IRQCHIP, but before calling |
| 2661 | KVM_RUN on any of the VCPUs. Calling this ioctl twice for any of the |
| 2662 | base addresses will return -EEXIST. |
Christoffer Dall | 3401d546 | 2013-01-23 13:18:04 -0500 | [diff] [blame] | 2663 | |
Christoffer Dall | ce01e4e | 2013-09-23 14:55:56 -0700 | [diff] [blame] | 2664 | Note, this IOCTL is deprecated and the more flexible SET/GET_DEVICE_ATTR API |
| 2665 | should be used instead. |
| 2666 | |
| 2667 | |
Anup Patel | 740edfc | 2013-09-30 14:20:08 +0530 | [diff] [blame] | 2668 | 4.86 KVM_PPC_RTAS_DEFINE_TOKEN |
Michael Ellerman | 8e591cb | 2013-04-17 20:30:00 +0000 | [diff] [blame] | 2669 | |
| 2670 | Capability: KVM_CAP_PPC_RTAS |
| 2671 | Architectures: ppc |
| 2672 | Type: vm ioctl |
| 2673 | Parameters: struct kvm_rtas_token_args |
| 2674 | Returns: 0 on success, -1 on error |
| 2675 | |
| 2676 | Defines a token value for a RTAS (Run Time Abstraction Services) |
| 2677 | service in order to allow it to be handled in the kernel. The |
| 2678 | argument struct gives the name of the service, which must be the name |
| 2679 | of a service that has a kernel-side implementation. If the token |
| 2680 | value is non-zero, it will be associated with that service, and |
| 2681 | subsequent RTAS calls by the guest specifying that token will be |
| 2682 | handled by the kernel. If the token value is 0, then any token |
| 2683 | associated with the service will be forgotten, and subsequent RTAS |
| 2684 | calls by the guest for that service will be passed to userspace to be |
| 2685 | handled. |
| 2686 | |
Alex Bennée | 4bd9d34 | 2014-09-09 17:27:18 +0100 | [diff] [blame] | 2687 | 4.87 KVM_SET_GUEST_DEBUG |
| 2688 | |
| 2689 | Capability: KVM_CAP_SET_GUEST_DEBUG |
Alex Bennée | 0e6f07f | 2015-07-07 17:29:55 +0100 | [diff] [blame] | 2690 | Architectures: x86, s390, ppc, arm64 |
Alex Bennée | 4bd9d34 | 2014-09-09 17:27:18 +0100 | [diff] [blame] | 2691 | Type: vcpu ioctl |
| 2692 | Parameters: struct kvm_guest_debug (in) |
| 2693 | Returns: 0 on success; -1 on error |
| 2694 | |
| 2695 | struct kvm_guest_debug { |
| 2696 | __u32 control; |
| 2697 | __u32 pad; |
| 2698 | struct kvm_guest_debug_arch arch; |
| 2699 | }; |
| 2700 | |
| 2701 | Set up the processor specific debug registers and configure vcpu for |
| 2702 | handling guest debug events. There are two parts to the structure, the |
| 2703 | first a control bitfield indicates the type of debug events to handle |
| 2704 | when running. Common control bits are: |
| 2705 | |
| 2706 | - KVM_GUESTDBG_ENABLE: guest debugging is enabled |
| 2707 | - KVM_GUESTDBG_SINGLESTEP: the next run should single-step |
| 2708 | |
| 2709 | The top 16 bits of the control field are architecture specific control |
| 2710 | flags which can include the following: |
| 2711 | |
Alex Bennée | 4bd611c | 2015-07-07 17:29:57 +0100 | [diff] [blame] | 2712 | - KVM_GUESTDBG_USE_SW_BP: using software breakpoints [x86, arm64] |
Alex Bennée | 834bf88 | 2015-07-07 17:30:02 +0100 | [diff] [blame] | 2713 | - KVM_GUESTDBG_USE_HW_BP: using hardware breakpoints [x86, s390, arm64] |
Alex Bennée | 4bd9d34 | 2014-09-09 17:27:18 +0100 | [diff] [blame] | 2714 | - KVM_GUESTDBG_INJECT_DB: inject DB type exception [x86] |
| 2715 | - KVM_GUESTDBG_INJECT_BP: inject BP type exception [x86] |
| 2716 | - KVM_GUESTDBG_EXIT_PENDING: trigger an immediate guest exit [s390] |
| 2717 | |
| 2718 | For example KVM_GUESTDBG_USE_SW_BP indicates that software breakpoints |
| 2719 | are enabled in memory so we need to ensure breakpoint exceptions are |
| 2720 | correctly trapped and the KVM run loop exits at the breakpoint and not |
| 2721 | running off into the normal guest vector. For KVM_GUESTDBG_USE_HW_BP |
| 2722 | we need to ensure the guest vCPUs architecture specific registers are |
| 2723 | updated to the correct (supplied) values. |
| 2724 | |
| 2725 | The second part of the structure is architecture specific and |
| 2726 | typically contains a set of debug registers. |
| 2727 | |
Alex Bennée | 834bf88 | 2015-07-07 17:30:02 +0100 | [diff] [blame] | 2728 | For arm64 the number of debug registers is implementation defined and |
| 2729 | can be determined by querying the KVM_CAP_GUEST_DEBUG_HW_BPS and |
| 2730 | KVM_CAP_GUEST_DEBUG_HW_WPS capabilities which return a positive number |
| 2731 | indicating the number of supported registers. |
| 2732 | |
Alex Bennée | 4bd9d34 | 2014-09-09 17:27:18 +0100 | [diff] [blame] | 2733 | When debug events exit the main run loop with the reason |
| 2734 | KVM_EXIT_DEBUG with the kvm_debug_exit_arch part of the kvm_run |
| 2735 | structure containing architecture specific debug information. |
Christoffer Dall | 3401d546 | 2013-01-23 13:18:04 -0500 | [diff] [blame] | 2736 | |
Alex Bennée | 209cf19 | 2014-09-09 17:27:19 +0100 | [diff] [blame] | 2737 | 4.88 KVM_GET_EMULATED_CPUID |
| 2738 | |
| 2739 | Capability: KVM_CAP_EXT_EMUL_CPUID |
| 2740 | Architectures: x86 |
| 2741 | Type: system ioctl |
| 2742 | Parameters: struct kvm_cpuid2 (in/out) |
| 2743 | Returns: 0 on success, -1 on error |
| 2744 | |
| 2745 | struct kvm_cpuid2 { |
| 2746 | __u32 nent; |
| 2747 | __u32 flags; |
| 2748 | struct kvm_cpuid_entry2 entries[0]; |
| 2749 | }; |
| 2750 | |
| 2751 | The member 'flags' is used for passing flags from userspace. |
| 2752 | |
| 2753 | #define KVM_CPUID_FLAG_SIGNIFCANT_INDEX BIT(0) |
| 2754 | #define KVM_CPUID_FLAG_STATEFUL_FUNC BIT(1) |
| 2755 | #define KVM_CPUID_FLAG_STATE_READ_NEXT BIT(2) |
| 2756 | |
| 2757 | struct kvm_cpuid_entry2 { |
| 2758 | __u32 function; |
| 2759 | __u32 index; |
| 2760 | __u32 flags; |
| 2761 | __u32 eax; |
| 2762 | __u32 ebx; |
| 2763 | __u32 ecx; |
| 2764 | __u32 edx; |
| 2765 | __u32 padding[3]; |
| 2766 | }; |
| 2767 | |
| 2768 | This ioctl returns x86 cpuid features which are emulated by |
| 2769 | kvm.Userspace can use the information returned by this ioctl to query |
| 2770 | which features are emulated by kvm instead of being present natively. |
| 2771 | |
| 2772 | Userspace invokes KVM_GET_EMULATED_CPUID by passing a kvm_cpuid2 |
| 2773 | structure with the 'nent' field indicating the number of entries in |
| 2774 | the variable-size array 'entries'. If the number of entries is too low |
| 2775 | to describe the cpu capabilities, an error (E2BIG) is returned. If the |
| 2776 | number is too high, the 'nent' field is adjusted and an error (ENOMEM) |
| 2777 | is returned. If the number is just right, the 'nent' field is adjusted |
| 2778 | to the number of valid entries in the 'entries' array, which is then |
| 2779 | filled. |
| 2780 | |
| 2781 | The entries returned are the set CPUID bits of the respective features |
| 2782 | which kvm emulates, as returned by the CPUID instruction, with unknown |
| 2783 | or unsupported feature bits cleared. |
| 2784 | |
| 2785 | Features like x2apic, for example, may not be present in the host cpu |
| 2786 | but are exposed by kvm in KVM_GET_SUPPORTED_CPUID because they can be |
| 2787 | emulated efficiently and thus not included here. |
| 2788 | |
| 2789 | The fields in each entry are defined as follows: |
| 2790 | |
| 2791 | function: the eax value used to obtain the entry |
| 2792 | index: the ecx value used to obtain the entry (for entries that are |
| 2793 | affected by ecx) |
| 2794 | flags: an OR of zero or more of the following: |
| 2795 | KVM_CPUID_FLAG_SIGNIFCANT_INDEX: |
| 2796 | if the index field is valid |
| 2797 | KVM_CPUID_FLAG_STATEFUL_FUNC: |
| 2798 | if cpuid for this function returns different values for successive |
| 2799 | invocations; there will be several entries with the same function, |
| 2800 | all with this flag set |
| 2801 | KVM_CPUID_FLAG_STATE_READ_NEXT: |
| 2802 | for KVM_CPUID_FLAG_STATEFUL_FUNC entries, set if this entry is |
| 2803 | the first entry to be read by a cpu |
| 2804 | eax, ebx, ecx, edx: the values returned by the cpuid instruction for |
| 2805 | this function/index combination |
| 2806 | |
Thomas Huth | 41408c2 | 2015-02-06 15:01:21 +0100 | [diff] [blame] | 2807 | 4.89 KVM_S390_MEM_OP |
| 2808 | |
| 2809 | Capability: KVM_CAP_S390_MEM_OP |
| 2810 | Architectures: s390 |
| 2811 | Type: vcpu ioctl |
| 2812 | Parameters: struct kvm_s390_mem_op (in) |
| 2813 | Returns: = 0 on success, |
| 2814 | < 0 on generic error (e.g. -EFAULT or -ENOMEM), |
| 2815 | > 0 if an exception occurred while walking the page tables |
| 2816 | |
Masanari Iida | 5d4f6f3 | 2015-10-04 00:46:21 +0900 | [diff] [blame] | 2817 | Read or write data from/to the logical (virtual) memory of a VCPU. |
Thomas Huth | 41408c2 | 2015-02-06 15:01:21 +0100 | [diff] [blame] | 2818 | |
| 2819 | Parameters are specified via the following structure: |
| 2820 | |
| 2821 | struct kvm_s390_mem_op { |
| 2822 | __u64 gaddr; /* the guest address */ |
| 2823 | __u64 flags; /* flags */ |
| 2824 | __u32 size; /* amount of bytes */ |
| 2825 | __u32 op; /* type of operation */ |
| 2826 | __u64 buf; /* buffer in userspace */ |
| 2827 | __u8 ar; /* the access register number */ |
| 2828 | __u8 reserved[31]; /* should be set to 0 */ |
| 2829 | }; |
| 2830 | |
| 2831 | The type of operation is specified in the "op" field. It is either |
| 2832 | KVM_S390_MEMOP_LOGICAL_READ for reading from logical memory space or |
| 2833 | KVM_S390_MEMOP_LOGICAL_WRITE for writing to logical memory space. The |
| 2834 | KVM_S390_MEMOP_F_CHECK_ONLY flag can be set in the "flags" field to check |
| 2835 | whether the corresponding memory access would create an access exception |
| 2836 | (without touching the data in the memory at the destination). In case an |
| 2837 | access exception occurred while walking the MMU tables of the guest, the |
| 2838 | ioctl returns a positive error number to indicate the type of exception. |
| 2839 | This exception is also raised directly at the corresponding VCPU if the |
| 2840 | flag KVM_S390_MEMOP_F_INJECT_EXCEPTION is set in the "flags" field. |
| 2841 | |
| 2842 | The start address of the memory region has to be specified in the "gaddr" |
| 2843 | field, and the length of the region in the "size" field. "buf" is the buffer |
| 2844 | supplied by the userspace application where the read data should be written |
| 2845 | to for KVM_S390_MEMOP_LOGICAL_READ, or where the data that should be written |
| 2846 | is stored for a KVM_S390_MEMOP_LOGICAL_WRITE. "buf" is unused and can be NULL |
| 2847 | when KVM_S390_MEMOP_F_CHECK_ONLY is specified. "ar" designates the access |
| 2848 | register number to be used. |
| 2849 | |
| 2850 | The "reserved" field is meant for future extensions. It is not used by |
| 2851 | KVM with the currently defined set of flags. |
| 2852 | |
Jason J. Herne | 30ee2a9 | 2014-09-23 09:23:01 -0400 | [diff] [blame] | 2853 | 4.90 KVM_S390_GET_SKEYS |
| 2854 | |
| 2855 | Capability: KVM_CAP_S390_SKEYS |
| 2856 | Architectures: s390 |
| 2857 | Type: vm ioctl |
| 2858 | Parameters: struct kvm_s390_skeys |
| 2859 | Returns: 0 on success, KVM_S390_GET_KEYS_NONE if guest is not using storage |
| 2860 | keys, negative value on error |
| 2861 | |
| 2862 | This ioctl is used to get guest storage key values on the s390 |
| 2863 | architecture. The ioctl takes parameters via the kvm_s390_skeys struct. |
| 2864 | |
| 2865 | struct kvm_s390_skeys { |
| 2866 | __u64 start_gfn; |
| 2867 | __u64 count; |
| 2868 | __u64 skeydata_addr; |
| 2869 | __u32 flags; |
| 2870 | __u32 reserved[9]; |
| 2871 | }; |
| 2872 | |
| 2873 | The start_gfn field is the number of the first guest frame whose storage keys |
| 2874 | you want to get. |
| 2875 | |
| 2876 | The count field is the number of consecutive frames (starting from start_gfn) |
| 2877 | whose storage keys to get. The count field must be at least 1 and the maximum |
| 2878 | allowed value is defined as KVM_S390_SKEYS_ALLOC_MAX. Values outside this range |
| 2879 | will cause the ioctl to return -EINVAL. |
| 2880 | |
| 2881 | The skeydata_addr field is the address to a buffer large enough to hold count |
| 2882 | bytes. This buffer will be filled with storage key data by the ioctl. |
| 2883 | |
| 2884 | 4.91 KVM_S390_SET_SKEYS |
| 2885 | |
| 2886 | Capability: KVM_CAP_S390_SKEYS |
| 2887 | Architectures: s390 |
| 2888 | Type: vm ioctl |
| 2889 | Parameters: struct kvm_s390_skeys |
| 2890 | Returns: 0 on success, negative value on error |
| 2891 | |
| 2892 | This ioctl is used to set guest storage key values on the s390 |
| 2893 | architecture. The ioctl takes parameters via the kvm_s390_skeys struct. |
| 2894 | See section on KVM_S390_GET_SKEYS for struct definition. |
| 2895 | |
| 2896 | The start_gfn field is the number of the first guest frame whose storage keys |
| 2897 | you want to set. |
| 2898 | |
| 2899 | The count field is the number of consecutive frames (starting from start_gfn) |
| 2900 | whose storage keys to get. The count field must be at least 1 and the maximum |
| 2901 | allowed value is defined as KVM_S390_SKEYS_ALLOC_MAX. Values outside this range |
| 2902 | will cause the ioctl to return -EINVAL. |
| 2903 | |
| 2904 | The skeydata_addr field is the address to a buffer containing count bytes of |
| 2905 | storage keys. Each byte in the buffer will be set as the storage key for a |
| 2906 | single frame starting at start_gfn for count frames. |
| 2907 | |
| 2908 | Note: If any architecturally invalid key value is found in the given data then |
| 2909 | the ioctl will return -EINVAL. |
| 2910 | |
Jens Freimann | 47b43c5 | 2014-11-11 20:57:06 +0100 | [diff] [blame] | 2911 | 4.92 KVM_S390_IRQ |
| 2912 | |
| 2913 | Capability: KVM_CAP_S390_INJECT_IRQ |
| 2914 | Architectures: s390 |
| 2915 | Type: vcpu ioctl |
| 2916 | Parameters: struct kvm_s390_irq (in) |
| 2917 | Returns: 0 on success, -1 on error |
| 2918 | Errors: |
| 2919 | EINVAL: interrupt type is invalid |
| 2920 | type is KVM_S390_SIGP_STOP and flag parameter is invalid value |
| 2921 | type is KVM_S390_INT_EXTERNAL_CALL and code is bigger |
| 2922 | than the maximum of VCPUs |
| 2923 | EBUSY: type is KVM_S390_SIGP_SET_PREFIX and vcpu is not stopped |
| 2924 | type is KVM_S390_SIGP_STOP and a stop irq is already pending |
| 2925 | type is KVM_S390_INT_EXTERNAL_CALL and an external call interrupt |
| 2926 | is already pending |
| 2927 | |
| 2928 | Allows to inject an interrupt to the guest. |
| 2929 | |
| 2930 | Using struct kvm_s390_irq as a parameter allows |
| 2931 | to inject additional payload which is not |
| 2932 | possible via KVM_S390_INTERRUPT. |
| 2933 | |
| 2934 | Interrupt parameters are passed via kvm_s390_irq: |
| 2935 | |
| 2936 | struct kvm_s390_irq { |
| 2937 | __u64 type; |
| 2938 | union { |
| 2939 | struct kvm_s390_io_info io; |
| 2940 | struct kvm_s390_ext_info ext; |
| 2941 | struct kvm_s390_pgm_info pgm; |
| 2942 | struct kvm_s390_emerg_info emerg; |
| 2943 | struct kvm_s390_extcall_info extcall; |
| 2944 | struct kvm_s390_prefix_info prefix; |
| 2945 | struct kvm_s390_stop_info stop; |
| 2946 | struct kvm_s390_mchk_info mchk; |
| 2947 | char reserved[64]; |
| 2948 | } u; |
| 2949 | }; |
| 2950 | |
| 2951 | type can be one of the following: |
| 2952 | |
| 2953 | KVM_S390_SIGP_STOP - sigp stop; parameter in .stop |
| 2954 | KVM_S390_PROGRAM_INT - program check; parameters in .pgm |
| 2955 | KVM_S390_SIGP_SET_PREFIX - sigp set prefix; parameters in .prefix |
| 2956 | KVM_S390_RESTART - restart; no parameters |
| 2957 | KVM_S390_INT_CLOCK_COMP - clock comparator interrupt; no parameters |
| 2958 | KVM_S390_INT_CPU_TIMER - CPU timer interrupt; no parameters |
| 2959 | KVM_S390_INT_EMERGENCY - sigp emergency; parameters in .emerg |
| 2960 | KVM_S390_INT_EXTERNAL_CALL - sigp external call; parameters in .extcall |
| 2961 | KVM_S390_MCHK - machine check interrupt; parameters in .mchk |
| 2962 | |
| 2963 | |
| 2964 | Note that the vcpu ioctl is asynchronous to vcpu execution. |
| 2965 | |
Jens Freimann | 816c766 | 2014-11-24 17:13:46 +0100 | [diff] [blame] | 2966 | 4.94 KVM_S390_GET_IRQ_STATE |
| 2967 | |
| 2968 | Capability: KVM_CAP_S390_IRQ_STATE |
| 2969 | Architectures: s390 |
| 2970 | Type: vcpu ioctl |
| 2971 | Parameters: struct kvm_s390_irq_state (out) |
| 2972 | Returns: >= number of bytes copied into buffer, |
| 2973 | -EINVAL if buffer size is 0, |
| 2974 | -ENOBUFS if buffer size is too small to fit all pending interrupts, |
| 2975 | -EFAULT if the buffer address was invalid |
| 2976 | |
| 2977 | This ioctl allows userspace to retrieve the complete state of all currently |
| 2978 | pending interrupts in a single buffer. Use cases include migration |
| 2979 | and introspection. The parameter structure contains the address of a |
| 2980 | userspace buffer and its length: |
| 2981 | |
| 2982 | struct kvm_s390_irq_state { |
| 2983 | __u64 buf; |
| 2984 | __u32 flags; |
| 2985 | __u32 len; |
| 2986 | __u32 reserved[4]; |
| 2987 | }; |
| 2988 | |
| 2989 | Userspace passes in the above struct and for each pending interrupt a |
| 2990 | struct kvm_s390_irq is copied to the provided buffer. |
| 2991 | |
| 2992 | If -ENOBUFS is returned the buffer provided was too small and userspace |
| 2993 | may retry with a bigger buffer. |
| 2994 | |
| 2995 | 4.95 KVM_S390_SET_IRQ_STATE |
| 2996 | |
| 2997 | Capability: KVM_CAP_S390_IRQ_STATE |
| 2998 | Architectures: s390 |
| 2999 | Type: vcpu ioctl |
| 3000 | Parameters: struct kvm_s390_irq_state (in) |
| 3001 | Returns: 0 on success, |
| 3002 | -EFAULT if the buffer address was invalid, |
| 3003 | -EINVAL for an invalid buffer length (see below), |
| 3004 | -EBUSY if there were already interrupts pending, |
| 3005 | errors occurring when actually injecting the |
| 3006 | interrupt. See KVM_S390_IRQ. |
| 3007 | |
| 3008 | This ioctl allows userspace to set the complete state of all cpu-local |
| 3009 | interrupts currently pending for the vcpu. It is intended for restoring |
| 3010 | interrupt state after a migration. The input parameter is a userspace buffer |
| 3011 | containing a struct kvm_s390_irq_state: |
| 3012 | |
| 3013 | struct kvm_s390_irq_state { |
| 3014 | __u64 buf; |
| 3015 | __u32 len; |
| 3016 | __u32 pad; |
| 3017 | }; |
| 3018 | |
| 3019 | The userspace memory referenced by buf contains a struct kvm_s390_irq |
| 3020 | for each interrupt to be injected into the guest. |
| 3021 | If one of the interrupts could not be injected for some reason the |
| 3022 | ioctl aborts. |
| 3023 | |
| 3024 | len must be a multiple of sizeof(struct kvm_s390_irq). It must be > 0 |
| 3025 | and it must not exceed (max_vcpus + 32) * sizeof(struct kvm_s390_irq), |
| 3026 | which is the maximum number of possibly pending cpu-local interrupts. |
Jens Freimann | 47b43c5 | 2014-11-11 20:57:06 +0100 | [diff] [blame] | 3027 | |
Paolo Bonzini | f077825 | 2015-04-01 15:06:40 +0200 | [diff] [blame] | 3028 | 4.90 KVM_SMI |
| 3029 | |
| 3030 | Capability: KVM_CAP_X86_SMM |
| 3031 | Architectures: x86 |
| 3032 | Type: vcpu ioctl |
| 3033 | Parameters: none |
| 3034 | Returns: 0 on success, -1 on error |
| 3035 | |
| 3036 | Queues an SMI on the thread's vcpu. |
| 3037 | |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 3038 | 5. The kvm_run structure |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 3039 | ------------------------ |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 3040 | |
| 3041 | Application code obtains a pointer to the kvm_run structure by |
| 3042 | mmap()ing a vcpu fd. From that point, application code can control |
| 3043 | execution by changing fields in kvm_run prior to calling the KVM_RUN |
| 3044 | ioctl, and obtain information about the reason KVM_RUN returned by |
| 3045 | looking up structure members. |
| 3046 | |
| 3047 | struct kvm_run { |
| 3048 | /* in */ |
| 3049 | __u8 request_interrupt_window; |
| 3050 | |
| 3051 | Request that KVM_RUN return when it becomes possible to inject external |
| 3052 | interrupts into the guest. Useful in conjunction with KVM_INTERRUPT. |
| 3053 | |
| 3054 | __u8 padding1[7]; |
| 3055 | |
| 3056 | /* out */ |
| 3057 | __u32 exit_reason; |
| 3058 | |
| 3059 | When KVM_RUN has returned successfully (return value 0), this informs |
| 3060 | application code why KVM_RUN has returned. Allowable values for this |
| 3061 | field are detailed below. |
| 3062 | |
| 3063 | __u8 ready_for_interrupt_injection; |
| 3064 | |
| 3065 | If request_interrupt_window has been specified, this field indicates |
| 3066 | an interrupt can be injected now with KVM_INTERRUPT. |
| 3067 | |
| 3068 | __u8 if_flag; |
| 3069 | |
| 3070 | The value of the current interrupt flag. Only valid if in-kernel |
| 3071 | local APIC is not used. |
| 3072 | |
Paolo Bonzini | f077825 | 2015-04-01 15:06:40 +0200 | [diff] [blame] | 3073 | __u16 flags; |
| 3074 | |
| 3075 | More architecture-specific flags detailing state of the VCPU that may |
| 3076 | affect the device's behavior. The only currently defined flag is |
| 3077 | KVM_RUN_X86_SMM, which is valid on x86 machines and is set if the |
| 3078 | VCPU is in system management mode. |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 3079 | |
| 3080 | /* in (pre_kvm_run), out (post_kvm_run) */ |
| 3081 | __u64 cr8; |
| 3082 | |
| 3083 | The value of the cr8 register. Only valid if in-kernel local APIC is |
| 3084 | not used. Both input and output. |
| 3085 | |
| 3086 | __u64 apic_base; |
| 3087 | |
| 3088 | The value of the APIC BASE msr. Only valid if in-kernel local |
| 3089 | APIC is not used. Both input and output. |
| 3090 | |
| 3091 | union { |
| 3092 | /* KVM_EXIT_UNKNOWN */ |
| 3093 | struct { |
| 3094 | __u64 hardware_exit_reason; |
| 3095 | } hw; |
| 3096 | |
| 3097 | If exit_reason is KVM_EXIT_UNKNOWN, the vcpu has exited due to unknown |
| 3098 | reasons. Further architecture-specific information is available in |
| 3099 | hardware_exit_reason. |
| 3100 | |
| 3101 | /* KVM_EXIT_FAIL_ENTRY */ |
| 3102 | struct { |
| 3103 | __u64 hardware_entry_failure_reason; |
| 3104 | } fail_entry; |
| 3105 | |
| 3106 | If exit_reason is KVM_EXIT_FAIL_ENTRY, the vcpu could not be run due |
| 3107 | to unknown reasons. Further architecture-specific information is |
| 3108 | available in hardware_entry_failure_reason. |
| 3109 | |
| 3110 | /* KVM_EXIT_EXCEPTION */ |
| 3111 | struct { |
| 3112 | __u32 exception; |
| 3113 | __u32 error_code; |
| 3114 | } ex; |
| 3115 | |
| 3116 | Unused. |
| 3117 | |
| 3118 | /* KVM_EXIT_IO */ |
| 3119 | struct { |
| 3120 | #define KVM_EXIT_IO_IN 0 |
| 3121 | #define KVM_EXIT_IO_OUT 1 |
| 3122 | __u8 direction; |
| 3123 | __u8 size; /* bytes */ |
| 3124 | __u16 port; |
| 3125 | __u32 count; |
| 3126 | __u64 data_offset; /* relative to kvm_run start */ |
| 3127 | } io; |
| 3128 | |
Wu Fengguang | 2044892d | 2009-12-24 09:04:16 +0800 | [diff] [blame] | 3129 | If exit_reason is KVM_EXIT_IO, then the vcpu has |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 3130 | executed a port I/O instruction which could not be satisfied by kvm. |
| 3131 | data_offset describes where the data is located (KVM_EXIT_IO_OUT) or |
| 3132 | where kvm expects application code to place the data for the next |
Wu Fengguang | 2044892d | 2009-12-24 09:04:16 +0800 | [diff] [blame] | 3133 | 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] | 3134 | |
Alex Bennée | 8ab30c1 | 2015-07-07 17:29:53 +0100 | [diff] [blame] | 3135 | /* KVM_EXIT_DEBUG */ |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 3136 | struct { |
| 3137 | struct kvm_debug_exit_arch arch; |
| 3138 | } debug; |
| 3139 | |
Alex Bennée | 8ab30c1 | 2015-07-07 17:29:53 +0100 | [diff] [blame] | 3140 | If the exit_reason is KVM_EXIT_DEBUG, then a vcpu is processing a debug event |
| 3141 | for which architecture specific information is returned. |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 3142 | |
| 3143 | /* KVM_EXIT_MMIO */ |
| 3144 | struct { |
| 3145 | __u64 phys_addr; |
| 3146 | __u8 data[8]; |
| 3147 | __u32 len; |
| 3148 | __u8 is_write; |
| 3149 | } mmio; |
| 3150 | |
Wu Fengguang | 2044892d | 2009-12-24 09:04:16 +0800 | [diff] [blame] | 3151 | If exit_reason is KVM_EXIT_MMIO, then the vcpu has |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 3152 | executed a memory-mapped I/O instruction which could not be satisfied |
| 3153 | by kvm. The 'data' member contains the written data if 'is_write' is |
| 3154 | true, and should be filled by application code otherwise. |
| 3155 | |
Christoffer Dall | 6acdb16 | 2014-01-28 08:28:42 -0800 | [diff] [blame] | 3156 | The 'data' member contains, in its first 'len' bytes, the value as it would |
| 3157 | appear if the VCPU performed a load or store of the appropriate width directly |
| 3158 | to the byte array. |
| 3159 | |
Paolo Bonzini | cc568ea | 2014-08-05 09:55:22 +0200 | [diff] [blame] | 3160 | NOTE: For KVM_EXIT_IO, KVM_EXIT_MMIO, KVM_EXIT_OSI, KVM_EXIT_PAPR and |
Alexander Graf | ce91ddc | 2014-07-28 19:29:13 +0200 | [diff] [blame] | 3161 | KVM_EXIT_EPR the corresponding |
Alexander Graf | ad0a048 | 2010-03-24 21:48:30 +0100 | [diff] [blame] | 3162 | operations are complete (and guest state is consistent) only after userspace |
| 3163 | 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] | 3164 | incomplete operations and then check for pending signals. Userspace |
| 3165 | can re-enter the guest with an unmasked signal pending to complete |
| 3166 | pending operations. |
| 3167 | |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 3168 | /* KVM_EXIT_HYPERCALL */ |
| 3169 | struct { |
| 3170 | __u64 nr; |
| 3171 | __u64 args[6]; |
| 3172 | __u64 ret; |
| 3173 | __u32 longmode; |
| 3174 | __u32 pad; |
| 3175 | } hypercall; |
| 3176 | |
Avi Kivity | 647dc49 | 2010-04-01 14:39:21 +0300 | [diff] [blame] | 3177 | Unused. This was once used for 'hypercall to userspace'. To implement |
| 3178 | such functionality, use KVM_EXIT_IO (x86) or KVM_EXIT_MMIO (all except s390). |
| 3179 | Note KVM_EXIT_IO is significantly faster than KVM_EXIT_MMIO. |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 3180 | |
| 3181 | /* KVM_EXIT_TPR_ACCESS */ |
| 3182 | struct { |
| 3183 | __u64 rip; |
| 3184 | __u32 is_write; |
| 3185 | __u32 pad; |
| 3186 | } tpr_access; |
| 3187 | |
| 3188 | To be documented (KVM_TPR_ACCESS_REPORTING). |
| 3189 | |
| 3190 | /* KVM_EXIT_S390_SIEIC */ |
| 3191 | struct { |
| 3192 | __u8 icptcode; |
| 3193 | __u64 mask; /* psw upper half */ |
| 3194 | __u64 addr; /* psw lower half */ |
| 3195 | __u16 ipa; |
| 3196 | __u32 ipb; |
| 3197 | } s390_sieic; |
| 3198 | |
| 3199 | s390 specific. |
| 3200 | |
| 3201 | /* KVM_EXIT_S390_RESET */ |
| 3202 | #define KVM_S390_RESET_POR 1 |
| 3203 | #define KVM_S390_RESET_CLEAR 2 |
| 3204 | #define KVM_S390_RESET_SUBSYSTEM 4 |
| 3205 | #define KVM_S390_RESET_CPU_INIT 8 |
| 3206 | #define KVM_S390_RESET_IPL 16 |
| 3207 | __u64 s390_reset_flags; |
| 3208 | |
| 3209 | s390 specific. |
| 3210 | |
Carsten Otte | e168bf8 | 2012-01-04 10:25:22 +0100 | [diff] [blame] | 3211 | /* KVM_EXIT_S390_UCONTROL */ |
| 3212 | struct { |
| 3213 | __u64 trans_exc_code; |
| 3214 | __u32 pgm_code; |
| 3215 | } s390_ucontrol; |
| 3216 | |
| 3217 | s390 specific. A page fault has occurred for a user controlled virtual |
| 3218 | machine (KVM_VM_S390_UNCONTROL) on it's host page table that cannot be |
| 3219 | resolved by the kernel. |
| 3220 | The program code and the translation exception code that were placed |
| 3221 | in the cpu's lowcore are presented here as defined by the z Architecture |
| 3222 | Principles of Operation Book in the Chapter for Dynamic Address Translation |
| 3223 | (DAT) |
| 3224 | |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 3225 | /* KVM_EXIT_DCR */ |
| 3226 | struct { |
| 3227 | __u32 dcrn; |
| 3228 | __u32 data; |
| 3229 | __u8 is_write; |
| 3230 | } dcr; |
| 3231 | |
Alexander Graf | ce91ddc | 2014-07-28 19:29:13 +0200 | [diff] [blame] | 3232 | Deprecated - was used for 440 KVM. |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 3233 | |
Alexander Graf | ad0a048 | 2010-03-24 21:48:30 +0100 | [diff] [blame] | 3234 | /* KVM_EXIT_OSI */ |
| 3235 | struct { |
| 3236 | __u64 gprs[32]; |
| 3237 | } osi; |
| 3238 | |
| 3239 | MOL uses a special hypercall interface it calls 'OSI'. To enable it, we catch |
| 3240 | hypercalls and exit with this exit struct that contains all the guest gprs. |
| 3241 | |
| 3242 | If exit_reason is KVM_EXIT_OSI, then the vcpu has triggered such a hypercall. |
| 3243 | Userspace can now handle the hypercall and when it's done modify the gprs as |
| 3244 | necessary. Upon guest entry all guest GPRs will then be replaced by the values |
| 3245 | in this struct. |
| 3246 | |
Paul Mackerras | de56a94 | 2011-06-29 00:21:34 +0000 | [diff] [blame] | 3247 | /* KVM_EXIT_PAPR_HCALL */ |
| 3248 | struct { |
| 3249 | __u64 nr; |
| 3250 | __u64 ret; |
| 3251 | __u64 args[9]; |
| 3252 | } papr_hcall; |
| 3253 | |
| 3254 | This is used on 64-bit PowerPC when emulating a pSeries partition, |
| 3255 | e.g. with the 'pseries' machine type in qemu. It occurs when the |
| 3256 | guest does a hypercall using the 'sc 1' instruction. The 'nr' field |
| 3257 | contains the hypercall number (from the guest R3), and 'args' contains |
| 3258 | the arguments (from the guest R4 - R12). Userspace should put the |
| 3259 | return code in 'ret' and any extra returned values in args[]. |
| 3260 | The possible hypercalls are defined in the Power Architecture Platform |
| 3261 | Requirements (PAPR) document available from www.power.org (free |
| 3262 | developer registration required to access it). |
| 3263 | |
Cornelia Huck | fa6b7fe | 2012-12-20 15:32:12 +0100 | [diff] [blame] | 3264 | /* KVM_EXIT_S390_TSCH */ |
| 3265 | struct { |
| 3266 | __u16 subchannel_id; |
| 3267 | __u16 subchannel_nr; |
| 3268 | __u32 io_int_parm; |
| 3269 | __u32 io_int_word; |
| 3270 | __u32 ipb; |
| 3271 | __u8 dequeued; |
| 3272 | } s390_tsch; |
| 3273 | |
| 3274 | s390 specific. This exit occurs when KVM_CAP_S390_CSS_SUPPORT has been enabled |
| 3275 | and TEST SUBCHANNEL was intercepted. If dequeued is set, a pending I/O |
| 3276 | interrupt for the target subchannel has been dequeued and subchannel_id, |
| 3277 | subchannel_nr, io_int_parm and io_int_word contain the parameters for that |
| 3278 | interrupt. ipb is needed for instruction parameter decoding. |
| 3279 | |
Alexander Graf | 1c81063 | 2013-01-04 18:12:48 +0100 | [diff] [blame] | 3280 | /* KVM_EXIT_EPR */ |
| 3281 | struct { |
| 3282 | __u32 epr; |
| 3283 | } epr; |
| 3284 | |
| 3285 | On FSL BookE PowerPC chips, the interrupt controller has a fast patch |
| 3286 | interrupt acknowledge path to the core. When the core successfully |
| 3287 | delivers an interrupt, it automatically populates the EPR register with |
| 3288 | the interrupt vector number and acknowledges the interrupt inside |
| 3289 | the interrupt controller. |
| 3290 | |
| 3291 | In case the interrupt controller lives in user space, we need to do |
| 3292 | the interrupt acknowledge cycle through it to fetch the next to be |
| 3293 | delivered interrupt vector using this exit. |
| 3294 | |
| 3295 | It gets triggered whenever both KVM_CAP_PPC_EPR are enabled and an |
| 3296 | external interrupt has just been delivered into the guest. User space |
| 3297 | should put the acknowledged interrupt vector into the 'epr' field. |
| 3298 | |
Anup Patel | 8ad6b63 | 2014-04-29 11:24:19 +0530 | [diff] [blame] | 3299 | /* KVM_EXIT_SYSTEM_EVENT */ |
| 3300 | struct { |
| 3301 | #define KVM_SYSTEM_EVENT_SHUTDOWN 1 |
| 3302 | #define KVM_SYSTEM_EVENT_RESET 2 |
Andrey Smetanin | 2ce7918 | 2015-07-03 15:01:41 +0300 | [diff] [blame] | 3303 | #define KVM_SYSTEM_EVENT_CRASH 3 |
Anup Patel | 8ad6b63 | 2014-04-29 11:24:19 +0530 | [diff] [blame] | 3304 | __u32 type; |
| 3305 | __u64 flags; |
| 3306 | } system_event; |
| 3307 | |
| 3308 | If exit_reason is KVM_EXIT_SYSTEM_EVENT then the vcpu has triggered |
| 3309 | a system-level event using some architecture specific mechanism (hypercall |
| 3310 | or some special instruction). In case of ARM/ARM64, this is triggered using |
| 3311 | HVC instruction based PSCI call from the vcpu. The 'type' field describes |
| 3312 | the system-level event type. The 'flags' field describes architecture |
| 3313 | specific flags for the system-level event. |
| 3314 | |
Christoffer Dall | cf5d3188 | 2014-10-16 17:00:18 +0200 | [diff] [blame] | 3315 | Valid values for 'type' are: |
| 3316 | KVM_SYSTEM_EVENT_SHUTDOWN -- the guest has requested a shutdown of the |
| 3317 | VM. Userspace is not obliged to honour this, and if it does honour |
| 3318 | this does not need to destroy the VM synchronously (ie it may call |
| 3319 | KVM_RUN again before shutdown finally occurs). |
| 3320 | KVM_SYSTEM_EVENT_RESET -- the guest has requested a reset of the VM. |
| 3321 | As with SHUTDOWN, userspace can choose to ignore the request, or |
| 3322 | to schedule the reset to occur in the future and may call KVM_RUN again. |
Andrey Smetanin | 2ce7918 | 2015-07-03 15:01:41 +0300 | [diff] [blame] | 3323 | KVM_SYSTEM_EVENT_CRASH -- the guest crash occurred and the guest |
| 3324 | has requested a crash condition maintenance. Userspace can choose |
| 3325 | to ignore the request, or to gather VM memory core dump and/or |
| 3326 | reset/shutdown of the VM. |
Christoffer Dall | cf5d3188 | 2014-10-16 17:00:18 +0200 | [diff] [blame] | 3327 | |
Steve Rutherford | 7543a63 | 2015-07-29 23:21:41 -0700 | [diff] [blame] | 3328 | /* KVM_EXIT_IOAPIC_EOI */ |
| 3329 | struct { |
| 3330 | __u8 vector; |
| 3331 | } eoi; |
| 3332 | |
| 3333 | Indicates that the VCPU's in-kernel local APIC received an EOI for a |
| 3334 | level-triggered IOAPIC interrupt. This exit only triggers when the |
| 3335 | IOAPIC is implemented in userspace (i.e. KVM_CAP_SPLIT_IRQCHIP is enabled); |
| 3336 | the userspace IOAPIC should process the EOI and retrigger the interrupt if |
| 3337 | it is still asserted. Vector is the LAPIC interrupt vector for which the |
| 3338 | EOI was received. |
| 3339 | |
Andrey Smetanin | db397571 | 2015-11-10 15:36:35 +0300 | [diff] [blame^] | 3340 | struct kvm_hyperv_exit { |
| 3341 | #define KVM_EXIT_HYPERV_SYNIC 1 |
| 3342 | __u32 type; |
| 3343 | union { |
| 3344 | struct { |
| 3345 | __u32 msr; |
| 3346 | __u64 control; |
| 3347 | __u64 evt_page; |
| 3348 | __u64 msg_page; |
| 3349 | } synic; |
| 3350 | } u; |
| 3351 | }; |
| 3352 | /* KVM_EXIT_HYPERV */ |
| 3353 | struct kvm_hyperv_exit hyperv; |
| 3354 | Indicates that the VCPU exits into userspace to process some tasks |
| 3355 | related to Hyper-V emulation. |
| 3356 | Valid values for 'type' are: |
| 3357 | KVM_EXIT_HYPERV_SYNIC -- synchronously notify user-space about |
| 3358 | Hyper-V SynIC state change. Notification is used to remap SynIC |
| 3359 | event/message pages and to enable/disable SynIC messages/events processing |
| 3360 | in userspace. |
| 3361 | |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 3362 | /* Fix the size of the union. */ |
| 3363 | char padding[256]; |
| 3364 | }; |
Christian Borntraeger | b9e5dc8 | 2012-01-11 11:20:30 +0100 | [diff] [blame] | 3365 | |
| 3366 | /* |
| 3367 | * shared registers between kvm and userspace. |
| 3368 | * kvm_valid_regs specifies the register classes set by the host |
| 3369 | * kvm_dirty_regs specified the register classes dirtied by userspace |
| 3370 | * struct kvm_sync_regs is architecture specific, as well as the |
| 3371 | * bits for kvm_valid_regs and kvm_dirty_regs |
| 3372 | */ |
| 3373 | __u64 kvm_valid_regs; |
| 3374 | __u64 kvm_dirty_regs; |
| 3375 | union { |
| 3376 | struct kvm_sync_regs regs; |
| 3377 | char padding[1024]; |
| 3378 | } s; |
| 3379 | |
| 3380 | If KVM_CAP_SYNC_REGS is defined, these fields allow userspace to access |
| 3381 | certain guest registers without having to call SET/GET_*REGS. Thus we can |
| 3382 | avoid some system call overhead if userspace has to handle the exit. |
| 3383 | Userspace can query the validity of the structure by checking |
| 3384 | kvm_valid_regs for specific bits. These bits are architecture specific |
| 3385 | and usually define the validity of a groups of registers. (e.g. one bit |
| 3386 | for general purpose registers) |
| 3387 | |
David Hildenbrand | d8482c0 | 2014-07-29 08:19:26 +0200 | [diff] [blame] | 3388 | Please note that the kernel is allowed to use the kvm_run structure as the |
| 3389 | primary storage for certain register types. Therefore, the kernel may use the |
| 3390 | values in kvm_run even if the corresponding bit in kvm_dirty_regs is not set. |
| 3391 | |
Avi Kivity | 9c1b96e | 2009-06-09 12:37:58 +0300 | [diff] [blame] | 3392 | }; |
Alexander Graf | 821246a | 2011-08-31 10:58:55 +0200 | [diff] [blame] | 3393 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 3394 | |
Borislav Petkov | 9c15bb1 | 2013-09-22 16:44:50 +0200 | [diff] [blame] | 3395 | |
Paul Mackerras | 699a0ea | 2014-06-02 11:02:59 +1000 | [diff] [blame] | 3396 | 6. Capabilities that can be enabled on vCPUs |
| 3397 | -------------------------------------------- |
Alexander Graf | 821246a | 2011-08-31 10:58:55 +0200 | [diff] [blame] | 3398 | |
Cornelia Huck | 0907c85 | 2014-06-27 09:29:26 +0200 | [diff] [blame] | 3399 | There are certain capabilities that change the behavior of the virtual CPU or |
| 3400 | the virtual machine when enabled. To enable them, please see section 4.37. |
| 3401 | Below you can find a list of capabilities and what their effect on the vCPU or |
| 3402 | the virtual machine is when enabling them. |
Alexander Graf | 821246a | 2011-08-31 10:58:55 +0200 | [diff] [blame] | 3403 | |
| 3404 | The following information is provided along with the description: |
| 3405 | |
| 3406 | Architectures: which instruction set architectures provide this ioctl. |
| 3407 | x86 includes both i386 and x86_64. |
| 3408 | |
Cornelia Huck | 0907c85 | 2014-06-27 09:29:26 +0200 | [diff] [blame] | 3409 | Target: whether this is a per-vcpu or per-vm capability. |
| 3410 | |
Alexander Graf | 821246a | 2011-08-31 10:58:55 +0200 | [diff] [blame] | 3411 | Parameters: what parameters are accepted by the capability. |
| 3412 | |
| 3413 | Returns: the return value. General error numbers (EBADF, ENOMEM, EINVAL) |
| 3414 | are not detailed, but errors with specific meanings are. |
| 3415 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 3416 | |
Alexander Graf | 821246a | 2011-08-31 10:58:55 +0200 | [diff] [blame] | 3417 | 6.1 KVM_CAP_PPC_OSI |
| 3418 | |
| 3419 | Architectures: ppc |
Cornelia Huck | 0907c85 | 2014-06-27 09:29:26 +0200 | [diff] [blame] | 3420 | Target: vcpu |
Alexander Graf | 821246a | 2011-08-31 10:58:55 +0200 | [diff] [blame] | 3421 | Parameters: none |
| 3422 | Returns: 0 on success; -1 on error |
| 3423 | |
| 3424 | This capability enables interception of OSI hypercalls that otherwise would |
| 3425 | be treated as normal system calls to be injected into the guest. OSI hypercalls |
| 3426 | were invented by Mac-on-Linux to have a standardized communication mechanism |
| 3427 | between the guest and the host. |
| 3428 | |
| 3429 | When this capability is enabled, KVM_EXIT_OSI can occur. |
| 3430 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 3431 | |
Alexander Graf | 821246a | 2011-08-31 10:58:55 +0200 | [diff] [blame] | 3432 | 6.2 KVM_CAP_PPC_PAPR |
| 3433 | |
| 3434 | Architectures: ppc |
Cornelia Huck | 0907c85 | 2014-06-27 09:29:26 +0200 | [diff] [blame] | 3435 | Target: vcpu |
Alexander Graf | 821246a | 2011-08-31 10:58:55 +0200 | [diff] [blame] | 3436 | Parameters: none |
| 3437 | Returns: 0 on success; -1 on error |
| 3438 | |
| 3439 | This capability enables interception of PAPR hypercalls. PAPR hypercalls are |
| 3440 | done using the hypercall instruction "sc 1". |
| 3441 | |
| 3442 | It also sets the guest privilege level to "supervisor" mode. Usually the guest |
| 3443 | runs in "hypervisor" privilege mode with a few missing features. |
| 3444 | |
| 3445 | In addition to the above, it changes the semantics of SDR1. In this mode, the |
| 3446 | HTAB address part of SDR1 contains an HVA instead of a GPA, as PAPR keeps the |
| 3447 | HTAB invisible to the guest. |
| 3448 | |
| 3449 | When this capability is enabled, KVM_EXIT_PAPR_HCALL can occur. |
Scott Wood | dc83b8b | 2011-08-18 15:25:21 -0500 | [diff] [blame] | 3450 | |
Jan Kiszka | 414fa98 | 2012-04-24 16:40:15 +0200 | [diff] [blame] | 3451 | |
Scott Wood | dc83b8b | 2011-08-18 15:25:21 -0500 | [diff] [blame] | 3452 | 6.3 KVM_CAP_SW_TLB |
| 3453 | |
| 3454 | Architectures: ppc |
Cornelia Huck | 0907c85 | 2014-06-27 09:29:26 +0200 | [diff] [blame] | 3455 | Target: vcpu |
Scott Wood | dc83b8b | 2011-08-18 15:25:21 -0500 | [diff] [blame] | 3456 | Parameters: args[0] is the address of a struct kvm_config_tlb |
| 3457 | Returns: 0 on success; -1 on error |
| 3458 | |
| 3459 | struct kvm_config_tlb { |
| 3460 | __u64 params; |
| 3461 | __u64 array; |
| 3462 | __u32 mmu_type; |
| 3463 | __u32 array_len; |
| 3464 | }; |
| 3465 | |
| 3466 | Configures the virtual CPU's TLB array, establishing a shared memory area |
| 3467 | between userspace and KVM. The "params" and "array" fields are userspace |
| 3468 | addresses of mmu-type-specific data structures. The "array_len" field is an |
| 3469 | safety mechanism, and should be set to the size in bytes of the memory that |
| 3470 | userspace has reserved for the array. It must be at least the size dictated |
| 3471 | by "mmu_type" and "params". |
| 3472 | |
| 3473 | While KVM_RUN is active, the shared region is under control of KVM. Its |
| 3474 | contents are undefined, and any modification by userspace results in |
| 3475 | boundedly undefined behavior. |
| 3476 | |
| 3477 | On return from KVM_RUN, the shared region will reflect the current state of |
| 3478 | the guest's TLB. If userspace makes any changes, it must call KVM_DIRTY_TLB |
| 3479 | to tell KVM which entries have been changed, prior to calling KVM_RUN again |
| 3480 | on this vcpu. |
| 3481 | |
| 3482 | For mmu types KVM_MMU_FSL_BOOKE_NOHV and KVM_MMU_FSL_BOOKE_HV: |
| 3483 | - The "params" field is of type "struct kvm_book3e_206_tlb_params". |
| 3484 | - The "array" field points to an array of type "struct |
| 3485 | kvm_book3e_206_tlb_entry". |
| 3486 | - The array consists of all entries in the first TLB, followed by all |
| 3487 | entries in the second TLB. |
| 3488 | - Within a TLB, entries are ordered first by increasing set number. Within a |
| 3489 | set, entries are ordered by way (increasing ESEL). |
| 3490 | - The hash for determining set number in TLB0 is: (MAS2 >> 12) & (num_sets - 1) |
| 3491 | where "num_sets" is the tlb_sizes[] value divided by the tlb_ways[] value. |
| 3492 | - The tsize field of mas1 shall be set to 4K on TLB0, even though the |
| 3493 | hardware ignores this value for TLB0. |
Cornelia Huck | fa6b7fe | 2012-12-20 15:32:12 +0100 | [diff] [blame] | 3494 | |
| 3495 | 6.4 KVM_CAP_S390_CSS_SUPPORT |
| 3496 | |
| 3497 | Architectures: s390 |
Cornelia Huck | 0907c85 | 2014-06-27 09:29:26 +0200 | [diff] [blame] | 3498 | Target: vcpu |
Cornelia Huck | fa6b7fe | 2012-12-20 15:32:12 +0100 | [diff] [blame] | 3499 | Parameters: none |
| 3500 | Returns: 0 on success; -1 on error |
| 3501 | |
| 3502 | This capability enables support for handling of channel I/O instructions. |
| 3503 | |
| 3504 | TEST PENDING INTERRUPTION and the interrupt portion of TEST SUBCHANNEL are |
| 3505 | handled in-kernel, while the other I/O instructions are passed to userspace. |
| 3506 | |
| 3507 | When this capability is enabled, KVM_EXIT_S390_TSCH will occur on TEST |
| 3508 | SUBCHANNEL intercepts. |
Alexander Graf | 1c81063 | 2013-01-04 18:12:48 +0100 | [diff] [blame] | 3509 | |
Cornelia Huck | 0907c85 | 2014-06-27 09:29:26 +0200 | [diff] [blame] | 3510 | Note that even though this capability is enabled per-vcpu, the complete |
| 3511 | virtual machine is affected. |
| 3512 | |
Alexander Graf | 1c81063 | 2013-01-04 18:12:48 +0100 | [diff] [blame] | 3513 | 6.5 KVM_CAP_PPC_EPR |
| 3514 | |
| 3515 | Architectures: ppc |
Cornelia Huck | 0907c85 | 2014-06-27 09:29:26 +0200 | [diff] [blame] | 3516 | Target: vcpu |
Alexander Graf | 1c81063 | 2013-01-04 18:12:48 +0100 | [diff] [blame] | 3517 | Parameters: args[0] defines whether the proxy facility is active |
| 3518 | Returns: 0 on success; -1 on error |
| 3519 | |
| 3520 | This capability enables or disables the delivery of interrupts through the |
| 3521 | external proxy facility. |
| 3522 | |
| 3523 | When enabled (args[0] != 0), every time the guest gets an external interrupt |
| 3524 | delivered, it automatically exits into user space with a KVM_EXIT_EPR exit |
| 3525 | to receive the topmost interrupt vector. |
| 3526 | |
| 3527 | When disabled (args[0] == 0), behavior is as if this facility is unsupported. |
| 3528 | |
| 3529 | When this capability is enabled, KVM_EXIT_EPR can occur. |
Scott Wood | eb1e4f4 | 2013-04-12 14:08:47 +0000 | [diff] [blame] | 3530 | |
| 3531 | 6.6 KVM_CAP_IRQ_MPIC |
| 3532 | |
| 3533 | Architectures: ppc |
| 3534 | Parameters: args[0] is the MPIC device fd |
| 3535 | args[1] is the MPIC CPU number for this vcpu |
| 3536 | |
| 3537 | This capability connects the vcpu to an in-kernel MPIC device. |
Paul Mackerras | 5975a2e | 2013-04-27 00:28:37 +0000 | [diff] [blame] | 3538 | |
| 3539 | 6.7 KVM_CAP_IRQ_XICS |
| 3540 | |
| 3541 | Architectures: ppc |
Cornelia Huck | 0907c85 | 2014-06-27 09:29:26 +0200 | [diff] [blame] | 3542 | Target: vcpu |
Paul Mackerras | 5975a2e | 2013-04-27 00:28:37 +0000 | [diff] [blame] | 3543 | Parameters: args[0] is the XICS device fd |
| 3544 | args[1] is the XICS CPU number (server ID) for this vcpu |
| 3545 | |
| 3546 | This capability connects the vcpu to an in-kernel XICS device. |
Cornelia Huck | 8a366a4 | 2014-06-27 11:06:25 +0200 | [diff] [blame] | 3547 | |
| 3548 | 6.8 KVM_CAP_S390_IRQCHIP |
| 3549 | |
| 3550 | Architectures: s390 |
| 3551 | Target: vm |
| 3552 | Parameters: none |
| 3553 | |
| 3554 | This capability enables the in-kernel irqchip for s390. Please refer to |
| 3555 | "4.24 KVM_CREATE_IRQCHIP" for details. |
Paul Mackerras | 699a0ea | 2014-06-02 11:02:59 +1000 | [diff] [blame] | 3556 | |
James Hogan | 5fafd874 | 2014-12-08 23:07:56 +0000 | [diff] [blame] | 3557 | 6.9 KVM_CAP_MIPS_FPU |
| 3558 | |
| 3559 | Architectures: mips |
| 3560 | Target: vcpu |
| 3561 | Parameters: args[0] is reserved for future use (should be 0). |
| 3562 | |
| 3563 | This capability allows the use of the host Floating Point Unit by the guest. It |
| 3564 | allows the Config1.FP bit to be set to enable the FPU in the guest. Once this is |
| 3565 | done the KVM_REG_MIPS_FPR_* and KVM_REG_MIPS_FCR_* registers can be accessed |
| 3566 | (depending on the current guest FPU register mode), and the Status.FR, |
| 3567 | Config5.FRE bits are accessible via the KVM API and also from the guest, |
| 3568 | depending on them being supported by the FPU. |
| 3569 | |
James Hogan | d952bd0 | 2014-12-08 23:07:56 +0000 | [diff] [blame] | 3570 | 6.10 KVM_CAP_MIPS_MSA |
| 3571 | |
| 3572 | Architectures: mips |
| 3573 | Target: vcpu |
| 3574 | Parameters: args[0] is reserved for future use (should be 0). |
| 3575 | |
| 3576 | This capability allows the use of the MIPS SIMD Architecture (MSA) by the guest. |
| 3577 | It allows the Config3.MSAP bit to be set to enable the use of MSA by the guest. |
| 3578 | Once this is done the KVM_REG_MIPS_VEC_* and KVM_REG_MIPS_MSA_* registers can be |
| 3579 | accessed, and the Config5.MSAEn bit is accessible via the KVM API and also from |
| 3580 | the guest. |
| 3581 | |
Paul Mackerras | 699a0ea | 2014-06-02 11:02:59 +1000 | [diff] [blame] | 3582 | 7. Capabilities that can be enabled on VMs |
| 3583 | ------------------------------------------ |
| 3584 | |
| 3585 | There are certain capabilities that change the behavior of the virtual |
| 3586 | machine when enabled. To enable them, please see section 4.37. Below |
| 3587 | you can find a list of capabilities and what their effect on the VM |
| 3588 | is when enabling them. |
| 3589 | |
| 3590 | The following information is provided along with the description: |
| 3591 | |
| 3592 | Architectures: which instruction set architectures provide this ioctl. |
| 3593 | x86 includes both i386 and x86_64. |
| 3594 | |
| 3595 | Parameters: what parameters are accepted by the capability. |
| 3596 | |
| 3597 | Returns: the return value. General error numbers (EBADF, ENOMEM, EINVAL) |
| 3598 | are not detailed, but errors with specific meanings are. |
| 3599 | |
| 3600 | |
| 3601 | 7.1 KVM_CAP_PPC_ENABLE_HCALL |
| 3602 | |
| 3603 | Architectures: ppc |
| 3604 | Parameters: args[0] is the sPAPR hcall number |
| 3605 | args[1] is 0 to disable, 1 to enable in-kernel handling |
| 3606 | |
| 3607 | This capability controls whether individual sPAPR hypercalls (hcalls) |
| 3608 | get handled by the kernel or not. Enabling or disabling in-kernel |
| 3609 | handling of an hcall is effective across the VM. On creation, an |
| 3610 | initial set of hcalls are enabled for in-kernel handling, which |
| 3611 | consists of those hcalls for which in-kernel handlers were implemented |
| 3612 | before this capability was implemented. If disabled, the kernel will |
| 3613 | not to attempt to handle the hcall, but will always exit to userspace |
| 3614 | to handle it. Note that it may not make sense to enable some and |
| 3615 | disable others of a group of related hcalls, but KVM does not prevent |
| 3616 | userspace from doing that. |
Paul Mackerras | ae2113a | 2014-06-02 11:03:00 +1000 | [diff] [blame] | 3617 | |
| 3618 | If the hcall number specified is not one that has an in-kernel |
| 3619 | implementation, the KVM_ENABLE_CAP ioctl will fail with an EINVAL |
| 3620 | error. |
David Hildenbrand | 2444b35 | 2014-10-09 14:10:13 +0200 | [diff] [blame] | 3621 | |
| 3622 | 7.2 KVM_CAP_S390_USER_SIGP |
| 3623 | |
| 3624 | Architectures: s390 |
| 3625 | Parameters: none |
| 3626 | |
| 3627 | This capability controls which SIGP orders will be handled completely in user |
| 3628 | space. With this capability enabled, all fast orders will be handled completely |
| 3629 | in the kernel: |
| 3630 | - SENSE |
| 3631 | - SENSE RUNNING |
| 3632 | - EXTERNAL CALL |
| 3633 | - EMERGENCY SIGNAL |
| 3634 | - CONDITIONAL EMERGENCY SIGNAL |
| 3635 | |
| 3636 | All other orders will be handled completely in user space. |
| 3637 | |
| 3638 | Only privileged operation exceptions will be checked for in the kernel (or even |
| 3639 | in the hardware prior to interception). If this capability is not enabled, the |
| 3640 | old way of handling SIGP orders is used (partially in kernel and user space). |
Eric Farman | 68c5575 | 2014-06-09 10:57:26 -0400 | [diff] [blame] | 3641 | |
| 3642 | 7.3 KVM_CAP_S390_VECTOR_REGISTERS |
| 3643 | |
| 3644 | Architectures: s390 |
| 3645 | Parameters: none |
| 3646 | Returns: 0 on success, negative value on error |
| 3647 | |
| 3648 | Allows use of the vector registers introduced with z13 processor, and |
| 3649 | provides for the synchronization between host and user space. Will |
| 3650 | return -EINVAL if the machine does not support vectors. |
Ekaterina Tumanova | e44fc8c | 2015-01-30 16:55:56 +0100 | [diff] [blame] | 3651 | |
| 3652 | 7.4 KVM_CAP_S390_USER_STSI |
| 3653 | |
| 3654 | Architectures: s390 |
| 3655 | Parameters: none |
| 3656 | |
| 3657 | This capability allows post-handlers for the STSI instruction. After |
| 3658 | initial handling in the kernel, KVM exits to user space with |
| 3659 | KVM_EXIT_S390_STSI to allow user space to insert further data. |
| 3660 | |
| 3661 | Before exiting to userspace, kvm handlers should fill in s390_stsi field of |
| 3662 | vcpu->run: |
| 3663 | struct { |
| 3664 | __u64 addr; |
| 3665 | __u8 ar; |
| 3666 | __u8 reserved; |
| 3667 | __u8 fc; |
| 3668 | __u8 sel1; |
| 3669 | __u16 sel2; |
| 3670 | } s390_stsi; |
| 3671 | |
| 3672 | @addr - guest address of STSI SYSIB |
| 3673 | @fc - function code |
| 3674 | @sel1 - selector 1 |
| 3675 | @sel2 - selector 2 |
| 3676 | @ar - access register number |
| 3677 | |
| 3678 | KVM handlers should exit to userspace with rc = -EREMOTE. |
Michael Ellerman | e928e9c | 2015-03-20 20:39:41 +1100 | [diff] [blame] | 3679 | |
Steve Rutherford | 49df639 | 2015-07-29 23:21:40 -0700 | [diff] [blame] | 3680 | 7.5 KVM_CAP_SPLIT_IRQCHIP |
| 3681 | |
| 3682 | Architectures: x86 |
Steve Rutherford | b053b2a | 2015-07-29 23:32:35 -0700 | [diff] [blame] | 3683 | Parameters: args[0] - number of routes reserved for userspace IOAPICs |
Steve Rutherford | 49df639 | 2015-07-29 23:21:40 -0700 | [diff] [blame] | 3684 | Returns: 0 on success, -1 on error |
| 3685 | |
| 3686 | Create a local apic for each processor in the kernel. This can be used |
| 3687 | instead of KVM_CREATE_IRQCHIP if the userspace VMM wishes to emulate the |
| 3688 | IOAPIC and PIC (and also the PIT, even though this has to be enabled |
| 3689 | separately). |
| 3690 | |
Steve Rutherford | b053b2a | 2015-07-29 23:32:35 -0700 | [diff] [blame] | 3691 | This capability also enables in kernel routing of interrupt requests; |
| 3692 | when KVM_CAP_SPLIT_IRQCHIP only routes of KVM_IRQ_ROUTING_MSI type are |
| 3693 | used in the IRQ routing table. The first args[0] MSI routes are reserved |
| 3694 | for the IOAPIC pins. Whenever the LAPIC receives an EOI for these routes, |
| 3695 | a KVM_EXIT_IOAPIC_EOI vmexit will be reported to userspace. |
Steve Rutherford | 49df639 | 2015-07-29 23:21:40 -0700 | [diff] [blame] | 3696 | |
| 3697 | Fails if VCPU has already been created, or if the irqchip is already in the |
| 3698 | kernel (i.e. KVM_CREATE_IRQCHIP has already been called). |
| 3699 | |
Michael Ellerman | e928e9c | 2015-03-20 20:39:41 +1100 | [diff] [blame] | 3700 | |
| 3701 | 8. Other capabilities. |
| 3702 | ---------------------- |
| 3703 | |
| 3704 | This section lists capabilities that give information about other |
| 3705 | features of the KVM implementation. |
| 3706 | |
| 3707 | 8.1 KVM_CAP_PPC_HWRNG |
| 3708 | |
| 3709 | Architectures: ppc |
| 3710 | |
| 3711 | This capability, if KVM_CHECK_EXTENSION indicates that it is |
| 3712 | available, means that that the kernel has an implementation of the |
| 3713 | H_RANDOM hypercall backed by a hardware random-number generator. |
| 3714 | If present, the kernel H_RANDOM handler can be enabled for guest use |
| 3715 | with the KVM_CAP_PPC_ENABLE_HCALL capability. |
Andrey Smetanin | 5c919412 | 2015-11-10 15:36:34 +0300 | [diff] [blame] | 3716 | |
| 3717 | 8.2 KVM_CAP_HYPERV_SYNIC |
| 3718 | |
| 3719 | Architectures: x86 |
| 3720 | This capability, if KVM_CHECK_EXTENSION indicates that it is |
| 3721 | available, means that that the kernel has an implementation of the |
| 3722 | Hyper-V Synthetic interrupt controller(SynIC). Hyper-V SynIC is |
| 3723 | used to support Windows Hyper-V based guest paravirt drivers(VMBus). |
| 3724 | |
| 3725 | In order to use SynIC, it has to be activated by setting this |
| 3726 | capability via KVM_ENABLE_CAP ioctl on the vcpu fd. Note that this |
| 3727 | will disable the use of APIC hardware virtualization even if supported |
| 3728 | by the CPU, as it's incompatible with SynIC auto-EOI behavior. |