BXE: min->MIN, plus an spatch
[akaros.git] / kern / arch / x86 / 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 __X86_EMULATE_H__
12 #define __X86_EMULATE_H__
13
14 struct x86_emulate_ctxt;
15
16 /*
17  * x86_emulate_ops:
18  *
19  * These operations represent the instruction emulator's interface to memory.
20  * There are two categories of operation: those that act on ordinary memory
21  * regions (*_std), and those that act on memory regions known to require
22  * special treatment or emulation (*_emulated).
23  *
24  * The emulator assumes that an instruction accesses only one 'emulated memory'
25  * location, that this location is the given linear faulting address (cr2), and
26  * that this is one of the instruction's data operands. Instruction fetches and
27  * stack operations are assumed never to access emulated memory. The emulator
28  * automatically deduces which operand of a string-move operation is accessing
29  * emulated memory, and assumes that the other operand accesses normal memory.
30  *
31  * NOTES:
32  *  1. The emulator isn't very smart about emulated vs. standard memory.
33  *     'Emulated memory' access addresses should be checked for sanity.
34  *     'Normal memory' accesses may fault, and the caller must arrange to
35  *     detect and handle reentrancy into the emulator via recursive faults.
36  *     Accesses may be unaligned and may cross page boundaries.
37  *  2. If the access fails (cannot emulate, or a standard access faults) then
38  *     it is up to the memop to propagate the fault to the guest VM via
39  *     some out-of-band mechanism, unknown to the emulator. The memop signals
40  *     failure by returning X86EMUL_PROPAGATE_FAULT to the emulator, which will
41  *     then immediately bail.
42  *  3. Valid access sizes are 1, 2, 4 and 8 bytes. On x86/32 systems only
43  *     cmpxchg8b_emulated need support 8-byte accesses.
44  *  4. The emulator cannot handle 64-bit mode emulation on an x86/32 system.
45  */
46 /* Access completed successfully: continue emulation as normal. */
47 #define X86EMUL_CONTINUE        0
48 /* Access is unhandleable: bail from emulation and return error to caller. */
49 #define X86EMUL_UNHANDLEABLE    1
50 /* Terminate emulation but return success to the caller. */
51 #define X86EMUL_PROPAGATE_FAULT 2       /* propagate a generated fault to guest */
52 #define X86EMUL_RETRY_INSTR     2       /* retry the instruction for some reason */
53 #define X86EMUL_CMPXCHG_FAILED  2       /* cmpxchg did not see expected value */
54 struct x86_emulate_ops {
55         /*
56          * read_std: Read bytes of standard (non-emulated/special) memory.
57          *           Used for instruction fetch, stack operations, and others.
58          *  @addr:  [IN ] Linear address from which to read.
59          *  @val:   [OUT] Value read from memory, zero-extended to 'u_long'.
60          *  @bytes: [IN ] Number of bytes to read from memory.
61          */
62         int (*read_std) (unsigned long addr,
63                                          unsigned long *val,
64                                          unsigned int bytes, struct x86_emulate_ctxt * ctxt);
65
66         /*
67          * write_std: Write bytes of standard (non-emulated/special) memory.
68          *            Used for stack operations, and others.
69          *  @addr:  [IN ] Linear address to which to write.
70          *  @val:   [IN ] Value to write to memory (low-order bytes used as
71          *                required).
72          *  @bytes: [IN ] Number of bytes to write to memory.
73          */
74         int (*write_std) (unsigned long addr,
75                                           unsigned long val,
76                                           unsigned int bytes, struct x86_emulate_ctxt * ctxt);
77
78         /*
79          * read_emulated: Read bytes from emulated/special memory area.
80          *  @addr:  [IN ] Linear address from which to read.
81          *  @val:   [OUT] Value read from memory, zero-extended to 'u_long'.
82          *  @bytes: [IN ] Number of bytes to read from memory.
83          */
84         int (*read_emulated) (unsigned long addr,
85                                                   unsigned long *val,
86                                                   unsigned int bytes, struct x86_emulate_ctxt * ctxt);
87
88         /*
89          * write_emulated: Read bytes from emulated/special memory area.
90          *  @addr:  [IN ] Linear address to which to write.
91          *  @val:   [IN ] Value to write to memory (low-order bytes used as
92          *                required).
93          *  @bytes: [IN ] Number of bytes to write to memory.
94          */
95         int (*write_emulated) (unsigned long addr,
96                                                    unsigned long val,
97                                                    unsigned int bytes, struct x86_emulate_ctxt * ctxt);
98
99         /*
100          * cmpxchg_emulated: Emulate an atomic (LOCKed) CMPXCHG operation on an
101          *                   emulated/special memory area.
102          *  @addr:  [IN ] Linear address to access.
103          *  @old:   [IN ] Value expected to be current at @addr.
104          *  @new:   [IN ] Value to write to @addr.
105          *  @bytes: [IN ] Number of bytes to access using CMPXCHG.
106          */
107         int (*cmpxchg_emulated) (unsigned long addr,
108                                                          unsigned long old,
109                                                          unsigned long new,
110                                                          unsigned int bytes,
111                                                          struct x86_emulate_ctxt * ctxt);
112
113         /*
114          * cmpxchg8b_emulated: Emulate an atomic (LOCKed) CMPXCHG8B 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          * NOTES:
120          *  1. This function is only ever called when emulating a real CMPXCHG8B.
121          *  2. This function is *never* called on x86/64 systems.
122          *  2. Not defining this function (i.e., specifying NULL) is equivalent
123          *     to defining a function that always returns X86EMUL_UNHANDLEABLE.
124          */
125         int (*cmpxchg8b_emulated) (unsigned long addr,
126                                                            unsigned long old_lo,
127                                                            unsigned long old_hi,
128                                                            unsigned long new_lo,
129                                                            unsigned long new_hi,
130                                                            struct x86_emulate_ctxt * ctxt);
131 };
132
133 struct cpu_user_regs;
134
135 struct x86_emulate_ctxt {
136         /* Register state before/after emulation. */
137         struct litevm_vcpu *vcpu;
138
139         /* Linear faulting address (if emulating a page-faulting instruction). */
140         unsigned long eflags;
141         unsigned long cr2;
142
143         /* Emulated execution mode, represented by an X86EMUL_MODE value. */
144         int mode;
145
146         unsigned long cs_base;
147         unsigned long ds_base;
148         unsigned long es_base;
149         unsigned long ss_base;
150         unsigned long gs_base;
151         unsigned long fs_base;
152 };
153
154 /* Execution mode, passed to the emulator. */
155 #define X86EMUL_MODE_REAL     0 /* Real mode.             */
156 #define X86EMUL_MODE_PROT16   2 /* 16-bit protected mode. */
157 #define X86EMUL_MODE_PROT32   4 /* 32-bit protected mode. */
158 #define X86EMUL_MODE_PROT64   8 /* 64-bit (long) mode.    */
159
160 /* Host execution mode. */
161 #if defined(__i386__)
162 #define X86EMUL_MODE_HOST X86EMUL_MODE_PROT32
163 #elif defined(__x86_64__)
164 #define X86EMUL_MODE_HOST X86EMUL_MODE_PROT64
165 #endif
166
167 /*
168  * x86_emulate_memop: Emulate an instruction that faulted attempting to
169  *                    read/write a 'special' memory area.
170  * Returns -1 on failure, 0 on success.
171  */
172 int x86_emulate_memop(struct x86_emulate_ctxt *ctxt,
173                                           struct x86_emulate_ops *ops);
174
175 /*
176  * Given the 'reg' portion of a ModRM byte, and a register block, return a
177  * pointer into the block that addresses the relevant register.
178  * @highbyte_regs specifies whether to decode AH,CH,DH,BH.
179  */
180 void *decode_register(uint8_t modrm_reg, unsigned long *regs,
181                                           int highbyte_regs);
182
183 #endif /* __X86_EMULATE_H__ */