SUPLib.cpp@ 104434

Last change on this file since 104434 was 104328, checked in by vboxsync, 8 months ago
SUPDrv: Belated bumping of the major I/O control interface version following the new parameter added to RTR0MemObjAllocCont. See r158085. [build fix] bugref:10457
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 85.2 KB

Line
1	/* $Id: SUPLib.cpp 104328 2024-04-12 21:00:17Z vboxsync $ */
2	/** @file
3	* VirtualBox Support Library - Common code.
4	*/
5
6	/*
7	* Copyright (C) 2006-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* The contents of this file may alternatively be used under the terms
26	* of the Common Development and Distribution License Version 1.0
27	* (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
28	* in the VirtualBox distribution, in which case the provisions of the
29	* CDDL are applicable instead of those of the GPL.
30	*
31	* You may elect to license modified versions of this file under the
32	* terms and conditions of either the GPL or the CDDL or both.
33	*
34	* SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
35	*/
36
37	/** @page pg_sup SUP - The Support Library
38	*
39	* The support library is responsible for providing facilities to load
40	* VMM Host Ring-0 code, to call Host VMM Ring-0 code from Ring-3 Host
41	* code, to pin down physical memory, and more.
42	*
43	* The VMM Host Ring-0 code can be combined in the support driver if
44	* permitted by kernel module license policies. If it is not combined
45	* it will be externalized in a .r0 module that will be loaded using
46	* the IPRT loader.
47	*
48	* The Ring-0 calling is done thru a generic SUP interface which will
49	* transfer an argument set and call a predefined entry point in the Host
50	* VMM Ring-0 code.
51	*
52	* See @ref grp_sup "SUP - Support APIs" for API details.
53	*/
54
55
56	/*********************************************************************************************************************************
57	* Header Files *
58	*********************************************************************************************************************************/
59	#define LOG_GROUP LOG_GROUP_SUP
60	#include <VBox/sup.h>
61	#include <VBox/err.h>
62	#include <VBox/param.h>
63	#include <VBox/log.h>
64	#include <VBox/VBoxTpG.h>
65
66	#include <iprt/assert.h>
67	#include <iprt/alloc.h>
68	#include <iprt/alloca.h>
69	#include <iprt/ldr.h>
70	#include <iprt/asm.h>
71	#include <iprt/mp.h>
72	#include <iprt/cpuset.h>
73	#include <iprt/thread.h>
74	#include <iprt/process.h>
75	#include <iprt/path.h>
76	#include <iprt/string.h>
77	#include <iprt/env.h>
78	#include <iprt/rand.h>
79	#include <iprt/x86.h>
80
81	#include "SUPDrvIOC.h"
82	#include "SUPLibInternal.h"
83
84
85	/*********************************************************************************************************************************
86	* Defined Constants And Macros *
87	*********************************************************************************************************************************/
88	/** R0 VMM module name. */
89	#define VMMR0_NAME "VMMR0"
90
91
92	/*********************************************************************************************************************************
93	* Structures and Typedefs *
94	*********************************************************************************************************************************/
95	typedef DECLCALLBACKTYPE(int, FNCALLVMMR0,(PVMR0 pVMR0, unsigned uOperation, void *pvArg));
96	typedef FNCALLVMMR0 *PFNCALLVMMR0;
97
98
99	/*********************************************************************************************************************************
100	* Global Variables *
101	*********************************************************************************************************************************/
102	/** Init counter. */
103	static uint32_t g_cInits = 0;
104	/** Whether we've been preinitied. */
105	static bool g_fPreInited = false;
106	/** The SUPLib instance data.
107	* Well, at least parts of it, specifically the parts that are being handed over
108	* via the pre-init mechanism from the hardened executable stub. */
109	DECL_HIDDEN_DATA(SUPLIBDATA) g_supLibData =
110	{
111	/.hDevice = / SUP_HDEVICE_NIL,
112	/.fUnrestricted = / true,
113	/.fDriverless = / false
114	#if defined(RT_OS_DARWIN)
115	,/* .uConnection = */ 0
116	#elif defined(RT_OS_LINUX)
117	,/* .fSysMadviseWorks = */ false
118	#endif
119	};
120
121	/** Pointer to the Global Information Page.
122	*
123	* This pointer is valid as long as SUPLib has a open session. Anyone using
124	* the page must treat this pointer as highly volatile and not trust it beyond
125	* one transaction.
126	*
127	* @todo This will probably deserve it's own session or some other good solution...
128	*/
129	DECLEXPORT(PSUPGLOBALINFOPAGE) g_pSUPGlobalInfoPage;
130	/** Address of the ring-0 mapping of the GIP. */
131	PSUPGLOBALINFOPAGE g_pSUPGlobalInfoPageR0;
132	/** The physical address of the GIP. */
133	static RTHCPHYS g_HCPhysSUPGlobalInfoPage = NIL_RTHCPHYS;
134
135	/** The negotiated cookie. */
136	DECL_HIDDEN_DATA(uint32_t) g_u32Cookie = 0;
137	/** The negotiated session cookie. */
138	DECL_HIDDEN_DATA(uint32_t) g_u32SessionCookie;
139	/** The session version. */
140	DECL_HIDDEN_DATA(uint32_t) g_uSupSessionVersion = 0;
141	/** Session handle. */
142	DECL_HIDDEN_DATA(PSUPDRVSESSION) g_pSession;
143	/** R0 SUP Functions used for resolving referenced to the SUPR0 module. */
144	DECL_HIDDEN_DATA(PSUPQUERYFUNCS) g_pSupFunctions;
145
146	/** PAGE_ALLOC_EX sans kernel mapping support indicator. */
147	static bool g_fSupportsPageAllocNoKernel = true;
148	/** Fake mode indicator. (~0 at first, 0 or 1 after first test) */
149	DECL_HIDDEN_DATA(uint32_t) g_uSupFakeMode = UINT32_MAX;
150
151
152	/*********************************************************************************************************************************
153	* Internal Functions *
154	*********************************************************************************************************************************/
155	static int supInitFake(PSUPDRVSESSION *ppSession);
156
157
158	/** Touch a range of pages. */
159	DECLINLINE(void) supR3TouchPages(void *pv, size_t cPages)
160	{
161	uint32_t volatile pu32 = (uint32_t volatile )pv;
162	while (cPages-- > 0)
163	{
164	ASMAtomicCmpXchgU32(pu32, 0, 0);
165	pu32 += PAGE_SIZE / sizeof(uint32_t);
166	}
167	}
168
169
170	SUPR3DECL(int) SUPR3Install(void)
171	{
172	return suplibOsInstall();
173	}
174
175
176	SUPR3DECL(int) SUPR3Uninstall(void)
177	{
178	return suplibOsUninstall();
179	}
180
181
182	DECL_NOTHROW(DECLEXPORT(int)) supR3PreInit(PSUPPREINITDATA pPreInitData, uint32_t fFlags)
183	{
184	/*
185	* The caller is kind of trustworthy, just perform some basic checks.
186	*
187	* Note! Do not do any fancy stuff here because IPRT has NOT been
188	* initialized at this point.
189	*/
190	if (!RT_VALID_PTR(pPreInitData))
191	return VERR_INVALID_POINTER;
192	if (g_fPreInited \|\| g_cInits > 0)
193	return VERR_WRONG_ORDER;
194
195	if ( pPreInitData->u32Magic != SUPPREINITDATA_MAGIC
196	\|\| pPreInitData->u32EndMagic != SUPPREINITDATA_MAGIC)
197	return VERR_INVALID_MAGIC;
198	if ( !(fFlags & SUPSECMAIN_FLAGS_DONT_OPEN_DEV)
199	&& pPreInitData->Data.hDevice == SUP_HDEVICE_NIL
200	&& !pPreInitData->Data.fDriverless)
201	return VERR_INVALID_HANDLE;
202	if ( ( (fFlags & SUPSECMAIN_FLAGS_DONT_OPEN_DEV)
203	\|\| pPreInitData->Data.fDriverless)
204	&& pPreInitData->Data.hDevice != SUP_HDEVICE_NIL)
205	return VERR_INVALID_PARAMETER;
206
207	/*
208	* Hand out the data.
209	*/
210	int rc = supR3HardenedRecvPreInitData(pPreInitData);
211	if (RT_FAILURE(rc))
212	return rc;
213
214	/** @todo This may need some small restructuring later, it doesn't quite work with a root service flag... */
215	if (!(fFlags & SUPSECMAIN_FLAGS_DONT_OPEN_DEV))
216	{
217	g_supLibData = pPreInitData->Data;
218	g_fPreInited = true;
219	}
220
221	return VINF_SUCCESS;
222	}
223
224
225	SUPR3DECL(int) SUPR3InitEx(uint32_t fFlags, PSUPDRVSESSION *ppSession)
226	{
227	/*
228	* Perform some sanity checks.
229	* (Got some trouble with compile time member alignment assertions.)
230	*/
231	Assert(!(RT_UOFFSETOF(SUPGLOBALINFOPAGE, u64NanoTSLastUpdateHz) & 0x7));
232	Assert(!(RT_UOFFSETOF(SUPGLOBALINFOPAGE, aCPUs) & 0x1f));
233	Assert(!(RT_UOFFSETOF(SUPGLOBALINFOPAGE, aCPUs[1]) & 0x1f));
234	Assert(!(RT_UOFFSETOF(SUPGLOBALINFOPAGE, aCPUs[0].u64NanoTS) & 0x7));
235	Assert(!(RT_UOFFSETOF(SUPGLOBALINFOPAGE, aCPUs[0].u64TSC) & 0x7));
236	Assert(!(RT_UOFFSETOF(SUPGLOBALINFOPAGE, aCPUs[0].u64CpuHz) & 0x7));
237
238	#ifdef VBOX_WITH_DRIVERLESS_FORCED
239	fFlags \|= SUPR3INIT_F_DRIVERLESS;
240	fFlags &= ~SUPR3INIT_F_UNRESTRICTED;
241	#endif
242
243	/*
244	* Check if already initialized.
245	*/
246	if (ppSession)
247	*ppSession = g_pSession;
248	if (g_cInits++ > 0)
249	{
250	if ( (fFlags & SUPR3INIT_F_UNRESTRICTED)
251	&& !g_supLibData.fUnrestricted
252	&& !g_supLibData.fDriverless)
253	{
254	g_cInits--;
255	if (ppSession)
256	*ppSession = NIL_RTR0PTR;
257	return VERR_VM_DRIVER_NOT_ACCESSIBLE; /** @todo different status code? */
258	}
259	return VINF_SUCCESS;
260	}
261
262	/*
263	* Check for fake mode.
264	*
265	* Fake mode is used when we're doing smoke testing and debugging.
266	* It's also useful on platforms where we haven't root access or which
267	* we haven't ported the support driver to.
268	*/
269	if (g_uSupFakeMode == ~0U)
270	{
271	const char *psz = RTEnvGet("VBOX_SUPLIB_FAKE");
272	if (psz && !strcmp(psz, "fake"))
273	ASMAtomicCmpXchgU32(&g_uSupFakeMode, 1, ~0U);
274	else
275	ASMAtomicCmpXchgU32(&g_uSupFakeMode, 0, ~0U);
276	}
277	if (RT_UNLIKELY(g_uSupFakeMode))
278	return supInitFake(ppSession);
279
280	/*
281	* Open the support driver.
282	*/
283	SUPINITOP enmWhat = kSupInitOp_Driver;
284	int rc = suplibOsInit(&g_supLibData, g_fPreInited, fFlags, &enmWhat, NULL);
285	if (RT_SUCCESS(rc) && !g_supLibData.fDriverless)
286	{
287	/*
288	* Negotiate the cookie.
289	*/
290	SUPCOOKIE CookieReq;
291	memset(&CookieReq, 0xff, sizeof(CookieReq));
292	CookieReq.Hdr.u32Cookie = SUPCOOKIE_INITIAL_COOKIE;
293	CookieReq.Hdr.u32SessionCookie = RTRandU32();
294	CookieReq.Hdr.cbIn = SUP_IOCTL_COOKIE_SIZE_IN;
295	CookieReq.Hdr.cbOut = SUP_IOCTL_COOKIE_SIZE_OUT;
296	CookieReq.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
297	CookieReq.Hdr.rc = VERR_INTERNAL_ERROR;
298	strcpy(CookieReq.u.In.szMagic, SUPCOOKIE_MAGIC);
299	CookieReq.u.In.u32ReqVersion = SUPDRV_IOC_VERSION;
300	const uint32_t uMinVersion = /*(SUPDRV_IOC_VERSION & 0xffff0000) == 0x00340000
301	? 0x00340000
302	: */ SUPDRV_IOC_VERSION & 0xffff0000;
303	CookieReq.u.In.u32MinVersion = uMinVersion;
304	rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_COOKIE, &CookieReq, SUP_IOCTL_COOKIE_SIZE);
305	if ( RT_SUCCESS(rc)
306	&& RT_SUCCESS(CookieReq.Hdr.rc))
307	{
308	g_uSupSessionVersion = CookieReq.u.Out.u32SessionVersion;
309	if ( (CookieReq.u.Out.u32SessionVersion & 0xffff0000) == (SUPDRV_IOC_VERSION & 0xffff0000)
310	&& CookieReq.u.Out.u32SessionVersion >= uMinVersion)
311	{
312	/*
313	* Query the functions.
314	*/
315	PSUPQUERYFUNCS pFuncsReq = NULL;
316	if (g_supLibData.fUnrestricted)
317	{
318	pFuncsReq = (PSUPQUERYFUNCS)RTMemAllocZ(SUP_IOCTL_QUERY_FUNCS_SIZE(CookieReq.u.Out.cFunctions));
319	if (pFuncsReq)
320	{
321	pFuncsReq->Hdr.u32Cookie = CookieReq.u.Out.u32Cookie;
322	pFuncsReq->Hdr.u32SessionCookie = CookieReq.u.Out.u32SessionCookie;
323	pFuncsReq->Hdr.cbIn = SUP_IOCTL_QUERY_FUNCS_SIZE_IN;
324	pFuncsReq->Hdr.cbOut = SUP_IOCTL_QUERY_FUNCS_SIZE_OUT(CookieReq.u.Out.cFunctions);
325	pFuncsReq->Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
326	pFuncsReq->Hdr.rc = VERR_INTERNAL_ERROR;
327	rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_QUERY_FUNCS(CookieReq.u.Out.cFunctions), pFuncsReq,
328	SUP_IOCTL_QUERY_FUNCS_SIZE(CookieReq.u.Out.cFunctions));
329	if (RT_SUCCESS(rc))
330	rc = pFuncsReq->Hdr.rc;
331	if (RT_SUCCESS(rc))
332	{
333	/*
334	* Map the GIP into userspace.
335	*/
336	Assert(!g_pSUPGlobalInfoPage);
337	SUPGIPMAP GipMapReq;
338	GipMapReq.Hdr.u32Cookie = CookieReq.u.Out.u32Cookie;
339	GipMapReq.Hdr.u32SessionCookie = CookieReq.u.Out.u32SessionCookie;
340	GipMapReq.Hdr.cbIn = SUP_IOCTL_GIP_MAP_SIZE_IN;
341	GipMapReq.Hdr.cbOut = SUP_IOCTL_GIP_MAP_SIZE_OUT;
342	GipMapReq.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
343	GipMapReq.Hdr.rc = VERR_INTERNAL_ERROR;
344	GipMapReq.u.Out.HCPhysGip = NIL_RTHCPHYS;
345	GipMapReq.u.Out.pGipR0 = NIL_RTR0PTR;
346	GipMapReq.u.Out.pGipR3 = NULL;
347	rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_GIP_MAP, &GipMapReq, SUP_IOCTL_GIP_MAP_SIZE);
348	if (RT_SUCCESS(rc))
349	rc = GipMapReq.Hdr.rc;
350	if (RT_SUCCESS(rc))
351	{
352	/*
353	* Set the GIP globals.
354	*/
355	AssertRelease(GipMapReq.u.Out.pGipR3->u32Magic == SUPGLOBALINFOPAGE_MAGIC);
356	AssertRelease(GipMapReq.u.Out.pGipR3->u32Version >= SUPGLOBALINFOPAGE_VERSION);
357
358	ASMAtomicXchgSize(&g_HCPhysSUPGlobalInfoPage, GipMapReq.u.Out.HCPhysGip);
359	ASMAtomicCmpXchgPtr((void * volatile *)&g_pSUPGlobalInfoPage, GipMapReq.u.Out.pGipR3, NULL);
360	ASMAtomicCmpXchgPtr((void * volatile )&g_pSUPGlobalInfoPageR0, (void )GipMapReq.u.Out.pGipR0, NULL);
361	}
362	}
363	}
364	else
365	rc = VERR_NO_MEMORY;
366	}
367
368	if (RT_SUCCESS(rc))
369	{
370	/*
371	* Set the globals and return success.
372	*/
373	g_u32Cookie = CookieReq.u.Out.u32Cookie;
374	g_u32SessionCookie = CookieReq.u.Out.u32SessionCookie;
375	g_pSession = CookieReq.u.Out.pSession;
376	g_pSupFunctions = pFuncsReq;
377	if (ppSession)
378	*ppSession = CookieReq.u.Out.pSession;
379	return VINF_SUCCESS;
380	}
381
382	/* bailout */
383	RTMemFree(pFuncsReq);
384	}
385	else
386	{
387	LogRel(("Support driver version mismatch: SessionVersion=%#x DriverVersion=%#x ClientVersion=%#x MinVersion=%#x\n",
388	CookieReq.u.Out.u32SessionVersion, CookieReq.u.Out.u32DriverVersion, SUPDRV_IOC_VERSION, uMinVersion));
389	rc = VERR_VM_DRIVER_VERSION_MISMATCH;
390	}
391	}
392	else
393	{
394	if (RT_SUCCESS(rc))
395	{
396	rc = CookieReq.Hdr.rc;
397	LogRel(("Support driver version mismatch: DriverVersion=%#x ClientVersion=%#x rc=%Rrc\n",
398	CookieReq.u.Out.u32DriverVersion, SUPDRV_IOC_VERSION, rc));
399	if (rc != VERR_VM_DRIVER_VERSION_MISMATCH)
400	rc = VERR_VM_DRIVER_VERSION_MISMATCH;
401	}
402	else
403	{
404	/* for pre 0x00060000 drivers */
405	LogRel(("Support driver version mismatch: DriverVersion=too-old ClientVersion=%#x\n", SUPDRV_IOC_VERSION));
406	rc = VERR_VM_DRIVER_VERSION_MISMATCH;
407	}
408	}
409
410	suplibOsTerm(&g_supLibData);
411	}
412	else if (RT_SUCCESS(rc))
413	{
414	/*
415	* Driverless initialization.
416	*/
417	Assert(fFlags & SUPR3INIT_F_DRIVERLESS_MASK);
418	LogRel(("SUP: In driverless mode.\n"));
419	return VINF_SUCCESS;
420	}
421
422	g_cInits--;
423
424	return rc;
425	}
426
427
428	SUPR3DECL(int) SUPR3Init(PSUPDRVSESSION *ppSession)
429	{
430	#ifndef VBOX_WITH_DRIVERLESS_FORCED
431	return SUPR3InitEx(SUPR3INIT_F_UNRESTRICTED, ppSession);
432	#else
433	return SUPR3InitEx(SUPR3INIT_F_DRIVERLESS, ppSession);
434	#endif
435	}
436
437	/**
438	* Fake mode init.
439	*/
440	static int supInitFake(PSUPDRVSESSION *ppSession)
441	{
442	Log(("SUP: Fake mode!\n"));
443	static const SUPFUNC s_aFakeFunctions[] =
444	{
445	/* name 0, function */
446	{ "SUPR0AbsIs64bit", 0, 0 },
447	{ "SUPR0Abs64bitKernelCS", 0, 0 },
448	{ "SUPR0Abs64bitKernelSS", 0, 0 },
449	{ "SUPR0Abs64bitKernelDS", 0, 0 },
450	{ "SUPR0AbsKernelCS", 0, 8 },
451	{ "SUPR0AbsKernelSS", 0, 16 },
452	{ "SUPR0AbsKernelDS", 0, 16 },
453	{ "SUPR0AbsKernelES", 0, 16 },
454	{ "SUPR0AbsKernelFS", 0, 24 },
455	{ "SUPR0AbsKernelGS", 0, 32 },
456	{ "SUPR0ComponentRegisterFactory", 0, 0xefeefffd },
457	{ "SUPR0ComponentDeregisterFactory", 0, 0xefeefffe },
458	{ "SUPR0ComponentQueryFactory", 0, 0xefeeffff },
459	{ "SUPR0ObjRegister", 0, 0xefef0000 },
460	{ "SUPR0ObjAddRef", 0, 0xefef0001 },
461	{ "SUPR0ObjAddRefEx", 0, 0xefef0001 },
462	{ "SUPR0ObjRelease", 0, 0xefef0002 },
463	{ "SUPR0ObjVerifyAccess", 0, 0xefef0003 },
464	{ "SUPR0LockMem", 0, 0xefef0004 },
465	{ "SUPR0UnlockMem", 0, 0xefef0005 },
466	{ "SUPR0ContAlloc", 0, 0xefef0006 },
467	{ "SUPR0ContFree", 0, 0xefef0007 },
468	{ "SUPR0MemAlloc", 0, 0xefef0008 },
469	{ "SUPR0MemGetPhys", 0, 0xefef0009 },
470	{ "SUPR0MemFree", 0, 0xefef000a },
471	{ "SUPR0Printf", 0, 0xefef000b },
472	{ "SUPR0GetPagingMode", 0, 0xefef000c },
473	{ "SUPR0EnableVTx", 0, 0xefef000e },
474	{ "RTMemAlloc", 0, 0xefef000f },
475	{ "RTMemAllocZ", 0, 0xefef0010 },
476	{ "RTMemFree", 0, 0xefef0011 },
477	{ "RTR0MemObjAddress", 0, 0xefef0012 },
478	{ "RTR0MemObjAddressR3", 0, 0xefef0013 },
479	{ "RTR0MemObjAllocPage", 0, 0xefef0014 },
480	{ "RTR0MemObjAllocPhysNC", 0, 0xefef0015 },
481	{ "RTR0MemObjAllocLow", 0, 0xefef0016 },
482	{ "RTR0MemObjEnterPhys", 0, 0xefef0017 },
483	{ "RTR0MemObjFree", 0, 0xefef0018 },
484	{ "RTR0MemObjGetPagePhysAddr", 0, 0xefef0019 },
485	{ "RTR0MemObjMapUser", 0, 0xefef001a },
486	{ "RTR0MemObjMapKernel", 0, 0xefef001b },
487	{ "RTR0MemObjMapKernelEx", 0, 0xefef001c },
488	{ "RTMpGetArraySize", 0, 0xefef001c },
489	{ "RTProcSelf", 0, 0xefef001d },
490	{ "RTR0ProcHandleSelf", 0, 0xefef001e },
491	{ "RTSemEventCreate", 0, 0xefef001f },
492	{ "RTSemEventSignal", 0, 0xefef0020 },
493	{ "RTSemEventWait", 0, 0xefef0021 },
494	{ "RTSemEventWaitNoResume", 0, 0xefef0022 },
495	{ "RTSemEventDestroy", 0, 0xefef0023 },
496	{ "RTSemEventMultiCreate", 0, 0xefef0024 },
497	{ "RTSemEventMultiSignal", 0, 0xefef0025 },
498	{ "RTSemEventMultiReset", 0, 0xefef0026 },
499	{ "RTSemEventMultiWait", 0, 0xefef0027 },
500	{ "RTSemEventMultiWaitNoResume", 0, 0xefef0028 },
501	{ "RTSemEventMultiDestroy", 0, 0xefef0029 },
502	{ "RTSemFastMutexCreate", 0, 0xefef002a },
503	{ "RTSemFastMutexDestroy", 0, 0xefef002b },
504	{ "RTSemFastMutexRequest", 0, 0xefef002c },
505	{ "RTSemFastMutexRelease", 0, 0xefef002d },
506	{ "RTSpinlockCreate", 0, 0xefef002e },
507	{ "RTSpinlockDestroy", 0, 0xefef002f },
508	{ "RTSpinlockAcquire", 0, 0xefef0030 },
509	{ "RTSpinlockRelease", 0, 0xefef0031 },
510	{ "RTSpinlockAcquireNoInts", 0, 0xefef0032 },
511	{ "RTTimeNanoTS", 0, 0xefef0034 },
512	{ "RTTimeMillieTS", 0, 0xefef0035 },
513	{ "RTTimeSystemNanoTS", 0, 0xefef0036 },
514	{ "RTTimeSystemMillieTS", 0, 0xefef0037 },
515	{ "RTThreadNativeSelf", 0, 0xefef0038 },
516	{ "RTThreadSleep", 0, 0xefef0039 },
517	{ "RTThreadYield", 0, 0xefef003a },
518	{ "RTTimerCreate", 0, 0xefef003a },
519	{ "RTTimerCreateEx", 0, 0xefef003a },
520	{ "RTTimerDestroy", 0, 0xefef003a },
521	{ "RTTimerStart", 0, 0xefef003a },
522	{ "RTTimerStop", 0, 0xefef003a },
523	{ "RTTimerChangeInterval", 0, 0xefef003a },
524	{ "RTTimerGetSystemGranularity", 0, 0xefef003a },
525	{ "RTTimerRequestSystemGranularity", 0, 0xefef003a },
526	{ "RTTimerReleaseSystemGranularity", 0, 0xefef003a },
527	{ "RTTimerCanDoHighResolution", 0, 0xefef003a },
528	{ "RTLogDefaultInstance", 0, 0xefef003b },
529	{ "RTLogRelGetDefaultInstance", 0, 0xefef003c },
530	{ "RTLogSetDefaultInstanceThread", 0, 0xefef003d },
531	{ "RTLogLogger", 0, 0xefef003e },
532	{ "RTLogLoggerEx", 0, 0xefef003f },
533	{ "RTLogLoggerExV", 0, 0xefef0040 },
534	{ "RTAssertMsg1", 0, 0xefef0041 },
535	{ "RTAssertMsg2", 0, 0xefef0042 },
536	{ "RTAssertMsg2V", 0, 0xefef0043 },
537	{ "SUPR0QueryVTCaps", 0, 0xefef0044 },
538	};
539
540	/* fake r0 functions. */
541	g_pSupFunctions = (PSUPQUERYFUNCS)RTMemAllocZ(SUP_IOCTL_QUERY_FUNCS_SIZE(RT_ELEMENTS(s_aFakeFunctions)));
542	if (g_pSupFunctions)
543	{
544	g_pSupFunctions->u.Out.cFunctions = RT_ELEMENTS(s_aFakeFunctions);
545	memcpy(&g_pSupFunctions->u.Out.aFunctions[0], &s_aFakeFunctions[0], sizeof(s_aFakeFunctions));
546	g_pSession = (PSUPDRVSESSION)(void *)g_pSupFunctions;
547	if (ppSession)
548	*ppSession = g_pSession;
549
550	/* fake the GIP. */
551	g_pSUPGlobalInfoPage = (PSUPGLOBALINFOPAGE)RTMemPageAllocZ(PAGE_SIZE);
552	if (g_pSUPGlobalInfoPage)
553	{
554	g_pSUPGlobalInfoPageR0 = g_pSUPGlobalInfoPage;
555	g_HCPhysSUPGlobalInfoPage = NIL_RTHCPHYS & ~(RTHCPHYS)PAGE_OFFSET_MASK;
556	/* the page is supposed to be invalid, so don't set the magic. */
557	return VINF_SUCCESS;
558	}
559
560	RTMemFree(g_pSupFunctions);
561	g_pSupFunctions = NULL;
562	}
563	return VERR_NO_MEMORY;
564	}
565
566
567	SUPR3DECL(int) SUPR3Term(bool fForced)
568	{
569	/*
570	* Verify state.
571	*/
572	AssertMsg(g_cInits > 0, ("SUPR3Term() is called before SUPR3Init()!\n"));
573	if (g_cInits == 0)
574	return VERR_WRONG_ORDER;
575	if (g_cInits == 1 \|\| fForced)
576	{
577	/*
578	* NULL the GIP pointer.
579	*/
580	if (g_pSUPGlobalInfoPage)
581	{
582	ASMAtomicWriteNullPtr((void * volatile *)&g_pSUPGlobalInfoPage);
583	ASMAtomicWriteNullPtr((void * volatile *)&g_pSUPGlobalInfoPageR0);
584	ASMAtomicWriteU64(&g_HCPhysSUPGlobalInfoPage, NIL_RTHCPHYS);
585	/* just a little safe guard against threads using the page. */
586	RTThreadSleep(50);
587	}
588
589	/*
590	* Close the support driver.
591	*/
592	int rc = suplibOsTerm(&g_supLibData);
593	if (rc)
594	return rc;
595
596	g_supLibData.hDevice = SUP_HDEVICE_NIL;
597	g_supLibData.fUnrestricted = true;
598	g_supLibData.fDriverless = false;
599	g_u32Cookie = 0;
600	g_u32SessionCookie = 0;
601	g_cInits = 0;
602	}
603	else
604	g_cInits--;
605
606	return 0;
607	}
608
609
610	SUPR3DECL(bool) SUPR3IsDriverless(void)
611	{
612	/* Assert(g_cInits > 0); - tstSSM does not initialize SUP, but SSM calls to
613	check status, so return driverless if not initialized. */
614	return g_supLibData.fDriverless \|\| g_cInits == 0;
615	}
616
617
618	SUPR3DECL(SUPPAGINGMODE) SUPR3GetPagingMode(void)
619	{
620	/*
621	* Deal with driverless first.
622	*/
623	if (g_supLibData.fDriverless)
624	#if defined(RT_ARCH_AMD64)
625	return SUPPAGINGMODE_AMD64_GLOBAL_NX;
626	#elif defined(RT_ARCH_X86)
627	return SUPPAGINGMODE_32_BIT_GLOBAL;
628	#else
629	return SUPPAGINGMODE_INVALID;
630	#endif
631
632	/*
633	* Issue IOCtl to the SUPDRV kernel module.
634	*/
635	SUPGETPAGINGMODE Req;
636	Req.Hdr.u32Cookie = g_u32Cookie;
637	Req.Hdr.u32SessionCookie = g_u32SessionCookie;
638	Req.Hdr.cbIn = SUP_IOCTL_GET_PAGING_MODE_SIZE_IN;
639	Req.Hdr.cbOut = SUP_IOCTL_GET_PAGING_MODE_SIZE_OUT;
640	Req.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
641	Req.Hdr.rc = VERR_INTERNAL_ERROR;
642	int rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_GET_PAGING_MODE, &Req, SUP_IOCTL_GET_PAGING_MODE_SIZE);
643	if ( RT_FAILURE(rc)
644	\|\| RT_FAILURE(Req.Hdr.rc))
645	{
646	LogRel(("SUPR3GetPagingMode: %Rrc %Rrc\n", rc, Req.Hdr.rc));
647	Req.u.Out.enmMode = SUPPAGINGMODE_INVALID;
648	}
649
650	return Req.u.Out.enmMode;
651	}
652
653
654	/**
655	* For later.
656	*/
657	static int supCallVMMR0ExFake(PVMR0 pVMR0, unsigned uOperation, uint64_t u64Arg, PSUPVMMR0REQHDR pReqHdr)
658	{
659	AssertMsgFailed(("%d\n", uOperation)); NOREF(pVMR0); NOREF(uOperation); NOREF(u64Arg); NOREF(pReqHdr);
660	return VERR_NOT_SUPPORTED;
661	}
662
663
664	SUPR3DECL(int) SUPR3CallVMMR0Fast(PVMR0 pVMR0, unsigned uOperation, VMCPUID idCpu)
665	{
666	NOREF(pVMR0);
667	static const uintptr_t s_auFunctions[3] =
668	{
669	SUP_IOCTL_FAST_DO_HM_RUN,
670	SUP_IOCTL_FAST_DO_NEM_RUN,
671	SUP_IOCTL_FAST_DO_NOP,
672	};
673	AssertCompile(SUP_VMMR0_DO_HM_RUN == 0);
674	AssertCompile(SUP_VMMR0_DO_NEM_RUN == 1);
675	AssertCompile(SUP_VMMR0_DO_NOP == 2);
676	AssertMsgReturn(uOperation < RT_ELEMENTS(s_auFunctions), ("%#x\n", uOperation), VERR_INTERNAL_ERROR);
677	return suplibOsIOCtlFast(&g_supLibData, s_auFunctions[uOperation], idCpu);
678	}
679
680
681	SUPR3DECL(int) SUPR3CallVMMR0Ex(PVMR0 pVMR0, VMCPUID idCpu, unsigned uOperation, uint64_t u64Arg, PSUPVMMR0REQHDR pReqHdr)
682	{
683	/*
684	* The following operations don't belong here.
685	*/
686	AssertMsgReturn( uOperation != SUP_VMMR0_DO_HM_RUN
687	&& uOperation != SUP_VMMR0_DO_NEM_RUN
688	&& uOperation != SUP_VMMR0_DO_NOP,
689	("%#x\n", uOperation),
690	VERR_INTERNAL_ERROR);
691
692	/* fake */
693	if (RT_UNLIKELY(g_uSupFakeMode))
694	return supCallVMMR0ExFake(pVMR0, uOperation, u64Arg, pReqHdr);
695
696	int rc;
697	if (!pReqHdr)
698	{
699	/* no data. */
700	SUPCALLVMMR0 Req;
701	Req.Hdr.u32Cookie = g_u32Cookie;
702	Req.Hdr.u32SessionCookie = g_u32SessionCookie;
703	Req.Hdr.cbIn = SUP_IOCTL_CALL_VMMR0_SIZE_IN(0);
704	Req.Hdr.cbOut = SUP_IOCTL_CALL_VMMR0_SIZE_OUT(0);
705	Req.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
706	Req.Hdr.rc = VERR_INTERNAL_ERROR;
707	Req.u.In.pVMR0 = pVMR0;
708	Req.u.In.idCpu = idCpu;
709	Req.u.In.uOperation = uOperation;
710	Req.u.In.u64Arg = u64Arg;
711	rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_CALL_VMMR0(0), &Req, SUP_IOCTL_CALL_VMMR0_SIZE(0));
712	if (RT_SUCCESS(rc))
713	rc = Req.Hdr.rc;
714	}
715	else if (SUP_IOCTL_CALL_VMMR0_SIZE(pReqHdr->cbReq) < _4K) /* FreeBSD won't copy more than 4K. */
716	{
717	AssertPtrReturn(pReqHdr, VERR_INVALID_POINTER);
718	AssertReturn(pReqHdr->u32Magic == SUPVMMR0REQHDR_MAGIC, VERR_INVALID_MAGIC);
719	const size_t cbReq = pReqHdr->cbReq;
720
721	PSUPCALLVMMR0 pReq = (PSUPCALLVMMR0)alloca(SUP_IOCTL_CALL_VMMR0_SIZE(cbReq));
722	pReq->Hdr.u32Cookie = g_u32Cookie;
723	pReq->Hdr.u32SessionCookie = g_u32SessionCookie;
724	pReq->Hdr.cbIn = SUP_IOCTL_CALL_VMMR0_SIZE_IN(cbReq);
725	pReq->Hdr.cbOut = SUP_IOCTL_CALL_VMMR0_SIZE_OUT(cbReq);
726	pReq->Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
727	pReq->Hdr.rc = VERR_INTERNAL_ERROR;
728	pReq->u.In.pVMR0 = pVMR0;
729	pReq->u.In.idCpu = idCpu;
730	pReq->u.In.uOperation = uOperation;
731	pReq->u.In.u64Arg = u64Arg;
732	memcpy(&pReq->abReqPkt[0], pReqHdr, cbReq);
733	rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_CALL_VMMR0(cbReq), pReq, SUP_IOCTL_CALL_VMMR0_SIZE(cbReq));
734	if (RT_SUCCESS(rc))
735	rc = pReq->Hdr.rc;
736	memcpy(pReqHdr, &pReq->abReqPkt[0], cbReq);
737	}
738	else if (pReqHdr->cbReq <= _512K)
739	{
740	AssertPtrReturn(pReqHdr, VERR_INVALID_POINTER);
741	AssertReturn(pReqHdr->u32Magic == SUPVMMR0REQHDR_MAGIC, VERR_INVALID_MAGIC);
742	const size_t cbReq = pReqHdr->cbReq;
743
744	PSUPCALLVMMR0 pReq = (PSUPCALLVMMR0)RTMemTmpAlloc(SUP_IOCTL_CALL_VMMR0_BIG_SIZE(cbReq));
745	pReq->Hdr.u32Cookie = g_u32Cookie;
746	pReq->Hdr.u32SessionCookie = g_u32SessionCookie;
747	pReq->Hdr.cbIn = SUP_IOCTL_CALL_VMMR0_BIG_SIZE_IN(cbReq);
748	pReq->Hdr.cbOut = SUP_IOCTL_CALL_VMMR0_BIG_SIZE_OUT(cbReq);
749	pReq->Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
750	pReq->Hdr.rc = VERR_INTERNAL_ERROR;
751	pReq->u.In.pVMR0 = pVMR0;
752	pReq->u.In.idCpu = idCpu;
753	pReq->u.In.uOperation = uOperation;
754	pReq->u.In.u64Arg = u64Arg;
755	memcpy(&pReq->abReqPkt[0], pReqHdr, cbReq);
756	rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_CALL_VMMR0_BIG, pReq, SUP_IOCTL_CALL_VMMR0_BIG_SIZE(cbReq));
757	if (RT_SUCCESS(rc))
758	rc = pReq->Hdr.rc;
759	memcpy(pReqHdr, &pReq->abReqPkt[0], cbReq);
760	RTMemTmpFree(pReq);
761	}
762	else
763	AssertMsgFailedReturn(("cbReq=%#x\n", pReqHdr->cbReq), VERR_OUT_OF_RANGE);
764	return rc;
765	}
766
767
768	SUPR3DECL(int) SUPR3CallVMMR0(PVMR0 pVMR0, VMCPUID idCpu, unsigned uOperation, void *pvArg)
769	{
770	/*
771	* The following operations don't belong here.
772	*/
773	AssertMsgReturn( uOperation != SUP_VMMR0_DO_HM_RUN
774	&& uOperation != SUP_VMMR0_DO_NEM_RUN
775	&& uOperation != SUP_VMMR0_DO_NOP,
776	("%#x\n", uOperation),
777	VERR_INTERNAL_ERROR);
778	return SUPR3CallVMMR0Ex(pVMR0, idCpu, uOperation, (uintptr_t)pvArg, NULL);
779	}
780
781
782	SUPR3DECL(int) SUPR3SetVMForFastIOCtl(PVMR0 pVMR0)
783	{
784	if (RT_UNLIKELY(g_uSupFakeMode))
785	return VINF_SUCCESS;
786
787	SUPSETVMFORFAST Req;
788	Req.Hdr.u32Cookie = g_u32Cookie;
789	Req.Hdr.u32SessionCookie = g_u32SessionCookie;
790	Req.Hdr.cbIn = SUP_IOCTL_SET_VM_FOR_FAST_SIZE_IN;
791	Req.Hdr.cbOut = SUP_IOCTL_SET_VM_FOR_FAST_SIZE_OUT;
792	Req.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
793	Req.Hdr.rc = VERR_INTERNAL_ERROR;
794	Req.u.In.pVMR0 = pVMR0;
795	int rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_SET_VM_FOR_FAST, &Req, SUP_IOCTL_SET_VM_FOR_FAST_SIZE);
796	if (RT_SUCCESS(rc))
797	rc = Req.Hdr.rc;
798	return rc;
799	}
800
801
802	SUPR3DECL(int) SUPR3CallR0Service(const char *pszService, size_t cchService, uint32_t uOperation, uint64_t u64Arg, PSUPR0SERVICEREQHDR pReqHdr)
803	{
804	AssertReturn(cchService < RT_SIZEOFMEMB(SUPCALLSERVICE, u.In.szName), VERR_INVALID_PARAMETER);
805	Assert(strlen(pszService) == cchService);
806
807	/* fake */
808	if (RT_UNLIKELY(g_uSupFakeMode))
809	return VERR_NOT_SUPPORTED;
810
811	int rc;
812	if (!pReqHdr)
813	{
814	/* no data. */
815	SUPCALLSERVICE Req;
816	Req.Hdr.u32Cookie = g_u32Cookie;
817	Req.Hdr.u32SessionCookie = g_u32SessionCookie;
818	Req.Hdr.cbIn = SUP_IOCTL_CALL_SERVICE_SIZE_IN(0);
819	Req.Hdr.cbOut = SUP_IOCTL_CALL_SERVICE_SIZE_OUT(0);
820	Req.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
821	Req.Hdr.rc = VERR_INTERNAL_ERROR;
822	memcpy(Req.u.In.szName, pszService, cchService);
823	Req.u.In.szName[cchService] = '\0';
824	Req.u.In.uOperation = uOperation;
825	Req.u.In.u64Arg = u64Arg;
826	rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_CALL_SERVICE(0), &Req, SUP_IOCTL_CALL_SERVICE_SIZE(0));
827	if (RT_SUCCESS(rc))
828	rc = Req.Hdr.rc;
829	}
830	else if (SUP_IOCTL_CALL_SERVICE_SIZE(pReqHdr->cbReq) < _4K) /* FreeBSD won't copy more than 4K. */
831	{
832	AssertPtrReturn(pReqHdr, VERR_INVALID_POINTER);
833	AssertReturn(pReqHdr->u32Magic == SUPR0SERVICEREQHDR_MAGIC, VERR_INVALID_MAGIC);
834	const size_t cbReq = pReqHdr->cbReq;
835
836	PSUPCALLSERVICE pReq = (PSUPCALLSERVICE)alloca(SUP_IOCTL_CALL_SERVICE_SIZE(cbReq));
837	pReq->Hdr.u32Cookie = g_u32Cookie;
838	pReq->Hdr.u32SessionCookie = g_u32SessionCookie;
839	pReq->Hdr.cbIn = SUP_IOCTL_CALL_SERVICE_SIZE_IN(cbReq);
840	pReq->Hdr.cbOut = SUP_IOCTL_CALL_SERVICE_SIZE_OUT(cbReq);
841	pReq->Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
842	pReq->Hdr.rc = VERR_INTERNAL_ERROR;
843	memcpy(pReq->u.In.szName, pszService, cchService);
844	pReq->u.In.szName[cchService] = '\0';
845	pReq->u.In.uOperation = uOperation;
846	pReq->u.In.u64Arg = u64Arg;
847	memcpy(&pReq->abReqPkt[0], pReqHdr, cbReq);
848	rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_CALL_SERVICE(cbReq), pReq, SUP_IOCTL_CALL_SERVICE_SIZE(cbReq));
849	if (RT_SUCCESS(rc))
850	rc = pReq->Hdr.rc;
851	memcpy(pReqHdr, &pReq->abReqPkt[0], cbReq);
852	}
853	else /** @todo may have to remove the size limits one this request... */
854	AssertMsgFailedReturn(("cbReq=%#x\n", pReqHdr->cbReq), VERR_INTERNAL_ERROR);
855	return rc;
856	}
857
858
859	/**
860	* Worker for the SUPR3Logger* APIs.
861	*
862	* @returns VBox status code.
863	* @param enmWhich Which logger.
864	* @param fWhat What to do with the logger.
865	* @param pszFlags The flags settings.
866	* @param pszGroups The groups settings.
867	* @param pszDest The destination specificier.
868	*/
869	static int supR3LoggerSettings(SUPLOGGER enmWhich, uint32_t fWhat, const char pszFlags, const char pszGroups, const char *pszDest)
870	{
871	uint32_t const cchFlags = pszFlags ? (uint32_t)strlen(pszFlags) : 0;
872	uint32_t const cchGroups = pszGroups ? (uint32_t)strlen(pszGroups) : 0;
873	uint32_t const cchDest = pszDest ? (uint32_t)strlen(pszDest) : 0;
874	uint32_t const cbStrTab = cchFlags + !!cchFlags
875	+ cchGroups + !!cchGroups
876	+ cchDest + !!cchDest
877	+ (!cchFlags && !cchGroups && !cchDest);
878
879	PSUPLOGGERSETTINGS pReq = (PSUPLOGGERSETTINGS)alloca(SUP_IOCTL_LOGGER_SETTINGS_SIZE(cbStrTab));
880	pReq->Hdr.u32Cookie = g_u32Cookie;
881	pReq->Hdr.u32SessionCookie = g_u32SessionCookie;
882	pReq->Hdr.cbIn = SUP_IOCTL_LOGGER_SETTINGS_SIZE_IN(cbStrTab);
883	pReq->Hdr.cbOut = SUP_IOCTL_LOGGER_SETTINGS_SIZE_OUT;
884	pReq->Hdr.fFlags= SUPREQHDR_FLAGS_DEFAULT;
885	pReq->Hdr.rc = VERR_INTERNAL_ERROR;
886	switch (enmWhich)
887	{
888	case SUPLOGGER_DEBUG: pReq->u.In.fWhich = SUPLOGGERSETTINGS_WHICH_DEBUG; break;
889	case SUPLOGGER_RELEASE: pReq->u.In.fWhich = SUPLOGGERSETTINGS_WHICH_RELEASE; break;
890	default:
891	return VERR_INVALID_PARAMETER;
892	}
893	pReq->u.In.fWhat = fWhat;
894
895	uint32_t off = 0;
896	if (cchFlags)
897	{
898	pReq->u.In.offFlags = off;
899	memcpy(&pReq->u.In.szStrings[off], pszFlags, cchFlags + 1);
900	off += cchFlags + 1;
901	}
902	else
903	pReq->u.In.offFlags = cbStrTab - 1;
904
905	if (cchGroups)
906	{
907	pReq->u.In.offGroups = off;
908	memcpy(&pReq->u.In.szStrings[off], pszGroups, cchGroups + 1);
909	off += cchGroups + 1;
910	}
911	else
912	pReq->u.In.offGroups = cbStrTab - 1;
913
914	if (cchDest)
915	{
916	pReq->u.In.offDestination = off;
917	memcpy(&pReq->u.In.szStrings[off], pszDest, cchDest + 1);
918	off += cchDest + 1;
919	}
920	else
921	pReq->u.In.offDestination = cbStrTab - 1;
922
923	if (!off)
924	{
925	pReq->u.In.szStrings[0] = '\0';
926	off++;
927	}
928	Assert(off == cbStrTab);
929	Assert(pReq->u.In.szStrings[cbStrTab - 1] == '\0');
930
931
932	int rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_LOGGER_SETTINGS(cbStrTab), pReq, SUP_IOCTL_LOGGER_SETTINGS_SIZE(cbStrTab));
933	if (RT_SUCCESS(rc))
934	rc = pReq->Hdr.rc;
935	return rc;
936	}
937
938
939	SUPR3DECL(int) SUPR3LoggerSettings(SUPLOGGER enmWhich, const char pszFlags, const char pszGroups, const char *pszDest)
940	{
941	return supR3LoggerSettings(enmWhich, SUPLOGGERSETTINGS_WHAT_SETTINGS, pszFlags, pszGroups, pszDest);
942	}
943
944
945	SUPR3DECL(int) SUPR3LoggerCreate(SUPLOGGER enmWhich, const char pszFlags, const char pszGroups, const char *pszDest)
946	{
947	return supR3LoggerSettings(enmWhich, SUPLOGGERSETTINGS_WHAT_CREATE, pszFlags, pszGroups, pszDest);
948	}
949
950
951	SUPR3DECL(int) SUPR3LoggerDestroy(SUPLOGGER enmWhich)
952	{
953	return supR3LoggerSettings(enmWhich, SUPLOGGERSETTINGS_WHAT_DESTROY, NULL, NULL, NULL);
954	}
955
956
957	SUPR3DECL(int) SUPR3PageAlloc(size_t cPages, uint32_t fFlags, void **ppvPages)
958	{
959	/*
960	* Validate.
961	*/
962	AssertPtrReturn(ppvPages, VERR_INVALID_POINTER);
963	*ppvPages = NULL;
964	AssertReturn(cPages > 0, VERR_PAGE_COUNT_OUT_OF_RANGE);
965	AssertReturn(!(fFlags & ~SUP_PAGE_ALLOC_F_VALID_MASK), VERR_INVALID_FLAGS);
966
967	/*
968	* Call OS specific worker.
969	*/
970	return suplibOsPageAlloc(&g_supLibData, cPages, fFlags, ppvPages);
971	}
972
973
974	SUPR3DECL(int) SUPR3PageFree(void *pvPages, size_t cPages)
975	{
976	/*
977	* Validate.
978	*/
979	AssertPtrReturn(pvPages, VERR_INVALID_POINTER);
980	AssertReturn(cPages > 0, VERR_PAGE_COUNT_OUT_OF_RANGE);
981
982	/*
983	* Call OS specific worker.
984	*/
985	return suplibOsPageFree(&g_supLibData, pvPages, cPages);
986	}
987
988
989	/**
990	* Locks down the physical memory backing a virtual memory
991	* range in the current process.
992	*
993	* @returns VBox status code.
994	* @param pvStart Start of virtual memory range.
995	* Must be page aligned.
996	* @param cPages Number of pages.
997	* @param paPages Where to store the physical page addresses returned.
998	* On entry this will point to an array of with cbMemory >> PAGE_SHIFT entries.
999	*/
1000	SUPR3DECL(int) supR3PageLock(void *pvStart, size_t cPages, PSUPPAGE paPages)
1001	{
1002	/*
1003	* Validate.
1004	*/
1005	AssertPtr(pvStart);
1006	AssertMsg(RT_ALIGN_P(pvStart, PAGE_SIZE) == pvStart, ("pvStart (%p) must be page aligned\n", pvStart));
1007	AssertPtr(paPages);
1008
1009	/* fake */
1010	if (RT_UNLIKELY(g_uSupFakeMode))
1011	{
1012	RTHCPHYS Phys = (uintptr_t)pvStart + PAGE_SIZE * 1024;
1013	size_t iPage = cPages;
1014	while (iPage-- > 0)
1015	paPages[iPage].Phys = Phys + (iPage << PAGE_SHIFT);
1016	return VINF_SUCCESS;
1017	}
1018
1019	/*
1020	* Issue IOCtl to the SUPDRV kernel module.
1021	*/
1022	int rc;
1023	PSUPPAGELOCK pReq = (PSUPPAGELOCK)RTMemTmpAllocZ(SUP_IOCTL_PAGE_LOCK_SIZE(cPages));
1024	if (RT_LIKELY(pReq))
1025	{
1026	pReq->Hdr.u32Cookie = g_u32Cookie;
1027	pReq->Hdr.u32SessionCookie = g_u32SessionCookie;
1028	pReq->Hdr.cbIn = SUP_IOCTL_PAGE_LOCK_SIZE_IN;
1029	pReq->Hdr.cbOut = SUP_IOCTL_PAGE_LOCK_SIZE_OUT(cPages);
1030	pReq->Hdr.fFlags = SUPREQHDR_FLAGS_MAGIC \| SUPREQHDR_FLAGS_EXTRA_OUT;
1031	pReq->Hdr.rc = VERR_INTERNAL_ERROR;
1032	pReq->u.In.pvR3 = pvStart;
1033	pReq->u.In.cPages = (uint32_t)cPages; AssertRelease(pReq->u.In.cPages == cPages);
1034	rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_PAGE_LOCK, pReq, SUP_IOCTL_PAGE_LOCK_SIZE(cPages));
1035	if (RT_SUCCESS(rc))
1036	rc = pReq->Hdr.rc;
1037	if (RT_SUCCESS(rc))
1038	{
1039	for (uint32_t iPage = 0; iPage < cPages; iPage++)
1040	{
1041	paPages[iPage].uReserved = 0;
1042	paPages[iPage].Phys = pReq->u.Out.aPages[iPage];
1043	Assert(!(paPages[iPage].Phys & ~X86_PTE_PAE_PG_MASK));
1044	}
1045	}
1046	RTMemTmpFree(pReq);
1047	}
1048	else
1049	rc = VERR_NO_TMP_MEMORY;
1050
1051	return rc;
1052	}
1053
1054
1055	/**
1056	* Releases locked down pages.
1057	*
1058	* @returns VBox status code.
1059	* @param pvStart Start of virtual memory range previously locked
1060	* down by SUPPageLock().
1061	*/
1062	SUPR3DECL(int) supR3PageUnlock(void *pvStart)
1063	{
1064	/*
1065	* Validate.
1066	*/
1067	AssertPtr(pvStart);
1068	AssertMsg(RT_ALIGN_P(pvStart, PAGE_SIZE) == pvStart, ("pvStart (%p) must be page aligned\n", pvStart));
1069
1070	/* fake */
1071	if (RT_UNLIKELY(g_uSupFakeMode))
1072	return VINF_SUCCESS;
1073
1074	/*
1075	* Issue IOCtl to the SUPDRV kernel module.
1076	*/
1077	SUPPAGEUNLOCK Req;
1078	Req.Hdr.u32Cookie = g_u32Cookie;
1079	Req.Hdr.u32SessionCookie = g_u32SessionCookie;
1080	Req.Hdr.cbIn = SUP_IOCTL_PAGE_UNLOCK_SIZE_IN;
1081	Req.Hdr.cbOut = SUP_IOCTL_PAGE_UNLOCK_SIZE_OUT;
1082	Req.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
1083	Req.Hdr.rc = VERR_INTERNAL_ERROR;
1084	Req.u.In.pvR3 = pvStart;
1085	int rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_PAGE_UNLOCK, &Req, SUP_IOCTL_PAGE_UNLOCK_SIZE);
1086	if (RT_SUCCESS(rc))
1087	rc = Req.Hdr.rc;
1088	return rc;
1089	}
1090
1091
1092	SUPR3DECL(int) SUPR3LockDownLoader(PRTERRINFO pErrInfo)
1093	{
1094	/* fake */
1095	if (RT_UNLIKELY(g_uSupFakeMode))
1096	return VINF_SUCCESS;
1097
1098	/*
1099	* Lock down the module loader interface.
1100	*/
1101	SUPREQHDR ReqHdr;
1102	ReqHdr.u32Cookie = g_u32Cookie;
1103	ReqHdr.u32SessionCookie = g_u32SessionCookie;
1104	ReqHdr.cbIn = SUP_IOCTL_LDR_LOCK_DOWN_SIZE_IN;
1105	ReqHdr.cbOut = SUP_IOCTL_LDR_LOCK_DOWN_SIZE_OUT;
1106	ReqHdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
1107	ReqHdr.rc = VERR_INTERNAL_ERROR;
1108	int rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_LDR_LOCK_DOWN, &ReqHdr, SUP_IOCTL_LDR_LOCK_DOWN_SIZE);
1109	if (RT_FAILURE(rc))
1110	return RTErrInfoSetF(pErrInfo, rc,
1111	"SUPR3LockDownLoader: SUP_IOCTL_LDR_LOCK_DOWN ioctl returned %Rrc", rc);
1112
1113	return ReqHdr.rc;
1114	}
1115
1116
1117	/**
1118	* Fallback for SUPR3PageAllocEx on systems where RTR0MemObjPhysAllocNC isn't
1119	* supported.
1120	*/
1121	static int supPagePageAllocNoKernelFallback(size_t cPages, void **ppvPages, PSUPPAGE paPages)
1122	{
1123	int rc = suplibOsPageAlloc(&g_supLibData, cPages, 0, ppvPages);
1124	if (RT_SUCCESS(rc))
1125	{
1126	Assert(ASMMemIsZero(*ppvPages, cPages << PAGE_SHIFT));
1127	if (!paPages)
1128	paPages = (PSUPPAGE)alloca(sizeof(paPages[0]) * cPages);
1129	rc = supR3PageLock(*ppvPages, cPages, paPages);
1130	if (RT_FAILURE(rc))
1131	suplibOsPageFree(&g_supLibData, *ppvPages, cPages);
1132	}
1133	return rc;
1134	}
1135
1136
1137	SUPR3DECL(int) SUPR3PageAllocEx(size_t cPages, uint32_t fFlags, void **ppvPages, PRTR0PTR pR0Ptr, PSUPPAGE paPages)
1138	{
1139	/*
1140	* Validate.
1141	*/
1142	AssertPtrReturn(ppvPages, VERR_INVALID_POINTER);
1143	*ppvPages = NULL;
1144	AssertPtrNullReturn(pR0Ptr, VERR_INVALID_POINTER);
1145	if (pR0Ptr)
1146	*pR0Ptr = NIL_RTR0PTR;
1147	AssertPtrNullReturn(paPages, VERR_INVALID_POINTER);
1148	AssertMsgReturn(cPages > 0 && cPages <= VBOX_MAX_ALLOC_PAGE_COUNT, ("cPages=%zu\n", cPages), VERR_PAGE_COUNT_OUT_OF_RANGE);
1149	AssertReturn(!fFlags, VERR_INVALID_FLAGS);
1150
1151	/*
1152	* Deal with driverless mode first.
1153	*/
1154	if (g_supLibData.fDriverless)
1155	{
1156	int rc = SUPR3PageAlloc(cPages, 0 /fFlags/, ppvPages);
1157	Assert(RT_FAILURE(rc) \|\| ASMMemIsZero(*ppvPages, cPages << PAGE_SHIFT));
1158	if (pR0Ptr)
1159	*pR0Ptr = NIL_RTR0PTR;
1160	if (paPages)
1161	for (size_t iPage = 0; iPage < cPages; iPage++)
1162	{
1163	paPages[iPage].uReserved = 0;
1164	paPages[iPage].Phys = NIL_RTHCPHYS;
1165	}
1166	return rc;
1167	}
1168
1169	/* Check that we've got a kernel connection so rtMemSaferSupR3AllocPages
1170	can do fallback without first having to hit assertions. */
1171	if (g_supLibData.hDevice != SUP_HDEVICE_NIL)
1172	{ /* likely */ }
1173	else
1174	return VERR_WRONG_ORDER;
1175
1176	/*
1177	* Use fallback for non-R0 mapping?
1178	*/
1179	if ( !pR0Ptr
1180	&& !g_fSupportsPageAllocNoKernel)
1181	return supPagePageAllocNoKernelFallback(cPages, ppvPages, paPages);
1182
1183	/*
1184	* Issue IOCtl to the SUPDRV kernel module.
1185	*/
1186	int rc;
1187	PSUPPAGEALLOCEX pReq = (PSUPPAGEALLOCEX)RTMemTmpAllocZ(SUP_IOCTL_PAGE_ALLOC_EX_SIZE(cPages));
1188	if (pReq)
1189	{
1190	pReq->Hdr.u32Cookie = g_u32Cookie;
1191	pReq->Hdr.u32SessionCookie = g_u32SessionCookie;
1192	pReq->Hdr.cbIn = SUP_IOCTL_PAGE_ALLOC_EX_SIZE_IN;
1193	pReq->Hdr.cbOut = SUP_IOCTL_PAGE_ALLOC_EX_SIZE_OUT(cPages);
1194	pReq->Hdr.fFlags = SUPREQHDR_FLAGS_MAGIC \| SUPREQHDR_FLAGS_EXTRA_OUT;
1195	pReq->Hdr.rc = VERR_INTERNAL_ERROR;
1196	pReq->u.In.cPages = (uint32_t)cPages; AssertRelease(pReq->u.In.cPages == cPages);
1197	pReq->u.In.fKernelMapping = pR0Ptr != NULL;
1198	pReq->u.In.fUserMapping = true;
1199	pReq->u.In.fReserved0 = false;
1200	pReq->u.In.fReserved1 = false;
1201	rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_PAGE_ALLOC_EX, pReq, SUP_IOCTL_PAGE_ALLOC_EX_SIZE(cPages));
1202	if (RT_SUCCESS(rc))
1203	{
1204	rc = pReq->Hdr.rc;
1205	if (RT_SUCCESS(rc))
1206	{
1207	*ppvPages = pReq->u.Out.pvR3;
1208	if (pR0Ptr)
1209	{
1210	*pR0Ptr = pReq->u.Out.pvR0;
1211	Assert(ASMMemIsZero(pReq->u.Out.pvR3, cPages << PAGE_SHIFT));
1212	#ifdef RT_OS_DARWIN /* HACK ALERT! */
1213	supR3TouchPages(pReq->u.Out.pvR3, cPages);
1214	#endif
1215	}
1216	else
1217	RT_BZERO(pReq->u.Out.pvR3, cPages << PAGE_SHIFT);
1218
1219	if (paPages)
1220	for (size_t iPage = 0; iPage < cPages; iPage++)
1221	{
1222	paPages[iPage].uReserved = 0;
1223	paPages[iPage].Phys = pReq->u.Out.aPages[iPage];
1224	Assert(!(paPages[iPage].Phys & ~X86_PTE_PAE_PG_MASK));
1225	}
1226	}
1227	else if ( rc == VERR_NOT_SUPPORTED
1228	&& !pR0Ptr)
1229	{
1230	g_fSupportsPageAllocNoKernel = false;
1231	rc = supPagePageAllocNoKernelFallback(cPages, ppvPages, paPages);
1232	}
1233	}
1234
1235	RTMemTmpFree(pReq);
1236	}
1237	else
1238	rc = VERR_NO_TMP_MEMORY;
1239	return rc;
1240
1241	}
1242
1243
1244	SUPR3DECL(int) SUPR3PageMapKernel(void *pvR3, uint32_t off, uint32_t cb, uint32_t fFlags, PRTR0PTR pR0Ptr)
1245	{
1246	/*
1247	* Validate.
1248	*/
1249	AssertPtrReturn(pvR3, VERR_INVALID_POINTER);
1250	AssertPtrReturn(pR0Ptr, VERR_INVALID_POINTER);
1251	Assert(!(off & PAGE_OFFSET_MASK));
1252	Assert(!(cb & PAGE_OFFSET_MASK) && cb);
1253	Assert(!fFlags);
1254	*pR0Ptr = NIL_RTR0PTR;
1255
1256	/*
1257	* Not a valid operation in driverless mode.
1258	*/
1259	AssertReturn(g_supLibData.fDriverless, VERR_SUP_DRIVERLESS);
1260
1261	/*
1262	* Issue IOCtl to the SUPDRV kernel module.
1263	*/
1264	SUPPAGEMAPKERNEL Req;
1265	Req.Hdr.u32Cookie = g_u32Cookie;
1266	Req.Hdr.u32SessionCookie = g_u32SessionCookie;
1267	Req.Hdr.cbIn = SUP_IOCTL_PAGE_MAP_KERNEL_SIZE_IN;
1268	Req.Hdr.cbOut = SUP_IOCTL_PAGE_MAP_KERNEL_SIZE_OUT;
1269	Req.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
1270	Req.Hdr.rc = VERR_INTERNAL_ERROR;
1271	Req.u.In.pvR3 = pvR3;
1272	Req.u.In.offSub = off;
1273	Req.u.In.cbSub = cb;
1274	Req.u.In.fFlags = fFlags;
1275	int rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_PAGE_MAP_KERNEL, &Req, SUP_IOCTL_PAGE_MAP_KERNEL_SIZE);
1276	if (RT_SUCCESS(rc))
1277	rc = Req.Hdr.rc;
1278	if (RT_SUCCESS(rc))
1279	*pR0Ptr = Req.u.Out.pvR0;
1280	return rc;
1281	}
1282
1283
1284	SUPR3DECL(int) SUPR3PageProtect(void *pvR3, RTR0PTR R0Ptr, uint32_t off, uint32_t cb, uint32_t fProt)
1285	{
1286	/*
1287	* Validate.
1288	*/
1289	AssertPtrReturn(pvR3, VERR_INVALID_POINTER);
1290	Assert(!(off & PAGE_OFFSET_MASK));
1291	Assert(!(cb & PAGE_OFFSET_MASK) && cb);
1292	AssertReturn(!(fProt & ~(RTMEM_PROT_NONE \| RTMEM_PROT_READ \| RTMEM_PROT_WRITE \| RTMEM_PROT_EXEC)), VERR_INVALID_PARAMETER);
1293
1294	/*
1295	* Deal with driverless mode first.
1296	*/
1297	if (g_supLibData.fDriverless)
1298	return RTMemProtect((uint8_t *)pvR3 + off, cb, fProt);
1299
1300	/*
1301	* Some OSes can do this from ring-3, so try that before we
1302	* issue the IOCtl to the SUPDRV kernel module.
1303	* (Yea, this isn't very nice, but just try get the job done for now.)
1304	*/
1305	#if !defined(RT_OS_SOLARIS)
1306	RTMemProtect((uint8_t *)pvR3 + off, cb, fProt);
1307	#endif
1308
1309	SUPPAGEPROTECT Req;
1310	Req.Hdr.u32Cookie = g_u32Cookie;
1311	Req.Hdr.u32SessionCookie = g_u32SessionCookie;
1312	Req.Hdr.cbIn = SUP_IOCTL_PAGE_PROTECT_SIZE_IN;
1313	Req.Hdr.cbOut = SUP_IOCTL_PAGE_PROTECT_SIZE_OUT;
1314	Req.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
1315	Req.Hdr.rc = VERR_INTERNAL_ERROR;
1316	Req.u.In.pvR3 = pvR3;
1317	Req.u.In.pvR0 = R0Ptr;
1318	Req.u.In.offSub = off;
1319	Req.u.In.cbSub = cb;
1320	Req.u.In.fProt = fProt;
1321	int rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_PAGE_PROTECT, &Req, SUP_IOCTL_PAGE_PROTECT_SIZE);
1322	if (RT_SUCCESS(rc))
1323	rc = Req.Hdr.rc;
1324	return rc;
1325	}
1326
1327
1328	SUPR3DECL(int) SUPR3PageFreeEx(void *pvPages, size_t cPages)
1329	{
1330	/*
1331	* Validate.
1332	*/
1333	AssertPtrReturn(pvPages, VERR_INVALID_POINTER);
1334	AssertReturn(cPages > 0, VERR_PAGE_COUNT_OUT_OF_RANGE);
1335
1336	/*
1337	* Deal with driverless mode first.
1338	*/
1339	if (g_supLibData.fDriverless)
1340	{
1341	SUPR3PageFree(pvPages, cPages);
1342	return VINF_SUCCESS;
1343	}
1344
1345	/*
1346	* Try normal free first, then if it fails check if we're using the fallback
1347	* for the allocations without kernel mappings and attempt unlocking it.
1348	*/
1349	NOREF(cPages);
1350	SUPPAGEFREE Req;
1351	Req.Hdr.u32Cookie = g_u32Cookie;
1352	Req.Hdr.u32SessionCookie = g_u32SessionCookie;
1353	Req.Hdr.cbIn = SUP_IOCTL_PAGE_FREE_SIZE_IN;
1354	Req.Hdr.cbOut = SUP_IOCTL_PAGE_FREE_SIZE_OUT;
1355	Req.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
1356	Req.Hdr.rc = VERR_INTERNAL_ERROR;
1357	Req.u.In.pvR3 = pvPages;
1358	int rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_PAGE_FREE, &Req, SUP_IOCTL_PAGE_FREE_SIZE);
1359	if (RT_SUCCESS(rc))
1360	{
1361	rc = Req.Hdr.rc;
1362	if ( rc == VERR_INVALID_PARAMETER
1363	&& !g_fSupportsPageAllocNoKernel)
1364	{
1365	int rc2 = supR3PageUnlock(pvPages);
1366	if (RT_SUCCESS(rc2))
1367	rc = suplibOsPageFree(&g_supLibData, pvPages, cPages);
1368	}
1369	}
1370	return rc;
1371	}
1372
1373
1374	SUPR3DECL(void *) SUPR3ContAlloc(size_t cPages, PRTR0PTR pR0Ptr, PRTHCPHYS pHCPhys)
1375	{
1376	/*
1377	* Validate.
1378	*/
1379	AssertPtrReturn(pHCPhys, NULL);
1380	*pHCPhys = NIL_RTHCPHYS;
1381	AssertPtrNullReturn(pR0Ptr, NULL);
1382	if (pR0Ptr)
1383	*pR0Ptr = NIL_RTR0PTR;
1384	AssertPtrNullReturn(pHCPhys, NULL);
1385	AssertMsgReturn(cPages > 0 && cPages < 256, ("cPages=%d must be > 0 and < 256\n", cPages), NULL);
1386
1387	/*
1388	* Deal with driverless mode first.
1389	*/
1390	if (g_supLibData.fDriverless)
1391	{
1392	void *pvPages = NULL;
1393	int rc = SUPR3PageAlloc(cPages, 0 /fFlags/, &pvPages);
1394	if (pR0Ptr)
1395	*pR0Ptr = NIL_RTR0PTR;
1396	if (pHCPhys)
1397	*pHCPhys = NIL_RTHCPHYS;
1398	return RT_SUCCESS(rc) ? pvPages : NULL;
1399	}
1400
1401	/*
1402	* Issue IOCtl to the SUPDRV kernel module.
1403	*/
1404	SUPCONTALLOC Req;
1405	Req.Hdr.u32Cookie = g_u32Cookie;
1406	Req.Hdr.u32SessionCookie = g_u32SessionCookie;
1407	Req.Hdr.cbIn = SUP_IOCTL_CONT_ALLOC_SIZE_IN;
1408	Req.Hdr.cbOut = SUP_IOCTL_CONT_ALLOC_SIZE_OUT;
1409	Req.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
1410	Req.Hdr.rc = VERR_INTERNAL_ERROR;
1411	Req.u.In.cPages = (uint32_t)cPages;
1412	int rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_CONT_ALLOC, &Req, SUP_IOCTL_CONT_ALLOC_SIZE);
1413	if ( RT_SUCCESS(rc)
1414	&& RT_SUCCESS(Req.Hdr.rc))
1415	{
1416	*pHCPhys = Req.u.Out.HCPhys;
1417	if (pR0Ptr)
1418	*pR0Ptr = Req.u.Out.pvR0;
1419	#ifdef RT_OS_DARWIN /* HACK ALERT! */
1420	supR3TouchPages(Req.u.Out.pvR3, cPages);
1421	#endif
1422	return Req.u.Out.pvR3;
1423	}
1424
1425	return NULL;
1426	}
1427
1428
1429	SUPR3DECL(int) SUPR3ContFree(void *pv, size_t cPages)
1430	{
1431	/*
1432	* Validate.
1433	*/
1434	if (!pv)
1435	return VINF_SUCCESS;
1436	AssertPtrReturn(pv, VERR_INVALID_POINTER);
1437	AssertReturn(cPages > 0, VERR_PAGE_COUNT_OUT_OF_RANGE);
1438
1439	/*
1440	* Deal with driverless mode first.
1441	*/
1442	if (g_supLibData.fDriverless)
1443	return SUPR3PageFree(pv, cPages);
1444
1445	/*
1446	* Issue IOCtl to the SUPDRV kernel module.
1447	*/
1448	SUPCONTFREE Req;
1449	Req.Hdr.u32Cookie = g_u32Cookie;
1450	Req.Hdr.u32SessionCookie = g_u32SessionCookie;
1451	Req.Hdr.cbIn = SUP_IOCTL_CONT_FREE_SIZE_IN;
1452	Req.Hdr.cbOut = SUP_IOCTL_CONT_FREE_SIZE_OUT;
1453	Req.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
1454	Req.Hdr.rc = VERR_INTERNAL_ERROR;
1455	Req.u.In.pvR3 = pv;
1456	int rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_CONT_FREE, &Req, SUP_IOCTL_CONT_FREE_SIZE);
1457	if (RT_SUCCESS(rc))
1458	rc = Req.Hdr.rc;
1459	return rc;
1460	}
1461
1462
1463	SUPR3DECL(int) SUPR3LowAlloc(size_t cPages, void **ppvPages, PRTR0PTR ppvPagesR0, PSUPPAGE paPages)
1464	{
1465	/*
1466	* Validate.
1467	*/
1468	AssertPtrReturn(ppvPages, VERR_INVALID_POINTER);
1469	*ppvPages = NULL;
1470	AssertPtrReturn(paPages, VERR_INVALID_POINTER);
1471	AssertMsgReturn(cPages > 0 && cPages < 256, ("cPages=%d must be > 0 and < 256\n", cPages), VERR_PAGE_COUNT_OUT_OF_RANGE);
1472
1473	/* fake */
1474	if (RT_UNLIKELY(g_uSupFakeMode))
1475	{
1476	ppvPages = RTMemPageAllocZ((size_t)cPages PAGE_SIZE);
1477	if (!*ppvPages)
1478	return VERR_NO_LOW_MEMORY;
1479
1480	/* fake physical addresses. */
1481	RTHCPHYS Phys = (uintptr_t)ppvPages + PAGE_SIZE 1024;
1482	size_t iPage = cPages;
1483	while (iPage-- > 0)
1484	paPages[iPage].Phys = Phys + (iPage << PAGE_SHIFT);
1485	return VINF_SUCCESS;
1486	}
1487
1488	/*
1489	* Issue IOCtl to the SUPDRV kernel module.
1490	*/
1491	int rc;
1492	PSUPLOWALLOC pReq = (PSUPLOWALLOC)RTMemTmpAllocZ(SUP_IOCTL_LOW_ALLOC_SIZE(cPages));
1493	if (pReq)
1494	{
1495	pReq->Hdr.u32Cookie = g_u32Cookie;
1496	pReq->Hdr.u32SessionCookie = g_u32SessionCookie;
1497	pReq->Hdr.cbIn = SUP_IOCTL_LOW_ALLOC_SIZE_IN;
1498	pReq->Hdr.cbOut = SUP_IOCTL_LOW_ALLOC_SIZE_OUT(cPages);
1499	pReq->Hdr.fFlags = SUPREQHDR_FLAGS_MAGIC \| SUPREQHDR_FLAGS_EXTRA_OUT;
1500	pReq->Hdr.rc = VERR_INTERNAL_ERROR;
1501	pReq->u.In.cPages = (uint32_t)cPages; AssertRelease(pReq->u.In.cPages == cPages);
1502	rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_LOW_ALLOC, pReq, SUP_IOCTL_LOW_ALLOC_SIZE(cPages));
1503	if (RT_SUCCESS(rc))
1504	rc = pReq->Hdr.rc;
1505	if (RT_SUCCESS(rc))
1506	{
1507	*ppvPages = pReq->u.Out.pvR3;
1508	if (ppvPagesR0)
1509	*ppvPagesR0 = pReq->u.Out.pvR0;
1510	if (paPages)
1511	for (size_t iPage = 0; iPage < cPages; iPage++)
1512	{
1513	paPages[iPage].uReserved = 0;
1514	paPages[iPage].Phys = pReq->u.Out.aPages[iPage];
1515	Assert(!(paPages[iPage].Phys & ~X86_PTE_PAE_PG_MASK));
1516	Assert(paPages[iPage].Phys <= UINT32_C(0xfffff000));
1517	}
1518	#ifdef RT_OS_DARWIN /* HACK ALERT! */
1519	supR3TouchPages(pReq->u.Out.pvR3, cPages);
1520	#endif
1521	}
1522	RTMemTmpFree(pReq);
1523	}
1524	else
1525	rc = VERR_NO_TMP_MEMORY;
1526
1527	return rc;
1528	}
1529
1530
1531	SUPR3DECL(int) SUPR3LowFree(void *pv, size_t cPages)
1532	{
1533	/*
1534	* Validate.
1535	*/
1536	if (!pv)
1537	return VINF_SUCCESS;
1538	AssertPtrReturn(pv, VERR_INVALID_POINTER);
1539	AssertReturn(cPages > 0, VERR_PAGE_COUNT_OUT_OF_RANGE);
1540
1541	/* fake */
1542	if (RT_UNLIKELY(g_uSupFakeMode))
1543	{
1544	RTMemPageFree(pv, cPages * PAGE_SIZE);
1545	return VINF_SUCCESS;
1546	}
1547
1548	/*
1549	* Issue IOCtl to the SUPDRV kernel module.
1550	*/
1551	SUPCONTFREE Req;
1552	Req.Hdr.u32Cookie = g_u32Cookie;
1553	Req.Hdr.u32SessionCookie = g_u32SessionCookie;
1554	Req.Hdr.cbIn = SUP_IOCTL_LOW_FREE_SIZE_IN;
1555	Req.Hdr.cbOut = SUP_IOCTL_LOW_FREE_SIZE_OUT;
1556	Req.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
1557	Req.Hdr.rc = VERR_INTERNAL_ERROR;
1558	Req.u.In.pvR3 = pv;
1559	int rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_LOW_FREE, &Req, SUP_IOCTL_LOW_FREE_SIZE);
1560	if (RT_SUCCESS(rc))
1561	rc = Req.Hdr.rc;
1562	return rc;
1563	}
1564
1565
1566	SUPR3DECL(int) SUPR3HardenedVerifyInit(void)
1567	{
1568	#ifdef RT_OS_WINDOWS
1569	if (g_cInits == 0)
1570	return suplibOsHardenedVerifyInit();
1571	#endif
1572	return VINF_SUCCESS;
1573	}
1574
1575
1576	SUPR3DECL(int) SUPR3HardenedVerifyTerm(void)
1577	{
1578	#ifdef RT_OS_WINDOWS
1579	if (g_cInits == 0)
1580	return suplibOsHardenedVerifyTerm();
1581	#endif
1582	return VINF_SUCCESS;
1583	}
1584
1585
1586	SUPR3DECL(int) SUPR3HardenedVerifyFile(const char pszFilename, const char pszMsg, PRTFILE phFile)
1587	{
1588	/*
1589	* Quick input validation.
1590	*/
1591	AssertPtr(pszFilename);
1592	AssertPtr(pszMsg);
1593	AssertReturn(!phFile, VERR_NOT_IMPLEMENTED); /** @todo Implement this. The deal is that we make sure the
1594	file is the same we verified after opening it. */
1595	RT_NOREF2(pszFilename, pszMsg);
1596
1597	/*
1598	* Only do the actual check in hardened builds.
1599	*/
1600	#ifdef VBOX_WITH_HARDENING
1601	int rc = supR3HardenedVerifyFixedFile(pszFilename, false /* fFatal */);
1602	if (RT_FAILURE(rc))
1603	LogRel(("SUPR3HardenedVerifyFile: %s: Verification of \"%s\" failed, rc=%Rrc\n", pszMsg, pszFilename, rc));
1604	return rc;
1605	#else
1606	return VINF_SUCCESS;
1607	#endif
1608	}
1609
1610
1611	SUPR3DECL(int) SUPR3HardenedVerifySelf(const char *pszArgv0, bool fInternal, PRTERRINFO pErrInfo)
1612	{
1613	/*
1614	* Quick input validation.
1615	*/
1616	AssertPtr(pszArgv0);
1617	RTErrInfoClear(pErrInfo);
1618
1619	/*
1620	* Get the executable image path as we need it for all the tests here.
1621	*/
1622	char szExecPath[RTPATH_MAX];
1623	if (!RTProcGetExecutablePath(szExecPath, sizeof(szExecPath)))
1624	return RTErrInfoSet(pErrInfo, VERR_INTERNAL_ERROR_2, "RTProcGetExecutablePath failed");
1625
1626	int rc;
1627	if (fInternal)
1628	{
1629	/*
1630	* Internal applications must be launched directly without any PATH
1631	* searching involved.
1632	*/
1633	if (RTPathCompare(pszArgv0, szExecPath) != 0)
1634	return RTErrInfoSetF(pErrInfo, VERR_SUPLIB_INVALID_ARGV0_INTERNAL,
1635	"argv[0] does not match the executable image path: '%s' != '%s'", pszArgv0, szExecPath);
1636
1637	/*
1638	* Internal applications must reside in or under the
1639	* RTPathAppPrivateArch directory.
1640	*/
1641	char szAppPrivateArch[RTPATH_MAX];
1642	rc = RTPathAppPrivateArch(szAppPrivateArch, sizeof(szAppPrivateArch));
1643	if (RT_FAILURE(rc))
1644	return RTErrInfoSetF(pErrInfo, VERR_SUPLIB_INVALID_ARGV0_INTERNAL,
1645	"RTPathAppPrivateArch failed with rc=%Rrc", rc);
1646	size_t cchAppPrivateArch = strlen(szAppPrivateArch);
1647	if ( cchAppPrivateArch >= strlen(szExecPath)
1648	\|\| !RTPATH_IS_SLASH(szExecPath[cchAppPrivateArch]))
1649	return RTErrInfoSet(pErrInfo, VERR_SUPLIB_INVALID_INTERNAL_APP_DIR,
1650	"Internal executable does reside under RTPathAppPrivateArch");
1651	szExecPath[cchAppPrivateArch] = '\0';
1652	if (RTPathCompare(szExecPath, szAppPrivateArch) != 0)
1653	return RTErrInfoSet(pErrInfo, VERR_SUPLIB_INVALID_INTERNAL_APP_DIR,
1654	"Internal executable does reside under RTPathAppPrivateArch");
1655	szExecPath[cchAppPrivateArch] = RTPATH_SLASH;
1656	}
1657
1658	#ifdef VBOX_WITH_HARDENING
1659	/*
1660	* Verify that the image file and parent directories are sane.
1661	*/
1662	rc = supR3HardenedVerifyFile(szExecPath, RTHCUINTPTR_MAX, false /fMaybe3rdParty/, pErrInfo);
1663	if (RT_FAILURE(rc))
1664	return rc;
1665	#endif
1666
1667	return VINF_SUCCESS;
1668	}
1669
1670
1671	SUPR3DECL(int) SUPR3HardenedVerifyDir(const char *pszDirPath, bool fRecursive, bool fCheckFiles, PRTERRINFO pErrInfo)
1672	{
1673	/*
1674	* Quick input validation
1675	*/
1676	AssertPtr(pszDirPath);
1677	RTErrInfoClear(pErrInfo);
1678
1679	/*
1680	* Only do the actual check in hardened builds.
1681	*/
1682	#ifdef VBOX_WITH_HARDENING
1683	int rc = supR3HardenedVerifyDir(pszDirPath, fRecursive, fCheckFiles, pErrInfo);
1684	if (RT_FAILURE(rc) && !RTErrInfoIsSet(pErrInfo))
1685	LogRel(("supR3HardenedVerifyDir: Verification of \"%s\" failed, rc=%Rrc\n", pszDirPath, rc));
1686	return rc;
1687	#else
1688	NOREF(pszDirPath); NOREF(fRecursive); NOREF(fCheckFiles);
1689	return VINF_SUCCESS;
1690	#endif
1691	}
1692
1693
1694	SUPR3DECL(int) SUPR3HardenedVerifyPlugIn(const char *pszFilename, PRTERRINFO pErrInfo)
1695	{
1696	/*
1697	* Quick input validation
1698	*/
1699	AssertPtr(pszFilename);
1700	RTErrInfoClear(pErrInfo);
1701
1702	/*
1703	* Only do the actual check in hardened builds.
1704	*/
1705	#ifdef VBOX_WITH_HARDENING
1706	int rc = supR3HardenedVerifyFile(pszFilename, RTHCUINTPTR_MAX, true /fMaybe3rdParty/, pErrInfo);
1707	if (RT_FAILURE(rc) && !RTErrInfoIsSet(pErrInfo))
1708	LogRel(("supR3HardenedVerifyFile: Verification of \"%s\" failed, rc=%Rrc\n", pszFilename, rc));
1709	return rc;
1710	#else
1711	RT_NOREF1(pszFilename);
1712	return VINF_SUCCESS;
1713	#endif
1714	}
1715
1716
1717	SUPR3DECL(int) SUPR3GipGetPhys(PRTHCPHYS pHCPhys)
1718	{
1719	if (g_pSUPGlobalInfoPage)
1720	{
1721	*pHCPhys = g_HCPhysSUPGlobalInfoPage;
1722	return VINF_SUCCESS;
1723	}
1724	*pHCPhys = NIL_RTHCPHYS;
1725	return VERR_WRONG_ORDER;
1726	}
1727
1728
1729	SUPR3DECL(int) SUPR3QueryVTxSupported(const char **ppszWhy)
1730	{
1731	*ppszWhy = NULL;
1732	#ifdef RT_OS_LINUX
1733	return suplibOsQueryVTxSupported(ppszWhy);
1734	#else
1735	return VINF_SUCCESS;
1736	#endif
1737	}
1738
1739
1740	SUPR3DECL(int) SUPR3QueryVTCaps(uint32_t *pfCaps)
1741	{
1742	AssertPtrReturn(pfCaps, VERR_INVALID_POINTER);
1743
1744	*pfCaps = 0;
1745
1746	int rc;
1747	if (!g_supLibData.fDriverless)
1748	{
1749	/*
1750	* Issue IOCtl to the SUPDRV kernel module.
1751	*/
1752	SUPVTCAPS Req;
1753	Req.Hdr.u32Cookie = g_u32Cookie;
1754	Req.Hdr.u32SessionCookie = g_u32SessionCookie;
1755	Req.Hdr.cbIn = SUP_IOCTL_VT_CAPS_SIZE_IN;
1756	Req.Hdr.cbOut = SUP_IOCTL_VT_CAPS_SIZE_OUT;
1757	Req.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
1758	Req.Hdr.rc = VERR_INTERNAL_ERROR;
1759	Req.u.Out.fCaps = 0;
1760	rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_VT_CAPS, &Req, SUP_IOCTL_VT_CAPS_SIZE);
1761	if (RT_SUCCESS(rc))
1762	{
1763	rc = Req.Hdr.rc;
1764	if (RT_SUCCESS(rc))
1765	*pfCaps = Req.u.Out.fCaps;
1766	}
1767	}
1768	/*
1769	* Fail this call in driverless mode.
1770	*/
1771	else
1772	rc = VERR_SUP_DRIVERLESS;
1773	return rc;
1774	}
1775
1776
1777	SUPR3DECL(bool) SUPR3IsNemSupportedWhenNoVtxOrAmdV(void)
1778	{
1779	#if defined(RT_OS_WINDOWS) \|\| defined(RT_OS_DARWIN)
1780	return suplibOsIsNemSupportedWhenNoVtxOrAmdV();
1781	#else
1782	return false;
1783	#endif
1784	}
1785
1786
1787	SUPR3DECL(int) SUPR3QueryMicrocodeRev(uint32_t *uMicrocodeRev)
1788	{
1789	AssertPtrReturn(uMicrocodeRev, VERR_INVALID_POINTER);
1790
1791	*uMicrocodeRev = 0;
1792
1793	int rc;
1794	if (!g_supLibData.fDriverless)
1795	{
1796	/*
1797	* Issue IOCtl to the SUPDRV kernel module.
1798	*/
1799	SUPUCODEREV Req;
1800	Req.Hdr.u32Cookie = g_u32Cookie;
1801	Req.Hdr.u32SessionCookie = g_u32SessionCookie;
1802	Req.Hdr.cbIn = SUP_IOCTL_UCODE_REV_SIZE_IN;
1803	Req.Hdr.cbOut = SUP_IOCTL_UCODE_REV_SIZE_OUT;
1804	Req.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
1805	Req.Hdr.rc = VERR_INTERNAL_ERROR;
1806	Req.u.Out.MicrocodeRev = 0;
1807	rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_UCODE_REV, &Req, SUP_IOCTL_UCODE_REV_SIZE);
1808	if (RT_SUCCESS(rc))
1809	{
1810	rc = Req.Hdr.rc;
1811	if (RT_SUCCESS(rc))
1812	*uMicrocodeRev = Req.u.Out.MicrocodeRev;
1813	}
1814	}
1815	/*
1816	* Just fail the call in driverless mode.
1817	*/
1818	else
1819	rc = VERR_SUP_DRIVERLESS;
1820	return rc;
1821	}
1822
1823
1824	SUPR3DECL(int) SUPR3TracerOpen(uint32_t uCookie, uintptr_t uArg)
1825	{
1826	/* fake */
1827	if (RT_UNLIKELY(g_uSupFakeMode))
1828	return VINF_SUCCESS;
1829
1830	/*
1831	* Issue IOCtl to the SUPDRV kernel module.
1832	*/
1833	SUPTRACEROPEN Req;
1834	Req.Hdr.u32Cookie = g_u32Cookie;
1835	Req.Hdr.u32SessionCookie= g_u32SessionCookie;
1836	Req.Hdr.cbIn = SUP_IOCTL_TRACER_OPEN_SIZE_IN;
1837	Req.Hdr.cbOut = SUP_IOCTL_TRACER_OPEN_SIZE_OUT;
1838	Req.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
1839	Req.Hdr.rc = VERR_INTERNAL_ERROR;
1840	Req.u.In.uCookie = uCookie;
1841	Req.u.In.uArg = uArg;
1842	int rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_TRACER_OPEN, &Req, SUP_IOCTL_TRACER_OPEN_SIZE);
1843	if (RT_SUCCESS(rc))
1844	rc = Req.Hdr.rc;
1845	return rc;
1846	}
1847
1848
1849	SUPR3DECL(int) SUPR3TracerClose(void)
1850	{
1851	/* fake */
1852	if (RT_UNLIKELY(g_uSupFakeMode))
1853	return VINF_SUCCESS;
1854
1855	/*
1856	* Issue IOCtl to the SUPDRV kernel module.
1857	*/
1858	SUPREQHDR Req;
1859	Req.u32Cookie = g_u32Cookie;
1860	Req.u32SessionCookie= g_u32SessionCookie;
1861	Req.cbIn = SUP_IOCTL_TRACER_OPEN_SIZE_IN;
1862	Req.cbOut = SUP_IOCTL_TRACER_OPEN_SIZE_OUT;
1863	Req.fFlags = SUPREQHDR_FLAGS_DEFAULT;
1864	Req.rc = VERR_INTERNAL_ERROR;
1865	int rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_TRACER_CLOSE, &Req, SUP_IOCTL_TRACER_CLOSE_SIZE);
1866	if (RT_SUCCESS(rc))
1867	rc = Req.rc;
1868	return rc;
1869	}
1870
1871
1872	SUPR3DECL(int) SUPR3TracerIoCtl(uintptr_t uCmd, uintptr_t uArg, int32_t *piRetVal)
1873	{
1874	/* fake */
1875	if (RT_UNLIKELY(g_uSupFakeMode))
1876	{
1877	*piRetVal = -1;
1878	return VERR_NOT_SUPPORTED;
1879	}
1880
1881	/*
1882	* Issue IOCtl to the SUPDRV kernel module.
1883	*/
1884	SUPTRACERIOCTL Req;
1885	Req.Hdr.u32Cookie = g_u32Cookie;
1886	Req.Hdr.u32SessionCookie= g_u32SessionCookie;
1887	Req.Hdr.cbIn = SUP_IOCTL_TRACER_IOCTL_SIZE_IN;
1888	Req.Hdr.cbOut = SUP_IOCTL_TRACER_IOCTL_SIZE_OUT;
1889	Req.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
1890	Req.Hdr.rc = VERR_INTERNAL_ERROR;
1891	Req.u.In.uCmd = uCmd;
1892	Req.u.In.uArg = uArg;
1893	int rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_TRACER_IOCTL, &Req, SUP_IOCTL_TRACER_IOCTL_SIZE);
1894	if (RT_SUCCESS(rc))
1895	{
1896	rc = Req.Hdr.rc;
1897	*piRetVal = Req.u.Out.iRetVal;
1898	}
1899	return rc;
1900	}
1901
1902
1903
1904	typedef struct SUPDRVTRACERSTRTAB
1905	{
1906	/** Pointer to the string table. */
1907	char *pchStrTab;
1908	/** The actual string table size. */
1909	uint32_t cbStrTab;
1910	/** The original string pointers. */
1911	RTUINTPTR apszOrgFunctions[1];
1912	} SUPDRVTRACERSTRTAB, *PSUPDRVTRACERSTRTAB;
1913
1914
1915	/**
1916	* Destroys a string table, restoring the original pszFunction member valus.
1917	*
1918	* @param pThis The string table structure.
1919	* @param paProbeLocs32 The probe location array, 32-bit type variant.
1920	* @param paProbeLocs64 The probe location array, 64-bit type variant.
1921	* @param cProbeLocs The number of elements in the array.
1922	* @param f32Bit Set if @a paProbeLocs32 should be used, when
1923	* clear use @a paProbeLocs64.
1924	*/
1925	static void supr3TracerDestroyStrTab(PSUPDRVTRACERSTRTAB pThis, PVTGPROBELOC32 paProbeLocs32, PVTGPROBELOC64 paProbeLocs64,
1926	uint32_t cProbeLocs, bool f32Bit)
1927	{
1928	/* Restore. */
1929	size_t i = cProbeLocs;
1930	if (f32Bit)
1931	while (i--)
1932	paProbeLocs32[i].pszFunction = (uint32_t)pThis->apszOrgFunctions[i];
1933	else
1934	while (i--)
1935	paProbeLocs64[i].pszFunction = pThis->apszOrgFunctions[i];
1936
1937	/* Free. */
1938	RTMemFree(pThis->pchStrTab);
1939	RTMemFree(pThis);
1940	}
1941
1942
1943	/**
1944	* Creates a string table for the pszFunction members in the probe location
1945	* array.
1946	*
1947	* This will save and replace the pszFunction members with offsets.
1948	*
1949	* @returns Pointer to a string table structure. NULL on failure.
1950	* @param paProbeLocs32 The probe location array, 32-bit type variant.
1951	* @param paProbeLocs64 The probe location array, 64-bit type variant.
1952	* @param cProbeLocs The number of elements in the array.
1953	* @param offDelta Relocation offset for the string pointers.
1954	* @param f32Bit Set if @a paProbeLocs32 should be used, when
1955	* clear use @a paProbeLocs64.
1956	*/
1957	static PSUPDRVTRACERSTRTAB supr3TracerCreateStrTab(PVTGPROBELOC32 paProbeLocs32,
1958	PVTGPROBELOC64 paProbeLocs64,
1959	uint32_t cProbeLocs,
1960	RTUINTPTR offDelta,
1961	bool f32Bit)
1962	{
1963	if (cProbeLocs > _128K)
1964	return NULL;
1965
1966	/*
1967	* Allocate the string table structures.
1968	*/
1969	size_t cbThis = RT_UOFFSETOF_DYN(SUPDRVTRACERSTRTAB, apszOrgFunctions[cProbeLocs]);
1970	PSUPDRVTRACERSTRTAB pThis = (PSUPDRVTRACERSTRTAB)RTMemAlloc(cbThis);
1971	if (!pThis)
1972	return NULL;
1973
1974	uint32_t const cHashBits = cProbeLocs * 2 - 1;
1975	uint32_t pbmHash = (uint32_t )RTMemAllocZ(RT_ALIGN_32(cHashBits, 64) / 8 );
1976	if (!pbmHash)
1977	{
1978	RTMemFree(pThis);
1979	return NULL;
1980	}
1981
1982	/*
1983	* Calc the max string table size and save the orignal pointers so we can
1984	* replace them later.
1985	*/
1986	size_t cbMax = 1;
1987	for (uint32_t i = 0; i < cProbeLocs; i++)
1988	{
1989	pThis->apszOrgFunctions[i] = f32Bit ? paProbeLocs32[i].pszFunction : paProbeLocs64[i].pszFunction;
1990	const char pszFunction = (const char )(uintptr_t)(pThis->apszOrgFunctions[i] + offDelta);
1991	size_t cch = strlen(pszFunction);
1992	if (cch > _1K)
1993	{
1994	cbMax = 0;
1995	break;
1996	}
1997	cbMax += cch + 1;
1998	}
1999
2000	/* Alloc space for it. */
2001	if (cbMax > 0)
2002	pThis->pchStrTab = (char *)RTMemAlloc(cbMax);
2003	else
2004	pThis->pchStrTab = NULL;
2005	if (!pThis->pchStrTab)
2006	{
2007	RTMemFree(pbmHash);
2008	RTMemFree(pThis);
2009	return NULL;
2010	}
2011
2012	/*
2013	* Create the string table.
2014	*/
2015	uint32_t off = 0;
2016	uint32_t offPrev = 0;
2017
2018	for (uint32_t i = 0; i < cProbeLocs; i++)
2019	{
2020	const char * const psz = (const char *)(uintptr_t)(pThis->apszOrgFunctions[i] + offDelta);
2021	size_t const cch = strlen(psz);
2022	uint32_t const iHashBit = RTStrHash1(psz) % cHashBits;
2023	if (ASMBitTestAndSet(pbmHash, iHashBit))
2024	{
2025	/* Often it's the most recent string. */
2026	if ( off - offPrev < cch + 1
2027	\|\| memcmp(&pThis->pchStrTab[offPrev], psz, cch + 1))
2028	{
2029	/* It wasn't, search the entire string table. (lazy bird) */
2030	offPrev = 0;
2031	while (offPrev < off)
2032	{
2033	size_t cchCur = strlen(&pThis->pchStrTab[offPrev]);
2034	if ( cchCur == cch
2035	&& !memcmp(&pThis->pchStrTab[offPrev], psz, cch + 1))
2036	break;
2037	offPrev += (uint32_t)cchCur + 1;
2038	}
2039	}
2040	}
2041	else
2042	offPrev = off;
2043
2044	/* Add the string to the table. */
2045	if (offPrev >= off)
2046	{
2047	memcpy(&pThis->pchStrTab[off], psz, cch + 1);
2048	offPrev = off;
2049	off += (uint32_t)cch + 1;
2050	}
2051
2052	/* Update the entry */
2053	if (f32Bit)
2054	paProbeLocs32[i].pszFunction = offPrev;
2055	else
2056	paProbeLocs64[i].pszFunction = offPrev;
2057	}
2058
2059	pThis->cbStrTab = off;
2060	RTMemFree(pbmHash);
2061	return pThis;
2062	}
2063
2064
2065
2066	SUPR3DECL(int) SUPR3TracerRegisterModule(uintptr_t hModNative, const char pszModule, struct VTGOBJHDR pVtgHdr,
2067	RTUINTPTR uVtgHdrAddr, uint32_t fFlags)
2068	{
2069	/* Validate input. */
2070	NOREF(hModNative);
2071	AssertPtrReturn(pVtgHdr, VERR_INVALID_POINTER);
2072	AssertReturn(!memcmp(pVtgHdr->szMagic, VTGOBJHDR_MAGIC, sizeof(pVtgHdr->szMagic)), VERR_SUPDRV_VTG_MAGIC);
2073	AssertPtrReturn(pszModule, VERR_INVALID_POINTER);
2074	size_t cchModule = strlen(pszModule);
2075	AssertReturn(cchModule < RT_SIZEOFMEMB(SUPTRACERUMODREG, u.In.szName), VERR_FILENAME_TOO_LONG);
2076	AssertReturn(!RTPathHavePath(pszModule), VERR_INVALID_PARAMETER);
2077	AssertReturn(fFlags == SUP_TRACER_UMOD_FLAGS_EXE \|\| fFlags == SUP_TRACER_UMOD_FLAGS_SHARED, VERR_INVALID_PARAMETER);
2078
2079	/*
2080	* Set the probe location array offset and size members. If the size is
2081	* zero, don't bother ring-0 with it.
2082	*/
2083	if (!pVtgHdr->offProbeLocs)
2084	{
2085	uint64_t u64Tmp = pVtgHdr->uProbeLocsEnd.u64 - pVtgHdr->uProbeLocs.u64;
2086	if (u64Tmp >= UINT32_MAX)
2087	return VERR_SUPDRV_VTG_BAD_HDR_TOO_MUCH;
2088	pVtgHdr->cbProbeLocs = (uint32_t)u64Tmp;
2089
2090	u64Tmp = pVtgHdr->uProbeLocs.u64 - uVtgHdrAddr;
2091	if ((int64_t)u64Tmp != (int32_t)u64Tmp)
2092	{
2093	LogRel(("SUPR3TracerRegisterModule: VERR_SUPDRV_VTG_BAD_HDR_PTR - u64Tmp=%#llx uProbeLocs=%#llx uVtgHdrAddr=%RTptr\n",
2094	u64Tmp, pVtgHdr->uProbeLocs.u64, uVtgHdrAddr));
2095	return VERR_SUPDRV_VTG_BAD_HDR_PTR;
2096	}
2097	pVtgHdr->offProbeLocs = (int32_t)u64Tmp;
2098	}
2099
2100	if ( !pVtgHdr->cbProbeLocs
2101	\|\| !pVtgHdr->cbProbes)
2102	return VINF_SUCCESS;
2103
2104	/*
2105	* Fake out.
2106	*/
2107	if (RT_UNLIKELY(g_uSupFakeMode))
2108	return VINF_SUCCESS;
2109
2110	/*
2111	* Create a string table for the function names in the location array.
2112	* It's somewhat easier to do that here than from ring-0.
2113	*/
2114	uint32_t const cProbeLocs = pVtgHdr->cbProbeLocs
2115	/ (pVtgHdr->cBits == 32 ? sizeof(VTGPROBELOC32) : sizeof(VTGPROBELOC64));
2116	PVTGPROBELOC paProbeLocs = (PVTGPROBELOC)((uintptr_t)pVtgHdr + pVtgHdr->offProbeLocs);
2117	PSUPDRVTRACERSTRTAB pStrTab = supr3TracerCreateStrTab((PVTGPROBELOC32)paProbeLocs,
2118	(PVTGPROBELOC64)paProbeLocs,
2119	cProbeLocs, (uintptr_t)pVtgHdr - uVtgHdrAddr,
2120	pVtgHdr->cBits == 32);
2121	if (!pStrTab)
2122	return VERR_NO_MEMORY;
2123
2124
2125	/*
2126	* Issue IOCtl to the SUPDRV kernel module.
2127	*/
2128	SUPTRACERUMODREG Req;
2129	Req.Hdr.u32Cookie = g_u32Cookie;
2130	Req.Hdr.u32SessionCookie= g_u32SessionCookie;
2131	Req.Hdr.cbIn = SUP_IOCTL_TRACER_UMOD_REG_SIZE_IN;
2132	Req.Hdr.cbOut = SUP_IOCTL_TRACER_UMOD_REG_SIZE_OUT;
2133	Req.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
2134	Req.Hdr.rc = VERR_INTERNAL_ERROR;
2135	Req.u.In.uVtgHdrAddr = uVtgHdrAddr;
2136	Req.u.In.R3PtrVtgHdr = pVtgHdr;
2137	Req.u.In.R3PtrStrTab = pStrTab->pchStrTab;
2138	Req.u.In.cbStrTab = pStrTab->cbStrTab;
2139	Req.u.In.fFlags = fFlags;
2140
2141	memcpy(Req.u.In.szName, pszModule, cchModule + 1);
2142	if (!RTPathHasSuffix(Req.u.In.szName))
2143	{
2144	/* Add the default suffix if none is given. */
2145	switch (fFlags & SUP_TRACER_UMOD_FLAGS_TYPE_MASK)
2146	{
2147	#if defined(RT_OS_WINDOWS) \|\| defined(RT_OS_OS2)
2148	case SUP_TRACER_UMOD_FLAGS_EXE:
2149	if (cchModule + sizeof(".exe") <= sizeof(Req.u.In.szName))
2150	strcpy(&Req.u.In.szName[cchModule], ".exe");
2151	break;
2152	#endif
2153
2154	case SUP_TRACER_UMOD_FLAGS_SHARED:
2155	{
2156	const char *pszSuff = RTLdrGetSuff();
2157	size_t cchSuff = strlen(pszSuff);
2158	if (cchModule + cchSuff < sizeof(Req.u.In.szName))
2159	memcpy(&Req.u.In.szName[cchModule], pszSuff, cchSuff + 1);
2160	break;
2161	}
2162	}
2163	}
2164
2165	int rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_TRACER_UMOD_REG, &Req, SUP_IOCTL_TRACER_UMOD_REG_SIZE);
2166	if (RT_SUCCESS(rc))
2167	rc = Req.Hdr.rc;
2168
2169	supr3TracerDestroyStrTab(pStrTab, (PVTGPROBELOC32)paProbeLocs, (PVTGPROBELOC64)paProbeLocs,
2170	cProbeLocs, pVtgHdr->cBits == 32);
2171	return rc;
2172	}
2173
2174
2175	SUPR3DECL(int) SUPR3TracerDeregisterModule(struct VTGOBJHDR *pVtgHdr)
2176	{
2177	/* Validate input. */
2178	AssertPtrReturn(pVtgHdr, VERR_INVALID_POINTER);
2179	AssertReturn(!memcmp(pVtgHdr->szMagic, VTGOBJHDR_MAGIC, sizeof(pVtgHdr->szMagic)), VERR_SUPDRV_VTG_MAGIC);
2180
2181	/*
2182	* Don't bother if the object is empty.
2183	*/
2184	if ( !pVtgHdr->cbProbeLocs
2185	\|\| !pVtgHdr->cbProbes)
2186	return VINF_SUCCESS;
2187
2188	/*
2189	* Fake out.
2190	*/
2191	if (RT_UNLIKELY(g_uSupFakeMode))
2192	return VINF_SUCCESS;
2193
2194	/*
2195	* Issue IOCtl to the SUPDRV kernel module.
2196	*/
2197	SUPTRACERUMODDEREG Req;
2198	Req.Hdr.u32Cookie = g_u32Cookie;
2199	Req.Hdr.u32SessionCookie= g_u32SessionCookie;
2200	Req.Hdr.cbIn = SUP_IOCTL_TRACER_UMOD_REG_SIZE_IN;
2201	Req.Hdr.cbOut = SUP_IOCTL_TRACER_UMOD_REG_SIZE_OUT;
2202	Req.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
2203	Req.Hdr.rc = VERR_INTERNAL_ERROR;
2204	Req.u.In.pVtgHdr = pVtgHdr;
2205
2206	int rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_TRACER_UMOD_DEREG, &Req, SUP_IOCTL_TRACER_UMOD_DEREG_SIZE);
2207	if (RT_SUCCESS(rc))
2208	rc = Req.Hdr.rc;
2209	return rc;
2210	}
2211
2212
2213	DECLASM(void) suplibTracerFireProbe(PVTGPROBELOC pProbeLoc, PSUPTRACERUMODFIREPROBE pReq)
2214	{
2215	RT_NOREF1(pProbeLoc);
2216
2217	pReq->Hdr.u32Cookie = g_u32Cookie;
2218	pReq->Hdr.u32SessionCookie = g_u32SessionCookie;
2219	Assert(pReq->Hdr.cbIn == SUP_IOCTL_TRACER_UMOD_FIRE_PROBE_SIZE_IN);
2220	Assert(pReq->Hdr.cbOut == SUP_IOCTL_TRACER_UMOD_FIRE_PROBE_SIZE_OUT);
2221	pReq->Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
2222	pReq->Hdr.rc = VINF_SUCCESS;
2223
2224	suplibOsIOCtl(&g_supLibData, SUP_IOCTL_TRACER_UMOD_FIRE_PROBE, pReq, SUP_IOCTL_TRACER_UMOD_FIRE_PROBE_SIZE);
2225	}
2226
2227
2228	SUPR3DECL(int) SUPR3MsrProberRead(uint32_t uMsr, RTCPUID idCpu, uint64_t puValue, bool pfGp)
2229	{
2230	SUPMSRPROBER Req;
2231	Req.Hdr.u32Cookie = g_u32Cookie;
2232	Req.Hdr.u32SessionCookie = g_u32SessionCookie;
2233	Req.Hdr.cbIn = SUP_IOCTL_MSR_PROBER_SIZE_IN;
2234	Req.Hdr.cbOut = SUP_IOCTL_MSR_PROBER_SIZE_OUT;
2235	Req.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
2236	Req.Hdr.rc = VERR_INTERNAL_ERROR;
2237
2238	Req.u.In.enmOp = SUPMSRPROBEROP_READ;
2239	Req.u.In.uMsr = uMsr;
2240	Req.u.In.idCpu = idCpu == NIL_RTCPUID ? UINT32_MAX : idCpu;
2241
2242	int rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_MSR_PROBER, &Req, SUP_IOCTL_MSR_PROBER_SIZE);
2243	if (RT_SUCCESS(rc))
2244	rc = Req.Hdr.rc;
2245	if (RT_SUCCESS(rc))
2246	{
2247	if (puValue)
2248	*puValue = Req.u.Out.uResults.Read.uValue;
2249	if (pfGp)
2250	*pfGp = Req.u.Out.uResults.Read.fGp;
2251	}
2252
2253	return rc;
2254	}
2255
2256
2257	SUPR3DECL(int) SUPR3MsrProberWrite(uint32_t uMsr, RTCPUID idCpu, uint64_t uValue, bool *pfGp)
2258	{
2259	SUPMSRPROBER Req;
2260	Req.Hdr.u32Cookie = g_u32Cookie;
2261	Req.Hdr.u32SessionCookie = g_u32SessionCookie;
2262	Req.Hdr.cbIn = SUP_IOCTL_MSR_PROBER_SIZE_IN;
2263	Req.Hdr.cbOut = SUP_IOCTL_MSR_PROBER_SIZE_OUT;
2264	Req.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
2265	Req.Hdr.rc = VERR_INTERNAL_ERROR;
2266
2267	Req.u.In.enmOp = SUPMSRPROBEROP_WRITE;
2268	Req.u.In.uMsr = uMsr;
2269	Req.u.In.idCpu = idCpu == NIL_RTCPUID ? UINT32_MAX : idCpu;
2270	Req.u.In.uArgs.Write.uToWrite = uValue;
2271
2272	int rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_MSR_PROBER, &Req, SUP_IOCTL_MSR_PROBER_SIZE);
2273	if (RT_SUCCESS(rc))
2274	rc = Req.Hdr.rc;
2275	if (RT_SUCCESS(rc) && pfGp)
2276	*pfGp = Req.u.Out.uResults.Write.fGp;
2277
2278	return rc;
2279	}
2280
2281
2282	SUPR3DECL(int) SUPR3MsrProberModify(uint32_t uMsr, RTCPUID idCpu, uint64_t fAndMask, uint64_t fOrMask,
2283	PSUPMSRPROBERMODIFYRESULT pResult)
2284	{
2285	return SUPR3MsrProberModifyEx(uMsr, idCpu, fAndMask, fOrMask, false /fFaster/, pResult);
2286	}
2287
2288
2289	SUPR3DECL(int) SUPR3MsrProberModifyEx(uint32_t uMsr, RTCPUID idCpu, uint64_t fAndMask, uint64_t fOrMask, bool fFaster,
2290	PSUPMSRPROBERMODIFYRESULT pResult)
2291	{
2292	SUPMSRPROBER Req;
2293	Req.Hdr.u32Cookie = g_u32Cookie;
2294	Req.Hdr.u32SessionCookie = g_u32SessionCookie;
2295	Req.Hdr.cbIn = SUP_IOCTL_MSR_PROBER_SIZE_IN;
2296	Req.Hdr.cbOut = SUP_IOCTL_MSR_PROBER_SIZE_OUT;
2297	Req.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
2298	Req.Hdr.rc = VERR_INTERNAL_ERROR;
2299
2300	Req.u.In.enmOp = fFaster ? SUPMSRPROBEROP_MODIFY_FASTER : SUPMSRPROBEROP_MODIFY;
2301	Req.u.In.uMsr = uMsr;
2302	Req.u.In.idCpu = idCpu == NIL_RTCPUID ? UINT32_MAX : idCpu;
2303	Req.u.In.uArgs.Modify.fAndMask = fAndMask;
2304	Req.u.In.uArgs.Modify.fOrMask = fOrMask;
2305
2306	int rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_MSR_PROBER, &Req, SUP_IOCTL_MSR_PROBER_SIZE);
2307	if (RT_SUCCESS(rc))
2308	rc = Req.Hdr.rc;
2309	if (RT_SUCCESS(rc))
2310	*pResult = Req.u.Out.uResults.Modify;
2311
2312	return rc;
2313	}
2314
2315
2316	SUPR3DECL(int) SUPR3ResumeSuspendedKeyboards(void)
2317	{
2318	#ifdef RT_OS_DARWIN
2319	/*
2320	* Issue IOCtl to the SUPDRV kernel module.
2321	*/
2322	SUPREQHDR Req;
2323	Req.u32Cookie = g_u32Cookie;
2324	Req.u32SessionCookie= g_u32SessionCookie;
2325	Req.cbIn = SUP_IOCTL_RESUME_SUSPENDED_KBDS_SIZE_IN;
2326	Req.cbOut = SUP_IOCTL_RESUME_SUSPENDED_KBDS_SIZE_OUT;
2327	Req.fFlags = SUPREQHDR_FLAGS_DEFAULT;
2328	Req.rc = VERR_INTERNAL_ERROR;
2329	int rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_RESUME_SUSPENDED_KBDS, &Req, SUP_IOCTL_RESUME_SUSPENDED_KBDS_SIZE);
2330	if (RT_SUCCESS(rc))
2331	rc = Req.rc;
2332	return rc;
2333	#else /* !RT_OS_DARWIN */
2334	return VERR_NOT_SUPPORTED;
2335	#endif
2336	}
2337
2338
2339	SUPR3DECL(int) SUPR3TscDeltaMeasure(RTCPUID idCpu, bool fAsync, bool fForce, uint8_t cRetries, uint8_t cMsWaitRetry)
2340	{
2341	SUPTSCDELTAMEASURE Req;
2342	Req.Hdr.u32Cookie = g_u32Cookie;
2343	Req.Hdr.u32SessionCookie = g_u32SessionCookie;
2344	Req.Hdr.cbIn = SUP_IOCTL_TSC_DELTA_MEASURE_SIZE_IN;
2345	Req.Hdr.cbOut = SUP_IOCTL_TSC_DELTA_MEASURE_SIZE_OUT;
2346	Req.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
2347	Req.Hdr.rc = VERR_INTERNAL_ERROR;
2348
2349	Req.u.In.cRetries = cRetries;
2350	Req.u.In.fAsync = fAsync;
2351	Req.u.In.fForce = fForce;
2352	Req.u.In.idCpu = idCpu;
2353	Req.u.In.cMsWaitRetry = cMsWaitRetry;
2354
2355	int rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_TSC_DELTA_MEASURE, &Req, SUP_IOCTL_TSC_DELTA_MEASURE_SIZE);
2356	if (RT_SUCCESS(rc))
2357	rc = Req.Hdr.rc;
2358	return rc;
2359	}
2360
2361
2362	SUPR3DECL(int) SUPR3ReadTsc(uint64_t puTsc, uint16_t pidApic)
2363	{
2364	AssertReturn(puTsc, VERR_INVALID_PARAMETER);
2365
2366	SUPTSCREAD Req;
2367	Req.Hdr.u32Cookie = g_u32Cookie;
2368	Req.Hdr.u32SessionCookie = g_u32SessionCookie;
2369	Req.Hdr.cbIn = SUP_IOCTL_TSC_READ_SIZE_IN;
2370	Req.Hdr.cbOut = SUP_IOCTL_TSC_READ_SIZE_OUT;
2371	Req.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
2372	Req.Hdr.rc = VERR_INTERNAL_ERROR;
2373
2374	int rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_TSC_READ, &Req, SUP_IOCTL_TSC_READ_SIZE);
2375	if (RT_SUCCESS(rc))
2376	{
2377	rc = Req.Hdr.rc;
2378	*puTsc = Req.u.Out.u64AdjustedTsc;
2379	if (pidApic)
2380	*pidApic = Req.u.Out.idApic;
2381	}
2382	return rc;
2383	}
2384
2385
2386	SUPR3DECL(int) SUPR3GipSetFlags(uint32_t fOrMask, uint32_t fAndMask)
2387	{
2388	AssertMsgReturn(!(fOrMask & ~SUPGIP_FLAGS_VALID_MASK),
2389	("fOrMask=%#x ValidMask=%#x\n", fOrMask, SUPGIP_FLAGS_VALID_MASK), VERR_INVALID_PARAMETER);
2390	AssertMsgReturn((fAndMask & ~SUPGIP_FLAGS_VALID_MASK) == ~SUPGIP_FLAGS_VALID_MASK,
2391	("fAndMask=%#x ValidMask=%#x\n", fAndMask, SUPGIP_FLAGS_VALID_MASK), VERR_INVALID_PARAMETER);
2392
2393	SUPGIPSETFLAGS Req;
2394	Req.Hdr.u32Cookie = g_u32Cookie;
2395	Req.Hdr.u32SessionCookie = g_u32SessionCookie;
2396	Req.Hdr.cbIn = SUP_IOCTL_GIP_SET_FLAGS_SIZE_IN;
2397	Req.Hdr.cbOut = SUP_IOCTL_GIP_SET_FLAGS_SIZE_OUT;
2398	Req.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
2399	Req.Hdr.rc = VERR_INTERNAL_ERROR;
2400
2401	Req.u.In.fAndMask = fAndMask;
2402	Req.u.In.fOrMask = fOrMask;
2403
2404	int rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_GIP_SET_FLAGS, &Req, SUP_IOCTL_GIP_SET_FLAGS_SIZE);
2405	if (RT_SUCCESS(rc))
2406	rc = Req.Hdr.rc;
2407	return rc;
2408	}
2409
2410
2411	SUPR3DECL(int) SUPR3GetHwvirtMsrs(PSUPHWVIRTMSRS pHwvirtMsrs, bool fForceRequery)
2412	{
2413	AssertReturn(pHwvirtMsrs, VERR_INVALID_PARAMETER);
2414
2415	SUPGETHWVIRTMSRS Req;
2416	Req.Hdr.u32Cookie = g_u32Cookie;
2417	Req.Hdr.u32SessionCookie = g_u32SessionCookie;
2418	Req.Hdr.cbIn = SUP_IOCTL_GET_HWVIRT_MSRS_SIZE_IN;
2419	Req.Hdr.cbOut = SUP_IOCTL_GET_HWVIRT_MSRS_SIZE_OUT;
2420	Req.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
2421	Req.Hdr.rc = VERR_INTERNAL_ERROR;
2422
2423	Req.u.In.fForce = fForceRequery;
2424	Req.u.In.fReserved0 = false;
2425	Req.u.In.fReserved1 = false;
2426	Req.u.In.fReserved2 = false;
2427
2428	int rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_GET_HWVIRT_MSRS, &Req, SUP_IOCTL_GET_HWVIRT_MSRS_SIZE);
2429	if (RT_SUCCESS(rc))
2430	{
2431	rc = Req.Hdr.rc;
2432	*pHwvirtMsrs = Req.u.Out.HwvirtMsrs;
2433	}
2434	else
2435	RT_ZERO(*pHwvirtMsrs);
2436	return rc;
2437	}
2438

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/HostDrivers/Support/SUPLib.cpp@ 104434

Download in other formats: