6 #define CONFIG_X86_32 1
12 #define CONFIG_X86_64 1
16 #if defined(__i386__) || defined (__x86_64__)
41 /******************************************************************************
44 * Generic x86 (32-bit and 64-bit) instruction decoder and emulator.
46 * Copyright (c) 2005 Keir Fraser
48 * From: xen-unstable 10676:af9809f51f81a3c43f276f00c81a52ef558afda4
51 #ifndef _ASM_X86_KVM_X86_EMULATE_H
52 #define _ASM_X86_KVM_X86_EMULATE_H
54 struct x86_emulate_ctxt
;
59 * These operations represent the instruction emulator's interface to memory.
60 * There are two categories of operation: those that act on ordinary memory
61 * regions (*_std), and those that act on memory regions known to require
62 * special treatment or emulation (*_emulated).
64 * The emulator assumes that an instruction accesses only one 'emulated memory'
65 * location, that this location is the given linear faulting address (cr2), and
66 * that this is one of the instruction's data operands. Instruction fetches and
67 * stack operations are assumed never to access emulated memory. The emulator
68 * automatically deduces which operand of a string-move operation is accessing
69 * emulated memory, and assumes that the other operand accesses normal memory.
72 * 1. The emulator isn't very smart about emulated vs. standard memory.
73 * 'Emulated memory' access addresses should be checked for sanity.
74 * 'Normal memory' accesses may fault, and the caller must arrange to
75 * detect and handle reentrancy into the emulator via recursive faults.
76 * Accesses may be unaligned and may cross page boundaries.
77 * 2. If the access fails (cannot emulate, or a standard access faults) then
78 * it is up to the memop to propagate the fault to the guest VM via
79 * some out-of-band mechanism, unknown to the emulator. The memop signals
80 * failure by returning X86EMUL_PROPAGATE_FAULT to the emulator, which will
81 * then immediately bail.
82 * 3. Valid access sizes are 1, 2, 4 and 8 bytes. On x86/32 systems only
83 * cmpxchg8b_emulated need support 8-byte accesses.
84 * 4. The emulator cannot handle 64-bit mode emulation on an x86/32 system.
86 /* Access completed successfully: continue emulation as normal. */
87 #define X86EMUL_CONTINUE 0
88 /* Access is unhandleable: bail from emulation and return error to caller. */
89 #define X86EMUL_UNHANDLEABLE 1
90 /* Terminate emulation but return success to the caller. */
91 #define X86EMUL_PROPAGATE_FAULT 2 /* propagate a generated fault to guest */
92 #define X86EMUL_RETRY_INSTR 2 /* retry the instruction for some reason */
93 #define X86EMUL_CMPXCHG_FAILED 2 /* cmpxchg did not see expected value */
94 struct x86_emulate_ops
{
96 * read_std: Read bytes of standard (non-emulated/special) memory.
97 * Used for instruction fetch, stack operations, and others.
98 * @addr: [IN ] Linear address from which to read.
99 * @val: [OUT] Value read from memory, zero-extended to 'u_long'.
100 * @bytes: [IN ] Number of bytes to read from memory.
102 int (*read_std
)(unsigned long addr
, void *val
,
103 unsigned int bytes
, struct kvm_vcpu
*vcpu
);
106 * read_emulated: Read bytes from emulated/special memory area.
107 * @addr: [IN ] Linear address from which to read.
108 * @val: [OUT] Value read from memory, zero-extended to 'u_long'.
109 * @bytes: [IN ] Number of bytes to read from memory.
111 int (*read_emulated
)(unsigned long addr
,
114 struct kvm_vcpu
*vcpu
);
117 * write_emulated: Read bytes from emulated/special memory area.
118 * @addr: [IN ] Linear address to which to write.
119 * @val: [IN ] Value to write to memory (low-order bytes used as
121 * @bytes: [IN ] Number of bytes to write to memory.
123 int (*write_emulated
)(unsigned long addr
,
126 struct kvm_vcpu
*vcpu
);
129 * cmpxchg_emulated: Emulate an atomic (LOCKed) CMPXCHG operation on an
130 * emulated/special memory area.
131 * @addr: [IN ] Linear address to access.
132 * @old: [IN ] Value expected to be current at @addr.
133 * @new: [IN ] Value to write to @addr.
134 * @bytes: [IN ] Number of bytes to access using CMPXCHG.
136 int (*cmpxchg_emulated
)(unsigned long addr
,
140 struct kvm_vcpu
*vcpu
);
144 /* Type, address-of, and value of an instruction's operand. */
146 enum { OP_REG
, OP_MEM
, OP_IMM
, OP_NONE
} type
;
148 unsigned long val
, orig_val
, *ptr
;
157 struct decode_cache
{
168 bool has_seg_override
;
171 unsigned long regs
[NR_VCPU_REGS
];
180 unsigned long modrm_ea
;
182 unsigned long modrm_val
;
183 struct fetch_cache fetch
;
186 struct x86_emulate_ctxt
{
187 /* Register state before/after emulation. */
188 struct kvm_vcpu
*vcpu
;
190 unsigned long eflags
;
191 /* Emulated execution mode, represented by an X86EMUL_MODE value. */
196 struct decode_cache decode
;
199 /* Repeat String Operation Prefix */
200 #define REPE_PREFIX 1
201 #define REPNE_PREFIX 2
203 /* Execution mode, passed to the emulator. */
204 #define X86EMUL_MODE_REAL 0 /* Real mode. */
205 #define X86EMUL_MODE_PROT16 2 /* 16-bit protected mode. */
206 #define X86EMUL_MODE_PROT32 4 /* 32-bit protected mode. */
207 #define X86EMUL_MODE_PROT64 8 /* 64-bit (long) mode. */
209 /* Host execution mode. */
210 #if defined(CONFIG_X86_32)
211 #define X86EMUL_MODE_HOST X86EMUL_MODE_PROT32
212 #elif defined(CONFIG_X86_64)
213 #define X86EMUL_MODE_HOST X86EMUL_MODE_PROT64
216 int x86_decode_insn(struct x86_emulate_ctxt
*ctxt
,
217 struct x86_emulate_ops
*ops
);
218 int x86_emulate_insn(struct x86_emulate_ctxt
*ctxt
,
219 struct x86_emulate_ops
*ops
);
221 #endif /* _ASM_X86_KVM_X86_EMULATE_H */