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
;
27 * These operations represent the instruction emulator's interface to memory.
28 * There are two categories of operation: those that act on ordinary memory
29 * regions (*_std), and those that act on memory regions known to require
30 * special treatment or emulation (*_emulated).
32 * The emulator assumes that an instruction accesses only one 'emulated memory'
33 * location, that this location is the given linear faulting address (cr2), and
34 * that this is one of the instruction's data operands. Instruction fetches and
35 * stack operations are assumed never to access emulated memory. The emulator
36 * automatically deduces which operand of a string-move operation is accessing
37 * emulated memory, and assumes that the other operand accesses normal memory.
40 * 1. The emulator isn't very smart about emulated vs. standard memory.
41 * 'Emulated memory' access addresses should be checked for sanity.
42 * 'Normal memory' accesses may fault, and the caller must arrange to
43 * detect and handle reentrancy into the emulator via recursive faults.
44 * Accesses may be unaligned and may cross page boundaries.
45 * 2. If the access fails (cannot emulate, or a standard access faults) then
46 * it is up to the memop to propagate the fault to the guest VM via
47 * some out-of-band mechanism, unknown to the emulator. The memop signals
48 * failure by returning X86EMUL_PROPAGATE_FAULT to the emulator, which will
49 * then immediately bail.
50 * 3. Valid access sizes are 1, 2, 4 and 8 bytes. On x86/32 systems only
51 * cmpxchg8b_emulated need support 8-byte accesses.
52 * 4. The emulator cannot handle 64-bit mode emulation on an x86/32 system.
54 /* Access completed successfully: continue emulation as normal. */
55 #define X86EMUL_CONTINUE 0
56 /* Access is unhandleable: bail from emulation and return error to caller. */
57 #define X86EMUL_UNHANDLEABLE 1
58 /* Terminate emulation but return success to the caller. */
59 #define X86EMUL_PROPAGATE_FAULT 2 /* propagate a generated fault to guest */
60 #define X86EMUL_RETRY_INSTR 3 /* retry the instruction for some reason */
61 #define X86EMUL_CMPXCHG_FAILED 4 /* cmpxchg did not see expected value */
62 #define X86EMUL_IO_NEEDED 5 /* IO is needed to complete emulation */
64 struct x86_emulate_ops
{
66 * read_std: Read bytes of standard (non-emulated/special) memory.
67 * Used for descriptor reading.
68 * @addr: [IN ] Linear address from which to read.
69 * @val: [OUT] Value read from memory, zero-extended to 'u_long'.
70 * @bytes: [IN ] Number of bytes to read from memory.
72 int (*read_std
)(unsigned long addr
, void *val
,
73 unsigned int bytes
, struct kvm_vcpu
*vcpu
,
74 struct x86_exception
*fault
);
77 * write_std: Write bytes of standard (non-emulated/special) memory.
78 * Used for descriptor writing.
79 * @addr: [IN ] Linear address to which to write.
80 * @val: [OUT] Value write to memory, zero-extended to 'u_long'.
81 * @bytes: [IN ] Number of bytes to write to memory.
83 int (*write_std
)(unsigned long addr
, void *val
,
84 unsigned int bytes
, struct kvm_vcpu
*vcpu
,
85 struct x86_exception
*fault
);
87 * fetch: Read bytes of standard (non-emulated/special) memory.
88 * Used for instruction fetch.
89 * @addr: [IN ] Linear address from which to read.
90 * @val: [OUT] Value read from memory, zero-extended to 'u_long'.
91 * @bytes: [IN ] Number of bytes to read from memory.
93 int (*fetch
)(unsigned long addr
, void *val
,
94 unsigned int bytes
, struct kvm_vcpu
*vcpu
,
95 struct x86_exception
*fault
);
98 * read_emulated: Read bytes from emulated/special memory area.
99 * @addr: [IN ] Linear address from which to read.
100 * @val: [OUT] Value read from memory, zero-extended to 'u_long'.
101 * @bytes: [IN ] Number of bytes to read from memory.
103 int (*read_emulated
)(unsigned long addr
,
106 struct x86_exception
*fault
,
107 struct kvm_vcpu
*vcpu
);
110 * write_emulated: Write bytes to emulated/special memory area.
111 * @addr: [IN ] Linear address to which to write.
112 * @val: [IN ] Value to write to memory (low-order bytes used as
114 * @bytes: [IN ] Number of bytes to write to memory.
116 int (*write_emulated
)(unsigned long addr
,
119 struct x86_exception
*fault
,
120 struct kvm_vcpu
*vcpu
);
123 * cmpxchg_emulated: Emulate an atomic (LOCKed) CMPXCHG operation on an
124 * emulated/special memory area.
125 * @addr: [IN ] Linear address to access.
126 * @old: [IN ] Value expected to be current at @addr.
127 * @new: [IN ] Value to write to @addr.
128 * @bytes: [IN ] Number of bytes to access using CMPXCHG.
130 int (*cmpxchg_emulated
)(unsigned long addr
,
134 struct x86_exception
*fault
,
135 struct kvm_vcpu
*vcpu
);
137 int (*pio_in_emulated
)(int size
, unsigned short port
, void *val
,
138 unsigned int count
, struct kvm_vcpu
*vcpu
);
140 int (*pio_out_emulated
)(int size
, unsigned short port
, const void *val
,
141 unsigned int count
, struct kvm_vcpu
*vcpu
);
143 bool (*get_cached_descriptor
)(struct desc_struct
*desc
,
144 int seg
, struct kvm_vcpu
*vcpu
);
145 void (*set_cached_descriptor
)(struct desc_struct
*desc
,
146 int seg
, struct kvm_vcpu
*vcpu
);
147 u16 (*get_segment_selector
)(int seg
, struct kvm_vcpu
*vcpu
);
148 void (*set_segment_selector
)(u16 sel
, int seg
, struct kvm_vcpu
*vcpu
);
149 unsigned long (*get_cached_segment_base
)(int seg
, struct kvm_vcpu
*vcpu
);
150 void (*get_gdt
)(struct desc_ptr
*dt
, struct kvm_vcpu
*vcpu
);
151 void (*get_idt
)(struct desc_ptr
*dt
, struct kvm_vcpu
*vcpu
);
152 ulong (*get_cr
)(int cr
, struct kvm_vcpu
*vcpu
);
153 int (*set_cr
)(int cr
, ulong val
, struct kvm_vcpu
*vcpu
);
154 int (*cpl
)(struct kvm_vcpu
*vcpu
);
155 int (*get_dr
)(int dr
, unsigned long *dest
, struct kvm_vcpu
*vcpu
);
156 int (*set_dr
)(int dr
, unsigned long value
, struct kvm_vcpu
*vcpu
);
157 int (*set_msr
)(struct kvm_vcpu
*vcpu
, u32 msr_index
, u64 data
);
158 int (*get_msr
)(struct kvm_vcpu
*vcpu
, u32 msr_index
, u64
*pdata
);
161 /* Type, address-of, and value of an instruction's operand. */
163 enum { OP_REG
, OP_MEM
, OP_IMM
, OP_NONE
} type
;
166 unsigned long orig_val
;
171 struct segmented_address
{
179 char valptr
[sizeof(unsigned long) + 2];
195 struct decode_cache
{
206 bool has_seg_override
;
209 int (*execute
)(struct x86_emulate_ctxt
*ctxt
);
210 unsigned long regs
[NR_VCPU_REGS
];
219 struct fetch_cache fetch
;
220 struct read_cache io_read
;
221 struct read_cache mem_read
;
224 struct x86_emulate_ctxt
{
225 struct x86_emulate_ops
*ops
;
227 /* Register state before/after emulation. */
228 struct kvm_vcpu
*vcpu
;
230 unsigned long eflags
;
231 unsigned long eip
; /* eip before instruction emulation */
232 /* Emulated execution mode, represented by an X86EMUL_MODE value. */
236 /* interruptibility state, as a result of execution of STI or MOV SS */
237 int interruptibility
;
239 bool perm_ok
; /* do not check permissions if true */
242 struct x86_exception exception
;
245 struct decode_cache decode
;
248 /* Repeat String Operation Prefix */
249 #define REPE_PREFIX 1
250 #define REPNE_PREFIX 2
252 /* Execution mode, passed to the emulator. */
253 #define X86EMUL_MODE_REAL 0 /* Real mode. */
254 #define X86EMUL_MODE_VM86 1 /* Virtual 8086 mode. */
255 #define X86EMUL_MODE_PROT16 2 /* 16-bit protected mode. */
256 #define X86EMUL_MODE_PROT32 4 /* 32-bit protected mode. */
257 #define X86EMUL_MODE_PROT64 8 /* 64-bit (long) mode. */
259 /* Host execution mode. */
260 #if defined(CONFIG_X86_32)
261 #define X86EMUL_MODE_HOST X86EMUL_MODE_PROT32
262 #elif defined(CONFIG_X86_64)
263 #define X86EMUL_MODE_HOST X86EMUL_MODE_PROT64
266 int x86_decode_insn(struct x86_emulate_ctxt
*ctxt
);
267 #define EMULATION_FAILED -1
268 #define EMULATION_OK 0
269 #define EMULATION_RESTART 1
270 int x86_emulate_insn(struct x86_emulate_ctxt
*ctxt
);
271 int emulator_task_switch(struct x86_emulate_ctxt
*ctxt
,
272 u16 tss_selector
, int reason
,
273 bool has_error_code
, u32 error_code
);
274 int emulate_int_real(struct x86_emulate_ctxt
*ctxt
,
275 struct x86_emulate_ops
*ops
, int irq
);
276 #endif /* _ASM_X86_KVM_X86_EMULATE_H */
This page took 0.037387 seconds and 5 git commands to generate.