logo

oasis-root

Compiled tree of Oasis Linux based on own branch at <https://hacktivis.me/git/oasis/> git clone https://anongit.hacktivis.me/git/oasis-root.git

kvm.h (49049B)


  1. /* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
  2. #ifndef __LINUX_KVM_H
  3. #define __LINUX_KVM_H
  4. /*
  5. * Userspace interface for /dev/kvm - kernel based virtual machine
  6. *
  7. * Note: you must update KVM_API_VERSION if you change this interface.
  8. */
  9. #include <linux/const.h>
  10. #include <linux/types.h>
  11. #include <linux/ioctl.h>
  12. #include <asm/kvm.h>
  13. #define KVM_API_VERSION 12
  14. /*
  15. * Backwards-compatible definitions.
  16. */
  17. #define __KVM_HAVE_GUEST_DEBUG
  18. /* for KVM_SET_USER_MEMORY_REGION */
  19. struct kvm_userspace_memory_region {
  20. __u32 slot;
  21. __u32 flags;
  22. __u64 guest_phys_addr;
  23. __u64 memory_size; /* bytes */
  24. __u64 userspace_addr; /* start of the userspace allocated memory */
  25. };
  26. /* for KVM_SET_USER_MEMORY_REGION2 */
  27. struct kvm_userspace_memory_region2 {
  28. __u32 slot;
  29. __u32 flags;
  30. __u64 guest_phys_addr;
  31. __u64 memory_size;
  32. __u64 userspace_addr;
  33. __u64 guest_memfd_offset;
  34. __u32 guest_memfd;
  35. __u32 pad1;
  36. __u64 pad2[14];
  37. };
  38. /*
  39. * The bit 0 ~ bit 15 of kvm_userspace_memory_region::flags are visible for
  40. * userspace, other bits are reserved for kvm internal use which are defined
  41. * in include/linux/kvm_host.h.
  42. */
  43. #define KVM_MEM_LOG_DIRTY_PAGES (1UL << 0)
  44. #define KVM_MEM_READONLY (1UL << 1)
  45. #define KVM_MEM_GUEST_MEMFD (1UL << 2)
  46. /* for KVM_IRQ_LINE */
  47. struct kvm_irq_level {
  48. /*
  49. * ACPI gsi notion of irq.
  50. * For IA-64 (APIC model) IOAPIC0: irq 0-23; IOAPIC1: irq 24-47..
  51. * For X86 (standard AT mode) PIC0/1: irq 0-15. IOAPIC0: 0-23..
  52. * For ARM: See Documentation/virt/kvm/api.rst
  53. */
  54. union {
  55. __u32 irq;
  56. __s32 status;
  57. };
  58. __u32 level;
  59. };
  60. struct kvm_irqchip {
  61. __u32 chip_id;
  62. __u32 pad;
  63. union {
  64. char dummy[512]; /* reserving space */
  65. #ifdef __KVM_HAVE_PIT
  66. struct kvm_pic_state pic;
  67. #endif
  68. #ifdef __KVM_HAVE_IOAPIC
  69. struct kvm_ioapic_state ioapic;
  70. #endif
  71. } chip;
  72. };
  73. /* for KVM_CREATE_PIT2 */
  74. struct kvm_pit_config {
  75. __u32 flags;
  76. __u32 pad[15];
  77. };
  78. #define KVM_PIT_SPEAKER_DUMMY 1
  79. struct kvm_hyperv_exit {
  80. #define KVM_EXIT_HYPERV_SYNIC 1
  81. #define KVM_EXIT_HYPERV_HCALL 2
  82. #define KVM_EXIT_HYPERV_SYNDBG 3
  83. __u32 type;
  84. __u32 pad1;
  85. union {
  86. struct {
  87. __u32 msr;
  88. __u32 pad2;
  89. __u64 control;
  90. __u64 evt_page;
  91. __u64 msg_page;
  92. } synic;
  93. struct {
  94. __u64 input;
  95. __u64 result;
  96. __u64 params[2];
  97. } hcall;
  98. struct {
  99. __u32 msr;
  100. __u32 pad2;
  101. __u64 control;
  102. __u64 status;
  103. __u64 send_page;
  104. __u64 recv_page;
  105. __u64 pending_page;
  106. } syndbg;
  107. } u;
  108. };
  109. struct kvm_xen_exit {
  110. #define KVM_EXIT_XEN_HCALL 1
  111. __u32 type;
  112. union {
  113. struct {
  114. __u32 longmode;
  115. __u32 cpl;
  116. __u64 input;
  117. __u64 result;
  118. __u64 params[6];
  119. } hcall;
  120. } u;
  121. };
  122. #define KVM_S390_GET_SKEYS_NONE 1
  123. #define KVM_S390_SKEYS_MAX 1048576
  124. #define KVM_EXIT_UNKNOWN 0
  125. #define KVM_EXIT_EXCEPTION 1
  126. #define KVM_EXIT_IO 2
  127. #define KVM_EXIT_HYPERCALL 3
  128. #define KVM_EXIT_DEBUG 4
  129. #define KVM_EXIT_HLT 5
  130. #define KVM_EXIT_MMIO 6
  131. #define KVM_EXIT_IRQ_WINDOW_OPEN 7
  132. #define KVM_EXIT_SHUTDOWN 8
  133. #define KVM_EXIT_FAIL_ENTRY 9
  134. #define KVM_EXIT_INTR 10
  135. #define KVM_EXIT_SET_TPR 11
  136. #define KVM_EXIT_TPR_ACCESS 12
  137. #define KVM_EXIT_S390_SIEIC 13
  138. #define KVM_EXIT_S390_RESET 14
  139. #define KVM_EXIT_DCR 15 /* deprecated */
  140. #define KVM_EXIT_NMI 16
  141. #define KVM_EXIT_INTERNAL_ERROR 17
  142. #define KVM_EXIT_OSI 18
  143. #define KVM_EXIT_PAPR_HCALL 19
  144. #define KVM_EXIT_S390_UCONTROL 20
  145. #define KVM_EXIT_WATCHDOG 21
  146. #define KVM_EXIT_S390_TSCH 22
  147. #define KVM_EXIT_EPR 23
  148. #define KVM_EXIT_SYSTEM_EVENT 24
  149. #define KVM_EXIT_S390_STSI 25
  150. #define KVM_EXIT_IOAPIC_EOI 26
  151. #define KVM_EXIT_HYPERV 27
  152. #define KVM_EXIT_ARM_NISV 28
  153. #define KVM_EXIT_X86_RDMSR 29
  154. #define KVM_EXIT_X86_WRMSR 30
  155. #define KVM_EXIT_DIRTY_RING_FULL 31
  156. #define KVM_EXIT_AP_RESET_HOLD 32
  157. #define KVM_EXIT_X86_BUS_LOCK 33
  158. #define KVM_EXIT_XEN 34
  159. #define KVM_EXIT_RISCV_SBI 35
  160. #define KVM_EXIT_RISCV_CSR 36
  161. #define KVM_EXIT_NOTIFY 37
  162. #define KVM_EXIT_LOONGARCH_IOCSR 38
  163. #define KVM_EXIT_MEMORY_FAULT 39
  164. /* For KVM_EXIT_INTERNAL_ERROR */
  165. /* Emulate instruction failed. */
  166. #define KVM_INTERNAL_ERROR_EMULATION 1
  167. /* Encounter unexpected simultaneous exceptions. */
  168. #define KVM_INTERNAL_ERROR_SIMUL_EX 2
  169. /* Encounter unexpected vm-exit due to delivery event. */
  170. #define KVM_INTERNAL_ERROR_DELIVERY_EV 3
  171. /* Encounter unexpected vm-exit reason */
  172. #define KVM_INTERNAL_ERROR_UNEXPECTED_EXIT_REASON 4
  173. /* Flags that describe what fields in emulation_failure hold valid data. */
  174. #define KVM_INTERNAL_ERROR_EMULATION_FLAG_INSTRUCTION_BYTES (1ULL << 0)
  175. /*
  176. * struct kvm_run can be modified by userspace at any time, so KVM must be
  177. * careful to avoid TOCTOU bugs. In order to protect KVM, HINT_UNSAFE_IN_KVM()
  178. * renames fields in struct kvm_run from <symbol> to <symbol>__unsafe when
  179. * compiled into the kernel, ensuring that any use within KVM is obvious and
  180. * gets extra scrutiny.
  181. */
  182. #define HINT_UNSAFE_IN_KVM(_symbol) _symbol
  183. /* for KVM_RUN, returned by mmap(vcpu_fd, offset=0) */
  184. struct kvm_run {
  185. /* in */
  186. __u8 request_interrupt_window;
  187. __u8 HINT_UNSAFE_IN_KVM(immediate_exit);
  188. __u8 padding1[6];
  189. /* out */
  190. __u32 exit_reason;
  191. __u8 ready_for_interrupt_injection;
  192. __u8 if_flag;
  193. __u16 flags;
  194. /* in (pre_kvm_run), out (post_kvm_run) */
  195. __u64 cr8;
  196. __u64 apic_base;
  197. #ifdef __KVM_S390
  198. /* the processor status word for s390 */
  199. __u64 psw_mask; /* psw upper half */
  200. __u64 psw_addr; /* psw lower half */
  201. #endif
  202. union {
  203. /* KVM_EXIT_UNKNOWN */
  204. struct {
  205. __u64 hardware_exit_reason;
  206. } hw;
  207. /* KVM_EXIT_FAIL_ENTRY */
  208. struct {
  209. __u64 hardware_entry_failure_reason;
  210. __u32 cpu;
  211. } fail_entry;
  212. /* KVM_EXIT_EXCEPTION */
  213. struct {
  214. __u32 exception;
  215. __u32 error_code;
  216. } ex;
  217. /* KVM_EXIT_IO */
  218. struct {
  219. #define KVM_EXIT_IO_IN 0
  220. #define KVM_EXIT_IO_OUT 1
  221. __u8 direction;
  222. __u8 size; /* bytes */
  223. __u16 port;
  224. __u32 count;
  225. __u64 data_offset; /* relative to kvm_run start */
  226. } io;
  227. /* KVM_EXIT_DEBUG */
  228. struct {
  229. struct kvm_debug_exit_arch arch;
  230. } debug;
  231. /* KVM_EXIT_MMIO */
  232. struct {
  233. __u64 phys_addr;
  234. __u8 data[8];
  235. __u32 len;
  236. __u8 is_write;
  237. } mmio;
  238. /* KVM_EXIT_LOONGARCH_IOCSR */
  239. struct {
  240. __u64 phys_addr;
  241. __u8 data[8];
  242. __u32 len;
  243. __u8 is_write;
  244. } iocsr_io;
  245. /* KVM_EXIT_HYPERCALL */
  246. struct {
  247. __u64 nr;
  248. __u64 args[6];
  249. __u64 ret;
  250. union {
  251. __u32 longmode;
  252. __u64 flags;
  253. };
  254. } hypercall;
  255. /* KVM_EXIT_TPR_ACCESS */
  256. struct {
  257. __u64 rip;
  258. __u32 is_write;
  259. __u32 pad;
  260. } tpr_access;
  261. /* KVM_EXIT_S390_SIEIC */
  262. struct {
  263. __u8 icptcode;
  264. __u16 ipa;
  265. __u32 ipb;
  266. } s390_sieic;
  267. /* KVM_EXIT_S390_RESET */
  268. __u64 s390_reset_flags;
  269. /* KVM_EXIT_S390_UCONTROL */
  270. struct {
  271. __u64 trans_exc_code;
  272. __u32 pgm_code;
  273. } s390_ucontrol;
  274. /* KVM_EXIT_DCR (deprecated) */
  275. struct {
  276. __u32 dcrn;
  277. __u32 data;
  278. __u8 is_write;
  279. } dcr;
  280. /* KVM_EXIT_INTERNAL_ERROR */
  281. struct {
  282. __u32 suberror;
  283. /* Available with KVM_CAP_INTERNAL_ERROR_DATA: */
  284. __u32 ndata;
  285. __u64 data[16];
  286. } internal;
  287. /*
  288. * KVM_INTERNAL_ERROR_EMULATION
  289. *
  290. * "struct emulation_failure" is an overlay of "struct internal"
  291. * that is used for the KVM_INTERNAL_ERROR_EMULATION sub-type of
  292. * KVM_EXIT_INTERNAL_ERROR. Note, unlike other internal error
  293. * sub-types, this struct is ABI! It also needs to be backwards
  294. * compatible with "struct internal". Take special care that
  295. * "ndata" is correct, that new fields are enumerated in "flags",
  296. * and that each flag enumerates fields that are 64-bit aligned
  297. * and sized (so that ndata+internal.data[] is valid/accurate).
  298. *
  299. * Space beyond the defined fields may be used to store arbitrary
  300. * debug information relating to the emulation failure. It is
  301. * accounted for in "ndata" but the format is unspecified and is
  302. * not represented in "flags". Any such information is *not* ABI!
  303. */
  304. struct {
  305. __u32 suberror;
  306. __u32 ndata;
  307. __u64 flags;
  308. union {
  309. struct {
  310. __u8 insn_size;
  311. __u8 insn_bytes[15];
  312. };
  313. };
  314. /* Arbitrary debug data may follow. */
  315. } emulation_failure;
  316. /* KVM_EXIT_OSI */
  317. struct {
  318. __u64 gprs[32];
  319. } osi;
  320. /* KVM_EXIT_PAPR_HCALL */
  321. struct {
  322. __u64 nr;
  323. __u64 ret;
  324. __u64 args[9];
  325. } papr_hcall;
  326. /* KVM_EXIT_S390_TSCH */
  327. struct {
  328. __u16 subchannel_id;
  329. __u16 subchannel_nr;
  330. __u32 io_int_parm;
  331. __u32 io_int_word;
  332. __u32 ipb;
  333. __u8 dequeued;
  334. } s390_tsch;
  335. /* KVM_EXIT_EPR */
  336. struct {
  337. __u32 epr;
  338. } epr;
  339. /* KVM_EXIT_SYSTEM_EVENT */
  340. struct {
  341. #define KVM_SYSTEM_EVENT_SHUTDOWN 1
  342. #define KVM_SYSTEM_EVENT_RESET 2
  343. #define KVM_SYSTEM_EVENT_CRASH 3
  344. #define KVM_SYSTEM_EVENT_WAKEUP 4
  345. #define KVM_SYSTEM_EVENT_SUSPEND 5
  346. #define KVM_SYSTEM_EVENT_SEV_TERM 6
  347. __u32 type;
  348. __u32 ndata;
  349. union {
  350. __u64 flags;
  351. __u64 data[16];
  352. };
  353. } system_event;
  354. /* KVM_EXIT_S390_STSI */
  355. struct {
  356. __u64 addr;
  357. __u8 ar;
  358. __u8 reserved;
  359. __u8 fc;
  360. __u8 sel1;
  361. __u16 sel2;
  362. } s390_stsi;
  363. /* KVM_EXIT_IOAPIC_EOI */
  364. struct {
  365. __u8 vector;
  366. } eoi;
  367. /* KVM_EXIT_HYPERV */
  368. struct kvm_hyperv_exit hyperv;
  369. /* KVM_EXIT_ARM_NISV */
  370. struct {
  371. __u64 esr_iss;
  372. __u64 fault_ipa;
  373. } arm_nisv;
  374. /* KVM_EXIT_X86_RDMSR / KVM_EXIT_X86_WRMSR */
  375. struct {
  376. __u8 error; /* user -> kernel */
  377. __u8 pad[7];
  378. #define KVM_MSR_EXIT_REASON_INVAL (1 << 0)
  379. #define KVM_MSR_EXIT_REASON_UNKNOWN (1 << 1)
  380. #define KVM_MSR_EXIT_REASON_FILTER (1 << 2)
  381. #define KVM_MSR_EXIT_REASON_VALID_MASK (KVM_MSR_EXIT_REASON_INVAL | \
  382. KVM_MSR_EXIT_REASON_UNKNOWN | \
  383. KVM_MSR_EXIT_REASON_FILTER)
  384. __u32 reason; /* kernel -> user */
  385. __u32 index; /* kernel -> user */
  386. __u64 data; /* kernel <-> user */
  387. } msr;
  388. /* KVM_EXIT_XEN */
  389. struct kvm_xen_exit xen;
  390. /* KVM_EXIT_RISCV_SBI */
  391. struct {
  392. unsigned long extension_id;
  393. unsigned long function_id;
  394. unsigned long args[6];
  395. unsigned long ret[2];
  396. } riscv_sbi;
  397. /* KVM_EXIT_RISCV_CSR */
  398. struct {
  399. unsigned long csr_num;
  400. unsigned long new_value;
  401. unsigned long write_mask;
  402. unsigned long ret_value;
  403. } riscv_csr;
  404. /* KVM_EXIT_NOTIFY */
  405. struct {
  406. #define KVM_NOTIFY_CONTEXT_INVALID (1 << 0)
  407. __u32 flags;
  408. } notify;
  409. /* KVM_EXIT_MEMORY_FAULT */
  410. struct {
  411. #define KVM_MEMORY_EXIT_FLAG_PRIVATE (1ULL << 3)
  412. __u64 flags;
  413. __u64 gpa;
  414. __u64 size;
  415. } memory_fault;
  416. /* Fix the size of the union. */
  417. char padding[256];
  418. };
  419. /* 2048 is the size of the char array used to bound/pad the size
  420. * of the union that holds sync regs.
  421. */
  422. #define SYNC_REGS_SIZE_BYTES 2048
  423. /*
  424. * shared registers between kvm and userspace.
  425. * kvm_valid_regs specifies the register classes set by the host
  426. * kvm_dirty_regs specified the register classes dirtied by userspace
  427. * struct kvm_sync_regs is architecture specific, as well as the
  428. * bits for kvm_valid_regs and kvm_dirty_regs
  429. */
  430. __u64 kvm_valid_regs;
  431. __u64 kvm_dirty_regs;
  432. union {
  433. struct kvm_sync_regs regs;
  434. char padding[SYNC_REGS_SIZE_BYTES];
  435. } s;
  436. };
  437. /* for KVM_REGISTER_COALESCED_MMIO / KVM_UNREGISTER_COALESCED_MMIO */
  438. struct kvm_coalesced_mmio_zone {
  439. __u64 addr;
  440. __u32 size;
  441. union {
  442. __u32 pad;
  443. __u32 pio;
  444. };
  445. };
  446. struct kvm_coalesced_mmio {
  447. __u64 phys_addr;
  448. __u32 len;
  449. union {
  450. __u32 pad;
  451. __u32 pio;
  452. };
  453. __u8 data[8];
  454. };
  455. struct kvm_coalesced_mmio_ring {
  456. __u32 first, last;
  457. struct kvm_coalesced_mmio coalesced_mmio[];
  458. };
  459. #define KVM_COALESCED_MMIO_MAX \
  460. ((PAGE_SIZE - sizeof(struct kvm_coalesced_mmio_ring)) / \
  461. sizeof(struct kvm_coalesced_mmio))
  462. /* for KVM_TRANSLATE */
  463. struct kvm_translation {
  464. /* in */
  465. __u64 linear_address;
  466. /* out */
  467. __u64 physical_address;
  468. __u8 valid;
  469. __u8 writeable;
  470. __u8 usermode;
  471. __u8 pad[5];
  472. };
  473. /* for KVM_INTERRUPT */
  474. struct kvm_interrupt {
  475. /* in */
  476. __u32 irq;
  477. };
  478. /* for KVM_GET_DIRTY_LOG */
  479. struct kvm_dirty_log {
  480. __u32 slot;
  481. __u32 padding1;
  482. union {
  483. void *dirty_bitmap; /* one bit per page */
  484. __u64 padding2;
  485. };
  486. };
  487. /* for KVM_CLEAR_DIRTY_LOG */
  488. struct kvm_clear_dirty_log {
  489. __u32 slot;
  490. __u32 num_pages;
  491. __u64 first_page;
  492. union {
  493. void *dirty_bitmap; /* one bit per page */
  494. __u64 padding2;
  495. };
  496. };
  497. /* for KVM_SET_SIGNAL_MASK */
  498. struct kvm_signal_mask {
  499. __u32 len;
  500. __u8 sigset[];
  501. };
  502. /* for KVM_TPR_ACCESS_REPORTING */
  503. struct kvm_tpr_access_ctl {
  504. __u32 enabled;
  505. __u32 flags;
  506. __u32 reserved[8];
  507. };
  508. /* for KVM_SET_VAPIC_ADDR */
  509. struct kvm_vapic_addr {
  510. __u64 vapic_addr;
  511. };
  512. /* for KVM_SET_MP_STATE */
  513. /* not all states are valid on all architectures */
  514. #define KVM_MP_STATE_RUNNABLE 0
  515. #define KVM_MP_STATE_UNINITIALIZED 1
  516. #define KVM_MP_STATE_INIT_RECEIVED 2
  517. #define KVM_MP_STATE_HALTED 3
  518. #define KVM_MP_STATE_SIPI_RECEIVED 4
  519. #define KVM_MP_STATE_STOPPED 5
  520. #define KVM_MP_STATE_CHECK_STOP 6
  521. #define KVM_MP_STATE_OPERATING 7
  522. #define KVM_MP_STATE_LOAD 8
  523. #define KVM_MP_STATE_AP_RESET_HOLD 9
  524. #define KVM_MP_STATE_SUSPENDED 10
  525. struct kvm_mp_state {
  526. __u32 mp_state;
  527. };
  528. /* for KVM_SET_GUEST_DEBUG */
  529. #define KVM_GUESTDBG_ENABLE 0x00000001
  530. #define KVM_GUESTDBG_SINGLESTEP 0x00000002
  531. struct kvm_guest_debug {
  532. __u32 control;
  533. __u32 pad;
  534. struct kvm_guest_debug_arch arch;
  535. };
  536. enum {
  537. kvm_ioeventfd_flag_nr_datamatch,
  538. kvm_ioeventfd_flag_nr_pio,
  539. kvm_ioeventfd_flag_nr_deassign,
  540. kvm_ioeventfd_flag_nr_virtio_ccw_notify,
  541. kvm_ioeventfd_flag_nr_fast_mmio,
  542. kvm_ioeventfd_flag_nr_max,
  543. };
  544. #define KVM_IOEVENTFD_FLAG_DATAMATCH (1 << kvm_ioeventfd_flag_nr_datamatch)
  545. #define KVM_IOEVENTFD_FLAG_PIO (1 << kvm_ioeventfd_flag_nr_pio)
  546. #define KVM_IOEVENTFD_FLAG_DEASSIGN (1 << kvm_ioeventfd_flag_nr_deassign)
  547. #define KVM_IOEVENTFD_FLAG_VIRTIO_CCW_NOTIFY \
  548. (1 << kvm_ioeventfd_flag_nr_virtio_ccw_notify)
  549. #define KVM_IOEVENTFD_VALID_FLAG_MASK ((1 << kvm_ioeventfd_flag_nr_max) - 1)
  550. struct kvm_ioeventfd {
  551. __u64 datamatch;
  552. __u64 addr; /* legal pio/mmio address */
  553. __u32 len; /* 1, 2, 4, or 8 bytes; or 0 to ignore length */
  554. __s32 fd;
  555. __u32 flags;
  556. __u8 pad[36];
  557. };
  558. #define KVM_X86_DISABLE_EXITS_MWAIT (1 << 0)
  559. #define KVM_X86_DISABLE_EXITS_HLT (1 << 1)
  560. #define KVM_X86_DISABLE_EXITS_PAUSE (1 << 2)
  561. #define KVM_X86_DISABLE_EXITS_CSTATE (1 << 3)
  562. #define KVM_X86_DISABLE_VALID_EXITS (KVM_X86_DISABLE_EXITS_MWAIT | \
  563. KVM_X86_DISABLE_EXITS_HLT | \
  564. KVM_X86_DISABLE_EXITS_PAUSE | \
  565. KVM_X86_DISABLE_EXITS_CSTATE)
  566. /* for KVM_ENABLE_CAP */
  567. struct kvm_enable_cap {
  568. /* in */
  569. __u32 cap;
  570. __u32 flags;
  571. __u64 args[4];
  572. __u8 pad[64];
  573. };
  574. #define KVMIO 0xAE
  575. /* machine type bits, to be used as argument to KVM_CREATE_VM */
  576. #define KVM_VM_S390_UCONTROL 1
  577. /* on ppc, 0 indicate default, 1 should force HV and 2 PR */
  578. #define KVM_VM_PPC_HV 1
  579. #define KVM_VM_PPC_PR 2
  580. /* on MIPS, 0 indicates auto, 1 forces VZ ASE, 2 forces trap & emulate */
  581. #define KVM_VM_MIPS_AUTO 0
  582. #define KVM_VM_MIPS_VZ 1
  583. #define KVM_VM_MIPS_TE 2
  584. #define KVM_S390_SIE_PAGE_OFFSET 1
  585. /*
  586. * On arm64, machine type can be used to request the physical
  587. * address size for the VM. Bits[7-0] are reserved for the guest
  588. * PA size shift (i.e, log2(PA_Size)). For backward compatibility,
  589. * value 0 implies the default IPA size, 40bits.
  590. */
  591. #define KVM_VM_TYPE_ARM_IPA_SIZE_MASK 0xffULL
  592. #define KVM_VM_TYPE_ARM_IPA_SIZE(x) \
  593. ((x) & KVM_VM_TYPE_ARM_IPA_SIZE_MASK)
  594. /*
  595. * ioctls for /dev/kvm fds:
  596. */
  597. #define KVM_GET_API_VERSION _IO(KVMIO, 0x00)
  598. #define KVM_CREATE_VM _IO(KVMIO, 0x01) /* returns a VM fd */
  599. #define KVM_GET_MSR_INDEX_LIST _IOWR(KVMIO, 0x02, struct kvm_msr_list)
  600. #define KVM_S390_ENABLE_SIE _IO(KVMIO, 0x06)
  601. /*
  602. * Check if a kvm extension is available. Argument is extension number,
  603. * return is 1 (yes) or 0 (no, sorry).
  604. */
  605. #define KVM_CHECK_EXTENSION _IO(KVMIO, 0x03)
  606. /*
  607. * Get size for mmap(vcpu_fd)
  608. */
  609. #define KVM_GET_VCPU_MMAP_SIZE _IO(KVMIO, 0x04) /* in bytes */
  610. #define KVM_GET_SUPPORTED_CPUID _IOWR(KVMIO, 0x05, struct kvm_cpuid2)
  611. #define KVM_GET_EMULATED_CPUID _IOWR(KVMIO, 0x09, struct kvm_cpuid2)
  612. #define KVM_GET_MSR_FEATURE_INDEX_LIST _IOWR(KVMIO, 0x0a, struct kvm_msr_list)
  613. /*
  614. * Extension capability list.
  615. */
  616. #define KVM_CAP_IRQCHIP 0
  617. #define KVM_CAP_HLT 1
  618. #define KVM_CAP_MMU_SHADOW_CACHE_CONTROL 2
  619. #define KVM_CAP_USER_MEMORY 3
  620. #define KVM_CAP_SET_TSS_ADDR 4
  621. #define KVM_CAP_VAPIC 6
  622. #define KVM_CAP_EXT_CPUID 7
  623. #define KVM_CAP_CLOCKSOURCE 8
  624. #define KVM_CAP_NR_VCPUS 9 /* returns recommended max vcpus per vm */
  625. #define KVM_CAP_NR_MEMSLOTS 10 /* returns max memory slots per vm */
  626. #define KVM_CAP_PIT 11
  627. #define KVM_CAP_NOP_IO_DELAY 12
  628. #define KVM_CAP_PV_MMU 13
  629. #define KVM_CAP_MP_STATE 14
  630. #define KVM_CAP_COALESCED_MMIO 15
  631. #define KVM_CAP_SYNC_MMU 16 /* Changes to host mmap are reflected in guest */
  632. #define KVM_CAP_IOMMU 18
  633. /* Bug in KVM_SET_USER_MEMORY_REGION fixed: */
  634. #define KVM_CAP_DESTROY_MEMORY_REGION_WORKS 21
  635. #define KVM_CAP_USER_NMI 22
  636. #define KVM_CAP_SET_GUEST_DEBUG 23
  637. #ifdef __KVM_HAVE_PIT
  638. #define KVM_CAP_REINJECT_CONTROL 24
  639. #endif
  640. #define KVM_CAP_IRQ_ROUTING 25
  641. #define KVM_CAP_IRQ_INJECT_STATUS 26
  642. #define KVM_CAP_ASSIGN_DEV_IRQ 29
  643. /* Another bug in KVM_SET_USER_MEMORY_REGION fixed: */
  644. #define KVM_CAP_JOIN_MEMORY_REGIONS_WORKS 30
  645. #ifdef __KVM_HAVE_MCE
  646. #define KVM_CAP_MCE 31
  647. #endif
  648. #define KVM_CAP_IRQFD 32
  649. #ifdef __KVM_HAVE_PIT
  650. #define KVM_CAP_PIT2 33
  651. #endif
  652. #define KVM_CAP_SET_BOOT_CPU_ID 34
  653. #ifdef __KVM_HAVE_PIT_STATE2
  654. #define KVM_CAP_PIT_STATE2 35
  655. #endif
  656. #define KVM_CAP_IOEVENTFD 36
  657. #define KVM_CAP_SET_IDENTITY_MAP_ADDR 37
  658. #ifdef __KVM_HAVE_XEN_HVM
  659. #define KVM_CAP_XEN_HVM 38
  660. #endif
  661. #define KVM_CAP_ADJUST_CLOCK 39
  662. #define KVM_CAP_INTERNAL_ERROR_DATA 40
  663. #ifdef __KVM_HAVE_VCPU_EVENTS
  664. #define KVM_CAP_VCPU_EVENTS 41
  665. #endif
  666. #define KVM_CAP_S390_PSW 42
  667. #define KVM_CAP_PPC_SEGSTATE 43
  668. #define KVM_CAP_HYPERV 44
  669. #define KVM_CAP_HYPERV_VAPIC 45
  670. #define KVM_CAP_HYPERV_SPIN 46
  671. #define KVM_CAP_PCI_SEGMENT 47
  672. #define KVM_CAP_PPC_PAIRED_SINGLES 48
  673. #define KVM_CAP_INTR_SHADOW 49
  674. #ifdef __KVM_HAVE_DEBUGREGS
  675. #define KVM_CAP_DEBUGREGS 50
  676. #endif
  677. #define KVM_CAP_X86_ROBUST_SINGLESTEP 51
  678. #define KVM_CAP_PPC_OSI 52
  679. #define KVM_CAP_PPC_UNSET_IRQ 53
  680. #define KVM_CAP_ENABLE_CAP 54
  681. #ifdef __KVM_HAVE_XSAVE
  682. #define KVM_CAP_XSAVE 55
  683. #endif
  684. #ifdef __KVM_HAVE_XCRS
  685. #define KVM_CAP_XCRS 56
  686. #endif
  687. #define KVM_CAP_PPC_GET_PVINFO 57
  688. #define KVM_CAP_PPC_IRQ_LEVEL 58
  689. #define KVM_CAP_ASYNC_PF 59
  690. #define KVM_CAP_TSC_CONTROL 60
  691. #define KVM_CAP_GET_TSC_KHZ 61
  692. #define KVM_CAP_PPC_BOOKE_SREGS 62
  693. #define KVM_CAP_SPAPR_TCE 63
  694. #define KVM_CAP_PPC_SMT 64
  695. #define KVM_CAP_PPC_RMA 65
  696. #define KVM_CAP_MAX_VCPUS 66 /* returns max vcpus per vm */
  697. #define KVM_CAP_PPC_HIOR 67
  698. #define KVM_CAP_PPC_PAPR 68
  699. #define KVM_CAP_SW_TLB 69
  700. #define KVM_CAP_ONE_REG 70
  701. #define KVM_CAP_S390_GMAP 71
  702. #define KVM_CAP_TSC_DEADLINE_TIMER 72
  703. #define KVM_CAP_S390_UCONTROL 73
  704. #define KVM_CAP_SYNC_REGS 74
  705. #define KVM_CAP_PCI_2_3 75
  706. #define KVM_CAP_KVMCLOCK_CTRL 76
  707. #define KVM_CAP_SIGNAL_MSI 77
  708. #define KVM_CAP_PPC_GET_SMMU_INFO 78
  709. #define KVM_CAP_S390_COW 79
  710. #define KVM_CAP_PPC_ALLOC_HTAB 80
  711. #define KVM_CAP_READONLY_MEM 81
  712. #define KVM_CAP_IRQFD_RESAMPLE 82
  713. #define KVM_CAP_PPC_BOOKE_WATCHDOG 83
  714. #define KVM_CAP_PPC_HTAB_FD 84
  715. #define KVM_CAP_S390_CSS_SUPPORT 85
  716. #define KVM_CAP_PPC_EPR 86
  717. #define KVM_CAP_ARM_PSCI 87
  718. #define KVM_CAP_ARM_SET_DEVICE_ADDR 88
  719. #define KVM_CAP_DEVICE_CTRL 89
  720. #define KVM_CAP_IRQ_MPIC 90
  721. #define KVM_CAP_PPC_RTAS 91
  722. #define KVM_CAP_IRQ_XICS 92
  723. #define KVM_CAP_ARM_EL1_32BIT 93
  724. #define KVM_CAP_SPAPR_MULTITCE 94
  725. #define KVM_CAP_EXT_EMUL_CPUID 95
  726. #define KVM_CAP_HYPERV_TIME 96
  727. #define KVM_CAP_IOAPIC_POLARITY_IGNORED 97
  728. #define KVM_CAP_ENABLE_CAP_VM 98
  729. #define KVM_CAP_S390_IRQCHIP 99
  730. #define KVM_CAP_IOEVENTFD_NO_LENGTH 100
  731. #define KVM_CAP_VM_ATTRIBUTES 101
  732. #define KVM_CAP_ARM_PSCI_0_2 102
  733. #define KVM_CAP_PPC_FIXUP_HCALL 103
  734. #define KVM_CAP_PPC_ENABLE_HCALL 104
  735. #define KVM_CAP_CHECK_EXTENSION_VM 105
  736. #define KVM_CAP_S390_USER_SIGP 106
  737. #define KVM_CAP_S390_VECTOR_REGISTERS 107
  738. #define KVM_CAP_S390_MEM_OP 108
  739. #define KVM_CAP_S390_USER_STSI 109
  740. #define KVM_CAP_S390_SKEYS 110
  741. #define KVM_CAP_MIPS_FPU 111
  742. #define KVM_CAP_MIPS_MSA 112
  743. #define KVM_CAP_S390_INJECT_IRQ 113
  744. #define KVM_CAP_S390_IRQ_STATE 114
  745. #define KVM_CAP_PPC_HWRNG 115
  746. #define KVM_CAP_DISABLE_QUIRKS 116
  747. #define KVM_CAP_X86_SMM 117
  748. #define KVM_CAP_MULTI_ADDRESS_SPACE 118
  749. #define KVM_CAP_GUEST_DEBUG_HW_BPS 119
  750. #define KVM_CAP_GUEST_DEBUG_HW_WPS 120
  751. #define KVM_CAP_SPLIT_IRQCHIP 121
  752. #define KVM_CAP_IOEVENTFD_ANY_LENGTH 122
  753. #define KVM_CAP_HYPERV_SYNIC 123
  754. #define KVM_CAP_S390_RI 124
  755. #define KVM_CAP_SPAPR_TCE_64 125
  756. #define KVM_CAP_ARM_PMU_V3 126
  757. #define KVM_CAP_VCPU_ATTRIBUTES 127
  758. #define KVM_CAP_MAX_VCPU_ID 128
  759. #define KVM_CAP_X2APIC_API 129
  760. #define KVM_CAP_S390_USER_INSTR0 130
  761. #define KVM_CAP_MSI_DEVID 131
  762. #define KVM_CAP_PPC_HTM 132
  763. #define KVM_CAP_SPAPR_RESIZE_HPT 133
  764. #define KVM_CAP_PPC_MMU_RADIX 134
  765. #define KVM_CAP_PPC_MMU_HASH_V3 135
  766. #define KVM_CAP_IMMEDIATE_EXIT 136
  767. #define KVM_CAP_MIPS_VZ 137
  768. #define KVM_CAP_MIPS_TE 138
  769. #define KVM_CAP_MIPS_64BIT 139
  770. #define KVM_CAP_S390_GS 140
  771. #define KVM_CAP_S390_AIS 141
  772. #define KVM_CAP_SPAPR_TCE_VFIO 142
  773. #define KVM_CAP_X86_DISABLE_EXITS 143
  774. #define KVM_CAP_ARM_USER_IRQ 144
  775. #define KVM_CAP_S390_CMMA_MIGRATION 145
  776. #define KVM_CAP_PPC_FWNMI 146
  777. #define KVM_CAP_PPC_SMT_POSSIBLE 147
  778. #define KVM_CAP_HYPERV_SYNIC2 148
  779. #define KVM_CAP_HYPERV_VP_INDEX 149
  780. #define KVM_CAP_S390_AIS_MIGRATION 150
  781. #define KVM_CAP_PPC_GET_CPU_CHAR 151
  782. #define KVM_CAP_S390_BPB 152
  783. #define KVM_CAP_GET_MSR_FEATURES 153
  784. #define KVM_CAP_HYPERV_EVENTFD 154
  785. #define KVM_CAP_HYPERV_TLBFLUSH 155
  786. #define KVM_CAP_S390_HPAGE_1M 156
  787. #define KVM_CAP_NESTED_STATE 157
  788. #define KVM_CAP_ARM_INJECT_SERROR_ESR 158
  789. #define KVM_CAP_MSR_PLATFORM_INFO 159
  790. #define KVM_CAP_PPC_NESTED_HV 160
  791. #define KVM_CAP_HYPERV_SEND_IPI 161
  792. #define KVM_CAP_COALESCED_PIO 162
  793. #define KVM_CAP_HYPERV_ENLIGHTENED_VMCS 163
  794. #define KVM_CAP_EXCEPTION_PAYLOAD 164
  795. #define KVM_CAP_ARM_VM_IPA_SIZE 165
  796. #define KVM_CAP_MANUAL_DIRTY_LOG_PROTECT 166 /* Obsolete */
  797. #define KVM_CAP_HYPERV_CPUID 167
  798. #define KVM_CAP_MANUAL_DIRTY_LOG_PROTECT2 168
  799. #define KVM_CAP_PPC_IRQ_XIVE 169
  800. #define KVM_CAP_ARM_SVE 170
  801. #define KVM_CAP_ARM_PTRAUTH_ADDRESS 171
  802. #define KVM_CAP_ARM_PTRAUTH_GENERIC 172
  803. #define KVM_CAP_PMU_EVENT_FILTER 173
  804. #define KVM_CAP_ARM_IRQ_LINE_LAYOUT_2 174
  805. #define KVM_CAP_HYPERV_DIRECT_TLBFLUSH 175
  806. #define KVM_CAP_PPC_GUEST_DEBUG_SSTEP 176
  807. #define KVM_CAP_ARM_NISV_TO_USER 177
  808. #define KVM_CAP_ARM_INJECT_EXT_DABT 178
  809. #define KVM_CAP_S390_VCPU_RESETS 179
  810. #define KVM_CAP_S390_PROTECTED 180
  811. #define KVM_CAP_PPC_SECURE_GUEST 181
  812. #define KVM_CAP_HALT_POLL 182
  813. #define KVM_CAP_ASYNC_PF_INT 183
  814. #define KVM_CAP_LAST_CPU 184
  815. #define KVM_CAP_SMALLER_MAXPHYADDR 185
  816. #define KVM_CAP_S390_DIAG318 186
  817. #define KVM_CAP_STEAL_TIME 187
  818. #define KVM_CAP_X86_USER_SPACE_MSR 188
  819. #define KVM_CAP_X86_MSR_FILTER 189
  820. #define KVM_CAP_ENFORCE_PV_FEATURE_CPUID 190
  821. #define KVM_CAP_SYS_HYPERV_CPUID 191
  822. #define KVM_CAP_DIRTY_LOG_RING 192
  823. #define KVM_CAP_X86_BUS_LOCK_EXIT 193
  824. #define KVM_CAP_PPC_DAWR1 194
  825. #define KVM_CAP_SET_GUEST_DEBUG2 195
  826. #define KVM_CAP_SGX_ATTRIBUTE 196
  827. #define KVM_CAP_VM_COPY_ENC_CONTEXT_FROM 197
  828. #define KVM_CAP_PTP_KVM 198
  829. #define KVM_CAP_HYPERV_ENFORCE_CPUID 199
  830. #define KVM_CAP_SREGS2 200
  831. #define KVM_CAP_EXIT_HYPERCALL 201
  832. #define KVM_CAP_PPC_RPT_INVALIDATE 202
  833. #define KVM_CAP_BINARY_STATS_FD 203
  834. #define KVM_CAP_EXIT_ON_EMULATION_FAILURE 204
  835. #define KVM_CAP_ARM_MTE 205
  836. #define KVM_CAP_VM_MOVE_ENC_CONTEXT_FROM 206
  837. #define KVM_CAP_VM_GPA_BITS 207
  838. #define KVM_CAP_XSAVE2 208
  839. #define KVM_CAP_SYS_ATTRIBUTES 209
  840. #define KVM_CAP_PPC_AIL_MODE_3 210
  841. #define KVM_CAP_S390_MEM_OP_EXTENSION 211
  842. #define KVM_CAP_PMU_CAPABILITY 212
  843. #define KVM_CAP_DISABLE_QUIRKS2 213
  844. #define KVM_CAP_VM_TSC_CONTROL 214
  845. #define KVM_CAP_SYSTEM_EVENT_DATA 215
  846. #define KVM_CAP_ARM_SYSTEM_SUSPEND 216
  847. #define KVM_CAP_S390_PROTECTED_DUMP 217
  848. #define KVM_CAP_X86_TRIPLE_FAULT_EVENT 218
  849. #define KVM_CAP_X86_NOTIFY_VMEXIT 219
  850. #define KVM_CAP_VM_DISABLE_NX_HUGE_PAGES 220
  851. #define KVM_CAP_S390_ZPCI_OP 221
  852. #define KVM_CAP_S390_CPU_TOPOLOGY 222
  853. #define KVM_CAP_DIRTY_LOG_RING_ACQ_REL 223
  854. #define KVM_CAP_S390_PROTECTED_ASYNC_DISABLE 224
  855. #define KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP 225
  856. #define KVM_CAP_PMU_EVENT_MASKED_EVENTS 226
  857. #define KVM_CAP_COUNTER_OFFSET 227
  858. #define KVM_CAP_ARM_EAGER_SPLIT_CHUNK_SIZE 228
  859. #define KVM_CAP_ARM_SUPPORTED_BLOCK_SIZES 229
  860. #define KVM_CAP_ARM_SUPPORTED_REG_MASK_RANGES 230
  861. #define KVM_CAP_USER_MEMORY2 231
  862. #define KVM_CAP_MEMORY_FAULT_INFO 232
  863. #define KVM_CAP_MEMORY_ATTRIBUTES 233
  864. #define KVM_CAP_GUEST_MEMFD 234
  865. #define KVM_CAP_VM_TYPES 235
  866. #define KVM_CAP_PRE_FAULT_MEMORY 236
  867. #define KVM_CAP_X86_APIC_BUS_CYCLES_NS 237
  868. #define KVM_CAP_X86_GUEST_MODE 238
  869. struct kvm_irq_routing_irqchip {
  870. __u32 irqchip;
  871. __u32 pin;
  872. };
  873. struct kvm_irq_routing_msi {
  874. __u32 address_lo;
  875. __u32 address_hi;
  876. __u32 data;
  877. union {
  878. __u32 pad;
  879. __u32 devid;
  880. };
  881. };
  882. struct kvm_irq_routing_s390_adapter {
  883. __u64 ind_addr;
  884. __u64 summary_addr;
  885. __u64 ind_offset;
  886. __u32 summary_offset;
  887. __u32 adapter_id;
  888. };
  889. struct kvm_irq_routing_hv_sint {
  890. __u32 vcpu;
  891. __u32 sint;
  892. };
  893. struct kvm_irq_routing_xen_evtchn {
  894. __u32 port;
  895. __u32 vcpu;
  896. __u32 priority;
  897. };
  898. #define KVM_IRQ_ROUTING_XEN_EVTCHN_PRIO_2LEVEL ((__u32)(-1))
  899. /* gsi routing entry types */
  900. #define KVM_IRQ_ROUTING_IRQCHIP 1
  901. #define KVM_IRQ_ROUTING_MSI 2
  902. #define KVM_IRQ_ROUTING_S390_ADAPTER 3
  903. #define KVM_IRQ_ROUTING_HV_SINT 4
  904. #define KVM_IRQ_ROUTING_XEN_EVTCHN 5
  905. struct kvm_irq_routing_entry {
  906. __u32 gsi;
  907. __u32 type;
  908. __u32 flags;
  909. __u32 pad;
  910. union {
  911. struct kvm_irq_routing_irqchip irqchip;
  912. struct kvm_irq_routing_msi msi;
  913. struct kvm_irq_routing_s390_adapter adapter;
  914. struct kvm_irq_routing_hv_sint hv_sint;
  915. struct kvm_irq_routing_xen_evtchn xen_evtchn;
  916. __u32 pad[8];
  917. } u;
  918. };
  919. struct kvm_irq_routing {
  920. __u32 nr;
  921. __u32 flags;
  922. struct kvm_irq_routing_entry entries[];
  923. };
  924. #define KVM_IRQFD_FLAG_DEASSIGN (1 << 0)
  925. /*
  926. * Available with KVM_CAP_IRQFD_RESAMPLE
  927. *
  928. * KVM_IRQFD_FLAG_RESAMPLE indicates resamplefd is valid and specifies
  929. * the irqfd to operate in resampling mode for level triggered interrupt
  930. * emulation. See Documentation/virt/kvm/api.rst.
  931. */
  932. #define KVM_IRQFD_FLAG_RESAMPLE (1 << 1)
  933. struct kvm_irqfd {
  934. __u32 fd;
  935. __u32 gsi;
  936. __u32 flags;
  937. __u32 resamplefd;
  938. __u8 pad[16];
  939. };
  940. /* For KVM_CAP_ADJUST_CLOCK */
  941. /* Do not use 1, KVM_CHECK_EXTENSION returned it before we had flags. */
  942. #define KVM_CLOCK_TSC_STABLE 2
  943. #define KVM_CLOCK_REALTIME (1 << 2)
  944. #define KVM_CLOCK_HOST_TSC (1 << 3)
  945. struct kvm_clock_data {
  946. __u64 clock;
  947. __u32 flags;
  948. __u32 pad0;
  949. __u64 realtime;
  950. __u64 host_tsc;
  951. __u32 pad[4];
  952. };
  953. /* For KVM_CAP_SW_TLB */
  954. #define KVM_MMU_FSL_BOOKE_NOHV 0
  955. #define KVM_MMU_FSL_BOOKE_HV 1
  956. struct kvm_config_tlb {
  957. __u64 params;
  958. __u64 array;
  959. __u32 mmu_type;
  960. __u32 array_len;
  961. };
  962. struct kvm_dirty_tlb {
  963. __u64 bitmap;
  964. __u32 num_dirty;
  965. };
  966. /* Available with KVM_CAP_ONE_REG */
  967. #define KVM_REG_ARCH_MASK 0xff00000000000000ULL
  968. #define KVM_REG_GENERIC 0x0000000000000000ULL
  969. /*
  970. * Architecture specific registers are to be defined in arch headers and
  971. * ORed with the arch identifier.
  972. */
  973. #define KVM_REG_PPC 0x1000000000000000ULL
  974. #define KVM_REG_X86 0x2000000000000000ULL
  975. #define KVM_REG_IA64 0x3000000000000000ULL
  976. #define KVM_REG_ARM 0x4000000000000000ULL
  977. #define KVM_REG_S390 0x5000000000000000ULL
  978. #define KVM_REG_ARM64 0x6000000000000000ULL
  979. #define KVM_REG_MIPS 0x7000000000000000ULL
  980. #define KVM_REG_RISCV 0x8000000000000000ULL
  981. #define KVM_REG_LOONGARCH 0x9000000000000000ULL
  982. #define KVM_REG_SIZE_SHIFT 52
  983. #define KVM_REG_SIZE_MASK 0x00f0000000000000ULL
  984. #define KVM_REG_SIZE_U8 0x0000000000000000ULL
  985. #define KVM_REG_SIZE_U16 0x0010000000000000ULL
  986. #define KVM_REG_SIZE_U32 0x0020000000000000ULL
  987. #define KVM_REG_SIZE_U64 0x0030000000000000ULL
  988. #define KVM_REG_SIZE_U128 0x0040000000000000ULL
  989. #define KVM_REG_SIZE_U256 0x0050000000000000ULL
  990. #define KVM_REG_SIZE_U512 0x0060000000000000ULL
  991. #define KVM_REG_SIZE_U1024 0x0070000000000000ULL
  992. #define KVM_REG_SIZE_U2048 0x0080000000000000ULL
  993. struct kvm_reg_list {
  994. __u64 n; /* number of regs */
  995. __u64 reg[];
  996. };
  997. struct kvm_one_reg {
  998. __u64 id;
  999. __u64 addr;
  1000. };
  1001. #define KVM_MSI_VALID_DEVID (1U << 0)
  1002. struct kvm_msi {
  1003. __u32 address_lo;
  1004. __u32 address_hi;
  1005. __u32 data;
  1006. __u32 flags;
  1007. __u32 devid;
  1008. __u8 pad[12];
  1009. };
  1010. struct kvm_arm_device_addr {
  1011. __u64 id;
  1012. __u64 addr;
  1013. };
  1014. /*
  1015. * Device control API, available with KVM_CAP_DEVICE_CTRL
  1016. */
  1017. #define KVM_CREATE_DEVICE_TEST 1
  1018. struct kvm_create_device {
  1019. __u32 type; /* in: KVM_DEV_TYPE_xxx */
  1020. __u32 fd; /* out: device handle */
  1021. __u32 flags; /* in: KVM_CREATE_DEVICE_xxx */
  1022. };
  1023. struct kvm_device_attr {
  1024. __u32 flags; /* no flags currently defined */
  1025. __u32 group; /* device-defined */
  1026. __u64 attr; /* group-defined */
  1027. __u64 addr; /* userspace address of attr data */
  1028. };
  1029. #define KVM_DEV_VFIO_FILE 1
  1030. #define KVM_DEV_VFIO_FILE_ADD 1
  1031. #define KVM_DEV_VFIO_FILE_DEL 2
  1032. /* KVM_DEV_VFIO_GROUP aliases are for compile time uapi compatibility */
  1033. #define KVM_DEV_VFIO_GROUP KVM_DEV_VFIO_FILE
  1034. #define KVM_DEV_VFIO_GROUP_ADD KVM_DEV_VFIO_FILE_ADD
  1035. #define KVM_DEV_VFIO_GROUP_DEL KVM_DEV_VFIO_FILE_DEL
  1036. #define KVM_DEV_VFIO_GROUP_SET_SPAPR_TCE 3
  1037. enum kvm_device_type {
  1038. KVM_DEV_TYPE_FSL_MPIC_20 = 1,
  1039. #define KVM_DEV_TYPE_FSL_MPIC_20 KVM_DEV_TYPE_FSL_MPIC_20
  1040. KVM_DEV_TYPE_FSL_MPIC_42,
  1041. #define KVM_DEV_TYPE_FSL_MPIC_42 KVM_DEV_TYPE_FSL_MPIC_42
  1042. KVM_DEV_TYPE_XICS,
  1043. #define KVM_DEV_TYPE_XICS KVM_DEV_TYPE_XICS
  1044. KVM_DEV_TYPE_VFIO,
  1045. #define KVM_DEV_TYPE_VFIO KVM_DEV_TYPE_VFIO
  1046. KVM_DEV_TYPE_ARM_VGIC_V2,
  1047. #define KVM_DEV_TYPE_ARM_VGIC_V2 KVM_DEV_TYPE_ARM_VGIC_V2
  1048. KVM_DEV_TYPE_FLIC,
  1049. #define KVM_DEV_TYPE_FLIC KVM_DEV_TYPE_FLIC
  1050. KVM_DEV_TYPE_ARM_VGIC_V3,
  1051. #define KVM_DEV_TYPE_ARM_VGIC_V3 KVM_DEV_TYPE_ARM_VGIC_V3
  1052. KVM_DEV_TYPE_ARM_VGIC_ITS,
  1053. #define KVM_DEV_TYPE_ARM_VGIC_ITS KVM_DEV_TYPE_ARM_VGIC_ITS
  1054. KVM_DEV_TYPE_XIVE,
  1055. #define KVM_DEV_TYPE_XIVE KVM_DEV_TYPE_XIVE
  1056. KVM_DEV_TYPE_ARM_PV_TIME,
  1057. #define KVM_DEV_TYPE_ARM_PV_TIME KVM_DEV_TYPE_ARM_PV_TIME
  1058. KVM_DEV_TYPE_RISCV_AIA,
  1059. #define KVM_DEV_TYPE_RISCV_AIA KVM_DEV_TYPE_RISCV_AIA
  1060. KVM_DEV_TYPE_MAX,
  1061. };
  1062. struct kvm_vfio_spapr_tce {
  1063. __s32 groupfd;
  1064. __s32 tablefd;
  1065. };
  1066. /*
  1067. * KVM_CREATE_VCPU receives as a parameter the vcpu slot, and returns
  1068. * a vcpu fd.
  1069. */
  1070. #define KVM_CREATE_VCPU _IO(KVMIO, 0x41)
  1071. #define KVM_GET_DIRTY_LOG _IOW(KVMIO, 0x42, struct kvm_dirty_log)
  1072. #define KVM_SET_NR_MMU_PAGES _IO(KVMIO, 0x44)
  1073. #define KVM_GET_NR_MMU_PAGES _IO(KVMIO, 0x45) /* deprecated */
  1074. #define KVM_SET_USER_MEMORY_REGION _IOW(KVMIO, 0x46, \
  1075. struct kvm_userspace_memory_region)
  1076. #define KVM_SET_TSS_ADDR _IO(KVMIO, 0x47)
  1077. #define KVM_SET_IDENTITY_MAP_ADDR _IOW(KVMIO, 0x48, __u64)
  1078. #define KVM_SET_USER_MEMORY_REGION2 _IOW(KVMIO, 0x49, \
  1079. struct kvm_userspace_memory_region2)
  1080. /* enable ucontrol for s390 */
  1081. #define KVM_S390_UCAS_MAP _IOW(KVMIO, 0x50, struct kvm_s390_ucas_mapping)
  1082. #define KVM_S390_UCAS_UNMAP _IOW(KVMIO, 0x51, struct kvm_s390_ucas_mapping)
  1083. #define KVM_S390_VCPU_FAULT _IOW(KVMIO, 0x52, unsigned long)
  1084. /* Device model IOC */
  1085. #define KVM_CREATE_IRQCHIP _IO(KVMIO, 0x60)
  1086. #define KVM_IRQ_LINE _IOW(KVMIO, 0x61, struct kvm_irq_level)
  1087. #define KVM_GET_IRQCHIP _IOWR(KVMIO, 0x62, struct kvm_irqchip)
  1088. #define KVM_SET_IRQCHIP _IOR(KVMIO, 0x63, struct kvm_irqchip)
  1089. #define KVM_CREATE_PIT _IO(KVMIO, 0x64)
  1090. #define KVM_GET_PIT _IOWR(KVMIO, 0x65, struct kvm_pit_state)
  1091. #define KVM_SET_PIT _IOR(KVMIO, 0x66, struct kvm_pit_state)
  1092. #define KVM_IRQ_LINE_STATUS _IOWR(KVMIO, 0x67, struct kvm_irq_level)
  1093. #define KVM_REGISTER_COALESCED_MMIO \
  1094. _IOW(KVMIO, 0x67, struct kvm_coalesced_mmio_zone)
  1095. #define KVM_UNREGISTER_COALESCED_MMIO \
  1096. _IOW(KVMIO, 0x68, struct kvm_coalesced_mmio_zone)
  1097. #define KVM_SET_GSI_ROUTING _IOW(KVMIO, 0x6a, struct kvm_irq_routing)
  1098. #define KVM_REINJECT_CONTROL _IO(KVMIO, 0x71)
  1099. #define KVM_IRQFD _IOW(KVMIO, 0x76, struct kvm_irqfd)
  1100. #define KVM_CREATE_PIT2 _IOW(KVMIO, 0x77, struct kvm_pit_config)
  1101. #define KVM_SET_BOOT_CPU_ID _IO(KVMIO, 0x78)
  1102. #define KVM_IOEVENTFD _IOW(KVMIO, 0x79, struct kvm_ioeventfd)
  1103. #define KVM_XEN_HVM_CONFIG _IOW(KVMIO, 0x7a, struct kvm_xen_hvm_config)
  1104. #define KVM_SET_CLOCK _IOW(KVMIO, 0x7b, struct kvm_clock_data)
  1105. #define KVM_GET_CLOCK _IOR(KVMIO, 0x7c, struct kvm_clock_data)
  1106. /* Available with KVM_CAP_PIT_STATE2 */
  1107. #define KVM_GET_PIT2 _IOR(KVMIO, 0x9f, struct kvm_pit_state2)
  1108. #define KVM_SET_PIT2 _IOW(KVMIO, 0xa0, struct kvm_pit_state2)
  1109. /* Available with KVM_CAP_PPC_GET_PVINFO */
  1110. #define KVM_PPC_GET_PVINFO _IOW(KVMIO, 0xa1, struct kvm_ppc_pvinfo)
  1111. /* Available with KVM_CAP_TSC_CONTROL for a vCPU, or with
  1112. * KVM_CAP_VM_TSC_CONTROL to set defaults for a VM */
  1113. #define KVM_SET_TSC_KHZ _IO(KVMIO, 0xa2)
  1114. #define KVM_GET_TSC_KHZ _IO(KVMIO, 0xa3)
  1115. /* Available with KVM_CAP_SIGNAL_MSI */
  1116. #define KVM_SIGNAL_MSI _IOW(KVMIO, 0xa5, struct kvm_msi)
  1117. /* Available with KVM_CAP_PPC_GET_SMMU_INFO */
  1118. #define KVM_PPC_GET_SMMU_INFO _IOR(KVMIO, 0xa6, struct kvm_ppc_smmu_info)
  1119. /* Available with KVM_CAP_PPC_ALLOC_HTAB */
  1120. #define KVM_PPC_ALLOCATE_HTAB _IOWR(KVMIO, 0xa7, __u32)
  1121. #define KVM_CREATE_SPAPR_TCE _IOW(KVMIO, 0xa8, struct kvm_create_spapr_tce)
  1122. #define KVM_CREATE_SPAPR_TCE_64 _IOW(KVMIO, 0xa8, \
  1123. struct kvm_create_spapr_tce_64)
  1124. /* Available with KVM_CAP_RMA */
  1125. #define KVM_ALLOCATE_RMA _IOR(KVMIO, 0xa9, struct kvm_allocate_rma)
  1126. /* Available with KVM_CAP_PPC_HTAB_FD */
  1127. #define KVM_PPC_GET_HTAB_FD _IOW(KVMIO, 0xaa, struct kvm_get_htab_fd)
  1128. /* Available with KVM_CAP_ARM_SET_DEVICE_ADDR */
  1129. #define KVM_ARM_SET_DEVICE_ADDR _IOW(KVMIO, 0xab, struct kvm_arm_device_addr)
  1130. /* Available with KVM_CAP_PPC_RTAS */
  1131. #define KVM_PPC_RTAS_DEFINE_TOKEN _IOW(KVMIO, 0xac, struct kvm_rtas_token_args)
  1132. /* Available with KVM_CAP_SPAPR_RESIZE_HPT */
  1133. #define KVM_PPC_RESIZE_HPT_PREPARE _IOR(KVMIO, 0xad, struct kvm_ppc_resize_hpt)
  1134. #define KVM_PPC_RESIZE_HPT_COMMIT _IOR(KVMIO, 0xae, struct kvm_ppc_resize_hpt)
  1135. /* Available with KVM_CAP_PPC_MMU_RADIX or KVM_CAP_PPC_MMU_HASH_V3 */
  1136. #define KVM_PPC_CONFIGURE_V3_MMU _IOW(KVMIO, 0xaf, struct kvm_ppc_mmuv3_cfg)
  1137. /* Available with KVM_CAP_PPC_MMU_RADIX */
  1138. #define KVM_PPC_GET_RMMU_INFO _IOW(KVMIO, 0xb0, struct kvm_ppc_rmmu_info)
  1139. /* Available with KVM_CAP_PPC_GET_CPU_CHAR */
  1140. #define KVM_PPC_GET_CPU_CHAR _IOR(KVMIO, 0xb1, struct kvm_ppc_cpu_char)
  1141. /* Available with KVM_CAP_PMU_EVENT_FILTER */
  1142. #define KVM_SET_PMU_EVENT_FILTER _IOW(KVMIO, 0xb2, struct kvm_pmu_event_filter)
  1143. #define KVM_PPC_SVM_OFF _IO(KVMIO, 0xb3)
  1144. #define KVM_ARM_MTE_COPY_TAGS _IOR(KVMIO, 0xb4, struct kvm_arm_copy_mte_tags)
  1145. /* Available with KVM_CAP_COUNTER_OFFSET */
  1146. #define KVM_ARM_SET_COUNTER_OFFSET _IOW(KVMIO, 0xb5, struct kvm_arm_counter_offset)
  1147. #define KVM_ARM_GET_REG_WRITABLE_MASKS _IOR(KVMIO, 0xb6, struct reg_mask_range)
  1148. /* ioctl for vm fd */
  1149. #define KVM_CREATE_DEVICE _IOWR(KVMIO, 0xe0, struct kvm_create_device)
  1150. /* ioctls for fds returned by KVM_CREATE_DEVICE */
  1151. #define KVM_SET_DEVICE_ATTR _IOW(KVMIO, 0xe1, struct kvm_device_attr)
  1152. #define KVM_GET_DEVICE_ATTR _IOW(KVMIO, 0xe2, struct kvm_device_attr)
  1153. #define KVM_HAS_DEVICE_ATTR _IOW(KVMIO, 0xe3, struct kvm_device_attr)
  1154. /*
  1155. * ioctls for vcpu fds
  1156. */
  1157. #define KVM_RUN _IO(KVMIO, 0x80)
  1158. #define KVM_GET_REGS _IOR(KVMIO, 0x81, struct kvm_regs)
  1159. #define KVM_SET_REGS _IOW(KVMIO, 0x82, struct kvm_regs)
  1160. #define KVM_GET_SREGS _IOR(KVMIO, 0x83, struct kvm_sregs)
  1161. #define KVM_SET_SREGS _IOW(KVMIO, 0x84, struct kvm_sregs)
  1162. #define KVM_TRANSLATE _IOWR(KVMIO, 0x85, struct kvm_translation)
  1163. #define KVM_INTERRUPT _IOW(KVMIO, 0x86, struct kvm_interrupt)
  1164. #define KVM_GET_MSRS _IOWR(KVMIO, 0x88, struct kvm_msrs)
  1165. #define KVM_SET_MSRS _IOW(KVMIO, 0x89, struct kvm_msrs)
  1166. #define KVM_SET_CPUID _IOW(KVMIO, 0x8a, struct kvm_cpuid)
  1167. #define KVM_SET_SIGNAL_MASK _IOW(KVMIO, 0x8b, struct kvm_signal_mask)
  1168. #define KVM_GET_FPU _IOR(KVMIO, 0x8c, struct kvm_fpu)
  1169. #define KVM_SET_FPU _IOW(KVMIO, 0x8d, struct kvm_fpu)
  1170. #define KVM_GET_LAPIC _IOR(KVMIO, 0x8e, struct kvm_lapic_state)
  1171. #define KVM_SET_LAPIC _IOW(KVMIO, 0x8f, struct kvm_lapic_state)
  1172. #define KVM_SET_CPUID2 _IOW(KVMIO, 0x90, struct kvm_cpuid2)
  1173. #define KVM_GET_CPUID2 _IOWR(KVMIO, 0x91, struct kvm_cpuid2)
  1174. /* Available with KVM_CAP_VAPIC */
  1175. #define KVM_TPR_ACCESS_REPORTING _IOWR(KVMIO, 0x92, struct kvm_tpr_access_ctl)
  1176. /* Available with KVM_CAP_VAPIC */
  1177. #define KVM_SET_VAPIC_ADDR _IOW(KVMIO, 0x93, struct kvm_vapic_addr)
  1178. /* valid for virtual machine (for floating interrupt)_and_ vcpu */
  1179. #define KVM_S390_INTERRUPT _IOW(KVMIO, 0x94, struct kvm_s390_interrupt)
  1180. /* store status for s390 */
  1181. #define KVM_S390_STORE_STATUS_NOADDR (-1ul)
  1182. #define KVM_S390_STORE_STATUS_PREFIXED (-2ul)
  1183. #define KVM_S390_STORE_STATUS _IOW(KVMIO, 0x95, unsigned long)
  1184. /* initial ipl psw for s390 */
  1185. #define KVM_S390_SET_INITIAL_PSW _IOW(KVMIO, 0x96, struct kvm_s390_psw)
  1186. /* initial reset for s390 */
  1187. #define KVM_S390_INITIAL_RESET _IO(KVMIO, 0x97)
  1188. #define KVM_GET_MP_STATE _IOR(KVMIO, 0x98, struct kvm_mp_state)
  1189. #define KVM_SET_MP_STATE _IOW(KVMIO, 0x99, struct kvm_mp_state)
  1190. /* Available with KVM_CAP_USER_NMI */
  1191. #define KVM_NMI _IO(KVMIO, 0x9a)
  1192. /* Available with KVM_CAP_SET_GUEST_DEBUG */
  1193. #define KVM_SET_GUEST_DEBUG _IOW(KVMIO, 0x9b, struct kvm_guest_debug)
  1194. /* MCE for x86 */
  1195. #define KVM_X86_SETUP_MCE _IOW(KVMIO, 0x9c, __u64)
  1196. #define KVM_X86_GET_MCE_CAP_SUPPORTED _IOR(KVMIO, 0x9d, __u64)
  1197. #define KVM_X86_SET_MCE _IOW(KVMIO, 0x9e, struct kvm_x86_mce)
  1198. /* Available with KVM_CAP_VCPU_EVENTS */
  1199. #define KVM_GET_VCPU_EVENTS _IOR(KVMIO, 0x9f, struct kvm_vcpu_events)
  1200. #define KVM_SET_VCPU_EVENTS _IOW(KVMIO, 0xa0, struct kvm_vcpu_events)
  1201. /* Available with KVM_CAP_DEBUGREGS */
  1202. #define KVM_GET_DEBUGREGS _IOR(KVMIO, 0xa1, struct kvm_debugregs)
  1203. #define KVM_SET_DEBUGREGS _IOW(KVMIO, 0xa2, struct kvm_debugregs)
  1204. /*
  1205. * vcpu version available with KVM_CAP_ENABLE_CAP
  1206. * vm version available with KVM_CAP_ENABLE_CAP_VM
  1207. */
  1208. #define KVM_ENABLE_CAP _IOW(KVMIO, 0xa3, struct kvm_enable_cap)
  1209. /* Available with KVM_CAP_XSAVE */
  1210. #define KVM_GET_XSAVE _IOR(KVMIO, 0xa4, struct kvm_xsave)
  1211. #define KVM_SET_XSAVE _IOW(KVMIO, 0xa5, struct kvm_xsave)
  1212. /* Available with KVM_CAP_XCRS */
  1213. #define KVM_GET_XCRS _IOR(KVMIO, 0xa6, struct kvm_xcrs)
  1214. #define KVM_SET_XCRS _IOW(KVMIO, 0xa7, struct kvm_xcrs)
  1215. /* Available with KVM_CAP_SW_TLB */
  1216. #define KVM_DIRTY_TLB _IOW(KVMIO, 0xaa, struct kvm_dirty_tlb)
  1217. /* Available with KVM_CAP_ONE_REG */
  1218. #define KVM_GET_ONE_REG _IOW(KVMIO, 0xab, struct kvm_one_reg)
  1219. #define KVM_SET_ONE_REG _IOW(KVMIO, 0xac, struct kvm_one_reg)
  1220. /* VM is being stopped by host */
  1221. #define KVM_KVMCLOCK_CTRL _IO(KVMIO, 0xad)
  1222. #define KVM_ARM_VCPU_INIT _IOW(KVMIO, 0xae, struct kvm_vcpu_init)
  1223. #define KVM_ARM_PREFERRED_TARGET _IOR(KVMIO, 0xaf, struct kvm_vcpu_init)
  1224. #define KVM_GET_REG_LIST _IOWR(KVMIO, 0xb0, struct kvm_reg_list)
  1225. /* Available with KVM_CAP_S390_MEM_OP */
  1226. #define KVM_S390_MEM_OP _IOW(KVMIO, 0xb1, struct kvm_s390_mem_op)
  1227. /* Available with KVM_CAP_S390_SKEYS */
  1228. #define KVM_S390_GET_SKEYS _IOW(KVMIO, 0xb2, struct kvm_s390_skeys)
  1229. #define KVM_S390_SET_SKEYS _IOW(KVMIO, 0xb3, struct kvm_s390_skeys)
  1230. /* Available with KVM_CAP_S390_INJECT_IRQ */
  1231. #define KVM_S390_IRQ _IOW(KVMIO, 0xb4, struct kvm_s390_irq)
  1232. /* Available with KVM_CAP_S390_IRQ_STATE */
  1233. #define KVM_S390_SET_IRQ_STATE _IOW(KVMIO, 0xb5, struct kvm_s390_irq_state)
  1234. #define KVM_S390_GET_IRQ_STATE _IOW(KVMIO, 0xb6, struct kvm_s390_irq_state)
  1235. /* Available with KVM_CAP_X86_SMM */
  1236. #define KVM_SMI _IO(KVMIO, 0xb7)
  1237. /* Available with KVM_CAP_S390_CMMA_MIGRATION */
  1238. #define KVM_S390_GET_CMMA_BITS _IOWR(KVMIO, 0xb8, struct kvm_s390_cmma_log)
  1239. #define KVM_S390_SET_CMMA_BITS _IOW(KVMIO, 0xb9, struct kvm_s390_cmma_log)
  1240. /* Memory Encryption Commands */
  1241. #define KVM_MEMORY_ENCRYPT_OP _IOWR(KVMIO, 0xba, unsigned long)
  1242. struct kvm_enc_region {
  1243. __u64 addr;
  1244. __u64 size;
  1245. };
  1246. #define KVM_MEMORY_ENCRYPT_REG_REGION _IOR(KVMIO, 0xbb, struct kvm_enc_region)
  1247. #define KVM_MEMORY_ENCRYPT_UNREG_REGION _IOR(KVMIO, 0xbc, struct kvm_enc_region)
  1248. /* Available with KVM_CAP_HYPERV_EVENTFD */
  1249. #define KVM_HYPERV_EVENTFD _IOW(KVMIO, 0xbd, struct kvm_hyperv_eventfd)
  1250. /* Available with KVM_CAP_NESTED_STATE */
  1251. #define KVM_GET_NESTED_STATE _IOWR(KVMIO, 0xbe, struct kvm_nested_state)
  1252. #define KVM_SET_NESTED_STATE _IOW(KVMIO, 0xbf, struct kvm_nested_state)
  1253. /* Available with KVM_CAP_MANUAL_DIRTY_LOG_PROTECT_2 */
  1254. #define KVM_CLEAR_DIRTY_LOG _IOWR(KVMIO, 0xc0, struct kvm_clear_dirty_log)
  1255. /* Available with KVM_CAP_HYPERV_CPUID (vcpu) / KVM_CAP_SYS_HYPERV_CPUID (system) */
  1256. #define KVM_GET_SUPPORTED_HV_CPUID _IOWR(KVMIO, 0xc1, struct kvm_cpuid2)
  1257. /* Available with KVM_CAP_ARM_SVE */
  1258. #define KVM_ARM_VCPU_FINALIZE _IOW(KVMIO, 0xc2, int)
  1259. /* Available with KVM_CAP_S390_VCPU_RESETS */
  1260. #define KVM_S390_NORMAL_RESET _IO(KVMIO, 0xc3)
  1261. #define KVM_S390_CLEAR_RESET _IO(KVMIO, 0xc4)
  1262. /* Available with KVM_CAP_S390_PROTECTED */
  1263. #define KVM_S390_PV_COMMAND _IOWR(KVMIO, 0xc5, struct kvm_pv_cmd)
  1264. /* Available with KVM_CAP_X86_MSR_FILTER */
  1265. #define KVM_X86_SET_MSR_FILTER _IOW(KVMIO, 0xc6, struct kvm_msr_filter)
  1266. /* Available with KVM_CAP_DIRTY_LOG_RING */
  1267. #define KVM_RESET_DIRTY_RINGS _IO(KVMIO, 0xc7)
  1268. /* Per-VM Xen attributes */
  1269. #define KVM_XEN_HVM_GET_ATTR _IOWR(KVMIO, 0xc8, struct kvm_xen_hvm_attr)
  1270. #define KVM_XEN_HVM_SET_ATTR _IOW(KVMIO, 0xc9, struct kvm_xen_hvm_attr)
  1271. /* Per-vCPU Xen attributes */
  1272. #define KVM_XEN_VCPU_GET_ATTR _IOWR(KVMIO, 0xca, struct kvm_xen_vcpu_attr)
  1273. #define KVM_XEN_VCPU_SET_ATTR _IOW(KVMIO, 0xcb, struct kvm_xen_vcpu_attr)
  1274. /* Available with KVM_CAP_XEN_HVM / KVM_XEN_HVM_CONFIG_EVTCHN_SEND */
  1275. #define KVM_XEN_HVM_EVTCHN_SEND _IOW(KVMIO, 0xd0, struct kvm_irq_routing_xen_evtchn)
  1276. #define KVM_GET_SREGS2 _IOR(KVMIO, 0xcc, struct kvm_sregs2)
  1277. #define KVM_SET_SREGS2 _IOW(KVMIO, 0xcd, struct kvm_sregs2)
  1278. #define KVM_DIRTY_LOG_MANUAL_PROTECT_ENABLE (1 << 0)
  1279. #define KVM_DIRTY_LOG_INITIALLY_SET (1 << 1)
  1280. /*
  1281. * Arch needs to define the macro after implementing the dirty ring
  1282. * feature. KVM_DIRTY_LOG_PAGE_OFFSET should be defined as the
  1283. * starting page offset of the dirty ring structures.
  1284. */
  1285. #ifndef KVM_DIRTY_LOG_PAGE_OFFSET
  1286. #define KVM_DIRTY_LOG_PAGE_OFFSET 0
  1287. #endif
  1288. /*
  1289. * KVM dirty GFN flags, defined as:
  1290. *
  1291. * |---------------+---------------+--------------|
  1292. * | bit 1 (reset) | bit 0 (dirty) | Status |
  1293. * |---------------+---------------+--------------|
  1294. * | 0 | 0 | Invalid GFN |
  1295. * | 0 | 1 | Dirty GFN |
  1296. * | 1 | X | GFN to reset |
  1297. * |---------------+---------------+--------------|
  1298. *
  1299. * Lifecycle of a dirty GFN goes like:
  1300. *
  1301. * dirtied harvested reset
  1302. * 00 -----------> 01 -------------> 1X -------+
  1303. * ^ |
  1304. * | |
  1305. * +------------------------------------------+
  1306. *
  1307. * The userspace program is only responsible for the 01->1X state
  1308. * conversion after harvesting an entry. Also, it must not skip any
  1309. * dirty bits, so that dirty bits are always harvested in sequence.
  1310. */
  1311. #define KVM_DIRTY_GFN_F_DIRTY _BITUL(0)
  1312. #define KVM_DIRTY_GFN_F_RESET _BITUL(1)
  1313. #define KVM_DIRTY_GFN_F_MASK 0x3
  1314. /*
  1315. * KVM dirty rings should be mapped at KVM_DIRTY_LOG_PAGE_OFFSET of
  1316. * per-vcpu mmaped regions as an array of struct kvm_dirty_gfn. The
  1317. * size of the gfn buffer is decided by the first argument when
  1318. * enabling KVM_CAP_DIRTY_LOG_RING.
  1319. */
  1320. struct kvm_dirty_gfn {
  1321. __u32 flags;
  1322. __u32 slot;
  1323. __u64 offset;
  1324. };
  1325. #define KVM_BUS_LOCK_DETECTION_OFF (1 << 0)
  1326. #define KVM_BUS_LOCK_DETECTION_EXIT (1 << 1)
  1327. #define KVM_PMU_CAP_DISABLE (1 << 0)
  1328. /**
  1329. * struct kvm_stats_header - Header of per vm/vcpu binary statistics data.
  1330. * @flags: Some extra information for header, always 0 for now.
  1331. * @name_size: The size in bytes of the memory which contains statistics
  1332. * name string including trailing '\0'. The memory is allocated
  1333. * at the send of statistics descriptor.
  1334. * @num_desc: The number of statistics the vm or vcpu has.
  1335. * @id_offset: The offset of the vm/vcpu stats' id string in the file pointed
  1336. * by vm/vcpu stats fd.
  1337. * @desc_offset: The offset of the vm/vcpu stats' descriptor block in the file
  1338. * pointd by vm/vcpu stats fd.
  1339. * @data_offset: The offset of the vm/vcpu stats' data block in the file
  1340. * pointed by vm/vcpu stats fd.
  1341. *
  1342. * This is the header userspace needs to read from stats fd before any other
  1343. * readings. It is used by userspace to discover all the information about the
  1344. * vm/vcpu's binary statistics.
  1345. * Userspace reads this header from the start of the vm/vcpu's stats fd.
  1346. */
  1347. struct kvm_stats_header {
  1348. __u32 flags;
  1349. __u32 name_size;
  1350. __u32 num_desc;
  1351. __u32 id_offset;
  1352. __u32 desc_offset;
  1353. __u32 data_offset;
  1354. };
  1355. #define KVM_STATS_TYPE_SHIFT 0
  1356. #define KVM_STATS_TYPE_MASK (0xF << KVM_STATS_TYPE_SHIFT)
  1357. #define KVM_STATS_TYPE_CUMULATIVE (0x0 << KVM_STATS_TYPE_SHIFT)
  1358. #define KVM_STATS_TYPE_INSTANT (0x1 << KVM_STATS_TYPE_SHIFT)
  1359. #define KVM_STATS_TYPE_PEAK (0x2 << KVM_STATS_TYPE_SHIFT)
  1360. #define KVM_STATS_TYPE_LINEAR_HIST (0x3 << KVM_STATS_TYPE_SHIFT)
  1361. #define KVM_STATS_TYPE_LOG_HIST (0x4 << KVM_STATS_TYPE_SHIFT)
  1362. #define KVM_STATS_TYPE_MAX KVM_STATS_TYPE_LOG_HIST
  1363. #define KVM_STATS_UNIT_SHIFT 4
  1364. #define KVM_STATS_UNIT_MASK (0xF << KVM_STATS_UNIT_SHIFT)
  1365. #define KVM_STATS_UNIT_NONE (0x0 << KVM_STATS_UNIT_SHIFT)
  1366. #define KVM_STATS_UNIT_BYTES (0x1 << KVM_STATS_UNIT_SHIFT)
  1367. #define KVM_STATS_UNIT_SECONDS (0x2 << KVM_STATS_UNIT_SHIFT)
  1368. #define KVM_STATS_UNIT_CYCLES (0x3 << KVM_STATS_UNIT_SHIFT)
  1369. #define KVM_STATS_UNIT_BOOLEAN (0x4 << KVM_STATS_UNIT_SHIFT)
  1370. #define KVM_STATS_UNIT_MAX KVM_STATS_UNIT_BOOLEAN
  1371. #define KVM_STATS_BASE_SHIFT 8
  1372. #define KVM_STATS_BASE_MASK (0xF << KVM_STATS_BASE_SHIFT)
  1373. #define KVM_STATS_BASE_POW10 (0x0 << KVM_STATS_BASE_SHIFT)
  1374. #define KVM_STATS_BASE_POW2 (0x1 << KVM_STATS_BASE_SHIFT)
  1375. #define KVM_STATS_BASE_MAX KVM_STATS_BASE_POW2
  1376. /**
  1377. * struct kvm_stats_desc - Descriptor of a KVM statistics.
  1378. * @flags: Annotations of the stats, like type, unit, etc.
  1379. * @exponent: Used together with @flags to determine the unit.
  1380. * @size: The number of data items for this stats.
  1381. * Every data item is of type __u64.
  1382. * @offset: The offset of the stats to the start of stat structure in
  1383. * structure kvm or kvm_vcpu.
  1384. * @bucket_size: A parameter value used for histogram stats. It is only used
  1385. * for linear histogram stats, specifying the size of the bucket;
  1386. * @name: The name string for the stats. Its size is indicated by the
  1387. * &kvm_stats_header->name_size.
  1388. */
  1389. struct kvm_stats_desc {
  1390. __u32 flags;
  1391. __s16 exponent;
  1392. __u16 size;
  1393. __u32 offset;
  1394. __u32 bucket_size;
  1395. char name[];
  1396. };
  1397. #define KVM_GET_STATS_FD _IO(KVMIO, 0xce)
  1398. /* Available with KVM_CAP_XSAVE2 */
  1399. #define KVM_GET_XSAVE2 _IOR(KVMIO, 0xcf, struct kvm_xsave)
  1400. /* Available with KVM_CAP_S390_PROTECTED_DUMP */
  1401. #define KVM_S390_PV_CPU_COMMAND _IOWR(KVMIO, 0xd0, struct kvm_pv_cmd)
  1402. /* Available with KVM_CAP_X86_NOTIFY_VMEXIT */
  1403. #define KVM_X86_NOTIFY_VMEXIT_ENABLED (1ULL << 0)
  1404. #define KVM_X86_NOTIFY_VMEXIT_USER (1ULL << 1)
  1405. /* Available with KVM_CAP_S390_ZPCI_OP */
  1406. #define KVM_S390_ZPCI_OP _IOW(KVMIO, 0xd1, struct kvm_s390_zpci_op)
  1407. /* Available with KVM_CAP_MEMORY_ATTRIBUTES */
  1408. #define KVM_SET_MEMORY_ATTRIBUTES _IOW(KVMIO, 0xd2, struct kvm_memory_attributes)
  1409. struct kvm_memory_attributes {
  1410. __u64 address;
  1411. __u64 size;
  1412. __u64 attributes;
  1413. __u64 flags;
  1414. };
  1415. #define KVM_MEMORY_ATTRIBUTE_PRIVATE (1ULL << 3)
  1416. #define KVM_CREATE_GUEST_MEMFD _IOWR(KVMIO, 0xd4, struct kvm_create_guest_memfd)
  1417. struct kvm_create_guest_memfd {
  1418. __u64 size;
  1419. __u64 flags;
  1420. __u64 reserved[6];
  1421. };
  1422. #define KVM_PRE_FAULT_MEMORY _IOWR(KVMIO, 0xd5, struct kvm_pre_fault_memory)
  1423. struct kvm_pre_fault_memory {
  1424. __u64 gpa;
  1425. __u64 size;
  1426. __u64 flags;
  1427. __u64 padding[5];
  1428. };
  1429. #endif /* __LINUX_KVM_H */