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
);
161 void (*get_fpu
)(struct x86_emulate_ctxt
*ctxt
); /* disables preempt */
162 void (*put_fpu
)(struct x86_emulate_ctxt
*ctxt
); /* reenables preempt */
165 typedef u32
__attribute__((vector_size(16))) sse128_t
;
167 /* Type, address-of, and value of an instruction's operand. */
169 enum { OP_REG
, OP_MEM
, OP_IMM
, OP_XMM
, OP_NONE
} type
;
172 unsigned long orig_val
;
177 struct segmented_address
{
186 char valptr
[sizeof(unsigned long) + 2];
203 struct decode_cache
{
214 bool has_seg_override
;
217 int (*execute
)(struct x86_emulate_ctxt
*ctxt
);
218 unsigned long regs
[NR_VCPU_REGS
];
227 struct fetch_cache fetch
;
228 struct read_cache io_read
;
229 struct read_cache mem_read
;
232 struct x86_emulate_ctxt
{
233 struct x86_emulate_ops
*ops
;
235 /* Register state before/after emulation. */
236 struct kvm_vcpu
*vcpu
;
238 unsigned long eflags
;
239 unsigned long eip
; /* eip before instruction emulation */
240 /* Emulated execution mode, represented by an X86EMUL_MODE value. */
244 /* interruptibility state, as a result of execution of STI or MOV SS */
245 int interruptibility
;
247 bool perm_ok
; /* do not check permissions if true */
248 bool only_vendor_specific_insn
;
251 struct x86_exception exception
;
254 struct decode_cache decode
;
257 /* Repeat String Operation Prefix */
258 #define REPE_PREFIX 0xf3
259 #define REPNE_PREFIX 0xf2
261 /* Execution mode, passed to the emulator. */
262 #define X86EMUL_MODE_REAL 0 /* Real mode. */
263 #define X86EMUL_MODE_VM86 1 /* Virtual 8086 mode. */
264 #define X86EMUL_MODE_PROT16 2 /* 16-bit protected mode. */
265 #define X86EMUL_MODE_PROT32 4 /* 32-bit protected mode. */
266 #define X86EMUL_MODE_PROT64 8 /* 64-bit (long) mode. */
268 /* Host execution mode. */
269 #if defined(CONFIG_X86_32)
270 #define X86EMUL_MODE_HOST X86EMUL_MODE_PROT32
271 #elif defined(CONFIG_X86_64)
272 #define X86EMUL_MODE_HOST X86EMUL_MODE_PROT64
275 int x86_decode_insn(struct x86_emulate_ctxt
*ctxt
, void *insn
, int insn_len
);
276 #define EMULATION_FAILED -1
277 #define EMULATION_OK 0
278 #define EMULATION_RESTART 1
279 int x86_emulate_insn(struct x86_emulate_ctxt
*ctxt
);
280 int emulator_task_switch(struct x86_emulate_ctxt
*ctxt
,
281 u16 tss_selector
, int reason
,
282 bool has_error_code
, u32 error_code
);
283 int emulate_int_real(struct x86_emulate_ctxt
*ctxt
,
284 struct x86_emulate_ops
*ops
, int irq
);
285 #endif /* _ASM_X86_KVM_X86_EMULATE_H */