SUPDrv.c revision 9888fffcfbe2d41dce14a1249b12cb88cc9b149f
faaa489e1cc905efd364e01fe09111173c95db68jeff.schenk * VBoxDrv - The VirtualBox Support Driver - Common code.
faaa489e1cc905efd364e01fe09111173c95db68jeff.schenk * Copyright (C) 2006-2015 Oracle Corporation
faaa489e1cc905efd364e01fe09111173c95db68jeff.schenk * This file is part of VirtualBox Open Source Edition (OSE), as
faaa489e1cc905efd364e01fe09111173c95db68jeff.schenk * available from http://www.virtualbox.org. This file is free software;
faaa489e1cc905efd364e01fe09111173c95db68jeff.schenk * you can redistribute it and/or modify it under the terms of the GNU
faaa489e1cc905efd364e01fe09111173c95db68jeff.schenk * General Public License (GPL) as published by the Free Software
faaa489e1cc905efd364e01fe09111173c95db68jeff.schenk * Foundation, in version 2 as it comes in the "COPYING" file of the
faaa489e1cc905efd364e01fe09111173c95db68jeff.schenk * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
faaa489e1cc905efd364e01fe09111173c95db68jeff.schenk * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
faaa489e1cc905efd364e01fe09111173c95db68jeff.schenk * The contents of this file may alternatively be used under the terms
faaa489e1cc905efd364e01fe09111173c95db68jeff.schenk * of the Common Development and Distribution License Version 1.0
faaa489e1cc905efd364e01fe09111173c95db68jeff.schenk * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
faaa489e1cc905efd364e01fe09111173c95db68jeff.schenk * VirtualBox OSE distribution, in which case the provisions of the
faaa489e1cc905efd364e01fe09111173c95db68jeff.schenk * CDDL are applicable instead of those of the GPL.
faaa489e1cc905efd364e01fe09111173c95db68jeff.schenk * You may elect to license modified versions of this file under the
faaa489e1cc905efd364e01fe09111173c95db68jeff.schenk * terms and conditions of either the GPL or the CDDL or both.
#define SUPDRV_AGNOSTIC
#include "SUPDrvInternal.h"
#ifndef PAGE_SHIFT
* instantiation in log-vbox.c(pp).
#ifndef VBOX_SVN_REV
# define VBOX_SVN_REV 0
static DECLCALLBACK(int) supdrvSessionObjHandleRetain(RTHANDLETABLE hHandleTable, void *pvObj, void *pvCtx, void *pvUser);
static DECLCALLBACK(void) supdrvSessionObjHandleDelete(RTHANDLETABLE hHandleTable, uint32_t h, void *pvObj, void *pvCtx, void *pvUser);
static int supdrvIOCtl_LdrGetSymbol(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPLDRGETSYMBOL pReq);
static int supdrvIDC_LdrGetSymbol(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPDRVIDCREQGETSYM pReq);
static int supdrvLdrSetVMMR0EPs(PSUPDRVDEVEXT pDevExt, void *pvVMMR0, void *pvVMMR0EntryInt,void *pvVMMR0EntryFast, void *pvVMMR0EntryEx);
static int supdrvIOCtl_CallServiceModule(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPCALLSERVICE pReq);
static int supdrvIOCtl_LoggerSettings(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPLOGGERSETTINGS pReq);
static int supdrvIOCtl_ResumeSuspendedKbds(void);
int rc;
#ifdef SUPDRV_WITH_RELEASE_LOGGER
"VBOX_RELEASE_LOG", RT_ELEMENTS(s_apszGroups), s_apszGroups, RTLOGDEST_STDOUT | RTLOGDEST_DEBUGGER, NULL);
memset(pDevExt, 0, sizeof(*pDevExt)); /* Does not wipe OS specific tail section of the structure. */
rc = RTSpinlockCreate(&pDevExt->hSessionHashTabSpinlock, RTSPINLOCK_FLAGS_INTERRUPT_SAFE, "SUPDrvSession");
#ifdef SUPDRV_USE_MUTEX_FOR_LDR
#ifdef SUPDRV_USE_MUTEX_FOR_LDR
#ifdef RT_OS_DARWIN
return VINF_SUCCESS;
#ifdef SUPDRV_USE_MUTEX_FOR_GIP
#ifdef SUPDRV_USE_MUTEX_FOR_LDR
#ifdef SUPDRV_WITH_RELEASE_LOGGER
return rc;
#ifdef SUPDRV_USE_MUTEX_FOR_GIP
#ifdef SUPDRV_USE_MUTEX_FOR_LDR
while (pObj)
while (pUsage)
#ifdef SUPDRV_WITH_RELEASE_LOGGER
int VBOXCALL supdrvCreateSession(PSUPDRVDEVEXT pDevExt, bool fUser, bool fUnrestricted, PSUPDRVSESSION *ppSession)
int rc;
return VERR_INVALID_PARAMETER;
if (pSession)
if (!rc)
if (fUser)
pSession->Bundle.cUsed = 0; */
return VINF_SUCCESS;
return rc;
int rc;
AssertReleaseMsg(pSession->R0Process == RTR0ProcHandleSelf() || pSession->R0Process == NIL_RTR0PROCESS,
AssertMsg(pUsage->cUsage >= 1 && pObj->cUsage >= pUsage->cUsage, ("glob %d; sess %d\n", pObj->cUsage, pUsage->cUsage));
pObj, pObj->enmType, pObj->pvUser1, pObj->pvUser2, pObj->CreatorProcess, RTProcSelf(), pObj->pfnDestructor));
while (pBundle)
Log2(("eType=%d pvR0=%p pvR3=%p cb=%ld\n", pBundle->aMem[i].eType, RTR0MemObjAddress(pBundle->aMem[i].MemObj),
(void *)RTR0MemObjAddressR3(pBundle->aMem[i].MapObjR3), (long)RTR0MemObjSize(pBundle->aMem[i].MemObj)));
while (pCur)
if (pPrev)
while (pUsage)
int VBOXCALL supdrvSessionHashTabInsert(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPDRVSESSION *ppOsSessionPtr,
void *pvUser)
unsigned iHash;
if (pCur)
if (pCur)
AssertFailed();
return VERR_WRONG_ORDER;
return VERR_RESOURCE_IN_USE;
return VERR_DUPLICATE;
if (ppOsSessionPtr)
return VINF_SUCCESS;
int VBOXCALL supdrvSessionHashTabRemove(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, void *pvUser)
unsigned iHash;
if (pCur)
return VERR_NOT_FOUND;
if (cRefs == 0)
return VINF_SUCCESS;
PSUPDRVSESSION VBOXCALL supdrvSessionHashTabLookup(PSUPDRVDEVEXT pDevExt, RTPROCESS Process, RTR0PROCESS R0Process,
unsigned iHash;
if (ppOsSessionPtr)
if ( pCur
while ( pCur
if (pCur)
return pCur;
return cRefs;
if (cRefs == 0)
return cRefs;
static DECLCALLBACK(int) supdrvSessionObjHandleRetain(RTHANDLETABLE hHandleTable, void *pvObj, void *pvCtx, void *pvUser)
static DECLCALLBACK(void) supdrvSessionObjHandleDelete(RTHANDLETABLE hHandleTable, uint32_t h, void *pvObj, void *pvCtx, void *pvUser)
NOREF(h);
int VBOXCALL supdrvIOCtlFast(uintptr_t uIOCtl, VMCPUID idCpu, PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession)
switch (uIOCtl)
case SUP_IOCTL_FAST_DO_HM_RUN:
case SUP_IOCTL_FAST_DO_NOP:
return VERR_INTERNAL_ERROR;
return VINF_SUCCESS;
return VERR_INTERNAL_ERROR;
int chCur;
while (offInv-- > 0)
static int supdrvIOCtlInnerUnrestricted(uintptr_t uIOCtl, PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPREQHDR pReqHdr)
OSDBGPRINT(( #Name ": Invalid input/output sizes. cbIn=%ld expected %ld. cbOut=%ld expected %ld.\n", \
REQ_CHECK_SIZES_EX(SUP_IOCTL_QUERY_FUNCS, SUP_IOCTL_QUERY_FUNCS_SIZE_IN, SUP_IOCTL_QUERY_FUNCS_SIZE_OUT(RT_ELEMENTS(g_aFunctions)));
pReq->Hdr.rc = SUPR0ContAlloc(pSession, pReq->u.In.cPages, &pReq->u.Out.pvR0, &pReq->u.Out.pvR3, &pReq->u.Out.HCPhys);
REQ_CHECK_SIZES_EX(SUP_IOCTL_LDR_LOAD, SUP_IOCTL_LDR_LOAD_SIZE_IN(pReq->u.In.cbImageWithTabs), SUP_IOCTL_LDR_LOAD_SIZE_OUT);
("SUP_IOCTL_LDR_LOAD: offSymbols=%#lx cSymbols=%#lx cbImageWithTabs=%#lx\n", (long)pReq->u.In.offSymbols,
("SUP_IOCTL_LDR_LOAD: offStrTab=%#lx cbStrTab=%#lx cbImageWithTabs=%#lx\n", (long)pReq->u.In.offStrTab,
uint32_t i;
("SUP_IOCTL_LDR_LOAD: sym #%ld: symb off %#lx (max=%#lx)\n", (long)i, (long)paSyms[i].offSymbol, (long)pReq->u.In.cbImageWithTabs));
("SUP_IOCTL_LDR_LOAD: sym #%ld: name off %#lx (max=%#lx)\n", (long)i, (long)paSyms[i].offName, (long)pReq->u.In.cbImageWithTabs));
REQ_CHECK_EXPR_FMT(RTStrEnd((char const *)&pReq->u.In.abImage[pReq->u.In.offStrTab + paSyms[i].offName],
("SUP_IOCTL_LDR_LOAD: sym #%ld: unterminated name! (%#lx / %#lx)\n", (long)i, (long)paSyms[i].offName, (long)pReq->u.In.cbImageWithTabs));
REQ_CHECK_EXPR(SUP_IOCTL_LDR_GET_SYMBOL, RTStrEnd(pReq->u.In.szSymbol, sizeof(pReq->u.In.szSymbol)));
REQ_CHECK_SIZES_EX(SUP_IOCTL_CALL_VMMR0, SUP_IOCTL_CALL_VMMR0_SIZE_IN(0), SUP_IOCTL_CALL_VMMR0_SIZE_OUT(0));
pReq->Hdr.rc = pDevExt->pfnVMMR0EntryEx(pReq->u.In.pVMR0, pReq->u.In.idCpu, pReq->u.In.uOperation, NULL, pReq->u.In.u64Arg, pSession);
("SUP_IOCTL_CALL_VMMR0: cbIn=%#x < %#lx\n", pReq->Hdr.cbIn, SUP_IOCTL_CALL_VMMR0_SIZE(sizeof(SUPVMMR0REQHDR))));
REQ_CHECK_SIZES_EX(SUP_IOCTL_CALL_VMMR0, SUP_IOCTL_CALL_VMMR0_SIZE_IN(pVMMReq->cbReq), SUP_IOCTL_CALL_VMMR0_SIZE_OUT(pVMMReq->cbReq));
pReq->Hdr.rc = pDevExt->pfnVMMR0EntryEx(pReq->u.In.pVMR0, pReq->u.In.idCpu, pReq->u.In.uOperation, pVMMReq, pReq->u.In.u64Arg, pSession);
pReq->Hdr.rc, pReq->u.In.uOperation, pReq->Hdr.cbOut, pReq->u.In.u64Arg, RTProcSelf(), RTThreadNativeSelf()));
pReq->Hdr.rc, pReq->u.In.uOperation, pReq->Hdr.cbOut, pReq->u.In.u64Arg, RTProcSelf(), RTThreadNativeSelf()));
("SUP_IOCTL_CALL_VMMR0_BIG: cbIn=%#x < %#lx\n", pReq->Hdr.cbIn, SUP_IOCTL_CALL_VMMR0_BIG_SIZE(sizeof(SUPVMMR0REQHDR))));
REQ_CHECK_SIZES_EX(SUP_IOCTL_CALL_VMMR0_BIG, SUP_IOCTL_CALL_VMMR0_BIG_SIZE_IN(pVMMReq->cbReq), SUP_IOCTL_CALL_VMMR0_BIG_SIZE_OUT(pVMMReq->cbReq));
pReq->Hdr.rc = pDevExt->pfnVMMR0EntryEx(pReq->u.In.pVMR0, pReq->u.In.idCpu, pReq->u.In.uOperation, pVMMReq, pReq->u.In.u64Arg, pSession);
pReq->Hdr.rc, pReq->u.In.uOperation, pReq->Hdr.cbOut, pReq->u.In.u64Arg, RTProcSelf(), RTThreadNativeSelf()));
pReq->Hdr.rc, pReq->u.In.uOperation, pReq->Hdr.cbOut, pReq->u.In.u64Arg, RTProcSelf(), RTThreadNativeSelf()));
REQ_CHECK_SIZES_EX(SUP_IOCTL_LOW_ALLOC, SUP_IOCTL_LOW_ALLOC_SIZE_IN, SUP_IOCTL_LOW_ALLOC_SIZE_OUT(pReq->u.In.cPages));
pReq->Hdr.rc = SUPR0LowAlloc(pSession, pReq->u.In.cPages, &pReq->u.Out.pvR0, &pReq->u.Out.pvR3, &pReq->u.Out.aPages[0]);
REQ_CHECK_SIZES_EX(SUP_IOCTL_PAGE_ALLOC_EX, SUP_IOCTL_PAGE_ALLOC_EX_SIZE_IN, SUP_IOCTL_PAGE_ALLOC_EX_SIZE_OUT(pReq->u.In.cPages));
("SUP_IOCTL_PAGE_ALLOC_EX: fReserved0=%d fReserved1=%d\n", pReq->u.In.fReserved0, pReq->u.In.fReserved1));
REQ_CHECK_EXPR_FMT(!pReq->u.In.fFlags, ("SUP_IOCTL_PAGE_MAP_KERNEL: fFlags=%#x! MBZ\n", pReq->u.In.fFlags));
REQ_CHECK_EXPR_FMT(!(pReq->u.In.offSub & PAGE_OFFSET_MASK), ("SUP_IOCTL_PAGE_MAP_KERNEL: offSub=%#x\n", pReq->u.In.offSub));
REQ_CHECK_EXPR_FMT(!(pReq->u.In.fProt & ~(RTMEM_PROT_READ | RTMEM_PROT_WRITE | RTMEM_PROT_EXEC | RTMEM_PROT_NONE)),
REQ_CHECK_EXPR_FMT(!(pReq->u.In.offSub & PAGE_OFFSET_MASK), ("SUP_IOCTL_PAGE_PROTECT: offSub=%#x\n", pReq->u.In.offSub));
pReq->Hdr.rc = SUPR0PageProtect(pSession, pReq->u.In.pvR3, pReq->u.In.pvR0, pReq->u.In.offSub, pReq->u.In.cbSub, pReq->u.In.fProt);
REQ_CHECK_SIZES_EX(SUP_IOCTL_CALL_SERVICE, SUP_IOCTL_CALL_SERVICE_SIZE_IN(0), SUP_IOCTL_CALL_SERVICE_SIZE_OUT(0));
("SUP_IOCTL_CALL_SERVICE: cbIn=%#x < %#lx\n", pReq->Hdr.cbIn, SUP_IOCTL_CALL_SERVICE_SIZE(sizeof(SUPR0SERVICEREQHDR))));
REQ_CHECK_SIZES_EX(SUP_IOCTL_CALL_SERVICE, SUP_IOCTL_CALL_SERVICE_SIZE_IN(pSrvReq->cbReq), SUP_IOCTL_CALL_SERVICE_SIZE_OUT(pSrvReq->cbReq));
case SUP_SEM_TYPE_EVENT:
case SUPSEMOP2_WAIT_MS_REL:
case SUPSEMOP2_WAIT_NS_ABS:
case SUPSEMOP2_WAIT_NS_REL:
case SUPSEMOP2_SIGNAL:
case SUPSEMOP2_CLOSE:
case SUPSEMOP2_RESET:
case SUP_SEM_TYPE_EVENT_MULTI:
case SUPSEMOP2_WAIT_MS_REL:
case SUPSEMOP2_WAIT_NS_ABS:
case SUPSEMOP2_WAIT_NS_REL:
case SUPSEMOP2_SIGNAL:
case SUPSEMOP2_CLOSE:
case SUPSEMOP2_RESET:
case SUP_SEM_TYPE_EVENT:
case SUPSEMOP3_CREATE:
case SUPSEMOP3_GET_RESOLUTION:
case SUP_SEM_TYPE_EVENT_MULTI:
case SUPSEMOP3_CREATE:
case SUPSEMOP3_GET_RESOLUTION:
pReqHdr->rc = supdrvIOCtl_TracerIOCtl(pDevExt, pSession, pReq->u.In.uCmd, pReq->u.In.uArg, &pReq->u.Out.iRetVal);
return VERR_INVALID_PARAMETER;
return VERR_GENERAL_FAILURE;
static int supdrvIOCtlInnerRestricted(uintptr_t uIOCtl, PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPREQHDR pReqHdr)
return VERR_GENERAL_FAILURE;
int VBOXCALL supdrvIOCtl(uintptr_t uIOCtl, PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPREQHDR pReqHdr, size_t cbReq)
int rc;
return VERR_INVALID_PARAMETER;
return VERR_INVALID_PARAMETER;
return VERR_INVALID_PARAMETER;
return VERR_INVALID_PARAMETER;
OSDBGPRINT(("vboxdrv: bad cookie %#lx / %#lx.\n", (long)pReqHdr->u32Cookie, (long)pReqHdr->u32SessionCookie));
return VERR_INVALID_PARAMETER;
return rc;
int VBOXCALL supdrvIDC(uintptr_t uReq, PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPDRVIDCREQHDR pReqHdr)
return VERR_INVALID_PARAMETER;
switch (uReq)
case SUPDRV_IDC_REQ_CONNECT:
|| (pReq->u.In.uMinVersion & UINT32_C(0xffff0000)) != (pReq->u.In.uReqVersion & UINT32_C(0xffff0000)))
return VINF_SUCCESS;
return VINF_SUCCESS;
return VINF_SUCCESS;
return VINF_SUCCESS;
return VINF_SUCCESS;
return VINF_SUCCESS;
return VERR_NOT_SUPPORTED;
* @param pfnDestructor The destructore function which will be called when the reference count reaches 0.
SUPR0DECL(void *) SUPR0ObjRegister(PSUPDRVSESSION pSession, SUPDRVOBJTYPE enmType, PFNSUPDRVDESTRUCTOR pfnDestructor, void *pvUser1, void *pvUser2)
if (!pObj)
return NULL;
if (pUsage)
if (!pUsage)
return NULL;
/* Log2(("SUPR0ObjRegister: pUsage=%p:{.pObj=%p, .pNext=%p}\n", pUsage, pUsage->pObj, pUsage->pNext)); */
return pObj;
("Invalid pvObj=%p magic=%#x (expected %#x or %#x)\n", pvObj, pObj->u32Magic, SUPDRVOBJ_MAGIC, SUPDRVOBJ_MAGIC_DEAD),
return VERR_WRONG_ORDER;
if (pUsagePre)
else if (!fNoBlocking)
if (!pUsagePre)
return VERR_NO_MEMORY;
return VERR_WRONG_ORDER;
if (pUsage)
else if (pUsagePre)
/*Log(("SUPR0AddRef: pUsagePre=%p:{.pObj=%p, .pNext=%p}\n", pUsagePre, pUsagePre->pObj, pUsagePre->pNext));*/
if (pUsagePre)
return rc;
/*Log2(("SUPR0ObjRelease: pUsage=%p:{.pObj=%p, .pNext=%p}\n", pUsage, pUsage->pObj, pUsage->pNext));*/
AssertMsg(pUsage->cUsage >= 1 && pObj->cUsage >= pUsage->cUsage, ("glob %d; sess %d\n", pObj->cUsage, pUsage->cUsage));
if (pUsagePrev)
pObj, pObj->enmType, pObj->pvUser1, pObj->pvUser2, pObj->CreatorProcess, RTProcSelf(), pObj->pfnDestructor));
return rc;
int rc;
return rc;
return VINF_SUCCESS;
return VERR_PERMISSION_DENIED;
SUPR0DECL(int) SUPR0LockMem(PSUPDRVSESSION pSession, RTR3PTR pvR3, uint32_t cPages, PRTHCPHYS paPages)
int rc;
LogFlow(("SUPR0LockMem: pSession=%p pvR3=%p cPages=%d paPages=%p\n", pSession, (void *)pvR3, cPages, paPages));
|| !pvR3)
return VERR_INVALID_PARAMETER;
rc = RTR0MemObjLockUser(&Mem.MemObj, pvR3, cb, RTMEM_PROT_READ | RTMEM_PROT_WRITE, RTR0ProcHandleSelf());
AssertMsg(RTR0MemObjAddressR3(Mem.MemObj) == pvR3, ("%p == %p\n", RTR0MemObjAddressR3(Mem.MemObj), pvR3));
while (iPage-- > 0)
return rc;
SUPR0DECL(int) SUPR0ContAlloc(PSUPDRVSESSION pSession, uint32_t cPages, PRTR0PTR ppvR0, PRTR3PTR ppvR3, PRTHCPHYS pHCPhys)
int rc;
LogFlow(("SUPR0ContAlloc: pSession=%p cPages=%d ppvR0=%p ppvR3=%p pHCPhys=%p\n", pSession, cPages, ppvR0, ppvR3, pHCPhys));
return VERR_INVALID_PARAMETER;
return VERR_PAGE_COUNT_OUT_OF_RANGE;
int rc2;
if (!rc)
return rc;
SUPR0DECL(int) SUPR0LowAlloc(PSUPDRVSESSION pSession, uint32_t cPages, PRTR0PTR ppvR0, PRTR3PTR ppvR3, PRTHCPHYS paPages)
unsigned iPage;
int rc;
LogFlow(("SUPR0LowAlloc: pSession=%p cPages=%d ppvR3=%p ppvR0=%p paPages=%p\n", pSession, cPages, ppvR3, ppvR0, paPages));
return VERR_INVALID_PARAMETER;
return VERR_PAGE_COUNT_OUT_OF_RANGE;
int rc2;
if (!rc)
return rc;
int rc;
return VERR_INVALID_PARAMETER;
int rc2;
if (!rc)
return VINF_SUCCESS;
return rc;
SUPR0DECL(int) SUPR0MemGetPhys(PSUPDRVSESSION pSession, RTHCUINTPTR uPtr, PSUPPAGE paPages) /** @todo switch this bugger to RTHCPHYS */
return VINF_SUCCESS;
return VERR_INVALID_PARAMETER;
SUPR0DECL(int) SUPR0PageAllocEx(PSUPDRVSESSION pSession, uint32_t cPages, uint32_t fFlags, PRTR3PTR ppvR3, PRTR0PTR ppvR0, PRTHCPHYS paPages)
int rc;
* Validate input. The allowed allocation size must be at least equal to the maximum guest VRAM size.
Log(("SUPR0PageAlloc: Illegal request cb=%u; must be greater than 0 and smaller than %uMB (VBOX_MAX_ALLOC_PAGE_COUNT pages).\n", cPages, VBOX_MAX_ALLOC_PAGE_COUNT * (_1M / _4K)));
return VERR_PAGE_COUNT_OUT_OF_RANGE;
if (ppvR0)
int rc2;
if (ppvR3)
if (!rc)
if (ppvR3)
if (ppvR0)
if (paPages)
while (iPage-- > 0)
return VINF_SUCCESS;
return rc;
SUPR0DECL(int) SUPR0PageMapKernel(PSUPDRVSESSION pSession, RTR3PTR pvR3, uint32_t offSub, uint32_t cbSub,
int rc;
LogFlow(("SUPR0PageMapKernel: pSession=%p pvR3=%p offSub=%#x cbSub=%#x\n", pSession, pvR3, offSub, cbSub));
* Validate input. The allowed allocation size must be at least equal to the maximum guest VRAM size.
return rc;
SUPR0DECL(int) SUPR0PageProtect(PSUPDRVSESSION pSession, RTR3PTR pvR3, RTR0PTR pvR0, uint32_t offSub, uint32_t cbSub, uint32_t fProt)
int rc;
LogFlow(("SUPR0PageProtect: pSession=%p pvR3=%p pvR0=%p offSub=%#x cbSub=%#x fProt-%#x\n", pSession, pvR3, pvR0, offSub, cbSub, fProt));
* Validate input. The allowed allocation size must be at least equal to the maximum guest VRAM size.
AssertReturn(!(fProt & ~(RTMEM_PROT_READ | RTMEM_PROT_WRITE | RTMEM_PROT_EXEC | RTMEM_PROT_NONE)), VERR_INVALID_PARAMETER);
return rc;
case X86_CR4_PGE:
case X86_CR4_PAE:
return enmMode;
#ifdef RT_OS_DARWIN
return VERR_NOT_SUPPORTED;
#ifdef RT_OS_DARWIN
return supdrvOSSuspendVTxOnCpu();
#ifdef RT_OS_DARWIN
bool fMaybeSmxMode;
bool fMsrLocked;
bool fSmxVmxAllowed;
bool fVmxAllowed;
bool fIsSmxModeAmbiguous;
int rc;
fIsSmxModeAmbiguous = false;
if (fMsrLocked)
else if (!fMaybeSmxMode)
if (fVmxAllowed)
fIsSmxModeAmbiguous = true;
if (pfIsSmxModeAmbiguous)
return rc;
int rc;
if (fInitSvm)
return rc;
bool fIsSmxModeAmbiguous = false;
*pfCaps = 0;
/* We may modify MSRs and re-read them, disable preemption so we make sure we don't migrate CPUs. */
if (ASMHasCpuId())
if (fIsSmxModeAmbiguous)
SUPR0Printf(("WARNING! CR4 hints SMX mode but your CPU is too secretive. Proceeding anyway... We wish you good luck!\n"));
return rc;
const char *psz;
int rc;
if (pNewReg)
if (!pCur)
if (pPrev)
return rc;
int rc;
if (pCur)
if (!pPrev)
return rc;
SUPR0DECL(int) SUPR0ComponentQueryFactory(PSUPDRVSESSION pSession, const char *pszName, const char *pszInterfaceUuid, void **ppvFactoryIf)
const char *pszEnd;
int rc;
while (pCur)
void *pvFactory = pCur->pFactory->pfnQueryFactoryInterface(pCur->pFactory, pSession, pszInterfaceUuid);
if (pvFactory)
return rc;
return VINF_SUCCESS;
if (!pBundle)
return VERR_NO_MEMORY;
return VINF_SUCCESS;
if (!uPtr)
return VERR_INVALID_PARAMETER;
return VINF_SUCCESS;
return VERR_INVALID_PARAMETER;
int rc;
void *pv;
LogFlow(("supdrvIOCtl_LdrOpen: szName=%s cbImageWithTabs=%d\n", pReq->u.In.szName, pReq->u.In.cbImageWithTabs));
/** @todo check cbImageBits and cbImageWithTabs here, if they differs that indicates that the images are different. */
return VINF_SUCCESS;
Log(("supdrvIOCtl_LdrOpen: Not adding '%s' to image list, loader interface is locked down!\n", pReq->u.In.szName));
return VERR_PERMISSION_DENIED;
if (!pv)
return rc;
return VINF_SUCCESS;
return VERR_INVALID_PARAMETER;
return rc;
return VINF_SUCCESS;
int rc;
LogFlow(("supdrvIOCtl_LdrLoad: pvImageBase=%p cbImageWithBits=%d\n", pReq->u.In.pvImageBase, pReq->u.In.cbImageWithTabs));
if (!pUsage)
return VERR_INVALID_HANDLE;
return VERR_INVALID_HANDLE;
return VERR_ALREADY_LOADED;
Log(("SUP_IOCTL_LDR_LOAD: Not loading '%s' image bits, loader interface is locked down!\n", pImage->szName));
return VERR_PERMISSION_DENIED;
case SUPLDRLOADEP_NOTHING:
case SUPLDRLOADEP_VMMR0:
rc = supdrvLdrValidatePointer( pDevExt, pImage, pReq->u.In.EP.VMMR0.pvVMMR0, false, pReq->u.In.abImage, "pvVMMR0");
rc = supdrvLdrValidatePointer(pDevExt, pImage, pReq->u.In.EP.VMMR0.pvVMMR0EntryInt, false, pReq->u.In.abImage, "pvVMMR0EntryInt");
rc = supdrvLdrValidatePointer(pDevExt, pImage, pReq->u.In.EP.VMMR0.pvVMMR0EntryFast, false, pReq->u.In.abImage, "pvVMMR0EntryFast");
rc = supdrvLdrValidatePointer(pDevExt, pImage, pReq->u.In.EP.VMMR0.pvVMMR0EntryEx, false, pReq->u.In.abImage, "pvVMMR0EntryEx");
return rc;
case SUPLDRLOADEP_SERVICE:
rc = supdrvLdrValidatePointer(pDevExt, pImage, pReq->u.In.EP.Service.pfnServiceReq, false, pReq->u.In.abImage, "pfnServiceReq");
return rc;
return VERR_INVALID_PARAMETER;
return VERR_INVALID_PARAMETER;
rc = supdrvLdrValidatePointer(pDevExt, pImage, pReq->u.In.pfnModuleInit, true, pReq->u.In.abImage, "pfnModuleInit");
return rc;
rc = supdrvLdrValidatePointer(pDevExt, pImage, pReq->u.In.pfnModuleTerm, true, pReq->u.In.abImage, "pfnModuleTerm");
return rc;
case SUPLDRLOADEP_NOTHING:
case SUPLDRLOADEP_VMMR0:
rc = supdrvLdrSetVMMR0EPs(pDevExt, pReq->u.In.EP.VMMR0.pvVMMR0, pReq->u.In.EP.VMMR0.pvVMMR0EntryInt,
case SUPLDRLOADEP_SERVICE:
return rc;
int rc;
if (!pUsage)
return VERR_INVALID_HANDLE;
if (RT_UNLIKELY((uintptr_t)pGenUsage->pObj->pfnDestructor - (uintptr_t)pImage->pvImage < pImage->cbImageBits))
if (pUsagePrev)
return rc;
return VINF_SUCCESS;
static int supdrvIOCtl_LdrGetSymbol(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPLDRGETSYMBOL pReq)
uint32_t i;
const char *pchStrings;
Log3(("supdrvIOCtl_LdrGetSymbol: pvImageBase=%p szSymbol=\"%s\"\n", pReq->u.In.pvImageBase, pReq->u.In.szSymbol));
if (!pUsage)
return VERR_INVALID_HANDLE;
return VERR_ALREADY_LOADED;
return rc;
static int supdrvIDC_LdrGetSymbol(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPDRVIDCREQGETSYM pReq)
char const *pszEnd;
uint32_t i;
if (pszModule)
Log3(("supdrvIDC_LdrGetSymbol: pszModule=%p:{%s} pszSymbol=%p:{%s}\n", pszModule, pszModule, pszSymbol, pszSymbol));
if ( !pszModule
return rc;
static int supdrvLdrSetVMMR0EPs(PSUPDRVDEVEXT pDevExt, void *pvVMMR0, void *pvVMMR0EntryInt, void *pvVMMR0EntryFast, void *pvVMMR0EntryEx)
return rc;
while (pUsage)
return VINF_SUCCESS;
return VINF_SUCCESS;
Log(("supdrvLdrFree: Warning: unloading '%s' image, while loader interface is locked down!\n", pImage->szName));
if (pImagePrev)
unsigned cObjs = 0;
cObjs++;
if (cObjs)
#ifdef SUPDRV_USE_MUTEX_FOR_LDR
return rc;
#ifdef SUPDRV_USE_MUTEX_FOR_LDR
static int supdrvIOCtl_CallServiceModule(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPCALLSERVICE pReq)
int rc;
if (pfnServiceReqHandler)
rc = pfnServiceReqHandler(pSession, pReq->u.In.uOperation, pReq->u.In.u64Arg, (PSUPR0SERVICEREQHDR)&pReq->abReqPkt[0]);
rc, pReq->u.In.uOperation, pReq->Hdr.cbOut, pReq->u.In.u64Arg, RTProcSelf(), RTThreadNativeSelf()));
rc, pReq->u.In.uOperation, pReq->Hdr.cbOut, pReq->u.In.u64Arg, RTProcSelf(), RTThreadNativeSelf()));
return rc;
return VERR_NOT_IMPLEMENTED;
static int supdrvIOCtl_LoggerSettings(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPLOGGERSETTINGS pReq)
int rc;
return VERR_INVALID_PARAMETER;
return VERR_ACCESS_DENIED;
return VERR_INTERNAL_ERROR;
return VERR_INTERNAL_ERROR;
if (pLogger)
if (pLogger)
NULL);
return rc;
#ifdef SUPDRV_WITH_MSR_PROBER
int rc;
case SUPMSRPROBEROP_READ:
case SUPMSRPROBEROP_WRITE:
case SUPMSRPROBEROP_MODIFY:
return VERR_INVALID_FUNCTION;
return rc;
return VERR_NOT_IMPLEMENTED;
static int supdrvIOCtl_ResumeSuspendedKbds(void)
#if defined(RT_OS_DARWIN)
return supdrvDarwinResumeSuspendedKbds();
return VERR_NOT_IMPLEMENTED;