c37296d0e9095f6f36ef734cb86dbf1632aa095d
[linux-2.6.git] / arch / x86 / include / asm / kvm_emulate.h
1 /******************************************************************************
2  * x86_emulate.h
3  *
4  * Generic x86 (32-bit and 64-bit) instruction decoder and emulator.
5  *
6  * Copyright (c) 2005 Keir Fraser
7  *
8  * From: xen-unstable 10676:af9809f51f81a3c43f276f00c81a52ef558afda4
9  */
10
11 #ifndef _ASM_X86_KVM_X86_EMULATE_H
12 #define _ASM_X86_KVM_X86_EMULATE_H
13
14 #include <asm/desc_defs.h>
15
16 struct x86_emulate_ctxt;
17
18 /*
19  * x86_emulate_ops:
20  *
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).
25  *
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.
32  *
33  * NOTES:
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.
47  */
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 {
57         /*
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.
63          */
64         int (*read_std)(unsigned long addr, void *val,
65                         unsigned int bytes, struct kvm_vcpu *vcpu, u32 *error);
66
67         /*
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.
73          */
74         int (*write_std)(unsigned long addr, void *val,
75                          unsigned int bytes, struct kvm_vcpu *vcpu, u32 *error);
76         /*
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.
82          */
83         int (*fetch)(unsigned long addr, void *val,
84                         unsigned int bytes, struct kvm_vcpu *vcpu, u32 *error);
85
86         /*
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.
91          */
92         int (*read_emulated)(unsigned long addr,
93                              void *val,
94                              unsigned int bytes,
95                              struct kvm_vcpu *vcpu);
96
97         /*
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
101          *                required).
102          *  @bytes: [IN ] Number of bytes to write to memory.
103          */
104         int (*write_emulated)(unsigned long addr,
105                               const void *val,
106                               unsigned int bytes,
107                               struct kvm_vcpu *vcpu);
108
109         /*
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.
116          */
117         int (*cmpxchg_emulated)(unsigned long addr,
118                                 const void *old,
119                                 const void *new,
120                                 unsigned int bytes,
121                                 struct kvm_vcpu *vcpu);
122
123         int (*pio_in_emulated)(int size, unsigned short port, void *val,
124                                unsigned int count, struct kvm_vcpu *vcpu);
125
126         int (*pio_out_emulated)(int size, unsigned short port, const void *val,
127                                 unsigned int count, struct kvm_vcpu *vcpu);
128
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         void (*get_gdt)(struct desc_ptr *dt, struct kvm_vcpu *vcpu);
136         ulong (*get_cr)(int cr, struct kvm_vcpu *vcpu);
137         void (*set_cr)(int cr, ulong val, struct kvm_vcpu *vcpu);
138         int (*cpl)(struct kvm_vcpu *vcpu);
139         void (*set_rflags)(struct kvm_vcpu *vcpu, unsigned long rflags);
140         int (*get_dr)(int dr, unsigned long *dest, struct kvm_vcpu *vcpu);
141         int (*set_dr)(int dr, unsigned long value, struct kvm_vcpu *vcpu);
142 };
143
144 /* Type, address-of, and value of an instruction's operand. */
145 struct operand {
146         enum { OP_REG, OP_MEM, OP_IMM, OP_NONE } type;
147         unsigned int bytes;
148         unsigned long orig_val, *ptr;
149         union {
150                 unsigned long val;
151                 char valptr[sizeof(unsigned long) + 2];
152         };
153 };
154
155 struct fetch_cache {
156         u8 data[15];
157         unsigned long start;
158         unsigned long end;
159 };
160
161 struct read_cache {
162         u8 data[1024];
163         unsigned long pos;
164         unsigned long end;
165 };
166
167 struct decode_cache {
168         u8 twobyte;
169         u8 b;
170         u8 lock_prefix;
171         u8 rep_prefix;
172         u8 op_bytes;
173         u8 ad_bytes;
174         u8 rex_prefix;
175         struct operand src;
176         struct operand src2;
177         struct operand dst;
178         bool has_seg_override;
179         u8 seg_override;
180         unsigned int d;
181         unsigned long regs[NR_VCPU_REGS];
182         unsigned long eip;
183         /* modrm */
184         u8 modrm;
185         u8 modrm_mod;
186         u8 modrm_reg;
187         u8 modrm_rm;
188         u8 use_modrm_ea;
189         bool rip_relative;
190         unsigned long modrm_ea;
191         void *modrm_ptr;
192         unsigned long modrm_val;
193         struct fetch_cache fetch;
194         struct read_cache io_read;
195         struct read_cache mem_read;
196 };
197
198 struct x86_emulate_ctxt {
199         /* Register state before/after emulation. */
200         struct kvm_vcpu *vcpu;
201
202         unsigned long eflags;
203         unsigned long eip; /* eip before instruction emulation */
204         /* Emulated execution mode, represented by an X86EMUL_MODE value. */
205         int mode;
206         u32 cs_base;
207
208         /* interruptibility state, as a result of execution of STI or MOV SS */
209         int interruptibility;
210
211         bool restart; /* restart string instruction after writeback */
212         /* decode cache */
213         struct decode_cache decode;
214 };
215
216 /* Repeat String Operation Prefix */
217 #define REPE_PREFIX     1
218 #define REPNE_PREFIX    2
219
220 /* Execution mode, passed to the emulator. */
221 #define X86EMUL_MODE_REAL     0 /* Real mode.             */
222 #define X86EMUL_MODE_VM86     1 /* Virtual 8086 mode.     */
223 #define X86EMUL_MODE_PROT16   2 /* 16-bit protected mode. */
224 #define X86EMUL_MODE_PROT32   4 /* 32-bit protected mode. */
225 #define X86EMUL_MODE_PROT64   8 /* 64-bit (long) mode.    */
226
227 /* Host execution mode. */
228 #if defined(CONFIG_X86_32)
229 #define X86EMUL_MODE_HOST X86EMUL_MODE_PROT32
230 #elif defined(CONFIG_X86_64)
231 #define X86EMUL_MODE_HOST X86EMUL_MODE_PROT64
232 #endif
233
234 int x86_decode_insn(struct x86_emulate_ctxt *ctxt,
235                     struct x86_emulate_ops *ops);
236 int x86_emulate_insn(struct x86_emulate_ctxt *ctxt,
237                      struct x86_emulate_ops *ops);
238 int emulator_task_switch(struct x86_emulate_ctxt *ctxt,
239                          struct x86_emulate_ops *ops,
240                          u16 tss_selector, int reason,
241                          bool has_error_code, u32 error_code);
242
243 #endif /* _ASM_X86_KVM_X86_EMULATE_H */