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