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