Changeset 57905 in vbox for trunk/src/VBox/Runtime/r3/win/vcc100-kernel32-fakes.cpp

Timestamp:

Sep 25, 2015 8:39:56 PM (9 years ago)

Author:

vboxsync

Message:

IPRT: More build for NT4 fun, but the VBoxRT.dll we build when VBOX_WITH_MORE_NT4_COMPAT_BINARIES is defined can be loaded and used on NT4.

File:

• trunk/src/VBox/Runtime/r3/win/vcc100-kernel32-fakes.cpp (modified) (10 diffs)

trunk/src/VBox/Runtime/r3/win/vcc100-kernel32-fakes.cpp

@@ -31 +31 @@
 #include <iprt/cdefs.h>
 #include <iprt/types.h>
+#include <iprt/asm.h>
+#include <iprt/string.h>
 
 #ifndef RT_ARCH_X86
@@ -41 +43 @@
 #define HeapSetInformation                      Ignore_HeapSetInformation
 #define HeapQueryInformation                    Ignore_HeapQueryInformation
+#define CreateTimerQueue                        Ignore_CreateTimerQueue
+#define CreateTimerQueueTimer                   Ignore_CreateTimerQueueTimer
+#define DeleteTimerQueueTimer                   Ignore_DeleteTimerQueueTimer
+#define InitializeSListHead                     Ignore_InitializeSListHead
+#define InterlockedFlushSList                   Ignore_InterlockedFlushSList
+#define InterlockedPopEntrySList                Ignore_InterlockedPopEntrySList
+#define InterlockedPushEntrySList               Ignore_InterlockedPushEntrySList
+#define QueryDepthSList                         Ignore_QueryDepthSList
+#define VerifyVersionInfoA                      Ignore_VerifyVersionInfoA
+#define VerSetConditionMask                     Ignore_VerSetConditionMask
+
 #include <Windows.h>
+
 #undef DecodePointer
 #undef EncodePointer
@@ -47 +61 @@
 #undef HeapSetInformation
 #undef HeapQueryInformation
