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 2 /* retry the instruction for some reason */
55 #define X86EMUL_CMPXCHG_FAILED 2 /* cmpxchg did not see expected value */
56 struct x86_emulate_ops {
58 * read_std: Read bytes of standard (non-emulated/special) memory.
59 * Used for descriptor reading.
60 * @addr: [IN ] Linear address from which to read.
61 * @val: [OUT] Value read from memory, zero-extended to 'u_long'.
62 * @bytes: [IN ] Number of bytes to read from memory.
64 int (*read_std)(unsigned long addr, void *val,
65 unsigned int bytes, struct kvm_vcpu *vcpu, u32 *error);
68 * write_std: Write bytes of standard (non-emulated/special) memory.
69 * Used for descriptor writing.
70 * @addr: [IN ] Linear address to which to write.
71 * @val: [OUT] Value write to memory, zero-extended to 'u_long'.
72 * @bytes: [IN ] Number of bytes to write to memory.
74 int (*write_std)(unsigned long addr, void *val,
75 unsigned int bytes, struct kvm_vcpu *vcpu, u32 *error);
77 * fetch: Read bytes of standard (non-emulated/special) memory.
78 * Used for instruction fetch.
79 * @addr: [IN ] Linear address from which to read.
80 * @val: [OUT] Value read from memory, zero-extended to 'u_long'.
81 * @bytes: [IN ] Number of bytes to read from memory.
83 int (*fetch)(unsigned long addr, void *val,
84 unsigned int bytes, struct kvm_vcpu *vcpu, u32 *error);
87 * read_emulated: Read bytes from emulated/special memory area.
88 * @addr: [IN ] Linear address from which to read.
89 * @val: [OUT] Value read from memory, zero-extended to 'u_long'.
90 * @bytes: [IN ] Number of bytes to read from memory.
92 int (*read_emulated)(unsigned long addr,
95 struct kvm_vcpu *vcpu);
98 * write_emulated: Write bytes to emulated/special memory area.
99 * @addr: [IN ] Linear address to which to write.
100 * @val: [IN ] Value to write to memory (low-order bytes used as
102 * @bytes: [IN ] Number of bytes to write to memory.
104 int (*write_emulated)(unsigned long addr,
107 struct kvm_vcpu *vcpu);
110 * cmpxchg_emulated: Emulate an atomic (LOCKed) CMPXCHG operation on an
111 * emulated/special memory area.
112 * @addr: [IN ] Linear address to access.
113 * @old: [IN ] Value expected to be current at @addr.
114 * @new: [IN ] Value to write to @addr.
115 * @bytes: [IN ] Number of bytes to access using CMPXCHG.
117 int (*cmpxchg_emulated)(unsigned long addr,
121 struct kvm_vcpu *vcpu);
123 int (*pio_in_emulated)(int size, unsigned short port, void *val,
124 unsigned int count, struct kvm_vcpu *vcpu);
126 int (*pio_out_emulated)(int size, unsigned short port, const void *val,
127 unsigned int count, struct kvm_vcpu *vcpu);
129 bool (*get_cached_descriptor)(struct desc_struct *desc,
130 int seg, struct kvm_vcpu *vcpu);
131 void (*set_cached_descriptor)(struct desc_struct *desc,
132 int seg, struct kvm_vcpu *vcpu);
133 u16 (*get_segment_selector)(int seg, struct kvm_vcpu *vcpu);
134 void (*set_segment_selector)(u16 sel, int seg, struct kvm_vcpu *vcpu);
135 unsigned long (*get_cached_segment_base)(int seg, struct kvm_vcpu *vcpu);
136 void (*get_gdt)(struct desc_ptr *dt, struct kvm_vcpu *vcpu);
137 ulong (*get_cr)(int cr, struct kvm_vcpu *vcpu);
138 int (*set_cr)(int cr, ulong val, struct kvm_vcpu *vcpu);
139 int (*cpl)(struct kvm_vcpu *vcpu);
140 void (*set_rflags)(struct kvm_vcpu *vcpu, unsigned long rflags);
141 int (*get_dr)(int dr, unsigned long *dest, struct kvm_vcpu *vcpu);
142 int (*set_dr)(int dr, unsigned long value, struct kvm_vcpu *vcpu);
143 int (*set_msr)(struct kvm_vcpu *vcpu, u32 msr_index, u64 data);
144 int (*get_msr)(struct kvm_vcpu *vcpu, u32 msr_index, u64 *pdata);
147 /* Type, address-of, and value of an instruction's operand. */
149 enum { OP_REG, OP_MEM, OP_IMM, OP_NONE } type;
151 unsigned long orig_val, *ptr;
154 char valptr[sizeof(unsigned long) + 2];
170 struct decode_cache {
181 bool has_seg_override;
184 unsigned long regs[NR_VCPU_REGS];
193 unsigned long modrm_ea;
195 unsigned long modrm_val;
196 struct fetch_cache fetch;
197 struct read_cache io_read;
198 struct read_cache mem_read;
201 struct x86_emulate_ctxt {
202 /* Register state before/after emulation. */
203 struct kvm_vcpu *vcpu;
205 unsigned long eflags;
206 unsigned long eip; /* eip before instruction emulation */
207 /* Emulated execution mode, represented by an X86EMUL_MODE value. */
211 /* interruptibility state, as a result of execution of STI or MOV SS */
212 int interruptibility;
214 bool restart; /* restart string instruction after writeback */
216 struct decode_cache decode;
219 /* Repeat String Operation Prefix */
220 #define REPE_PREFIX 1
221 #define REPNE_PREFIX 2
223 /* Execution mode, passed to the emulator. */
224 #define X86EMUL_MODE_REAL 0 /* Real mode. */
225 #define X86EMUL_MODE_VM86 1 /* Virtual 8086 mode. */
226 #define X86EMUL_MODE_PROT16 2 /* 16-bit protected mode. */
227 #define X86EMUL_MODE_PROT32 4 /* 32-bit protected mode. */
228 #define X86EMUL_MODE_PROT64 8 /* 64-bit (long) mode. */
230 /* Host execution mode. */
231 #if defined(CONFIG_X86_32)
232 #define X86EMUL_MODE_HOST X86EMUL_MODE_PROT32
233 #elif defined(CONFIG_X86_64)
234 #define X86EMUL_MODE_HOST X86EMUL_MODE_PROT64
237 int x86_decode_insn(struct x86_emulate_ctxt *ctxt,
238 struct x86_emulate_ops *ops);
239 int x86_emulate_insn(struct x86_emulate_ctxt *ctxt,
240 struct x86_emulate_ops *ops);
241 int emulator_task_switch(struct x86_emulate_ctxt *ctxt,
242 struct x86_emulate_ops *ops,
243 u16 tss_selector, int reason,
244 bool has_error_code, u32 error_code);
246 #endif /* _ASM_X86_KVM_X86_EMULATE_H */