1 | /* $Id: VBoxREMWrapper.cpp 38364 2011-08-08 19:12:29Z vboxsync $ */
|
---|
2 | /** @file
|
---|
3 | *
|
---|
4 | * VBoxREM Win64 DLL Wrapper.
|
---|
5 | */
|
---|
6 | /*
|
---|
7 | * Copyright (C) 2006-2007 Oracle Corporation
|
---|
8 | *
|
---|
9 | * This file is part of VirtualBox Open Source Edition (OSE), as
|
---|
10 | * available from http://www.virtualbox.org. This file is free software;
|
---|
11 | * you can redistribute it and/or modify it under the terms of the GNU
|
---|
12 | * General Public License (GPL) as published by the Free Software
|
---|
13 | * Foundation, in version 2 as it comes in the "COPYING" file of the
|
---|
14 | * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
|
---|
15 | * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
|
---|
16 | */
|
---|
17 |
|
---|
18 |
|
---|
19 | /** @page pg_vboxrem_amd64 VBoxREM Hacks on AMD64
|
---|
20 | *
|
---|
21 | * There are problems with building BoxREM both on WIN64 and 64-bit linux.
|
---|
22 | *
|
---|
23 | * On linux binutils refuses to link shared objects without -fPIC compiled code
|
---|
24 | * (bitches about some fixup types). But when trying to build with -fPIC dyngen
|
---|
25 | * doesn't like the code anymore. Sweet. The current solution is to build the
|
---|
26 | * VBoxREM code as a relocatable module and use our ELF loader to load it.
|
---|
27 | *
|
---|
28 | * On WIN64 we're not aware of any GCC port which can emit code using the MSC
|
---|
29 | * calling convention. So, we're in for some real fun here. The choice is between
|
---|
30 | * porting GCC to AMD64 WIN64 and coming up with some kind of wrapper around
|
---|
31 | * either the win32 build or the 64-bit linux build.
|
---|
32 | *
|
---|
33 | * -# Porting GCC will be a lot of work. For one thing the calling convention differs
|
---|
34 | * and messing with such stuff can easily create ugly bugs. We would also have to
|
---|
35 | * do some binutils changes, but I think those are rather small compared to GCC.
|
---|
36 | * (That said, the MSC calling convention is far simpler than the linux one, it
|
---|
37 | * reminds me of _Optlink which we have working already.)
|
---|
38 | * -# Wrapping win32 code will work, but addresses outside the first 4GB are
|
---|
39 | * inaccessible and we will have to create 32-64 thunks for all imported functions.
|
---|
40 | * (To switch between 32-bit and 64-bit is load the right CS using far jmps (32->64)
|
---|
41 | * or far returns (both).)
|
---|
42 | * -# Wrapping 64-bit linux code might be the easier solution. The requirements here
|
---|
43 | * are:
|
---|
44 | * - Remove all CRT references we possibly, either by using intrinsics or using
|
---|
45 | * IPRT. Part of IPRT will be linked into VBoxREM2.rel, this will be yet another
|
---|
46 | * IPRT mode which I've dubbed 'no-crt'. The no-crt mode provide basic non-system
|
---|
47 | * dependent stuff.
|
---|
48 | * - Compile and link it into a relocatable object (include the gcc intrinsics
|
---|
49 | * in libgcc). Call this VBoxREM2.rel.
|
---|
50 | * - Write a wrapper dll, VBoxREM.dll, for which during REMR3Init() will load
|
---|
51 | * VBoxREM2.rel (using IPRT) and generate calling convention wrappers
|
---|
52 | * for all IPRT functions and VBoxVMM functions that it uses. All exports
|
---|
53 | * will be wrapped vice versa.
|
---|
54 | * - For building on windows hosts, we will use a mingw32 hosted cross compiler.
|
---|
55 | * and add a 'no-crt' mode to IPRT where it provides the necessary CRT headers
|
---|
56 | * and function implementations.
|
---|
57 | *
|
---|
58 | * The 3rd solution will be tried out first since it requires the least effort and
|
---|
59 | * will let us make use of the full 64-bit register set.
|
---|
60 | *
|
---|
61 | *
|
---|
62 | *
|
---|
63 | * @section sec_vboxrem_amd64_compare Comparing the GCC and MSC calling conventions
|
---|
64 | *
|
---|
65 | * GCC expects the following (cut & past from page 20 in the ABI draft 0.96):
|
---|
66 | *
|
---|
67 | * @verbatim
|
---|
68 | %rax temporary register; with variable arguments passes information about the
|
---|
69 | number of SSE registers used; 1st return register.
|
---|
70 | [Not preserved]
|
---|
71 | %rbx callee-saved register; optionally used as base pointer.
|
---|
72 | [Preserved]
|
---|
73 | %rcx used to pass 4th integer argument to functions.
|
---|
74 | [Not preserved]
|
---|
75 | %rdx used to pass 3rd argument to functions; 2nd return register
|
---|
76 | [Not preserved]
|
---|
77 | %rsp stack pointer
|
---|
78 | [Preserved]
|
---|
79 | %rbp callee-saved register; optionally used as frame pointer
|
---|
80 | [Preserved]
|
---|
81 | %rsi used to pass 2nd argument to functions
|
---|
82 | [Not preserved]
|
---|
83 | %rdi used to pass 1st argument to functions
|
---|
84 | [Not preserved]
|
---|
85 | %r8 used to pass 5th argument to functions
|
---|
86 | [Not preserved]
|
---|
87 | %r9 used to pass 6th argument to functions
|
---|
88 | [Not preserved]
|
---|
89 | %r10 temporary register, used for passing a function's static chain
|
---|
90 | pointer [Not preserved]
|
---|
91 | %r11 temporary register
|
---|
92 | [Not preserved]
|
---|
93 | %r12-r15 callee-saved registers
|
---|
94 | [Preserved]
|
---|
95 | %xmm0-%xmm1 used to pass and return floating point arguments
|
---|
96 | [Not preserved]
|
---|
97 | %xmm2-%xmm7 used to pass floating point arguments
|
---|
98 | [Not preserved]
|
---|
99 | %xmm8-%xmm15 temporary registers
|
---|
100 | [Not preserved]
|
---|
101 | %mmx0-%mmx7 temporary registers
|
---|
102 | [Not preserved]
|
---|
103 | %st0 temporary register; used to return long double arguments
|
---|
104 | [Not preserved]
|
---|
105 | %st1 temporary registers; used to return long double arguments
|
---|
106 | [Not preserved]
|
---|
107 | %st2-%st7 temporary registers
|
---|
108 | [Not preserved]
|
---|
109 | %fs Reserved for system use (as thread specific data register)
|
---|
110 | [Not preserved]
|
---|
111 | @endverbatim
|
---|
112 | *
|
---|
113 | * Direction flag is preserved as cleared.
|
---|
114 | * The stack must be aligned on a 16-byte boundary before the 'call/jmp' instruction.
|
---|
115 | *
|
---|
116 | *
|
---|
117 | *
|
---|
118 | * MSC expects the following:
|
---|
119 | * @verbatim
|
---|
120 | rax return value, not preserved.
|
---|
121 | rbx preserved.
|
---|
122 | rcx 1st argument, integer, not preserved.
|
---|
123 | rdx 2nd argument, integer, not preserved.
|
---|
124 | rbp preserved.
|
---|
125 | rsp preserved.
|
---|
126 | rsi preserved.
|
---|
127 | rdi preserved.
|
---|
128 | r8 3rd argument, integer, not preserved.
|
---|
129 | r9 4th argument, integer, not preserved.
|
---|
130 | r10 scratch register, not preserved.
|
---|
131 | r11 scratch register, not preserved.
|
---|
132 | r12-r15 preserved.
|
---|
133 | xmm0 1st argument, fp, return value, not preserved.
|
---|
134 | xmm1 2st argument, fp, not preserved.
|
---|
135 | xmm2 3st argument, fp, not preserved.
|
---|
136 | xmm3 4st argument, fp, not preserved.
|
---|
137 | xmm4-xmm5 scratch, not preserved.
|
---|
138 | xmm6-xmm15 preserved.
|
---|
139 | @endverbatim
|
---|
140 | *
|
---|
141 | * Dunno what the direction flag is...
|
---|
142 | * The stack must be aligned on a 16-byte boundary before the 'call/jmp' instruction.
|
---|
143 | *
|
---|
144 | *
|
---|
145 | * Thus, When GCC code is calling MSC code we don't really have to preserve
|
---|
146 | * anything. But but MSC code is calling GCC code, we'll have to save esi and edi.
|
---|
147 | *
|
---|
148 | */
|
---|
149 |
|
---|
150 |
|
---|
151 | /*******************************************************************************
|
---|
152 | * Defined Constants And Macros *
|
---|
153 | *******************************************************************************/
|
---|
154 | /** @def USE_REM_STUBS
|
---|
155 | * Define USE_REM_STUBS to stub the entire REM stuff. This is useful during
|
---|
156 | * early porting (before we start running stuff).
|
---|
157 | */
|
---|
158 | #if defined(DOXYGEN_RUNNING)
|
---|
159 | # define USE_REM_STUBS
|
---|
160 | #endif
|
---|
161 |
|
---|
162 | /** @def USE_REM_CALLING_CONVENTION_GLUE
|
---|
163 | * Define USE_REM_CALLING_CONVENTION_GLUE for platforms where it's necessary to
|
---|
164 | * use calling convention wrappers.
|
---|
165 | */
|
---|
166 | #if (defined(RT_ARCH_AMD64) && defined(RT_OS_WINDOWS)) || defined(DOXYGEN_RUNNING)
|
---|
167 | # define USE_REM_CALLING_CONVENTION_GLUE
|
---|
168 | #endif
|
---|
169 |
|
---|
170 | /** @def USE_REM_IMPORT_JUMP_GLUE
|
---|
171 | * Define USE_REM_IMPORT_JUMP_GLUE for platforms where we need to
|
---|
172 | * emit some jump glue to deal with big addresses.
|
---|
173 | */
|
---|
174 | #if (defined(RT_ARCH_AMD64) && !defined(USE_REM_CALLING_CONVENTION_GLUE) && !defined(RT_OS_DARWIN)) || defined(DOXYGEN_RUNNING)
|
---|
175 | # define USE_REM_IMPORT_JUMP_GLUE
|
---|
176 | #endif
|
---|
177 |
|
---|
178 | /** @def VBOX_USE_BITNESS_SELECTOR
|
---|
179 | * Define VBOX_USE_BITNESS_SELECTOR to build this module as a bitness selector
|
---|
180 | * between VBoxREM32 and VBoxREM64.
|
---|
181 | */
|
---|
182 | #if defined(DOXYGEN_RUNNING)
|
---|
183 | # define VBOX_USE_BITNESS_SELECTOR
|
---|
184 | #endif
|
---|
185 |
|
---|
186 | /** @def VBOX_WITHOUT_REM_LDR_CYCLE
|
---|
187 | * Define VBOX_WITHOUT_REM_LDR_CYCLE dynamically resolve any dependencies on
|
---|
188 | * VBoxVMM and thus avoid the cyclic dependency between VBoxREM and VBoxVMM.
|
---|
189 | */
|
---|
190 | #if defined(DOXYGEN_RUNNING)
|
---|
191 | # define VBOX_WITHOUT_REM_LDR_CYCLE
|
---|
192 | #endif
|
---|
193 |
|
---|
194 |
|
---|
195 | /*******************************************************************************
|
---|
196 | * Header Files *
|
---|
197 | *******************************************************************************/
|
---|
198 | #define LOG_GROUP LOG_GROUP_REM
|
---|
199 | #include <VBox/vmm/rem.h>
|
---|
200 | #include <VBox/vmm/vmm.h>
|
---|
201 | #include <VBox/vmm/dbgf.h>
|
---|
202 | #include <VBox/dbg.h>
|
---|
203 | #include <VBox/vmm/csam.h>
|
---|
204 | #include <VBox/vmm/mm.h>
|
---|
205 | #include <VBox/vmm/em.h>
|
---|
206 | #include <VBox/vmm/ssm.h>
|
---|
207 | #include <VBox/vmm/hwaccm.h>
|
---|
208 | #include <VBox/vmm/patm.h>
|
---|
209 | #include <VBox/vmm/pdm.h>
|
---|
210 | #include <VBox/vmm/pdmcritsect.h>
|
---|
211 | #include <VBox/vmm/pgm.h>
|
---|
212 | #include <VBox/vmm/iom.h>
|
---|
213 | #include <VBox/vmm/vm.h>
|
---|
214 | #include <VBox/err.h>
|
---|
215 | #include <VBox/log.h>
|
---|
216 | #include <VBox/dis.h>
|
---|
217 |
|
---|
218 | #include <iprt/alloc.h>
|
---|
219 | #include <iprt/assert.h>
|
---|
220 | #include <iprt/ldr.h>
|
---|
221 | #include <iprt/lockvalidator.h>
|
---|
222 | #include <iprt/param.h>
|
---|
223 | #include <iprt/path.h>
|
---|
224 | #include <iprt/string.h>
|
---|
225 | #include <iprt/stream.h>
|
---|
226 |
|
---|
227 |
|
---|
228 | /*******************************************************************************
|
---|
229 | * Structures and Typedefs *
|
---|
230 | *******************************************************************************/
|
---|
231 | /**
|
---|
232 | * Parameter descriptor.
|
---|
233 | */
|
---|
234 | typedef struct REMPARMDESC
|
---|
235 | {
|
---|
236 | /** Parameter flags (REMPARMDESC_FLAGS_*). */
|
---|
237 | uint8_t fFlags;
|
---|
238 | /** The parameter size if REMPARMDESC_FLAGS_SIZE is set. */
|
---|
239 | uint8_t cb;
|
---|
240 | /** Pointer to additional data.
|
---|
241 | * For REMPARMDESC_FLAGS_PFN this is a PREMFNDESC. */
|
---|
242 | void *pvExtra;
|
---|
243 |
|
---|
244 | } REMPARMDESC, *PREMPARMDESC;
|
---|
245 | /** Pointer to a constant parameter descriptor. */
|
---|
246 | typedef const REMPARMDESC *PCREMPARMDESC;
|
---|
247 |
|
---|
248 | /** @name Parameter descriptor flags.
|
---|
249 | * @{ */
|
---|
250 | /** The parameter type is a kind of integer which could fit in a register. This includes pointers. */
|
---|
251 | #define REMPARMDESC_FLAGS_INT 0
|
---|
252 | /** The parameter is a GC pointer. */
|
---|
253 | #define REMPARMDESC_FLAGS_GCPTR 1
|
---|
254 | /** The parameter is a GC physical address. */
|
---|
255 | #define REMPARMDESC_FLAGS_GCPHYS 2
|
---|
256 | /** The parameter is a HC physical address. */
|
---|
257 | #define REMPARMDESC_FLAGS_HCPHYS 3
|
---|
258 | /** The parameter type is a kind of floating point. */
|
---|
259 | #define REMPARMDESC_FLAGS_FLOAT 4
|
---|
260 | /** The parameter value is a struct. This type takes a size. */
|
---|
261 | #define REMPARMDESC_FLAGS_STRUCT 5
|
---|
262 | /** The parameter is an elipsis. */
|
---|
263 | #define REMPARMDESC_FLAGS_ELLIPSIS 6
|
---|
264 | /** The parameter is a va_list. */
|
---|
265 | #define REMPARMDESC_FLAGS_VALIST 7
|
---|
266 | /** The parameter is a function pointer. pvExtra is a PREMFNDESC. */
|
---|
267 | #define REMPARMDESC_FLAGS_PFN 8
|
---|
268 | /** The parameter type mask. */
|
---|
269 | #define REMPARMDESC_FLAGS_TYPE_MASK 15
|
---|
270 | /** The parameter size field is valid. */
|
---|
271 | #define REMPARMDESC_FLAGS_SIZE RT_BIT(7)
|
---|
272 | /** @} */
|
---|
273 |
|
---|
274 | /**
|
---|
275 | * Function descriptor.
|
---|
276 | */
|
---|
277 | typedef struct REMFNDESC
|
---|
278 | {
|
---|
279 | /** The function name. */
|
---|
280 | const char *pszName;
|
---|
281 | /** Exports: Pointer to the function pointer.
|
---|
282 | * Imports: Pointer to the function. */
|
---|
283 | void *pv;
|
---|
284 | /** Array of parameter descriptors. */
|
---|
285 | PCREMPARMDESC paParams;
|
---|
286 | /** The number of parameter descriptors pointed to by paParams. */
|
---|
287 | uint8_t cParams;
|
---|
288 | /** Function flags (REMFNDESC_FLAGS_*). */
|
---|
289 | uint8_t fFlags;
|
---|
290 | /** The size of the return value. */
|
---|
291 | uint8_t cbReturn;
|
---|
292 | /** Pointer to the wrapper code for imports. */
|
---|
293 | void *pvWrapper;
|
---|
294 | } REMFNDESC, *PREMFNDESC;
|
---|
295 | /** Pointer to a constant function descriptor. */
|
---|
296 | typedef const REMFNDESC *PCREMFNDESC;
|
---|
297 |
|
---|
298 | /** @name Function descriptor flags.
|
---|
299 | * @{ */
|
---|
300 | /** The return type is void. */
|
---|
301 | #define REMFNDESC_FLAGS_RET_VOID 0
|
---|
302 | /** The return type is a kind of integer passed in rax/eax. This includes pointers. */
|
---|
303 | #define REMFNDESC_FLAGS_RET_INT 1
|
---|
304 | /** The return type is a kind of floating point. */
|
---|
305 | #define REMFNDESC_FLAGS_RET_FLOAT 2
|
---|
306 | /** The return value is a struct. This type take a size. */
|
---|
307 | #define REMFNDESC_FLAGS_RET_STRUCT 3
|
---|
308 | /** The return type mask. */
|
---|
309 | #define REMFNDESC_FLAGS_RET_TYPE_MASK 7
|
---|
310 | /** The argument list contains one or more va_list arguments (i.e. problems). */
|
---|
311 | #define REMFNDESC_FLAGS_VALIST RT_BIT(6)
|
---|
312 | /** The function has an ellipsis (i.e. a problem). */
|
---|
313 | #define REMFNDESC_FLAGS_ELLIPSIS RT_BIT(7)
|
---|
314 | /** @} */
|
---|
315 |
|
---|
316 | /**
|
---|
317 | * Chunk of read-write-executable memory.
|
---|
318 | */
|
---|
319 | typedef struct REMEXECMEM
|
---|
320 | {
|
---|
321 | /** The number of bytes left. */
|
---|
322 | struct REMEXECMEM *pNext;
|
---|
323 | /** The size of this chunk. */
|
---|
324 | uint32_t cb;
|
---|
325 | /** The offset of the next code block. */
|
---|
326 | uint32_t off;
|
---|
327 | #if ARCH_BITS == 32
|
---|
328 | uint32_t padding;
|
---|
329 | #endif
|
---|
330 | } REMEXECMEM, *PREMEXECMEM;
|
---|
331 |
|
---|
332 |
|
---|
333 | /*******************************************************************************
|
---|
334 | * Global Variables *
|
---|
335 | *******************************************************************************/
|
---|
336 | #ifndef USE_REM_STUBS
|
---|
337 | /** Loader handle of the REM object/DLL. */
|
---|
338 | static RTLDRMOD g_ModREM2 = NIL_RTLDRMOD;
|
---|
339 | /** Pointer to the memory containing the loaded REM2 object/DLL. */
|
---|
340 | static void *g_pvREM2 = NULL;
|
---|
341 | /** The size of the memory g_pvREM2 is pointing to. */
|
---|
342 | static size_t g_cbREM2 = 0;
|
---|
343 | # ifdef VBOX_WITHOUT_REM_LDR_CYCLE
|
---|
344 | /** Loader handle of the VBoxVMM DLL. */
|
---|
345 | static RTLDRMOD g_ModVMM = NIL_RTLDRMOD;
|
---|
346 | # endif
|
---|
347 |
|
---|
348 | /** Linux object export addresses.
|
---|
349 | * These are references from the assembly wrapper code.
|
---|
350 | * @{ */
|
---|
351 | static DECLCALLBACKPTR(int, pfnREMR3Init)(PVM);
|
---|
352 | static DECLCALLBACKPTR(int, pfnREMR3InitFinalize)(PVM);
|
---|
353 | static DECLCALLBACKPTR(int, pfnREMR3Term)(PVM);
|
---|
354 | static DECLCALLBACKPTR(void, pfnREMR3Reset)(PVM);
|
---|
355 | static DECLCALLBACKPTR(int, pfnREMR3Step)(PVM, PVMCPU);
|
---|
356 | static DECLCALLBACKPTR(int, pfnREMR3BreakpointSet)(PVM, RTGCUINTPTR);
|
---|
357 | static DECLCALLBACKPTR(int, pfnREMR3BreakpointClear)(PVM, RTGCUINTPTR);
|
---|
358 | static DECLCALLBACKPTR(int, pfnREMR3EmulateInstruction)(PVM, PVMCPU);
|
---|
359 | static DECLCALLBACKPTR(int, pfnREMR3Run)(PVM, PVMCPU);
|
---|
360 | static DECLCALLBACKPTR(int, pfnREMR3State)(PVM, PVMCPU);
|
---|
361 | static DECLCALLBACKPTR(int, pfnREMR3StateBack)(PVM, PVMCPU);
|
---|
362 | static DECLCALLBACKPTR(void, pfnREMR3StateUpdate)(PVM, PVMCPU);
|
---|
363 | static DECLCALLBACKPTR(void, pfnREMR3A20Set)(PVM, PVMCPU, bool);
|
---|
364 | static DECLCALLBACKPTR(void, pfnREMR3ReplayHandlerNotifications)(PVM pVM);
|
---|
365 | static DECLCALLBACKPTR(void, pfnREMR3NotifyPhysRamRegister)(PVM, RTGCPHYS, RTGCPHYS, unsigned);
|
---|
366 | static DECLCALLBACKPTR(void, pfnREMR3NotifyPhysRamDeregister)(PVM, RTGCPHYS, RTUINT);
|
---|
367 | static DECLCALLBACKPTR(void, pfnREMR3NotifyPhysRomRegister)(PVM, RTGCPHYS, RTUINT, void *, bool);
|
---|
368 | static DECLCALLBACKPTR(void, pfnREMR3NotifyHandlerPhysicalModify)(PVM, PGMPHYSHANDLERTYPE, RTGCPHYS, RTGCPHYS, RTGCPHYS, bool, bool);
|
---|
369 | static DECLCALLBACKPTR(void, pfnREMR3NotifyHandlerPhysicalRegister)(PVM, PGMPHYSHANDLERTYPE, RTGCPHYS, RTGCPHYS, bool);
|
---|
370 | static DECLCALLBACKPTR(void, pfnREMR3NotifyHandlerPhysicalDeregister)(PVM, PGMPHYSHANDLERTYPE, RTGCPHYS, RTGCPHYS, bool, bool);
|
---|
371 | static DECLCALLBACKPTR(void, pfnREMR3NotifyInterruptSet)(PVM, PVMCPU);
|
---|
372 | static DECLCALLBACKPTR(void, pfnREMR3NotifyInterruptClear)(PVM, PVMCPU);
|
---|
373 | static DECLCALLBACKPTR(void, pfnREMR3NotifyTimerPending)(PVM, PVMCPU);
|
---|
374 | static DECLCALLBACKPTR(void, pfnREMR3NotifyDmaPending)(PVM);
|
---|
375 | static DECLCALLBACKPTR(void, pfnREMR3NotifyQueuePending)(PVM);
|
---|
376 | static DECLCALLBACKPTR(void, pfnREMR3NotifyFF)(PVM);
|
---|
377 | static DECLCALLBACKPTR(int, pfnREMR3NotifyCodePageChanged)(PVM, PVMCPU, RTGCPTR);
|
---|
378 | static DECLCALLBACKPTR(void, pfnREMR3NotifyPendingInterrupt)(PVM, PVMCPU, uint8_t);
|
---|
379 | static DECLCALLBACKPTR(uint32_t, pfnREMR3QueryPendingInterrupt)(PVM, PVMCPU);
|
---|
380 | static DECLCALLBACKPTR(int, pfnREMR3DisasEnableStepping)(PVM, bool);
|
---|
381 | static DECLCALLBACKPTR(bool, pfnREMR3IsPageAccessHandled)(PVM, RTGCPHYS);
|
---|
382 | /** @} */
|
---|
383 |
|
---|
384 | /** Export and import parameter descriptors.
|
---|
385 | * @{
|
---|
386 | */
|
---|
387 | /* Common args. */
|
---|
388 | static const REMPARMDESC g_aArgsSIZE_T[] =
|
---|
389 | {
|
---|
390 | { REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL }
|
---|
391 | };
|
---|
392 | static const REMPARMDESC g_aArgsPTR[] =
|
---|
393 | {
|
---|
394 | { REMPARMDESC_FLAGS_INT, sizeof(void *), NULL }
|
---|
395 | };
|
---|
396 | static const REMPARMDESC g_aArgsSIZE_TTag[] =
|
---|
397 | {
|
---|
398 | { REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL },
|
---|
399 | { REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL }
|
---|
400 | };
|
---|
401 | static const REMPARMDESC g_aArgsPTRTag[] =
|
---|
402 | {
|
---|
403 | { REMPARMDESC_FLAGS_INT, sizeof(void *), NULL },
|
---|
404 | { REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL }
|
---|
405 | };
|
---|
406 | static const REMPARMDESC g_aArgsPTR_SIZE_T[] =
|
---|
407 | {
|
---|
408 | { REMPARMDESC_FLAGS_INT, sizeof(void *), NULL },
|
---|
409 | { REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL }
|
---|
410 | };
|
---|
411 | static const REMPARMDESC g_aArgsVM[] =
|
---|
412 | {
|
---|
413 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL }
|
---|
414 | };
|
---|
415 | static const REMPARMDESC g_aArgsVMCPU[] =
|
---|
416 | {
|
---|
417 | { REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL }
|
---|
418 | };
|
---|
419 |
|
---|
420 | static const REMPARMDESC g_aArgsVMandVMCPU[] =
|
---|
421 | {
|
---|
422 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
423 | { REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL }
|
---|
424 | };
|
---|
425 |
|
---|
426 | /* REM args */
|
---|
427 | static const REMPARMDESC g_aArgsBreakpoint[] =
|
---|
428 | {
|
---|
429 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
430 | { REMPARMDESC_FLAGS_GCPTR, sizeof(RTGCUINTPTR), NULL }
|
---|
431 | };
|
---|
432 | static const REMPARMDESC g_aArgsA20Set[] =
|
---|
433 | {
|
---|
434 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
435 | { REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
|
---|
436 | { REMPARMDESC_FLAGS_INT, sizeof(bool), NULL }
|
---|
437 | };
|
---|
438 | static const REMPARMDESC g_aArgsNotifyPhysRamRegister[] =
|
---|
439 | {
|
---|
440 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
441 | { REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
|
---|
442 | { REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
|
---|
443 | { REMPARMDESC_FLAGS_INT, sizeof(void *), NULL },
|
---|
444 | { REMPARMDESC_FLAGS_INT, sizeof(unsigned), NULL }
|
---|
445 | };
|
---|
446 | static const REMPARMDESC g_aArgsNotifyPhysRamChunkRegister[] =
|
---|
447 | {
|
---|
448 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
449 | { REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
|
---|
450 | { REMPARMDESC_FLAGS_INT, sizeof(RTUINT), NULL },
|
---|
451 | { REMPARMDESC_FLAGS_INT, sizeof(RTHCUINTPTR), NULL },
|
---|
452 | { REMPARMDESC_FLAGS_INT, sizeof(unsigned), NULL }
|
---|
453 | };
|
---|
454 | static const REMPARMDESC g_aArgsNotifyPhysRamDeregister[] =
|
---|
455 | {
|
---|
456 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
457 | { REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
|
---|
458 | { REMPARMDESC_FLAGS_INT, sizeof(RTUINT), NULL }
|
---|
459 | };
|
---|
460 | static const REMPARMDESC g_aArgsNotifyPhysRomRegister[] =
|
---|
461 | {
|
---|
462 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
463 | { REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
|
---|
464 | { REMPARMDESC_FLAGS_INT, sizeof(RTUINT), NULL },
|
---|
465 | { REMPARMDESC_FLAGS_INT, sizeof(void *), NULL },
|
---|
466 | { REMPARMDESC_FLAGS_INT, sizeof(bool), NULL }
|
---|
467 | };
|
---|
468 | static const REMPARMDESC g_aArgsNotifyHandlerPhysicalModify[] =
|
---|
469 | {
|
---|
470 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
471 | { REMPARMDESC_FLAGS_INT, sizeof(PGMPHYSHANDLERTYPE), NULL },
|
---|
472 | { REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
|
---|
473 | { REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
|
---|
474 | { REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
|
---|
475 | { REMPARMDESC_FLAGS_INT, sizeof(bool), NULL },
|
---|
476 | { REMPARMDESC_FLAGS_INT, sizeof(bool), NULL }
|
---|
477 | };
|
---|
478 | static const REMPARMDESC g_aArgsNotifyHandlerPhysicalRegister[] =
|
---|
479 | {
|
---|
480 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
481 | { REMPARMDESC_FLAGS_INT, sizeof(PGMPHYSHANDLERTYPE), NULL },
|
---|
482 | { REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
|
---|
483 | { REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
|
---|
484 | { REMPARMDESC_FLAGS_INT, sizeof(bool), NULL }
|
---|
485 | };
|
---|
486 | static const REMPARMDESC g_aArgsNotifyHandlerPhysicalDeregister[] =
|
---|
487 | {
|
---|
488 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
489 | { REMPARMDESC_FLAGS_INT, sizeof(PGMPHYSHANDLERTYPE), NULL },
|
---|
490 | { REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
|
---|
491 | { REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
|
---|
492 | { REMPARMDESC_FLAGS_INT, sizeof(bool), NULL },
|
---|
493 | { REMPARMDESC_FLAGS_INT, sizeof(bool), NULL }
|
---|
494 | };
|
---|
495 | static const REMPARMDESC g_aArgsNotifyCodePageChanged[] =
|
---|
496 | {
|
---|
497 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
498 | { REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
|
---|
499 | { REMPARMDESC_FLAGS_GCPTR, sizeof(RTGCUINTPTR), NULL }
|
---|
500 | };
|
---|
501 | static const REMPARMDESC g_aArgsNotifyPendingInterrupt[] =
|
---|
502 | {
|
---|
503 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
504 | { REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
|
---|
505 | { REMPARMDESC_FLAGS_INT, sizeof(uint8_t), NULL }
|
---|
506 | };
|
---|
507 | static const REMPARMDESC g_aArgsDisasEnableStepping[] =
|
---|
508 | {
|
---|
509 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
510 | { REMPARMDESC_FLAGS_INT, sizeof(bool), NULL }
|
---|
511 | };
|
---|
512 | static const REMPARMDESC g_aArgsIsPageAccessHandled[] =
|
---|
513 | {
|
---|
514 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
515 | { REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL }
|
---|
516 | };
|
---|
517 |
|
---|
518 | # ifndef VBOX_USE_BITNESS_SELECTOR
|
---|
519 |
|
---|
520 | /* VMM args */
|
---|
521 | static const REMPARMDESC g_aArgsCPUMGetGuestCpl[] =
|
---|
522 | {
|
---|
523 | { REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
|
---|
524 | { REMPARMDESC_FLAGS_INT, sizeof(PCPUMCTXCORE), NULL },
|
---|
525 | };
|
---|
526 |
|
---|
527 | /* EMInterpretInstructionCPU args */
|
---|
528 | static const REMPARMDESC g_aArgsEMInterpretInstructionCPU[] =
|
---|
529 | {
|
---|
530 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
531 | { REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
|
---|
532 | { REMPARMDESC_FLAGS_INT, sizeof(PDISCPUSTATE), NULL },
|
---|
533 | { REMPARMDESC_FLAGS_INT, sizeof(PCPUMCTXCORE), NULL },
|
---|
534 | { REMPARMDESC_FLAGS_GCPTR, sizeof(RTGCPTR), NULL },
|
---|
535 | { REMPARMDESC_FLAGS_INT, sizeof(EMCODETYPE), NULL },
|
---|
536 | { REMPARMDESC_FLAGS_INT, sizeof(uint32_t *), NULL }
|
---|
537 | };
|
---|
538 |
|
---|
539 | /* CPUMQueryGuestMsr args */
|
---|
540 | static const REMPARMDESC g_aArgsCPUMQueryGuestMsr[] =
|
---|
541 | {
|
---|
542 | { REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
|
---|
543 | { REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
|
---|
544 | { REMPARMDESC_FLAGS_INT, sizeof(uint64_t *), NULL },
|
---|
545 | };
|
---|
546 |
|
---|
547 | /* CPUMSetGuestMsr args */
|
---|
548 | static const REMPARMDESC g_aArgsCPUMSetGuestMsr[] =
|
---|
549 | {
|
---|
550 | { REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
|
---|
551 | { REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
|
---|
552 | { REMPARMDESC_FLAGS_INT, sizeof(uint64_t), NULL },
|
---|
553 | };
|
---|
554 |
|
---|
555 | static const REMPARMDESC g_aArgsCPUMGetGuestCpuId[] =
|
---|
556 | {
|
---|
557 | { REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
|
---|
558 | { REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
|
---|
559 | { REMPARMDESC_FLAGS_INT, sizeof(uint32_t *), NULL },
|
---|
560 | { REMPARMDESC_FLAGS_INT, sizeof(uint32_t *), NULL },
|
---|
561 | { REMPARMDESC_FLAGS_INT, sizeof(uint32_t *), NULL },
|
---|
562 | { REMPARMDESC_FLAGS_INT, sizeof(uint32_t *), NULL }
|
---|
563 | };
|
---|
564 |
|
---|
565 | static const REMPARMDESC g_aArgsCPUMR3RemEnter[] =
|
---|
566 | {
|
---|
567 | { REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
|
---|
568 | { REMPARMDESC_FLAGS_INT, sizeof(uint32_t *), NULL }
|
---|
569 | };
|
---|
570 |
|
---|
571 | static const REMPARMDESC g_aArgsCPUMR3RemLeave[] =
|
---|
572 | {
|
---|
573 | { REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
|
---|
574 | { REMPARMDESC_FLAGS_INT, sizeof(bool), NULL }
|
---|
575 | };
|
---|
576 |
|
---|
577 | static const REMPARMDESC g_aArgsCPUMSetChangedFlags[] =
|
---|
578 | {
|
---|
579 | { REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
|
---|
580 | { REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL }
|
---|
581 | };
|
---|
582 |
|
---|
583 | static const REMPARMDESC g_aArgsCPUMQueryGuestCtxPtr[] =
|
---|
584 | {
|
---|
585 | { REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL }
|
---|
586 | };
|
---|
587 | static const REMPARMDESC g_aArgsCSAMR3MonitorPage[] =
|
---|
588 | {
|
---|
589 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
590 | { REMPARMDESC_FLAGS_INT, sizeof(RTRCPTR), NULL },
|
---|
591 | { REMPARMDESC_FLAGS_INT, sizeof(CSAMTAG), NULL }
|
---|
592 | };
|
---|
593 | static const REMPARMDESC g_aArgsCSAMR3UnmonitorPage[] =
|
---|
594 | {
|
---|
595 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
596 | { REMPARMDESC_FLAGS_INT, sizeof(RTRCPTR), NULL },
|
---|
597 | { REMPARMDESC_FLAGS_INT, sizeof(CSAMTAG), NULL }
|
---|
598 | };
|
---|
599 |
|
---|
600 | static const REMPARMDESC g_aArgsCSAMR3RecordCallAddress[] =
|
---|
601 | {
|
---|
602 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
603 | { REMPARMDESC_FLAGS_INT, sizeof(RTRCPTR), NULL }
|
---|
604 | };
|
---|
605 |
|
---|
606 | # if defined(VBOX_WITH_DEBUGGER) && !(defined(RT_OS_WINDOWS) && defined(RT_ARCH_AMD64)) /* the callbacks are problematic */
|
---|
607 | static const REMPARMDESC g_aArgsDBGCRegisterCommands[] =
|
---|
608 | {
|
---|
609 | { REMPARMDESC_FLAGS_INT, sizeof(PCDBGCCMD), NULL },
|
---|
610 | { REMPARMDESC_FLAGS_INT, sizeof(unsigned), NULL }
|
---|
611 | };
|
---|
612 | # endif
|
---|
613 | static const REMPARMDESC g_aArgsDBGFR3DisasInstrEx[] =
|
---|
614 | {
|
---|
615 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
616 | { REMPARMDESC_FLAGS_INT, sizeof(VMCPUID), NULL },
|
---|
617 | { REMPARMDESC_FLAGS_INT, sizeof(RTSEL), NULL },
|
---|
618 | { REMPARMDESC_FLAGS_INT, sizeof(RTGCPTR), NULL },
|
---|
619 | { REMPARMDESC_FLAGS_INT, sizeof(unsigned), NULL },
|
---|
620 | { REMPARMDESC_FLAGS_INT, sizeof(char *), NULL },
|
---|
621 | { REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
|
---|
622 | { REMPARMDESC_FLAGS_INT, sizeof(uint32_t *), NULL }
|
---|
623 | };
|
---|
624 | static const REMPARMDESC g_aArgsDBGFR3DisasInstrCurrentLogInternal[] =
|
---|
625 | {
|
---|
626 | { REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
|
---|
627 | { REMPARMDESC_FLAGS_INT, sizeof(char *), NULL }
|
---|
628 | };
|
---|
629 | static const REMPARMDESC g_aArgsDBGFR3Info[] =
|
---|
630 | {
|
---|
631 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
632 | { REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
|
---|
633 | { REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
|
---|
634 | { REMPARMDESC_FLAGS_INT, sizeof(PCDBGFINFOHLP), NULL }
|
---|
635 | };
|
---|
636 | static const REMPARMDESC g_aArgsDBGFR3AsSymbolByAddr[] =
|
---|
637 | {
|
---|
638 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
639 | { REMPARMDESC_FLAGS_INT, sizeof(RTDBGAS), NULL },
|
---|
640 | { REMPARMDESC_FLAGS_INT, sizeof(PCDBGFADDRESS), NULL },
|
---|
641 | { REMPARMDESC_FLAGS_GCPTR, sizeof(PRTGCINTPTR), NULL },
|
---|
642 | { REMPARMDESC_FLAGS_INT, sizeof(PRTDBGSYMBOL), NULL },
|
---|
643 | { REMPARMDESC_FLAGS_INT, sizeof(PRTDBGMOD), NULL }
|
---|
644 | };
|
---|
645 | static const REMPARMDESC g_aArgsDBGFR3AddrFromFlat[] =
|
---|
646 | {
|
---|
647 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
648 | { REMPARMDESC_FLAGS_INT, sizeof(PDBGFADDRESS), NULL },
|
---|
649 | { REMPARMDESC_FLAGS_INT, sizeof(RTGCUINTPTR), NULL }
|
---|
650 | };
|
---|
651 | static const REMPARMDESC g_aArgsDISInstr[] =
|
---|
652 | {
|
---|
653 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
654 | { REMPARMDESC_FLAGS_INT, sizeof(RTUINTPTR), NULL },
|
---|
655 | { REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
|
---|
656 | { REMPARMDESC_FLAGS_INT, sizeof(uint32_t *), NULL },
|
---|
657 | { REMPARMDESC_FLAGS_INT, sizeof(char *), NULL }
|
---|
658 | };
|
---|
659 | static const REMPARMDESC g_aArgsEMR3FatalError[] =
|
---|
660 | {
|
---|
661 | { REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
|
---|
662 | { REMPARMDESC_FLAGS_INT, sizeof(int), NULL }
|
---|
663 | };
|
---|
664 | static const REMPARMDESC g_aArgsHWACCMR3CanExecuteGuest[] =
|
---|
665 | {
|
---|
666 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
667 | { REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
|
---|
668 | { REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
|
---|
669 | { REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL }
|
---|
670 | };
|
---|
671 | static const REMPARMDESC g_aArgsIOMIOPortRead[] =
|
---|
672 | {
|
---|
673 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
674 | { REMPARMDESC_FLAGS_INT, sizeof(RTIOPORT), NULL },
|
---|
675 | { REMPARMDESC_FLAGS_INT, sizeof(uint32_t *), NULL },
|
---|
676 | { REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL }
|
---|
677 | };
|
---|
678 | static const REMPARMDESC g_aArgsIOMIOPortWrite[] =
|
---|
679 | {
|
---|
680 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
681 | { REMPARMDESC_FLAGS_INT, sizeof(RTIOPORT), NULL },
|
---|
682 | { REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
|
---|
683 | { REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL }
|
---|
684 | };
|
---|
685 | static const REMPARMDESC g_aArgsIOMMMIORead[] =
|
---|
686 | {
|
---|
687 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
688 | { REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
|
---|
689 | { REMPARMDESC_FLAGS_INT, sizeof(uint32_t *), NULL },
|
---|
690 | { REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL }
|
---|
691 | };
|
---|
692 | static const REMPARMDESC g_aArgsIOMMMIOWrite[] =
|
---|
693 | {
|
---|
694 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
695 | { REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
|
---|
696 | { REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
|
---|
697 | { REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL }
|
---|
698 | };
|
---|
699 | static const REMPARMDESC g_aArgsMMR3HeapAlloc[] =
|
---|
700 | {
|
---|
701 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
702 | { REMPARMDESC_FLAGS_INT, sizeof(MMTAG), NULL },
|
---|
703 | { REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL }
|
---|
704 | };
|
---|
705 | static const REMPARMDESC g_aArgsMMR3HeapAllocZ[] =
|
---|
706 | {
|
---|
707 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
708 | { REMPARMDESC_FLAGS_INT, sizeof(MMTAG), NULL },
|
---|
709 | { REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL }
|
---|
710 | };
|
---|
711 | static const REMPARMDESC g_aArgsPATMIsPatchGCAddr[] =
|
---|
712 | {
|
---|
713 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
714 | { REMPARMDESC_FLAGS_INT, sizeof(RTRCUINTPTR), NULL }
|
---|
715 | };
|
---|
716 | static const REMPARMDESC g_aArgsPATMR3QueryOpcode[] =
|
---|
717 | {
|
---|
718 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
719 | { REMPARMDESC_FLAGS_INT, sizeof(RTRCPTR), NULL },
|
---|
720 | { REMPARMDESC_FLAGS_INT, sizeof(uint8_t *), NULL }
|
---|
721 | };
|
---|
722 | static const REMPARMDESC g_aArgsPATMR3QueryPatchMem[] =
|
---|
723 | {
|
---|
724 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
725 | { REMPARMDESC_FLAGS_INT, sizeof(uint32_t *), NULL }
|
---|
726 | };
|
---|
727 | static const REMPARMDESC g_aArgsPDMApicGetBase[] =
|
---|
728 | {
|
---|
729 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
730 | { REMPARMDESC_FLAGS_INT, sizeof(uint64_t *), NULL }
|
---|
731 | };
|
---|
732 | static const REMPARMDESC g_aArgsPDMApicGetTPR[] =
|
---|
733 | {
|
---|
734 | { REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
|
---|
735 | { REMPARMDESC_FLAGS_INT, sizeof(uint8_t *), NULL },
|
---|
736 | { REMPARMDESC_FLAGS_INT, sizeof(uint8_t *), NULL }
|
---|
737 | };
|
---|
738 | static const REMPARMDESC g_aArgsPDMApicSetBase[] =
|
---|
739 | {
|
---|
740 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
741 | { REMPARMDESC_FLAGS_INT, sizeof(uint64_t), NULL }
|
---|
742 | };
|
---|
743 | static const REMPARMDESC g_aArgsPDMApicSetTPR[] =
|
---|
744 | {
|
---|
745 | { REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
|
---|
746 | { REMPARMDESC_FLAGS_INT, sizeof(uint8_t), NULL }
|
---|
747 | };
|
---|
748 | static const REMPARMDESC g_aArgsPDMGetInterrupt[] =
|
---|
749 | {
|
---|
750 | { REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
|
---|
751 | { REMPARMDESC_FLAGS_INT, sizeof(uint8_t *), NULL }
|
---|
752 | };
|
---|
753 | static const REMPARMDESC g_aArgsPDMIsaSetIrq[] =
|
---|
754 | {
|
---|
755 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
756 | { REMPARMDESC_FLAGS_INT, sizeof(uint8_t), NULL },
|
---|
757 | { REMPARMDESC_FLAGS_INT, sizeof(uint8_t), NULL }
|
---|
758 | };
|
---|
759 | static const REMPARMDESC g_aArgsPDMR3CritSectInit[] =
|
---|
760 | {
|
---|
761 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
762 | { REMPARMDESC_FLAGS_INT, sizeof(PPDMCRITSECT), NULL },
|
---|
763 | /* RT_SRC_POS_DECL */
|
---|
764 | { REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
|
---|
765 | { REMPARMDESC_FLAGS_INT, sizeof(unsigned int), NULL },
|
---|
766 | { REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
|
---|
767 | { REMPARMDESC_FLAGS_INT, sizeof(char *), NULL },
|
---|
768 | { REMPARMDESC_FLAGS_ELLIPSIS, 0 }
|
---|
769 | };
|
---|
770 | static const REMPARMDESC g_aArgsPDMCritSectEnter[] =
|
---|
771 | {
|
---|
772 | { REMPARMDESC_FLAGS_INT, sizeof(PPDMCRITSECT), NULL },
|
---|
773 | { REMPARMDESC_FLAGS_INT, sizeof(int), NULL }
|
---|
774 | };
|
---|
775 | static const REMPARMDESC g_aArgsPDMCritSectEnterDebug[] =
|
---|
776 | {
|
---|
777 | { REMPARMDESC_FLAGS_INT, sizeof(PPDMCRITSECT), NULL },
|
---|
778 | { REMPARMDESC_FLAGS_INT, sizeof(int), NULL },
|
---|
779 | { REMPARMDESC_FLAGS_INT, sizeof(RTHCUINTPTR), NULL },
|
---|
780 | /* RT_SRC_POS_DECL */
|
---|
781 | { REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
|
---|
782 | { REMPARMDESC_FLAGS_INT, sizeof(unsigned), NULL },
|
---|
783 | { REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL }
|
---|
784 | };
|
---|
785 | static const REMPARMDESC g_aArgsPGMGetGuestMode[] =
|
---|
786 | {
|
---|
787 | { REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
|
---|
788 | };
|
---|
789 | static const REMPARMDESC g_aArgsPGMGstGetPage[] =
|
---|
790 | {
|
---|
791 | { REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
|
---|
792 | { REMPARMDESC_FLAGS_GCPTR, sizeof(RTGCPTR), NULL },
|
---|
793 | { REMPARMDESC_FLAGS_INT, sizeof(uint64_t *), NULL },
|
---|
794 | { REMPARMDESC_FLAGS_INT, sizeof(PRTGCPHYS), NULL }
|
---|
795 | };
|
---|
796 | static const REMPARMDESC g_aArgsPGMInvalidatePage[] =
|
---|
797 | {
|
---|
798 | { REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
|
---|
799 | { REMPARMDESC_FLAGS_GCPTR, sizeof(RTGCPTR), NULL }
|
---|
800 | };
|
---|
801 | static const REMPARMDESC g_aArgsPGMR3PhysTlbGCPhys2Ptr[] =
|
---|
802 | {
|
---|
803 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
804 | { REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
|
---|
805 | { REMPARMDESC_FLAGS_INT, sizeof(bool), NULL },
|
---|
806 | { REMPARMDESC_FLAGS_INT, sizeof(void *), NULL }
|
---|
807 | };
|
---|
808 | static const REMPARMDESC g_aArgsPGM3PhysGrowRange[] =
|
---|
809 | {
|
---|
810 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
811 | { REMPARMDESC_FLAGS_INT, sizeof(PCRTGCPHYS), NULL }
|
---|
812 | };
|
---|
813 | static const REMPARMDESC g_aArgsPGMPhysIsGCPhysValid[] =
|
---|
814 | {
|
---|
815 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
816 | { REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL }
|
---|
817 | };
|
---|
818 | static const REMPARMDESC g_aArgsPGMPhysRead[] =
|
---|
819 | {
|
---|
820 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
821 | { REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
|
---|
822 | { REMPARMDESC_FLAGS_INT, sizeof(void *), NULL },
|
---|
823 | { REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL }
|
---|
824 | };
|
---|
825 | static const REMPARMDESC g_aArgsPGMPhysSimpleReadGCPtr[] =
|
---|
826 | {
|
---|
827 | { REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
|
---|
828 | { REMPARMDESC_FLAGS_INT, sizeof(void *), NULL },
|
---|
829 | { REMPARMDESC_FLAGS_GCPTR, sizeof(RTGCPTR), NULL },
|
---|
830 | { REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL }
|
---|
831 | };
|
---|
832 | static const REMPARMDESC g_aArgsPGMPhysWrite[] =
|
---|
833 | {
|
---|
834 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
835 | { REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
|
---|
836 | { REMPARMDESC_FLAGS_INT, sizeof(const void *), NULL },
|
---|
837 | { REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL }
|
---|
838 | };
|
---|
839 | static const REMPARMDESC g_aArgsPGMChangeMode[] =
|
---|
840 | {
|
---|
841 | { REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
|
---|
842 | { REMPARMDESC_FLAGS_INT, sizeof(uint64_t), NULL },
|
---|
843 | { REMPARMDESC_FLAGS_INT, sizeof(uint64_t), NULL },
|
---|
844 | { REMPARMDESC_FLAGS_INT, sizeof(uint64_t), NULL }
|
---|
845 | };
|
---|
846 | static const REMPARMDESC g_aArgsPGMFlushTLB[] =
|
---|
847 | {
|
---|
848 | { REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
|
---|
849 | { REMPARMDESC_FLAGS_INT, sizeof(uint64_t), NULL },
|
---|
850 | { REMPARMDESC_FLAGS_INT, sizeof(bool), NULL }
|
---|
851 | };
|
---|
852 | static const REMPARMDESC g_aArgsPGMR3PhysReadUxx[] =
|
---|
853 | {
|
---|
854 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
855 | { REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL }
|
---|
856 | };
|
---|
857 | static const REMPARMDESC g_aArgsPGMR3PhysWriteU8[] =
|
---|
858 | {
|
---|
859 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
860 | { REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
|
---|
861 | { REMPARMDESC_FLAGS_INT, sizeof(uint8_t), NULL }
|
---|
862 | };
|
---|
863 | static const REMPARMDESC g_aArgsPGMR3PhysWriteU16[] =
|
---|
864 | {
|
---|
865 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
866 | { REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
|
---|
867 | { REMPARMDESC_FLAGS_INT, sizeof(uint16_t), NULL }
|
---|
868 | };
|
---|
869 | static const REMPARMDESC g_aArgsPGMR3PhysWriteU32[] =
|
---|
870 | {
|
---|
871 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
872 | { REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
|
---|
873 | { REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL }
|
---|
874 | };
|
---|
875 | static const REMPARMDESC g_aArgsPGMR3PhysWriteU64[] =
|
---|
876 | {
|
---|
877 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
878 | { REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
|
---|
879 | { REMPARMDESC_FLAGS_INT, sizeof(uint64_t), NULL }
|
---|
880 | };
|
---|
881 | static const REMPARMDESC g_aArgsRTMemReallocTag[] =
|
---|
882 | {
|
---|
883 | { REMPARMDESC_FLAGS_INT, sizeof(void*), NULL },
|
---|
884 | { REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL },
|
---|
885 | { REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL }
|
---|
886 | };
|
---|
887 | static const REMPARMDESC g_aArgsSSMR3GetGCPtr[] =
|
---|
888 | {
|
---|
889 | { REMPARMDESC_FLAGS_INT, sizeof(PSSMHANDLE), NULL },
|
---|
890 | { REMPARMDESC_FLAGS_INT, sizeof(PRTGCPTR), NULL }
|
---|
891 | };
|
---|
892 | static const REMPARMDESC g_aArgsSSMR3GetMem[] =
|
---|
893 | {
|
---|
894 | { REMPARMDESC_FLAGS_INT, sizeof(PSSMHANDLE), NULL },
|
---|
895 | { REMPARMDESC_FLAGS_INT, sizeof(void *), NULL },
|
---|
896 | { REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL }
|
---|
897 | };
|
---|
898 | static const REMPARMDESC g_aArgsSSMR3GetU32[] =
|
---|
899 | {
|
---|
900 | { REMPARMDESC_FLAGS_INT, sizeof(PSSMHANDLE), NULL },
|
---|
901 | { REMPARMDESC_FLAGS_INT, sizeof(uint32_t *), NULL }
|
---|
902 | };
|
---|
903 | static const REMPARMDESC g_aArgsSSMR3GetUInt[] =
|
---|
904 | {
|
---|
905 | { REMPARMDESC_FLAGS_INT, sizeof(PSSMHANDLE), NULL },
|
---|
906 | { REMPARMDESC_FLAGS_INT, sizeof(PRTUINT), NULL }
|
---|
907 | };
|
---|
908 | static const REMPARMDESC g_aArgsSSMR3PutGCPtr[] =
|
---|
909 | {
|
---|
910 | { REMPARMDESC_FLAGS_INT, sizeof(PSSMHANDLE), NULL },
|
---|
911 | { REMPARMDESC_FLAGS_GCPTR, sizeof(RTGCPTR), NULL }
|
---|
912 | };
|
---|
913 | static const REMPARMDESC g_aArgsSSMR3PutMem[] =
|
---|
914 | {
|
---|
915 | { REMPARMDESC_FLAGS_INT, sizeof(PSSMHANDLE), NULL },
|
---|
916 | { REMPARMDESC_FLAGS_INT, sizeof(const void *), NULL },
|
---|
917 | { REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL }
|
---|
918 | };
|
---|
919 | static const REMPARMDESC g_aArgsSSMR3PutU32[] =
|
---|
920 | {
|
---|
921 | { REMPARMDESC_FLAGS_INT, sizeof(PSSMHANDLE), NULL },
|
---|
922 | { REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
|
---|
923 | };
|
---|
924 | static const REMPARMDESC g_aArgsSSMR3PutUInt[] =
|
---|
925 | {
|
---|
926 | { REMPARMDESC_FLAGS_INT, sizeof(PSSMHANDLE), NULL },
|
---|
927 | { REMPARMDESC_FLAGS_INT, sizeof(RTUINT), NULL },
|
---|
928 | };
|
---|
929 |
|
---|
930 | static const REMPARMDESC g_aArgsSSMIntLiveExecCallback[] =
|
---|
931 | {
|
---|
932 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
933 | { REMPARMDESC_FLAGS_INT, sizeof(PSSMHANDLE), NULL },
|
---|
934 | { REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
|
---|
935 | };
|
---|
936 | static REMFNDESC g_SSMIntLiveExecCallback =
|
---|
937 | {
|
---|
938 | "SSMIntLiveExecCallback", NULL, &g_aArgsSSMIntLiveExecCallback[0], RT_ELEMENTS(g_aArgsSSMIntLiveExecCallback), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL
|
---|
939 | };
|
---|
940 |
|
---|
941 | static const REMPARMDESC g_aArgsSSMIntLiveVoteCallback[] =
|
---|
942 | {
|
---|
943 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
944 | { REMPARMDESC_FLAGS_INT, sizeof(PSSMHANDLE), NULL },
|
---|
945 | };
|
---|
946 | static REMFNDESC g_SSMIntLiveVoteCallback =
|
---|
947 | {
|
---|
948 | "SSMIntLiveVoteCallback", NULL, &g_aArgsSSMIntLiveVoteCallback[0], RT_ELEMENTS(g_aArgsSSMIntLiveVoteCallback), REMFNDESC_FLAGS_RET_INT, sizeof(bool), NULL
|
---|
949 | };
|
---|
950 |
|
---|
951 | static const REMPARMDESC g_aArgsSSMIntCallback[] =
|
---|
952 | {
|
---|
953 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
954 | { REMPARMDESC_FLAGS_INT, sizeof(PSSMHANDLE), NULL },
|
---|
955 | };
|
---|
956 | static REMFNDESC g_SSMIntCallback =
|
---|
957 | {
|
---|
958 | "SSMIntCallback", NULL, &g_aArgsSSMIntCallback[0], RT_ELEMENTS(g_aArgsSSMIntCallback), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL
|
---|
959 | };
|
---|
960 |
|
---|
961 | static const REMPARMDESC g_aArgsSSMIntLoadExecCallback[] =
|
---|
962 | {
|
---|
963 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
964 | { REMPARMDESC_FLAGS_INT, sizeof(PSSMHANDLE), NULL },
|
---|
965 | { REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
|
---|
966 | { REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
|
---|
967 | };
|
---|
968 | static REMFNDESC g_SSMIntLoadExecCallback =
|
---|
969 | {
|
---|
970 | "SSMIntLoadExecCallback", NULL, &g_aArgsSSMIntLoadExecCallback[0], RT_ELEMENTS(g_aArgsSSMIntLoadExecCallback), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL
|
---|
971 | };
|
---|
972 | /* Note: don't forget about the handwritten assembly wrapper when changing this! */
|
---|
973 | static const REMPARMDESC g_aArgsSSMR3RegisterInternal[] =
|
---|
974 | {
|
---|
975 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
976 | { REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
|
---|
977 | { REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
|
---|
978 | { REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
|
---|
979 | { REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL },
|
---|
980 | { REMPARMDESC_FLAGS_PFN, sizeof(PFNSSMINTLIVEPREP), &g_SSMIntCallback },
|
---|
981 | { REMPARMDESC_FLAGS_PFN, sizeof(PFNSSMINTLIVEEXEC), &g_SSMIntLiveExecCallback },
|
---|
982 | { REMPARMDESC_FLAGS_PFN, sizeof(PFNSSMINTLIVEVOTE), &g_SSMIntLiveVoteCallback },
|
---|
983 | { REMPARMDESC_FLAGS_PFN, sizeof(PFNSSMINTSAVEPREP), &g_SSMIntCallback },
|
---|
984 | { REMPARMDESC_FLAGS_PFN, sizeof(PFNSSMINTSAVEEXEC), &g_SSMIntCallback },
|
---|
985 | { REMPARMDESC_FLAGS_PFN, sizeof(PFNSSMINTSAVEDONE), &g_SSMIntCallback },
|
---|
986 | { REMPARMDESC_FLAGS_PFN, sizeof(PFNSSMINTLOADPREP), &g_SSMIntCallback },
|
---|
987 | { REMPARMDESC_FLAGS_PFN, sizeof(PFNSSMINTLOADEXEC), &g_SSMIntLoadExecCallback },
|
---|
988 | { REMPARMDESC_FLAGS_PFN, sizeof(PFNSSMINTLOADDONE), &g_SSMIntCallback },
|
---|
989 | };
|
---|
990 |
|
---|
991 | static const REMPARMDESC g_aArgsSTAMR3Register[] =
|
---|
992 | {
|
---|
993 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
994 | { REMPARMDESC_FLAGS_INT, sizeof(void *), NULL },
|
---|
995 | { REMPARMDESC_FLAGS_INT, sizeof(STAMTYPE), NULL },
|
---|
996 | { REMPARMDESC_FLAGS_INT, sizeof(STAMVISIBILITY), NULL },
|
---|
997 | { REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
|
---|
998 | { REMPARMDESC_FLAGS_INT, sizeof(STAMUNIT), NULL },
|
---|
999 | { REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL }
|
---|
1000 | };
|
---|
1001 | static const REMPARMDESC g_aArgsSTAMR3Deregister[] =
|
---|
1002 | {
|
---|
1003 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
1004 | { REMPARMDESC_FLAGS_INT, sizeof(void *), NULL },
|
---|
1005 | };
|
---|
1006 | static const REMPARMDESC g_aArgsTRPMAssertTrap[] =
|
---|
1007 | {
|
---|
1008 | { REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
|
---|
1009 | { REMPARMDESC_FLAGS_INT, sizeof(uint8_t), NULL },
|
---|
1010 | { REMPARMDESC_FLAGS_INT, sizeof(TRPMEVENT), NULL }
|
---|
1011 | };
|
---|
1012 | static const REMPARMDESC g_aArgsTRPMQueryTrap[] =
|
---|
1013 | {
|
---|
1014 | { REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
|
---|
1015 | { REMPARMDESC_FLAGS_INT, sizeof(uint8_t *), NULL },
|
---|
1016 | { REMPARMDESC_FLAGS_INT, sizeof(TRPMEVENT *), NULL }
|
---|
1017 | };
|
---|
1018 | static const REMPARMDESC g_aArgsTRPMSetErrorCode[] =
|
---|
1019 | {
|
---|
1020 | { REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
|
---|
1021 | { REMPARMDESC_FLAGS_GCPTR, sizeof(RTGCUINT), NULL }
|
---|
1022 | };
|
---|
1023 | static const REMPARMDESC g_aArgsTRPMSetFaultAddress[] =
|
---|
1024 | {
|
---|
1025 | { REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
|
---|
1026 | { REMPARMDESC_FLAGS_GCPTR, sizeof(RTGCUINT), NULL }
|
---|
1027 | };
|
---|
1028 | static const REMPARMDESC g_aArgsVMR3ReqCallWait[] =
|
---|
1029 | {
|
---|
1030 | { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
|
---|
1031 | { REMPARMDESC_FLAGS_INT, sizeof(VMCPUID), NULL },
|
---|
1032 | { REMPARMDESC_FLAGS_INT, sizeof(void *), NULL },
|
---|
1033 | { REMPARMDESC_FLAGS_INT, sizeof(unsigned), NULL },
|
---|
1034 | { REMPARMDESC_FLAGS_ELLIPSIS, 0, NULL }
|
---|
1035 | };
|
---|
1036 | static const REMPARMDESC g_aArgsVMR3ReqFree[] =
|
---|
1037 | {
|
---|
1038 | { REMPARMDESC_FLAGS_INT, sizeof(PVMREQ), NULL }
|
---|
1039 | };
|
---|
1040 |
|
---|
1041 | /* IPRT args */
|
---|
1042 | static const REMPARMDESC g_aArgsRTAssertMsg1[] =
|
---|
1043 | {
|
---|
1044 | { REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
|
---|
1045 | { REMPARMDESC_FLAGS_INT, sizeof(unsigned), NULL },
|
---|
1046 | { REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
|
---|
1047 | { REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL }
|
---|
1048 | };
|
---|
1049 | static const REMPARMDESC g_aArgsRTAssertMsg2[] =
|
---|
1050 | {
|
---|
1051 | { REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
|
---|
1052 | { REMPARMDESC_FLAGS_ELLIPSIS, 0, NULL }
|
---|
1053 | };
|
---|
1054 | static const REMPARMDESC g_aArgsRTAssertMsg2V[] =
|
---|
1055 | {
|
---|
1056 | { REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
|
---|
1057 | { REMPARMDESC_FLAGS_VALIST, 0, NULL }
|
---|
1058 | };
|
---|
1059 | static const REMPARMDESC g_aArgsRTLogFlags[] =
|
---|
1060 | {
|
---|
1061 | { REMPARMDESC_FLAGS_INT, sizeof(PRTLOGGER), NULL },
|
---|
1062 | { REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL }
|
---|
1063 | };
|
---|
1064 | static const REMPARMDESC g_aArgsRTLogFlush[] =
|
---|
1065 | {
|
---|
1066 | { REMPARMDESC_FLAGS_INT, sizeof(PRTLOGGER), NULL }
|
---|
1067 | };
|
---|
1068 | static const REMPARMDESC g_aArgsRTLogLoggerEx[] =
|
---|
1069 | {
|
---|
1070 | { REMPARMDESC_FLAGS_INT, sizeof(PRTLOGGER), NULL },
|
---|
1071 | { REMPARMDESC_FLAGS_INT, sizeof(unsigned), NULL },
|
---|
1072 | { REMPARMDESC_FLAGS_INT, sizeof(unsigned), NULL },
|
---|
1073 | { REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
|
---|
1074 | { REMPARMDESC_FLAGS_ELLIPSIS, 0, NULL }
|
---|
1075 | };
|
---|
1076 | static const REMPARMDESC g_aArgsRTLogLoggerExV[] =
|
---|
1077 | {
|
---|
1078 | { REMPARMDESC_FLAGS_INT, sizeof(PRTLOGGER), NULL },
|
---|
1079 | { REMPARMDESC_FLAGS_INT, sizeof(unsigned), NULL },
|
---|
1080 | { REMPARMDESC_FLAGS_INT, sizeof(unsigned), NULL },
|
---|
1081 | { REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
|
---|
1082 | { REMPARMDESC_FLAGS_VALIST, 0, NULL }
|
---|
1083 | };
|
---|
1084 | static const REMPARMDESC g_aArgsRTLogPrintf[] =
|
---|
1085 | {
|
---|
1086 | { REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
|
---|
1087 | { REMPARMDESC_FLAGS_ELLIPSIS, 0, NULL }
|
---|
1088 | };
|
---|
1089 | static const REMPARMDESC g_aArgsRTMemProtect[] =
|
---|
1090 | {
|
---|
1091 | { REMPARMDESC_FLAGS_INT, sizeof(void *), NULL },
|
---|
1092 | { REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL },
|
---|
1093 | { REMPARMDESC_FLAGS_INT, sizeof(unsigned), NULL }
|
---|
1094 | };
|
---|
1095 | static const REMPARMDESC g_aArgsRTStrPrintf[] =
|
---|
1096 | {
|
---|
1097 | { REMPARMDESC_FLAGS_INT, sizeof(char *), NULL },
|
---|
1098 | { REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL },
|
---|
1099 | { REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
|
---|
1100 | { REMPARMDESC_FLAGS_ELLIPSIS, 0, NULL }
|
---|
1101 | };
|
---|
1102 | static const REMPARMDESC g_aArgsRTStrPrintfV[] =
|
---|
1103 | {
|
---|
1104 | { REMPARMDESC_FLAGS_INT, sizeof(char *), NULL },
|
---|
1105 | { REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL },
|
---|
1106 | { REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
|
---|
1107 | { REMPARMDESC_FLAGS_VALIST, 0, NULL }
|
---|
1108 | };
|
---|
1109 | static const REMPARMDESC g_aArgsThread[] =
|
---|
1110 | {
|
---|
1111 | { REMPARMDESC_FLAGS_INT, sizeof(RTTHREAD), NULL }
|
---|
1112 | };
|
---|
1113 |
|
---|
1114 |
|
---|
1115 | /* CRT args */
|
---|
1116 | static const REMPARMDESC g_aArgsmemcpy[] =
|
---|
1117 | {
|
---|
1118 | { REMPARMDESC_FLAGS_INT, sizeof(void *), NULL },
|
---|
1119 | { REMPARMDESC_FLAGS_INT, sizeof(const void *), NULL },
|
---|
1120 | { REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL }
|
---|
1121 | };
|
---|
1122 | static const REMPARMDESC g_aArgsmemset[] =
|
---|
1123 | {
|
---|
1124 | { REMPARMDESC_FLAGS_INT, sizeof(void *), NULL },
|
---|
1125 | { REMPARMDESC_FLAGS_INT, sizeof(int), NULL },
|
---|
1126 | { REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL }
|
---|
1127 | };
|
---|
1128 |
|
---|
1129 | # endif /* !VBOX_USE_BITNESS_SELECTOR */
|
---|
1130 |
|
---|
1131 | /** @} */
|
---|
1132 |
|
---|
1133 | /**
|
---|
1134 | * Descriptors for the exported functions.
|
---|
1135 | */
|
---|
1136 | static const REMFNDESC g_aExports[] =
|
---|
1137 | { /* pszName, (void *)pv, pParams, cParams, fFlags, cb, pvWrapper. */
|
---|
1138 | { "REMR3Init", (void *)&pfnREMR3Init, &g_aArgsVM[0], RT_ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1139 | { "REMR3InitFinalize", (void *)&pfnREMR3InitFinalize, &g_aArgsVM[0], RT_ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1140 | { "REMR3Term", (void *)&pfnREMR3Term, &g_aArgsVM[0], RT_ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1141 | { "REMR3Reset", (void *)&pfnREMR3Reset, &g_aArgsVM[0], RT_ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1142 | { "REMR3Step", (void *)&pfnREMR3Step, &g_aArgsVMandVMCPU[0], RT_ELEMENTS(g_aArgsVMandVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1143 | { "REMR3BreakpointSet", (void *)&pfnREMR3BreakpointSet, &g_aArgsBreakpoint[0], RT_ELEMENTS(g_aArgsBreakpoint), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1144 | { "REMR3BreakpointClear", (void *)&pfnREMR3BreakpointClear, &g_aArgsBreakpoint[0], RT_ELEMENTS(g_aArgsBreakpoint), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1145 | { "REMR3EmulateInstruction", (void *)&pfnREMR3EmulateInstruction, &g_aArgsVMandVMCPU[0], RT_ELEMENTS(g_aArgsVMandVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1146 | { "REMR3Run", (void *)&pfnREMR3Run, &g_aArgsVMandVMCPU[0], RT_ELEMENTS(g_aArgsVMandVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1147 | { "REMR3State", (void *)&pfnREMR3State, &g_aArgsVMandVMCPU[0], RT_ELEMENTS(g_aArgsVMandVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1148 | { "REMR3StateBack", (void *)&pfnREMR3StateBack, &g_aArgsVMandVMCPU[0], RT_ELEMENTS(g_aArgsVMandVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1149 | { "REMR3StateUpdate", (void *)&pfnREMR3StateUpdate, &g_aArgsVMandVMCPU[0], RT_ELEMENTS(g_aArgsVMandVMCPU), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1150 | { "REMR3A20Set", (void *)&pfnREMR3A20Set, &g_aArgsA20Set[0], RT_ELEMENTS(g_aArgsA20Set), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1151 | { "REMR3ReplayHandlerNotifications", (void *)&pfnREMR3ReplayHandlerNotifications, &g_aArgsVM[0], RT_ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1152 | { "REMR3NotifyPhysRamRegister", (void *)&pfnREMR3NotifyPhysRamRegister, &g_aArgsNotifyPhysRamRegister[0], RT_ELEMENTS(g_aArgsNotifyPhysRamRegister), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1153 | { "REMR3NotifyPhysRamDeregister", (void *)&pfnREMR3NotifyPhysRamDeregister, &g_aArgsNotifyPhysRamDeregister[0], RT_ELEMENTS(g_aArgsNotifyPhysRamDeregister), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1154 | { "REMR3NotifyPhysRomRegister", (void *)&pfnREMR3NotifyPhysRomRegister, &g_aArgsNotifyPhysRomRegister[0], RT_ELEMENTS(g_aArgsNotifyPhysRomRegister), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1155 | { "REMR3NotifyHandlerPhysicalModify", (void *)&pfnREMR3NotifyHandlerPhysicalModify, &g_aArgsNotifyHandlerPhysicalModify[0], RT_ELEMENTS(g_aArgsNotifyHandlerPhysicalModify), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1156 | { "REMR3NotifyHandlerPhysicalRegister", (void *)&pfnREMR3NotifyHandlerPhysicalRegister, &g_aArgsNotifyHandlerPhysicalRegister[0], RT_ELEMENTS(g_aArgsNotifyHandlerPhysicalRegister), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1157 | { "REMR3NotifyHandlerPhysicalDeregister", (void *)&pfnREMR3NotifyHandlerPhysicalDeregister, &g_aArgsNotifyHandlerPhysicalDeregister[0], RT_ELEMENTS(g_aArgsNotifyHandlerPhysicalDeregister), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1158 | { "REMR3NotifyInterruptSet", (void *)&pfnREMR3NotifyInterruptSet, &g_aArgsVMandVMCPU[0], RT_ELEMENTS(g_aArgsVMandVMCPU), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1159 | { "REMR3NotifyInterruptClear", (void *)&pfnREMR3NotifyInterruptClear, &g_aArgsVMandVMCPU[0], RT_ELEMENTS(g_aArgsVMandVMCPU), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1160 | { "REMR3NotifyTimerPending", (void *)&pfnREMR3NotifyTimerPending, &g_aArgsVMandVMCPU[0], RT_ELEMENTS(g_aArgsVMandVMCPU), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1161 | { "REMR3NotifyDmaPending", (void *)&pfnREMR3NotifyDmaPending, &g_aArgsVM[0], RT_ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1162 | { "REMR3NotifyQueuePending", (void *)&pfnREMR3NotifyQueuePending, &g_aArgsVM[0], RT_ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1163 | { "REMR3NotifyFF", (void *)&pfnREMR3NotifyFF, &g_aArgsVM[0], RT_ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1164 | { "REMR3NotifyCodePageChanged", (void *)&pfnREMR3NotifyCodePageChanged, &g_aArgsNotifyCodePageChanged[0], RT_ELEMENTS(g_aArgsNotifyCodePageChanged), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1165 | { "REMR3NotifyPendingInterrupt", (void *)&pfnREMR3NotifyPendingInterrupt, &g_aArgsNotifyPendingInterrupt[0], RT_ELEMENTS(g_aArgsNotifyPendingInterrupt), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1166 | { "REMR3QueryPendingInterrupt", (void *)&pfnREMR3QueryPendingInterrupt, &g_aArgsVMandVMCPU[0], RT_ELEMENTS(g_aArgsVMandVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(uint32_t), NULL },
|
---|
1167 | { "REMR3DisasEnableStepping", (void *)&pfnREMR3DisasEnableStepping, &g_aArgsDisasEnableStepping[0], RT_ELEMENTS(g_aArgsDisasEnableStepping), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1168 | { "REMR3IsPageAccessHandled", (void *)&pfnREMR3IsPageAccessHandled, &g_aArgsIsPageAccessHandled[0], RT_ELEMENTS(g_aArgsIsPageAccessHandled), REMFNDESC_FLAGS_RET_INT, sizeof(bool), NULL }
|
---|
1169 | };
|
---|
1170 |
|
---|
1171 | # ifndef VBOX_USE_BITNESS_SELECTOR
|
---|
1172 |
|
---|
1173 | # ifdef VBOX_WITHOUT_REM_LDR_CYCLE
|
---|
1174 | # define VMM_FN(name) NULL
|
---|
1175 | # else
|
---|
1176 | # define VMM_FN(name) (void *)(uintptr_t)& name
|
---|
1177 | # endif
|
---|
1178 |
|
---|
1179 | /**
|
---|
1180 | * Descriptors for the functions imported from VBoxVMM.
|
---|
1181 | */
|
---|
1182 | static REMFNDESC g_aVMMImports[] =
|
---|
1183 | {
|
---|
1184 | { "CPUMAreHiddenSelRegsValid", VMM_FN(CPUMAreHiddenSelRegsValid), &g_aArgsVMCPU[0], RT_ELEMENTS(g_aArgsVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(bool), NULL },
|
---|
1185 | { "CPUMR3RemEnter", VMM_FN(CPUMR3RemEnter), &g_aArgsCPUMR3RemEnter[0], RT_ELEMENTS(g_aArgsCPUMR3RemEnter), REMFNDESC_FLAGS_RET_INT, sizeof(uint32_t), NULL },
|
---|
1186 | { "CPUMR3RemLeave", VMM_FN(CPUMR3RemLeave), &g_aArgsCPUMR3RemLeave[0], RT_ELEMENTS(g_aArgsCPUMR3RemLeave), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1187 | { "CPUMSetChangedFlags", VMM_FN(CPUMSetChangedFlags), &g_aArgsCPUMSetChangedFlags[0], RT_ELEMENTS(g_aArgsCPUMSetChangedFlags), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1188 | { "CPUMGetGuestCPL", VMM_FN(CPUMGetGuestCPL), &g_aArgsCPUMGetGuestCpl[0], RT_ELEMENTS(g_aArgsCPUMGetGuestCpl), REMFNDESC_FLAGS_RET_INT, sizeof(unsigned), NULL },
|
---|
1189 | { "CPUMQueryGuestMsr", VMM_FN(CPUMQueryGuestMsr), &g_aArgsCPUMQueryGuestMsr[0], RT_ELEMENTS(g_aArgsCPUMQueryGuestMsr), REMFNDESC_FLAGS_RET_INT, sizeof(uint64_t), NULL },
|
---|
1190 | { "CPUMSetGuestMsr", VMM_FN(CPUMSetGuestMsr), &g_aArgsCPUMSetGuestMsr[0], RT_ELEMENTS(g_aArgsCPUMSetGuestMsr), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1191 | { "CPUMGetGuestCpuId", VMM_FN(CPUMGetGuestCpuId), &g_aArgsCPUMGetGuestCpuId[0], RT_ELEMENTS(g_aArgsCPUMGetGuestCpuId), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1192 | { "CPUMGetGuestEAX", VMM_FN(CPUMGetGuestEAX), &g_aArgsVMCPU[0], RT_ELEMENTS(g_aArgsVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(uint32_t), NULL },
|
---|
1193 | { "CPUMGetGuestEBP", VMM_FN(CPUMGetGuestEBP), &g_aArgsVMCPU[0], RT_ELEMENTS(g_aArgsVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(uint32_t), NULL },
|
---|
1194 | { "CPUMGetGuestEBX", VMM_FN(CPUMGetGuestEBX), &g_aArgsVMCPU[0], RT_ELEMENTS(g_aArgsVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(uint32_t), NULL },
|
---|
1195 | { "CPUMGetGuestECX", VMM_FN(CPUMGetGuestECX), &g_aArgsVMCPU[0], RT_ELEMENTS(g_aArgsVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(uint32_t), NULL },
|
---|
1196 | { "CPUMGetGuestEDI", VMM_FN(CPUMGetGuestEDI), &g_aArgsVMCPU[0], RT_ELEMENTS(g_aArgsVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(uint32_t), NULL },
|
---|
1197 | { "CPUMGetGuestEDX", VMM_FN(CPUMGetGuestEDX), &g_aArgsVMCPU[0], RT_ELEMENTS(g_aArgsVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(uint32_t), NULL },
|
---|
1198 | { "CPUMGetGuestEIP", VMM_FN(CPUMGetGuestEIP), &g_aArgsVMCPU[0], RT_ELEMENTS(g_aArgsVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(uint32_t), NULL },
|
---|
1199 | { "CPUMGetGuestESI", VMM_FN(CPUMGetGuestESI), &g_aArgsVMCPU[0], RT_ELEMENTS(g_aArgsVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(uint32_t), NULL },
|
---|
1200 | { "CPUMGetGuestESP", VMM_FN(CPUMGetGuestESP), &g_aArgsVMCPU[0], RT_ELEMENTS(g_aArgsVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(uint32_t), NULL },
|
---|
1201 | { "CPUMGetGuestCS", VMM_FN(CPUMGetGuestCS), &g_aArgsVMCPU[0], RT_ELEMENTS(g_aArgsVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(RTSEL), NULL },
|
---|
1202 | { "CPUMGetGuestSS", VMM_FN(CPUMGetGuestSS), &g_aArgsVMCPU[0], RT_ELEMENTS(g_aArgsVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(RTSEL), NULL },
|
---|
1203 | { "CPUMGetGuestCpuVendor", VMM_FN(CPUMGetGuestCpuVendor), &g_aArgsVM[0], RT_ELEMENTS(g_aArgsVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(CPUMCPUVENDOR), NULL },
|
---|
1204 | { "CPUMQueryGuestCtxPtr", VMM_FN(CPUMQueryGuestCtxPtr), &g_aArgsCPUMQueryGuestCtxPtr[0], RT_ELEMENTS(g_aArgsCPUMQueryGuestCtxPtr), REMFNDESC_FLAGS_RET_INT, sizeof(PCPUMCTX), NULL },
|
---|
1205 | { "CSAMR3MonitorPage", VMM_FN(CSAMR3MonitorPage), &g_aArgsCSAMR3MonitorPage[0], RT_ELEMENTS(g_aArgsCSAMR3MonitorPage), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1206 | { "CSAMR3UnmonitorPage", VMM_FN(CSAMR3UnmonitorPage), &g_aArgsCSAMR3UnmonitorPage[0], RT_ELEMENTS(g_aArgsCSAMR3UnmonitorPage), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1207 | { "CSAMR3RecordCallAddress", VMM_FN(CSAMR3RecordCallAddress), &g_aArgsCSAMR3RecordCallAddress[0], RT_ELEMENTS(g_aArgsCSAMR3RecordCallAddress), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1208 | # if defined(VBOX_WITH_DEBUGGER) && !(defined(RT_OS_WINDOWS) && defined(RT_ARCH_AMD64)) /* the callbacks are problematic */
|
---|
1209 | { "DBGCRegisterCommands", VMM_FN(DBGCRegisterCommands), &g_aArgsDBGCRegisterCommands[0], RT_ELEMENTS(g_aArgsDBGCRegisterCommands), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1210 | # endif
|
---|
1211 | { "DBGFR3DisasInstrEx", VMM_FN(DBGFR3DisasInstrEx), &g_aArgsDBGFR3DisasInstrEx[0], RT_ELEMENTS(g_aArgsDBGFR3DisasInstrEx), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1212 | { "DBGFR3DisasInstrCurrentLogInternal", VMM_FN(DBGFR3DisasInstrCurrentLogInternal), &g_aArgsDBGFR3DisasInstrCurrentLogInternal[0], RT_ELEMENTS(g_aArgsDBGFR3DisasInstrCurrentLogInternal),REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1213 | { "DBGFR3Info", VMM_FN(DBGFR3Info), &g_aArgsDBGFR3Info[0], RT_ELEMENTS(g_aArgsDBGFR3Info), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1214 | { "DBGFR3InfoLogRelHlp", VMM_FN(DBGFR3InfoLogRelHlp), NULL, 0, REMFNDESC_FLAGS_RET_INT, sizeof(void *), NULL },
|
---|
1215 | { "DBGFR3AsSymbolByAddr", VMM_FN(DBGFR3AsSymbolByAddr), &g_aArgsDBGFR3AsSymbolByAddr[0], RT_ELEMENTS(g_aArgsDBGFR3AsSymbolByAddr), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1216 | { "DBGFR3AddrFromFlat", VMM_FN(DBGFR3AddrFromFlat), &g_aArgsDBGFR3AddrFromFlat[0], RT_ELEMENTS(g_aArgsDBGFR3AddrFromFlat), REMFNDESC_FLAGS_RET_INT, sizeof(PDBGFADDRESS), NULL },
|
---|
1217 | { "DISInstr", VMM_FN(DISInstr), &g_aArgsDISInstr[0], RT_ELEMENTS(g_aArgsDISInstr), REMFNDESC_FLAGS_RET_INT, sizeof(bool), NULL },
|
---|
1218 | { "EMR3FatalError", VMM_FN(EMR3FatalError), &g_aArgsEMR3FatalError[0], RT_ELEMENTS(g_aArgsEMR3FatalError), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1219 | { "EMRemLock", VMM_FN(EMRemLock), &g_aArgsVM[0], RT_ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1220 | { "EMRemUnlock", VMM_FN(EMRemUnlock), &g_aArgsVM[0], RT_ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1221 | { "EMRemIsLockOwner", VMM_FN(EMRemIsLockOwner), &g_aArgsVM[0], RT_ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_VOID, sizeof(bool), NULL },
|
---|
1222 | { "HWACCMR3CanExecuteGuest", VMM_FN(HWACCMR3CanExecuteGuest), &g_aArgsHWACCMR3CanExecuteGuest[0], RT_ELEMENTS(g_aArgsHWACCMR3CanExecuteGuest), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1223 | { "IOMIOPortRead", VMM_FN(IOMIOPortRead), &g_aArgsIOMIOPortRead[0], RT_ELEMENTS(g_aArgsIOMIOPortRead), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1224 | { "IOMIOPortWrite", VMM_FN(IOMIOPortWrite), &g_aArgsIOMIOPortWrite[0], RT_ELEMENTS(g_aArgsIOMIOPortWrite), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1225 | { "IOMMMIORead", VMM_FN(IOMMMIORead), &g_aArgsIOMMMIORead[0], RT_ELEMENTS(g_aArgsIOMMMIORead), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1226 | { "IOMMMIOWrite", VMM_FN(IOMMMIOWrite), &g_aArgsIOMMMIOWrite[0], RT_ELEMENTS(g_aArgsIOMMMIOWrite), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1227 | { "MMR3HeapAlloc", VMM_FN(MMR3HeapAlloc), &g_aArgsMMR3HeapAlloc[0], RT_ELEMENTS(g_aArgsMMR3HeapAlloc), REMFNDESC_FLAGS_RET_INT, sizeof(void *), NULL },
|
---|
1228 | { "MMR3HeapAllocZ", VMM_FN(MMR3HeapAllocZ), &g_aArgsMMR3HeapAllocZ[0], RT_ELEMENTS(g_aArgsMMR3HeapAllocZ), REMFNDESC_FLAGS_RET_INT, sizeof(void *), NULL },
|
---|
1229 | { "MMR3PhysGetRamSize", VMM_FN(MMR3PhysGetRamSize), &g_aArgsVM[0], RT_ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(uint64_t), NULL },
|
---|
1230 | { "PATMIsPatchGCAddr", VMM_FN(PATMIsPatchGCAddr), &g_aArgsPATMIsPatchGCAddr[0], RT_ELEMENTS(g_aArgsPATMIsPatchGCAddr), REMFNDESC_FLAGS_RET_INT, sizeof(bool), NULL },
|
---|
1231 | { "PATMR3QueryOpcode", VMM_FN(PATMR3QueryOpcode), &g_aArgsPATMR3QueryOpcode[0], RT_ELEMENTS(g_aArgsPATMR3QueryOpcode), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1232 | { "PATMR3QueryPatchMemGC", VMM_FN(PATMR3QueryPatchMemGC), &g_aArgsPATMR3QueryPatchMem[0], RT_ELEMENTS(g_aArgsPATMR3QueryPatchMem), REMFNDESC_FLAGS_RET_INT, sizeof(RTGCPTR), NULL },
|
---|
1233 | { "PATMR3QueryPatchMemHC", VMM_FN(PATMR3QueryPatchMemHC), &g_aArgsPATMR3QueryPatchMem[0], RT_ELEMENTS(g_aArgsPATMR3QueryPatchMem), REMFNDESC_FLAGS_RET_INT, sizeof(void *), NULL },
|
---|
1234 | { "PDMApicGetBase", VMM_FN(PDMApicGetBase), &g_aArgsPDMApicGetBase[0], RT_ELEMENTS(g_aArgsPDMApicGetBase), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1235 | { "PDMApicGetTPR", VMM_FN(PDMApicGetTPR), &g_aArgsPDMApicGetTPR[0], RT_ELEMENTS(g_aArgsPDMApicGetTPR), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1236 | { "PDMApicSetBase", VMM_FN(PDMApicSetBase), &g_aArgsPDMApicSetBase[0], RT_ELEMENTS(g_aArgsPDMApicSetBase), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1237 | { "PDMApicSetTPR", VMM_FN(PDMApicSetTPR), &g_aArgsPDMApicSetTPR[0], RT_ELEMENTS(g_aArgsPDMApicSetTPR), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1238 | { "PDMR3DmaRun", VMM_FN(PDMR3DmaRun), &g_aArgsVM[0], RT_ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1239 | { "PDMR3CritSectInit", VMM_FN(PDMR3CritSectInit), &g_aArgsPDMR3CritSectInit[0], RT_ELEMENTS(g_aArgsPDMR3CritSectInit), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1240 | { "PDMCritSectEnter", VMM_FN(PDMCritSectEnter), &g_aArgsPDMCritSectEnter[0], RT_ELEMENTS(g_aArgsPDMCritSectEnter), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1241 | { "PDMCritSectLeave", VMM_FN(PDMCritSectLeave), &g_aArgsPTR[0], RT_ELEMENTS(g_aArgsPTR), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1242 | # ifdef VBOX_STRICT
|
---|
1243 | { "PDMCritSectEnterDebug", VMM_FN(PDMCritSectEnterDebug), &g_aArgsPDMCritSectEnterDebug[0], RT_ELEMENTS(g_aArgsPDMCritSectEnterDebug), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1244 | # endif
|
---|
1245 | { "PDMGetInterrupt", VMM_FN(PDMGetInterrupt), &g_aArgsPDMGetInterrupt[0], RT_ELEMENTS(g_aArgsPDMGetInterrupt), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1246 | { "PDMIsaSetIrq", VMM_FN(PDMIsaSetIrq), &g_aArgsPDMIsaSetIrq[0], RT_ELEMENTS(g_aArgsPDMIsaSetIrq), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1247 | { "PGMGetGuestMode", VMM_FN(PGMGetGuestMode), &g_aArgsPGMGetGuestMode[0], RT_ELEMENTS(g_aArgsPGMGetGuestMode), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1248 | { "PGMGstGetPage", VMM_FN(PGMGstGetPage), &g_aArgsPGMGstGetPage[0], RT_ELEMENTS(g_aArgsPGMGstGetPage), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1249 | { "PGMInvalidatePage", VMM_FN(PGMInvalidatePage), &g_aArgsPGMInvalidatePage[0], RT_ELEMENTS(g_aArgsPGMInvalidatePage), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1250 | { "PGMPhysIsGCPhysValid", VMM_FN(PGMPhysIsGCPhysValid), &g_aArgsPGMPhysIsGCPhysValid[0], RT_ELEMENTS(g_aArgsPGMPhysIsGCPhysValid), REMFNDESC_FLAGS_RET_INT, sizeof(bool), NULL },
|
---|
1251 | { "PGMPhysIsA20Enabled", VMM_FN(PGMPhysIsA20Enabled), &g_aArgsVMCPU[0], RT_ELEMENTS(g_aArgsVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(bool), NULL },
|
---|
1252 | { "PGMPhysRead", VMM_FN(PGMPhysRead), &g_aArgsPGMPhysRead[0], RT_ELEMENTS(g_aArgsPGMPhysRead), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1253 | { "PGMPhysSimpleReadGCPtr", VMM_FN(PGMPhysSimpleReadGCPtr), &g_aArgsPGMPhysSimpleReadGCPtr[0], RT_ELEMENTS(g_aArgsPGMPhysSimpleReadGCPtr), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1254 | { "PGMPhysWrite", VMM_FN(PGMPhysWrite), &g_aArgsPGMPhysWrite[0], RT_ELEMENTS(g_aArgsPGMPhysWrite), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1255 | { "PGMChangeMode", VMM_FN(PGMChangeMode), &g_aArgsPGMChangeMode[0], RT_ELEMENTS(g_aArgsPGMChangeMode), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1256 | { "PGMFlushTLB", VMM_FN(PGMFlushTLB), &g_aArgsPGMFlushTLB[0], RT_ELEMENTS(g_aArgsPGMFlushTLB), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1257 | { "PGMR3PhysReadU8", VMM_FN(PGMR3PhysReadU8), &g_aArgsPGMR3PhysReadUxx[0], RT_ELEMENTS(g_aArgsPGMR3PhysReadUxx), REMFNDESC_FLAGS_RET_INT, sizeof(uint8_t), NULL },
|
---|
1258 | { "PGMR3PhysReadU16", VMM_FN(PGMR3PhysReadU16), &g_aArgsPGMR3PhysReadUxx[0], RT_ELEMENTS(g_aArgsPGMR3PhysReadUxx), REMFNDESC_FLAGS_RET_INT, sizeof(uint16_t), NULL },
|
---|
1259 | { "PGMR3PhysReadU32", VMM_FN(PGMR3PhysReadU32), &g_aArgsPGMR3PhysReadUxx[0], RT_ELEMENTS(g_aArgsPGMR3PhysReadUxx), REMFNDESC_FLAGS_RET_INT, sizeof(uint32_t), NULL },
|
---|
1260 | { "PGMR3PhysReadU64", VMM_FN(PGMR3PhysReadU64), &g_aArgsPGMR3PhysReadUxx[0], RT_ELEMENTS(g_aArgsPGMR3PhysReadUxx), REMFNDESC_FLAGS_RET_INT, sizeof(uint64_t), NULL },
|
---|
1261 | { "PGMR3PhysWriteU8", VMM_FN(PGMR3PhysWriteU8), &g_aArgsPGMR3PhysWriteU8[0], RT_ELEMENTS(g_aArgsPGMR3PhysWriteU8), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1262 | { "PGMR3PhysWriteU16", VMM_FN(PGMR3PhysWriteU16), &g_aArgsPGMR3PhysWriteU16[0], RT_ELEMENTS(g_aArgsPGMR3PhysWriteU16), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1263 | { "PGMR3PhysWriteU32", VMM_FN(PGMR3PhysWriteU32), &g_aArgsPGMR3PhysWriteU32[0], RT_ELEMENTS(g_aArgsPGMR3PhysWriteU32), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1264 | { "PGMR3PhysWriteU64", VMM_FN(PGMR3PhysWriteU64), &g_aArgsPGMR3PhysWriteU64[0], RT_ELEMENTS(g_aArgsPGMR3PhysWriteU32), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1265 | { "PGMR3PhysTlbGCPhys2Ptr", VMM_FN(PGMR3PhysTlbGCPhys2Ptr), &g_aArgsPGMR3PhysTlbGCPhys2Ptr[0], RT_ELEMENTS(g_aArgsPGMR3PhysTlbGCPhys2Ptr), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1266 | { "PGMIsLockOwner", VMM_FN(PGMIsLockOwner), &g_aArgsVM[0], RT_ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(bool), NULL },
|
---|
1267 | { "SSMR3GetGCPtr", VMM_FN(SSMR3GetGCPtr), &g_aArgsSSMR3GetGCPtr[0], RT_ELEMENTS(g_aArgsSSMR3GetGCPtr), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1268 | { "SSMR3GetMem", VMM_FN(SSMR3GetMem), &g_aArgsSSMR3GetMem[0], RT_ELEMENTS(g_aArgsSSMR3GetMem), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1269 | { "SSMR3GetU32", VMM_FN(SSMR3GetU32), &g_aArgsSSMR3GetU32[0], RT_ELEMENTS(g_aArgsSSMR3GetU32), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1270 | { "SSMR3GetUInt", VMM_FN(SSMR3GetUInt), &g_aArgsSSMR3GetUInt[0], RT_ELEMENTS(g_aArgsSSMR3GetUInt), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1271 | { "SSMR3PutGCPtr", VMM_FN(SSMR3PutGCPtr), &g_aArgsSSMR3PutGCPtr[0], RT_ELEMENTS(g_aArgsSSMR3PutGCPtr), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1272 | { "SSMR3PutMem", VMM_FN(SSMR3PutMem), &g_aArgsSSMR3PutMem[0], RT_ELEMENTS(g_aArgsSSMR3PutMem), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1273 | { "SSMR3PutU32", VMM_FN(SSMR3PutU32), &g_aArgsSSMR3PutU32[0], RT_ELEMENTS(g_aArgsSSMR3PutU32), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1274 | { "SSMR3PutUInt", VMM_FN(SSMR3PutUInt), &g_aArgsSSMR3PutUInt[0], RT_ELEMENTS(g_aArgsSSMR3PutUInt), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1275 | { "SSMR3RegisterInternal", VMM_FN(SSMR3RegisterInternal), &g_aArgsSSMR3RegisterInternal[0], RT_ELEMENTS(g_aArgsSSMR3RegisterInternal), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1276 | { "STAMR3Register", VMM_FN(STAMR3Register), &g_aArgsSTAMR3Register[0], RT_ELEMENTS(g_aArgsSTAMR3Register), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1277 | { "STAMR3Deregister", VMM_FN(STAMR3Deregister), &g_aArgsSTAMR3Deregister[0], RT_ELEMENTS(g_aArgsSTAMR3Deregister), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1278 | { "TMCpuTickGet", VMM_FN(TMCpuTickGet), &g_aArgsVMCPU[0], RT_ELEMENTS(g_aArgsVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(uint64_t), NULL },
|
---|
1279 | { "TMR3NotifySuspend", VMM_FN(TMR3NotifySuspend), &g_aArgsVMandVMCPU[0], RT_ELEMENTS(g_aArgsVMandVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1280 | { "TMR3NotifyResume", VMM_FN(TMR3NotifyResume), &g_aArgsVMandVMCPU[0], RT_ELEMENTS(g_aArgsVMandVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1281 | { "TMNotifyEndOfExecution", VMM_FN(TMNotifyEndOfExecution), &g_aArgsVMCPU[0], RT_ELEMENTS(g_aArgsVMCPU), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1282 | { "TMNotifyStartOfExecution", VMM_FN(TMNotifyStartOfExecution), &g_aArgsVMCPU[0], RT_ELEMENTS(g_aArgsVMCPU), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1283 | { "TMTimerPollBool", VMM_FN(TMTimerPollBool), &g_aArgsVMandVMCPU[0], RT_ELEMENTS(g_aArgsVMandVMCPU), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1284 | { "TMR3TimerQueuesDo", VMM_FN(TMR3TimerQueuesDo), &g_aArgsVM[0], RT_ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1285 | { "TRPMAssertTrap", VMM_FN(TRPMAssertTrap), &g_aArgsTRPMAssertTrap[0], RT_ELEMENTS(g_aArgsTRPMAssertTrap), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1286 | { "TRPMGetErrorCode", VMM_FN(TRPMGetErrorCode), &g_aArgsVMCPU[0], RT_ELEMENTS(g_aArgsVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(RTGCUINT), NULL },
|
---|
1287 | { "TRPMGetFaultAddress", VMM_FN(TRPMGetFaultAddress), &g_aArgsVMCPU[0], RT_ELEMENTS(g_aArgsVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(RTGCUINTPTR),NULL },
|
---|
1288 | { "TRPMQueryTrap", VMM_FN(TRPMQueryTrap), &g_aArgsTRPMQueryTrap[0], RT_ELEMENTS(g_aArgsTRPMQueryTrap), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1289 | { "TRPMResetTrap", VMM_FN(TRPMResetTrap), &g_aArgsVMCPU[0], RT_ELEMENTS(g_aArgsVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1290 | { "TRPMSetErrorCode", VMM_FN(TRPMSetErrorCode), &g_aArgsTRPMSetErrorCode[0], RT_ELEMENTS(g_aArgsTRPMSetErrorCode), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1291 | { "TRPMSetFaultAddress", VMM_FN(TRPMSetFaultAddress), &g_aArgsTRPMSetFaultAddress[0], RT_ELEMENTS(g_aArgsTRPMSetFaultAddress), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1292 | { "VMMGetCpu", VMM_FN(VMMGetCpu), &g_aArgsVM[0], RT_ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(PVMCPU), NULL },
|
---|
1293 | { "VMR3ReqCallWait", VMM_FN(VMR3ReqCallWait), &g_aArgsVMR3ReqCallWait[0], RT_ELEMENTS(g_aArgsVMR3ReqCallWait), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1294 | { "VMR3ReqFree", VMM_FN(VMR3ReqFree), &g_aArgsVMR3ReqFree[0], RT_ELEMENTS(g_aArgsVMR3ReqFree), REMFNDESC_FLAGS_RET_INT | REMFNDESC_FLAGS_ELLIPSIS, sizeof(int), NULL },
|
---|
1295 | { "VMR3GetVMCPUId", VMM_FN(VMR3GetVMCPUId), &g_aArgsVM[0], RT_ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1296 | { "VMR3GetVMCPUNativeThread", VMM_FN(VMR3GetVMCPUNativeThread), &g_aArgsVM[0], RT_ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(void *), NULL },
|
---|
1297 | { "EMInterpretInstructionCPU", VMM_FN(EMInterpretInstructionCPU), &g_aArgsEMInterpretInstructionCPU[0], RT_ELEMENTS(g_aArgsEMInterpretInstructionCPU), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1298 | // { "", VMM_FN(), &g_aArgsVM[0], RT_ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1299 | };
|
---|
1300 |
|
---|
1301 |
|
---|
1302 | /**
|
---|
1303 | * Descriptors for the functions imported from VBoxRT.
|
---|
1304 | */
|
---|
1305 | static REMFNDESC g_aRTImports[] =
|
---|
1306 | {
|
---|
1307 | { "RTAssertMsg1", (void *)(uintptr_t)&RTAssertMsg1, &g_aArgsRTAssertMsg1[0], RT_ELEMENTS(g_aArgsRTAssertMsg1), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1308 | { "RTAssertMsg1Weak", (void *)(uintptr_t)&RTAssertMsg1Weak, &g_aArgsRTAssertMsg1[0], RT_ELEMENTS(g_aArgsRTAssertMsg1), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1309 | { "RTAssertMsg2", (void *)(uintptr_t)&RTAssertMsg2, &g_aArgsRTAssertMsg2[0], RT_ELEMENTS(g_aArgsRTAssertMsg2), REMFNDESC_FLAGS_RET_VOID | REMFNDESC_FLAGS_ELLIPSIS, 0, NULL },
|
---|
1310 | { "RTAssertMsg2V", (void *)(uintptr_t)&RTAssertMsg2V, &g_aArgsRTAssertMsg2V[0], RT_ELEMENTS(g_aArgsRTAssertMsg2V), REMFNDESC_FLAGS_RET_VOID | REMFNDESC_FLAGS_VALIST, 0, NULL },
|
---|
1311 | { "RTAssertMsg2Weak", (void *)(uintptr_t)&RTAssertMsg2Weak, &g_aArgsRTAssertMsg2[0], RT_ELEMENTS(g_aArgsRTAssertMsg2), REMFNDESC_FLAGS_RET_VOID | REMFNDESC_FLAGS_ELLIPSIS, 0, NULL },
|
---|
1312 | { "RTAssertShouldPanic", (void *)(uintptr_t)&RTAssertShouldPanic, NULL, 0, REMFNDESC_FLAGS_RET_INT, sizeof(bool), NULL },
|
---|
1313 | { "RTLogDefaultInstance", (void *)(uintptr_t)&RTLogDefaultInstance, NULL, 0, REMFNDESC_FLAGS_RET_INT, sizeof(PRTLOGGER), NULL },
|
---|
1314 | { "RTLogRelDefaultInstance", (void *)(uintptr_t)&RTLogRelDefaultInstance, NULL, 0, REMFNDESC_FLAGS_RET_INT, sizeof(PRTLOGGER), NULL },
|
---|
1315 | { "RTLogFlags", (void *)(uintptr_t)&RTLogFlags, &g_aArgsRTLogFlags[0], RT_ELEMENTS(g_aArgsRTLogFlags), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1316 | { "RTLogFlush", (void *)(uintptr_t)&RTLogFlush, &g_aArgsRTLogFlush[0], RT_ELEMENTS(g_aArgsRTLogFlush), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1317 | { "RTLogLoggerEx", (void *)(uintptr_t)&RTLogLoggerEx, &g_aArgsRTLogLoggerEx[0], RT_ELEMENTS(g_aArgsRTLogLoggerEx), REMFNDESC_FLAGS_RET_VOID | REMFNDESC_FLAGS_ELLIPSIS, 0, NULL },
|
---|
1318 | { "RTLogLoggerExV", (void *)(uintptr_t)&RTLogLoggerExV, &g_aArgsRTLogLoggerExV[0], RT_ELEMENTS(g_aArgsRTLogLoggerExV), REMFNDESC_FLAGS_RET_VOID | REMFNDESC_FLAGS_VALIST, 0, NULL },
|
---|
1319 | { "RTLogPrintf", (void *)(uintptr_t)&RTLogPrintf, &g_aArgsRTLogPrintf[0], RT_ELEMENTS(g_aArgsRTLogPrintf), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1320 | { "RTLogRelPrintf", (void *)(uintptr_t)&RTLogRelPrintf, &g_aArgsRTLogPrintf[0], RT_ELEMENTS(g_aArgsRTLogPrintf), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1321 | { "RTMemAllocTag", (void *)(uintptr_t)&RTMemAllocTag, &g_aArgsSIZE_TTag[0], RT_ELEMENTS(g_aArgsSIZE_TTag), REMFNDESC_FLAGS_RET_INT, sizeof(void *), NULL },
|
---|
1322 | { "RTMemAllocZTag", (void *)(uintptr_t)&RTMemAllocZTag, &g_aArgsSIZE_TTag[0], RT_ELEMENTS(g_aArgsSIZE_TTag), REMFNDESC_FLAGS_RET_INT, sizeof(void *), NULL },
|
---|
1323 | { "RTMemReallocTag", (void *)(uintptr_t)&RTMemReallocTag, &g_aArgsRTMemReallocTag[0], RT_ELEMENTS(g_aArgsRTMemReallocTag), REMFNDESC_FLAGS_RET_INT, sizeof(void *), NULL },
|
---|
1324 | { "RTMemExecAllocTag", (void *)(uintptr_t)&RTMemExecAllocTag, &g_aArgsSIZE_TTag[0], RT_ELEMENTS(g_aArgsSIZE_TTag), REMFNDESC_FLAGS_RET_INT, sizeof(void *), NULL },
|
---|
1325 | { "RTMemExecFree", (void *)(uintptr_t)&RTMemExecFree, &g_aArgsPTR_SIZE_T[0], RT_ELEMENTS(g_aArgsPTR_SIZE_T), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1326 | { "RTMemFree", (void *)(uintptr_t)&RTMemFree, &g_aArgsPTR[0], RT_ELEMENTS(g_aArgsPTR), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1327 | { "RTMemPageAllocTag", (void *)(uintptr_t)&RTMemPageAllocTag, &g_aArgsSIZE_TTag[0], RT_ELEMENTS(g_aArgsSIZE_TTag), REMFNDESC_FLAGS_RET_INT, sizeof(void *), NULL },
|
---|
1328 | { "RTMemPageFree", (void *)(uintptr_t)&RTMemPageFree, &g_aArgsPTR_SIZE_T[0], RT_ELEMENTS(g_aArgsPTR_SIZE_T), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
|
---|
1329 | { "RTMemProtect", (void *)(uintptr_t)&RTMemProtect, &g_aArgsRTMemProtect[0], RT_ELEMENTS(g_aArgsRTMemProtect), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
|
---|
1330 | { "RTStrPrintf", (void *)(uintptr_t)&RTStrPrintf, &g_aArgsRTStrPrintf[0], RT_ELEMENTS(g_aArgsRTStrPrintf), REMFNDESC_FLAGS_RET_INT | REMFNDESC_FLAGS_ELLIPSIS, sizeof(size_t), NULL },
|
---|
1331 | { "RTStrPrintfV", (void *)(uintptr_t)&RTStrPrintfV, &g_aArgsRTStrPrintfV[0], RT_ELEMENTS(g_aArgsRTStrPrintfV), REMFNDESC_FLAGS_RET_INT | REMFNDESC_FLAGS_VALIST, sizeof(size_t), NULL },
|
---|
1332 | { "RTThreadSelf", (void *)(uintptr_t)&RTThreadSelf, NULL, 0, REMFNDESC_FLAGS_RET_INT, sizeof(RTTHREAD), NULL },
|
---|
1333 | { "RTThreadNativeSelf", (void *)(uintptr_t)&RTThreadNativeSelf, NULL, 0, REMFNDESC_FLAGS_RET_INT, sizeof(RTNATIVETHREAD), NULL },
|
---|
1334 | { "RTLockValidatorWriteLockGetCount", (void *)(uintptr_t)&RTLockValidatorWriteLockGetCount, &g_aArgsThread[0], 0, REMFNDESC_FLAGS_RET_INT, sizeof(int32_t), NULL },
|
---|
1335 | };
|
---|
1336 |
|
---|
1337 |
|
---|
1338 | /**
|
---|
1339 | * Descriptors for the functions imported from VBoxRT.
|
---|
1340 | */
|
---|
1341 | static REMFNDESC g_aCRTImports[] =
|
---|
1342 | {
|
---|
1343 | { "memcpy", (void *)(uintptr_t)&memcpy, &g_aArgsmemcpy[0], RT_ELEMENTS(g_aArgsmemcpy), REMFNDESC_FLAGS_RET_INT, sizeof(void *), NULL },
|
---|
1344 | { "memset", (void *)(uintptr_t)&memset, &g_aArgsmemset[0], RT_ELEMENTS(g_aArgsmemset), REMFNDESC_FLAGS_RET_INT, sizeof(void *), NULL }
|
---|
1345 | /*
|
---|
1346 | floor floor
|
---|
1347 | memcpy memcpy
|
---|
1348 | sqrt sqrt
|
---|
1349 | sqrtf sqrtf
|
---|
1350 | */
|
---|
1351 | };
|
---|
1352 |
|
---|
1353 |
|
---|
1354 | # if defined(USE_REM_CALLING_CONVENTION_GLUE) || defined(USE_REM_IMPORT_JUMP_GLUE)
|
---|
1355 | /** LIFO of read-write-executable memory chunks used for wrappers. */
|
---|
1356 | static PREMEXECMEM g_pExecMemHead;
|
---|
1357 | # endif
|
---|
1358 | # endif /* !VBOX_USE_BITNESS_SELECTOR */
|
---|
1359 |
|
---|
1360 |
|
---|
1361 |
|
---|
1362 | /*******************************************************************************
|
---|
1363 | * Internal Functions *
|
---|
1364 | *******************************************************************************/
|
---|
1365 | # ifndef VBOX_USE_BITNESS_SELECTOR
|
---|
1366 | static int remGenerateExportGlue(PRTUINTPTR pValue, PCREMFNDESC pDesc);
|
---|
1367 |
|
---|
1368 | # ifdef USE_REM_CALLING_CONVENTION_GLUE
|
---|
1369 | DECLASM(int) WrapGCC2MSC0Int(void); DECLASM(int) WrapGCC2MSC0Int_EndProc(void);
|
---|
1370 | DECLASM(int) WrapGCC2MSC1Int(void); DECLASM(int) WrapGCC2MSC1Int_EndProc(void);
|
---|
1371 | DECLASM(int) WrapGCC2MSC2Int(void); DECLASM(int) WrapGCC2MSC2Int_EndProc(void);
|
---|
1372 | DECLASM(int) WrapGCC2MSC3Int(void); DECLASM(int) WrapGCC2MSC3Int_EndProc(void);
|
---|
1373 | DECLASM(int) WrapGCC2MSC4Int(void); DECLASM(int) WrapGCC2MSC4Int_EndProc(void);
|
---|
1374 | DECLASM(int) WrapGCC2MSC5Int(void); DECLASM(int) WrapGCC2MSC5Int_EndProc(void);
|
---|
1375 | DECLASM(int) WrapGCC2MSC6Int(void); DECLASM(int) WrapGCC2MSC6Int_EndProc(void);
|
---|
1376 | DECLASM(int) WrapGCC2MSC7Int(void); DECLASM(int) WrapGCC2MSC7Int_EndProc(void);
|
---|
1377 | DECLASM(int) WrapGCC2MSC8Int(void); DECLASM(int) WrapGCC2MSC8Int_EndProc(void);
|
---|
1378 | DECLASM(int) WrapGCC2MSC9Int(void); DECLASM(int) WrapGCC2MSC9Int_EndProc(void);
|
---|
1379 | DECLASM(int) WrapGCC2MSC10Int(void); DECLASM(int) WrapGCC2MSC10Int_EndProc(void);
|
---|
1380 | DECLASM(int) WrapGCC2MSC11Int(void); DECLASM(int) WrapGCC2MSC11Int_EndProc(void);
|
---|
1381 | DECLASM(int) WrapGCC2MSC12Int(void); DECLASM(int) WrapGCC2MSC12Int_EndProc(void);
|
---|
1382 | DECLASM(int) WrapGCC2MSCVariadictInt(void); DECLASM(int) WrapGCC2MSCVariadictInt_EndProc(void);
|
---|
1383 | DECLASM(int) WrapGCC2MSC_SSMR3RegisterInternal(void); DECLASM(int) WrapGCC2MSC_SSMR3RegisterInternal_EndProc(void);
|
---|
1384 |
|
---|
1385 | DECLASM(int) WrapMSC2GCC0Int(void); DECLASM(int) WrapMSC2GCC0Int_EndProc(void);
|
---|
1386 | DECLASM(int) WrapMSC2GCC1Int(void); DECLASM(int) WrapMSC2GCC1Int_EndProc(void);
|
---|
1387 | DECLASM(int) WrapMSC2GCC2Int(void); DECLASM(int) WrapMSC2GCC2Int_EndProc(void);
|
---|
1388 | DECLASM(int) WrapMSC2GCC3Int(void); DECLASM(int) WrapMSC2GCC3Int_EndProc(void);
|
---|
1389 | DECLASM(int) WrapMSC2GCC4Int(void); DECLASM(int) WrapMSC2GCC4Int_EndProc(void);
|
---|
1390 | DECLASM(int) WrapMSC2GCC5Int(void); DECLASM(int) WrapMSC2GCC5Int_EndProc(void);
|
---|
1391 | DECLASM(int) WrapMSC2GCC6Int(void); DECLASM(int) WrapMSC2GCC6Int_EndProc(void);
|
---|
1392 | DECLASM(int) WrapMSC2GCC7Int(void); DECLASM(int) WrapMSC2GCC7Int_EndProc(void);
|
---|
1393 | DECLASM(int) WrapMSC2GCC8Int(void); DECLASM(int) WrapMSC2GCC8Int_EndProc(void);
|
---|
1394 | DECLASM(int) WrapMSC2GCC9Int(void); DECLASM(int) WrapMSC2GCC9Int_EndProc(void);
|
---|
1395 | # endif
|
---|
1396 |
|
---|
1397 |
|
---|
1398 | # if defined(USE_REM_CALLING_CONVENTION_GLUE) || defined(USE_REM_IMPORT_JUMP_GLUE)
|
---|
1399 | /**
|
---|
1400 | * Allocates a block of memory for glue code.
|
---|
1401 | *
|
---|
1402 | * The returned memory is padded with INT3s.
|
---|
1403 | *
|
---|
1404 | * @returns Pointer to the allocated memory.
|
---|
1405 | * @param The amount of memory to allocate.
|
---|
1406 | */
|
---|
1407 | static void *remAllocGlue(size_t cb)
|
---|
1408 | {
|
---|
1409 | PREMEXECMEM pCur = g_pExecMemHead;
|
---|
1410 | uint32_t cbAligned = (uint32_t)RT_ALIGN_32(cb, 32);
|
---|
1411 | while (pCur)
|
---|
1412 | {
|
---|
1413 | if (pCur->cb - pCur->off >= cbAligned)
|
---|
1414 | {
|
---|
1415 | void *pv = (uint8_t *)pCur + pCur->off;
|
---|
1416 | pCur->off += cbAligned;
|
---|
1417 | return memset(pv, 0xcc, cbAligned);
|
---|
1418 | }
|
---|
1419 | pCur = pCur->pNext;
|
---|
1420 | }
|
---|
1421 |
|
---|
1422 | /* add a new chunk */
|
---|
1423 | AssertReturn(_64K - RT_ALIGN_Z(sizeof(*pCur), 32) > cbAligned, NULL);
|
---|
1424 | pCur = (PREMEXECMEM)RTMemExecAlloc(_64K);
|
---|
1425 | AssertReturn(pCur, NULL);
|
---|
1426 | pCur->cb = _64K;
|
---|
1427 | pCur->off = RT_ALIGN_32(sizeof(*pCur), 32) + cbAligned;
|
---|
1428 | pCur->pNext = g_pExecMemHead;
|
---|
1429 | g_pExecMemHead = pCur;
|
---|
1430 | return memset((uint8_t *)pCur + RT_ALIGN_Z(sizeof(*pCur), 32), 0xcc, cbAligned);
|
---|
1431 | }
|
---|
1432 | # endif /* USE_REM_CALLING_CONVENTION_GLUE || USE_REM_IMPORT_JUMP_GLUE */
|
---|
1433 |
|
---|
1434 |
|
---|
1435 | # ifdef USE_REM_CALLING_CONVENTION_GLUE
|
---|
1436 | /**
|
---|
1437 | * Checks if a function is all straight forward integers.
|
---|
1438 | *
|
---|
1439 | * @returns True if it's simple, false if it's bothersome.
|
---|
1440 | * @param pDesc The function descriptor.
|
---|
1441 | */
|
---|
1442 | static bool remIsFunctionAllInts(PCREMFNDESC pDesc)
|
---|
1443 | {
|
---|
1444 | if ( ( (pDesc->fFlags & REMFNDESC_FLAGS_RET_TYPE_MASK) != REMFNDESC_FLAGS_RET_INT
|
---|
1445 | || pDesc->cbReturn > sizeof(uint64_t))
|
---|
1446 | && (pDesc->fFlags & REMFNDESC_FLAGS_RET_TYPE_MASK) != REMFNDESC_FLAGS_RET_VOID)
|
---|
1447 | return false;
|
---|
1448 | unsigned i = pDesc->cParams;
|
---|
1449 | while (i-- > 0)
|
---|
1450 | switch (pDesc->paParams[i].fFlags & REMPARMDESC_FLAGS_TYPE_MASK)
|
---|
1451 | {
|
---|
1452 | case REMPARMDESC_FLAGS_INT:
|
---|
1453 | case REMPARMDESC_FLAGS_GCPTR:
|
---|
1454 | case REMPARMDESC_FLAGS_GCPHYS:
|
---|
1455 | case REMPARMDESC_FLAGS_HCPHYS:
|
---|
1456 | break;
|
---|
1457 |
|
---|
1458 | default:
|
---|
1459 | AssertReleaseMsgFailed(("Invalid param flags %#x for #%d of %s!\n", pDesc->paParams[i].fFlags, i, pDesc->pszName));
|
---|
1460 | case REMPARMDESC_FLAGS_VALIST:
|
---|
1461 | case REMPARMDESC_FLAGS_ELLIPSIS:
|
---|
1462 | case REMPARMDESC_FLAGS_FLOAT:
|
---|
1463 | case REMPARMDESC_FLAGS_STRUCT:
|
---|
1464 | case REMPARMDESC_FLAGS_PFN:
|
---|
1465 | return false;
|
---|
1466 | }
|
---|
1467 | return true;
|
---|
1468 | }
|
---|
1469 |
|
---|
1470 |
|
---|
1471 | /**
|
---|
1472 | * Checks if the function has an ellipsis (...) argument.
|
---|
1473 | *
|
---|
1474 | * @returns true if it has an ellipsis, otherwise false.
|
---|
1475 | * @param pDesc The function descriptor.
|
---|
1476 | */
|
---|
1477 | static bool remHasFunctionEllipsis(PCREMFNDESC pDesc)
|
---|
1478 | {
|
---|
1479 | unsigned i = pDesc->cParams;
|
---|
1480 | while (i-- > 0)
|
---|
1481 | if ((pDesc->paParams[i].fFlags & REMPARMDESC_FLAGS_TYPE_MASK) == REMPARMDESC_FLAGS_ELLIPSIS)
|
---|
1482 | return true;
|
---|
1483 | return false;
|
---|
1484 | }
|
---|
1485 |
|
---|
1486 |
|
---|
1487 | /**
|
---|
1488 | * Checks if the function uses floating point (FP) arguments or return value.
|
---|
1489 | *
|
---|
1490 | * @returns true if it uses floating point, otherwise false.
|
---|
1491 | * @param pDesc The function descriptor.
|
---|
1492 | */
|
---|
1493 | static bool remIsFunctionUsingFP(PCREMFNDESC pDesc)
|
---|
1494 | {
|
---|
1495 | if ((pDesc->fFlags & REMFNDESC_FLAGS_RET_TYPE_MASK) == REMFNDESC_FLAGS_RET_FLOAT)
|
---|
1496 | return true;
|
---|
1497 | unsigned i = pDesc->cParams;
|
---|
1498 | while (i-- > 0)
|
---|
1499 | if ((pDesc->paParams[i].fFlags & REMPARMDESC_FLAGS_TYPE_MASK) == REMPARMDESC_FLAGS_FLOAT)
|
---|
1500 | return true;
|
---|
1501 | return false;
|
---|
1502 | }
|
---|
1503 |
|
---|
1504 |
|
---|
1505 | /** @name The export and import fixups.
|
---|
1506 | * @{ */
|
---|
1507 | # define REM_FIXUP_32_REAL_STUFF UINT32_C(0xdeadbeef)
|
---|
1508 | # define REM_FIXUP_64_REAL_STUFF UINT64_C(0xdeadf00df00ddead)
|
---|
1509 | # define REM_FIXUP_64_DESC UINT64_C(0xdead00010001dead)
|
---|
1510 | # define REM_FIXUP_64_LOG_ENTRY UINT64_C(0xdead00020002dead)
|
---|
1511 | # define REM_FIXUP_64_LOG_EXIT UINT64_C(0xdead00030003dead)
|
---|
1512 | # define REM_FIXUP_64_WRAP_GCC_CB UINT64_C(0xdead00040004dead)
|
---|
1513 | /** @} */
|
---|
1514 |
|
---|
1515 |
|
---|
1516 | /**
|
---|
1517 | * Entry logger function.
|
---|
1518 | *
|
---|
1519 | * @param pDesc The description.
|
---|
1520 | */
|
---|
1521 | DECLASM(void) remLogEntry(PCREMFNDESC pDesc)
|
---|
1522 | {
|
---|
1523 | RTPrintf("calling %s\n", pDesc->pszName);
|
---|
1524 | }
|
---|
1525 |
|
---|
1526 |
|
---|
1527 | /**
|
---|
1528 | * Exit logger function.
|
---|
1529 | *
|
---|
1530 | * @param pDesc The description.
|
---|
1531 | * @param pvRet The return code.
|
---|
1532 | */
|
---|
1533 | DECLASM(void) remLogExit(PCREMFNDESC pDesc, void *pvRet)
|
---|
1534 | {
|
---|
1535 | RTPrintf("returning %p from %s\n", pvRet, pDesc->pszName);
|
---|
1536 | }
|
---|
1537 |
|
---|
1538 |
|
---|
1539 | /**
|
---|
1540 | * Creates a wrapper for the specified callback function at run time.
|
---|
1541 | *
|
---|
1542 | * @param pDesc The function descriptor.
|
---|
1543 | * @param pValue Upon entry *pValue contains the address of the function to be wrapped.
|
---|
1544 | * Upon return *pValue contains the address of the wrapper glue function.
|
---|
1545 | * @param iParam The parameter index in the function descriptor (0 based).
|
---|
1546 | * If UINT32_MAX pDesc is the descriptor for *pValue.
|
---|
1547 | */
|
---|
1548 | DECLASM(void) remWrapGCCCallback(PCREMFNDESC pDesc, PRTUINTPTR pValue, uint32_t iParam)
|
---|
1549 | {
|
---|
1550 | AssertPtr(pDesc);
|
---|
1551 | AssertPtr(pValue);
|
---|
1552 |
|
---|
1553 | /*
|
---|
1554 | * Simple?
|
---|
1555 | */
|
---|
1556 | if (!*pValue)
|
---|
1557 | return;
|
---|
1558 |
|
---|
1559 | /*
|
---|
1560 | * Locate the right function descriptor.
|
---|
1561 | */
|
---|
1562 | if (iParam != UINT32_MAX)
|
---|
1563 | {
|
---|
1564 | AssertRelease(iParam < pDesc->cParams);
|
---|
1565 | pDesc = (PCREMFNDESC)pDesc->paParams[iParam].pvExtra;
|
---|
1566 | AssertPtr(pDesc);
|
---|
1567 | }
|
---|
1568 |
|
---|
1569 | /*
|
---|
1570 | * When we get serious, here is where to insert the hash table lookup.
|
---|
1571 | */
|
---|
1572 |
|
---|
1573 | /*
|
---|
1574 | * Create a new glue patch.
|
---|
1575 | */
|
---|
1576 | # ifdef RT_OS_WINDOWS
|
---|
1577 | int rc = remGenerateExportGlue(pValue, pDesc);
|
---|
1578 | # else
|
---|
1579 | # error "port me"
|
---|
1580 | # endif
|
---|
1581 | AssertReleaseRC(rc);
|
---|
1582 |
|
---|
1583 | /*
|
---|
1584 | * Add it to the hash (later)
|
---|
1585 | */
|
---|
1586 | }
|
---|
1587 |
|
---|
1588 |
|
---|
1589 | /**
|
---|
1590 | * Fixes export glue.
|
---|
1591 | *
|
---|
1592 | * @param pvGlue The glue code.
|
---|
1593 | * @param cb The size of the glue code.
|
---|
1594 | * @param pvExport The address of the export we're wrapping.
|
---|
1595 | * @param pDesc The export descriptor.
|
---|
1596 | */
|
---|
1597 | static void remGenerateExportGlueFixup(void *pvGlue, size_t cb, uintptr_t uExport, PCREMFNDESC pDesc)
|
---|
1598 | {
|
---|
1599 | union
|
---|
1600 | {
|
---|
1601 | uint8_t *pu8;
|
---|
1602 | int32_t *pi32;
|
---|
1603 | uint32_t *pu32;
|
---|
1604 | uint64_t *pu64;
|
---|
1605 | void *pv;
|
---|
1606 | } u;
|
---|
1607 | u.pv = pvGlue;
|
---|
1608 |
|
---|
1609 | while (cb >= 4)
|
---|
1610 | {
|
---|
1611 | /** @todo add defines for the fixup constants... */
|
---|
1612 | if (*u.pu32 == REM_FIXUP_32_REAL_STUFF)
|
---|
1613 | {
|
---|
1614 | /* 32-bit rel jmp/call to real export. */
|
---|
1615 | *u.pi32 = uExport - (uintptr_t)(u.pi32 + 1);
|
---|
1616 | Assert((uintptr_t)(u.pi32 + 1) + *u.pi32 == uExport);
|
---|
1617 | u.pi32++;
|
---|
1618 | cb -= 4;
|
---|
1619 | continue;
|
---|
1620 | }
|
---|
1621 | if (cb >= 8 && *u.pu64 == REM_FIXUP_64_REAL_STUFF)
|
---|
1622 | {
|
---|
1623 | /* 64-bit address to the real export. */
|
---|
1624 | *u.pu64++ = uExport;
|
---|
1625 | cb -= 8;
|
---|
1626 | continue;
|
---|
1627 | }
|
---|
1628 | if (cb >= 8 && *u.pu64 == REM_FIXUP_64_DESC)
|
---|
1629 | {
|
---|
1630 | /* 64-bit address to the descriptor. */
|
---|
1631 | *u.pu64++ = (uintptr_t)pDesc;
|
---|
1632 | cb -= 8;
|
---|
1633 | continue;
|
---|
1634 | }
|
---|
1635 | if (cb >= 8 && *u.pu64 == REM_FIXUP_64_WRAP_GCC_CB)
|
---|
1636 | {
|
---|
1637 | /* 64-bit address to the entry logger function. */
|
---|
1638 | *u.pu64++ = (uintptr_t)remWrapGCCCallback;
|
---|
1639 | cb -= 8;
|
---|
1640 | continue;
|
---|
1641 | }
|
---|
1642 | if (cb >= 8 && *u.pu64 == REM_FIXUP_64_LOG_ENTRY)
|
---|
1643 | {
|
---|
1644 | /* 64-bit address to the entry logger function. */
|
---|
1645 | *u.pu64++ = (uintptr_t)remLogEntry;
|
---|
1646 | cb -= 8;
|
---|
1647 | continue;
|
---|
1648 | }
|
---|
1649 | if (cb >= 8 && *u.pu64 == REM_FIXUP_64_LOG_EXIT)
|
---|
1650 | {
|
---|
1651 | /* 64-bit address to the entry logger function. */
|
---|
1652 | *u.pu64++ = (uintptr_t)remLogExit;
|
---|
1653 | cb -= 8;
|
---|
1654 | continue;
|
---|
1655 | }
|
---|
1656 |
|
---|
1657 | /* move on. */
|
---|
1658 | u.pu8++;
|
---|
1659 | cb--;
|
---|
1660 | }
|
---|
1661 | }
|
---|
1662 |
|
---|
1663 |
|
---|
1664 | /**
|
---|
1665 | * Fixes import glue.
|
---|
1666 | *
|
---|
1667 | * @param pvGlue The glue code.
|
---|
1668 | * @param cb The size of the glue code.
|
---|
1669 | * @param pDesc The import descriptor.
|
---|
1670 | */
|
---|
1671 | static void remGenerateImportGlueFixup(void *pvGlue, size_t cb, PCREMFNDESC pDesc)
|
---|
1672 | {
|
---|
1673 | union
|
---|
1674 | {
|
---|
1675 | uint8_t *pu8;
|
---|
1676 | int32_t *pi32;
|
---|
1677 | uint32_t *pu32;
|
---|
1678 | uint64_t *pu64;
|
---|
1679 | void *pv;
|
---|
1680 | } u;
|
---|
1681 | u.pv = pvGlue;
|
---|
1682 |
|
---|
1683 | while (cb >= 4)
|
---|
1684 | {
|
---|
1685 | if (*u.pu32 == REM_FIXUP_32_REAL_STUFF)
|
---|
1686 | {
|
---|
1687 | /* 32-bit rel jmp/call to real function. */
|
---|
1688 | *u.pi32 = (uintptr_t)pDesc->pv - (uintptr_t)(u.pi32 + 1);
|
---|
1689 | Assert((uintptr_t)(u.pi32 + 1) + *u.pi32 == (uintptr_t)pDesc->pv);
|
---|
1690 | u.pi32++;
|
---|
1691 | cb -= 4;
|
---|
1692 | continue;
|
---|
1693 | }
|
---|
1694 | if (cb >= 8 && *u.pu64 == REM_FIXUP_64_REAL_STUFF)
|
---|
1695 | {
|
---|
1696 | /* 64-bit address to the real function. */
|
---|
1697 | *u.pu64++ = (uintptr_t)pDesc->pv;
|
---|
1698 | cb -= 8;
|
---|
1699 | continue;
|
---|
1700 | }
|
---|
1701 | if (cb >= 8 && *u.pu64 == REM_FIXUP_64_DESC)
|
---|
1702 | {
|
---|
1703 | /* 64-bit address to the descriptor. */
|
---|
1704 | *u.pu64++ = (uintptr_t)pDesc;
|
---|
1705 | cb -= 8;
|
---|
1706 | continue;
|
---|
1707 | }
|
---|
1708 | if (cb >= 8 && *u.pu64 == REM_FIXUP_64_WRAP_GCC_CB)
|
---|
1709 | {
|
---|
1710 | /* 64-bit address to the entry logger function. */
|
---|
1711 | *u.pu64++ = (uintptr_t)remWrapGCCCallback;
|
---|
1712 | cb -= 8;
|
---|
1713 | continue;
|
---|
1714 | }
|
---|
1715 | if (cb >= 8 && *u.pu64 == REM_FIXUP_64_LOG_ENTRY)
|
---|
1716 | {
|
---|
1717 | /* 64-bit address to the entry logger function. */
|
---|
1718 | *u.pu64++ = (uintptr_t)remLogEntry;
|
---|
1719 | cb -= 8;
|
---|
1720 | continue;
|
---|
1721 | }
|
---|
1722 | if (cb >= 8 && *u.pu64 == REM_FIXUP_64_LOG_EXIT)
|
---|
1723 | {
|
---|
1724 | /* 64-bit address to the entry logger function. */
|
---|
1725 | *u.pu64++ = (uintptr_t)remLogExit;
|
---|
1726 | cb -= 8;
|
---|
1727 | continue;
|
---|
1728 | }
|
---|
1729 |
|
---|
1730 | /* move on. */
|
---|
1731 | u.pu8++;
|
---|
1732 | cb--;
|
---|
1733 | }
|
---|
1734 | }
|
---|
1735 |
|
---|
1736 | # endif /* USE_REM_CALLING_CONVENTION_GLUE */
|
---|
1737 |
|
---|
1738 |
|
---|
1739 | /**
|
---|
1740 | * Generate wrapper glue code for an export.
|
---|
1741 | *
|
---|
1742 | * This is only used on win64 when loading a 64-bit linux module. So, on other
|
---|
1743 | * platforms it will not do anything.
|
---|
1744 | *
|
---|
1745 | * @returns VBox status code.
|
---|
1746 | * @param pValue IN: Where to get the address of the function to wrap.
|
---|
1747 | * OUT: Where to store the glue address.
|
---|
1748 | * @param pDesc The export descriptor.
|
---|
1749 | */
|
---|
1750 | static int remGenerateExportGlue(PRTUINTPTR pValue, PCREMFNDESC pDesc)
|
---|
1751 | {
|
---|
1752 | # ifdef USE_REM_CALLING_CONVENTION_GLUE
|
---|
1753 | uintptr_t *ppfn = (uintptr_t *)pDesc->pv;
|
---|
1754 |
|
---|
1755 | uintptr_t pfn = 0; /* a little hack for the callback glue */
|
---|
1756 | if (!ppfn)
|
---|
1757 | ppfn = &pfn;
|
---|
1758 |
|
---|
1759 | if (!*ppfn)
|
---|
1760 | {
|
---|
1761 | if (remIsFunctionAllInts(pDesc))
|
---|
1762 | {
|
---|
1763 | static const struct { void *pvStart, *pvEnd; } s_aTemplates[] =
|
---|
1764 | {
|
---|
1765 | { (void *)&WrapMSC2GCC0Int, (void *)&WrapMSC2GCC0Int_EndProc },
|
---|
1766 | { (void *)&WrapMSC2GCC1Int, (void *)&WrapMSC2GCC1Int_EndProc },
|
---|
1767 | { (void *)&WrapMSC2GCC2Int, (void *)&WrapMSC2GCC2Int_EndProc },
|
---|
1768 | { (void *)&WrapMSC2GCC3Int, (void *)&WrapMSC2GCC3Int_EndProc },
|
---|
1769 | { (void *)&WrapMSC2GCC4Int, (void *)&WrapMSC2GCC4Int_EndProc },
|
---|
1770 | { (void *)&WrapMSC2GCC5Int, (void *)&WrapMSC2GCC5Int_EndProc },
|
---|
1771 | { (void *)&WrapMSC2GCC6Int, (void *)&WrapMSC2GCC6Int_EndProc },
|
---|
1772 | { (void *)&WrapMSC2GCC7Int, (void *)&WrapMSC2GCC7Int_EndProc },
|
---|
1773 | { (void *)&WrapMSC2GCC8Int, (void *)&WrapMSC2GCC8Int_EndProc },
|
---|
1774 | { (void *)&WrapMSC2GCC9Int, (void *)&WrapMSC2GCC9Int_EndProc },
|
---|
1775 | };
|
---|
1776 | const unsigned i = pDesc->cParams;
|
---|
1777 | AssertReleaseMsg(i < RT_ELEMENTS(s_aTemplates), ("%d (%s)\n", i, pDesc->pszName));
|
---|
1778 |
|
---|
1779 | /* duplicate the patch. */
|
---|
1780 | const size_t cb = (uintptr_t)s_aTemplates[i].pvEnd - (uintptr_t)s_aTemplates[i].pvStart;
|
---|
1781 | uint8_t *pb = (uint8_t *)remAllocGlue(cb);
|
---|
1782 | AssertReturn(pb, VERR_NO_MEMORY);
|
---|
1783 | memcpy(pb, s_aTemplates[i].pvStart, cb);
|
---|
1784 |
|
---|
1785 | /* fix it up. */
|
---|
1786 | remGenerateExportGlueFixup(pb, cb, *pValue, pDesc);
|
---|
1787 | *ppfn = (uintptr_t)pb;
|
---|
1788 | }
|
---|
1789 | else
|
---|
1790 | {
|
---|
1791 | /* custom hacks - it's simpler to make assembly templates than writing a more generic code generator... */
|
---|
1792 | static const struct { const char *pszName; PFNRT pvStart, pvEnd; } s_aTemplates[] =
|
---|
1793 | {
|
---|
1794 | { "somefunction", (PFNRT)&WrapMSC2GCC9Int, (PFNRT)&WrapMSC2GCC9Int_EndProc },
|
---|
1795 | };
|
---|
1796 | unsigned i;
|
---|
1797 | for (i = 0; i < RT_ELEMENTS(s_aTemplates); i++)
|
---|
1798 | if (!strcmp(pDesc->pszName, s_aTemplates[i].pszName))
|
---|
1799 | break;
|
---|
1800 | AssertReleaseMsgReturn(i < RT_ELEMENTS(s_aTemplates), ("Not implemented! %s\n", pDesc->pszName), VERR_NOT_IMPLEMENTED);
|
---|
1801 |
|
---|
1802 | /* duplicate the patch. */
|
---|
1803 | const size_t cb = (uintptr_t)s_aTemplates[i].pvEnd - (uintptr_t)s_aTemplates[i].pvStart;
|
---|
1804 | uint8_t *pb = (uint8_t *)remAllocGlue(cb);
|
---|
1805 | AssertReturn(pb, VERR_NO_MEMORY);
|
---|
1806 | memcpy(pb, s_aTemplates[i].pvStart, cb);
|
---|
1807 |
|
---|
1808 | /* fix it up. */
|
---|
1809 | remGenerateExportGlueFixup(pb, cb, *pValue, pDesc);
|
---|
1810 | *ppfn = (uintptr_t)pb;
|
---|
1811 | }
|
---|
1812 | }
|
---|
1813 | *pValue = *ppfn;
|
---|
1814 | return VINF_SUCCESS;
|
---|
1815 | # else /* !USE_REM_CALLING_CONVENTION_GLUE */
|
---|
1816 | return VINF_SUCCESS;
|
---|
1817 | # endif /* !USE_REM_CALLING_CONVENTION_GLUE */
|
---|
1818 | }
|
---|
1819 |
|
---|
1820 |
|
---|
1821 | /**
|
---|
1822 | * Generate wrapper glue code for an import.
|
---|
1823 | *
|
---|
1824 | * This is only used on win64 when loading a 64-bit linux module. So, on other
|
---|
1825 | * platforms it will simply return the address of the imported function
|
---|
1826 | * without generating any glue code.
|
---|
1827 | *
|
---|
1828 | * @returns VBox status code.
|
---|
1829 | * @param pValue Where to store the glue address.
|
---|
1830 | * @param pDesc The export descriptor.
|
---|
1831 | */
|
---|
1832 | static int remGenerateImportGlue(PRTUINTPTR pValue, PREMFNDESC pDesc)
|
---|
1833 | {
|
---|
1834 | # if defined(USE_REM_CALLING_CONVENTION_GLUE) || defined(USE_REM_IMPORT_JUMP_GLUE)
|
---|
1835 | if (!pDesc->pvWrapper)
|
---|
1836 | {
|
---|
1837 | # ifdef USE_REM_CALLING_CONVENTION_GLUE
|
---|
1838 | if (remIsFunctionAllInts(pDesc))
|
---|
1839 | {
|
---|
1840 | static const struct { void *pvStart, *pvEnd; } s_aTemplates[] =
|
---|
1841 | {
|
---|
1842 | { (void *)&WrapGCC2MSC0Int, (void *)&WrapGCC2MSC0Int_EndProc },
|
---|
1843 | { (void *)&WrapGCC2MSC1Int, (void *)&WrapGCC2MSC1Int_EndProc },
|
---|
1844 | { (void *)&WrapGCC2MSC2Int, (void *)&WrapGCC2MSC2Int_EndProc },
|
---|
1845 | { (void *)&WrapGCC2MSC3Int, (void *)&WrapGCC2MSC3Int_EndProc },
|
---|
1846 | { (void *)&WrapGCC2MSC4Int, (void *)&WrapGCC2MSC4Int_EndProc },
|
---|
1847 | { (void *)&WrapGCC2MSC5Int, (void *)&WrapGCC2MSC5Int_EndProc },
|
---|
1848 | { (void *)&WrapGCC2MSC6Int, (void *)&WrapGCC2MSC6Int_EndProc },
|
---|
1849 | { (void *)&WrapGCC2MSC7Int, (void *)&WrapGCC2MSC7Int_EndProc },
|
---|
1850 | { (void *)&WrapGCC2MSC8Int, (void *)&WrapGCC2MSC8Int_EndProc },
|
---|
1851 | { (void *)&WrapGCC2MSC9Int, (void *)&WrapGCC2MSC9Int_EndProc },
|
---|
1852 | { (void *)&WrapGCC2MSC10Int, (void *)&WrapGCC2MSC10Int_EndProc },
|
---|
1853 | { (void *)&WrapGCC2MSC11Int, (void *)&WrapGCC2MSC11Int_EndProc },
|
---|
1854 | { (void *)&WrapGCC2MSC12Int, (void *)&WrapGCC2MSC12Int_EndProc }
|
---|
1855 | };
|
---|
1856 | const unsigned i = pDesc->cParams;
|
---|
1857 | AssertReleaseMsg(i < RT_ELEMENTS(s_aTemplates), ("%d (%s)\n", i, pDesc->pszName));
|
---|
1858 |
|
---|
1859 | /* duplicate the patch. */
|
---|
1860 | const size_t cb = (uintptr_t)s_aTemplates[i].pvEnd - (uintptr_t)s_aTemplates[i].pvStart;
|
---|
1861 | pDesc->pvWrapper = remAllocGlue(cb);
|
---|
1862 | AssertReturn(pDesc->pvWrapper, VERR_NO_MEMORY);
|
---|
1863 | memcpy(pDesc->pvWrapper, s_aTemplates[i].pvStart, cb);
|
---|
1864 |
|
---|
1865 | /* fix it up. */
|
---|
1866 | remGenerateImportGlueFixup((uint8_t *)pDesc->pvWrapper, cb, pDesc);
|
---|
1867 | }
|
---|
1868 | else if ( remHasFunctionEllipsis(pDesc)
|
---|
1869 | && !remIsFunctionUsingFP(pDesc))
|
---|
1870 | {
|
---|
1871 | /* duplicate the patch. */
|
---|
1872 | const size_t cb = (uintptr_t)&WrapGCC2MSCVariadictInt_EndProc - (uintptr_t)&WrapGCC2MSCVariadictInt;
|
---|
1873 | pDesc->pvWrapper = remAllocGlue(cb);
|
---|
1874 | AssertReturn(pDesc->pvWrapper, VERR_NO_MEMORY);
|
---|
1875 | memcpy(pDesc->pvWrapper, (void *)&WrapGCC2MSCVariadictInt, cb);
|
---|
1876 |
|
---|
1877 | /* fix it up. */
|
---|
1878 | remGenerateImportGlueFixup((uint8_t *)pDesc->pvWrapper, cb, pDesc);
|
---|
1879 | }
|
---|
1880 | else
|
---|
1881 | {
|
---|
1882 | /* custom hacks - it's simpler to make assembly templates than writing a more generic code generator... */
|
---|
1883 | static const struct { const char *pszName; PFNRT pvStart, pvEnd; } s_aTemplates[] =
|
---|
1884 | {
|
---|
1885 | { "SSMR3RegisterInternal", (PFNRT)&WrapGCC2MSC_SSMR3RegisterInternal, (PFNRT)&WrapGCC2MSC_SSMR3RegisterInternal_EndProc },
|
---|
1886 | };
|
---|
1887 | unsigned i;
|
---|
1888 | for (i = 0; i < RT_ELEMENTS(s_aTemplates); i++)
|
---|
1889 | if (!strcmp(pDesc->pszName, s_aTemplates[i].pszName))
|
---|
1890 | break;
|
---|
1891 | AssertReleaseMsgReturn(i < RT_ELEMENTS(s_aTemplates), ("Not implemented! %s\n", pDesc->pszName), VERR_NOT_IMPLEMENTED);
|
---|
1892 |
|
---|
1893 | /* duplicate the patch. */
|
---|
1894 | const size_t cb = (uintptr_t)s_aTemplates[i].pvEnd - (uintptr_t)s_aTemplates[i].pvStart;
|
---|
1895 | pDesc->pvWrapper = remAllocGlue(cb);
|
---|
1896 | AssertReturn(pDesc->pvWrapper, VERR_NO_MEMORY);
|
---|
1897 | memcpy(pDesc->pvWrapper, s_aTemplates[i].pvStart, cb);
|
---|
1898 |
|
---|
1899 | /* fix it up. */
|
---|
1900 | remGenerateImportGlueFixup((uint8_t *)pDesc->pvWrapper, cb, pDesc);
|
---|
1901 | }
|
---|
1902 | # else /* !USE_REM_CALLING_CONVENTION_GLUE */
|
---|
1903 |
|
---|
1904 | /*
|
---|
1905 | * Generate a jump patch.
|
---|
1906 | */
|
---|
1907 | uint8_t *pb;
|
---|
1908 | # ifdef RT_ARCH_AMD64
|
---|
1909 | pDesc->pvWrapper = pb = (uint8_t *)remAllocGlue(32);
|
---|
1910 | AssertReturn(pDesc->pvWrapper, VERR_NO_MEMORY);
|
---|
1911 | /**pb++ = 0xcc;*/
|
---|
1912 | *pb++ = 0xff;
|
---|
1913 | *pb++ = 0x24;
|
---|
1914 | *pb++ = 0x25;
|
---|
1915 | *(uint32_t *)pb = (uintptr_t)pb + 5;
|
---|
1916 | pb += 5;
|
---|
1917 | *(uint64_t *)pb = (uint64_t)pDesc->pv;
|
---|
1918 | # else
|
---|
1919 | pDesc->pvWrapper = pb = (uint8_t *)remAllocGlue(8);
|
---|
1920 | AssertReturn(pDesc->pvWrapper, VERR_NO_MEMORY);
|
---|
1921 | *pb++ = 0xea;
|
---|
1922 | *(uint32_t *)pb = (uint32_t)pDesc->pv;
|
---|
1923 | # endif
|
---|
1924 | # endif /* !USE_REM_CALLING_CONVENTION_GLUE */
|
---|
1925 | }
|
---|
1926 | *pValue = (uintptr_t)pDesc->pvWrapper;
|
---|
1927 | # else /* !USE_REM_CALLING_CONVENTION_GLUE */
|
---|
1928 | *pValue = (uintptr_t)pDesc->pv;
|
---|
1929 | # endif /* !USE_REM_CALLING_CONVENTION_GLUE */
|
---|
1930 | return VINF_SUCCESS;
|
---|
1931 | }
|
---|
1932 |
|
---|
1933 |
|
---|
1934 | /**
|
---|
1935 | * Resolve an external symbol during RTLdrGetBits().
|
---|
1936 | *
|
---|
1937 | * @returns iprt status code.
|
---|
1938 | * @param hLdrMod The loader module handle.
|
---|
1939 | * @param pszModule Module name.
|
---|
1940 | * @param pszSymbol Symbol name, NULL if uSymbol should be used.
|
---|
1941 | * @param uSymbol Symbol ordinal, ~0 if pszSymbol should be used.
|
---|
1942 | * @param pValue Where to store the symbol value (address).
|
---|
1943 | * @param pvUser User argument.
|
---|
1944 | */
|
---|
1945 | static DECLCALLBACK(int) remGetImport(RTLDRMOD hLdrMod, const char *pszModule, const char *pszSymbol, unsigned uSymbol, RTUINTPTR *pValue, void *pvUser)
|
---|
1946 | {
|
---|
1947 | unsigned i;
|
---|
1948 | for (i = 0; i < RT_ELEMENTS(g_aVMMImports); i++)
|
---|
1949 | if (!strcmp(g_aVMMImports[i].pszName, pszSymbol))
|
---|
1950 | return remGenerateImportGlue(pValue, &g_aVMMImports[i]);
|
---|
1951 | for (i = 0; i < RT_ELEMENTS(g_aRTImports); i++)
|
---|
1952 | if (!strcmp(g_aRTImports[i].pszName, pszSymbol))
|
---|
1953 | return remGenerateImportGlue(pValue, &g_aRTImports[i]);
|
---|
1954 | for (i = 0; i < RT_ELEMENTS(g_aCRTImports); i++)
|
---|
1955 | if (!strcmp(g_aCRTImports[i].pszName, pszSymbol))
|
---|
1956 | return remGenerateImportGlue(pValue, &g_aCRTImports[i]);
|
---|
1957 | LogRel(("Missing REM Import: %s\n", pszSymbol));
|
---|
1958 | # if 1
|
---|
1959 | *pValue = 0;
|
---|
1960 | AssertMsgFailed(("%s.%s\n", pszModule, pszSymbol));
|
---|
1961 | return VERR_SYMBOL_NOT_FOUND;
|
---|
1962 | # else
|
---|
1963 | return remGenerateImportGlue(pValue, &g_aCRTImports[0]);
|
---|
1964 | # endif
|
---|
1965 | }
|
---|
1966 |
|
---|
1967 | /**
|
---|
1968 | * Loads the linux object, resolves all imports and exports.
|
---|
1969 | *
|
---|
1970 | * @returns VBox status code.
|
---|
1971 | */
|
---|
1972 | static int remLoadLinuxObj(void)
|
---|
1973 | {
|
---|
1974 | size_t offFilename;
|
---|
1975 | char szPath[RTPATH_MAX];
|
---|
1976 | int rc = RTPathAppPrivateArch(szPath, sizeof(szPath) - 32);
|
---|
1977 | AssertRCReturn(rc, rc);
|
---|
1978 | offFilename = strlen(szPath);
|
---|
1979 |
|
---|
1980 | # ifdef VBOX_WITHOUT_REM_LDR_CYCLE
|
---|
1981 | /*
|
---|
1982 | * Resolve all the VBoxVMM references.
|
---|
1983 | */
|
---|
1984 | if (g_ModVMM != NIL_RTLDRMOD)
|
---|
1985 | {
|
---|
1986 | rc = SUPR3HardenedLdrLoadAppPriv("VBoxVMM", &g_ModVMM, RTLDRLOAD_FLAGS_LOCAL, NULL);
|
---|
1987 | AssertRCReturn(rc, rc);
|
---|
1988 | for (size_t i = 0; i < RT_ELEMENTS(g_aVMMImports); i++)
|
---|
1989 | {
|
---|
1990 | rc = RTLdrGetSymbol(g_ModVMM, g_aVMMImports[i].pszName, &g_aVMMImports[i].pv);
|
---|
1991 | AssertLogRelMsgRCReturn(rc, ("RTLdrGetSymbol(VBoxVMM,%s,) -> %Rrc\n", g_aVMMImports[i].pszName, rc), rc);
|
---|
1992 | }
|
---|
1993 | }
|
---|
1994 | # endif
|
---|
1995 |
|
---|
1996 | /*
|
---|
1997 | * Load the VBoxREM2.rel object/DLL.
|
---|
1998 | */
|
---|
1999 | strcpy(&szPath[offFilename], "/VBoxREM2.rel");
|
---|
2000 | rc = RTLdrOpen(szPath, 0, RTLDRARCH_HOST, &g_ModREM2);
|
---|
2001 | if (RT_SUCCESS(rc))
|
---|
2002 | {
|
---|
2003 | g_cbREM2 = RTLdrSize(g_ModREM2);
|
---|
2004 | g_pvREM2 = RTMemExecAlloc(g_cbREM2);
|
---|
2005 | if (g_pvREM2)
|
---|
2006 | {
|
---|
2007 | RTPathChangeToUnixSlashes(szPath, true);
|
---|
2008 | # ifdef DEBUG /* How to load the VBoxREM2.rel symbols into the GNU debugger. */
|
---|
2009 | RTPrintf("VBoxREMWrapper: (gdb) add-symbol-file %s 0x%p\n", szPath, g_pvREM2);
|
---|
2010 | # endif
|
---|
2011 | LogRel(("REM: Loading %s at 0x%p (%d bytes)\n"
|
---|
2012 | "REM: (gdb) add-symbol-file %s 0x%p\n",
|
---|
2013 | szPath, g_pvREM2, RTLdrSize(g_ModREM2), szPath, g_pvREM2));
|
---|
2014 | rc = RTLdrGetBits(g_ModREM2, g_pvREM2, (RTUINTPTR)g_pvREM2, remGetImport, NULL);
|
---|
2015 | if (RT_SUCCESS(rc))
|
---|
2016 | {
|
---|
2017 | /*
|
---|
2018 | * Resolve exports.
|
---|
2019 | */
|
---|
2020 | unsigned i;
|
---|
2021 | for (i = 0; i < RT_ELEMENTS(g_aExports); i++)
|
---|
2022 | {
|
---|
2023 | RTUINTPTR Value;
|
---|
2024 | rc = RTLdrGetSymbolEx(g_ModREM2, g_pvREM2, (RTUINTPTR)g_pvREM2, g_aExports[i].pszName, &Value);
|
---|
2025 | AssertMsgRC(rc, ("%s rc=%Rrc\n", g_aExports[i].pszName, rc));
|
---|
2026 | if (RT_FAILURE(rc))
|
---|
2027 | break;
|
---|
2028 | rc = remGenerateExportGlue(&Value, &g_aExports[i]);
|
---|
2029 | if (RT_FAILURE(rc))
|
---|
2030 | break;
|
---|
2031 | *(void **)g_aExports[i].pv = (void *)(uintptr_t)Value;
|
---|
2032 | }
|
---|
2033 | return rc;
|
---|
2034 | }
|
---|
2035 |
|
---|
2036 | RTMemExecFree(g_pvREM2, g_cbREM2);
|
---|
2037 | g_pvREM2 = NULL;
|
---|
2038 | }
|
---|
2039 | g_cbREM2 = 0;
|
---|
2040 | RTLdrClose(g_ModREM2);
|
---|
2041 | g_ModREM2 = NIL_RTLDRMOD;
|
---|
2042 | }
|
---|
2043 | LogRel(("REM: failed loading '%s', rc=%Rrc\n", szPath, rc));
|
---|
2044 | return rc;
|
---|
2045 | }
|
---|
2046 |
|
---|
2047 |
|
---|
2048 | /**
|
---|
2049 | * Unloads the linux object, freeing up all resources (dlls and
|
---|
2050 | * import glue) we allocated during remLoadLinuxObj().
|
---|
2051 | */
|
---|
2052 | static void remUnloadLinuxObj(void)
|
---|
2053 | {
|
---|
2054 | unsigned i;
|
---|
2055 |
|
---|
2056 | /* close modules. */
|
---|
2057 | RTLdrClose(g_ModREM2);
|
---|
2058 | g_ModREM2 = NIL_RTLDRMOD;
|
---|
2059 | RTMemExecFree(g_pvREM2, g_cbREM2);
|
---|
2060 | g_pvREM2 = NULL;
|
---|
2061 | g_cbREM2 = 0;
|
---|
2062 |
|
---|
2063 | /* clear the pointers. */
|
---|
2064 | for (i = 0; i < RT_ELEMENTS(g_aExports); i++)
|
---|
2065 | *(void **)g_aExports[i].pv = NULL;
|
---|
2066 | # if defined(USE_REM_CALLING_CONVENTION_GLUE) || defined(USE_REM_IMPORT_JUMP_GLUE)
|
---|
2067 | for (i = 0; i < RT_ELEMENTS(g_aVMMImports); i++)
|
---|
2068 | g_aVMMImports[i].pvWrapper = NULL;
|
---|
2069 | for (i = 0; i < RT_ELEMENTS(g_aRTImports); i++)
|
---|
2070 | g_aRTImports[i].pvWrapper = NULL;
|
---|
2071 | for (i = 0; i < RT_ELEMENTS(g_aCRTImports); i++)
|
---|
2072 | g_aCRTImports[i].pvWrapper = NULL;
|
---|
2073 |
|
---|
2074 | /* free wrapper memory. */
|
---|
2075 | while (g_pExecMemHead)
|
---|
2076 | {
|
---|
2077 | PREMEXECMEM pCur = g_pExecMemHead;
|
---|
2078 | g_pExecMemHead = pCur->pNext;
|
---|
2079 | memset(pCur, 0xcc, pCur->cb);
|
---|
2080 | RTMemExecFree(pCur, pCur->cb);
|
---|
2081 | }
|
---|
2082 | # endif
|
---|
2083 | }
|
---|
2084 |
|
---|
2085 | # else /* VBOX_USE_BITNESS_SELECTOR */
|
---|
2086 |
|
---|
2087 | /**
|
---|
2088 | * Checks if 64-bit support is enabled.
|
---|
2089 | *
|
---|
2090 | * @returns true / false.
|
---|
2091 | * @param pVM Pointer to the shared VM structure.
|
---|
2092 | */
|
---|
2093 | static bool remIs64bitEnabled(PVM pVM)
|
---|
2094 | {
|
---|
2095 | bool f;
|
---|
2096 | int rc;
|
---|
2097 |
|
---|
2098 | # ifdef VBOX_WITHOUT_REM_LDR_CYCLE
|
---|
2099 | if (g_ModVMM == NIL_RTLDRMOD)
|
---|
2100 | {
|
---|
2101 | rc = SUPR3HardenedLdrLoadAppPriv("VBoxVMM", &g_ModVMM, RTLDRLOAD_FLAGS_LOCAL, NULL);
|
---|
2102 | AssertRCReturn(rc, false);
|
---|
2103 | }
|
---|
2104 |
|
---|
2105 | DECLCALLBACKMEMBER(PCFGMNODE, pfnCFGMR3GetRoot)(PVM);
|
---|
2106 | rc = RTLdrGetSymbol(g_ModVMM, "CFGMR3GetRoot", (void **)&pfnCFGMR3GetRoot);
|
---|
2107 | AssertRCReturn(rc, false);
|
---|
2108 |
|
---|
2109 | DECLCALLBACKMEMBER(PCFGMNODE, pfnCFGMR3GetChild)(PCFGMNODE, const char *);
|
---|
2110 | rc = RTLdrGetSymbol(g_ModVMM, "CFGMR3GetChild", (void **)&pfnCFGMR3GetChild);
|
---|
2111 | AssertRCReturn(rc, false);
|
---|
2112 |
|
---|
2113 | DECLCALLBACKMEMBER(int, pfnCFGMR3QueryBoolDef)(PCFGMNODE, const char *, bool *, bool);
|
---|
2114 | rc = RTLdrGetSymbol(g_ModVMM, "CFGMR3QueryBoolDef", (void **)&pfnCFGMR3QueryBoolDef);
|
---|
2115 | AssertRCReturn(rc, false);
|
---|
2116 |
|
---|
2117 | rc = pfnCFGMR3QueryBoolDef(pfnCFGMR3GetChild(pfnCFGMR3GetRoot(pVM), "REM"), "64bitEnabled", &f, false);
|
---|
2118 | # else
|
---|
2119 | rc = CFGMR3QueryBoolDef(CFGMR3GetChild(CFGMR3GetRoot(pVM), "REM"), "64bitEnabled", &f, false);
|
---|
2120 | # endif
|
---|
2121 | AssertRCReturn(rc, false);
|
---|
2122 | return f;
|
---|
2123 | }
|
---|
2124 |
|
---|
2125 |
|
---|
2126 | /**
|
---|
2127 | * Loads real REM object, resolves all exports (imports are done by native loader).
|
---|
2128 | *
|
---|
2129 | * @returns VBox status code.
|
---|
2130 | */
|
---|
2131 | static int remLoadProperObj(PVM pVM)
|
---|
2132 | {
|
---|
2133 | /*
|
---|
2134 | * Load the VBoxREM32/64 object/DLL.
|
---|
2135 | */
|
---|
2136 | const char *pszModule = remIs64bitEnabled(pVM) ? "VBoxREM64" : "VBoxREM32";
|
---|
2137 | int rc = SUPR3HardenedLdrLoadAppPriv(pszModule, &g_ModREM2, RTLDRLOAD_FLAGS_LOCAL, NULL);
|
---|
2138 | if (RT_SUCCESS(rc))
|
---|
2139 | {
|
---|
2140 | LogRel(("REM: %s\n", pszModule));
|
---|
2141 |
|
---|
2142 | /*
|
---|
2143 | * Resolve exports.
|
---|
2144 | */
|
---|
2145 | unsigned i;
|
---|
2146 | for (i = 0; i < RT_ELEMENTS(g_aExports); i++)
|
---|
2147 | {
|
---|
2148 | void *pvValue;
|
---|
2149 | rc = RTLdrGetSymbol(g_ModREM2, g_aExports[i].pszName, &pvValue);
|
---|
2150 | AssertLogRelMsgRCBreak(rc, ("%s rc=%Rrc\n", g_aExports[i].pszName, rc));
|
---|
2151 | *(void **)g_aExports[i].pv = pvValue;
|
---|
2152 | }
|
---|
2153 | }
|
---|
2154 |
|
---|
2155 | return rc;
|
---|
2156 | }
|
---|
2157 |
|
---|
2158 |
|
---|
2159 | /**
|
---|
2160 | * Unloads the real REM object.
|
---|
2161 | */
|
---|
2162 | static void remUnloadProperObj(void)
|
---|
2163 | {
|
---|
2164 | /* close module. */
|
---|
2165 | RTLdrClose(g_ModREM2);
|
---|
2166 | g_ModREM2 = NIL_RTLDRMOD;
|
---|
2167 | }
|
---|
2168 |
|
---|
2169 | # endif /* VBOX_USE_BITNESS_SELECTOR */
|
---|
2170 | #endif /* USE_REM_STUBS */
|
---|
2171 |
|
---|
2172 | REMR3DECL(int) REMR3Init(PVM pVM)
|
---|
2173 | {
|
---|
2174 | #ifdef USE_REM_STUBS
|
---|
2175 | return VINF_SUCCESS;
|
---|
2176 |
|
---|
2177 | #elif defined(VBOX_USE_BITNESS_SELECTOR)
|
---|
2178 | if (!pfnREMR3Init)
|
---|
2179 | {
|
---|
2180 | int rc = remLoadProperObj(pVM);
|
---|
2181 | if (RT_FAILURE(rc))
|
---|
2182 | return rc;
|
---|
2183 | }
|
---|
2184 | return pfnREMR3Init(pVM);
|
---|
2185 |
|
---|
2186 | #else
|
---|
2187 | if (!pfnREMR3Init)
|
---|
2188 | {
|
---|
2189 | int rc = remLoadLinuxObj();
|
---|
2190 | if (RT_FAILURE(rc))
|
---|
2191 | return rc;
|
---|
2192 | }
|
---|
2193 | return pfnREMR3Init(pVM);
|
---|
2194 | #endif
|
---|
2195 | }
|
---|
2196 |
|
---|
2197 | REMR3DECL(int) REMR3InitFinalize(PVM pVM)
|
---|
2198 | {
|
---|
2199 | #ifndef USE_REM_STUBS
|
---|
2200 | Assert(VALID_PTR(pfnREMR3InitFinalize));
|
---|
2201 | return pfnREMR3InitFinalize(pVM);
|
---|
2202 | #endif
|
---|
2203 | }
|
---|
2204 |
|
---|
2205 | REMR3DECL(int) REMR3Term(PVM pVM)
|
---|
2206 | {
|
---|
2207 | #ifdef USE_REM_STUBS
|
---|
2208 | return VINF_SUCCESS;
|
---|
2209 |
|
---|
2210 | #elif defined(VBOX_USE_BITNESS_SELECTOR)
|
---|
2211 | int rc;
|
---|
2212 | Assert(VALID_PTR(pfnREMR3Term));
|
---|
2213 | rc = pfnREMR3Term(pVM);
|
---|
2214 | remUnloadProperObj();
|
---|
2215 | return rc;
|
---|
2216 |
|
---|
2217 | #else
|
---|
2218 | int rc;
|
---|
2219 | Assert(VALID_PTR(pfnREMR3Term));
|
---|
2220 | rc = pfnREMR3Term(pVM);
|
---|
2221 | remUnloadLinuxObj();
|
---|
2222 | return rc;
|
---|
2223 | #endif
|
---|
2224 | }
|
---|
2225 |
|
---|
2226 | REMR3DECL(void) REMR3Reset(PVM pVM)
|
---|
2227 | {
|
---|
2228 | #ifndef USE_REM_STUBS
|
---|
2229 | Assert(VALID_PTR(pfnREMR3Reset));
|
---|
2230 | pfnREMR3Reset(pVM);
|
---|
2231 | #endif
|
---|
2232 | }
|
---|
2233 |
|
---|
2234 | REMR3DECL(int) REMR3Step(PVM pVM, PVMCPU pVCpu)
|
---|
2235 | {
|
---|
2236 | #ifdef USE_REM_STUBS
|
---|
2237 | return VERR_NOT_IMPLEMENTED;
|
---|
2238 | #else
|
---|
2239 | Assert(VALID_PTR(pfnREMR3Step));
|
---|
2240 | return pfnREMR3Step(pVM, pVCpu);
|
---|
2241 | #endif
|
---|
2242 | }
|
---|
2243 |
|
---|
2244 | REMR3DECL(int) REMR3BreakpointSet(PVM pVM, RTGCUINTPTR Address)
|
---|
2245 | {
|
---|
2246 | #ifdef USE_REM_STUBS
|
---|
2247 | return VERR_REM_NO_MORE_BP_SLOTS;
|
---|
2248 | #else
|
---|
2249 | Assert(VALID_PTR(pfnREMR3BreakpointSet));
|
---|
2250 | return pfnREMR3BreakpointSet(pVM, Address);
|
---|
2251 | #endif
|
---|
2252 | }
|
---|
2253 |
|
---|
2254 | REMR3DECL(int) REMR3BreakpointClear(PVM pVM, RTGCUINTPTR Address)
|
---|
2255 | {
|
---|
2256 | #ifdef USE_REM_STUBS
|
---|
2257 | return VERR_NOT_IMPLEMENTED;
|
---|
2258 | #else
|
---|
2259 | Assert(VALID_PTR(pfnREMR3BreakpointClear));
|
---|
2260 | return pfnREMR3BreakpointClear(pVM, Address);
|
---|
2261 | #endif
|
---|
2262 | }
|
---|
2263 |
|
---|
2264 | REMR3DECL(int) REMR3EmulateInstruction(PVM pVM, PVMCPU pVCpu)
|
---|
2265 | {
|
---|
2266 | #ifdef USE_REM_STUBS
|
---|
2267 | return VERR_NOT_IMPLEMENTED;
|
---|
2268 | #else
|
---|
2269 | Assert(VALID_PTR(pfnREMR3EmulateInstruction));
|
---|
2270 | return pfnREMR3EmulateInstruction(pVM, pVCpu);
|
---|
2271 | #endif
|
---|
2272 | }
|
---|
2273 |
|
---|
2274 | REMR3DECL(int) REMR3Run(PVM pVM, PVMCPU pVCpu)
|
---|
2275 | {
|
---|
2276 | #ifdef USE_REM_STUBS
|
---|
2277 | return VERR_NOT_IMPLEMENTED;
|
---|
2278 | #else
|
---|
2279 | Assert(VALID_PTR(pfnREMR3Run));
|
---|
2280 | return pfnREMR3Run(pVM, pVCpu);
|
---|
2281 | #endif
|
---|
2282 | }
|
---|
2283 |
|
---|
2284 | REMR3DECL(int) REMR3State(PVM pVM, PVMCPU pVCpu)
|
---|
2285 | {
|
---|
2286 | #ifdef USE_REM_STUBS
|
---|
2287 | return VERR_NOT_IMPLEMENTED;
|
---|
2288 | #else
|
---|
2289 | Assert(VALID_PTR(pfnREMR3State));
|
---|
2290 | return pfnREMR3State(pVM, pVCpu);
|
---|
2291 | #endif
|
---|
2292 | }
|
---|
2293 |
|
---|
2294 | REMR3DECL(int) REMR3StateBack(PVM pVM, PVMCPU pVCpu)
|
---|
2295 | {
|
---|
2296 | #ifdef USE_REM_STUBS
|
---|
2297 | return VERR_NOT_IMPLEMENTED;
|
---|
2298 | #else
|
---|
2299 | Assert(VALID_PTR(pfnREMR3StateBack));
|
---|
2300 | return pfnREMR3StateBack(pVM, pVCpu);
|
---|
2301 | #endif
|
---|
2302 | }
|
---|
2303 |
|
---|
2304 | REMR3DECL(void) REMR3StateUpdate(PVM pVM, PVMCPU pVCpu)
|
---|
2305 | {
|
---|
2306 | #ifndef USE_REM_STUBS
|
---|
2307 | Assert(VALID_PTR(pfnREMR3StateUpdate));
|
---|
2308 | pfnREMR3StateUpdate(pVM, pVCpu);
|
---|
2309 | #endif
|
---|
2310 | }
|
---|
2311 |
|
---|
2312 | REMR3DECL(void) REMR3A20Set(PVM pVM, PVMCPU pVCpu, bool fEnable)
|
---|
2313 | {
|
---|
2314 | #ifndef USE_REM_STUBS
|
---|
2315 | Assert(VALID_PTR(pfnREMR3A20Set));
|
---|
2316 | pfnREMR3A20Set(pVM, pVCpu, fEnable);
|
---|
2317 | #endif
|
---|
2318 | }
|
---|
2319 |
|
---|
2320 | REMR3DECL(void) REMR3ReplayHandlerNotifications(PVM pVM)
|
---|
2321 | {
|
---|
2322 | #ifndef USE_REM_STUBS
|
---|
2323 | Assert(VALID_PTR(pfnREMR3ReplayHandlerNotifications));
|
---|
2324 | pfnREMR3ReplayHandlerNotifications(pVM);
|
---|
2325 | #endif
|
---|
2326 | }
|
---|
2327 |
|
---|
2328 | REMR3DECL(int) REMR3NotifyCodePageChanged(PVM pVM, PVMCPU pVCpu, RTGCPTR pvCodePage)
|
---|
2329 | {
|
---|
2330 | #ifdef USE_REM_STUBS
|
---|
2331 | return VINF_SUCCESS;
|
---|
2332 | #else
|
---|
2333 | Assert(VALID_PTR(pfnREMR3NotifyCodePageChanged));
|
---|
2334 | return pfnREMR3NotifyCodePageChanged(pVM, pVCpu, pvCodePage);
|
---|
2335 | #endif
|
---|
2336 | }
|
---|
2337 |
|
---|
2338 | REMR3DECL(void) REMR3NotifyPhysRamRegister(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS cb, unsigned fFlags)
|
---|
2339 | {
|
---|
2340 | #ifndef USE_REM_STUBS
|
---|
2341 | Assert(VALID_PTR(pfnREMR3NotifyPhysRamRegister));
|
---|
2342 | pfnREMR3NotifyPhysRamRegister(pVM, GCPhys, cb, fFlags);
|
---|
2343 | #endif
|
---|
2344 | }
|
---|
2345 |
|
---|
2346 | REMR3DECL(void) REMR3NotifyPhysRomRegister(PVM pVM, RTGCPHYS GCPhys, RTUINT cb, void *pvCopy, bool fShadow)
|
---|
2347 | {
|
---|
2348 | #ifndef USE_REM_STUBS
|
---|
2349 | Assert(VALID_PTR(pfnREMR3NotifyPhysRomRegister));
|
---|
2350 | pfnREMR3NotifyPhysRomRegister(pVM, GCPhys, cb, pvCopy, fShadow);
|
---|
2351 | #endif
|
---|
2352 | }
|
---|
2353 |
|
---|
2354 | REMR3DECL(void) REMR3NotifyPhysRamDeregister(PVM pVM, RTGCPHYS GCPhys, RTUINT cb)
|
---|
2355 | {
|
---|
2356 | #ifndef USE_REM_STUBS
|
---|
2357 | Assert(VALID_PTR(pfnREMR3NotifyPhysRamDeregister));
|
---|
2358 | pfnREMR3NotifyPhysRamDeregister(pVM, GCPhys, cb);
|
---|
2359 | #endif
|
---|
2360 | }
|
---|
2361 |
|
---|
2362 | REMR3DECL(void) REMR3NotifyHandlerPhysicalRegister(PVM pVM, PGMPHYSHANDLERTYPE enmType, RTGCPHYS GCPhys, RTGCPHYS cb, bool fHasHCHandler)
|
---|
2363 | {
|
---|
2364 | #ifndef USE_REM_STUBS
|
---|
2365 | Assert(VALID_PTR(pfnREMR3NotifyHandlerPhysicalRegister));
|
---|
2366 | pfnREMR3NotifyHandlerPhysicalRegister(pVM, enmType, GCPhys, cb, fHasHCHandler);
|
---|
2367 | #endif
|
---|
2368 | }
|
---|
2369 |
|
---|
2370 | REMR3DECL(void) REMR3NotifyHandlerPhysicalDeregister(PVM pVM, PGMPHYSHANDLERTYPE enmType, RTGCPHYS GCPhys, RTGCPHYS cb, bool fHasHCHandler, bool fRestoreAsRAM)
|
---|
2371 | {
|
---|
2372 | #ifndef USE_REM_STUBS
|
---|
2373 | Assert(VALID_PTR(pfnREMR3NotifyHandlerPhysicalDeregister));
|
---|
2374 | pfnREMR3NotifyHandlerPhysicalDeregister(pVM, enmType, GCPhys, cb, fHasHCHandler, fRestoreAsRAM);
|
---|
2375 | #endif
|
---|
2376 | }
|
---|
2377 |
|
---|
2378 | REMR3DECL(void) REMR3NotifyHandlerPhysicalModify(PVM pVM, PGMPHYSHANDLERTYPE enmType, RTGCPHYS GCPhysOld, RTGCPHYS GCPhysNew, RTGCPHYS cb, bool fHasHCHandler, bool fRestoreAsRAM)
|
---|
2379 | {
|
---|
2380 | #ifndef USE_REM_STUBS
|
---|
2381 | Assert(VALID_PTR(pfnREMR3NotifyHandlerPhysicalModify));
|
---|
2382 | pfnREMR3NotifyHandlerPhysicalModify(pVM, enmType, GCPhysOld, GCPhysNew, cb, fHasHCHandler, fRestoreAsRAM);
|
---|
2383 | #endif
|
---|
2384 | }
|
---|
2385 |
|
---|
2386 | REMR3DECL(bool) REMR3IsPageAccessHandled(PVM pVM, RTGCPHYS GCPhys)
|
---|
2387 | {
|
---|
2388 | #ifdef USE_REM_STUBS
|
---|
2389 | return false;
|
---|
2390 | #else
|
---|
2391 | Assert(VALID_PTR(pfnREMR3IsPageAccessHandled));
|
---|
2392 | return pfnREMR3IsPageAccessHandled(pVM, GCPhys);
|
---|
2393 | #endif
|
---|
2394 | }
|
---|
2395 |
|
---|
2396 | REMR3DECL(int) REMR3DisasEnableStepping(PVM pVM, bool fEnable)
|
---|
2397 | {
|
---|
2398 | #ifdef USE_REM_STUBS
|
---|
2399 | return VERR_NOT_IMPLEMENTED;
|
---|
2400 | #else
|
---|
2401 | Assert(VALID_PTR(pfnREMR3DisasEnableStepping));
|
---|
2402 | return pfnREMR3DisasEnableStepping(pVM, fEnable);
|
---|
2403 | #endif
|
---|
2404 | }
|
---|
2405 |
|
---|
2406 | REMR3DECL(void) REMR3NotifyPendingInterrupt(PVM pVM, PVMCPU pVCpu, uint8_t u8Interrupt)
|
---|
2407 | {
|
---|
2408 | #ifndef USE_REM_STUBS
|
---|
2409 | Assert(VALID_PTR(pfnREMR3NotifyPendingInterrupt));
|
---|
2410 | pfnREMR3NotifyPendingInterrupt(pVM, pVCpu, u8Interrupt);
|
---|
2411 | #endif
|
---|
2412 | }
|
---|
2413 |
|
---|
2414 | REMR3DECL(uint32_t) REMR3QueryPendingInterrupt(PVM pVM, PVMCPU pVCpu)
|
---|
2415 | {
|
---|
2416 | #ifdef USE_REM_STUBS
|
---|
2417 | return REM_NO_PENDING_IRQ;
|
---|
2418 | #else
|
---|
2419 | Assert(VALID_PTR(pfnREMR3QueryPendingInterrupt));
|
---|
2420 | return pfnREMR3QueryPendingInterrupt(pVM, pVCpu);
|
---|
2421 | #endif
|
---|
2422 | }
|
---|
2423 |
|
---|
2424 | REMR3DECL(void) REMR3NotifyInterruptSet(PVM pVM, PVMCPU pVCpu)
|
---|
2425 | {
|
---|
2426 | #ifndef USE_REM_STUBS
|
---|
2427 | Assert(VALID_PTR(pfnREMR3NotifyInterruptSet));
|
---|
2428 | pfnREMR3NotifyInterruptSet(pVM, pVCpu);
|
---|
2429 | #endif
|
---|
2430 | }
|
---|
2431 |
|
---|
2432 | REMR3DECL(void) REMR3NotifyInterruptClear(PVM pVM, PVMCPU pVCpu)
|
---|
2433 | {
|
---|
2434 | #ifndef USE_REM_STUBS
|
---|
2435 | Assert(VALID_PTR(pfnREMR3NotifyInterruptClear));
|
---|
2436 | pfnREMR3NotifyInterruptClear(pVM, pVCpu);
|
---|
2437 | #endif
|
---|
2438 | }
|
---|
2439 |
|
---|
2440 | REMR3DECL(void) REMR3NotifyTimerPending(PVM pVM, PVMCPU pVCpuDst)
|
---|
2441 | {
|
---|
2442 | #ifndef USE_REM_STUBS
|
---|
2443 | Assert(VALID_PTR(pfnREMR3NotifyTimerPending));
|
---|
2444 | pfnREMR3NotifyTimerPending(pVM, pVCpuDst);
|
---|
2445 | #endif
|
---|
2446 | }
|
---|
2447 |
|
---|
2448 | REMR3DECL(void) REMR3NotifyDmaPending(PVM pVM)
|
---|
2449 | {
|
---|
2450 | #ifndef USE_REM_STUBS
|
---|
2451 | Assert(VALID_PTR(pfnREMR3NotifyDmaPending));
|
---|
2452 | pfnREMR3NotifyDmaPending(pVM);
|
---|
2453 | #endif
|
---|
2454 | }
|
---|
2455 |
|
---|
2456 | REMR3DECL(void) REMR3NotifyQueuePending(PVM pVM)
|
---|
2457 | {
|
---|
2458 | #ifndef USE_REM_STUBS
|
---|
2459 | Assert(VALID_PTR(pfnREMR3NotifyQueuePending));
|
---|
2460 | pfnREMR3NotifyQueuePending(pVM);
|
---|
2461 | #endif
|
---|
2462 | }
|
---|
2463 |
|
---|
2464 | REMR3DECL(void) REMR3NotifyFF(PVM pVM)
|
---|
2465 | {
|
---|
2466 | #ifndef USE_REM_STUBS
|
---|
2467 | /* the timer can call this early on, so don't be picky. */
|
---|
2468 | if (pfnREMR3NotifyFF)
|
---|
2469 | pfnREMR3NotifyFF(pVM);
|
---|
2470 | #endif
|
---|
2471 | }
|
---|