1 /******************************************************************************
4 * Generic x86 (32-bit and 64-bit) instruction decoder and emulator.
6 * Copyright (c) 2005 Keir Fraser
8 * From: xen-unstable 10676:af9809f51f81a3c43f276f00c81a52ef558afda4
11 #ifndef _ASM_X86_KVM_X86_EMULATE_H
12 #define _ASM_X86_KVM_X86_EMULATE_H
14 #include <asm/desc_defs.h>
16 struct x86_emulate_ctxt
;
18 struct x86_exception
{
20 bool error_code_valid
;
22 bool nested_page_fault
;
23 u64 address
; /* cr2 or nested page fault gpa */
29 * These operations represent the instruction emulator's interface to memory.
30 * There are two categories of operation: those that act on ordinary memory
31 * regions (*_std), and those that act on memory regions known to require
32 * special treatment or emulation (*_emulated).
34 * The emulator assumes that an instruction accesses only one 'emulated memory'
35 * location, that this location is the given linear faulting address (cr2), and
36 * that this is one of the instruction's data operands. Instruction fetches and
37 * stack operations are assumed never to access emulated memory. The emulator
38 * automatically deduces which operand of a string-move operation is accessing
39 * emulated memory, and assumes that the other operand accesses normal memory.
42 * 1. The emulator isn't very smart about emulated vs. standard memory.
43 * 'Emulated memory' access addresses should be checked for sanity.
44 * 'Normal memory' accesses may fault, and the caller must arrange to
45 * detect and handle reentrancy into the emulator via recursive faults.
46 * Accesses may be unaligned and may cross page boundaries.
47 * 2. If the access fails (cannot emulate, or a standard access faults) then
48 * it is up to the memop to propagate the fault to the guest VM via
49 * some out-of-band mechanism, unknown to the emulator. The memop signals
50 * failure by returning X86EMUL_PROPAGATE_FAULT to the emulator, which will
51 * then immediately bail.
52 * 3. Valid access sizes are 1, 2, 4 and 8 bytes. On x86/32 systems only
53 * cmpxchg8b_emulated need support 8-byte accesses.
54 * 4. The emulator cannot handle 64-bit mode emulation on an x86/32 system.
56 /* Access completed successfully: continue emulation as normal. */
57 #define X86EMUL_CONTINUE 0
58 /* Access is unhandleable: bail from emulation and return error to caller. */
59 #define X86EMUL_UNHANDLEABLE 1
60 /* Terminate emulation but return success to the caller. */
61 #define X86EMUL_PROPAGATE_FAULT 2 /* propagate a generated fault to guest */
62 #define X86EMUL_RETRY_INSTR 3 /* retry the instruction for some reason */
63 #define X86EMUL_CMPXCHG_FAILED 4 /* cmpxchg did not see expected value */
64 #define X86EMUL_IO_NEEDED 5 /* IO is needed to complete emulation */
66 struct x86_emulate_ops
{
68 * read_std: Read bytes of standard (non-emulated/special) memory.
69 * Used for descriptor reading.
70 * @addr: [IN ] Linear address from which to read.
71 * @val: [OUT] Value read from memory, zero-extended to 'u_long'.
72 * @bytes: [IN ] Number of bytes to read from memory.
74 int (*read_std
)(unsigned long addr
, void *val
,
75 unsigned int bytes
, struct kvm_vcpu
*vcpu
,
76 struct x86_exception
*fault
);
79 * write_std: Write bytes of standard (non-emulated/special) memory.
80 * Used for descriptor writing.
81 * @addr: [IN ] Linear address to which to write.
82 * @val: [OUT] Value write to memory, zero-extended to 'u_long'.
83 * @bytes: [IN ] Number of bytes to write to memory.
85 int (*write_std
)(unsigned long addr
, void *val
,
86 unsigned int bytes
, struct kvm_vcpu
*vcpu
,
87 struct x86_exception
*fault
);
89 * fetch: Read bytes of standard (non-emulated/special) memory.
90 * Used for instruction fetch.
91 * @addr: [IN ] Linear address from which to read.
92 * @val: [OUT] Value read from memory, zero-extended to 'u_long'.
93 * @bytes: [IN ] Number of bytes to read from memory.
95 int (*fetch
)(unsigned long addr
, void *val
,
96 unsigned int bytes
, struct kvm_vcpu
*vcpu
,
97 struct x86_exception
*fault
);
100 * read_emulated: Read bytes from emulated/special memory area.
101 * @addr: [IN ] Linear address from which to read.
102 * @val: [OUT] Value read from memory, zero-extended to 'u_long'.
103 * @bytes: [IN ] Number of bytes to read from memory.
105 int (*read_emulated
)(unsigned long addr
,
108 struct x86_exception
*fault
,
109 struct kvm_vcpu
*vcpu
);
112 * write_emulated: Write bytes to emulated/special memory area.
113 * @addr: [IN ] Linear address to which to write.
114 * @val: [IN ] Value to write to memory (low-order bytes used as
116 * @bytes: [IN ] Number of bytes to write to memory.
118 int (*write_emulated
)(unsigned long addr
,
121 struct x86_exception
*fault
,
122 struct kvm_vcpu
*vcpu
);
125 * cmpxchg_emulated: Emulate an atomic (LOCKed) CMPXCHG operation on an
126 * emulated/special memory area.
127 * @addr: [IN ] Linear address to access.
128 * @old: [IN ] Value expected to be current at @addr.
129 * @new: [IN ] Value to write to @addr.
130 * @bytes: [IN ] Number of bytes to access using CMPXCHG.
132 int (*cmpxchg_emulated
)(unsigned long addr
,
136 struct x86_exception
*fault
,
137 struct kvm_vcpu
*vcpu
);
139 int (*pio_in_emulated
)(int size
, unsigned short port
, void *val
,
140 unsigned int count
, struct kvm_vcpu
*vcpu
);
142 int (*pio_out_emulated
)(int size
, unsigned short port
, const void *val
,
143 unsigned int count
, struct kvm_vcpu
*vcpu
);
145 bool (*get_cached_descriptor
)(struct desc_struct
*desc
, u32
*base3
,
146 int seg
, struct kvm_vcpu
*vcpu
);
147 void (*set_cached_descriptor
)(struct desc_struct
*desc
, u32 base3
,
148 int seg
, struct kvm_vcpu
*vcpu
);
149 u16 (*get_segment_selector
)(int seg
, struct kvm_vcpu
*vcpu
);
150 void (*set_segment_selector
)(u16 sel
, int seg
, struct kvm_vcpu
*vcpu
);
151 unsigned long (*get_cached_segment_base
)(int seg
, struct kvm_vcpu
*vcpu
);
152 void (*get_gdt
)(struct desc_ptr
*dt
, struct kvm_vcpu
*vcpu
);
153 void (*get_idt
)(struct desc_ptr
*dt
, struct kvm_vcpu
*vcpu
);
154 ulong (*get_cr
)(int cr
, struct kvm_vcpu
*vcpu
);
155 int (*set_cr
)(int cr
, ulong val
, struct kvm_vcpu
*vcpu
);
156 int (*cpl
)(struct kvm_vcpu
*vcpu
);
157 int (*get_dr
)(int dr
, unsigned long *dest
, struct kvm_vcpu
*vcpu
);
158 int (*set_dr
)(int dr
, unsigned long value
, struct kvm_vcpu
*vcpu
);
159 int (*set_msr
)(struct kvm_vcpu
*vcpu
, u32 msr_index
, u64 data
);
160 int (*get_msr
)(struct kvm_vcpu
*vcpu
, u32 msr_index
, u64
*pdata
);
163 /* Type, address-of, and value of an instruction's operand. */
165 enum { OP_REG
, OP_MEM
, OP_IMM
, OP_NONE
} type
;
168 unsigned long orig_val
;
173 struct segmented_address
{
181 char valptr
[sizeof(unsigned long) + 2];
197 struct decode_cache
{
208 bool has_seg_override
;
211 int (*execute
)(struct x86_emulate_ctxt
*ctxt
);
212 unsigned long regs
[NR_VCPU_REGS
];
221 struct fetch_cache fetch
;
222 struct read_cache io_read
;
223 struct read_cache mem_read
;
226 struct x86_emulate_ctxt
{
227 struct x86_emulate_ops
*ops
;
229 /* Register state before/after emulation. */
230 struct kvm_vcpu
*vcpu
;
232 unsigned long eflags
;
233 unsigned long eip
; /* eip before instruction emulation */
234 /* Emulated execution mode, represented by an X86EMUL_MODE value. */
238 /* interruptibility state, as a result of execution of STI or MOV SS */
239 int interruptibility
;
241 bool perm_ok
; /* do not check permissions if true */
242 bool only_vendor_specific_insn
;
245 struct x86_exception exception
;
248 struct decode_cache decode
;
251 /* Repeat String Operation Prefix */
252 #define REPE_PREFIX 1
253 #define REPNE_PREFIX 2
255 /* Execution mode, passed to the emulator. */
256 #define X86EMUL_MODE_REAL 0 /* Real mode. */
257 #define X86EMUL_MODE_VM86 1 /* Virtual 8086 mode. */
258 #define X86EMUL_MODE_PROT16 2 /* 16-bit protected mode. */
259 #define X86EMUL_MODE_PROT32 4 /* 32-bit protected mode. */
260 #define X86EMUL_MODE_PROT64 8 /* 64-bit (long) mode. */
262 /* Host execution mode. */
263 #if defined(CONFIG_X86_32)
264 #define X86EMUL_MODE_HOST X86EMUL_MODE_PROT32
265 #elif defined(CONFIG_X86_64)
266 #define X86EMUL_MODE_HOST X86EMUL_MODE_PROT64
269 int x86_decode_insn(struct x86_emulate_ctxt
*ctxt
, void *insn
, int insn_len
);
270 #define EMULATION_FAILED -1
271 #define EMULATION_OK 0
272 #define EMULATION_RESTART 1
273 int x86_emulate_insn(struct x86_emulate_ctxt
*ctxt
);
274 int emulator_task_switch(struct x86_emulate_ctxt
*ctxt
,
275 u16 tss_selector
, int reason
,
276 bool has_error_code
, u32 error_code
);
277 int emulate_int_real(struct x86_emulate_ctxt
*ctxt
,
278 struct x86_emulate_ops
*ops
, int irq
);
279 #endif /* _ASM_X86_KVM_X86_EMULATE_H */