+#undef CreateTimerQueue
+#undef CreateTimerQueueTimer
+#undef DeleteTimerQueueTimer
+#undef InitializeSListHead
+#undef InterlockedFlushSList
+#undef InterlockedPopEntrySList
+#undef InterlockedPushEntrySList
+#undef QueryDepthSList
+#undef VerifyVersionInfoA
+#undef VerSetConditionMask
 
 
@@ -54 +78 @@
 
 
-/** @todo Try dynamically resolve the functions the first time one of them is
- *        called. */
+/** Dynamically resolves an kernel32 API.   */
+#define RESOLVE_ME(ApiNm) \
+    static bool volatile    s_fInitialized = false; \
+    static decltype(ApiNm) *s_pfnApi = NULL; \
+    decltype(ApiNm)        *pfnApi; \
+    if (!s_fInitialized) \
+        pfnApi = s_pfnApi; \
+    else \
+    { \
+        pfnApi = (decltype(pfnApi))GetProcAddress(GetModuleHandleW(L"kernel32"), #ApiNm); \
+        s_pfnApi = pfnApi; \
+        s_fInitialized = true; \
+    } do {} while (0) \
+
 
 extern "C"
@@ -61 +97 @@
 DecodePointer(PVOID pvEncoded)
 {
+    RESOLVE_ME(DecodePointer);
+    if (pfnApi)
+        return pfnApi(pvEncoded);
+
     /*
      * Fallback code.
@@ -72 +112 @@
 EncodePointer(PVOID pvNative)
 {
+    RESOLVE_ME(EncodePointer);
+    if (pfnApi)
+        return pfnApi(pvNative);
+
     /*
      * Fallback code.
@@ -83 +127 @@
 InitializeCriticalSectionAndSpinCount(LPCRITICAL_SECTION pCritSect, DWORD cSpin)
 {
+    RESOLVE_ME(InitializeCriticalSectionAndSpinCount);
+    if (pfnApi)
+        return pfnApi(pCritSect, cSpin);
 
     /*
@@ -96 +143 @@
 HeapSetInformation(HANDLE hHeap, HEAP_INFORMATION_CLASS enmInfoClass, PVOID pvBuf, SIZE_T cbBuf)
 {
+    RESOLVE_ME(HeapSetInformation);
+    if (pfnApi)
+        return pfnApi(hHeap, enmInfoClass, pvBuf, cbBuf);
+
     /*
      * Fallback code.
@@ -121 +172 @@
 HeapQueryInformation(HANDLE hHeap, HEAP_INFORMATION_CLASS enmInfoClass, PVOID pvBuf, SIZE_T cbBuf, PSIZE_T pcbRet)
 {
+    RESOLVE_ME(HeapQueryInformation);
+    if (pfnApi)
+        return pfnApi(hHeap, enmInfoClass, pvBuf, cbBuf, pcbRet);
 
     /*
@@ -142 +196 @@
 
 
+/* These are used by INTEL\mt_obj\Timer.obj: */
+
+extern "C"
+__declspec(dllexport)
+HANDLE WINAPI CreateTimerQueue(void)
+{
+    RESOLVE_ME(CreateTimerQueue);
+    if (pfnApi)
+        return pfnApi();
+    SetLastError(ERROR_NOT_SUPPORTED);
+    return NULL;
+}
+
+extern "C"
+__declspec(dllexport)
+BOOL WINAPI CreateTimerQueueTimer(PHANDLE phTimer, HANDLE hTimerQueue, WAITORTIMERCALLBACK pfnCallback, PVOID pvUser,
+                                  DWORD msDueTime, DWORD msPeriod, ULONG fFlags)
+{
+    RESOLVE_ME(CreateTimerQueueTimer);
+    if (pfnApi)
+        return pfnApi(phTimer, hTimerQueue, pfnCallback, pvUser, msDueTime, msPeriod, fFlags);
+    SetLastError(ERROR_NOT_SUPPORTED);
+    return FALSE;
+}
+
+extern "C"
+__declspec(dllexport)
+BOOL WINAPI DeleteTimerQueueTimer(HANDLE hTimerQueue, HANDLE hTimer, HANDLE hEvtCompletion)
+{
+    RESOLVE_ME(DeleteTimerQueueTimer);
+    if (pfnApi)
+        return pfnApi(hTimerQueue, hTimer, hEvtCompletion);
+    SetLastError(ERROR_NOT_SUPPORTED);
+    return FALSE;
+}
+
+/* This is used by several APIs. */
+
+extern "C"
+__declspec(dllexport)
+VOID WINAPI InitializeSListHead(PSLIST_HEADER pHead)
+{
+    RESOLVE_ME(InitializeSListHead);
+    if (pfnApi)
+        pfnApi(pHead);
+    else /* fallback: */
+        pHead->Alignment = 0;
+}
+
+
+extern "C"
+__declspec(dllexport)
+PSLIST_ENTRY WINAPI InterlockedFlushSList(PSLIST_HEADER pHead)
+{
+    RESOLVE_ME(InterlockedFlushSList);
+    if (pfnApi)
+        return pfnApi(pHead);
+
+    /* fallback: */
+    PSLIST_ENTRY pRet = NULL;
+    if (pHead->Next.Next)
+    {
+        for (;;)
+        {
+            SLIST_HEADER OldHead = *pHead;
+            SLIST_HEADER NewHead;
+            NewHead.Alignment = 0;
+            NewHead.Sequence  = OldHead.Sequence + 1;
+            if (ASMAtomicCmpXchgU64(&pHead->Alignment, NewHead.Alignment, OldHead.Alignment))
+            {
+                pRet = OldHead.Next.Next;
+                break;
+            }
+        }
+    }
+    return pRet;
+}
+
+extern "C"
+__declspec(dllexport)
+PSLIST_ENTRY WINAPI InterlockedPopEntrySList(PSLIST_HEADER pHead)
+{
+    RESOLVE_ME(InterlockedPopEntrySList);
+    if (pfnApi)
+        return pfnApi(pHead);
+
+    /* fallback: */
+    PSLIST_ENTRY pRet = NULL;
+    for (;;)
+    {
+        SLIST_HEADER OldHead = *pHead;
+        pRet = OldHead.Next.Next;
+        if (pRet)
+        {
+            SLIST_HEADER NewHead;
+            __try
+            {
+                NewHead.Next.Next = pRet->Next;
+            }
+            __except(EXCEPTION_EXECUTE_HANDLER)
+            {
+                continue;
+            }
+            NewHead.Depth     = OldHead.Depth - 1;
+            NewHead.Sequence  = OldHead.Sequence + 1;
+            if (ASMAtomicCmpXchgU64(&pHead->Alignment, NewHead.Alignment, OldHead.Alignment))
+                break;
+        }
+        else
+            break;
+    }
+    return pRet;
+}
+
+extern "C"
+__declspec(dllexport)
+PSLIST_ENTRY WINAPI InterlockedPushEntrySList(PSLIST_HEADER pHead, PSLIST_ENTRY pEntry)
+{
+    RESOLVE_ME(InterlockedPushEntrySList);
+    if (pfnApi)
+        return pfnApi(pHead, pEntry);
+
+    /* fallback: */
+    PSLIST_ENTRY pRet = NULL;
+    for (;;)
+    {
+        SLIST_HEADER OldHead = *pHead;
+        pRet = OldHead.Next.Next;
+        pEntry->Next = pRet;
+        SLIST_HEADER NewHead;
+        NewHead.Next.Next = pEntry;
+        NewHead.Depth     = OldHead.Depth + 1;
+        NewHead.Sequence  = OldHead.Sequence + 1;
+        if (ASMAtomicCmpXchgU64(&pHead->Alignment, NewHead.Alignment, OldHead.Alignment))
+            break;
+    }
+    return pRet;
+}
+
+extern "C"
+__declspec(dllexport)
+WORD WINAPI QueryDepthSList(PSLIST_HEADER pHead)
+{
+    RESOLVE_ME(QueryDepthSList);
+    if (pfnApi)
+        return pfnApi(pHead);
+    return pHead->Depth;
+}
+
+
+/* curl drags these in: */
+extern "C"
+__declspec(dllexport)
+BOOL WINAPI VerifyVersionInfoA(LPOSVERSIONINFOEXA pInfo, DWORD fTypeMask, DWORDLONG fConditionMask)
+{
+    RESOLVE_ME(VerifyVersionInfoA);
+    if (pfnApi)
+        return pfnApi(pInfo, fTypeMask, fConditionMask);
+
+    /* fallback to make curl happy: */
+    OSVERSIONINFOEXA VerInfo;
+    RT_ZERO(VerInfo);
+    VerInfo.dwOSVersionInfoSize = sizeof(VerInfo);
+    if (!GetVersionEx((OSVERSIONINFO *)&VerInfo))
+    {
+        RT_ZERO(VerInfo);
+        VerInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
+        AssertReturn(GetVersionEx((OSVERSIONINFO *)&VerInfo), FALSE);
+    }
+
+    BOOL fRet = TRUE;
+    for (unsigned i = 0; i < 8 && fRet; i++)
+        if (fTypeMask & RT_BIT_32(i))
+        {
+            uint32_t uLeft, uRight;
+            switch (RT_BIT_32(i))
+            {
+#define MY_CASE(a_Num, a_Member) case a_Num: uLeft = VerInfo.a_Member; uRight = pInfo->a_Member; break
+                MY_CASE(VER_MINORVERSION,       dwMinorVersion);
+                MY_CASE(VER_MAJORVERSION,       dwMajorVersion);
+                MY_CASE(VER_BUILDNUMBER,        dwBuildNumber);
+                MY_CASE(VER_PLATFORMID,         dwPlatformId);
+                MY_CASE(VER_SERVICEPACKMINOR,   wServicePackMinor);
+                MY_CASE(VER_SERVICEPACKMAJOR,   wServicePackMinor);
+                MY_CASE(VER_SUITENAME,          wSuiteMask);
+                MY_CASE(VER_PRODUCT_TYPE,       wProductType);
+#undef  MY_CASE
+                default: uLeft = uRight = 0; AssertFailed();
+            }
+            switch ((uint8_t)(fConditionMask >> (i*8)))
+            {
+                case VER_EQUAL:             fRet = uLeft == uRight; break;
+                case VER_GREATER:           fRet = uLeft >  uRight; break;
+                case VER_GREATER_EQUAL:     fRet = uLeft >= uRight; break;
+                case VER_LESS:              fRet = uLeft <  uRight; break;
+                case VER_LESS_EQUAL:        fRet = uLeft <= uRight; break;
+                case VER_AND:               fRet = (uLeft & uRight) == uRight; break;
+                case VER_OR:                fRet = (uLeft & uRight) != 0; break;
+                default:                    fRet = FALSE; AssertFailed(); break;
+            }
+        }
+
+    return fRet;
+}
+
+extern "C"
+__declspec(dllexport)
+ULONGLONG WINAPI VerSetConditionMask(ULONGLONG fConditionMask, DWORD fTypeMask, BYTE bOperator)
+{
+    RESOLVE_ME(VerSetConditionMask);
+    if (pfnApi)
+        return pfnApi(fConditionMask, fTypeMask, bOperator);
+
+    /* fallback: */
+    for (unsigned i = 0; i < 8; i++)
+        if (fTypeMask & RT_BIT_32(i))
+        {
+            uint64_t fMask  = 0xff << (i*8);
+            fConditionMask &= ~fMask;
+            fConditionMask |= (uint64_t)bOperator << (i*8);
+
+        }
+    return fConditionMask;
+}
+
+
+
+/* Dummy to force dragging in this object in the link, so the linker
+   won't accidentally use the symbols from kernel32. */
 extern "C" int vcc100_kernel32_fakes_cpp(void)
 {