SUPDrv.c revision 7c5a7ff4a2d119cd8b8951194cbb0b4e4efb2b13
4c83fd46d254a6e1cad9f1df4395408cd9ff7833vboxsync/* $Revision$ */
3b8ffb6094762b1754b860e35f77070f91cdd3a5vboxsync * VBoxDrv - The VirtualBox Support Driver - Common code.
b6e201e4d129ec1eda91e9bdf5c303cda51ab4f6vboxsync * Copyright (C) 2006-2007 Sun Microsystems, Inc.
4c83fd46d254a6e1cad9f1df4395408cd9ff7833vboxsync * This file is part of VirtualBox Open Source Edition (OSE), as
4c83fd46d254a6e1cad9f1df4395408cd9ff7833vboxsync * available from http://www.virtualbox.org. This file is free software;
4c83fd46d254a6e1cad9f1df4395408cd9ff7833vboxsync * you can redistribute it and/or modify it under the terms of the GNU
4c83fd46d254a6e1cad9f1df4395408cd9ff7833vboxsync * General Public License (GPL) as published by the Free Software
4c83fd46d254a6e1cad9f1df4395408cd9ff7833vboxsync * Foundation, in version 2 as it comes in the "COPYING" file of the
4c83fd46d254a6e1cad9f1df4395408cd9ff7833vboxsync * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
4c83fd46d254a6e1cad9f1df4395408cd9ff7833vboxsync * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
4c83fd46d254a6e1cad9f1df4395408cd9ff7833vboxsync * The contents of this file may alternatively be used under the terms
4c83fd46d254a6e1cad9f1df4395408cd9ff7833vboxsync * of the Common Development and Distribution License Version 1.0
4c83fd46d254a6e1cad9f1df4395408cd9ff7833vboxsync * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
4c83fd46d254a6e1cad9f1df4395408cd9ff7833vboxsync * VirtualBox OSE distribution, in which case the provisions of the
4c83fd46d254a6e1cad9f1df4395408cd9ff7833vboxsync * CDDL are applicable instead of those of the GPL.
4c83fd46d254a6e1cad9f1df4395408cd9ff7833vboxsync * You may elect to license modified versions of this file under the
4c83fd46d254a6e1cad9f1df4395408cd9ff7833vboxsync * terms and conditions of either the GPL or the CDDL or both.
1701080b3ba6367b310c28b85a71c269dad5b789vboxsync * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
513aeb62b50925ef51b8be944083cd2589ecf743vboxsync * Clara, CA 95054 USA or visit http://www.sun.com if you need
513aeb62b50925ef51b8be944083cd2589ecf743vboxsync * additional information or have any questions.
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsync/*******************************************************************************
1701080b3ba6367b310c28b85a71c269dad5b789vboxsync* Header Files *
4c83fd46d254a6e1cad9f1df4395408cd9ff7833vboxsync*******************************************************************************/
3ac37715f0e878da3b1737b45b89720dd768a31bvboxsync/* VBox/x86.h not compatible with the Linux kernel sources */
5358508a9c364e20d5ae19ac1e95c9c2597fde1avboxsync * Logging assignments:
5358508a9c364e20d5ae19ac1e95c9c2597fde1avboxsync * Log - useful stuff, like failures.
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsync * LogFlow - program flow, except the really noisy bits.
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsync * Log2 - Cleanup.
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsync * Log3 - Loader flow noise.
3b8ffb6094762b1754b860e35f77070f91cdd3a5vboxsync * Log4 - Call VMMR0 flow noise.
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsync * Log5 - Native yet-to-be-defined noise.
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsync * Log6 - Native ioctl flow noise.
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsync * Logging requires BUILD_TYPE=debug and possibly changes to the logger
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsync * instanciation in log-vbox.c(pp).
5358508a9c364e20d5ae19ac1e95c9c2597fde1avboxsync/*******************************************************************************
8259a8d9542c4211c5e216850c10c620ab7cd411vboxsync* Defined Constants And Macros *
3b8ffb6094762b1754b860e35f77070f91cdd3a5vboxsync*******************************************************************************/
3b8ffb6094762b1754b860e35f77070f91cdd3a5vboxsync/* from x86.h - clashes with linux thus this duplication */
63abe53fde500f57944b09a7860e3515b966270cvboxsync#define X86_CPUID_AMD_FEATURE_EDX_LONG_MODE RT_BIT(29)
63abe53fde500f57944b09a7860e3515b966270cvboxsync/** The frequency by which we recalculate the u32UpdateHz and
63abe53fde500f57944b09a7860e3515b966270cvboxsync * u32UpdateIntervalNS GIP members. The value must be a power of 2. */
a240f1229507269d3449217c9d483597e498d3bcvboxsync * Validates a session pointer.
a240f1229507269d3449217c9d483597e498d3bcvboxsync * @returns true/false accordingly.
a240f1229507269d3449217c9d483597e498d3bcvboxsync * @param pSession The session.
a240f1229507269d3449217c9d483597e498d3bcvboxsync/** @def VBOX_SVN_REV
a240f1229507269d3449217c9d483597e498d3bcvboxsync * The makefile should define this if it can. */
4c83fd46d254a6e1cad9f1df4395408cd9ff7833vboxsync/*******************************************************************************
4c83fd46d254a6e1cad9f1df4395408cd9ff7833vboxsync* Internal Functions *
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsync*******************************************************************************/
4c83fd46d254a6e1cad9f1df4395408cd9ff7833vboxsyncstatic int supdrvMemAdd(PSUPDRVMEMREF pMem, PSUPDRVSESSION pSession);
a240f1229507269d3449217c9d483597e498d3bcvboxsyncstatic int supdrvMemRelease(PSUPDRVSESSION pSession, RTHCUINTPTR uPtr, SUPDRVMEMREFTYPE eType);
7c17a8c920f84a6da1b663bf0529900bf6557ddfvboxsyncstatic int supdrvIOCtl_LdrOpen(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPLDROPEN pReq);
a240f1229507269d3449217c9d483597e498d3bcvboxsyncstatic int supdrvIOCtl_LdrLoad(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPLDRLOAD pReq);
a240f1229507269d3449217c9d483597e498d3bcvboxsyncstatic int supdrvIOCtl_LdrFree(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPLDRFREE pReq);
a240f1229507269d3449217c9d483597e498d3bcvboxsyncstatic int supdrvIOCtl_LdrGetSymbol(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPLDRGETSYMBOL pReq);
8259a8d9542c4211c5e216850c10c620ab7cd411vboxsyncstatic int supdrvIDC_LdrGetSymbol(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPDRVIDCREQGETSYM pReq);
a240f1229507269d3449217c9d483597e498d3bcvboxsyncstatic int supdrvLdrSetVMMR0EPs(PSUPDRVDEVEXT pDevExt, void *pvVMMR0, void *pvVMMR0EntryInt, void *pvVMMR0EntryFast, void *pvVMMR0EntryEx);
7c17a8c920f84a6da1b663bf0529900bf6557ddfvboxsyncstatic void supdrvLdrUnsetVMMR0EPs(PSUPDRVDEVEXT pDevExt);
7c17a8c920f84a6da1b663bf0529900bf6557ddfvboxsyncstatic int supdrvLdrAddUsage(PSUPDRVSESSION pSession, PSUPDRVLDRIMAGE pImage);
a240f1229507269d3449217c9d483597e498d3bcvboxsyncstatic void supdrvLdrFree(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage);
7c17a8c920f84a6da1b663bf0529900bf6557ddfvboxsyncstatic int supdrvIOCtl_CallServiceModule(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPCALLSERVICE pReq);
7c17a8c920f84a6da1b663bf0529900bf6557ddfvboxsyncstatic int supdrvIOCtl_LoggerSettings(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPLOGGERSETTINGS pReq);
b1be5bf5ba98f0818e29935222b4e8bbd15abe17vboxsyncstatic SUPGIPMODE supdrvGipDeterminTscMode(PSUPDRVDEVEXT pDevExt);
7c17a8c920f84a6da1b663bf0529900bf6557ddfvboxsyncstatic int supdrvPageGetPhys(PSUPDRVSESSION pSession, RTR3PTR pvR3, uint32_t cPages, PRTHCPHYS paPages);
a240f1229507269d3449217c9d483597e498d3bcvboxsyncstatic bool supdrvPageWasLockedByPageAlloc(PSUPDRVSESSION pSession, RTR3PTR pvR3);
7c17a8c920f84a6da1b663bf0529900bf6557ddfvboxsync#endif /* RT_OS_WINDOWS */
a240f1229507269d3449217c9d483597e498d3bcvboxsyncstatic void supdrvGipDestroy(PSUPDRVDEVEXT pDevExt);
4c83fd46d254a6e1cad9f1df4395408cd9ff7833vboxsyncstatic DECLCALLBACK(void) supdrvGipSyncTimer(PRTTIMER pTimer, void *pvUser, uint64_t iTick);
4c83fd46d254a6e1cad9f1df4395408cd9ff7833vboxsyncstatic DECLCALLBACK(void) supdrvGipAsyncTimer(PRTTIMER pTimer, void *pvUser, uint64_t iTick);
4c83fd46d254a6e1cad9f1df4395408cd9ff7833vboxsyncstatic DECLCALLBACK(void) supdrvGipMpEvent(RTMPEVENT enmEvent, RTCPUID idCpu, void *pvUser);
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsyncDECLASM(int) supdrvNtWrapVMMR0EntryEx(PFNRT pfnVMMR0EntryEx, PVM pVM, unsigned uOperation, PSUPVMMR0REQHDR pReq, uint64_t u64Arg, PSUPDRVSESSION pSession);
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsyncDECLASM(int) supdrvNtWrapVMMR0EntryFast(PFNRT pfnVMMR0EntryFast, PVM pVM, unsigned idCpu, unsigned uOperation);
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsyncDECLASM(void) supdrvNtWrapObjDestructor(PFNRT pfnDestruction, void *pvObj, void *pvUser1, void *pvUser2);
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsyncDECLASM(void *) supdrvNtWrapQueryFactoryInterface(PFNRT pfnQueryFactoryInterface, struct SUPDRVFACTORY const *pSupDrvFactory, PSUPDRVSESSION pSession, const char *pszInterfaceUuid);
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsyncDECLASM(int) supdrvNtWrapModuleInit(PFNRT pfnModuleInit);
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsyncDECLASM(void) supdrvNtWrapModuleTerm(PFNRT pfnModuleTerm);
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsyncDECLASM(int) supdrvNtWrapServiceReqHandler(PFNRT pfnServiceReqHandler, PSUPDRVSESSION pSession, uint32_t uOperation, uint64_t u64Arg, PSUPR0SERVICEREQHDR pReqHdr);
a419e5c3ed740caf9a6db66cf72137a9426d5d59vboxsyncDECLASM(int) UNWIND_WRAP(SUPR0ComponentRegisterFactory)(PSUPDRVSESSION pSession, PCSUPDRVFACTORY pFactory);
a419e5c3ed740caf9a6db66cf72137a9426d5d59vboxsyncDECLASM(int) UNWIND_WRAP(SUPR0ComponentDeregisterFactory)(PSUPDRVSESSION pSession, PCSUPDRVFACTORY pFactory);
a419e5c3ed740caf9a6db66cf72137a9426d5d59vboxsyncDECLASM(int) UNWIND_WRAP(SUPR0ComponentQueryFactory)(PSUPDRVSESSION pSession, const char *pszName, const char *pszInterfaceUuid, void **ppvFactoryIf);
a419e5c3ed740caf9a6db66cf72137a9426d5d59vboxsyncDECLASM(void *) UNWIND_WRAP(SUPR0ObjRegister)(PSUPDRVSESSION pSession, SUPDRVOBJTYPE enmType, PFNSUPDRVDESTRUCTOR pfnDestructor, void *pvUser1, void *pvUser2);
a419e5c3ed740caf9a6db66cf72137a9426d5d59vboxsyncDECLASM(int) UNWIND_WRAP(SUPR0ObjAddRef)(void *pvObj, PSUPDRVSESSION pSession);
a419e5c3ed740caf9a6db66cf72137a9426d5d59vboxsyncDECLASM(int) UNWIND_WRAP(SUPR0ObjAddRefEx)(void *pvObj, PSUPDRVSESSION pSession, bool fNoPreempt);
a419e5c3ed740caf9a6db66cf72137a9426d5d59vboxsyncDECLASM(int) UNWIND_WRAP(SUPR0ObjRelease)(void *pvObj, PSUPDRVSESSION pSession);
a419e5c3ed740caf9a6db66cf72137a9426d5d59vboxsyncDECLASM(int) UNWIND_WRAP(SUPR0ObjVerifyAccess)(void *pvObj, PSUPDRVSESSION pSession, const char *pszObjName);
a419e5c3ed740caf9a6db66cf72137a9426d5d59vboxsyncDECLASM(int) UNWIND_WRAP(SUPR0LockMem)(PSUPDRVSESSION pSession, RTR3PTR pvR3, uint32_t cPages, PRTHCPHYS paPages);
a419e5c3ed740caf9a6db66cf72137a9426d5d59vboxsyncDECLASM(int) UNWIND_WRAP(SUPR0UnlockMem)(PSUPDRVSESSION pSession, RTR3PTR pvR3);
a419e5c3ed740caf9a6db66cf72137a9426d5d59vboxsyncDECLASM(int) UNWIND_WRAP(SUPR0ContAlloc)(PSUPDRVSESSION pSession, uint32_t cPages, PRTR0PTR ppvR0, PRTR3PTR ppvR3, PRTHCPHYS pHCPhys);
a419e5c3ed740caf9a6db66cf72137a9426d5d59vboxsyncDECLASM(int) UNWIND_WRAP(SUPR0ContFree)(PSUPDRVSESSION pSession, RTHCUINTPTR uPtr);
a419e5c3ed740caf9a6db66cf72137a9426d5d59vboxsyncDECLASM(int) UNWIND_WRAP(SUPR0LowAlloc)(PSUPDRVSESSION pSession, uint32_t cPages, PRTR0PTR ppvR0, PRTR3PTR ppvR3, PRTHCPHYS paPages);
a419e5c3ed740caf9a6db66cf72137a9426d5d59vboxsyncDECLASM(int) UNWIND_WRAP(SUPR0LowFree)(PSUPDRVSESSION pSession, RTHCUINTPTR uPtr);
a419e5c3ed740caf9a6db66cf72137a9426d5d59vboxsyncDECLASM(int) UNWIND_WRAP(SUPR0MemAlloc)(PSUPDRVSESSION pSession, uint32_t cb, PRTR0PTR ppvR0, PRTR3PTR ppvR3);
a419e5c3ed740caf9a6db66cf72137a9426d5d59vboxsyncDECLASM(int) UNWIND_WRAP(SUPR0MemGetPhys)(PSUPDRVSESSION pSession, RTHCUINTPTR uPtr, PSUPPAGE paPages);
a419e5c3ed740caf9a6db66cf72137a9426d5d59vboxsyncDECLASM(int) UNWIND_WRAP(SUPR0MemFree)(PSUPDRVSESSION pSession, RTHCUINTPTR uPtr);
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsyncDECLASM(int) UNWIND_WRAP(SUPR0PageAlloc)(PSUPDRVSESSION pSession, uint32_t cPages, PRTR3PTR ppvR3, PRTHCPHYS paPages);
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsyncDECLASM(int) UNWIND_WRAP(SUPR0PageFree)(PSUPDRVSESSION pSession, RTR3PTR pvR3);
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsync//DECLASM(int) UNWIND_WRAP(SUPR0Printf)(const char *pszFormat, ...);
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsyncDECLASM(SUPPAGINGMODE) UNWIND_WRAP(SUPR0GetPagingMode)(void);
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsyncDECLASM(void *) UNWIND_WRAP(RTMemAlloc)(size_t cb) RT_NO_THROW;
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsyncDECLASM(void *) UNWIND_WRAP(RTMemAllocZ)(size_t cb) RT_NO_THROW;
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsyncDECLASM(void) UNWIND_WRAP(RTMemFree)(void *pv) RT_NO_THROW;
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsyncDECLASM(void *) UNWIND_WRAP(RTMemDup)(const void *pvSrc, size_t cb) RT_NO_THROW;
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsyncDECLASM(void *) UNWIND_WRAP(RTMemDupEx)(const void *pvSrc, size_t cbSrc, size_t cbExtra) RT_NO_THROW;
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsyncDECLASM(void *) UNWIND_WRAP(RTMemRealloc)(void *pvOld, size_t cbNew) RT_NO_THROW;
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsyncDECLASM(int) UNWIND_WRAP(RTR0MemObjAllocLow)(PRTR0MEMOBJ pMemObj, size_t cb, bool fExecutable);
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsyncDECLASM(int) UNWIND_WRAP(RTR0MemObjAllocPage)(PRTR0MEMOBJ pMemObj, size_t cb, bool fExecutable);
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsyncDECLASM(int) UNWIND_WRAP(RTR0MemObjAllocPhys)(PRTR0MEMOBJ pMemObj, size_t cb, RTHCPHYS PhysHighest);
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsyncDECLASM(int) UNWIND_WRAP(RTR0MemObjAllocPhysNC)(PRTR0MEMOBJ pMemObj, size_t cb, RTHCPHYS PhysHighest);
a419e5c3ed740caf9a6db66cf72137a9426d5d59vboxsyncDECLASM(int) UNWIND_WRAP(RTR0MemObjAllocCont)(PRTR0MEMOBJ pMemObj, size_t cb, bool fExecutable);
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsyncDECLASM(int) UNWIND_WRAP(RTR0MemObjEnterPhys)(PRTR0MEMOBJ pMemObj, RTHCPHYS Phys, size_t cb);
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsyncDECLASM(int) UNWIND_WRAP(RTR0MemObjLockUser)(PRTR0MEMOBJ pMemObj, RTR3PTR R3Ptr, size_t cb, RTR0PROCESS R0Process);
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsyncDECLASM(int) UNWIND_WRAP(RTR0MemObjMapKernel)(PRTR0MEMOBJ pMemObj, RTR0MEMOBJ MemObjToMap, void *pvFixed, size_t uAlignment, unsigned fProt);
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsyncDECLASM(int) UNWIND_WRAP(RTR0MemObjMapKernelEx)(PRTR0MEMOBJ pMemObj, RTR0MEMOBJ MemObjToMap, void *pvFixed, size_t uAlignment, unsigned fProt, size_t offSub, size_t cbSub);
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsyncDECLASM(int) UNWIND_WRAP(RTR0MemObjMapUser)(PRTR0MEMOBJ pMemObj, RTR0MEMOBJ MemObjToMap, RTR3PTR R3PtrFixed, size_t uAlignment, unsigned fProt, RTR0PROCESS R0Process);
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsync/*DECLASM(void *) UNWIND_WRAP(RTR0MemObjAddress)(RTR0MEMOBJ MemObj); - not necessary */
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsync/*DECLASM(RTR3PTR) UNWIND_WRAP(RTR0MemObjAddressR3)(RTR0MEMOBJ MemObj); - not necessary */
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsync/*DECLASM(size_t) UNWIND_WRAP(RTR0MemObjSize)(RTR0MEMOBJ MemObj); - not necessary */
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsync/*DECLASM(bool) UNWIND_WRAP(RTR0MemObjIsMapping)(RTR0MEMOBJ MemObj); - not necessary */
513aeb62b50925ef51b8be944083cd2589ecf743vboxsync/*DECLASM(RTHCPHYS) UNWIND_WRAP(RTR0MemObjGetPagePhysAddr)(RTR0MEMOBJ MemObj, size_t iPage); - not necessary */
a419e5c3ed740caf9a6db66cf72137a9426d5d59vboxsyncDECLASM(int) UNWIND_WRAP(RTR0MemObjFree)(RTR0MEMOBJ MemObj, bool fFreeMappings);
202cf39359cf7baae7442c23a9dc8b6549964b38vboxsync/* RTProcSelf - not necessary */
202cf39359cf7baae7442c23a9dc8b6549964b38vboxsync/* RTR0ProcHandleSelf - not necessary */
202cf39359cf7baae7442c23a9dc8b6549964b38vboxsyncDECLASM(int) UNWIND_WRAP(RTSemFastMutexCreate)(PRTSEMFASTMUTEX pMutexSem);
202cf39359cf7baae7442c23a9dc8b6549964b38vboxsyncDECLASM(int) UNWIND_WRAP(RTSemFastMutexDestroy)(RTSEMFASTMUTEX MutexSem);
202cf39359cf7baae7442c23a9dc8b6549964b38vboxsyncDECLASM(int) UNWIND_WRAP(RTSemFastMutexRequest)(RTSEMFASTMUTEX MutexSem);
202cf39359cf7baae7442c23a9dc8b6549964b38vboxsyncDECLASM(int) UNWIND_WRAP(RTSemFastMutexRelease)(RTSEMFASTMUTEX MutexSem);
202cf39359cf7baae7442c23a9dc8b6549964b38vboxsyncDECLASM(int) UNWIND_WRAP(RTSemEventCreate)(PRTSEMEVENT pEventSem);
202cf39359cf7baae7442c23a9dc8b6549964b38vboxsyncDECLASM(int) UNWIND_WRAP(RTSemEventSignal)(RTSEMEVENT EventSem);
202cf39359cf7baae7442c23a9dc8b6549964b38vboxsyncDECLASM(int) UNWIND_WRAP(RTSemEventWait)(RTSEMEVENT EventSem, unsigned cMillies);
202cf39359cf7baae7442c23a9dc8b6549964b38vboxsyncDECLASM(int) UNWIND_WRAP(RTSemEventWaitNoResume)(RTSEMEVENT EventSem, unsigned cMillies);
202cf39359cf7baae7442c23a9dc8b6549964b38vboxsyncDECLASM(int) UNWIND_WRAP(RTSemEventDestroy)(RTSEMEVENT EventSem);
202cf39359cf7baae7442c23a9dc8b6549964b38vboxsyncDECLASM(int) UNWIND_WRAP(RTSemEventMultiCreate)(PRTSEMEVENTMULTI pEventMultiSem);
202cf39359cf7baae7442c23a9dc8b6549964b38vboxsyncDECLASM(int) UNWIND_WRAP(RTSemEventMultiSignal)(RTSEMEVENTMULTI EventMultiSem);
202cf39359cf7baae7442c23a9dc8b6549964b38vboxsyncDECLASM(int) UNWIND_WRAP(RTSemEventMultiReset)(RTSEMEVENTMULTI EventMultiSem);
4c83fd46d254a6e1cad9f1df4395408cd9ff7833vboxsyncDECLASM(int) UNWIND_WRAP(RTSemEventMultiWait)(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies);
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsyncDECLASM(int) UNWIND_WRAP(RTSemEventMultiWaitNoResume)(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies);
513aeb62b50925ef51b8be944083cd2589ecf743vboxsyncDECLASM(int) UNWIND_WRAP(RTSemEventMultiDestroy)(RTSEMEVENTMULTI EventMultiSem);
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsyncDECLASM(int) UNWIND_WRAP(RTSpinlockCreate)(PRTSPINLOCK pSpinlock);
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsyncDECLASM(int) UNWIND_WRAP(RTSpinlockDestroy)(RTSPINLOCK Spinlock);
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsyncDECLASM(void) UNWIND_WRAP(RTSpinlockAcquire)(RTSPINLOCK Spinlock, PRTSPINLOCKTMP pTmp);
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsyncDECLASM(void) UNWIND_WRAP(RTSpinlockRelease)(RTSPINLOCK Spinlock, PRTSPINLOCKTMP pTmp);
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsyncDECLASM(void) UNWIND_WRAP(RTSpinlockAcquireNoInts)(RTSPINLOCK Spinlock, PRTSPINLOCKTMP pTmp);
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsyncDECLASM(void) UNWIND_WRAP(RTSpinlockReleaseNoInts)(RTSPINLOCK Spinlock, PRTSPINLOCKTMP pTmp);
c80170800394cbf2746e3136b41886c2d11617aevboxsync/* RTTimeNanoTS - not necessary */
c80170800394cbf2746e3136b41886c2d11617aevboxsync/* RTTimeMilliTS - not necessary */
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsync/* RTTimeSystemNanoTS - not necessary */
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsync/* RTTimeSystemMilliTS - not necessary */
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsync/* RTThreadNativeSelf - not necessary */
c80170800394cbf2746e3136b41886c2d11617aevboxsyncDECLASM(int) UNWIND_WRAP(RTThreadSleep)(unsigned cMillies);
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsync/* RTThreadSelf - not necessary */
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsyncDECLASM(int) UNWIND_WRAP(RTThreadCreate)(PRTTHREAD pThread, PFNRTTHREAD pfnThread, void *pvUser, size_t cbStack,
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsync RTTHREADTYPE enmType, unsigned fFlags, const char *pszName);
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsyncDECLASM(RTNATIVETHREAD) UNWIND_WRAP(RTThreadGetNative)(RTTHREAD Thread);
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsyncDECLASM(int) UNWIND_WRAP(RTThreadWait)(RTTHREAD Thread, unsigned cMillies, int *prc);
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsyncDECLASM(int) UNWIND_WRAP(RTThreadWaitNoResume)(RTTHREAD Thread, unsigned cMillies, int *prc);
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsyncDECLASM(const char *) UNWIND_WRAP(RTThreadGetName)(RTTHREAD Thread);
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsyncDECLASM(const char *) UNWIND_WRAP(RTThreadSelfName)(void);
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsyncDECLASM(RTTHREADTYPE) UNWIND_WRAP(RTThreadGetType)(RTTHREAD Thread);
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsyncDECLASM(int) UNWIND_WRAP(RTThreadUserSignal)(RTTHREAD Thread);
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsyncDECLASM(int) UNWIND_WRAP(RTThreadUserReset)(RTTHREAD Thread);
4c83fd46d254a6e1cad9f1df4395408cd9ff7833vboxsyncDECLASM(int) UNWIND_WRAP(RTThreadUserWait)(RTTHREAD Thread, unsigned cMillies);
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsyncDECLASM(int) UNWIND_WRAP(RTThreadUserWaitNoResume)(RTTHREAD Thread, unsigned cMillies);
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsync/* RTLogDefaultInstance - a bit of a gamble, but we do not want the overhead! */
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsync/* RTMpCpuId - not necessary */
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsync/* RTMpCpuIdFromSetIndex - not necessary */
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsync/* RTMpCpuIdToSetIndex - not necessary */
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsync/* RTMpIsCpuPossible - not necessary */
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsync/* RTMpGetCount - not necessary */
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsync/* RTMpGetMaxCpuId - not necessary */
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsync/* RTMpGetOnlineCount - not necessary */
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsync/* RTMpGetOnlineSet - not necessary */
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsync/* RTMpGetSet - not necessary */
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsync/* RTMpIsCpuOnline - not necessary */
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsyncDECLASM(int) UNWIND_WRAP(RTMpOnAll)(PFNRTMPWORKER pfnWorker, void *pvUser1, void *pvUser2);
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsyncDECLASM(int) UNWIND_WRAP(RTMpOnOthers)(PFNRTMPWORKER pfnWorker, void *pvUser1, void *pvUser2);
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsyncDECLASM(int) UNWIND_WRAP(RTMpOnSpecific)(RTCPUID idCpu, PFNRTMPWORKER pfnWorker, void *pvUser1, void *pvUser2);
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsyncDECLASM(int) UNWIND_WRAP(RTMpIsCpuWorkPending)(void);
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsync/* RTLogRelDefaultInstance - not necessary. */
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsyncDECLASM(int) UNWIND_WRAP(RTLogSetDefaultInstanceThread)(PRTLOGGER pLogger, uintptr_t uKey);
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsync/* RTLogLogger - can't wrap this buster. */
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsync/* RTLogLoggerEx - can't wrap this buster. */
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsyncDECLASM(void) UNWIND_WRAP(RTLogLoggerExV)(PRTLOGGER pLogger, unsigned fFlags, unsigned iGroup, const char *pszFormat, va_list args);
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsync/* RTLogPrintf - can't wrap this buster. */ /** @todo provide va_list log wrappers in RuntimeR0. */
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsyncDECLASM(void) UNWIND_WRAP(RTLogPrintfV)(const char *pszFormat, va_list args);
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsyncDECLASM(void) UNWIND_WRAP(AssertMsg1)(const char *pszExpr, unsigned uLine, const char *pszFile, const char *pszFunction);
4c83fd46d254a6e1cad9f1df4395408cd9ff7833vboxsync/* AssertMsg2 - can't wrap this buster. */
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsync#endif /* RT_WITH_W64_UNWIND_HACK */
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsync/*******************************************************************************
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsync* Global Variables *
4c83fd46d254a6e1cad9f1df4395408cd9ff7833vboxsync*******************************************************************************/
4c83fd46d254a6e1cad9f1df4395408cd9ff7833vboxsync * Array of the R0 SUP API.
e3a5468cbde9a6f09d91ada9e117bf458d8ea578vboxsync /* name function */
513aeb62b50925ef51b8be944083cd2589ecf743vboxsync /* Entries with absolute addresses determined at runtime, fixup
e05f27c2a433db4ad6e65a4daec7dc1fc7c05d6cvboxsync code makes ugly ASSUMPTIONS about the order here: */
513aeb62b50925ef51b8be944083cd2589ecf743vboxsync { "SUPR0AbsIs64bit", (void *)0 },
4c83fd46d254a6e1cad9f1df4395408cd9ff7833vboxsync { "SUPR0Abs64bitKernelCS", (void *)0 },
513aeb62b50925ef51b8be944083cd2589ecf743vboxsync { "SUPR0Abs64bitKernelSS", (void *)0 },
4c83fd46d254a6e1cad9f1df4395408cd9ff7833vboxsync { "SUPR0Abs64bitKernelDS", (void *)0 },
e3a5468cbde9a6f09d91ada9e117bf458d8ea578vboxsync { "SUPR0AbsKernelCS", (void *)0 },
513aeb62b50925ef51b8be944083cd2589ecf743vboxsync { "SUPR0AbsKernelSS", (void *)0 },
e05f27c2a433db4ad6e65a4daec7dc1fc7c05d6cvboxsync { "SUPR0AbsKernelDS", (void *)0 },
513aeb62b50925ef51b8be944083cd2589ecf743vboxsync { "SUPR0AbsKernelES", (void *)0 },
4c83fd46d254a6e1cad9f1df4395408cd9ff7833vboxsync { "SUPR0AbsKernelFS", (void *)0 },
513aeb62b50925ef51b8be944083cd2589ecf743vboxsync { "SUPR0AbsKernelGS", (void *)0 },
513aeb62b50925ef51b8be944083cd2589ecf743vboxsync /* Normal function pointers: */
513aeb62b50925ef51b8be944083cd2589ecf743vboxsync { "SUPR0ComponentRegisterFactory", (void *)UNWIND_WRAP(SUPR0ComponentRegisterFactory) },
513aeb62b50925ef51b8be944083cd2589ecf743vboxsync { "SUPR0ComponentDeregisterFactory", (void *)UNWIND_WRAP(SUPR0ComponentDeregisterFactory) },
513aeb62b50925ef51b8be944083cd2589ecf743vboxsync { "SUPR0ComponentQueryFactory", (void *)UNWIND_WRAP(SUPR0ComponentQueryFactory) },
513aeb62b50925ef51b8be944083cd2589ecf743vboxsync { "SUPR0ObjRegister", (void *)UNWIND_WRAP(SUPR0ObjRegister) },
513aeb62b50925ef51b8be944083cd2589ecf743vboxsync { "SUPR0ObjAddRef", (void *)UNWIND_WRAP(SUPR0ObjAddRef) },
c233a6c1d308bef5547fbdaf150e55d4bffe8160vboxsync { "SUPR0ObjAddRefEx", (void *)UNWIND_WRAP(SUPR0ObjAddRefEx) },
4c83fd46d254a6e1cad9f1df4395408cd9ff7833vboxsync { "SUPR0ObjRelease", (void *)UNWIND_WRAP(SUPR0ObjRelease) },
513aeb62b50925ef51b8be944083cd2589ecf743vboxsync { "SUPR0ObjVerifyAccess", (void *)UNWIND_WRAP(SUPR0ObjVerifyAccess) },
67d41b57434d471b6e80647a0820bce4dc23d29bvboxsync { "SUPR0LockMem", (void *)UNWIND_WRAP(SUPR0LockMem) },
67d41b57434d471b6e80647a0820bce4dc23d29bvboxsync { "SUPR0UnlockMem", (void *)UNWIND_WRAP(SUPR0UnlockMem) },
67d41b57434d471b6e80647a0820bce4dc23d29bvboxsync { "SUPR0ContAlloc", (void *)UNWIND_WRAP(SUPR0ContAlloc) },
67d41b57434d471b6e80647a0820bce4dc23d29bvboxsync { "SUPR0ContFree", (void *)UNWIND_WRAP(SUPR0ContFree) },
67d41b57434d471b6e80647a0820bce4dc23d29bvboxsync { "SUPR0LowAlloc", (void *)UNWIND_WRAP(SUPR0LowAlloc) },
4c83fd46d254a6e1cad9f1df4395408cd9ff7833vboxsync { "SUPR0LowFree", (void *)UNWIND_WRAP(SUPR0LowFree) },
4c83fd46d254a6e1cad9f1df4395408cd9ff7833vboxsync { "SUPR0MemAlloc", (void *)UNWIND_WRAP(SUPR0MemAlloc) },
4c83fd46d254a6e1cad9f1df4395408cd9ff7833vboxsync { "SUPR0MemGetPhys", (void *)UNWIND_WRAP(SUPR0MemGetPhys) },
26bb484d2741bfe195e287adff4a7b8077a55dc8vboxsync { "SUPR0MemFree", (void *)UNWIND_WRAP(SUPR0MemFree) },
513aeb62b50925ef51b8be944083cd2589ecf743vboxsync { "SUPR0PageAlloc", (void *)UNWIND_WRAP(SUPR0PageAlloc) },
18142bb4472fae3b4ba86e62f513e52eb792fcecvboxsync { "SUPR0PageFree", (void *)UNWIND_WRAP(SUPR0PageFree) },
e05f27c2a433db4ad6e65a4daec7dc1fc7c05d6cvboxsync { "SUPR0Printf", (void *)SUPR0Printf }, /** @todo needs wrapping? */
e29c8ca0fcdec07576097dce21b0a924c014d270vboxsync { "SUPR0GetPagingMode", (void *)UNWIND_WRAP(SUPR0GetPagingMode) },
4c83fd46d254a6e1cad9f1df4395408cd9ff7833vboxsync { "RTMemAllocZ", (void *)UNWIND_WRAP(RTMemAllocZ) },
513aeb62b50925ef51b8be944083cd2589ecf743vboxsync /*{ "RTMemDup", (void *)UNWIND_WRAP(RTMemDup) },
513aeb62b50925ef51b8be944083cd2589ecf743vboxsync { "RTMemDupEx", (void *)UNWIND_WRAP(RTMemDupEx) },*/
513aeb62b50925ef51b8be944083cd2589ecf743vboxsync { "RTMemRealloc", (void *)UNWIND_WRAP(RTMemRealloc) },
a240f1229507269d3449217c9d483597e498d3bcvboxsync { "RTR0MemObjAllocLow", (void *)UNWIND_WRAP(RTR0MemObjAllocLow) },
a240f1229507269d3449217c9d483597e498d3bcvboxsync { "RTR0MemObjAllocPage", (void *)UNWIND_WRAP(RTR0MemObjAllocPage) },
7c17a8c920f84a6da1b663bf0529900bf6557ddfvboxsync { "RTR0MemObjAllocPhys", (void *)UNWIND_WRAP(RTR0MemObjAllocPhys) },
a240f1229507269d3449217c9d483597e498d3bcvboxsync { "RTR0MemObjAllocPhysNC", (void *)UNWIND_WRAP(RTR0MemObjAllocPhysNC) },
a240f1229507269d3449217c9d483597e498d3bcvboxsync { "RTR0MemObjAllocCont", (void *)UNWIND_WRAP(RTR0MemObjAllocCont) },
a240f1229507269d3449217c9d483597e498d3bcvboxsync { "RTR0MemObjEnterPhys", (void *)UNWIND_WRAP(RTR0MemObjEnterPhys) },
a240f1229507269d3449217c9d483597e498d3bcvboxsync { "RTR0MemObjLockUser", (void *)UNWIND_WRAP(RTR0MemObjLockUser) },
1701080b3ba6367b310c28b85a71c269dad5b789vboxsync { "RTR0MemObjMapKernel", (void *)UNWIND_WRAP(RTR0MemObjMapKernel) },
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTR0MemObjMapKernelEx", (void *)UNWIND_WRAP(RTR0MemObjMapKernelEx) },
1701080b3ba6367b310c28b85a71c269dad5b789vboxsync { "RTR0MemObjMapUser", (void *)UNWIND_WRAP(RTR0MemObjMapUser) },
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsync { "RTR0MemObjAddress", (void *)RTR0MemObjAddress },
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsync { "RTR0MemObjAddressR3", (void *)RTR0MemObjAddressR3 },
1701080b3ba6367b310c28b85a71c269dad5b789vboxsync { "RTR0MemObjIsMapping", (void *)RTR0MemObjIsMapping },
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTR0MemObjGetPagePhysAddr", (void *)RTR0MemObjGetPagePhysAddr },
1701080b3ba6367b310c28b85a71c269dad5b789vboxsync { "RTR0MemObjFree", (void *)UNWIND_WRAP(RTR0MemObjFree) },
63abe53fde500f57944b09a7860e3515b966270cvboxsync/* These don't work yet on linux - use fast mutexes!
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTSemMutexCreate", (void *)RTSemMutexCreate },
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTSemMutexRequest", (void *)RTSemMutexRequest },
10cb8cb86f4b22e0e4aaed184c4ba3fc90907854vboxsync { "RTSemMutexRelease", (void *)RTSemMutexRelease },
10cb8cb86f4b22e0e4aaed184c4ba3fc90907854vboxsync { "RTSemMutexDestroy", (void *)RTSemMutexDestroy },
10cb8cb86f4b22e0e4aaed184c4ba3fc90907854vboxsync { "RTR0ProcHandleSelf", (void *)RTR0ProcHandleSelf },
10cb8cb86f4b22e0e4aaed184c4ba3fc90907854vboxsync { "RTSemFastMutexCreate", (void *)UNWIND_WRAP(RTSemFastMutexCreate) },
10cb8cb86f4b22e0e4aaed184c4ba3fc90907854vboxsync { "RTSemFastMutexDestroy", (void *)UNWIND_WRAP(RTSemFastMutexDestroy) },
10cb8cb86f4b22e0e4aaed184c4ba3fc90907854vboxsync { "RTSemFastMutexRequest", (void *)UNWIND_WRAP(RTSemFastMutexRequest) },
10cb8cb86f4b22e0e4aaed184c4ba3fc90907854vboxsync { "RTSemFastMutexRelease", (void *)UNWIND_WRAP(RTSemFastMutexRelease) },
10cb8cb86f4b22e0e4aaed184c4ba3fc90907854vboxsync { "RTSemEventCreate", (void *)UNWIND_WRAP(RTSemEventCreate) },
10cb8cb86f4b22e0e4aaed184c4ba3fc90907854vboxsync { "RTSemEventSignal", (void *)UNWIND_WRAP(RTSemEventSignal) },
10cb8cb86f4b22e0e4aaed184c4ba3fc90907854vboxsync { "RTSemEventWait", (void *)UNWIND_WRAP(RTSemEventWait) },
10cb8cb86f4b22e0e4aaed184c4ba3fc90907854vboxsync { "RTSemEventWaitNoResume", (void *)UNWIND_WRAP(RTSemEventWaitNoResume) },
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTSemEventDestroy", (void *)UNWIND_WRAP(RTSemEventDestroy) },
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTSemEventMultiCreate", (void *)UNWIND_WRAP(RTSemEventMultiCreate) },
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTSemEventMultiSignal", (void *)UNWIND_WRAP(RTSemEventMultiSignal) },
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTSemEventMultiReset", (void *)UNWIND_WRAP(RTSemEventMultiReset) },
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTSemEventMultiWait", (void *)UNWIND_WRAP(RTSemEventMultiWait) },
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTSemEventMultiWaitNoResume", (void *)UNWIND_WRAP(RTSemEventMultiWaitNoResume) },
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTSemEventMultiDestroy", (void *)UNWIND_WRAP(RTSemEventMultiDestroy) },
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTSpinlockCreate", (void *)UNWIND_WRAP(RTSpinlockCreate) },
3b8ffb6094762b1754b860e35f77070f91cdd3a5vboxsync { "RTSpinlockDestroy", (void *)UNWIND_WRAP(RTSpinlockDestroy) },
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTSpinlockAcquire", (void *)UNWIND_WRAP(RTSpinlockAcquire) },
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTSpinlockRelease", (void *)UNWIND_WRAP(RTSpinlockRelease) },
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTSpinlockAcquireNoInts", (void *)UNWIND_WRAP(RTSpinlockAcquireNoInts) },
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTSpinlockReleaseNoInts", (void *)UNWIND_WRAP(RTSpinlockReleaseNoInts) },
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTTimeSystemNanoTS", (void *)RTTimeSystemNanoTS },
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTTimeSystemMillieTS", (void *)RTTimeSystemMilliTS },
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTThreadNativeSelf", (void *)RTThreadNativeSelf },
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTThreadSleep", (void *)UNWIND_WRAP(RTThreadSleep) },
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTThreadYield", (void *)UNWIND_WRAP(RTThreadYield) },
e961f5bfe1727c6816d3dad3805ebe21b6ba1c64vboxsync#if 0 /* Thread APIs, Part 2. */
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTThreadSelf", (void *)UNWIND_WRAP(RTThreadSelf) },
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTThreadCreate", (void *)UNWIND_WRAP(RTThreadCreate) }, /** @todo need to wrap the callback */
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTThreadGetNative", (void *)UNWIND_WRAP(RTThreadGetNative) },
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTThreadWait", (void *)UNWIND_WRAP(RTThreadWait) },
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTThreadWaitNoResume", (void *)UNWIND_WRAP(RTThreadWaitNoResume) },
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTThreadGetName", (void *)UNWIND_WRAP(RTThreadGetName) },
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTThreadSelfName", (void *)UNWIND_WRAP(RTThreadSelfName) },
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTThreadGetType", (void *)UNWIND_WRAP(RTThreadGetType) },
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTThreadUserSignal", (void *)UNWIND_WRAP(RTThreadUserSignal) },
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTThreadUserReset", (void *)UNWIND_WRAP(RTThreadUserReset) },
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTThreadUserWait", (void *)UNWIND_WRAP(RTThreadUserWait) },
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTThreadUserWaitNoResume", (void *)UNWIND_WRAP(RTThreadUserWaitNoResume) },
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTLogDefaultInstance", (void *)RTLogDefaultInstance },
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTMpCpuIdFromSetIndex", (void *)RTMpCpuIdFromSetIndex },
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTMpCpuIdToSetIndex", (void *)RTMpCpuIdToSetIndex },
e05f27c2a433db4ad6e65a4daec7dc1fc7c05d6cvboxsync { "RTMpIsCpuPossible", (void *)RTMpIsCpuPossible },
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTMpGetOnlineCount", (void *)RTMpGetOnlineCount },
a240f1229507269d3449217c9d483597e498d3bcvboxsync { "RTMpIsCpuWorkPending", (void *)UNWIND_WRAP(RTMpIsCpuWorkPending) },
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTMpOnOthers", (void *)UNWIND_WRAP(RTMpOnOthers) },
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTMpOnSpecific", (void *)UNWIND_WRAP(RTMpOnSpecific) },
ad65c02966453e954ae479971daf0dedaae96fdavboxsync { "RTPowerNotificationRegister", (void *)RTPowerNotificationRegister },
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTPowerNotificationDeregister", (void *)RTPowerNotificationDeregister },
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTLogRelDefaultInstance", (void *)RTLogRelDefaultInstance },
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTLogSetDefaultInstanceThread", (void *)UNWIND_WRAP(RTLogSetDefaultInstanceThread) },
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTLogLogger", (void *)RTLogLogger }, /** @todo remove this */
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTLogLoggerEx", (void *)RTLogLoggerEx }, /** @todo remove this */
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTLogLoggerExV", (void *)UNWIND_WRAP(RTLogLoggerExV) },
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTLogPrintf", (void *)RTLogPrintf }, /** @todo remove this */
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTLogPrintfV", (void *)UNWIND_WRAP(RTLogPrintfV) },
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "AssertMsg2", (void *)AssertMsg2 }, /** @todo replace this by RTAssertMsg2V */
63abe53fde500f57944b09a7860e3515b966270cvboxsync { "RTR0AssertPanicSystem", (void *)RTR0AssertPanicSystem },
63abe53fde500f57944b09a7860e3515b966270cvboxsync * Drag in the rest of IRPT since we share it with the
63abe53fde500f57944b09a7860e3515b966270cvboxsync * rest of the kernel modules on darwin.
e05f27c2a433db4ad6e65a4daec7dc1fc7c05d6cvboxsync#endif /* RT_OS_DARWIN || RT_OS_SOLARIS */
63abe53fde500f57944b09a7860e3515b966270cvboxsync * Initializes the device extentsion structure.
63abe53fde500f57944b09a7860e3515b966270cvboxsync * @returns IPRT status code.
63abe53fde500f57944b09a7860e3515b966270cvboxsync * @param pDevExt The device extension to initialize.
63abe53fde500f57944b09a7860e3515b966270cvboxsyncint VBOXCALL supdrvInitDevExt(PSUPDRVDEVEXT pDevExt)
63abe53fde500f57944b09a7860e3515b966270cvboxsync * Create the release log.
63abe53fde500f57944b09a7860e3515b966270cvboxsync static const char * const s_apszGroups[] = VBOX_LOGGROUP_NAMES;
63abe53fde500f57944b09a7860e3515b966270cvboxsync rc = RTLogCreate(&pRelLogger, 0 /* fFlags */, "all",
63abe53fde500f57944b09a7860e3515b966270cvboxsync "VBOX_RELEASE_LOG", RT_ELEMENTS(s_apszGroups), s_apszGroups,
63abe53fde500f57944b09a7860e3515b966270cvboxsync * Initialize it.
63abe53fde500f57944b09a7860e3515b966270cvboxsync rc = RTSemFastMutexCreate(&pDevExt->mtxComponentFactory);
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync pDevExt->u32Cookie = BIRD; /** @todo make this random? */
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync * Fixup the absolute symbols.
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync * Because of the table indexing assumptions we'll have a little #ifdef orgy
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync * here rather than distributing this to OS specific files. At least for now.
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsync g_aFunctions[0].pfn = (void *)1; /* SUPR0AbsIs64bit */
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync g_aFunctions[1].pfn = (void *)0x80; /* SUPR0Abs64bitKernelCS - KERNEL64_CS, seg.h */
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync g_aFunctions[2].pfn = (void *)0x88; /* SUPR0Abs64bitKernelSS - KERNEL64_SS, seg.h */
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync g_aFunctions[3].pfn = (void *)0x88; /* SUPR0Abs64bitKernelDS - KERNEL64_SS, seg.h */
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync g_aFunctions[0].pfn = g_aFunctions[1].pfn = g_aFunctions[2].pfn = g_aFunctions[4].pfn = (void *)0;
3b8ffb6094762b1754b860e35f77070f91cdd3a5vboxsync g_aFunctions[4].pfn = (void *)0x08; /* SUPR0AbsKernelCS - KERNEL_CS, seg.h */
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync g_aFunctions[5].pfn = (void *)0x10; /* SUPR0AbsKernelSS - KERNEL_DS, seg.h */
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync g_aFunctions[6].pfn = (void *)0x10; /* SUPR0AbsKernelDS - KERNEL_DS, seg.h */
3b8ffb6094762b1754b860e35f77070f91cdd3a5vboxsync g_aFunctions[7].pfn = (void *)0x10; /* SUPR0AbsKernelES - KERNEL_DS, seg.h */
3b8ffb6094762b1754b860e35f77070f91cdd3a5vboxsync g_aFunctions[8].pfn = (void *)0x10; /* SUPR0AbsKernelFS - KERNEL_DS, seg.h */
3b8ffb6094762b1754b860e35f77070f91cdd3a5vboxsync g_aFunctions[9].pfn = (void *)0x48; /* SUPR0AbsKernelGS - CPU_DATA_GS, seg.h */
3b8ffb6094762b1754b860e35f77070f91cdd3a5vboxsync# else /* 64-bit darwin: */
3b8ffb6094762b1754b860e35f77070f91cdd3a5vboxsync g_aFunctions[0].pfn = (void *)1; /* SUPR0AbsIs64bit */
3b8ffb6094762b1754b860e35f77070f91cdd3a5vboxsync g_aFunctions[1].pfn = (void *)(uintptr_t)ASMGetCS(); /* SUPR0Abs64bitKernelCS */
3b8ffb6094762b1754b860e35f77070f91cdd3a5vboxsync g_aFunctions[2].pfn = (void *)(uintptr_t)ASMGetSS(); /* SUPR0Abs64bitKernelSS */
3b8ffb6094762b1754b860e35f77070f91cdd3a5vboxsync g_aFunctions[3].pfn = (void *)0; /* SUPR0Abs64bitKernelDS */
3b8ffb6094762b1754b860e35f77070f91cdd3a5vboxsync g_aFunctions[4].pfn = (void *)(uintptr_t)ASMGetCS(); /* SUPR0AbsKernelCS */
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync g_aFunctions[5].pfn = (void *)(uintptr_t)ASMGetSS(); /* SUPR0AbsKernelSS */
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync g_aFunctions[6].pfn = (void *)0; /* SUPR0AbsKernelDS */
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync g_aFunctions[7].pfn = (void *)0; /* SUPR0AbsKernelES */
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsync g_aFunctions[8].pfn = (void *)0; /* SUPR0AbsKernelFS */
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync g_aFunctions[9].pfn = (void *)0; /* SUPR0AbsKernelGS */
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync#else /* !RT_OS_DARWIN */
3b8ffb6094762b1754b860e35f77070f91cdd3a5vboxsync g_aFunctions[0].pfn = (void *)1; /* SUPR0AbsIs64bit */
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync g_aFunctions[1].pfn = (void *)(uintptr_t)ASMGetCS(); /* SUPR0Abs64bitKernelCS */
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync g_aFunctions[2].pfn = (void *)(uintptr_t)ASMGetSS(); /* SUPR0Abs64bitKernelSS */
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync g_aFunctions[3].pfn = (void *)(uintptr_t)ASMGetDS(); /* SUPR0Abs64bitKernelDS */
3b8ffb6094762b1754b860e35f77070f91cdd3a5vboxsync g_aFunctions[0].pfn = g_aFunctions[1].pfn = g_aFunctions[2].pfn = g_aFunctions[4].pfn = (void *)0;
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsync g_aFunctions[4].pfn = (void *)(uintptr_t)ASMGetCS(); /* SUPR0AbsKernelCS */
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync g_aFunctions[5].pfn = (void *)(uintptr_t)ASMGetSS(); /* SUPR0AbsKernelSS */
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync g_aFunctions[6].pfn = (void *)(uintptr_t)ASMGetDS(); /* SUPR0AbsKernelDS */
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync g_aFunctions[7].pfn = (void *)(uintptr_t)ASMGetES(); /* SUPR0AbsKernelES */
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync g_aFunctions[8].pfn = (void *)(uintptr_t)ASMGetFS(); /* SUPR0AbsKernelFS */
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsync g_aFunctions[9].pfn = (void *)(uintptr_t)ASMGetGS(); /* SUPR0AbsKernelGS */
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync#endif /* !RT_OS_DARWIN */
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync RTSemFastMutexDestroy(pDevExt->mtxComponentFactory);
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync * Delete the device extension (e.g. cleanup members).
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync * @param pDevExt The device extension to delete.
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsyncvoid VBOXCALL supdrvDeleteDevExt(PSUPDRVDEVEXT pDevExt)
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync * Kill mutexes and spinlocks.
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync RTSemFastMutexDestroy(pDevExt->mtxComponentFactory);
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync * Free lists.
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync /* objects. */
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync#if !defined(DEBUG_bird) || !defined(RT_OS_LINUX) /* breaks unloading, temporary, remove me! */
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync Assert(!pObj); /* (can trigger on forced unloads) */
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync /* usage records. */
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync /* kill the GIP. */
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync /* destroy the loggers. */
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync * Create session.
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync * @returns IPRT status code.
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync * @param pDevExt Device extension.
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync * @param fUser Flag indicating whether this is a user or kernel session.
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync * @param ppSession Where to store the pointer to the session data.
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsyncint VBOXCALL supdrvCreateSession(PSUPDRVDEVEXT pDevExt, bool fUser, PSUPDRVSESSION *ppSession)
831c9796bf55b3de7e945e11d5d087b0ee4ffcd6vboxsync * Allocate memory for the session data.
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync PSUPDRVSESSION pSession = *ppSession = (PSUPDRVSESSION)RTMemAllocZ(sizeof(*pSession));
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync /* Initialize session data. */
63abe53fde500f57944b09a7860e3515b966270cvboxsync /*pSession->pLdrUsage = NULL;
63abe53fde500f57944b09a7860e3515b966270cvboxsync pSession->pVM = NULL;
63abe53fde500f57944b09a7860e3515b966270cvboxsync pSession->pUsage = NULL;
63abe53fde500f57944b09a7860e3515b966270cvboxsync pSession->pGip = NULL;
5358508a9c364e20d5ae19ac1e95c9c2597fde1avboxsync pSession->fGipReferenced = false;
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsync pSession->Bundle.cUsed = 0; */
63abe53fde500f57944b09a7860e3515b966270cvboxsync LogFlow(("Created session %p initial cookie=%#x\n", pSession, pSession->u32Cookie));
63abe53fde500f57944b09a7860e3515b966270cvboxsync * Shared code for cleaning up a session.
e961f5bfe1727c6816d3dad3805ebe21b6ba1c64vboxsync * @param pDevExt Device extension.
63abe53fde500f57944b09a7860e3515b966270cvboxsync * @param pSession Session data.
63abe53fde500f57944b09a7860e3515b966270cvboxsync * This data will be freed by this routine.
63abe53fde500f57944b09a7860e3515b966270cvboxsyncvoid VBOXCALL supdrvCloseSession(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession)
63abe53fde500f57944b09a7860e3515b966270cvboxsync * Cleanup the session first.
63abe53fde500f57944b09a7860e3515b966270cvboxsync * Free the rest of the session stuff.
63abe53fde500f57944b09a7860e3515b966270cvboxsync * Shared code for cleaning up a session (but not quite freeing it).
63abe53fde500f57944b09a7860e3515b966270cvboxsync * This is primarily intended for MAC OS X where we have to clean up the memory
63abe53fde500f57944b09a7860e3515b966270cvboxsync * stuff before the file handle is closed.
63abe53fde500f57944b09a7860e3515b966270cvboxsync * @param pDevExt Device extension.
63abe53fde500f57944b09a7860e3515b966270cvboxsync * @param pSession Session data.
0a31ef301cd343725c4ee64edb7f5a5e2dc51432vboxsync * This data will be freed by this routine.
0a31ef301cd343725c4ee64edb7f5a5e2dc51432vboxsyncvoid VBOXCALL supdrvCleanupSession(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession)
63abe53fde500f57944b09a7860e3515b966270cvboxsync LogFlow(("supdrvCleanupSession: pSession=%p\n", pSession));
63abe53fde500f57944b09a7860e3515b966270cvboxsync * Remove logger instances related to this session.
63abe53fde500f57944b09a7860e3515b966270cvboxsync RTLogSetDefaultInstanceThread(NULL, (uintptr_t)pSession);
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsync * Release object references made in this session.
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsync * In theory there should be noone racing us in this session.
63abe53fde500f57944b09a7860e3515b966270cvboxsync RTSPINLOCKTMP SpinlockTmp = RTSPINLOCKTMP_INITIALIZER;
5358508a9c364e20d5ae19ac1e95c9c2597fde1avboxsync RTSpinlockAcquire(pDevExt->Spinlock, &SpinlockTmp);
63abe53fde500f57944b09a7860e3515b966270cvboxsync AssertMsg(pUsage->cUsage >= 1 && pObj->cUsage >= pUsage->cUsage, ("glob %d; sess %d\n", pObj->cUsage, pUsage->cUsage));
5358508a9c364e20d5ae19ac1e95c9c2597fde1avboxsync RTSpinlockRelease(pDevExt->Spinlock, &SpinlockTmp);
63abe53fde500f57944b09a7860e3515b966270cvboxsync /* Destroy the object and free the record. */
5358508a9c364e20d5ae19ac1e95c9c2597fde1avboxsync for (pObjPrev = pDevExt->pObjs; pObjPrev; pObjPrev = pObjPrev->pNext)
63abe53fde500f57944b09a7860e3515b966270cvboxsync RTSpinlockRelease(pDevExt->Spinlock, &SpinlockTmp);
63abe53fde500f57944b09a7860e3515b966270cvboxsync Log(("supdrvCleanupSession: destroying %p/%d (%p/%p) cpid=%RTproc pid=%RTproc dtor=%p\n",
63abe53fde500f57944b09a7860e3515b966270cvboxsync pObj, pObj->enmType, pObj->pvUser1, pObj->pvUser2, pObj->CreatorProcess, RTProcSelf(), pObj->pfnDestructor));
63abe53fde500f57944b09a7860e3515b966270cvboxsync supdrvNtWrapObjDestructor((PFNRT)pObj->pfnDestructor, pObj, pObj->pvUser1, pObj->pvUser2);
63abe53fde500f57944b09a7860e3515b966270cvboxsync pObj->pfnDestructor(pObj, pObj->pvUser1, pObj->pvUser2);
63abe53fde500f57944b09a7860e3515b966270cvboxsync /* free it and continue. */
63abe53fde500f57944b09a7860e3515b966270cvboxsync RTSpinlockAcquire(pDevExt->Spinlock, &SpinlockTmp);
63abe53fde500f57944b09a7860e3515b966270cvboxsync RTSpinlockRelease(pDevExt->Spinlock, &SpinlockTmp);
63abe53fde500f57944b09a7860e3515b966270cvboxsync AssertMsg(!pSession->pUsage, ("Some buster reregistered an object during desturction!\n"));
a240f1229507269d3449217c9d483597e498d3bcvboxsync * Release memory allocated in the session.
a240f1229507269d3449217c9d483597e498d3bcvboxsync * We do not serialize this as we assume that the application will
a240f1229507269d3449217c9d483597e498d3bcvboxsync * not allocated memory while closing the file handle object.
63abe53fde500f57944b09a7860e3515b966270cvboxsync unsigned i;
63abe53fde500f57944b09a7860e3515b966270cvboxsync * Check and unlock all entries in the bundle.
63abe53fde500f57944b09a7860e3515b966270cvboxsync Log2(("eType=%d pvR0=%p pvR3=%p cb=%ld\n", pBundle->aMem[i].eType, RTR0MemObjAddress(pBundle->aMem[i].MemObj),
3ac37715f0e878da3b1737b45b89720dd768a31bvboxsync (void *)RTR0MemObjAddressR3(pBundle->aMem[i].MapObjR3), (long)RTR0MemObjSize(pBundle->aMem[i].MemObj)));
10cb8cb86f4b22e0e4aaed184c4ba3fc90907854vboxsync rc = RTR0MemObjFree(pBundle->aMem[i].MapObjR3, false);
3ac37715f0e878da3b1737b45b89720dd768a31bvboxsync AssertRC(rc); /** @todo figure out how to handle this. */
63abe53fde500f57944b09a7860e3515b966270cvboxsync rc = RTR0MemObjFree(pBundle->aMem[i].MemObj, true /* fFreeMappings */);
63abe53fde500f57944b09a7860e3515b966270cvboxsync AssertRC(rc); /** @todo figure out how to handle this. */
e05f27c2a433db4ad6e65a4daec7dc1fc7c05d6cvboxsync * Advance and free previous bundle.
63abe53fde500f57944b09a7860e3515b966270cvboxsync * Deregister component factories.
a240f1229507269d3449217c9d483597e498d3bcvboxsync RTSemFastMutexRequest(pDevExt->mtxComponentFactory);
5849847f8528d02e107c8639415ce97c75722f47vboxsync PSUPDRVFACTORYREG pCur = pDevExt->pComponentFactoryHead;
63abe53fde500f57944b09a7860e3515b966270cvboxsync /* unlink it */
5358508a9c364e20d5ae19ac1e95c9c2597fde1avboxsync /* free it */
3b8ffb6094762b1754b860e35f77070f91cdd3a5vboxsync RTSemFastMutexRelease(pDevExt->mtxComponentFactory);
3b8ffb6094762b1754b860e35f77070f91cdd3a5vboxsync Log2(("deregistering component factories - done\n"));
3b8ffb6094762b1754b860e35f77070f91cdd3a5vboxsync * Loaded images needs to be dereferenced and possibly freed up.
63abe53fde500f57944b09a7860e3515b966270cvboxsync * Unmap the GIP.
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync * Fast path I/O Control worker.
10cb8cb86f4b22e0e4aaed184c4ba3fc90907854vboxsync * @returns VBox status code that should be passed down to ring-3 unchanged.
10cb8cb86f4b22e0e4aaed184c4ba3fc90907854vboxsync * @param uIOCtl Function number.
10cb8cb86f4b22e0e4aaed184c4ba3fc90907854vboxsync * @param idCpu VMCPU id.
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync * @param pDevExt Device extention.
0a31ef301cd343725c4ee64edb7f5a5e2dc51432vboxsync * @param pSession Session data.
0a31ef301cd343725c4ee64edb7f5a5e2dc51432vboxsyncint VBOXCALL supdrvIOCtlFast(uintptr_t uIOCtl, unsigned idCpu, PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession)
10cb8cb86f4b22e0e4aaed184c4ba3fc90907854vboxsync * We check the two prereqs after doing this only to allow the compiler to optimize things better.
5ac3a2fbc96993f1cd3ecdabdcd79cc653a6410dvboxsync if (RT_LIKELY(pSession->pVM && pDevExt->pfnVMMR0EntryFast))
10cb8cb86f4b22e0e4aaed184c4ba3fc90907854vboxsync supdrvNtWrapVMMR0EntryFast((PFNRT)pDevExt->pfnVMMR0EntryFast, pSession->pVM, idCpu, SUP_VMMR0_DO_RAW_RUN);
10cb8cb86f4b22e0e4aaed184c4ba3fc90907854vboxsync pDevExt->pfnVMMR0EntryFast(pSession->pVM, idCpu, SUP_VMMR0_DO_RAW_RUN);
10cb8cb86f4b22e0e4aaed184c4ba3fc90907854vboxsync supdrvNtWrapVMMR0EntryFast((PFNRT)pDevExt->pfnVMMR0EntryFast, pSession->pVM, idCpu, SUP_VMMR0_DO_HWACC_RUN);
10cb8cb86f4b22e0e4aaed184c4ba3fc90907854vboxsync pDevExt->pfnVMMR0EntryFast(pSession->pVM, idCpu, SUP_VMMR0_DO_HWACC_RUN);
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsync supdrvNtWrapVMMR0EntryFast((PFNRT)pDevExt->pfnVMMR0EntryFast, pSession->pVM, idCpu, SUP_VMMR0_DO_NOP);
63abe53fde500f57944b09a7860e3515b966270cvboxsync pDevExt->pfnVMMR0EntryFast(pSession->pVM, idCpu, SUP_VMMR0_DO_NOP);
a240f1229507269d3449217c9d483597e498d3bcvboxsync * Helper for supdrvIOCtl. Check if pszStr contains any character of pszChars.
a240f1229507269d3449217c9d483597e498d3bcvboxsync * We would use strpbrk here if this function would be contained in the RedHat kABI white
a240f1229507269d3449217c9d483597e498d3bcvboxsync * @return 1 if pszStr does contain any character of pszChars, 0 otherwise.
a240f1229507269d3449217c9d483597e498d3bcvboxsync * @param pszStr String to check
299c0429f8b440592c7be4aeda01db7b8a35936evboxsync * @param pszChars Character set
299c0429f8b440592c7be4aeda01db7b8a35936evboxsyncstatic int supdrvCheckInvalidChar(const char *pszStr, const char *pszChars)
299c0429f8b440592c7be4aeda01db7b8a35936evboxsync * I/O Control worker.
299c0429f8b440592c7be4aeda01db7b8a35936evboxsync * @returns 0 on success.
299c0429f8b440592c7be4aeda01db7b8a35936evboxsync * @returns VERR_INVALID_PARAMETER if the request is invalid.
299c0429f8b440592c7be4aeda01db7b8a35936evboxsync * @param uIOCtl Function number.
299c0429f8b440592c7be4aeda01db7b8a35936evboxsync * @param pDevExt Device extention.
299c0429f8b440592c7be4aeda01db7b8a35936evboxsync * @param pSession Session data.
299c0429f8b440592c7be4aeda01db7b8a35936evboxsync * @param pReqHdr The request header.
5241b680af4032ae194feacc047f177ae01c4e90vboxsyncint VBOXCALL supdrvIOCtl(uintptr_t uIOCtl, PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPREQHDR pReqHdr)
5241b680af4032ae194feacc047f177ae01c4e90vboxsync * Validate the request.
5241b680af4032ae194feacc047f177ae01c4e90vboxsync /* this first check could probably be omitted as its also done by the OS specific code... */
5241b680af4032ae194feacc047f177ae01c4e90vboxsync if (RT_UNLIKELY( (pReqHdr->fFlags & SUPREQHDR_FLAGS_MAGIC_MASK) != SUPREQHDR_FLAGS_MAGIC
5241b680af4032ae194feacc047f177ae01c4e90vboxsync OSDBGPRINT(("vboxdrv: Bad ioctl request header; cbIn=%#lx cbOut=%#lx fFlags=%#lx\n",
5241b680af4032ae194feacc047f177ae01c4e90vboxsync (long)pReqHdr->cbIn, (long)pReqHdr->cbOut, (long)pReqHdr->fFlags));
5241b680af4032ae194feacc047f177ae01c4e90vboxsync if (pReqHdr->u32Cookie != SUPCOOKIE_INITIAL_COOKIE)
5241b680af4032ae194feacc047f177ae01c4e90vboxsync OSDBGPRINT(("SUP_IOCTL_COOKIE: bad cookie %#lx\n", (long)pReqHdr->u32Cookie));
5241b680af4032ae194feacc047f177ae01c4e90vboxsync else if (RT_UNLIKELY( pReqHdr->u32Cookie != pDevExt->u32Cookie
5241b680af4032ae194feacc047f177ae01c4e90vboxsync || pReqHdr->u32SessionCookie != pSession->u32Cookie))
5241b680af4032ae194feacc047f177ae01c4e90vboxsync OSDBGPRINT(("vboxdrv: bad cookie %#lx / %#lx.\n", (long)pReqHdr->u32Cookie, (long)pReqHdr->u32SessionCookie));
5241b680af4032ae194feacc047f177ae01c4e90vboxsync * Validation macros
5241b680af4032ae194feacc047f177ae01c4e90vboxsync#define REQ_CHECK_SIZES_EX(Name, cbInExpect, cbOutExpect) \
5241b680af4032ae194feacc047f177ae01c4e90vboxsync if (RT_UNLIKELY(pReqHdr->cbIn != (cbInExpect) || pReqHdr->cbOut != (cbOutExpect))) \
5241b680af4032ae194feacc047f177ae01c4e90vboxsync OSDBGPRINT(( #Name ": Invalid input/output sizes. cbIn=%ld expected %ld. cbOut=%ld expected %ld.\n", \
5241b680af4032ae194feacc047f177ae01c4e90vboxsync (long)pReq->Hdr.cbIn, (long)(cbInExpect), (long)pReq->Hdr.cbOut, (long)(cbOutExpect))); \
5241b680af4032ae194feacc047f177ae01c4e90vboxsync } while (0)
5241b680af4032ae194feacc047f177ae01c4e90vboxsync#define REQ_CHECK_SIZES(Name) REQ_CHECK_SIZES_EX(Name, Name ## _SIZE_IN, Name ## _SIZE_OUT)
5241b680af4032ae194feacc047f177ae01c4e90vboxsync OSDBGPRINT(( #Name ": Invalid input/output sizes. cbIn=%ld expected %ld.\n", \
5241b680af4032ae194feacc047f177ae01c4e90vboxsync } while (0)
5241b680af4032ae194feacc047f177ae01c4e90vboxsync if (RT_UNLIKELY(pReqHdr->cbOut != (cbOutExpect))) \
5241b680af4032ae194feacc047f177ae01c4e90vboxsync OSDBGPRINT(( #Name ": Invalid input/output sizes. cbOut=%ld expected %ld.\n", \
5241b680af4032ae194feacc047f177ae01c4e90vboxsync } while (0)
5241b680af4032ae194feacc047f177ae01c4e90vboxsync } while (0)
5241b680af4032ae194feacc047f177ae01c4e90vboxsync } while (0)
dd29fe9569ba44e02e6458aea15837615005c87cvboxsync * The switch.
299c0429f8b440592c7be4aeda01db7b8a35936evboxsync if (strncmp(pReq->u.In.szMagic, SUPCOOKIE_MAGIC, sizeof(pReq->u.In.szMagic)))
5241b680af4032ae194feacc047f177ae01c4e90vboxsync OSDBGPRINT(("SUP_IOCTL_COOKIE: invalid magic %.16s\n", pReq->u.In.szMagic));
299c0429f8b440592c7be4aeda01db7b8a35936evboxsync * Call out to the OS specific code and let it do permission checks on the
5241b680af4032ae194feacc047f177ae01c4e90vboxsync * client process.
4a86421b8276e3794fee4f1fde73bf3721a6e964vboxsync if (!supdrvOSValidateClientProcess(pDevExt, pSession))
299c0429f8b440592c7be4aeda01db7b8a35936evboxsync * Match the version.
dd29fe9569ba44e02e6458aea15837615005c87cvboxsync * The current logic is very simple, match the major interface version.
5241b680af4032ae194feacc047f177ae01c4e90vboxsync || (pReq->u.In.u32MinVersion & 0xffff0000) != (SUPDRV_IOC_VERSION & 0xffff0000))
dd29fe9569ba44e02e6458aea15837615005c87cvboxsync OSDBGPRINT(("SUP_IOCTL_COOKIE: Version mismatch. Requested: %#x Min: %#x Current: %#x\n",
5241b680af4032ae194feacc047f177ae01c4e90vboxsync pReq->u.In.u32ReqVersion, pReq->u.In.u32MinVersion, SUPDRV_IOC_VERSION));
202cf39359cf7baae7442c23a9dc8b6549964b38vboxsync * Fill in return data and be gone.
dd17ef4b1d8719c9da95a9b05f5e0a0daa8c3cdbvboxsync * N.B. The first one to change SUPDRV_IOC_VERSION shall makes sure that
b1be5bf5ba98f0818e29935222b4e8bbd15abe17vboxsync * u32SessionVersion <= u32ReqVersion!
b1be5bf5ba98f0818e29935222b4e8bbd15abe17vboxsync /** @todo Somehow validate the client and negotiate a secure cookie... */
202cf39359cf7baae7442c23a9dc8b6549964b38vboxsync pReq->u.Out.u32SessionCookie = pSession->u32Cookie;
202cf39359cf7baae7442c23a9dc8b6549964b38vboxsync pReq->u.Out.u32SessionVersion = SUPDRV_IOC_VERSION;
dd17ef4b1d8719c9da95a9b05f5e0a0daa8c3cdbvboxsync pReq->u.Out.cFunctions = sizeof(g_aFunctions) / sizeof(g_aFunctions[0]);
dd17ef4b1d8719c9da95a9b05f5e0a0daa8c3cdbvboxsync case SUP_CTL_CODE_NO_SIZE(SUP_IOCTL_QUERY_FUNCS(0)):
dd17ef4b1d8719c9da95a9b05f5e0a0daa8c3cdbvboxsync /* validate */
dd17ef4b1d8719c9da95a9b05f5e0a0daa8c3cdbvboxsync REQ_CHECK_SIZES_EX(SUP_IOCTL_QUERY_FUNCS, SUP_IOCTL_QUERY_FUNCS_SIZE_IN, SUP_IOCTL_QUERY_FUNCS_SIZE_OUT(RT_ELEMENTS(g_aFunctions)));
dd17ef4b1d8719c9da95a9b05f5e0a0daa8c3cdbvboxsync /* execute */
dd29fe9569ba44e02e6458aea15837615005c87cvboxsync pReq->u.Out.cFunctions = RT_ELEMENTS(g_aFunctions);
dd29fe9569ba44e02e6458aea15837615005c87cvboxsync memcpy(&pReq->u.Out.aFunctions[0], g_aFunctions, sizeof(g_aFunctions));
dd29fe9569ba44e02e6458aea15837615005c87cvboxsync /* validate */
dd17ef4b1d8719c9da95a9b05f5e0a0daa8c3cdbvboxsync /* execute */
dd17ef4b1d8719c9da95a9b05f5e0a0daa8c3cdbvboxsync /* validate */
dd17ef4b1d8719c9da95a9b05f5e0a0daa8c3cdbvboxsync /* execute */
202cf39359cf7baae7442c23a9dc8b6549964b38vboxsync /* validate */
b1be5bf5ba98f0818e29935222b4e8bbd15abe17vboxsync REQ_CHECK_SIZE_IN(SUP_IOCTL_PAGE_LOCK, SUP_IOCTL_PAGE_LOCK_SIZE_IN);
202cf39359cf7baae7442c23a9dc8b6549964b38vboxsync REQ_CHECK_SIZE_OUT(SUP_IOCTL_PAGE_LOCK, SUP_IOCTL_PAGE_LOCK_SIZE_OUT(pReq->u.In.cPages));
202cf39359cf7baae7442c23a9dc8b6549964b38vboxsync REQ_CHECK_EXPR(SUP_IOCTL_PAGE_LOCK, pReq->u.In.cPages > 0);
202cf39359cf7baae7442c23a9dc8b6549964b38vboxsync REQ_CHECK_EXPR(SUP_IOCTL_PAGE_LOCK, pReq->u.In.pvR3 >= PAGE_SIZE);
202cf39359cf7baae7442c23a9dc8b6549964b38vboxsync /* execute */
202cf39359cf7baae7442c23a9dc8b6549964b38vboxsync pReq->Hdr.rc = SUPR0LockMem(pSession, pReq->u.In.pvR3, pReq->u.In.cPages, &pReq->u.Out.aPages[0]);
4a86421b8276e3794fee4f1fde73bf3721a6e964vboxsync /* validate */
dd17ef4b1d8719c9da95a9b05f5e0a0daa8c3cdbvboxsync /* execute */
dd17ef4b1d8719c9da95a9b05f5e0a0daa8c3cdbvboxsync pReq->Hdr.rc = SUPR0UnlockMem(pSession, pReq->u.In.pvR3);
b1be5bf5ba98f0818e29935222b4e8bbd15abe17vboxsync /* validate */
b1be5bf5ba98f0818e29935222b4e8bbd15abe17vboxsync /* execute */
b1be5bf5ba98f0818e29935222b4e8bbd15abe17vboxsync pReq->Hdr.rc = SUPR0ContAlloc(pSession, pReq->u.In.cPages, &pReq->u.Out.pvR0, &pReq->u.Out.pvR3, &pReq->u.Out.HCPhys);
dd17ef4b1d8719c9da95a9b05f5e0a0daa8c3cdbvboxsync /* validate */
dd17ef4b1d8719c9da95a9b05f5e0a0daa8c3cdbvboxsync /* execute */
dd17ef4b1d8719c9da95a9b05f5e0a0daa8c3cdbvboxsync pReq->Hdr.rc = SUPR0ContFree(pSession, (RTHCUINTPTR)pReq->u.In.pvR3);
dd17ef4b1d8719c9da95a9b05f5e0a0daa8c3cdbvboxsync /* validate */
202cf39359cf7baae7442c23a9dc8b6549964b38vboxsync REQ_CHECK_EXPR(SUP_IOCTL_LDR_OPEN, pReq->u.In.cbImage > 0);
202cf39359cf7baae7442c23a9dc8b6549964b38vboxsync REQ_CHECK_EXPR(SUP_IOCTL_LDR_OPEN, pReq->u.In.cbImage < _1M*16);
202cf39359cf7baae7442c23a9dc8b6549964b38vboxsync REQ_CHECK_EXPR(SUP_IOCTL_LDR_OPEN, pReq->u.In.szName[0]);
202cf39359cf7baae7442c23a9dc8b6549964b38vboxsync REQ_CHECK_EXPR(SUP_IOCTL_LDR_OPEN, memchr(pReq->u.In.szName, '\0', sizeof(pReq->u.In.szName)));
202cf39359cf7baae7442c23a9dc8b6549964b38vboxsync REQ_CHECK_EXPR(SUP_IOCTL_LDR_OPEN, !supdrvCheckInvalidChar(pReq->u.In.szName, ";:()[]{}/\\|&*%#@!~`\"'"));
202cf39359cf7baae7442c23a9dc8b6549964b38vboxsync /* execute */
202cf39359cf7baae7442c23a9dc8b6549964b38vboxsync pReq->Hdr.rc = supdrvIOCtl_LdrOpen(pDevExt, pSession, pReq);
202cf39359cf7baae7442c23a9dc8b6549964b38vboxsync /* validate */
202cf39359cf7baae7442c23a9dc8b6549964b38vboxsync REQ_CHECK_EXPR(Name, pReq->Hdr.cbIn >= sizeof(*pReq));
b1be5bf5ba98f0818e29935222b4e8bbd15abe17vboxsync REQ_CHECK_SIZES_EX(SUP_IOCTL_LDR_LOAD, SUP_IOCTL_LDR_LOAD_SIZE_IN(pReq->u.In.cbImage), SUP_IOCTL_LDR_LOAD_SIZE_OUT);
b1be5bf5ba98f0818e29935222b4e8bbd15abe17vboxsync REQ_CHECK_EXPR(SUP_IOCTL_LDR_LOAD, pReq->u.In.cSymbols <= 16384);
dd17ef4b1d8719c9da95a9b05f5e0a0daa8c3cdbvboxsync && pReq->u.In.offSymbols + pReq->u.In.cSymbols * sizeof(SUPLDRSYM) <= pReq->u.In.cbImage),
dd17ef4b1d8719c9da95a9b05f5e0a0daa8c3cdbvboxsync ("SUP_IOCTL_LDR_LOAD: offSymbols=%#lx cSymbols=%#lx cbImage=%#lx\n", (long)pReq->u.In.offSymbols,
dd17ef4b1d8719c9da95a9b05f5e0a0daa8c3cdbvboxsync (long)pReq->u.In.cSymbols, (long)pReq->u.In.cbImage));
dd17ef4b1d8719c9da95a9b05f5e0a0daa8c3cdbvboxsync && pReq->u.In.offStrTab + pReq->u.In.cbStrTab <= pReq->u.In.cbImage
dd17ef4b1d8719c9da95a9b05f5e0a0daa8c3cdbvboxsync ("SUP_IOCTL_LDR_LOAD: offStrTab=%#lx cbStrTab=%#lx cbImage=%#lx\n", (long)pReq->u.In.offStrTab,
dd17ef4b1d8719c9da95a9b05f5e0a0daa8c3cdbvboxsync (long)pReq->u.In.cbStrTab, (long)pReq->u.In.cbImage));
b1be5bf5ba98f0818e29935222b4e8bbd15abe17vboxsync PSUPLDRSYM paSyms = (PSUPLDRSYM)&pReq->u.In.achImage[pReq->u.In.offSymbols];
b1be5bf5ba98f0818e29935222b4e8bbd15abe17vboxsync REQ_CHECK_EXPR_FMT(paSyms[i].offSymbol < pReq->u.In.cbImage,
dd17ef4b1d8719c9da95a9b05f5e0a0daa8c3cdbvboxsync ("SUP_IOCTL_LDR_LOAD: sym #%ld: symb off %#lx (max=%#lx)\n", (long)i, (long)paSyms[i].offSymbol, (long)pReq->u.In.cbImage));
dd17ef4b1d8719c9da95a9b05f5e0a0daa8c3cdbvboxsync REQ_CHECK_EXPR_FMT(paSyms[i].offName < pReq->u.In.cbStrTab,
202cf39359cf7baae7442c23a9dc8b6549964b38vboxsync ("SUP_IOCTL_LDR_LOAD: sym #%ld: name off %#lx (max=%#lx)\n", (long)i, (long)paSyms[i].offName, (long)pReq->u.In.cbImage));
202cf39359cf7baae7442c23a9dc8b6549964b38vboxsync REQ_CHECK_EXPR_FMT(memchr(&pReq->u.In.achImage[pReq->u.In.offStrTab + paSyms[i].offName], '\0', pReq->u.In.cbStrTab - paSyms[i].offName),
202cf39359cf7baae7442c23a9dc8b6549964b38vboxsync ("SUP_IOCTL_LDR_LOAD: sym #%ld: unterminated name! (%#lx / %#lx)\n", (long)i, (long)paSyms[i].offName, (long)pReq->u.In.cbImage));
dd17ef4b1d8719c9da95a9b05f5e0a0daa8c3cdbvboxsync /* execute */
b1be5bf5ba98f0818e29935222b4e8bbd15abe17vboxsync pReq->Hdr.rc = supdrvIOCtl_LdrLoad(pDevExt, pSession, pReq);
b1be5bf5ba98f0818e29935222b4e8bbd15abe17vboxsync /* validate */
e734a8323642a985bf371d969c977d6f67fad134vboxsync /* execute */
35d76c6a04e6c62e314710054cbbbb3fb6a086ccvboxsync pReq->Hdr.rc = supdrvIOCtl_LdrFree(pDevExt, pSession, pReq);
35d76c6a04e6c62e314710054cbbbb3fb6a086ccvboxsync case SUP_CTL_CODE_NO_SIZE(SUP_IOCTL_LDR_GET_SYMBOL):
b1be5bf5ba98f0818e29935222b4e8bbd15abe17vboxsync /* validate */
b1be5bf5ba98f0818e29935222b4e8bbd15abe17vboxsync REQ_CHECK_EXPR(SUP_IOCTL_LDR_GET_SYMBOL, memchr(pReq->u.In.szSymbol, '\0', sizeof(pReq->u.In.szSymbol)));
dd17ef4b1d8719c9da95a9b05f5e0a0daa8c3cdbvboxsync /* execute */
dd17ef4b1d8719c9da95a9b05f5e0a0daa8c3cdbvboxsync pReq->Hdr.rc = supdrvIOCtl_LdrGetSymbol(pDevExt, pSession, pReq);
b1be5bf5ba98f0818e29935222b4e8bbd15abe17vboxsync case SUP_CTL_CODE_NO_SIZE(SUP_IOCTL_CALL_VMMR0(0)):
202cf39359cf7baae7442c23a9dc8b6549964b38vboxsync /* validate */
b1be5bf5ba98f0818e29935222b4e8bbd15abe17vboxsync Log4(("SUP_IOCTL_CALL_VMMR0: op=%u in=%u arg=%RX64 p/t=%RTproc/%RTthrd\n",
b1be5bf5ba98f0818e29935222b4e8bbd15abe17vboxsync pReq->u.In.uOperation, pReq->Hdr.cbIn, pReq->u.In.u64Arg, RTProcSelf(), RTThreadNativeSelf()));
b1be5bf5ba98f0818e29935222b4e8bbd15abe17vboxsync if (pReq->Hdr.cbIn == SUP_IOCTL_CALL_VMMR0_SIZE(0))
b1be5bf5ba98f0818e29935222b4e8bbd15abe17vboxsync REQ_CHECK_SIZES_EX(SUP_IOCTL_CALL_VMMR0, SUP_IOCTL_CALL_VMMR0_SIZE_IN(0), SUP_IOCTL_CALL_VMMR0_SIZE_OUT(0));
b1be5bf5ba98f0818e29935222b4e8bbd15abe17vboxsync /* execute */
b1be5bf5ba98f0818e29935222b4e8bbd15abe17vboxsync pReq->Hdr.rc = supdrvNtWrapVMMR0EntryEx((PFNRT)pDevExt->pfnVMMR0EntryEx, pReq->u.In.pVMR0, pReq->u.In.uOperation, NULL, pReq->u.In.u64Arg, pSession);
b1be5bf5ba98f0818e29935222b4e8bbd15abe17vboxsync pReq->Hdr.rc = pDevExt->pfnVMMR0EntryEx(pReq->u.In.pVMR0, pReq->u.In.uOperation, NULL, pReq->u.In.u64Arg, pSession);
b1be5bf5ba98f0818e29935222b4e8bbd15abe17vboxsync PSUPVMMR0REQHDR pVMMReq = (PSUPVMMR0REQHDR)&pReq->abReqPkt[0];
b1be5bf5ba98f0818e29935222b4e8bbd15abe17vboxsync REQ_CHECK_EXPR_FMT(pReq->Hdr.cbIn >= SUP_IOCTL_CALL_VMMR0_SIZE(sizeof(SUPVMMR0REQHDR)),
b1be5bf5ba98f0818e29935222b4e8bbd15abe17vboxsync ("SUP_IOCTL_CALL_VMMR0: cbIn=%#x < %#lx\n", pReq->Hdr.cbIn, SUP_IOCTL_CALL_VMMR0_SIZE(sizeof(SUPVMMR0REQHDR))));
b1be5bf5ba98f0818e29935222b4e8bbd15abe17vboxsync REQ_CHECK_EXPR(SUP_IOCTL_CALL_VMMR0, pVMMReq->u32Magic == SUPVMMR0REQHDR_MAGIC);
b1be5bf5ba98f0818e29935222b4e8bbd15abe17vboxsync REQ_CHECK_SIZES_EX(SUP_IOCTL_CALL_VMMR0, SUP_IOCTL_CALL_VMMR0_SIZE_IN(pVMMReq->cbReq), SUP_IOCTL_CALL_VMMR0_SIZE_OUT(pVMMReq->cbReq));
b1be5bf5ba98f0818e29935222b4e8bbd15abe17vboxsync /* execute */
b1be5bf5ba98f0818e29935222b4e8bbd15abe17vboxsync pReq->Hdr.rc = supdrvNtWrapVMMR0EntryEx((PFNRT)pDevExt->pfnVMMR0EntryEx, pReq->u.In.pVMR0, pReq->u.In.uOperation, pVMMReq, pReq->u.In.u64Arg, pSession);
b1be5bf5ba98f0818e29935222b4e8bbd15abe17vboxsync pReq->Hdr.rc = pDevExt->pfnVMMR0EntryEx(pReq->u.In.pVMR0, pReq->u.In.uOperation, pVMMReq, pReq->u.In.u64Arg, pSession);
b1be5bf5ba98f0818e29935222b4e8bbd15abe17vboxsync Log(("SUP_IOCTL_CALL_VMMR0: rc=%Rrc op=%u out=%u arg=%RX64 p/t=%RTproc/%RTthrd\n",
b1be5bf5ba98f0818e29935222b4e8bbd15abe17vboxsync pReq->Hdr.rc, pReq->u.In.uOperation, pReq->Hdr.cbOut, pReq->u.In.u64Arg, RTProcSelf(), RTThreadNativeSelf()));
b1be5bf5ba98f0818e29935222b4e8bbd15abe17vboxsync Log4(("SUP_IOCTL_CALL_VMMR0: rc=%Rrc op=%u out=%u arg=%RX64 p/t=%RTproc/%RTthrd\n",
b1be5bf5ba98f0818e29935222b4e8bbd15abe17vboxsync pReq->Hdr.rc, pReq->u.In.uOperation, pReq->Hdr.cbOut, pReq->u.In.u64Arg, RTProcSelf(), RTThreadNativeSelf()));
b1be5bf5ba98f0818e29935222b4e8bbd15abe17vboxsync case SUP_CTL_CODE_NO_SIZE(SUP_IOCTL_GET_PAGING_MODE):
b1be5bf5ba98f0818e29935222b4e8bbd15abe17vboxsync /* validate */
b1be5bf5ba98f0818e29935222b4e8bbd15abe17vboxsync PSUPGETPAGINGMODE pReq = (PSUPGETPAGINGMODE)pReqHdr;
dd17ef4b1d8719c9da95a9b05f5e0a0daa8c3cdbvboxsync /* execute */
a240f1229507269d3449217c9d483597e498d3bcvboxsync /* validate */
a240f1229507269d3449217c9d483597e498d3bcvboxsync REQ_CHECK_EXPR(SUP_IOCTL_LOW_ALLOC, pReq->Hdr.cbIn <= SUP_IOCTL_LOW_ALLOC_SIZE_IN);
a240f1229507269d3449217c9d483597e498d3bcvboxsync REQ_CHECK_SIZES_EX(SUP_IOCTL_LOW_ALLOC, SUP_IOCTL_LOW_ALLOC_SIZE_IN, SUP_IOCTL_LOW_ALLOC_SIZE_OUT(pReq->u.In.cPages));
a240f1229507269d3449217c9d483597e498d3bcvboxsync /* execute */
a240f1229507269d3449217c9d483597e498d3bcvboxsync pReq->Hdr.rc = SUPR0LowAlloc(pSession, pReq->u.In.cPages, &pReq->u.Out.pvR0, &pReq->u.Out.pvR3, &pReq->u.Out.aPages[0]);
2aa583580ca6f01fcfc8764b9030b3d8e6d3a53dvboxsync /* validate */
63abe53fde500f57944b09a7860e3515b966270cvboxsync /* execute */
63abe53fde500f57944b09a7860e3515b966270cvboxsync pReq->Hdr.rc = SUPR0LowFree(pSession, (RTHCUINTPTR)pReq->u.In.pvR3);
63abe53fde500f57944b09a7860e3515b966270cvboxsync /* validate */
e05f27c2a433db4ad6e65a4daec7dc1fc7c05d6cvboxsync /* execute */
e05f27c2a433db4ad6e65a4daec7dc1fc7c05d6cvboxsync pReq->Hdr.rc = SUPR0GipMap(pSession, &pReq->u.Out.pGipR3, &pReq->u.Out.HCPhysGip);
e05f27c2a433db4ad6e65a4daec7dc1fc7c05d6cvboxsync /* validate */
63abe53fde500f57944b09a7860e3515b966270cvboxsync /* execute */
63abe53fde500f57944b09a7860e3515b966270cvboxsync case SUP_CTL_CODE_NO_SIZE(SUP_IOCTL_SET_VM_FOR_FAST):
bf02d66a125c596179dac9ccbe6f4f5c87e0e275vboxsync /* validate */
63abe53fde500f57944b09a7860e3515b966270cvboxsync && !((uintptr_t)pReq->u.In.pVMR0 & (PAGE_SIZE - 1))),
63abe53fde500f57944b09a7860e3515b966270cvboxsync ("SUP_IOCTL_SET_VM_FOR_FAST: pVMR0=%p!\n", pReq->u.In.pVMR0));
63abe53fde500f57944b09a7860e3515b966270cvboxsync /* execute */
e05f27c2a433db4ad6e65a4daec7dc1fc7c05d6cvboxsync /* validate */
63abe53fde500f57944b09a7860e3515b966270cvboxsync REQ_CHECK_EXPR(SUP_IOCTL_PAGE_ALLOC, pReq->Hdr.cbIn <= SUP_IOCTL_PAGE_ALLOC_SIZE_IN);
63abe53fde500f57944b09a7860e3515b966270cvboxsync REQ_CHECK_SIZES_EX(SUP_IOCTL_PAGE_ALLOC, SUP_IOCTL_PAGE_ALLOC_SIZE_IN, SUP_IOCTL_PAGE_ALLOC_SIZE_OUT(pReq->u.In.cPages));
63abe53fde500f57944b09a7860e3515b966270cvboxsync /* execute */
e05f27c2a433db4ad6e65a4daec7dc1fc7c05d6cvboxsync pReq->Hdr.rc = SUPR0PageAlloc(pSession, pReq->u.In.cPages, &pReq->u.Out.pvR3, &pReq->u.Out.aPages[0]);
e05f27c2a433db4ad6e65a4daec7dc1fc7c05d6cvboxsync case SUP_CTL_CODE_NO_SIZE(SUP_IOCTL_PAGE_ALLOC_EX):
939e2ecb812c6402abcc63e7d615c5444acfd02evboxsync /* validate */
e05f27c2a433db4ad6e65a4daec7dc1fc7c05d6cvboxsync REQ_CHECK_EXPR(SUP_IOCTL_PAGE_ALLOC_EX, pReq->Hdr.cbIn <= SUP_IOCTL_PAGE_ALLOC_EX_SIZE_IN);
e05f27c2a433db4ad6e65a4daec7dc1fc7c05d6cvboxsync 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));
e05f27c2a433db4ad6e65a4daec7dc1fc7c05d6cvboxsync REQ_CHECK_EXPR_FMT(pReq->u.In.fKernelMapping || pReq->u.In.fUserMapping,
10cb8cb86f4b22e0e4aaed184c4ba3fc90907854vboxsync ("SUP_IOCTL_PAGE_ALLOC_EX: No mapping requested!\n"));
e05f27c2a433db4ad6e65a4daec7dc1fc7c05d6cvboxsync ("SUP_IOCTL_PAGE_ALLOC_EX: Must have user mapping!\n"));
63abe53fde500f57944b09a7860e3515b966270cvboxsync REQ_CHECK_EXPR_FMT(!pReq->u.In.fReserved0 && !pReq->u.In.fReserved1,
63abe53fde500f57944b09a7860e3515b966270cvboxsync ("SUP_IOCTL_PAGE_ALLOC_EX: fReserved0=%d fReserved1=%d\n", pReq->u.In.fReserved0, pReq->u.In.fReserved1));
63abe53fde500f57944b09a7860e3515b966270cvboxsync /* execute */
63abe53fde500f57944b09a7860e3515b966270cvboxsync pReq->Hdr.rc = SUPR0PageAllocEx(pSession, pReq->u.In.cPages, 0 /* fFlags */,
e05f27c2a433db4ad6e65a4daec7dc1fc7c05d6cvboxsync pReq->u.In.fUserMapping ? &pReq->u.Out.pvR3 : NULL,
63abe53fde500f57944b09a7860e3515b966270cvboxsync pReq->u.In.fKernelMapping ? &pReq->u.Out.pvR0 : NULL,
513aeb62b50925ef51b8be944083cd2589ecf743vboxsync case SUP_CTL_CODE_NO_SIZE(SUP_IOCTL_PAGE_MAP_KERNEL):
a240f1229507269d3449217c9d483597e498d3bcvboxsync /* validate */
7c17a8c920f84a6da1b663bf0529900bf6557ddfvboxsync PSUPPAGEMAPKERNEL pReq = (PSUPPAGEMAPKERNEL)pReqHdr;
a240f1229507269d3449217c9d483597e498d3bcvboxsync REQ_CHECK_EXPR_FMT(!pReq->u.In.fFlags, ("SUP_IOCTL_PAGE_MAP_KERNEL: fFlags=%#x! MBZ\n", pReq->u.In.fFlags));
a240f1229507269d3449217c9d483597e498d3bcvboxsync REQ_CHECK_EXPR_FMT(!(pReq->u.In.offSub & PAGE_OFFSET_MASK), ("SUP_IOCTL_PAGE_MAP_KERNEL: offSub=%#x\n", pReq->u.In.offSub));
a240f1229507269d3449217c9d483597e498d3bcvboxsync REQ_CHECK_EXPR_FMT(pReq->u.In.cbSub && !(pReq->u.In.cbSub & PAGE_OFFSET_MASK),
a240f1229507269d3449217c9d483597e498d3bcvboxsync ("SUP_IOCTL_PAGE_MAP_KERNEL: cbSub=%#x\n", pReq->u.In.cbSub));
a240f1229507269d3449217c9d483597e498d3bcvboxsync /* execute */
a240f1229507269d3449217c9d483597e498d3bcvboxsync pReq->Hdr.rc = SUPR0PageMapKernel(pSession, pReq->u.In.pvR3, pReq->u.In.offSub, pReq->u.In.cbSub,
8259a8d9542c4211c5e216850c10c620ab7cd411vboxsync /* validate */
63abe53fde500f57944b09a7860e3515b966270cvboxsync /* execute */
10cb8cb86f4b22e0e4aaed184c4ba3fc90907854vboxsync pReq->Hdr.rc = SUPR0PageFree(pSession, pReq->u.In.pvR3);
10cb8cb86f4b22e0e4aaed184c4ba3fc90907854vboxsync case SUP_CTL_CODE_NO_SIZE(SUP_IOCTL_CALL_SERVICE(0)):
63abe53fde500f57944b09a7860e3515b966270cvboxsync /* validate */
63abe53fde500f57944b09a7860e3515b966270cvboxsync Log4(("SUP_IOCTL_CALL_SERVICE: op=%u in=%u arg=%RX64 p/t=%RTproc/%RTthrd\n",
63abe53fde500f57944b09a7860e3515b966270cvboxsync pReq->u.In.uOperation, pReq->Hdr.cbIn, pReq->u.In.u64Arg, RTProcSelf(), RTThreadNativeSelf()));
63abe53fde500f57944b09a7860e3515b966270cvboxsync if (pReq->Hdr.cbIn == SUP_IOCTL_CALL_SERVICE_SIZE(0))
3b8ffb6094762b1754b860e35f77070f91cdd3a5vboxsync REQ_CHECK_SIZES_EX(SUP_IOCTL_CALL_SERVICE, SUP_IOCTL_CALL_SERVICE_SIZE_IN(0), SUP_IOCTL_CALL_SERVICE_SIZE_OUT(0));
63abe53fde500f57944b09a7860e3515b966270cvboxsync PSUPR0SERVICEREQHDR pSrvReq = (PSUPR0SERVICEREQHDR)&pReq->abReqPkt[0];
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsync REQ_CHECK_EXPR_FMT(pReq->Hdr.cbIn >= SUP_IOCTL_CALL_SERVICE_SIZE(sizeof(SUPR0SERVICEREQHDR)),
63abe53fde500f57944b09a7860e3515b966270cvboxsync ("SUP_IOCTL_CALL_SERVICE: cbIn=%#x < %#lx\n", pReq->Hdr.cbIn, SUP_IOCTL_CALL_SERVICE_SIZE(sizeof(SUPR0SERVICEREQHDR))));
63abe53fde500f57944b09a7860e3515b966270cvboxsync REQ_CHECK_EXPR(SUP_IOCTL_CALL_SERVICE, pSrvReq->u32Magic == SUPR0SERVICEREQHDR_MAGIC);
e961f5bfe1727c6816d3dad3805ebe21b6ba1c64vboxsync REQ_CHECK_SIZES_EX(SUP_IOCTL_CALL_SERVICE, SUP_IOCTL_CALL_SERVICE_SIZE_IN(pSrvReq->cbReq), SUP_IOCTL_CALL_SERVICE_SIZE_OUT(pSrvReq->cbReq));
63abe53fde500f57944b09a7860e3515b966270cvboxsync REQ_CHECK_EXPR(SUP_IOCTL_CALL_SERVICE, memchr(pReq->u.In.szName, '\0', sizeof(pReq->u.In.szName)));
462e60a19d02a99b2b1a5c08dff74bb0808d707cvboxsync /* execute */
63abe53fde500f57944b09a7860e3515b966270cvboxsync pReq->Hdr.rc = supdrvIOCtl_CallServiceModule(pDevExt, pSession, pReq);
63abe53fde500f57944b09a7860e3515b966270cvboxsync case SUP_CTL_CODE_NO_SIZE(SUP_IOCTL_LOGGER_SETTINGS(0)):
e05f27c2a433db4ad6e65a4daec7dc1fc7c05d6cvboxsync /* validate */
63abe53fde500f57944b09a7860e3515b966270cvboxsync PSUPLOGGERSETTINGS pReq = (PSUPLOGGERSETTINGS)pReqHdr;
63abe53fde500f57944b09a7860e3515b966270cvboxsync REQ_CHECK_SIZE_OUT(SUP_IOCTL_LOGGER_SETTINGS, SUP_IOCTL_LOGGER_SETTINGS_SIZE_OUT);
3ac37715f0e878da3b1737b45b89720dd768a31bvboxsync REQ_CHECK_EXPR(SUP_IOCTL_LOGGER_SETTINGS, pReq->Hdr.cbIn >= SUP_IOCTL_LOGGER_SETTINGS_SIZE_IN(1));
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsync cbStrTab = pReq->Hdr.cbIn - SUP_IOCTL_LOGGER_SETTINGS_SIZE_IN(0);
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsync REQ_CHECK_EXPR(SUP_IOCTL_LOGGER_SETTINGS, pReq->u.In.offGroups < cbStrTab);
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsync REQ_CHECK_EXPR(SUP_IOCTL_LOGGER_SETTINGS, pReq->u.In.offFlags < cbStrTab);
e05f27c2a433db4ad6e65a4daec7dc1fc7c05d6cvboxsync REQ_CHECK_EXPR(SUP_IOCTL_LOGGER_SETTINGS, pReq->u.In.offDestination < cbStrTab);
63abe53fde500f57944b09a7860e3515b966270cvboxsync REQ_CHECK_EXPR_FMT(pReq->u.In.szStrings[cbStrTab - 1] == '\0',
63abe53fde500f57944b09a7860e3515b966270cvboxsync ("SUP_IOCTL_LOGGER_SETTINGS: cbIn=%#x cbStrTab=%#zx LastChar=%d\n",
63abe53fde500f57944b09a7860e3515b966270cvboxsync pReq->Hdr.cbIn, cbStrTab, pReq->u.In.szStrings[cbStrTab - 1]));
e05f27c2a433db4ad6e65a4daec7dc1fc7c05d6cvboxsync REQ_CHECK_EXPR(SUP_IOCTL_LOGGER_SETTINGS, pReq->u.In.fWhich <= SUPLOGGERSETTINGS_WHICH_RELEASE);
a240f1229507269d3449217c9d483597e498d3bcvboxsync REQ_CHECK_EXPR(SUP_IOCTL_LOGGER_SETTINGS, pReq->u.In.fWhat <= SUPLOGGERSETTINGS_WHAT_DESTROY);
e05f27c2a433db4ad6e65a4daec7dc1fc7c05d6cvboxsync /* execute */
e05f27c2a433db4ad6e65a4daec7dc1fc7c05d6cvboxsync pReq->Hdr.rc = supdrvIOCtl_LoggerSettings(pDevExt, pSession, pReq);
63abe53fde500f57944b09a7860e3515b966270cvboxsync * Inter-Driver Communcation (IDC) worker.
63abe53fde500f57944b09a7860e3515b966270cvboxsync * @returns VBox status code.
63abe53fde500f57944b09a7860e3515b966270cvboxsync * @retval VINF_SUCCESS on success.
63abe53fde500f57944b09a7860e3515b966270cvboxsync * @retval VERR_INVALID_PARAMETER if the request is invalid.
63abe53fde500f57944b09a7860e3515b966270cvboxsync * @retval VERR_NOT_SUPPORTED if the request isn't supported.
63abe53fde500f57944b09a7860e3515b966270cvboxsync * @param uReq The request (function) code.
63abe53fde500f57944b09a7860e3515b966270cvboxsync * @param pDevExt Device extention.
63abe53fde500f57944b09a7860e3515b966270cvboxsync * @param pSession Session data.
63abe53fde500f57944b09a7860e3515b966270cvboxsync * @param pReqHdr The request header.
a419e5c3ed740caf9a6db66cf72137a9426d5d59vboxsyncint VBOXCALL supdrvIDC(uintptr_t uReq, PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPDRVIDCREQHDR pReqHdr)
a419e5c3ed740caf9a6db66cf72137a9426d5d59vboxsync * The OS specific code has already validated the pSession
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsync * pointer, and the request size being greater or equal to
a419e5c3ed740caf9a6db66cf72137a9426d5d59vboxsync * size of the header.
63abe53fde500f57944b09a7860e3515b966270cvboxsync * So, just check that pSession is a kernel context session.
63abe53fde500f57944b09a7860e3515b966270cvboxsync * Validation macro.
63abe53fde500f57944b09a7860e3515b966270cvboxsync OSDBGPRINT(( #Name ": Invalid input/output sizes. cb=%ld expected %ld.\n", \
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsync } while (0)
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsync PSUPDRVIDCREQCONNECT pReq = (PSUPDRVIDCREQCONNECT)pReqHdr;
63abe53fde500f57944b09a7860e3515b966270cvboxsync REQ_CHECK_IDC_SIZE(SUPDRV_IDC_REQ_CONNECT, sizeof(*pReq));
2571b76c8b0ea7c45d491602aba9984254fa7d66vboxsync * Validate the cookie and other input.
63abe53fde500f57944b09a7860e3515b966270cvboxsync OSDBGPRINT(("SUPDRV_IDC_REQ_CONNECT: pSession=%p expected NULL!\n", pReq->Hdr.pSession));
63abe53fde500f57944b09a7860e3515b966270cvboxsync if (pReq->u.In.u32MagicCookie != SUPDRVIDCREQ_CONNECT_MAGIC_COOKIE)
63abe53fde500f57944b09a7860e3515b966270cvboxsync OSDBGPRINT(("SUPDRV_IDC_REQ_CONNECT: u32MagicCookie=%#x expected %#x!\n",
63abe53fde500f57944b09a7860e3515b966270cvboxsync (unsigned)pReq->u.In.u32MagicCookie, (unsigned)SUPDRVIDCREQ_CONNECT_MAGIC_COOKIE));
8259a8d9542c4211c5e216850c10c620ab7cd411vboxsync if ( pReq->u.In.uMinVersion > pReq->u.In.uReqVersion
8259a8d9542c4211c5e216850c10c620ab7cd411vboxsync || (pReq->u.In.uMinVersion & UINT32_C(0xffff0000)) != (pReq->u.In.uReqVersion & UINT32_C(0xffff0000)))
513aeb62b50925ef51b8be944083cd2589ecf743vboxsync OSDBGPRINT(("SUPDRV_IDC_REQ_CONNECT: uMinVersion=%#x uMaxVersion=%#x doesn't match!\n",
e05f27c2a433db4ad6e65a4daec7dc1fc7c05d6cvboxsync * Match the version.
513aeb62b50925ef51b8be944083cd2589ecf743vboxsync * The current logic is very simple, match the major interface version.
3b8ffb6094762b1754b860e35f77070f91cdd3a5vboxsync || (pReq->u.In.uMinVersion & 0xffff0000) != (SUPDRV_IDC_VERSION & 0xffff0000))
3b8ffb6094762b1754b860e35f77070f91cdd3a5vboxsync OSDBGPRINT(("SUPDRV_IDC_REQ_CONNECT: Version mismatch. Requested: %#x Min: %#x Current: %#x\n",
3b8ffb6094762b1754b860e35f77070f91cdd3a5vboxsync pReq->u.In.uReqVersion, pReq->u.In.uMinVersion, (unsigned)SUPDRV_IDC_VERSION));
3b8ffb6094762b1754b860e35f77070f91cdd3a5vboxsync * On NT we will already have a session associated with the
3b8ffb6094762b1754b860e35f77070f91cdd3a5vboxsync * client, just like with the SUP_IOCTL_COOKIE request, while
3b8ffb6094762b1754b860e35f77070f91cdd3a5vboxsync * the other doesn't.
e05f27c2a433db4ad6e65a4daec7dc1fc7c05d6cvboxsync pReq->Hdr.rc = supdrvCreateSession(pDevExt, false /* fUser */, &pSession);
e05f27c2a433db4ad6e65a4daec7dc1fc7c05d6cvboxsync OSDBGPRINT(("SUPDRV_IDC_REQ_CONNECT: failed to create session, rc=%d\n", pReq->Hdr.rc));
3b8ffb6094762b1754b860e35f77070f91cdd3a5vboxsync REQ_CHECK_IDC_SIZE(SUPDRV_IDC_REQ_DISCONNECT, sizeof(*pReqHdr));
e05f27c2a433db4ad6e65a4daec7dc1fc7c05d6cvboxsync /* Windows will destroy the session when the file object is destroyed. */
e05f27c2a433db4ad6e65a4daec7dc1fc7c05d6cvboxsync PSUPDRVIDCREQGETSYM pReq = (PSUPDRVIDCREQGETSYM)pReqHdr;
e05f27c2a433db4ad6e65a4daec7dc1fc7c05d6cvboxsync REQ_CHECK_IDC_SIZE(SUPDRV_IDC_REQ_GET_SYMBOL, sizeof(*pReq));
e05f27c2a433db4ad6e65a4daec7dc1fc7c05d6cvboxsync pReq->Hdr.rc = supdrvIDC_LdrGetSymbol(pDevExt, pSession, pReq);
a240f1229507269d3449217c9d483597e498d3bcvboxsync PSUPDRVIDCREQCOMPREGFACTORY pReq = (PSUPDRVIDCREQCOMPREGFACTORY)pReqHdr;
a240f1229507269d3449217c9d483597e498d3bcvboxsync REQ_CHECK_IDC_SIZE(SUPDRV_IDC_REQ_COMPONENT_REGISTER_FACTORY, sizeof(*pReq));
a240f1229507269d3449217c9d483597e498d3bcvboxsync pReq->Hdr.rc = SUPR0ComponentRegisterFactory(pSession, pReq->u.In.pFactory);
e05f27c2a433db4ad6e65a4daec7dc1fc7c05d6cvboxsync PSUPDRVIDCREQCOMPDEREGFACTORY pReq = (PSUPDRVIDCREQCOMPDEREGFACTORY)pReqHdr;
e05f27c2a433db4ad6e65a4daec7dc1fc7c05d6cvboxsync REQ_CHECK_IDC_SIZE(SUPDRV_IDC_REQ_COMPONENT_DEREGISTER_FACTORY, sizeof(*pReq));
3b8ffb6094762b1754b860e35f77070f91cdd3a5vboxsync pReq->Hdr.rc = SUPR0ComponentDeregisterFactory(pSession, pReq->u.In.pFactory);
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;
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;