| #ifndef __LINUX_KVM_H | 
 | #define __LINUX_KVM_H | 
 |  | 
 | /* | 
 |  * Userspace interface for /dev/kvm - kernel based virtual machine | 
 |  * | 
 |  * Note: you must update KVM_API_VERSION if you change this interface. | 
 |  */ | 
 |  | 
 | #include <asm/types.h> | 
 | #include <linux/ioctl.h> | 
 |  | 
 | #define KVM_API_VERSION 12 | 
 |  | 
 | /* Architectural interrupt line count. */ | 
 | #define KVM_NR_INTERRUPTS 256 | 
 |  | 
 | /* for KVM_CREATE_MEMORY_REGION */ | 
 | struct kvm_memory_region { | 
 | 	__u32 slot; | 
 | 	__u32 flags; | 
 | 	__u64 guest_phys_addr; | 
 | 	__u64 memory_size; /* bytes */ | 
 | }; | 
 |  | 
 | /* for kvm_memory_region::flags */ | 
 | #define KVM_MEM_LOG_DIRTY_PAGES  1UL | 
 |  | 
 | struct kvm_memory_alias { | 
 | 	__u32 slot;  /* this has a different namespace than memory slots */ | 
 | 	__u32 flags; | 
 | 	__u64 guest_phys_addr; | 
 | 	__u64 memory_size; | 
 | 	__u64 target_phys_addr; | 
 | }; | 
 |  | 
 | /* for KVM_IRQ_LINE */ | 
 | struct kvm_irq_level { | 
 | 	/* | 
 | 	 * ACPI gsi notion of irq. | 
 | 	 * For IA-64 (APIC model) IOAPIC0: irq 0-23; IOAPIC1: irq 24-47.. | 
 | 	 * For X86 (standard AT mode) PIC0/1: irq 0-15. IOAPIC0: 0-23.. | 
 | 	 */ | 
 | 	__u32 irq; | 
 | 	__u32 level; | 
 | }; | 
 |  | 
 | /* for KVM_GET_IRQCHIP and KVM_SET_IRQCHIP */ | 
 | struct kvm_pic_state { | 
 | 	__u8 last_irr;	/* edge detection */ | 
 | 	__u8 irr;		/* interrupt request register */ | 
 | 	__u8 imr;		/* interrupt mask register */ | 
 | 	__u8 isr;		/* interrupt service register */ | 
 | 	__u8 priority_add;	/* highest irq priority */ | 
 | 	__u8 irq_base; | 
 | 	__u8 read_reg_select; | 
 | 	__u8 poll; | 
 | 	__u8 special_mask; | 
 | 	__u8 init_state; | 
 | 	__u8 auto_eoi; | 
 | 	__u8 rotate_on_auto_eoi; | 
 | 	__u8 special_fully_nested_mode; | 
 | 	__u8 init4;		/* true if 4 byte init */ | 
 | 	__u8 elcr;		/* PIIX edge/trigger selection */ | 
 | 	__u8 elcr_mask; | 
 | }; | 
 |  | 
 | #define KVM_IOAPIC_NUM_PINS  24 | 
 | struct kvm_ioapic_state { | 
 | 	__u64 base_address; | 
 | 	__u32 ioregsel; | 
 | 	__u32 id; | 
 | 	__u32 irr; | 
 | 	__u32 pad; | 
 | 	union { | 
 | 		__u64 bits; | 
 | 		struct { | 
 | 			__u8 vector; | 
 | 			__u8 delivery_mode:3; | 
 | 			__u8 dest_mode:1; | 
 | 			__u8 delivery_status:1; | 
 | 			__u8 polarity:1; | 
 | 			__u8 remote_irr:1; | 
 | 			__u8 trig_mode:1; | 
 | 			__u8 mask:1; | 
 | 			__u8 reserve:7; | 
 | 			__u8 reserved[4]; | 
 | 			__u8 dest_id; | 
 | 		} fields; | 
 | 	} redirtbl[KVM_IOAPIC_NUM_PINS]; | 
 | }; | 
 |  | 
 | #define KVM_IRQCHIP_PIC_MASTER   0 | 
 | #define KVM_IRQCHIP_PIC_SLAVE    1 | 
 | #define KVM_IRQCHIP_IOAPIC       2 | 
 |  | 
 | struct kvm_irqchip { | 
 | 	__u32 chip_id; | 
 | 	__u32 pad; | 
 |         union { | 
 | 		char dummy[512];  /* reserving space */ | 
 | 		struct kvm_pic_state pic; | 
 | 		struct kvm_ioapic_state ioapic; | 
 | 	} chip; | 
 | }; | 
 |  | 
 | #define KVM_EXIT_UNKNOWN          0 | 
 | #define KVM_EXIT_EXCEPTION        1 | 
 | #define KVM_EXIT_IO               2 | 
 | #define KVM_EXIT_HYPERCALL        3 | 
 | #define KVM_EXIT_DEBUG            4 | 
 | #define KVM_EXIT_HLT              5 | 
 | #define KVM_EXIT_MMIO             6 | 
 | #define KVM_EXIT_IRQ_WINDOW_OPEN  7 | 
 | #define KVM_EXIT_SHUTDOWN         8 | 
 | #define KVM_EXIT_FAIL_ENTRY       9 | 
 | #define KVM_EXIT_INTR             10 | 
 | #define KVM_EXIT_SET_TPR          11 | 
 |  | 
 | /* for KVM_RUN, returned by mmap(vcpu_fd, offset=0) */ | 
 | struct kvm_run { | 
 | 	/* in */ | 
 | 	__u8 request_interrupt_window; | 
 | 	__u8 padding1[7]; | 
 |  | 
 | 	/* out */ | 
 | 	__u32 exit_reason; | 
 | 	__u8 ready_for_interrupt_injection; | 
 | 	__u8 if_flag; | 
 | 	__u8 padding2[2]; | 
 |  | 
 | 	/* in (pre_kvm_run), out (post_kvm_run) */ | 
 | 	__u64 cr8; | 
 | 	__u64 apic_base; | 
 |  | 
 | 	union { | 
 | 		/* KVM_EXIT_UNKNOWN */ | 
 | 		struct { | 
 | 			__u64 hardware_exit_reason; | 
 | 		} hw; | 
 | 		/* KVM_EXIT_FAIL_ENTRY */ | 
 | 		struct { | 
 | 			__u64 hardware_entry_failure_reason; | 
 | 		} fail_entry; | 
 | 		/* KVM_EXIT_EXCEPTION */ | 
 | 		struct { | 
 | 			__u32 exception; | 
 | 			__u32 error_code; | 
 | 		} ex; | 
 | 		/* KVM_EXIT_IO */ | 
 | 		struct kvm_io { | 
 | #define KVM_EXIT_IO_IN  0 | 
 | #define KVM_EXIT_IO_OUT 1 | 
 | 			__u8 direction; | 
 | 			__u8 size; /* bytes */ | 
 | 			__u16 port; | 
 | 			__u32 count; | 
 | 			__u64 data_offset; /* relative to kvm_run start */ | 
 | 		} io; | 
 | 		struct { | 
 | 		} debug; | 
 | 		/* KVM_EXIT_MMIO */ | 
 | 		struct { | 
 | 			__u64 phys_addr; | 
 | 			__u8  data[8]; | 
 | 			__u32 len; | 
 | 			__u8  is_write; | 
 | 		} mmio; | 
 | 		/* KVM_EXIT_HYPERCALL */ | 
 | 		struct { | 
 | 			__u64 nr; | 
 | 			__u64 args[6]; | 
 | 			__u64 ret; | 
 | 			__u32 longmode; | 
 | 			__u32 pad; | 
 | 		} hypercall; | 
 | 		/* Fix the size of the union. */ | 
 | 		char padding[256]; | 
 | 	}; | 
 | }; | 
 |  | 
 | /* for KVM_GET_REGS and KVM_SET_REGS */ | 
 | struct kvm_regs { | 
 | 	/* out (KVM_GET_REGS) / in (KVM_SET_REGS) */ | 
 | 	__u64 rax, rbx, rcx, rdx; | 
 | 	__u64 rsi, rdi, rsp, rbp; | 
 | 	__u64 r8,  r9,  r10, r11; | 
 | 	__u64 r12, r13, r14, r15; | 
 | 	__u64 rip, rflags; | 
 | }; | 
 |  | 
 | /* for KVM_GET_FPU and KVM_SET_FPU */ | 
 | struct kvm_fpu { | 
 | 	__u8  fpr[8][16]; | 
 | 	__u16 fcw; | 
 | 	__u16 fsw; | 
 | 	__u8  ftwx;  /* in fxsave format */ | 
 | 	__u8  pad1; | 
 | 	__u16 last_opcode; | 
 | 	__u64 last_ip; | 
 | 	__u64 last_dp; | 
 | 	__u8  xmm[16][16]; | 
 | 	__u32 mxcsr; | 
 | 	__u32 pad2; | 
 | }; | 
 |  | 
 | /* for KVM_GET_LAPIC and KVM_SET_LAPIC */ | 
 | #define KVM_APIC_REG_SIZE 0x400 | 
 | struct kvm_lapic_state { | 
 | 	char regs[KVM_APIC_REG_SIZE]; | 
 | }; | 
 |  | 
 | struct kvm_segment { | 
 | 	__u64 base; | 
 | 	__u32 limit; | 
 | 	__u16 selector; | 
 | 	__u8  type; | 
 | 	__u8  present, dpl, db, s, l, g, avl; | 
 | 	__u8  unusable; | 
 | 	__u8  padding; | 
 | }; | 
 |  | 
 | struct kvm_dtable { | 
 | 	__u64 base; | 
 | 	__u16 limit; | 
 | 	__u16 padding[3]; | 
 | }; | 
 |  | 
 | /* for KVM_GET_SREGS and KVM_SET_SREGS */ | 
 | struct kvm_sregs { | 
 | 	/* out (KVM_GET_SREGS) / in (KVM_SET_SREGS) */ | 
 | 	struct kvm_segment cs, ds, es, fs, gs, ss; | 
 | 	struct kvm_segment tr, ldt; | 
 | 	struct kvm_dtable gdt, idt; | 
 | 	__u64 cr0, cr2, cr3, cr4, cr8; | 
 | 	__u64 efer; | 
 | 	__u64 apic_base; | 
 | 	__u64 interrupt_bitmap[(KVM_NR_INTERRUPTS + 63) / 64]; | 
 | }; | 
 |  | 
 | struct kvm_msr_entry { | 
 | 	__u32 index; | 
 | 	__u32 reserved; | 
 | 	__u64 data; | 
 | }; | 
 |  | 
 | /* for KVM_GET_MSRS and KVM_SET_MSRS */ | 
 | struct kvm_msrs { | 
 | 	__u32 nmsrs; /* number of msrs in entries */ | 
 | 	__u32 pad; | 
 |  | 
 | 	struct kvm_msr_entry entries[0]; | 
 | }; | 
 |  | 
 | /* for KVM_GET_MSR_INDEX_LIST */ | 
 | struct kvm_msr_list { | 
 | 	__u32 nmsrs; /* number of msrs in entries */ | 
 | 	__u32 indices[0]; | 
 | }; | 
 |  | 
 | /* for KVM_TRANSLATE */ | 
 | struct kvm_translation { | 
 | 	/* in */ | 
 | 	__u64 linear_address; | 
 |  | 
 | 	/* out */ | 
 | 	__u64 physical_address; | 
 | 	__u8  valid; | 
 | 	__u8  writeable; | 
 | 	__u8  usermode; | 
 | 	__u8  pad[5]; | 
 | }; | 
 |  | 
 | /* for KVM_INTERRUPT */ | 
 | struct kvm_interrupt { | 
 | 	/* in */ | 
 | 	__u32 irq; | 
 | }; | 
 |  | 
 | struct kvm_breakpoint { | 
 | 	__u32 enabled; | 
 | 	__u32 padding; | 
 | 	__u64 address; | 
 | }; | 
 |  | 
 | /* for KVM_DEBUG_GUEST */ | 
 | struct kvm_debug_guest { | 
 | 	/* int */ | 
 | 	__u32 enabled; | 
 | 	__u32 pad; | 
 | 	struct kvm_breakpoint breakpoints[4]; | 
 | 	__u32 singlestep; | 
 | }; | 
 |  | 
 | /* for KVM_GET_DIRTY_LOG */ | 
 | struct kvm_dirty_log { | 
 | 	__u32 slot; | 
 | 	__u32 padding; | 
 | 	union { | 
 | 		void __user *dirty_bitmap; /* one bit per page */ | 
 | 		__u64 padding; | 
 | 	}; | 
 | }; | 
 |  | 
 | struct kvm_cpuid_entry { | 
 | 	__u32 function; | 
 | 	__u32 eax; | 
 | 	__u32 ebx; | 
 | 	__u32 ecx; | 
 | 	__u32 edx; | 
 | 	__u32 padding; | 
 | }; | 
 |  | 
 | /* for KVM_SET_CPUID */ | 
 | struct kvm_cpuid { | 
 | 	__u32 nent; | 
 | 	__u32 padding; | 
 | 	struct kvm_cpuid_entry entries[0]; | 
 | }; | 
 |  | 
 | /* for KVM_SET_SIGNAL_MASK */ | 
 | struct kvm_signal_mask { | 
 | 	__u32 len; | 
 | 	__u8  sigset[0]; | 
 | }; | 
 |  | 
 | #define KVMIO 0xAE | 
 |  | 
 | /* | 
 |  * ioctls for /dev/kvm fds: | 
 |  */ | 
 | #define KVM_GET_API_VERSION       _IO(KVMIO,   0x00) | 
 | #define KVM_CREATE_VM             _IO(KVMIO,   0x01) /* returns a VM fd */ | 
 | #define KVM_GET_MSR_INDEX_LIST    _IOWR(KVMIO, 0x02, struct kvm_msr_list) | 
 | /* | 
 |  * Check if a kvm extension is available.  Argument is extension number, | 
 |  * return is 1 (yes) or 0 (no, sorry). | 
 |  */ | 
 | #define KVM_CHECK_EXTENSION       _IO(KVMIO,   0x03) | 
 | /* | 
 |  * Get size for mmap(vcpu_fd) | 
 |  */ | 
 | #define KVM_GET_VCPU_MMAP_SIZE    _IO(KVMIO,   0x04) /* in bytes */ | 
 |  | 
 | /* | 
 |  * Extension capability list. | 
 |  */ | 
 | #define KVM_CAP_IRQCHIP	  0 | 
 | #define KVM_CAP_HLT	  1 | 
 |  | 
 | /* | 
 |  * ioctls for VM fds | 
 |  */ | 
 | #define KVM_SET_MEMORY_REGION     _IOW(KVMIO, 0x40, struct kvm_memory_region) | 
 | /* | 
 |  * KVM_CREATE_VCPU receives as a parameter the vcpu slot, and returns | 
 |  * a vcpu fd. | 
 |  */ | 
 | #define KVM_CREATE_VCPU           _IO(KVMIO,  0x41) | 
 | #define KVM_GET_DIRTY_LOG         _IOW(KVMIO, 0x42, struct kvm_dirty_log) | 
 | #define KVM_SET_MEMORY_ALIAS      _IOW(KVMIO, 0x43, struct kvm_memory_alias) | 
 | /* Device model IOC */ | 
 | #define KVM_CREATE_IRQCHIP	  _IO(KVMIO,  0x60) | 
 | #define KVM_IRQ_LINE		  _IOW(KVMIO, 0x61, struct kvm_irq_level) | 
 | #define KVM_GET_IRQCHIP		  _IOWR(KVMIO, 0x62, struct kvm_irqchip) | 
 | #define KVM_SET_IRQCHIP		  _IOR(KVMIO,  0x63, struct kvm_irqchip) | 
 |  | 
 | /* | 
 |  * ioctls for vcpu fds | 
 |  */ | 
 | #define KVM_RUN                   _IO(KVMIO,   0x80) | 
 | #define KVM_GET_REGS              _IOR(KVMIO,  0x81, struct kvm_regs) | 
 | #define KVM_SET_REGS              _IOW(KVMIO,  0x82, struct kvm_regs) | 
 | #define KVM_GET_SREGS             _IOR(KVMIO,  0x83, struct kvm_sregs) | 
 | #define KVM_SET_SREGS             _IOW(KVMIO,  0x84, struct kvm_sregs) | 
 | #define KVM_TRANSLATE             _IOWR(KVMIO, 0x85, struct kvm_translation) | 
 | #define KVM_INTERRUPT             _IOW(KVMIO,  0x86, struct kvm_interrupt) | 
 | #define KVM_DEBUG_GUEST           _IOW(KVMIO,  0x87, struct kvm_debug_guest) | 
 | #define KVM_GET_MSRS              _IOWR(KVMIO, 0x88, struct kvm_msrs) | 
 | #define KVM_SET_MSRS              _IOW(KVMIO,  0x89, struct kvm_msrs) | 
 | #define KVM_SET_CPUID             _IOW(KVMIO,  0x8a, struct kvm_cpuid) | 
 | #define KVM_SET_SIGNAL_MASK       _IOW(KVMIO,  0x8b, struct kvm_signal_mask) | 
 | #define KVM_GET_FPU               _IOR(KVMIO,  0x8c, struct kvm_fpu) | 
 | #define KVM_SET_FPU               _IOW(KVMIO,  0x8d, struct kvm_fpu) | 
 | #define KVM_GET_LAPIC             _IOR(KVMIO,  0x8e, struct kvm_lapic_state) | 
 | #define KVM_SET_LAPIC             _IOW(KVMIO,  0x8f, struct kvm_lapic_state) | 
 |  | 
 | #endif |