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