VirtualBox

Ignore:
Timestamp:
Dec 11, 2009 5:09:23 PM (15 years ago)
Author:
vboxsync
Message:

HostDrivers,SrvIntNetR0,iprt/ntwrap.mac: Removed all the RT_WITH_W64_UNWIND_HACK fun.

Location:
trunk/src/VBox/HostDrivers/Support
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/HostDrivers/Support/Makefile.kmk

    r25300 r25336  
    175175VBoxDrv_DEFS          = IN_RT_R0 IN_SUP_R0 SUPDRV_WITH_RELEASE_LOGGER
    176176ifdef VBOX_WITHOUT_NATIVE_R0_LOADER
    177  VBoxDrv_DEFS.amd64   = RT_WITH_W64_UNWIND_HACK VBOX_WITHOUT_NATIVE_R0_LOADER
     177 VBoxDrv_DEFS        += VBOX_WITHOUT_NATIVE_R0_LOADER
    178178endif
    179179ifdef VBOX_WITH_VMMR0_DISABLE_PREEMPTION

  • trunk/src/VBox/HostDrivers/Support/SUPDrv.c

    r25307 r25336  
    55
    66/*
    7  * Copyright (C) 2006-2007 Sun Microsystems, Inc.
     7 * Copyright (C) 2006-2009 Sun Microsystems, Inc.
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    113113static DECLCALLBACK(void) supdrvGipMpEvent(RTMPEVENT enmEvent, RTCPUID idCpu, void *pvUser);
    114114
    115 #ifdef RT_WITH_W64_UNWIND_HACK
    116 DECLASM(int)    supdrvNtWrapVMMR0EntryEx(PFNRT pfnVMMR0EntryEx, PVM pVM, VMCPUID idCpu, unsigned uOperation, PSUPVMMR0REQHDR pReq, uint64_t u64Arg, PSUPDRVSESSION pSession);
    117 DECLASM(int)    supdrvNtWrapVMMR0EntryFast(PFNRT pfnVMMR0EntryFast, PVM pVM, VMCPUID idCpu, unsigned uOperation);
    118 DECLASM(void)   supdrvNtWrapObjDestructor(PFNRT pfnDestruction, void *pvObj, void *pvUser1, void *pvUser2);
    119 DECLASM(void *) supdrvNtWrapQueryFactoryInterface(PFNRT pfnQueryFactoryInterface, struct SUPDRVFACTORY const *pSupDrvFactory, PSUPDRVSESSION pSession, const char *pszInterfaceUuid);
    120 DECLASM(int)    supdrvNtWrapModuleInit(PFNRT pfnModuleInit);
    121 DECLASM(void)   supdrvNtWrapModuleTerm(PFNRT pfnModuleTerm);
    122 DECLASM(int)    supdrvNtWrapServiceReqHandler(PFNRT pfnServiceReqHandler, PSUPDRVSESSION pSession, uint32_t uOperation, uint64_t u64Arg, PSUPR0SERVICEREQHDR pReqHdr);
    123 
    124 DECLASM(int)    UNWIND_WRAP(SUPR0ComponentRegisterFactory)(PSUPDRVSESSION pSession, PCSUPDRVFACTORY pFactory);
    125 DECLASM(int)    UNWIND_WRAP(SUPR0ComponentDeregisterFactory)(PSUPDRVSESSION pSession, PCSUPDRVFACTORY pFactory);
    126 DECLASM(int)    UNWIND_WRAP(SUPR0ComponentQueryFactory)(PSUPDRVSESSION pSession, const char *pszName, const char *pszInterfaceUuid, void **ppvFactoryIf);
    127 DECLASM(void *) UNWIND_WRAP(SUPR0ObjRegister)(PSUPDRVSESSION pSession, SUPDRVOBJTYPE enmType, PFNSUPDRVDESTRUCTOR pfnDestructor, void *pvUser1, void *pvUser2);
    128 DECLASM(int)    UNWIND_WRAP(SUPR0ObjAddRef)(void *pvObj, PSUPDRVSESSION pSession);
    129 DECLASM(int)    UNWIND_WRAP(SUPR0ObjAddRefEx)(void *pvObj, PSUPDRVSESSION pSession, bool fNoPreempt);
    130 DECLASM(int)    UNWIND_WRAP(SUPR0ObjRelease)(void *pvObj, PSUPDRVSESSION pSession);
    131 DECLASM(int)    UNWIND_WRAP(SUPR0ObjVerifyAccess)(void *pvObj, PSUPDRVSESSION pSession, const char *pszObjName);
    132 DECLASM(int)    UNWIND_WRAP(SUPR0LockMem)(PSUPDRVSESSION pSession, RTR3PTR pvR3, uint32_t cPages, PRTHCPHYS paPages);
    133 DECLASM(int)    UNWIND_WRAP(SUPR0UnlockMem)(PSUPDRVSESSION pSession, RTR3PTR pvR3);
    134 DECLASM(int)    UNWIND_WRAP(SUPR0ContAlloc)(PSUPDRVSESSION pSession, uint32_t cPages, PRTR0PTR ppvR0, PRTR3PTR ppvR3, PRTHCPHYS pHCPhys);
    135 DECLASM(int)    UNWIND_WRAP(SUPR0ContFree)(PSUPDRVSESSION pSession, RTHCUINTPTR uPtr);
    136 DECLASM(int)    UNWIND_WRAP(SUPR0LowAlloc)(PSUPDRVSESSION pSession, uint32_t cPages, PRTR0PTR ppvR0, PRTR3PTR ppvR3, PRTHCPHYS paPages);
    137 DECLASM(int)    UNWIND_WRAP(SUPR0LowFree)(PSUPDRVSESSION pSession, RTHCUINTPTR uPtr);
    138 DECLASM(int)    UNWIND_WRAP(SUPR0MemAlloc)(PSUPDRVSESSION pSession, uint32_t cb, PRTR0PTR ppvR0, PRTR3PTR ppvR3);
    139 DECLASM(int)    UNWIND_WRAP(SUPR0MemGetPhys)(PSUPDRVSESSION pSession, RTHCUINTPTR uPtr, PSUPPAGE paPages);
    140 DECLASM(int)    UNWIND_WRAP(SUPR0MemFree)(PSUPDRVSESSION pSession, RTHCUINTPTR uPtr);
    141 DECLASM(int)    UNWIND_WRAP(SUPR0PageAllocEx)(PSUPDRVSESSION pSession, uint32_t cPages, uint32_t fFlags, PRTR3PTR ppvR3, PRTR0PTR ppvR0, PRTHCPHYS paPages);
    142 DECLASM(int)    UNWIND_WRAP(SUPR0PageFree)(PSUPDRVSESSION pSession, RTR3PTR pvR3);
    143 //DECLASM(int)    UNWIND_WRAP(SUPR0Printf)(const char *pszFormat, ...);
    144 DECLASM(int)    UNWIND_WRAP(SUPSemEventCreate)(PSUPDRVSESSION pSession, PSUPSEMEVENT phEvent);
    145 DECLASM(int)    UNWIND_WRAP(SUPSemEventClose)(PSUPDRVSESSION pSession, SUPSEMEVENT hEvent);
    146 DECLASM(int)    UNWIND_WRAP(SUPSemEventSignal)(PSUPDRVSESSION pSession, SUPSEMEVENT hEvent);
    147 DECLASM(int)    UNWIND_WRAP(SUPSemEventWait)(PSUPDRVSESSION pSession, SUPSEMEVENT hEvent, uint32_t cMillies);
    148 DECLASM(int)    UNWIND_WRAP(SUPSemEventWaitNoResume)(PSUPDRVSESSION pSession, SUPSEMEVENT hEvent, uint32_t cMillies);
    149 DECLASM(int)    UNWIND_WRAP(SUPSemEventMultiCreate)(PSUPDRVSESSION pSession, PSUPSEMEVENTMULTI phEventMulti);
    150 DECLASM(int)    UNWIND_WRAP(SUPSemEventMultiClose)(PSUPDRVSESSION pSession, SUPSEMEVENTMULTI hEventMulti);
    151 DECLASM(int)    UNWIND_WRAP(SUPSemEventMultiSignal)(PSUPDRVSESSION pSession, SUPSEMEVENTMULTI hEventMulti);
    152 DECLASM(int)    UNWIND_WRAP(SUPSemEventMultiReset)(PSUPDRVSESSION pSession, SUPSEMEVENTMULTI hEventMulti);
    153 DECLASM(int)    UNWIND_WRAP(SUPSemEventMultiWait)(PSUPDRVSESSION pSession, SUPSEMEVENTMULTI hEventMulti, uint32_t cMillies);
    154 DECLASM(int)    UNWIND_WRAP(SUPSemEventMultiWaitNoResume)(PSUPDRVSESSION pSession, SUPSEMEVENTMULTI hEventMulti, uint32_t cMillies);
    155 DECLASM(SUPPAGINGMODE) UNWIND_WRAP(SUPR0GetPagingMode)(void);
    156 DECLASM(void *) UNWIND_WRAP(RTMemAlloc)(size_t cb) RT_NO_THROW;
    157 DECLASM(void *) UNWIND_WRAP(RTMemAllocZ)(size_t cb) RT_NO_THROW;
    158 DECLASM(void)   UNWIND_WRAP(RTMemFree)(void *pv) RT_NO_THROW;
    159 DECLASM(void *) UNWIND_WRAP(RTMemDup)(const void *pvSrc, size_t cb) RT_NO_THROW;
    160 DECLASM(void *) UNWIND_WRAP(RTMemDupEx)(const void *pvSrc, size_t cbSrc, size_t cbExtra) RT_NO_THROW;
    161 DECLASM(void *) UNWIND_WRAP(RTMemRealloc)(void *pvOld, size_t cbNew) RT_NO_THROW;
    162 DECLASM(int)    UNWIND_WRAP(RTR0MemObjAllocLow)(PRTR0MEMOBJ pMemObj, size_t cb, bool fExecutable);
    163 DECLASM(int)    UNWIND_WRAP(RTR0MemObjAllocPage)(PRTR0MEMOBJ pMemObj, size_t cb, bool fExecutable);
    164 DECLASM(int)    UNWIND_WRAP(RTR0MemObjAllocPhys)(PRTR0MEMOBJ pMemObj, size_t cb, RTHCPHYS PhysHighest);
    165 DECLASM(int)    UNWIND_WRAP(RTR0MemObjAllocPhysNC)(PRTR0MEMOBJ pMemObj, size_t cb, RTHCPHYS PhysHighest);
    166 DECLASM(int)    UNWIND_WRAP(RTR0MemObjAllocCont)(PRTR0MEMOBJ pMemObj, size_t cb, bool fExecutable);
    167 DECLASM(int)    UNWIND_WRAP(RTR0MemObjEnterPhys)(PRTR0MEMOBJ pMemObj, RTHCPHYS Phys, size_t cb);
    168 DECLASM(int)    UNWIND_WRAP(RTR0MemObjLockUser)(PRTR0MEMOBJ pMemObj, RTR3PTR R3Ptr, size_t cb, uint32_t fFlags, RTR0PROCESS R0Process);
    169 DECLASM(int)    UNWIND_WRAP(RTR0MemObjMapKernel)(PRTR0MEMOBJ pMemObj, RTR0MEMOBJ MemObjToMap, void *pvFixed, size_t uAlignment, unsigned fProt);
    170 DECLASM(int)    UNWIND_WRAP(RTR0MemObjMapKernelEx)(PRTR0MEMOBJ pMemObj, RTR0MEMOBJ MemObjToMap, void *pvFixed, size_t uAlignment, unsigned fProt, size_t offSub, size_t cbSub);
    171 DECLASM(int)    UNWIND_WRAP(RTR0MemObjMapUser)(PRTR0MEMOBJ pMemObj, RTR0MEMOBJ MemObjToMap, RTR3PTR R3PtrFixed, size_t uAlignment, unsigned fProt, RTR0PROCESS R0Process);
    172 DECLASM(int)    UNWIND_WRAP(RTR0MemObjProtect)(RTR0MEMOBJ hMemObj, size_t offsub, size_t cbSub, uint32_t fProt);
    173 /*DECLASM(void *) UNWIND_WRAP(RTR0MemObjAddress)(RTR0MEMOBJ MemObj); - not necessary */
    174 /*DECLASM(RTR3PTR) UNWIND_WRAP(RTR0MemObjAddressR3)(RTR0MEMOBJ MemObj); - not necessary */
    175 /*DECLASM(size_t) UNWIND_WRAP(RTR0MemObjSize)(RTR0MEMOBJ MemObj); - not necessary */
    176 /*DECLASM(bool)   UNWIND_WRAP(RTR0MemObjIsMapping)(RTR0MEMOBJ MemObj); - not necessary */
    177 /*DECLASM(RTHCPHYS) UNWIND_WRAP(RTR0MemObjGetPagePhysAddr)(RTR0MEMOBJ MemObj, size_t iPage); - not necessary */
    178 DECLASM(int)    UNWIND_WRAP(RTR0MemObjFree)(RTR0MEMOBJ MemObj, bool fFreeMappings);
    179 DECLASM(int)    UNWIND_WRAP(RTR0MemUserCopyFrom)(void *pvDst, RTR3PTR R3PtrSrc, size_t cb);
    180 DECLASM(int)    UNWIND_WRAP(RTR0MemUserCopyTo)(RTR3PTR R3PtrDst, void const *pvSrc, size_t cb);
    181 /* RTR0MemUserIsValidAddr - not necessary */
    182 /* RTR0MemKernelIsValidAddr - not necessary */
    183 /* RTR0MemAreKrnlAndUsrDifferent - not necessary */
    184 /* RTProcSelf             - not necessary */
    185 /* RTR0ProcHandleSelf     - not necessary */
    186 DECLASM(int)    UNWIND_WRAP(RTSemFastMutexCreate)(PRTSEMFASTMUTEX pMutexSem);
    187 DECLASM(int)    UNWIND_WRAP(RTSemFastMutexDestroy)(RTSEMFASTMUTEX MutexSem);
    188 DECLASM(int)    UNWIND_WRAP(RTSemFastMutexRequest)(RTSEMFASTMUTEX MutexSem);
    189 DECLASM(int)    UNWIND_WRAP(RTSemFastMutexRelease)(RTSEMFASTMUTEX MutexSem);
    190 DECLASM(int)    UNWIND_WRAP(RTSemEventCreate)(PRTSEMEVENT pEventSem);
    191 DECLASM(int)    UNWIND_WRAP(RTSemEventSignal)(RTSEMEVENT EventSem);
    192 DECLASM(int)    UNWIND_WRAP(RTSemEventWait)(RTSEMEVENT EventSem, unsigned cMillies);
    193 DECLASM(int)    UNWIND_WRAP(RTSemEventWaitNoResume)(RTSEMEVENT EventSem, unsigned cMillies);
    194 DECLASM(int)    UNWIND_WRAP(RTSemEventDestroy)(RTSEMEVENT EventSem);
    195 DECLASM(int)    UNWIND_WRAP(RTSemEventMultiCreate)(PRTSEMEVENTMULTI pEventMultiSem);
    196 DECLASM(int)    UNWIND_WRAP(RTSemEventMultiSignal)(RTSEMEVENTMULTI EventMultiSem);
    197 DECLASM(int)    UNWIND_WRAP(RTSemEventMultiReset)(RTSEMEVENTMULTI EventMultiSem);
    198 DECLASM(int)    UNWIND_WRAP(RTSemEventMultiWait)(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies);
    199 DECLASM(int)    UNWIND_WRAP(RTSemEventMultiWaitNoResume)(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies);
    200 DECLASM(int)    UNWIND_WRAP(RTSemEventMultiDestroy)(RTSEMEVENTMULTI EventMultiSem);
    201 DECLASM(int)    UNWIND_WRAP(RTSpinlockCreate)(PRTSPINLOCK pSpinlock);
    202 DECLASM(int)    UNWIND_WRAP(RTSpinlockDestroy)(RTSPINLOCK Spinlock);
    203 DECLASM(void)   UNWIND_WRAP(RTSpinlockAcquire)(RTSPINLOCK Spinlock, PRTSPINLOCKTMP pTmp);
    204 DECLASM(void)   UNWIND_WRAP(RTSpinlockRelease)(RTSPINLOCK Spinlock, PRTSPINLOCKTMP pTmp);
    205 DECLASM(void)   UNWIND_WRAP(RTSpinlockAcquireNoInts)(RTSPINLOCK Spinlock, PRTSPINLOCKTMP pTmp);
    206 DECLASM(void)   UNWIND_WRAP(RTSpinlockReleaseNoInts)(RTSPINLOCK Spinlock, PRTSPINLOCKTMP pTmp);
    207 /* RTTimeNanoTS           - not necessary */
    208 /* RTTimeMilliTS          - not necessary */
    209 /* RTTimeSystemNanoTS     - not necessary */
    210 /* RTTimeSystemMilliTS    - not necessary */
    211 /* RTThreadNativeSelf     - not necessary */
    212 DECLASM(int)    UNWIND_WRAP(RTThreadSleep)(unsigned cMillies);
    213 DECLASM(bool)   UNWIND_WRAP(RTThreadYield)(void);
    214 #if 0
    215 /* RTThreadSelf           - not necessary */
    216 DECLASM(int)    UNWIND_WRAP(RTThreadCreate)(PRTTHREAD pThread, PFNRTTHREAD pfnThread, void *pvUser, size_t cbStack,
    217                                             RTTHREADTYPE enmType, unsigned fFlags, const char *pszName);
    218 DECLASM(RTNATIVETHREAD) UNWIND_WRAP(RTThreadGetNative)(RTTHREAD Thread);
    219 DECLASM(int)    UNWIND_WRAP(RTThreadWait)(RTTHREAD Thread, unsigned cMillies, int *prc);
    220 DECLASM(int)    UNWIND_WRAP(RTThreadWaitNoResume)(RTTHREAD Thread, unsigned cMillies, int *prc);
    221 DECLASM(const char *) UNWIND_WRAP(RTThreadGetName)(RTTHREAD Thread);
    222 DECLASM(const char *) UNWIND_WRAP(RTThreadSelfName)(void);
    223 DECLASM(RTTHREADTYPE) UNWIND_WRAP(RTThreadGetType)(RTTHREAD Thread);
    224 DECLASM(int)    UNWIND_WRAP(RTThreadUserSignal)(RTTHREAD Thread);
    225 DECLASM(int)    UNWIND_WRAP(RTThreadUserReset)(RTTHREAD Thread);
    226 DECLASM(int)    UNWIND_WRAP(RTThreadUserWait)(RTTHREAD Thread, unsigned cMillies);
    227 DECLASM(int)    UNWIND_WRAP(RTThreadUserWaitNoResume)(RTTHREAD Thread, unsigned cMillies);
    228 #endif
    229 /* RTThreadPreemptIsEnabled - not necessary */
    230 /* RTThreadPreemptIsPending - not necessary */
    231 /* RTThreadPreemptIsPendingTrusty - not necessary */
    232 DECLASM(void)   UNWIND_WRAP(RTThreadPreemptDisable)(PRTTHREADPREEMPTSTATE pState);
    233 DECLASM(void)   UNWIND_WRAP(RTThreadPreemptRestore)(RTTHREADPREEMPTSTATE pState);
    234 /* RTLogDefaultInstance   - a bit of a gamble, but we do not want the overhead! */
    235 /* RTMpCpuId              - not necessary */
    236 /* RTMpCpuIdFromSetIndex  - not necessary */
    237 /* RTMpCpuIdToSetIndex    - not necessary */
    238 /* RTMpIsCpuPossible      - not necessary */
    239 /* RTMpGetCount           - not necessary */
    240 /* RTMpGetMaxCpuId        - not necessary */
    241 /* RTMpGetOnlineCount     - not necessary */
    242 /* RTMpGetOnlineSet       - not necessary */
    243 /* RTMpGetSet             - not necessary */
    244 /* RTMpIsCpuOnline        - not necessary */
    245 DECLASM(int)   UNWIND_WRAP(RTMpIsCpuWorkPending)(void);
    246 DECLASM(int)   UNWIND_WRAP(RTMpOnAll)(PFNRTMPWORKER pfnWorker, void *pvUser1, void *pvUser2);
    247 DECLASM(int)   UNWIND_WRAP(RTMpOnOthers)(PFNRTMPWORKER pfnWorker, void *pvUser1, void *pvUser2);
    248 DECLASM(int)   UNWIND_WRAP(RTMpOnSpecific)(RTCPUID idCpu, PFNRTMPWORKER pfnWorker, void *pvUser1, void *pvUser2);
    249 DECLASM(int)   UNWIND_WRAP(RTMpPokeCpu)(RTCPUID idCpu);
    250 /* RTLogRelDefaultInstance - not necessary. */
    251 DECLASM(int)   UNWIND_WRAP(RTLogSetDefaultInstanceThread)(PRTLOGGER pLogger, uintptr_t uKey);
    252 /* RTLogLogger            - can't wrap this buster.  */
    253 /* RTLogLoggerEx          - can't wrap this buster. */
    254 DECLASM(void)  UNWIND_WRAP(RTLogLoggerExV)(PRTLOGGER pLogger, unsigned fFlags, unsigned iGroup, const char *pszFormat, va_list args);
    255 /* RTLogPrintf            - can't wrap this buster. */  /** @todo provide va_list log wrappers in RuntimeR0. */
    256 DECLASM(void)  UNWIND_WRAP(RTLogPrintfV)(const char *pszFormat, va_list args);
    257 DECLASM(void)  UNWIND_WRAP(AssertMsg1)(const char *pszExpr, unsigned uLine, const char *pszFile, const char *pszFunction);
    258 /* AssertMsg2             - can't wrap this buster. */
    259 #endif /* RT_WITH_W64_UNWIND_HACK */
    260 
    261115
    262116/*******************************************************************************
    … …  
    284138    { "SUPR0AbsKernelGS",                       (void *)0 },
    285139        /* Normal function pointers: */
    286     { "SUPR0ComponentRegisterFactory",          (void *)UNWIND_WRAP(SUPR0ComponentRegisterFactory) },
    287     { "SUPR0ComponentDeregisterFactory",        (void *)UNWIND_WRAP(SUPR0ComponentDeregisterFactory) },
    288     { "SUPR0ComponentQueryFactory",             (void *)UNWIND_WRAP(SUPR0ComponentQueryFactory) },
    289     { "SUPR0ObjRegister",                       (void *)UNWIND_WRAP(SUPR0ObjRegister) },
    290     { "SUPR0ObjAddRef",                         (void *)UNWIND_WRAP(SUPR0ObjAddRef) },
    291     { "SUPR0ObjAddRefEx",                       (void *)UNWIND_WRAP(SUPR0ObjAddRefEx) },
    292     { "SUPR0ObjRelease",                        (void *)UNWIND_WRAP(SUPR0ObjRelease) },
    293     { "SUPR0ObjVerifyAccess",                   (void *)UNWIND_WRAP(SUPR0ObjVerifyAccess) },
    294     { "SUPR0LockMem",                           (void *)UNWIND_WRAP(SUPR0LockMem) },
    295     { "SUPR0UnlockMem",                         (void *)UNWIND_WRAP(SUPR0UnlockMem) },
    296     { "SUPR0ContAlloc",                         (void *)UNWIND_WRAP(SUPR0ContAlloc) },
    297     { "SUPR0ContFree",                          (void *)UNWIND_WRAP(SUPR0ContFree) },
    298     { "SUPR0LowAlloc",                          (void *)UNWIND_WRAP(SUPR0LowAlloc) },
    299     { "SUPR0LowFree",                           (void *)UNWIND_WRAP(SUPR0LowFree) },
    300     { "SUPR0MemAlloc",                          (void *)UNWIND_WRAP(SUPR0MemAlloc) },
    301     { "SUPR0MemGetPhys",                        (void *)UNWIND_WRAP(SUPR0MemGetPhys) },
    302     { "SUPR0MemFree",                           (void *)UNWIND_WRAP(SUPR0MemFree) },
    303     { "SUPR0PageAllocEx",                       (void *)UNWIND_WRAP(SUPR0PageAllocEx) },
    304     { "SUPR0PageFree",                          (void *)UNWIND_WRAP(SUPR0PageFree) },
     140    { "SUPR0ComponentRegisterFactory",          (void *)SUPR0ComponentRegisterFactory },
     141    { "SUPR0ComponentDeregisterFactory",        (void *)SUPR0ComponentDeregisterFactory },
     142    { "SUPR0ComponentQueryFactory",             (void *)SUPR0ComponentQueryFactory },
     143    { "SUPR0ObjRegister",                       (void *)SUPR0ObjRegister },
     144    { "SUPR0ObjAddRef",                         (void *)SUPR0ObjAddRef },
     145    { "SUPR0ObjAddRefEx",                       (void *)SUPR0ObjAddRefEx },
     146    { "SUPR0ObjRelease",                        (void *)SUPR0ObjRelease },
     147    { "SUPR0ObjVerifyAccess",                   (void *)SUPR0ObjVerifyAccess },
     148    { "SUPR0LockMem",                           (void *)SUPR0LockMem },
     149    { "SUPR0UnlockMem",                         (void *)SUPR0UnlockMem },
     150    { "SUPR0ContAlloc",                         (void *)SUPR0ContAlloc },
     151    { "SUPR0ContFree",                          (void *)SUPR0ContFree },
     152    { "SUPR0LowAlloc",                          (void *)SUPR0LowAlloc },
     153    { "SUPR0LowFree",                           (void *)SUPR0LowFree },
     154    { "SUPR0MemAlloc",                          (void *)SUPR0MemAlloc },
     155    { "SUPR0MemGetPhys",                        (void *)SUPR0MemGetPhys },
     156    { "SUPR0MemFree",                           (void *)SUPR0MemFree },
     157    { "SUPR0PageAllocEx",                       (void *)SUPR0PageAllocEx },
     158    { "SUPR0PageFree",                          (void *)SUPR0PageFree },
    305159    { "SUPR0Printf",                            (void *)SUPR0Printf }, /** @todo needs wrapping? */
    306     { "SUPSemEventCreate",                      (void *)UNWIND_WRAP(SUPSemEventCreate) },
    307     { "SUPSemEventClose",                       (void *)UNWIND_WRAP(SUPSemEventClose) },
    308     { "SUPSemEventSignal",                      (void *)UNWIND_WRAP(SUPSemEventSignal) },
    309     { "SUPSemEventWait",                        (void *)UNWIND_WRAP(SUPSemEventWait) },
    310     { "SUPSemEventWaitNoResume",                (void *)UNWIND_WRAP(SUPSemEventWaitNoResume) },
    311     { "SUPSemEventMultiCreate",                 (void *)UNWIND_WRAP(SUPSemEventMultiCreate) },
    312     { "SUPSemEventMultiClose",                  (void *)UNWIND_WRAP(SUPSemEventMultiClose) },
    313     { "SUPSemEventMultiSignal",                 (void *)UNWIND_WRAP(SUPSemEventMultiSignal) },
    314     { "SUPSemEventMultiReset",                  (void *)UNWIND_WRAP(SUPSemEventMultiReset) },
    315     { "SUPSemEventMultiWait",                   (void *)UNWIND_WRAP(SUPSemEventMultiWait) },
    316     { "SUPSemEventMultiWaitNoResume",           (void *)UNWIND_WRAP(SUPSemEventMultiWaitNoResume) },
    317     { "SUPR0GetPagingMode",                     (void *)UNWIND_WRAP(SUPR0GetPagingMode) },
     160    { "SUPSemEventCreate",                      (void *)SUPSemEventCreate },
     161    { "SUPSemEventClose",                       (void *)SUPSemEventClose },
     162    { "SUPSemEventSignal",                      (void *)SUPSemEventSignal },
     163    { "SUPSemEventWait",                        (void *)SUPSemEventWait },
     164    { "SUPSemEventWaitNoResume",                (void *)SUPSemEventWaitNoResume },
     165    { "SUPSemEventMultiCreate",                 (void *)SUPSemEventMultiCreate },
     166    { "SUPSemEventMultiClose",                  (void *)SUPSemEventMultiClose },
     167    { "SUPSemEventMultiSignal",                 (void *)SUPSemEventMultiSignal },
     168    { "SUPSemEventMultiReset",                  (void *)SUPSemEventMultiReset },
     169    { "SUPSemEventMultiWait",                   (void *)SUPSemEventMultiWait },
     170    { "SUPSemEventMultiWaitNoResume",           (void *)SUPSemEventMultiWaitNoResume },
     171    { "SUPR0GetPagingMode",                     (void *)SUPR0GetPagingMode },
    318172    { "SUPR0EnableVTx",                         (void *)SUPR0EnableVTx },
    319173    { "SUPGetGIP",                              (void *)SUPGetGIP },
    320174    { "g_pSUPGlobalInfoPage",                   (void *)&g_pSUPGlobalInfoPage },
    321     { "RTMemAlloc",                             (void *)UNWIND_WRAP(RTMemAlloc) },
    322     { "RTMemAllocZ",                            (void *)UNWIND_WRAP(RTMemAllocZ) },
    323     { "RTMemFree",                              (void *)UNWIND_WRAP(RTMemFree) },
    324     /*{ "RTMemDup",                               (void *)UNWIND_WRAP(RTMemDup) },
    325     { "RTMemDupEx",                             (void *)UNWIND_WRAP(RTMemDupEx) },*/
    326     { "RTMemRealloc",                           (void *)UNWIND_WRAP(RTMemRealloc) },
    327     { "RTR0MemObjAllocLow",                     (void *)UNWIND_WRAP(RTR0MemObjAllocLow) },
    328     { "RTR0MemObjAllocPage",                    (void *)UNWIND_WRAP(RTR0MemObjAllocPage) },
    329     { "RTR0MemObjAllocPhys",                    (void *)UNWIND_WRAP(RTR0MemObjAllocPhys) },
    330     { "RTR0MemObjAllocPhysNC",                  (void *)UNWIND_WRAP(RTR0MemObjAllocPhysNC) },
    331     { "RTR0MemObjAllocCont",                    (void *)UNWIND_WRAP(RTR0MemObjAllocCont) },
    332     { "RTR0MemObjEnterPhys",                    (void *)UNWIND_WRAP(RTR0MemObjEnterPhys) },
    333     { "RTR0MemObjLockUser",                     (void *)UNWIND_WRAP(RTR0MemObjLockUser) },
    334     { "RTR0MemObjMapKernel",                    (void *)UNWIND_WRAP(RTR0MemObjMapKernel) },
    335     { "RTR0MemObjMapKernelEx",                  (void *)UNWIND_WRAP(RTR0MemObjMapKernelEx) },
    336     { "RTR0MemObjMapUser",                      (void *)UNWIND_WRAP(RTR0MemObjMapUser) },
    337     { "RTR0MemObjProtect",                      (void *)UNWIND_WRAP(RTR0MemObjProtect) },
     175    { "RTMemAlloc",                             (void *)RTMemAlloc },
     176    { "RTMemAllocZ",                            (void *)RTMemAllocZ },
     177    { "RTMemFree",                              (void *)RTMemFree },
     178    /*{ "RTMemDup",                               (void *)RTMemDup },
     179    { "RTMemDupEx",                             (void *)RTMemDupEx },*/
     180    { "RTMemRealloc",                           (void *)RTMemRealloc },
     181    { "RTR0MemObjAllocLow",                     (void *)RTR0MemObjAllocLow },
     182    { "RTR0MemObjAllocPage",                    (void *)RTR0MemObjAllocPage },
     183    { "RTR0MemObjAllocPhys",                    (void *)RTR0MemObjAllocPhys },
     184    { "RTR0MemObjAllocPhysNC",                  (void *)RTR0MemObjAllocPhysNC },
     185    { "RTR0MemObjAllocCont",                    (void *)RTR0MemObjAllocCont },
     186    { "RTR0MemObjEnterPhys",                    (void *)RTR0MemObjEnterPhys },
     187    { "RTR0MemObjLockUser",                     (void *)RTR0MemObjLockUser },
     188    { "RTR0MemObjMapKernel",                    (void *)RTR0MemObjMapKernel },
     189    { "RTR0MemObjMapKernelEx",                  (void *)RTR0MemObjMapKernelEx },
     190    { "RTR0MemObjMapUser",                      (void *)RTR0MemObjMapUser },
     191    { "RTR0MemObjProtect",                      (void *)RTR0MemObjProtect },
    338192    { "RTR0MemObjAddress",                      (void *)RTR0MemObjAddress },
    339193    { "RTR0MemObjAddressR3",                    (void *)RTR0MemObjAddressR3 },
    … …  
    341195    { "RTR0MemObjIsMapping",                    (void *)RTR0MemObjIsMapping },
    342196    { "RTR0MemObjGetPagePhysAddr",              (void *)RTR0MemObjGetPagePhysAddr },
    343     { "RTR0MemObjFree",                         (void *)UNWIND_WRAP(RTR0MemObjFree) },
    344     { "RTR0MemUserCopyFrom",                    (void *)UNWIND_WRAP(RTR0MemUserCopyFrom) },
    345     { "RTR0MemUserCopyTo",                      (void *)UNWIND_WRAP(RTR0MemUserCopyTo) },
     197    { "RTR0MemObjFree",                         (void *)RTR0MemObjFree },
     198    { "RTR0MemUserCopyFrom",                    (void *)RTR0MemUserCopyFrom },
     199    { "RTR0MemUserCopyTo",                      (void *)RTR0MemUserCopyTo },
    346200    { "RTR0MemUserIsValidAddr",                 (void *)RTR0MemUserIsValidAddr },
    347201    { "RTR0MemKernelIsValidAddr",               (void *)RTR0MemKernelIsValidAddr },
    … …  
    355209    { "RTProcSelf",                             (void *)RTProcSelf },
    356210    { "RTR0ProcHandleSelf",                     (void *)RTR0ProcHandleSelf },
    357     { "RTSemFastMutexCreate",                   (void *)UNWIND_WRAP(RTSemFastMutexCreate) },
    358     { "RTSemFastMutexDestroy",                  (void *)UNWIND_WRAP(RTSemFastMutexDestroy) },
    359     { "RTSemFastMutexRequest",                  (void *)UNWIND_WRAP(RTSemFastMutexRequest) },
    360     { "RTSemFastMutexRelease",                  (void *)UNWIND_WRAP(RTSemFastMutexRelease) },
    361     { "RTSemEventCreate",                       (void *)UNWIND_WRAP(RTSemEventCreate) },
    362     { "RTSemEventSignal",                       (void *)UNWIND_WRAP(RTSemEventSignal) },
    363     { "RTSemEventWait",                         (void *)UNWIND_WRAP(RTSemEventWait) },
    364     { "RTSemEventWaitNoResume",                 (void *)UNWIND_WRAP(RTSemEventWaitNoResume) },
    365     { "RTSemEventDestroy",                      (void *)UNWIND_WRAP(RTSemEventDestroy) },
    366     { "RTSemEventMultiCreate",                  (void *)UNWIND_WRAP(RTSemEventMultiCreate) },
    367     { "RTSemEventMultiSignal",                  (void *)UNWIND_WRAP(RTSemEventMultiSignal) },
    368     { "RTSemEventMultiReset",                   (void *)UNWIND_WRAP(RTSemEventMultiReset) },
    369     { "RTSemEventMultiWait",                    (void *)UNWIND_WRAP(RTSemEventMultiWait) },
    370     { "RTSemEventMultiWaitNoResume",            (void *)UNWIND_WRAP(RTSemEventMultiWaitNoResume) },
    371     { "RTSemEventMultiDestroy",                 (void *)UNWIND_WRAP(RTSemEventMultiDestroy) },
    372     { "RTSpinlockCreate",                       (void *)UNWIND_WRAP(RTSpinlockCreate) },
    373     { "RTSpinlockDestroy",                      (void *)UNWIND_WRAP(RTSpinlockDestroy) },
    374     { "RTSpinlockAcquire",                      (void *)UNWIND_WRAP(RTSpinlockAcquire) },
    375     { "RTSpinlockRelease",                      (void *)UNWIND_WRAP(RTSpinlockRelease) },
    376     { "RTSpinlockAcquireNoInts",                (void *)UNWIND_WRAP(RTSpinlockAcquireNoInts) },
    377     { "RTSpinlockReleaseNoInts",                (void *)UNWIND_WRAP(RTSpinlockReleaseNoInts) },
     211    { "RTSemFastMutexCreate",                   (void *)RTSemFastMutexCreate },
     212    { "RTSemFastMutexDestroy",                  (void *)RTSemFastMutexDestroy },
     213    { "RTSemFastMutexRequest",                  (void *)RTSemFastMutexRequest },
     214    { "RTSemFastMutexRelease",                  (void *)RTSemFastMutexRelease },
     215    { "RTSemEventCreate",                       (void *)RTSemEventCreate },
     216    { "RTSemEventSignal",                       (void *)RTSemEventSignal },
     217    { "RTSemEventWait",                         (void *)RTSemEventWait },
     218    { "RTSemEventWaitNoResume",                 (void *)RTSemEventWaitNoResume },
     219    { "RTSemEventDestroy",                      (void *)RTSemEventDestroy },
     220    { "RTSemEventMultiCreate",                  (void *)RTSemEventMultiCreate },
     221    { "RTSemEventMultiSignal",                  (void *)RTSemEventMultiSignal },
     222    { "RTSemEventMultiReset",                   (void *)RTSemEventMultiReset },
     223    { "RTSemEventMultiWait",                    (void *)RTSemEventMultiWait },
     224    { "RTSemEventMultiWaitNoResume",            (void *)RTSemEventMultiWaitNoResume },
     225    { "RTSemEventMultiDestroy",                 (void *)RTSemEventMultiDestroy },
     226    { "RTSpinlockCreate",                       (void *)RTSpinlockCreate },
     227    { "RTSpinlockDestroy",                      (void *)RTSpinlockDestroy },
     228    { "RTSpinlockAcquire",                      (void *)RTSpinlockAcquire },
     229    { "RTSpinlockRelease",                      (void *)RTSpinlockRelease },
     230    { "RTSpinlockAcquireNoInts",                (void *)RTSpinlockAcquireNoInts },
     231    { "RTSpinlockReleaseNoInts",                (void *)RTSpinlockReleaseNoInts },
    378232    { "RTTimeNanoTS",                           (void *)RTTimeNanoTS },
    379233    { "RTTimeMilliTS",                          (void *)RTTimeMilliTS },
    … …  
    381235    { "RTTimeSystemMilliTS",                    (void *)RTTimeSystemMilliTS },
    382236    { "RTThreadNativeSelf",                     (void *)RTThreadNativeSelf },
    383     { "RTThreadSleep",                          (void *)UNWIND_WRAP(RTThreadSleep) },
    384     { "RTThreadYield",                          (void *)UNWIND_WRAP(RTThreadYield) },
     237    { "RTThreadSleep",                          (void *)RTThreadSleep },
     238    { "RTThreadYield",                          (void *)RTThreadYield },
    385239#if 0 /* Thread APIs, Part 2. */
    386     { "RTThreadSelf",                           (void *)UNWIND_WRAP(RTThreadSelf) },
    387     { "RTThreadCreate",                         (void *)UNWIND_WRAP(RTThreadCreate) }, /** @todo need to wrap the callback */
    388     { "RTThreadGetNative",                      (void *)UNWIND_WRAP(RTThreadGetNative) },
    389     { "RTThreadWait",                           (void *)UNWIND_WRAP(RTThreadWait) },
    390     { "RTThreadWaitNoResume",                   (void *)UNWIND_WRAP(RTThreadWaitNoResume) },
    391     { "RTThreadGetName",                        (void *)UNWIND_WRAP(RTThreadGetName) },
    392     { "RTThreadSelfName",                       (void *)UNWIND_WRAP(RTThreadSelfName) },
    393     { "RTThreadGetType",                        (void *)UNWIND_WRAP(RTThreadGetType) },
    394     { "RTThreadUserSignal",                     (void *)UNWIND_WRAP(RTThreadUserSignal) },
    395     { "RTThreadUserReset",                      (void *)UNWIND_WRAP(RTThreadUserReset) },
    396     { "RTThreadUserWait",                       (void *)UNWIND_WRAP(RTThreadUserWait) },
    397     { "RTThreadUserWaitNoResume",               (void *)UNWIND_WRAP(RTThreadUserWaitNoResume) },
     240    { "RTThreadSelf",                           (void *)RTThreadSelf },
     241    { "RTThreadCreate",                         (void *)RTThreadCreate }, /** @todo need to wrap the callback */
     242    { "RTThreadGetNative",                      (void *)RTThreadGetNative },
     243    { "RTThreadWait",                           (void *)RTThreadWait },
     244    { "RTThreadWaitNoResume",                   (void *)RTThreadWaitNoResume },
     245    { "RTThreadGetName",                        (void *)RTThreadGetName },
     246    { "RTThreadSelfName",                       (void *)RTThreadSelfName },
     247    { "RTThreadGetType",                        (void *)RTThreadGetType },
     248    { "RTThreadUserSignal",                     (void *)RTThreadUserSignal },
     249    { "RTThreadUserReset",                      (void *)RTThreadUserReset },
     250    { "RTThreadUserWait",                       (void *)RTThreadUserWait },
     251    { "RTThreadUserWaitNoResume",               (void *)RTThreadUserWaitNoResume },
    398252#endif
    399253    { "RTThreadPreemptIsEnabled",               (void *)RTThreadPreemptIsEnabled },
    … …  
    401255    { "RTThreadPreemptIsPendingTrusty",         (void *)RTThreadPreemptIsPendingTrusty },
    402256    { "RTThreadPreemptIsPossible",              (void *)RTThreadPreemptIsPossible },
    403     { "RTThreadPreemptDisable",                 (void *)UNWIND_WRAP(RTThreadPreemptDisable) },
    404     { "RTThreadPreemptRestore",                 (void *)UNWIND_WRAP(RTThreadPreemptRestore) },
     257    { "RTThreadPreemptDisable",                 (void *)RTThreadPreemptDisable },
     258    { "RTThreadPreemptRestore",                 (void *)RTThreadPreemptRestore },
    405259    { "RTThreadIsInInterrupt",                  (void *)RTThreadIsInInterrupt },
    406260
    … …  
    416270    { "RTMpGetSet",                             (void *)RTMpGetSet },
    417271    { "RTMpIsCpuOnline",                        (void *)RTMpIsCpuOnline },
    418     { "RTMpIsCpuWorkPending",                   (void *)UNWIND_WRAP(RTMpIsCpuWorkPending) },
    419     { "RTMpOnAll",                              (void *)UNWIND_WRAP(RTMpOnAll) },
    420     { "RTMpOnOthers",                           (void *)UNWIND_WRAP(RTMpOnOthers) },
    421     { "RTMpOnSpecific",                         (void *)UNWIND_WRAP(RTMpOnSpecific) },
    422     { "RTMpPokeCpu",                            (void *)UNWIND_WRAP(RTMpPokeCpu) },
     272    { "RTMpIsCpuWorkPending",                   (void *)RTMpIsCpuWorkPending },
     273    { "RTMpOnAll",                              (void *)RTMpOnAll },
     274    { "RTMpOnOthers",                           (void *)RTMpOnOthers },
     275    { "RTMpOnSpecific",                         (void *)RTMpOnSpecific },
     276    { "RTMpPokeCpu",                            (void *)RTMpPokeCpu },
    423277    { "RTPowerNotificationRegister",            (void *)RTPowerNotificationRegister },
    424278    { "RTPowerNotificationDeregister",          (void *)RTPowerNotificationDeregister },
    425279    { "RTLogRelDefaultInstance",                (void *)RTLogRelDefaultInstance },
    426     { "RTLogSetDefaultInstanceThread",          (void *)UNWIND_WRAP(RTLogSetDefaultInstanceThread) },
     280    { "RTLogSetDefaultInstanceThread",          (void *)RTLogSetDefaultInstanceThread },
    427281    { "RTLogLogger",                            (void *)RTLogLogger }, /** @todo remove this */
    428282    { "RTLogLoggerEx",                          (void *)RTLogLoggerEx }, /** @todo remove this */
    429     { "RTLogLoggerExV",                         (void *)UNWIND_WRAP(RTLogLoggerExV) },
     283    { "RTLogLoggerExV",                         (void *)RTLogLoggerExV },
    430284    { "RTLogPrintf",                            (void *)RTLogPrintf }, /** @todo remove this */
    431     { "RTLogPrintfV",                           (void *)UNWIND_WRAP(RTLogPrintfV) },
    432     { "AssertMsg1",                             (void *)UNWIND_WRAP(AssertMsg1) },
     285    { "RTLogPrintfV",                           (void *)RTLogPrintfV },
     286    { "AssertMsg1",                             (void *)AssertMsg1 },
    433287    { "AssertMsg2",                             (void *)AssertMsg2 }, /** @todo replace this by RTAssertMsg2V */
    434288#if defined(RT_OS_DARWIN) || defined(RT_OS_SOLARIS)
    … …  
    823677                     pObj, pObj->enmType, pObj->pvUser1, pObj->pvUser2, pObj->CreatorProcess, RTProcSelf(), pObj->pfnDestructor));
    824678                if (pObj->pfnDestructor)
    825 #ifdef RT_WITH_W64_UNWIND_HACK
    826                     supdrvNtWrapObjDestructor((PFNRT)pObj->pfnDestructor, pObj, pObj->pvUser1, pObj->pvUser2);
    827 #else
    828679                    pObj->pfnDestructor(pObj, pObj->pvUser1, pObj->pvUser2);
    829 #endif
    830680                RTMemFree(pObj);
    831681            }
    … …  
    1022872        {
    1023873            case SUP_IOCTL_FAST_DO_RAW_RUN:
    1024 #ifdef RT_WITH_W64_UNWIND_HACK
    1025                 supdrvNtWrapVMMR0EntryFast((PFNRT)pDevExt->pfnVMMR0EntryFast, pSession->pVM, idCpu, SUP_VMMR0_DO_RAW_RUN);
    1026 #else
    1027874                pDevExt->pfnVMMR0EntryFast(pSession->pVM, idCpu, SUP_VMMR0_DO_RAW_RUN);
    1028 #endif
    1029875                break;
    1030876            case SUP_IOCTL_FAST_DO_HWACC_RUN:
    1031 #ifdef RT_WITH_W64_UNWIND_HACK
    1032                 supdrvNtWrapVMMR0EntryFast((PFNRT)pDevExt->pfnVMMR0EntryFast, pSession->pVM, idCpu, SUP_VMMR0_DO_HWACC_RUN);
    1033 #else
    1034877                pDevExt->pfnVMMR0EntryFast(pSession->pVM, idCpu, SUP_VMMR0_DO_HWACC_RUN);
    1035 #endif
    1036878                break;
    1037879            case SUP_IOCTL_FAST_DO_NOP:
    1038 #ifdef RT_WITH_W64_UNWIND_HACK
    1039                 supdrvNtWrapVMMR0EntryFast((PFNRT)pDevExt->pfnVMMR0EntryFast, pSession->pVM, idCpu, SUP_VMMR0_DO_NOP);
    1040 #else
    1041880                pDevExt->pfnVMMR0EntryFast(pSession->pVM, idCpu, SUP_VMMR0_DO_NOP);
    1042 #endif
    1043881                break;
    1044882            default:
    … …  
    13981236                /* execute */
    13991237                if (RT_LIKELY(pDevExt->pfnVMMR0EntryEx))
    1400 #ifdef RT_WITH_W64_UNWIND_HACK
    1401                     pReq->Hdr.rc = supdrvNtWrapVMMR0EntryEx((PFNRT)pDevExt->pfnVMMR0EntryEx, pReq->u.In.pVMR0, pReq->u.In.idCpu, pReq->u.In.uOperation, NULL, pReq->u.In.u64Arg, pSession);
    1402 #else
    14031238                    pReq->Hdr.rc = pDevExt->pfnVMMR0EntryEx(pReq->u.In.pVMR0, pReq->u.In.idCpu, pReq->u.In.uOperation, NULL, pReq->u.In.u64Arg, pSession);
    1404 #endif
    14051239                else
    14061240                    pReq->Hdr.rc = VERR_WRONG_ORDER;
    … …  
    14161250                /* execute */
    14171251                if (RT_LIKELY(pDevExt->pfnVMMR0EntryEx))
    1418 #ifdef RT_WITH_W64_UNWIND_HACK
    1419                     pReq->Hdr.rc = supdrvNtWrapVMMR0EntryEx((PFNRT)pDevExt->pfnVMMR0EntryEx, pReq->u.In.pVMR0, pReq->u.In.idCpu, pReq->u.In.uOperation, pVMMReq, pReq->u.In.u64Arg, pSession);
    1420 #else
    14211252                    pReq->Hdr.rc = pDevExt->pfnVMMR0EntryEx(pReq->u.In.pVMR0, pReq->u.In.idCpu, pReq->u.In.uOperation, pVMMReq, pReq->u.In.u64Arg, pSession);
    1422 #endif
    14231253                else
    14241254                    pReq->Hdr.rc = VERR_WRONG_ORDER;
    … …  
    22282058             pObj, pObj->enmType, pObj->pvUser1, pObj->pvUser2, pObj->CreatorProcess, RTProcSelf(), pObj->pfnDestructor));
    22292059        if (pObj->pfnDestructor)
    2230 #ifdef RT_WITH_W64_UNWIND_HACK
    2231             supdrvNtWrapObjDestructor((PFNRT)pObj->pfnDestructor, pObj, pObj->pvUser1, pObj->pvUser2);
    2232 #else
    22332060            pObj->pfnDestructor(pObj, pObj->pvUser1, pObj->pvUser2);
    2234 #endif
    22352061        RTMemFree(pObj);
    22362062    }
    … …  
    32993125                &&  !memcmp(pCur->pFactory->szName, pszName, cchName))
    33003126            {
    3301 #ifdef RT_WITH_W64_UNWIND_HACK
    3302                 void *pvFactory = supdrvNtWrapQueryFactoryInterface((PFNRT)pCur->pFactory->pfnQueryFactoryInterface, pCur->pFactory, pSession, pszInterfaceUuid);
    3303 #else
    33043127                void *pvFactory = pCur->pFactory->pfnQueryFactoryInterface(pCur->pFactory, pSession, pszInterfaceUuid);
    3305 #endif
    33063128                if (pvFactory)
    33073129                {
    … …  
    37723594    {
    37733595        Log(("supdrvIOCtl_LdrLoad: calling pfnModuleInit=%p\n", pImage->pfnModuleInit));
    3774 #ifdef RT_WITH_W64_UNWIND_HACK
    3775         rc = supdrvNtWrapModuleInit((PFNRT)pImage->pfnModuleInit);
    3776 #else
    37773596        rc = pImage->pfnModuleInit();
    3778 #endif
    37793597        if (rc && pDevExt->pvVMMR0 == pImage->pvImage)
    37803598            supdrvLdrUnsetVMMR0EPs(pDevExt);
    … …  
    42244042    {
    42254043        LogFlow(("supdrvIOCtl_LdrLoad: calling pfnModuleTerm=%p\n", pImage->pfnModuleTerm));
    4226 #ifdef RT_WITH_W64_UNWIND_HACK
    4227         supdrvNtWrapModuleTerm(pImage->pfnModuleTerm);
    4228 #else
    42294044        pImage->pfnModuleTerm();
    4230 #endif
    42314045    }
    42324046
    … …  
    43184132             */
    43194133            if (pReq->Hdr.cbIn == SUP_IOCTL_CALL_SERVICE_SIZE(0))
    4320 #ifdef RT_WITH_W64_UNWIND_HACK
    4321                 rc = supdrvNtWrapServiceReqHandler((PFNRT)pfnServiceReqHandler, pSession, pReq->u.In.uOperation, pReq->u.In.u64Arg, NULL);
    4322 #else
    43234134                rc = pfnServiceReqHandler(pSession, pReq->u.In.uOperation, pReq->u.In.u64Arg, NULL);
    4324 #endif
    43254135            else
    4326 #ifdef RT_WITH_W64_UNWIND_HACK
    4327                 rc = supdrvNtWrapServiceReqHandler((PFNRT)pfnServiceReqHandler, pSession, pReq->u.In.uOperation,
    4328                                                    pReq->u.In.u64Arg, (PSUPR0SERVICEREQHDR)&pReq->abReqPkt[0]);
    4329 #else
    43304136                rc = pfnServiceReqHandler(pSession, pReq->u.In.uOperation, pReq->u.In.u64Arg, (PSUPR0SERVICEREQHDR)&pReq->abReqPkt[0]);
    4331 #endif
    43324137        }
    43334138        else

  • trunk/src/VBox/HostDrivers/Support/SUPDrvInternal.h

    r25308 r25336  
    263263#else
    264264# define dprintf2(a) do { } while (0)
    265 #endif
    266 
    267 
    268 /** @def RT_WITH_W64_UNWIND_HACK
    269  * Changes a function name into the wrapped version if we've
    270  * enabled the unwind hack.
    271  *
    272  * The unwind hack is for making the NT unwind procedures skip
    273  * our dynamically loaded code when they try to walk the call
    274  * stack. Needless to say, they kind of don't expect what
    275  * we're doing here and get kind of confused and may BSOD. */
    276 #ifdef DOXYGEN_RUNNING
    277 # define RT_WITH_W64_UNWIND_HACK
    278 #endif
    279 /** @def UNWIND_WRAP
    280  * If RT_WITH_W64_UNWIND_HACK is defined, the name will be prefixed with
    281  * 'supdrvNtWrap'.
    282  * @param Name  The function to wrapper.  */
    283 #ifdef RT_WITH_W64_UNWIND_HACK
    284 # define UNWIND_WRAP(Name)  supdrvNtWrap##Name
    285 #else
    286 # define UNWIND_WRAP(Name)  Name
    287265#endif
    288266

  • trunk/src/VBox/HostDrivers/Support/win/SUPDrv-win.cpp

    r25331 r25336  
    620620
    621621#ifdef VBOX_WITHOUT_NATIVE_R0_LOADER
     622# ifndef RT_ARCH_X86
     623#  error "VBOX_WITHOUT_NATIVE_R0_LOADER is only safe on x86."
     624# endif
    622625    NOREF(pDevExt); NOREF(pszFilename); NOREF(pImage);
    623626    return VERR_NOT_SUPPORTED;
    … …  
    691694            {
    692695                case /* 0xc0000003 */ STATUS_INVALID_INFO_CLASS:
     696# ifdef RT_ARCH_AMD64
     697                    /* Unwind will crash and BSOD, so no fallback here! */
     698                    rc = VERR_NOT_IMPLEMENTED;
     699# else
    693700                    /*
    694                      * Use the old way of loading the modules if we can.  We do
    695                      * not try class 26 because it will not work correctly on
    696                      * terminal server and have issues with paging of the image.
     701                     * Use the old way of loading the modules.
    697702                     *
    698                      * Note! Using the 64-bit wrappers will require hacking the
    699                      *       image verfication in supdrvOSLdrLoad.
     703                     * Note! We do *NOT* try class 26 because it will probably
     704                     *       not work correctly on terminal servers and such.
    700705                     */
    701 # if !defined(RT_ARCH_AMD64) || defined(RT_WITH_W64_UNWIND_HACK)
    702706                    rc = VERR_NOT_SUPPORTED;
    703 # else
    704                     rc = VERR_NOT_IMPLEMENTED;
    705707# endif
    706708                    break;
    … …  
    735737
    736738/**
    737  * memcmp + log. 
    738  * 
     739 * memcmp + log.
     740 *
    739741 * @returns Same as memcmp.
    740742 * @param   pImage          The image.
    … …  
    806808                                     / sizeof(IMAGE_IMPORT_DESCRIPTOR);
    807809            IMAGE_IMPORT_DESCRIPTOR const *pImp;
    808             pImp = (IMAGE_IMPORT_DESCRIPTOR const *)(pbImageBits 
     810            pImp = (IMAGE_IMPORT_DESCRIPTOR const *)(pbImageBits
    809811                                                     + pNtHdrs->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress);
    810812            while (   cImpsLeft-- > 0

  • trunk/src/VBox/HostDrivers/Support/win/SUPDrvA-win.asm

    r25274 r25336  
    55
    66;
    7 ; Copyright (C) 2006-2007 Sun Microsystems, Inc.
     7; Copyright (C) 2006-2009 Sun Microsystems, Inc.
    88;
    99; This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    3232;* Header Files                                                                *
    3333;*******************************************************************************
    34 %include "iprt/ntwrap.mac"
     34%include "iprt/asmdefs.mac"
    3535
    3636BEGINCODE
    3737%ifdef RT_ARCH_AMD64
    38 %define _DbgPrint DbgPrint
     38 %define _DbgPrint DbgPrint
    3939%endif
    4040extern _DbgPrint
    … …  
    4949%endif
    5050
    51 
    52 %ifdef RT_WITH_W64_UNWIND_HACK
    53  %ifdef RT_ARCH_AMD64
    54 
    55 ;
    56 ; This has the same order as the list in SUPDrv.c
    57 ;
    58 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, SUPR0ComponentRegisterFactory
    59 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, SUPR0ComponentDeregisterFactory
    60 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, SUPR0ComponentQueryFactory
    61 NtWrapDyn2DrvFunctionWith5Params       supdrvNtWrap, SUPR0ObjRegister
    62 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, SUPR0ObjAddRef
    63 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, SUPR0ObjAddRefEx
    64 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, SUPR0ObjRelease
    65 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, SUPR0ObjVerifyAccess
    66 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, SUPR0LockMem
    67 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, SUPR0UnlockMem
    68 NtWrapDyn2DrvFunctionWith5Params       supdrvNtWrap, SUPR0ContAlloc
    69 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, SUPR0ContFree
    70 NtWrapDyn2DrvFunctionWith5Params       supdrvNtWrap, SUPR0LowAlloc
    71 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, SUPR0LowFree
    72 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, SUPR0MemAlloc
    73 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, SUPR0MemGetPhys
    74 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, SUPR0MemFree
    75 NtWrapDyn2DrvFunctionWith6Params       supdrvNtWrap, SUPR0PageAllocEx
    76 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, SUPR0PageFree
    77 ;NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, SUPR0Printf            - cannot wrap this buster.
    78 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, SUPSemEventCreate
    79 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, SUPSemEventClose
    80 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, SUPSemEventSignal
    81 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, SUPSemEventWait
    82 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, SUPSemEventWaitNoResume
    83 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, SUPSemEventMultiCreate
    84 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, SUPSemEventMultiClose
    85 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, SUPSemEventMultiSignal
    86 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, SUPSemEventMultiReset
    87 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, SUPSemEventMultiWait
    88 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, SUPSemEventMultiWaitNoResume
    89 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, SUPR0GetPagingMode
    90 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTMemAlloc
    91 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTMemAllocZ
    92 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTMemFree
    93 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTMemDup
    94 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTMemDupEx
    95 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTMemRealloc
    96 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTR0MemObjAllocLow
    97 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTR0MemObjAllocPage
    98 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTR0MemObjAllocPhys
    99 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTR0MemObjAllocPhysNC
    100 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTR0MemObjAllocCont
    101 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTR0MemObjEnterPhys
    102 NtWrapDyn2DrvFunctionWith5Params       supdrvNtWrap, RTR0MemObjLockUser
    103 NtWrapDyn2DrvFunctionWith5Params       supdrvNtWrap, RTR0MemObjMapKernel
    104 NtWrapDyn2DrvFunctionWith7Params       supdrvNtWrap, RTR0MemObjMapKernelEx
    105 NtWrapDyn2DrvFunctionWith6Params       supdrvNtWrap, RTR0MemObjMapUser
    106 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTR0MemObjProtect
    107 ;NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTR0MemObjAddress      - not necessary
    108 ;NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTR0MemObjAddressR3    - not necessary
    109 ;NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTR0MemObjSize         - not necessary
    110 ;NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTR0MemObjIsMapping    - not necessary
    111 ;NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTR0MemObjGetPagePhysAddr - not necessary
    112 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTR0MemObjFree
    113 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTR0MemUserCopyFrom
    114 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTR0MemUserCopyTo
    115 ;NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTR0MemUserIsValidAddr - not necessary
    116 ;NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTR0MemKernelIsValidAdd - not necessary
    117 ;NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTR0MemAreKrnlAndUsrDifferent - not necessary
    118 ;NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTProcSelf             - not necessary
    119 ;NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTR0ProcHandleSelf     - not necessary
    120 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTSemFastMutexCreate
    121 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTSemFastMutexDestroy
    122 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTSemFastMutexRequest
    123 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTSemFastMutexRelease
    124 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTSemEventCreate
    125 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTSemEventSignal
    126 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTSemEventWait
    127 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTSemEventWaitNoResume
    128 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTSemEventDestroy
    129 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTSemEventMultiCreate
    130 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTSemEventMultiSignal
    131 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTSemEventMultiReset
    132 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTSemEventMultiWait
    133 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTSemEventMultiWaitNoResume
    134 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTSemEventMultiDestroy
    135 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTSpinlockCreate
    136 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTSpinlockDestroy
    137 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTSpinlockAcquire
    138 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTSpinlockRelease
    139 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTSpinlockAcquireNoInts
    140 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTSpinlockReleaseNoInts
    141 ;NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTTimeNanoTS           - not necessary
    142 ;NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTTimeMilliTS          - not necessary
    143 ;NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTTimeSystemNanoTS     - not necessary
    144 ;NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTTimeSystemMilliTS    - not necessary
    145 ;NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTThreadNativeSelf     - not necessary
    146 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTThreadSleep
    147 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTThreadYield
    148 %if 0 ; Thread APIs, Part 2
    149 ;NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTThreadSelf
    150 NtWrapDyn2DrvFunctionWith7Params       supdrvNtWrap, RTThreadCreate
    151 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTThreadGetNative
    152 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTThreadWait
    153 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTThreadWaitNoResume
    154 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTThreadGetName
    155 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTThreadSelfName
    156 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTThreadGetType
    157 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTThreadUserSignal
    158 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTThreadUserReset
    159 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTThreadUserWait
    160 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTThreadUserWaitNoResume
    161 %endif
    162 ;NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTThreadPreemptIsEnabled - not necessary
    163 ;NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTThreadPreemptIsPending - not necessary
    164 ;NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTThreadPreemptIsPendingTrusty - not necessary
    165 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTThreadPreemptDisable
    166 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTThreadPreemptRestore
    167 ;NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTLogDefaultInstance   - a bit of a gamble, but we do not want the overhead!
    168 ;NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTMpCpuId              - not necessary
    169 ;NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTMpCpuIdFromSetIndex  - not necessary
    170 ;NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTMpCpuIdToSetIndex    - not necessary
    171 ;NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTMpIsCpuPossible      - not necessary
    172 ;NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTMpGetCount           - not necessary
    173 ;NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTMpGetMaxCpuId        - not necessary
    174 ;NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTMpGetOnlineCount     - not necessary
    175 ;NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTMpGetOnlineSet       - not necessary
    176 ;NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTMpGetSet             - not necessary
    177 ;NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTMpIsCpuOnline        - not necessary
    178 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTMpIsCpuWorkPending
    179 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTMpOnAll
    180 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTMpOnOthers
    181 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTMpOnSpecific
    182 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTMpPokeCpu
    183 ;NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTLogRelDefaultInstance - not necessary.
    184 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTLogSetDefaultInstanceThread
    185 ;NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTLogLogger            - can't wrap this buster.
    186 ;NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTLogLoggerEx          - can't wrap this buster.
    187 NtWrapDyn2DrvFunctionWith5Params       supdrvNtWrap, RTLogLoggerExV
    188 ;NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTLogPrintf            - can't wrap this buster. ;; @todo provide va_list log wrappers in RuntimeR0.
    189 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTLogPrintfV
    190 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, AssertMsg1
    191 ;NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, AssertMsg2             - can't wrap this buster.
    192 NtWrapDrv2DynFunctionWithAllRegParams   supdrvNtWrap, RTPowerSignalEvent
    193 
    194 
    195 ;;
    196 ; @cproto DECLASM(int) supdrvNtWrapVMMR0EntryEx(PFNRT pfnVMMR0EntryEx, PVM pVM, unsigned idCpu, unsigned uOperation, PSUPVMMR0REQHDR pReq, uint64_t u64Arg, PSUPDRVSESSION pSession);
    197 ;
    198 ; @param    pfnVMMR0EntryEx     rcx
    199 ; @param    pVM                 rdx
    200 ; @param    idCpu               r8
    201 ; @param    uOperation          r9
    202 ; @param    pReq                [rsp + 28h] / [rbp + 30h]
    203 ; @param    u64Arg              [rsp + 30h] / [rbp + 38h]
    204 ; @param    pSession            [rsp + 38h] / [rbp + 40h]
    205 ;
    206 BEGINPROC supdrvNtWrapVMMR0EntryEx
    207         NtWrapProlog supdrvNtWrapVMMR0EntryEx
    208         NtWrapCreateMarker
    209 
    210         mov     rax, rcx
    211         mov     rcx, rdx
    212         mov     rdx, r8
    213         mov     r8, r9
    214         mov     r9, [rbp + 30h]
    215         mov     r11, [rbp + 38h]
    216         mov     [rsp + 20h], r11
    217         mov     r11, [rbp + 40h]
    218         mov     [rsp + 28h], r11
    219         call    rax
    220 
    221         NtWrapDestroyMarker
    222         NtWrapEpilog supdrvNtWrapVMMR0EntryEx
    223 ENDPROC   supdrvNtWrapVMMR0EntryEx
    224 
    225 
    226 ;;
    227 ; @cproto DECLASM(int)    supdrvNtWrapVMMR0EntryFast(PFNRT pfnVMMR0EntryFast, PVM pVM, unsigned idCPU, unsigned uOperation);
    228 ;
    229 ; @param    pfnVMMR0EntryFast   rcx
    230 ; @param    pVM                 rdx
    231 ; @param    idCPU               r8
    232 ; @param    uOperation          r9
    233 ;
    234 BEGINPROC supdrvNtWrapVMMR0EntryFast
    235         NtWrapProlog supdrvNtWrapVMMR0EntryFast
    236         NtWrapCreateMarker
    237 
    238         mov     rax, rcx
    239         mov     rcx, rdx
    240         mov     rdx, r8
    241         mov     r8, r9
    242         call    rax
    243 
    244         NtWrapDestroyMarker
    245         NtWrapEpilog supdrvNtWrapVMMR0EntryFast
    246 ENDPROC   supdrvNtWrapVMMR0EntryFast
    247 
    248 
    249 ;;
    250 ; @cproto DECLASM(void)   supdrvNtWrapObjDestructor(PFNRT pfnDestruction, void *pvObj, void *pvUser1, void *pvUser2);
    251 ;
    252 ; @param    pfnDestruction      rcx
    253 ; @param    pvObj               rdx
    254 ; @param    pvUser1             r8
    255 ; @param    pvUser2             r9
    256 ;
    257 BEGINPROC supdrvNtWrapObjDestructor
    258         NtWrapProlog supdrvNtWrapObjDestructor
    259         NtWrapCreateMarker
    260 
    261         mov     rax, rcx
    262         mov     rcx, rdx
    263         mov     rdx, r8
    264         mov     r8, r9
    265         call    rax
    266 
    267         NtWrapDestroyMarker
    268         NtWrapEpilog supdrvNtWrapObjDestructor
    269 ENDPROC   supdrvNtWrapObjDestructor
    270 
    271 
    272 ;;
    273 ; @cproto DECLASM(void *) supdrvNtWrapQueryFactoryInterface(PFNRT pfnQueryFactoryInterface, struct SUPDRVFACTORY const *pSupDrvFactory,
    274 ;                                                           PSUPDRVSESSION pSession, const char *pszInterfaceUuid);
    275 ;
    276 ; @param    pfnQueryFactoryInterface    rcx
    277 ; @param    pSupDrvFactory      rdx
    278 ; @param    pSession            r8
    279 ; @param    pszInterfaceUuid    r9
    280 ;
    281 BEGINPROC supdrvNtWrapQueryFactoryInterface
    282         NtWrapProlog supdrvNtWrapQueryFactoryInterface
    283         NtWrapCreateMarker
    284 
    285         mov     rax, rcx
    286         mov     rcx, rdx
    287         mov     rdx, r8
    288         mov     r8, r9
    289         call    rax
    290 
    291         NtWrapDestroyMarker
    292         NtWrapEpilog supdrvNtWrapQueryFactoryInterface
    293 ENDPROC   supdrvNtWrapQueryFactoryInterface
    294 
    295 
    296 ;;
    297 ; @cproto DECLASM(int)    supdrvNtWrapModuleInit(PFNRT pfnModuleInit);
    298 ;
    299 ; @param    pfnModuleInit       rcx
    300 ;
    301 BEGINPROC supdrvNtWrapModuleInit
    302         NtWrapProlog supdrvNtWrapModuleInit
    303         NtWrapCreateMarker
    304 
    305         call    rcx
    306 
    307         NtWrapDestroyMarker
    308         NtWrapEpilog supdrvNtWrapModuleInit
    309 ENDPROC   supdrvNtWrapModuleInit
    310 
    311 
    312 ;;
    313 ; @cproto DECLASM(void)   supdrvNtWrapModuleTerm(PFNRT pfnModuleTerm);
    314 ;
    315 ; @param    pfnModuleInit       rcx
    316 ;
    317 BEGINPROC supdrvNtWrapModuleTerm
    318         NtWrapProlog supdrvNtWrapModuleTerm
    319         NtWrapCreateMarker
    320 
    321         call    rcx
    322 
    323         NtWrapDestroyMarker
    324         NtWrapEpilog supdrvNtWrapModuleTerm
    325 ENDPROC   supdrvNtWrapModuleTerm
    326 
    327 
    328 ;;
    329 ; @cproto DECLASM(int) supdrvNtWrapServiceReqHandler(PFNRT pfnServiceReqHandler, PSUPDRVSESSION pSession, uint32_t uOperation, uint64_t u64Arg, PSUPR0SERVICEREQHDR pReqHdr);
    330 ;
    331 ; @param    pfnSerivceReqHandler rcx
    332 ; @param    pSession            rdx
    333 ; @param    uOperation          r8
    334 ; @param    u64Arg              r9
    335 ; @param    pReq                [rsp + 28h] / [rbp + 30h]
    336 ;
    337 BEGINPROC supdrvNtWrapServiceReqHandler
    338         NtWrapProlog supdrvNtWrapServiceReqHandler
    339         NtWrapCreateMarker
    340 
    341         mov     rax, rcx
    342         mov     rcx, rdx
    343         mov     rdx, r8
    344         mov     r8, r9
    345         mov     r9, [rbp + 30h]
    346         call    rax
    347 
    348         NtWrapDestroyMarker
    349         NtWrapEpilog supdrvNtWrapServiceReqHandler
    350 ENDPROC   supdrvNtWrapServiceReqHandler
    351 
    352 
    353  %endif ; RT_ARCH_AMD64
    354 %endif ; RT_WITH_W64_UNWIND_HACK
    355 
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette