SUPDrv.c revision 8ddb51786b506ba3395546aa1af6cac6d3114e1c
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync/* $Revision$ */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * VBoxDrv - The VirtualBox Support Driver - Common code.
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * Copyright (C) 2006-2007 Sun Microsystems, Inc.
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * This file is part of VirtualBox Open Source Edition (OSE), as
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * available from http://www.virtualbox.org. This file is free software;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * you can redistribute it and/or modify it under the terms of the GNU
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * General Public License (GPL) as published by the Free Software
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * Foundation, in version 2 as it comes in the "COPYING" file of the
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * The contents of this file may alternatively be used under the terms
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * of the Common Development and Distribution License Version 1.0
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * VirtualBox OSE distribution, in which case the provisions of the
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * CDDL are applicable instead of those of the GPL.
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * You may elect to license modified versions of this file under the
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * terms and conditions of either the GPL or the CDDL or both.
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * Clara, CA 95054 USA or visit http://www.sun.com if you need
dc959f60f6d3e0cba86f7da4d39aa475913a7e10vboxsync * additional information or have any questions.
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync/*******************************************************************************
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync* Header Files *
dc959f60f6d3e0cba86f7da4d39aa475913a7e10vboxsync*******************************************************************************/
dc959f60f6d3e0cba86f7da4d39aa475913a7e10vboxsync#if defined(RT_OS_DARWIN) || defined(RT_OS_SOLARIS) || defined(RT_OS_FREEBSD)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync/* VBox/x86.h not compatible with the Linux kernel sources */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * Logging assignments:
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * Log - useful stuff, like failures.
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * LogFlow - program flow, except the really noisy bits.
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * Log2 - Cleanup.
dc959f60f6d3e0cba86f7da4d39aa475913a7e10vboxsync * Log3 - Loader flow noise.
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * Log4 - Call VMMR0 flow noise.
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * Log5 - Native yet-to-be-defined noise.
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * Log6 - Native ioctl flow noise.
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * Logging requires BUILD_TYPE=debug and possibly changes to the logger
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * instanciation in log-vbox.c(pp).
dc959f60f6d3e0cba86f7da4d39aa475913a7e10vboxsync/*******************************************************************************
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync* Defined Constants And Macros *
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync*******************************************************************************/
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync/* from x86.h - clashes with linux thus this duplication */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync#define X86_CPUID_AMD_FEATURE_EDX_LONG_MODE RT_BIT(29)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync/** The frequency by which we recalculate the u32UpdateHz and
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * u32UpdateIntervalNS GIP members. The value must be a power of 2. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * Validates a session pointer.
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * @returns true/false accordingly.
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * @param pSession The session.
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync/** @def VBOX_SVN_REV
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * The makefile should define this if it can. */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync/*******************************************************************************
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync* Internal Functions *
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync*******************************************************************************/
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic DECLCALLBACK(int) supdrvSessionObjHandleRetain(RTHANDLETABLE hHandleTable, void *pvObj, void *pvCtx, void *pvUser);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic DECLCALLBACK(void) supdrvSessionObjHandleDelete(RTHANDLETABLE hHandleTable, uint32_t h, void *pvObj, void *pvCtx, void *pvUser);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic int supdrvMemAdd(PSUPDRVMEMREF pMem, PSUPDRVSESSION pSession);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic int supdrvMemRelease(PSUPDRVSESSION pSession, RTHCUINTPTR uPtr, SUPDRVMEMREFTYPE eType);
dc959f60f6d3e0cba86f7da4d39aa475913a7e10vboxsyncstatic int supdrvIOCtl_LdrOpen(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPLDROPEN pReq);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic int supdrvIOCtl_LdrLoad(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPLDRLOAD pReq);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic int supdrvIOCtl_LdrFree(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPLDRFREE pReq);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic int supdrvIOCtl_LdrGetSymbol(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPLDRGETSYMBOL pReq);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic int supdrvIDC_LdrGetSymbol(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPDRVIDCREQGETSYM pReq);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic int supdrvLdrSetVMMR0EPs(PSUPDRVDEVEXT pDevExt, void *pvVMMR0, void *pvVMMR0EntryInt, void *pvVMMR0EntryFast, void *pvVMMR0EntryEx);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic void supdrvLdrUnsetVMMR0EPs(PSUPDRVDEVEXT pDevExt);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic int supdrvLdrAddUsage(PSUPDRVSESSION pSession, PSUPDRVLDRIMAGE pImage);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic void supdrvLdrFree(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic int supdrvIOCtl_CallServiceModule(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPCALLSERVICE pReq);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic int supdrvIOCtl_LoggerSettings(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPLOGGERSETTINGS pReq);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic SUPGIPMODE supdrvGipDeterminTscMode(PSUPDRVDEVEXT pDevExt);
dc959f60f6d3e0cba86f7da4d39aa475913a7e10vboxsyncstatic int supdrvPageGetPhys(PSUPDRVSESSION pSession, RTR3PTR pvR3, uint32_t cPages, PRTHCPHYS paPages);
dc959f60f6d3e0cba86f7da4d39aa475913a7e10vboxsyncstatic bool supdrvPageWasLockedByPageAlloc(PSUPDRVSESSION pSession, RTR3PTR pvR3);
dc959f60f6d3e0cba86f7da4d39aa475913a7e10vboxsync#endif /* RT_OS_WINDOWS */
dc959f60f6d3e0cba86f7da4d39aa475913a7e10vboxsyncstatic void supdrvGipDestroy(PSUPDRVDEVEXT pDevExt);
dc959f60f6d3e0cba86f7da4d39aa475913a7e10vboxsyncstatic DECLCALLBACK(void) supdrvGipSyncTimer(PRTTIMER pTimer, void *pvUser, uint64_t iTick);
dc959f60f6d3e0cba86f7da4d39aa475913a7e10vboxsyncstatic DECLCALLBACK(void) supdrvGipAsyncTimer(PRTTIMER pTimer, void *pvUser, uint64_t iTick);
dc959f60f6d3e0cba86f7da4d39aa475913a7e10vboxsyncstatic DECLCALLBACK(void) supdrvGipMpEvent(RTMPEVENT enmEvent, RTCPUID idCpu, void *pvUser);
dc959f60f6d3e0cba86f7da4d39aa475913a7e10vboxsyncDECLASM(int) supdrvNtWrapVMMR0EntryEx(PFNRT pfnVMMR0EntryEx, PVM pVM, VMCPUID idCpu, unsigned uOperation, PSUPVMMR0REQHDR pReq, uint64_t u64Arg, PSUPDRVSESSION pSession);
dc959f60f6d3e0cba86f7da4d39aa475913a7e10vboxsyncDECLASM(int) supdrvNtWrapVMMR0EntryFast(PFNRT pfnVMMR0EntryFast, PVM pVM, VMCPUID idCpu, unsigned uOperation);
dc959f60f6d3e0cba86f7da4d39aa475913a7e10vboxsyncDECLASM(void) supdrvNtWrapObjDestructor(PFNRT pfnDestruction, void *pvObj, void *pvUser1, void *pvUser2);
dc959f60f6d3e0cba86f7da4d39aa475913a7e10vboxsyncDECLASM(void *) supdrvNtWrapQueryFactoryInterface(PFNRT pfnQueryFactoryInterface, struct SUPDRVFACTORY const *pSupDrvFactory, PSUPDRVSESSION pSession, const char *pszInterfaceUuid);
dc959f60f6d3e0cba86f7da4d39aa475913a7e10vboxsyncDECLASM(int) supdrvNtWrapModuleInit(PFNRT pfnModuleInit);
dc959f60f6d3e0cba86f7da4d39aa475913a7e10vboxsyncDECLASM(void) supdrvNtWrapModuleTerm(PFNRT pfnModuleTerm);
dc959f60f6d3e0cba86f7da4d39aa475913a7e10vboxsyncDECLASM(int) supdrvNtWrapServiceReqHandler(PFNRT pfnServiceReqHandler, PSUPDRVSESSION pSession, uint32_t uOperation, uint64_t u64Arg, PSUPR0SERVICEREQHDR pReqHdr);
dc959f60f6d3e0cba86f7da4d39aa475913a7e10vboxsyncDECLASM(int) UNWIND_WRAP(SUPR0ComponentRegisterFactory)(PSUPDRVSESSION pSession, PCSUPDRVFACTORY pFactory);
dc959f60f6d3e0cba86f7da4d39aa475913a7e10vboxsyncDECLASM(int) UNWIND_WRAP(SUPR0ComponentDeregisterFactory)(PSUPDRVSESSION pSession, PCSUPDRVFACTORY pFactory);
dc959f60f6d3e0cba86f7da4d39aa475913a7e10vboxsyncDECLASM(int) UNWIND_WRAP(SUPR0ComponentQueryFactory)(PSUPDRVSESSION pSession, const char *pszName, const char *pszInterfaceUuid, void **ppvFactoryIf);
d0a71f63bd810b54e0359223fe53b07730154dc5vboxsyncDECLASM(void *) UNWIND_WRAP(SUPR0ObjRegister)(PSUPDRVSESSION pSession, SUPDRVOBJTYPE enmType, PFNSUPDRVDESTRUCTOR pfnDestructor, void *pvUser1, void *pvUser2);
d0a71f63bd810b54e0359223fe53b07730154dc5vboxsyncDECLASM(int) UNWIND_WRAP(SUPR0ObjAddRef)(void *pvObj, PSUPDRVSESSION pSession);
d0a71f63bd810b54e0359223fe53b07730154dc5vboxsyncDECLASM(int) UNWIND_WRAP(SUPR0ObjAddRefEx)(void *pvObj, PSUPDRVSESSION pSession, bool fNoPreempt);
d0a71f63bd810b54e0359223fe53b07730154dc5vboxsyncDECLASM(int) UNWIND_WRAP(SUPR0ObjRelease)(void *pvObj, PSUPDRVSESSION pSession);
d0a71f63bd810b54e0359223fe53b07730154dc5vboxsyncDECLASM(int) UNWIND_WRAP(SUPR0ObjVerifyAccess)(void *pvObj, PSUPDRVSESSION pSession, const char *pszObjName);
d0a71f63bd810b54e0359223fe53b07730154dc5vboxsyncDECLASM(int) UNWIND_WRAP(SUPR0LockMem)(PSUPDRVSESSION pSession, RTR3PTR pvR3, uint32_t cPages, PRTHCPHYS paPages);
d0a71f63bd810b54e0359223fe53b07730154dc5vboxsyncDECLASM(int) UNWIND_WRAP(SUPR0UnlockMem)(PSUPDRVSESSION pSession, RTR3PTR pvR3);
d0a71f63bd810b54e0359223fe53b07730154dc5vboxsyncDECLASM(int) UNWIND_WRAP(SUPR0ContAlloc)(PSUPDRVSESSION pSession, uint32_t cPages, PRTR0PTR ppvR0, PRTR3PTR ppvR3, PRTHCPHYS pHCPhys);
d0a71f63bd810b54e0359223fe53b07730154dc5vboxsyncDECLASM(int) UNWIND_WRAP(SUPR0ContFree)(PSUPDRVSESSION pSession, RTHCUINTPTR uPtr);
d0a71f63bd810b54e0359223fe53b07730154dc5vboxsyncDECLASM(int) UNWIND_WRAP(SUPR0LowAlloc)(PSUPDRVSESSION pSession, uint32_t cPages, PRTR0PTR ppvR0, PRTR3PTR ppvR3, PRTHCPHYS paPages);
d0a71f63bd810b54e0359223fe53b07730154dc5vboxsyncDECLASM(int) UNWIND_WRAP(SUPR0LowFree)(PSUPDRVSESSION pSession, RTHCUINTPTR uPtr);
d0a71f63bd810b54e0359223fe53b07730154dc5vboxsyncDECLASM(int) UNWIND_WRAP(SUPR0MemAlloc)(PSUPDRVSESSION pSession, uint32_t cb, PRTR0PTR ppvR0, PRTR3PTR ppvR3);
d0a71f63bd810b54e0359223fe53b07730154dc5vboxsyncDECLASM(int) UNWIND_WRAP(SUPR0MemGetPhys)(PSUPDRVSESSION pSession, RTHCUINTPTR uPtr, PSUPPAGE paPages);
d0a71f63bd810b54e0359223fe53b07730154dc5vboxsyncDECLASM(int) UNWIND_WRAP(SUPR0MemFree)(PSUPDRVSESSION pSession, RTHCUINTPTR uPtr);
d0a71f63bd810b54e0359223fe53b07730154dc5vboxsyncDECLASM(int) UNWIND_WRAP(SUPR0PageAlloc)(PSUPDRVSESSION pSession, uint32_t cPages, PRTR3PTR ppvR3, PRTHCPHYS paPages);
d0a71f63bd810b54e0359223fe53b07730154dc5vboxsyncDECLASM(int) UNWIND_WRAP(SUPR0PageFree)(PSUPDRVSESSION pSession, RTR3PTR pvR3);
d0a71f63bd810b54e0359223fe53b07730154dc5vboxsync//DECLASM(int) UNWIND_WRAP(SUPR0Printf)(const char *pszFormat, ...);
d0a71f63bd810b54e0359223fe53b07730154dc5vboxsyncDECLASM(int) UNWIND_WRAP(SUPSemEventCreate)(PSUPDRVSESSION pSession, PSUPSEMEVENT phEvent);
d0a71f63bd810b54e0359223fe53b07730154dc5vboxsyncDECLASM(int) UNWIND_WRAP(SUPSemEventClose)(PSUPDRVSESSION pSession, SUPSEMEVENT hEvent);
d0a71f63bd810b54e0359223fe53b07730154dc5vboxsyncDECLASM(int) UNWIND_WRAP(SUPSemEventSignal)(PSUPDRVSESSION pSession, SUPSEMEVENT hEvent);
d0a71f63bd810b54e0359223fe53b07730154dc5vboxsyncDECLASM(int) UNWIND_WRAP(SUPSemEventWait)(PSUPDRVSESSION pSession, SUPSEMEVENT hEvent, uint32_t cMillies);
d0a71f63bd810b54e0359223fe53b07730154dc5vboxsyncDECLASM(int) UNWIND_WRAP(SUPSemEventWaitNoResume)(PSUPDRVSESSION pSession, SUPSEMEVENT hEvent, uint32_t cMillies);
32b1164f35483be483177be7b5235002a4a5afbevboxsyncDECLASM(int) UNWIND_WRAP(SUPSemEventMultiCreate)(PSUPDRVSESSION pSession, PSUPSEMEVENTMULTI phEventMulti);
32b1164f35483be483177be7b5235002a4a5afbevboxsyncDECLASM(int) UNWIND_WRAP(SUPSemEventMultiClose)(PSUPDRVSESSION pSession, SUPSEMEVENTMULTI hEventMulti);
dc959f60f6d3e0cba86f7da4d39aa475913a7e10vboxsyncDECLASM(int) UNWIND_WRAP(SUPSemEventMultiSignal)(PSUPDRVSESSION pSession, SUPSEMEVENTMULTI hEventMulti);
dc959f60f6d3e0cba86f7da4d39aa475913a7e10vboxsyncDECLASM(int) UNWIND_WRAP(SUPSemEventMultiReset)(PSUPDRVSESSION pSession, SUPSEMEVENTMULTI hEventMulti);
32b1164f35483be483177be7b5235002a4a5afbevboxsyncDECLASM(int) UNWIND_WRAP(SUPSemEventMultiWait)(PSUPDRVSESSION pSession, SUPSEMEVENTMULTI hEventMulti, uint32_t cMillies);
dc959f60f6d3e0cba86f7da4d39aa475913a7e10vboxsyncDECLASM(int) UNWIND_WRAP(SUPSemEventMultiWaitNoResume)(PSUPDRVSESSION pSession, SUPSEMEVENTMULTI hEventMulti, uint32_t cMillies);
dc959f60f6d3e0cba86f7da4d39aa475913a7e10vboxsyncDECLASM(SUPPAGINGMODE) UNWIND_WRAP(SUPR0GetPagingMode)(void);
dc959f60f6d3e0cba86f7da4d39aa475913a7e10vboxsyncDECLASM(void *) UNWIND_WRAP(RTMemAlloc)(size_t cb) RT_NO_THROW;
dc959f60f6d3e0cba86f7da4d39aa475913a7e10vboxsyncDECLASM(void *) UNWIND_WRAP(RTMemAllocZ)(size_t cb) RT_NO_THROW;
dc959f60f6d3e0cba86f7da4d39aa475913a7e10vboxsyncDECLASM(void) UNWIND_WRAP(RTMemFree)(void *pv) RT_NO_THROW;
dc959f60f6d3e0cba86f7da4d39aa475913a7e10vboxsyncDECLASM(void *) UNWIND_WRAP(RTMemDup)(const void *pvSrc, size_t cb) RT_NO_THROW;
dc959f60f6d3e0cba86f7da4d39aa475913a7e10vboxsyncDECLASM(void *) UNWIND_WRAP(RTMemDupEx)(const void *pvSrc, size_t cbSrc, size_t cbExtra) RT_NO_THROW;
dc959f60f6d3e0cba86f7da4d39aa475913a7e10vboxsyncDECLASM(void *) UNWIND_WRAP(RTMemRealloc)(void *pvOld, size_t cbNew) RT_NO_THROW;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLASM(int) UNWIND_WRAP(RTR0MemObjAllocLow)(PRTR0MEMOBJ pMemObj, size_t cb, bool fExecutable);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLASM(int) UNWIND_WRAP(RTR0MemObjAllocPage)(PRTR0MEMOBJ pMemObj, size_t cb, bool fExecutable);
dc959f60f6d3e0cba86f7da4d39aa475913a7e10vboxsyncDECLASM(int) UNWIND_WRAP(RTR0MemObjAllocPhys)(PRTR0MEMOBJ pMemObj, size_t cb, RTHCPHYS PhysHighest);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLASM(int) UNWIND_WRAP(RTR0MemObjAllocPhysNC)(PRTR0MEMOBJ pMemObj, size_t cb, RTHCPHYS PhysHighest);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLASM(int) UNWIND_WRAP(RTR0MemObjAllocCont)(PRTR0MEMOBJ pMemObj, size_t cb, bool fExecutable);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLASM(int) UNWIND_WRAP(RTR0MemObjEnterPhys)(PRTR0MEMOBJ pMemObj, RTHCPHYS Phys, size_t cb);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLASM(int) UNWIND_WRAP(RTR0MemObjLockUser)(PRTR0MEMOBJ pMemObj, RTR3PTR R3Ptr, size_t cb, RTR0PROCESS R0Process);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLASM(int) UNWIND_WRAP(RTR0MemObjMapKernel)(PRTR0MEMOBJ pMemObj, RTR0MEMOBJ MemObjToMap, void *pvFixed, size_t uAlignment, unsigned fProt);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLASM(int) UNWIND_WRAP(RTR0MemObjMapKernelEx)(PRTR0MEMOBJ pMemObj, RTR0MEMOBJ MemObjToMap, void *pvFixed, size_t uAlignment, unsigned fProt, size_t offSub, size_t cbSub);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLASM(int) UNWIND_WRAP(RTR0MemObjMapUser)(PRTR0MEMOBJ pMemObj, RTR0MEMOBJ MemObjToMap, RTR3PTR R3PtrFixed, size_t uAlignment, unsigned fProt, RTR0PROCESS R0Process);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync/*DECLASM(void *) UNWIND_WRAP(RTR0MemObjAddress)(RTR0MEMOBJ MemObj); - not necessary */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync/*DECLASM(RTR3PTR) UNWIND_WRAP(RTR0MemObjAddressR3)(RTR0MEMOBJ MemObj); - not necessary */
dc959f60f6d3e0cba86f7da4d39aa475913a7e10vboxsync/*DECLASM(size_t) UNWIND_WRAP(RTR0MemObjSize)(RTR0MEMOBJ MemObj); - not necessary */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync/*DECLASM(bool) UNWIND_WRAP(RTR0MemObjIsMapping)(RTR0MEMOBJ MemObj); - not necessary */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync/*DECLASM(RTHCPHYS) UNWIND_WRAP(RTR0MemObjGetPagePhysAddr)(RTR0MEMOBJ MemObj, size_t iPage); - not necessary */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLASM(int) UNWIND_WRAP(RTR0MemObjFree)(RTR0MEMOBJ MemObj, bool fFreeMappings);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync/* RTProcSelf - not necessary */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync/* RTR0ProcHandleSelf - not necessary */
e6ad2e18e663b076aeabfec994947514566a7accvboxsyncDECLASM(int) UNWIND_WRAP(RTSemFastMutexCreate)(PRTSEMFASTMUTEX pMutexSem);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLASM(int) UNWIND_WRAP(RTSemFastMutexDestroy)(RTSEMFASTMUTEX MutexSem);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLASM(int) UNWIND_WRAP(RTSemFastMutexRequest)(RTSEMFASTMUTEX MutexSem);
dc959f60f6d3e0cba86f7da4d39aa475913a7e10vboxsyncDECLASM(int) UNWIND_WRAP(RTSemFastMutexRelease)(RTSEMFASTMUTEX MutexSem);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLASM(int) UNWIND_WRAP(RTSemEventCreate)(PRTSEMEVENT pEventSem);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLASM(int) UNWIND_WRAP(RTSemEventSignal)(RTSEMEVENT EventSem);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLASM(int) UNWIND_WRAP(RTSemEventWait)(RTSEMEVENT EventSem, unsigned cMillies);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLASM(int) UNWIND_WRAP(RTSemEventWaitNoResume)(RTSEMEVENT EventSem, unsigned cMillies);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLASM(int) UNWIND_WRAP(RTSemEventDestroy)(RTSEMEVENT EventSem);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLASM(int) UNWIND_WRAP(RTSemEventMultiCreate)(PRTSEMEVENTMULTI pEventMultiSem);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLASM(int) UNWIND_WRAP(RTSemEventMultiSignal)(RTSEMEVENTMULTI EventMultiSem);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLASM(int) UNWIND_WRAP(RTSemEventMultiReset)(RTSEMEVENTMULTI EventMultiSem);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLASM(int) UNWIND_WRAP(RTSemEventMultiWait)(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLASM(int) UNWIND_WRAP(RTSemEventMultiWaitNoResume)(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLASM(int) UNWIND_WRAP(RTSemEventMultiDestroy)(RTSEMEVENTMULTI EventMultiSem);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLASM(int) UNWIND_WRAP(RTSpinlockCreate)(PRTSPINLOCK pSpinlock);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLASM(int) UNWIND_WRAP(RTSpinlockDestroy)(RTSPINLOCK Spinlock);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLASM(void) UNWIND_WRAP(RTSpinlockAcquire)(RTSPINLOCK Spinlock, PRTSPINLOCKTMP pTmp);
d9fec6d329252f6e5eb8f564690e582b2aea6624vboxsyncDECLASM(void) UNWIND_WRAP(RTSpinlockRelease)(RTSPINLOCK Spinlock, PRTSPINLOCKTMP pTmp);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLASM(void) UNWIND_WRAP(RTSpinlockAcquireNoInts)(RTSPINLOCK Spinlock, PRTSPINLOCKTMP pTmp);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLASM(void) UNWIND_WRAP(RTSpinlockReleaseNoInts)(RTSPINLOCK Spinlock, PRTSPINLOCKTMP pTmp);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync/* RTTimeNanoTS - not necessary */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync/* RTTimeMilliTS - not necessary */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync/* RTTimeSystemNanoTS - not necessary */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync/* RTTimeSystemMilliTS - not necessary */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync/* RTThreadNativeSelf - not necessary */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLASM(int) UNWIND_WRAP(RTThreadSleep)(unsigned cMillies);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync/* RTThreadSelf - not necessary */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLASM(int) UNWIND_WRAP(RTThreadCreate)(PRTTHREAD pThread, PFNRTTHREAD pfnThread, void *pvUser, size_t cbStack,
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync RTTHREADTYPE enmType, unsigned fFlags, const char *pszName);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLASM(RTNATIVETHREAD) UNWIND_WRAP(RTThreadGetNative)(RTTHREAD Thread);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLASM(int) UNWIND_WRAP(RTThreadWait)(RTTHREAD Thread, unsigned cMillies, int *prc);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLASM(int) UNWIND_WRAP(RTThreadWaitNoResume)(RTTHREAD Thread, unsigned cMillies, int *prc);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLASM(const char *) UNWIND_WRAP(RTThreadGetName)(RTTHREAD Thread);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLASM(const char *) UNWIND_WRAP(RTThreadSelfName)(void);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLASM(RTTHREADTYPE) UNWIND_WRAP(RTThreadGetType)(RTTHREAD Thread);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLASM(int) UNWIND_WRAP(RTThreadUserSignal)(RTTHREAD Thread);
e6ad2e18e663b076aeabfec994947514566a7accvboxsyncDECLASM(int) UNWIND_WRAP(RTThreadUserReset)(RTTHREAD Thread);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLASM(int) UNWIND_WRAP(RTThreadUserWait)(RTTHREAD Thread, unsigned cMillies);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLASM(int) UNWIND_WRAP(RTThreadUserWaitNoResume)(RTTHREAD Thread, unsigned cMillies);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync/* RTThreadPreemptIsEnabled - not necessary */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync/* RTThreadPreemptIsPending - not necessary */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync/* RTThreadPreemptIsPendingTrusty - not necessary */
dc959f60f6d3e0cba86f7da4d39aa475913a7e10vboxsync/* RTThreadPreemptDisable - not necessary */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLASM(void) UNWIND_WRAP(RTThreadPreemptRestore)(RTTHREADPREEMPTSTATE pState);
e6ad2e18e663b076aeabfec994947514566a7accvboxsync/* RTLogDefaultInstance - a bit of a gamble, but we do not want the overhead! */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync/* RTMpCpuId - not necessary */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync/* RTMpCpuIdFromSetIndex - not necessary */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync/* RTMpCpuIdToSetIndex - not necessary */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync/* RTMpIsCpuPossible - not necessary */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync/* RTMpGetCount - not necessary */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync/* RTMpGetMaxCpuId - not necessary */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync/* RTMpGetOnlineCount - not necessary */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync/* RTMpGetOnlineSet - not necessary */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync/* RTMpGetSet - not necessary */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync/* RTMpIsCpuOnline - not necessary */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLASM(int) UNWIND_WRAP(RTMpIsCpuWorkPending)(void);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLASM(int) UNWIND_WRAP(RTMpOnAll)(PFNRTMPWORKER pfnWorker, void *pvUser1, void *pvUser2);
DECLASM(int) UNWIND_WRAP(RTMpOnSpecific)(RTCPUID idCpu, PFNRTMPWORKER pfnWorker, void *pvUser1, void *pvUser2);
DECLASM(void) UNWIND_WRAP(RTLogLoggerExV)(PRTLOGGER pLogger, unsigned fFlags, unsigned iGroup, const char *pszFormat, va_list args);
DECLASM(void) UNWIND_WRAP(AssertMsg1)(const char *pszExpr, unsigned uLine, const char *pszFile, const char *pszFunction);
#if defined(RT_OS_DARWIN)
int rc;
#ifdef SUPDRV_WITH_RELEASE_LOGGER
if (!rc)
if (!rc)
if (!rc)
if (!rc)
#ifdef RT_OS_DARWIN
return VINF_SUCCESS;
#ifdef SUPDRV_WITH_RELEASE_LOGGER
return rc;
while (pObj)
while (pUsage)
#ifdef SUPDRV_WITH_RELEASE_LOGGER
if (pSession)
if (!rc)
pSession->Bundle.cUsed = 0; */
if (fUser)
return VINF_SUCCESS;
return rc;
int rc;
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));
#ifdef RT_WITH_W64_UNWIND_HACK
while (pBundle)
int rc;
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)
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)
#ifdef RT_WITH_W64_UNWIND_HACK
supdrvNtWrapVMMR0EntryFast((PFNRT)pDevExt->pfnVMMR0EntryFast, pSession->pVM, idCpu, SUP_VMMR0_DO_RAW_RUN);
#ifdef RT_WITH_W64_UNWIND_HACK
supdrvNtWrapVMMR0EntryFast((PFNRT)pDevExt->pfnVMMR0EntryFast, pSession->pVM, idCpu, SUP_VMMR0_DO_HWACC_RUN);
case SUP_IOCTL_FAST_DO_NOP:
#ifdef RT_WITH_W64_UNWIND_HACK
supdrvNtWrapVMMR0EntryFast((PFNRT)pDevExt->pfnVMMR0EntryFast, pSession->pVM, idCpu, SUP_VMMR0_DO_NOP);
return VERR_INTERNAL_ERROR;
return VINF_SUCCESS;
return VERR_INTERNAL_ERROR;
* list, see http://www.kerneldrivers.org/RHEL5.
int chCur;
int ch;
int VBOXCALL supdrvIOCtl(uintptr_t uIOCtl, PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPREQHDR pReqHdr)
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;
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_EXPR(SUP_IOCTL_LDR_OPEN, !supdrvCheckInvalidChar(pReq->u.In.szName, ";:()[]{}/\\|&*%#@!~`\"'"));
REQ_CHECK_SIZES_EX(SUP_IOCTL_LDR_LOAD, SUP_IOCTL_LDR_LOAD_SIZE_IN(pReq->u.In.cbImage), SUP_IOCTL_LDR_LOAD_SIZE_OUT);
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.cbImage));
("SUP_IOCTL_LDR_LOAD: sym #%ld: name off %#lx (max=%#lx)\n", (long)i, (long)paSyms[i].offName, (long)pReq->u.In.cbImage));
REQ_CHECK_EXPR_FMT(memchr(&pReq->u.In.achImage[pReq->u.In.offStrTab + paSyms[i].offName], '\0', pReq->u.In.cbStrTab - paSyms[i].offName),
("SUP_IOCTL_LDR_LOAD: sym #%ld: unterminated name! (%#lx / %#lx)\n", (long)i, (long)paSyms[i].offName, (long)pReq->u.In.cbImage));
REQ_CHECK_EXPR(SUP_IOCTL_LDR_GET_SYMBOL, memchr(pReq->u.In.szSymbol, '\0', 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));
#ifdef RT_WITH_W64_UNWIND_HACK
pReq->Hdr.rc = supdrvNtWrapVMMR0EntryEx((PFNRT)pDevExt->pfnVMMR0EntryEx, pReq->u.In.pVMR0, pReq->u.In.idCpu, pReq->u.In.uOperation, NULL, pReq->u.In.u64Arg, pSession);
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));
#ifdef RT_WITH_W64_UNWIND_HACK
pReq->Hdr.rc = supdrvNtWrapVMMR0EntryEx((PFNRT)pDevExt->pfnVMMR0EntryEx, pReq->u.In.pVMR0, pReq->u.In.idCpu, pReq->u.In.uOperation, pVMMReq, pReq->u.In.u64Arg, pSession);
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, SUP_IOCTL_PAGE_ALLOC_SIZE_IN, SUP_IOCTL_PAGE_ALLOC_SIZE_OUT(pReq->u.In.cPages));
pReq->Hdr.rc = SUPR0PageAlloc(pSession, pReq->u.In.cPages, &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_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));
REQ_CHECK_SIZES_EX(SUP_IOCTL_SEM_CREATE, SUP_IOCTL_SEM_CREATE_SIZE_IN, SUP_IOCTL_SEM_CREATE_SIZE_OUT);
case SUP_SEM_TYPE_EVENT:
case SUP_SEM_TYPE_EVENT_MULTI:
case SUP_SEM_TYPE_EVENT:
case SUPSEMOP_WAIT:
case SUPSEMOP_SIGNAL:
case SUPSEMOP_CLOSE:
case SUPSEMOP_RESET:
case SUP_SEM_TYPE_EVENT_MULTI:
case SUPSEMOP_WAIT:
case SUPSEMOP_SIGNAL:
case SUPSEMOP_CLOSE:
case SUPSEMOP_RESET:
return SUPDRV_ERR_GENERAL_FAILURE;
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;
#ifdef RT_OS_WINDOWS
return VINF_SUCCESS;
return VINF_SUCCESS;
#ifdef RT_OS_WINDOWS
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));
#ifdef RT_WITH_W64_UNWIND_HACK
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;
#ifdef RT_OS_WINDOWS /* A temporary hack for windows, will be removed once all ring-3 code has been cleaned up. */
return rc;
AssertMsg(RTR0MemObjAddressR3(Mem.MemObj) == pvR3, ("%p == %p\n", RTR0MemObjAddressR3(Mem.MemObj), pvR3));
while (iPage-- > 0)
return rc;
#ifdef RT_OS_WINDOWS
return VINF_SUCCESS;
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) SUPR0PageAlloc(PSUPDRVSESSION pSession, uint32_t cPages, PRTR3PTR ppvR3, PRTHCPHYS paPages)
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 128MB.\n", cPages));
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;
#ifdef RT_OS_WINDOWS
static int supdrvPageGetPhys(PSUPDRVSESSION pSession, RTR3PTR pvR3, uint32_t cPages, PRTHCPHYS paPages)
LogFlow(("supdrvPageGetPhys: pSession=%p pvR3=%p cPages=%#lx paPages=%p\n", pSession, (void *)pvR3, (long)cPages, paPages));
return VINF_SUCCESS;
return VERR_INVALID_PARAMETER;
if (ppGipR3)
ASMAtomicXchgU32(&pGip->aCPUs[i].u32TransactionId, pGip->aCPUs[i].u32TransactionId & ~(GIP_UPDATEHZ_RECALC_FREQ * 2 - 1));
if (pHCPhysGip)
if (ppGipR3)
#ifdef DEBUG_DARWIN_GIP
OSDBGPRINT(("SUPR0GipMap: returns %d *pHCPhysGip=%lx pGip=%p\n", rc, (unsigned long)HCPhys, (void *)pGip));
LogFlow(( "SUPR0GipMap: returns %d *pHCPhysGip=%lx pGip=%p\n", rc, (unsigned long)HCPhys, (void *)pGip));
return rc;
#ifdef DEBUG_DARWIN_GIP
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)
#ifdef RT_WITH_W64_UNWIND_HACK
void *pvFactory = supdrvNtWrapQueryFactoryInterface((PFNRT)pCur->pFactory->pfnQueryFactoryInterface, pCur->pFactory, pSession, pszInterfaceUuid);
void *pvFactory = pCur->pFactory->pfnQueryFactoryInterface(pCur->pFactory, pSession, pszInterfaceUuid);
if (pvFactory)
return rc;
int rc;
void *pvObj = SUPR0ObjRegister(pSession, SUPDRVOBJTYPE_SEM_EVENT, supR0SemEventDestructor, hEventReal, NULL);
if (pvObj)
return VINF_SUCCESS;
return rc;
return VINF_SUCCESS;
return VERR_INVALID_HANDLE;
if (!pObj)
return VERR_INVALID_HANDLE;
int rc;
return VERR_INVALID_HANDLE;
pObj = (PSUPDRVOBJ)RTHandleTableLookupWithCtx(pSession->hHandleTable, h32, SUPDRV_HANDLE_CTX_EVENT);
if (!pObj)
return VERR_INVALID_HANDLE;
return rc;
int rc;
return VERR_INVALID_HANDLE;
pObj = (PSUPDRVOBJ)RTHandleTableLookupWithCtx(pSession->hHandleTable, h32, SUPDRV_HANDLE_CTX_EVENT);
if (!pObj)
return VERR_INVALID_HANDLE;
return rc;
SUPDECL(int) SUPSemEventWaitNoResume(PSUPDRVSESSION pSession, SUPSEMEVENT hEvent, uint32_t cMillies)
int rc;
return VERR_INVALID_HANDLE;
pObj = (PSUPDRVOBJ)RTHandleTableLookupWithCtx(pSession->hHandleTable, h32, SUPDRV_HANDLE_CTX_EVENT);
if (!pObj)
return VERR_INVALID_HANDLE;
return rc;
int rc;
void *pvObj = SUPR0ObjRegister(pSession, SUPDRVOBJTYPE_SEM_EVENT_MULTI, supR0SemEventMultiDestructor, hEventMultReal, NULL);
if (pvObj)
return VINF_SUCCESS;
return rc;
return VINF_SUCCESS;
return VERR_INVALID_HANDLE;
pObj = (PSUPDRVOBJ)RTHandleTableFreeWithCtx(pSession->hHandleTable, h32, SUPDRV_HANDLE_CTX_EVENT_MULTI);
if (!pObj)
return VERR_INVALID_HANDLE;
int rc;
return VERR_INVALID_HANDLE;
pObj = (PSUPDRVOBJ)RTHandleTableLookupWithCtx(pSession->hHandleTable, h32, SUPDRV_HANDLE_CTX_EVENT_MULTI);
if (!pObj)
return VERR_INVALID_HANDLE;
return rc;
int rc;
return VERR_INVALID_HANDLE;
pObj = (PSUPDRVOBJ)RTHandleTableLookupWithCtx(pSession->hHandleTable, h32, SUPDRV_HANDLE_CTX_EVENT_MULTI);
if (!pObj)
return VERR_INVALID_HANDLE;
return rc;
SUPDECL(int) SUPSemEventMultiWait(PSUPDRVSESSION pSession, SUPSEMEVENTMULTI hEventMulti, uint32_t cMillies)
int rc;
return VERR_INVALID_HANDLE;
pObj = (PSUPDRVOBJ)RTHandleTableLookupWithCtx(pSession->hHandleTable, h32, SUPDRV_HANDLE_CTX_EVENT_MULTI);
if (!pObj)
return VERR_INVALID_HANDLE;
return rc;
SUPDECL(int) SUPSemEventMultiWaitNoResume(PSUPDRVSESSION pSession, SUPSEMEVENTMULTI hEventMulti, uint32_t cMillies)
int rc;
return VERR_INVALID_HANDLE;
pObj = (PSUPDRVOBJ)RTHandleTableLookupWithCtx(pSession->hHandleTable, h32, SUPDRV_HANDLE_CTX_EVENT_MULTI);
if (!pObj)
return VERR_INVALID_HANDLE;
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;
unsigned cb;
void *pv;
return VINF_SUCCESS;
if (!pv)
return VERR_NO_MEMORY;
return VINF_SUCCESS;
int rc;
LogFlow(("supdrvIOCtl_LdrLoad: pvImageBase=%p cbImage=%d\n", pReq->u.In.pvImageBase, pReq->u.In.cbImage));
if (!pUsage)
return VERR_INVALID_HANDLE;
Log(("SUP_IOCTL_LDR_LOAD: image size mismatch!! %d(prep) != %d(load)\n", pImage->cbImage, pReq->u.In.cbImage));
return VERR_INVALID_HANDLE;
return SUPDRV_ERR_ALREADY_LOADED;
case SUPLDRLOADEP_NOTHING:
case SUPLDRLOADEP_VMMR0:
return VERR_INVALID_PARAMETER;
if ( (uintptr_t)pReq->u.In.EP.VMMR0.pvVMMR0EntryInt - (uintptr_t)pImage->pvImage >= pReq->u.In.cbImage
|| (uintptr_t)pReq->u.In.EP.VMMR0.pvVMMR0EntryFast - (uintptr_t)pImage->pvImage >= pReq->u.In.cbImage
|| (uintptr_t)pReq->u.In.EP.VMMR0.pvVMMR0EntryEx - (uintptr_t)pImage->pvImage >= pReq->u.In.cbImage)
Log(("Out of range (%p LB %#x): pvVMMR0EntryInt=%p, pvVMMR0EntryFast=%p or pvVMMR0EntryEx=%p is NULL!\n",
return VERR_INVALID_PARAMETER;
case SUPLDRLOADEP_SERVICE:
return VERR_INVALID_PARAMETER;
if ((uintptr_t)pReq->u.In.EP.Service.pfnServiceReq - (uintptr_t)pImage->pvImage >= pReq->u.In.cbImage)
Log(("Out of range (%p LB %#x): pfnServiceReq=%p, pvVMMR0EntryFast=%p or pvVMMR0EntryEx=%p is NULL!\n",
return VERR_INVALID_PARAMETER;
return VERR_INVALID_PARAMETER;
return VERR_INVALID_PARAMETER;
return VERR_INVALID_PARAMETER;
return VERR_INVALID_PARAMETER;
case SUPLDRLOADEP_NOTHING:
case SUPLDRLOADEP_VMMR0:
rc = supdrvLdrSetVMMR0EPs(pDevExt, pReq->u.In.EP.VMMR0.pvVMMR0, pReq->u.In.EP.VMMR0.pvVMMR0EntryInt,
case SUPLDRLOADEP_SERVICE:
#ifdef RT_WITH_W64_UNWIND_HACK
if (rc)
return rc;
int rc;
if (!pUsage)
return VERR_INVALID_HANDLE;
if (RT_UNLIKELY((uintptr_t)pGenUsage->pObj->pfnDestructor - (uintptr_t)pImage->pvImage < pImage->cbImage))
if (pUsagePrev)
return rc;
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;
if (pImagePrev)
unsigned cObjs = 0;
cObjs++;
if (cObjs)
#ifdef RT_WITH_W64_UNWIND_HACK
static int supdrvIOCtl_CallServiceModule(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPCALLSERVICE pReq)
int rc;
if (pfnServiceReqHandler)
#ifdef RT_WITH_W64_UNWIND_HACK
rc = supdrvNtWrapServiceReqHandler((PFNRT)pfnServiceReqHandler, pSession, pReq->u.In.uOperation, pReq->u.In.u64Arg, NULL);
#ifdef RT_WITH_W64_UNWIND_HACK
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;
case X86_CR4_PGE:
case X86_CR4_PAE:
return enmMode;
#ifdef RT_OS_DARWIN
return VERR_NOT_SUPPORTED;
int rc;
return rc;
#if 0 /** @todo Disabled this as we didn't used to do it before and causes unnecessary stress on laptops.
rc = RTTimerCreateEx(&pDevExt->pGipTimer, u32Interval, RTTIMER_FLAGS_CPU_ALL, supdrvGipAsyncTimer, pDevExt);
return VINF_SUCCESS;
OSDBGPRINT(("supdrvGipCreate: failed create GIP timer at %ld ns interval. rc=%d\n", (long)u32Interval, rc));
return rc;
int rc;
#ifdef DEBUG_DARWIN_GIP
bool fIgnored;
for (i = 0; i < RTCPUSET_MAX_CPUS; i++)
int VBOXCALL supdrvGipInit(PSUPDRVDEVEXT pDevExt, PSUPGLOBALINFOPAGE pGip, RTHCPHYS HCPhys, uint64_t u64NanoTS, unsigned uUpdateHz)
#ifdef DEBUG_DARWIN_GIP
OSDBGPRINT(("supdrvGipInit: pGip=%p HCPhys=%lx u64NanoTS=%llu uUpdateHz=%d\n", pGip, (long)HCPhys, u64NanoTS, uUpdateHz));
LogFlow(("supdrvGipInit: pGip=%p HCPhys=%lx u64NanoTS=%llu uUpdateHz=%d\n", pGip, (long)HCPhys, u64NanoTS, uUpdateHz));
return VINF_SUCCESS;
static DECLCALLBACK(void) supdrvDetermineAsyncTscWorker(RTCPUID idCpu, void *pvUser1, void *pvUser2)
int iCpu;
bool fAsync = false;
while (cLoops-- > 0)
fAsync = true;
return fAsync;
return SUPGIPMODE_ASYNC_TSC;
return SUPGIPMODE_ASYNC_TSC;
return SUPGIPMODE_ASYNC_TSC;
return SUPGIPMODE_SYNC_TSC;
unsigned iTSCHistoryHead;