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
;
21 * These operations represent the instruction emulator's interface to memory.
22 * There are two categories of operation: those that act on ordinary memory
23 * regions (*_std), and those that act on memory regions known to require
24 * special treatment or emulation (*_emulated).
26 * The emulator assumes that an instruction accesses only one 'emulated memory'
27 * location, that this location is the given linear faulting address (cr2), and
28 * that this is one of the instruction's data operands. Instruction fetches and
29 * stack operations are assumed never to access emulated memory. The emulator
30 * automatically deduces which operand of a string-move operation is accessing
31 * emulated memory, and assumes that the other operand accesses normal memory.
34 * 1. The emulator isn't very smart about emulated vs. standard memory.
35 * 'Emulated memory' access addresses should be checked for sanity.
36 * 'Normal memory' accesses may fault, and the caller must arrange to
37 * detect and handle reentrancy into the emulator via recursive faults.
38 * Accesses may be unaligned and may cross page boundaries.
39 * 2. If the access fails (cannot emulate, or a standard access faults) then
40 * it is up to the memop to propagate the fault to the guest VM via
41 * some out-of-band mechanism, unknown to the emulator. The memop signals
42 * failure by returning X86EMUL_PROPAGATE_FAULT to the emulator, which will
43 * then immediately bail.
44 * 3. Valid access sizes are 1, 2, 4 and 8 bytes. On x86/32 systems only
45 * cmpxchg8b_emulated need support 8-byte accesses.
46 * 4. The emulator cannot handle 64-bit mode emulation on an x86/32 system.
48 /* Access completed successfully: continue emulation as normal. */
49 #define X86EMUL_CONTINUE 0
50 /* Access is unhandleable: bail from emulation and return error to caller. */
51 #define X86EMUL_UNHANDLEABLE 1
52 /* Terminate emulation but return success to the caller. */
53 #define X86EMUL_PROPAGATE_FAULT 2 /* propagate a generated fault to guest */
54 #define X86EMUL_RETRY_INSTR 3 /* retry the instruction for some reason */
55 #define X86EMUL_CMPXCHG_FAILED 4 /* cmpxchg did not see expected value */
56 #define X86EMUL_IO_NEEDED 5 /* IO is needed to complete emulation */
58 struct x86_emulate_ops
{
60 * read_std: Read bytes of standard (non-emulated/special) memory.
61 * Used for descriptor reading.
62 * @addr: [IN ] Linear address from which to read.
63 * @val: [OUT] Value read from memory, zero-extended to 'u_long'.
64 * @bytes: [IN ] Number of bytes to read from memory.
66 int (*read_std
)(unsigned long addr
, void *val
,
67 unsigned int bytes
, struct kvm_vcpu
*vcpu
, u32
*error
);
70 * write_std: Write bytes of standard (non-emulated/special) memory.
71 * Used for descriptor writing.
72 * @addr: [IN ] Linear address to which to write.
73 * @val: [OUT] Value write to memory, zero-extended to 'u_long'.
74 * @bytes: [IN ] Number of bytes to write to memory.
76 int (*write_std
)(unsigned long addr
, void *val
,
77 unsigned int bytes
, struct kvm_vcpu
*vcpu
, u32
*error
);
79 * fetch: Read bytes of standard (non-emulated/special) memory.
80 * Used for instruction fetch.
81 * @addr: [IN ] Linear address from which to read.
82 * @val: [OUT] Value read from memory, zero-extended to 'u_long'.
83 * @bytes: [IN ] Number of bytes to read from memory.
85 int (*fetch
)(unsigned long addr
, void *val
,
86 unsigned int bytes
, struct kvm_vcpu
*vcpu
, u32
*error
);
89 * read_emulated: Read bytes from emulated/special memory area.
90 * @addr: [IN ] Linear address from which to read.
91 * @val: [OUT] Value read from memory, zero-extended to 'u_long'.
92 * @bytes: [IN ] Number of bytes to read from memory.
94 int (*read_emulated
)(unsigned long addr
,
98 struct kvm_vcpu
*vcpu
);
101 * write_emulated: Write bytes to emulated/special memory area.
102 * @addr: [IN ] Linear address to which to write.
103 * @val: [IN ] Value to write to memory (low-order bytes used as
105 * @bytes: [IN ] Number of bytes to write to memory.
107 int (*write_emulated
)(unsigned long addr
,
111 struct kvm_vcpu
*vcpu
);
114 * cmpxchg_emulated: Emulate an atomic (LOCKed) CMPXCHG operation on an
115 * emulated/special memory area.
116 * @addr: [IN ] Linear address to access.
117 * @old: [IN ] Value expected to be current at @addr.
118 * @new: [IN ] Value to write to @addr.
119 * @bytes: [IN ] Number of bytes to access using CMPXCHG.
121 int (*cmpxchg_emulated
)(unsigned long addr
,
126 struct kvm_vcpu
*vcpu
);
128 int (*pio_in_emulated
)(int size
, unsigned short port
, void *val
,
129 unsigned int count
, struct kvm_vcpu
*vcpu
);
131 int (*pio_out_emulated
)(int size
, unsigned short port
, const void *val
,
132 unsigned int count
, struct kvm_vcpu
*vcpu
);
134 bool (*get_cached_descriptor
)(struct desc_struct
*desc
,
135 int seg
, struct kvm_vcpu
*vcpu
);
136 void (*set_cached_descriptor
)(struct desc_struct
*desc
,
137 int seg
, struct kvm_vcpu
*vcpu
);
138 u16 (*get_segment_selector
)(int seg
, struct kvm_vcpu
*vcpu
);
139 void (*set_segment_selector
)(u16 sel
, int seg
, struct kvm_vcpu
*vcpu
);
140 unsigned long (*get_cached_segment_base
)(int seg
, struct kvm_vcpu
*vcpu
);
141 void (*get_gdt
)(struct desc_ptr
*dt
, struct kvm_vcpu
*vcpu
);
142 ulong (*get_cr
)(int cr
, struct kvm_vcpu
*vcpu
);
143 int (*set_cr
)(int cr
, ulong val
, struct kvm_vcpu
*vcpu
);
144 int (*cpl
)(struct kvm_vcpu
*vcpu
);
145 void (*set_rflags
)(struct kvm_vcpu
*vcpu
, unsigned long rflags
);
146 int (*get_dr
)(int dr
, unsigned long *dest
, struct kvm_vcpu
*vcpu
);
147 int (*set_dr
)(int dr
, unsigned long value
, struct kvm_vcpu
*vcpu
);
148 int (*set_msr
)(struct kvm_vcpu
*vcpu
, u32 msr_index
, u64 data
);
149 int (*get_msr
)(struct kvm_vcpu
*vcpu
, u32 msr_index
, u64
*pdata
);
152 /* Type, address-of, and value of an instruction's operand. */
154 enum { OP_REG
, OP_MEM
, OP_IMM
, OP_NONE
} type
;
156 unsigned long orig_val
, *ptr
;
159 char valptr
[sizeof(unsigned long) + 2];
175 struct decode_cache
{
186 bool has_seg_override
;
189 unsigned long regs
[NR_VCPU_REGS
];
198 unsigned long modrm_ea
;
200 unsigned long modrm_val
;
201 struct fetch_cache fetch
;
202 struct read_cache io_read
;
203 struct read_cache mem_read
;
206 struct x86_emulate_ctxt
{
207 /* Register state before/after emulation. */
208 struct kvm_vcpu
*vcpu
;
210 unsigned long eflags
;
211 unsigned long eip
; /* eip before instruction emulation */
212 /* Emulated execution mode, represented by an X86EMUL_MODE value. */
216 /* interruptibility state, as a result of execution of STI or MOV SS */
217 int interruptibility
;
219 bool restart
; /* restart string instruction after writeback */
221 struct decode_cache decode
;
224 /* Repeat String Operation Prefix */
225 #define REPE_PREFIX 1
226 #define REPNE_PREFIX 2
228 /* Execution mode, passed to the emulator. */
229 #define X86EMUL_MODE_REAL 0 /* Real mode. */
230 #define X86EMUL_MODE_VM86 1 /* Virtual 8086 mode. */
231 #define X86EMUL_MODE_PROT16 2 /* 16-bit protected mode. */
232 #define X86EMUL_MODE_PROT32 4 /* 32-bit protected mode. */
233 #define X86EMUL_MODE_PROT64 8 /* 64-bit (long) mode. */
235 /* Host execution mode. */
236 #if defined(CONFIG_X86_32)
237 #define X86EMUL_MODE_HOST X86EMUL_MODE_PROT32
238 #elif defined(CONFIG_X86_64)
239 #define X86EMUL_MODE_HOST X86EMUL_MODE_PROT64
242 int x86_decode_insn(struct x86_emulate_ctxt
*ctxt
,
243 struct x86_emulate_ops
*ops
);
244 int x86_emulate_insn(struct x86_emulate_ctxt
*ctxt
,
245 struct x86_emulate_ops
*ops
);
246 int emulator_task_switch(struct x86_emulate_ctxt
*ctxt
,
247 struct x86_emulate_ops
*ops
,
248 u16 tss_selector
, int reason
,
249 bool has_error_code
, u32 error_code
);
251 #endif /* _ASM_X86_KVM_X86_EMULATE_H */