VirtualBox

Changeset 57905 in vbox


Ignore:
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.

Location:
trunk/src/VBox/Runtime
Files:
4 added
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Runtime/Makefile.kmk

    r57865 r57905  
    13021302RuntimeGuestR3_SOURCES.win.x86               += \
    13031303        r3/win/vcc100-kernel32-fakes.cpp \
    1304         r3/win/vcc100-kernel32-fakesA.asm
     1304        r3/win/vcc100-kernel32-fakesA.asm \
     1305        r3/win/vcc100-ntdll-fakes.cpp \
     1306        r3/win/vcc100-ntdll-fakesA.asm \
     1307        r3/win/vcc100-ws2_32-fakes.cpp \
     1308        r3/win/vcc100-ws2_32-fakesA.asm
    13051309
    13061310#
    … …  
    14811485        r3/win/vcc100-kernel32-fakes.cpp \
    14821486        r3/win/vcc100-kernel32-fakesA.asm \
     1487        r3/win/vcc100-ws2_32-fakes.cpp \
     1488        r3/win/vcc100-ws2_32-fakesA.asm \
     1489        r3/win/vcc100-ntdll-fakes.cpp \
     1490        r3/win/vcc100-ntdll-fakesA.asm \
    14831491        r3/win/vcc100-msvcrt-fakes.cpp
    14841492 VBoxRT_TEMPLATE         = VBoxR3RuntimeDllItself

  • trunk/src/VBox/Runtime/generic/http-curl.cpp

    r57815 r57905  
    6363#ifdef RT_OS_WINDOWS
    6464# include <Winhttp.h>
     65# include "../r3/win/internal-r3-win.h"
    6566#endif
    6667
    … …  
    13371338static DECLCALLBACK(int) rtHttpWinResolveImports(void *pvUser)
    13381339{
     1340    /*
     1341     * winhttp.dll is not present on NT4 and probably was first introduced with XP.
     1342     */
    13391343    RTLDRMOD hMod;
    13401344    int rc = RTLdrLoadSystem("winhttp.dll", true /*fNoUnload*/, &hMod);
    … …  
    13511355            rc = RTLdrGetSymbol(hMod, "WinHttpGetIEProxyConfigForCurrentUser", (void **)&g_pfnWinHttpGetIEProxyConfigForCurrentUser);
    13521356        RTLdrClose(hMod);
    1353     }
    1354     AssertRC(rc);
     1357        AssertRC(rc);
     1358    }
     1359    else
     1360        AssertMsg(g_enmWinVer < kRTWinOSType_XP, ("%Rrc\n", rc));
    13551361
    13561362    NOREF(pvUser);

  • trunk/src/VBox/Runtime/r3/win/RTSystemQueryTotalRam-win.cpp

    r57358 r57905  
    3737#include <iprt/string.h>
    3838
     39#include "internal-r3-win.h"
     40
     41
     42/*********************************************************************************************************************************
     43*   Global Variables                                                                                                             *
     44*********************************************************************************************************************************/
     45static bool volatile            g_fInitialized = false;
     46typedef BOOL (WINAPI *PFNGLOBALMEMORYSTATUSEX)(LPMEMORYSTATUSEX);
     47static PFNGLOBALMEMORYSTATUSEX  g_pfnGlobalMemoryStatusEx = NULL;
     48
     49
     50/**
     51 * The GlobalMemoryStatusEx API is not available on older Windows version.
     52 *
     53 * @returns Pointer to GlobalMemoryStatusEx or NULL if not available.
     54 */
     55DECLINLINE(PFNGLOBALMEMORYSTATUSEX) rtSystemWinGetExApi(void)
     56{
     57    PFNGLOBALMEMORYSTATUSEX pfnEx;
     58    if (g_fInitialized)
     59        pfnEx = g_pfnGlobalMemoryStatusEx;
     60    else
     61    {
     62        pfnEx = (PFNGLOBALMEMORYSTATUSEX)GetProcAddress(g_hModKernel32, "GlobalMemoryStatusEx");
     63        g_pfnGlobalMemoryStatusEx = pfnEx;
     64        g_fInitialized = true;
     65    }
     66    return pfnEx;
     67}
     68
    3969
    4070RTDECL(int) RTSystemQueryTotalRam(uint64_t *pcb)
    4171{
    42     MEMORYSTATUSEX MemStatus;
    43 
    4472    AssertPtrReturn(pcb, VERR_INVALID_POINTER);
    4573
    46     MemStatus.dwLength = sizeof(MemStatus);
    47     if (!GlobalMemoryStatusEx(&MemStatus))
    48         return RTErrConvertFromWin32(GetLastError());
    49 
    50     *pcb = MemStatus.ullTotalPhys;
    51     return VINF_SUCCESS;
     74    int rc = VINF_SUCCESS;
     75    PFNGLOBALMEMORYSTATUSEX pfnGlobalMemoryStatusEx = rtSystemWinGetExApi();
     76    if (pfnGlobalMemoryStatusEx)
     77    {
     78        MEMORYSTATUSEX MemStatus;
     79        MemStatus.dwLength = sizeof(MemStatus);
     80        if (pfnGlobalMemoryStatusEx(&MemStatus))
     81            *pcb = MemStatus.ullTotalPhys;
     82        else
     83            rc = RTErrConvertFromWin32(GetLastError());
     84    }
     85    else
     86    {
     87        MEMORYSTATUS MemStatus;
     88        RT_ZERO(MemStatus);
     89        MemStatus.dwLength = sizeof(MemStatus);
     90        GlobalMemoryStatus(&MemStatus);
     91        *pcb = MemStatus.dwTotalPhys;
     92    }
     93    return rc;
    5294}
    5395
    … …  
    5597RTDECL(int) RTSystemQueryAvailableRam(uint64_t *pcb)
    5698{
    57     MEMORYSTATUSEX MemStatus;
    58 
    5999    AssertPtrReturn(pcb, VERR_INVALID_POINTER);
    60100
    61     MemStatus.dwLength = sizeof(MemStatus);
    62     if (!GlobalMemoryStatusEx(&MemStatus))
    63         return RTErrConvertFromWin32(GetLastError());
    64 
    65     *pcb = MemStatus.ullAvailPhys;
    66     return VINF_SUCCESS;
     101    int rc = VINF_SUCCESS;
     102    PFNGLOBALMEMORYSTATUSEX pfnGlobalMemoryStatusEx = rtSystemWinGetExApi();
     103    if (pfnGlobalMemoryStatusEx)
     104    {
     105        MEMORYSTATUSEX MemStatus;
     106        MemStatus.dwLength = sizeof(MemStatus);
     107        if (pfnGlobalMemoryStatusEx(&MemStatus))
     108            *pcb = MemStatus.ullAvailPhys;
     109        else
     110            rc = RTErrConvertFromWin32(GetLastError());
     111    }
     112    else
     113    {
     114        MEMORYSTATUS MemStatus;
     115        RT_ZERO(MemStatus);
     116        MemStatus.dwLength = sizeof(MemStatus);
     117        GlobalMemoryStatus(&MemStatus);
     118        *pcb = MemStatus.dwAvailPhys;
     119    }
     120    return rc;
    67121}

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

    r57865 r57905  
    3131#include <iprt/cdefs.h>
    3232#include <iprt/types.h>
     33#include <iprt/asm.h>
     34#include <iprt/string.h>
    3335
    3436#ifndef RT_ARCH_X86
    … …  
    4143#define HeapSetInformation                      Ignore_HeapSetInformation
    4244#define HeapQueryInformation                    Ignore_HeapQueryInformation
     45#define CreateTimerQueue                        Ignore_CreateTimerQueue
     46#define CreateTimerQueueTimer                   Ignore_CreateTimerQueueTimer
     47#define DeleteTimerQueueTimer                   Ignore_DeleteTimerQueueTimer
     48#define InitializeSListHead                     Ignore_InitializeSListHead
     49#define InterlockedFlushSList                   Ignore_InterlockedFlushSList
     50#define InterlockedPopEntrySList                Ignore_InterlockedPopEntrySList
     51#define InterlockedPushEntrySList               Ignore_InterlockedPushEntrySList
     52#define QueryDepthSList                         Ignore_QueryDepthSList
     53#define VerifyVersionInfoA                      Ignore_VerifyVersionInfoA
     54#define VerSetConditionMask                     Ignore_VerSetConditionMask
     55
    4356#include <Windows.h>
     57
    4458#undef DecodePointer
    4559#undef EncodePointer
    … …  
    4761#undef HeapSetInformation
    4862#undef HeapQueryInformation
     63#undef CreateTimerQueue
     64#undef CreateTimerQueueTimer
     65#undef DeleteTimerQueueTimer
     66#undef InitializeSListHead
     67#undef InterlockedFlushSList
     68#undef InterlockedPopEntrySList
     69#undef InterlockedPushEntrySList
     70#undef QueryDepthSList
     71#undef VerifyVersionInfoA
     72#undef VerSetConditionMask
    4973
    5074
    … …  
    5478
    5579
    56 /** @todo Try dynamically resolve the functions the first time one of them is
    57  *        called. */
     80/** Dynamically resolves an kernel32 API.   */
     81#define RESOLVE_ME(ApiNm) \
     82    static bool volatile    s_fInitialized = false; \
     83    static decltype(ApiNm) *s_pfnApi = NULL; \
     84    decltype(ApiNm)        *pfnApi; \
     85    if (!s_fInitialized) \
     86        pfnApi = s_pfnApi; \
     87    else \
     88    { \
     89        pfnApi = (decltype(pfnApi))GetProcAddress(GetModuleHandleW(L"kernel32"), #ApiNm); \
     90        s_pfnApi = pfnApi; \
     91        s_fInitialized = true; \
     92    } do {} while (0) \
     93
    5894
    5995extern "C"
    … …  
    6197DecodePointer(PVOID pvEncoded)
    6298{
     99    RESOLVE_ME(DecodePointer);
     100    if (pfnApi)
     101        return pfnApi(pvEncoded);
     102
    63103    /*
    64104     * Fallback code.
    … …  
    72112EncodePointer(PVOID pvNative)
    73113{
     114    RESOLVE_ME(EncodePointer);
     115    if (pfnApi)
     116        return pfnApi(pvNative);
     117
    74118    /*
    75119     * Fallback code.
    … …  
    83127InitializeCriticalSectionAndSpinCount(LPCRITICAL_SECTION pCritSect, DWORD cSpin)
    84128{
     129    RESOLVE_ME(InitializeCriticalSectionAndSpinCount);
     130    if (pfnApi)
     131        return pfnApi(pCritSect, cSpin);
    85132
    86133    /*
    … …  
    96143HeapSetInformation(HANDLE hHeap, HEAP_INFORMATION_CLASS enmInfoClass, PVOID pvBuf, SIZE_T cbBuf)
    97144{
     145    RESOLVE_ME(HeapSetInformation);
     146    if (pfnApi)
     147        return pfnApi(hHeap, enmInfoClass, pvBuf, cbBuf);
     148
    98149    /*
    99150     * Fallback code.
    … …  
    121172HeapQueryInformation(HANDLE hHeap, HEAP_INFORMATION_CLASS enmInfoClass, PVOID pvBuf, SIZE_T cbBuf, PSIZE_T pcbRet)
    122173{
     174    RESOLVE_ME(HeapQueryInformation);
     175    if (pfnApi)
     176        return pfnApi(hHeap, enmInfoClass, pvBuf, cbBuf, pcbRet);
    123177
    124178    /*
    … …  
    142196
    143197
     198/* These are used by INTEL\mt_obj\Timer.obj: */
     199
     200extern "C"
     201__declspec(dllexport)
     202HANDLE WINAPI CreateTimerQueue(void)
     203{
     204    RESOLVE_ME(CreateTimerQueue);
     205    if (pfnApi)
     206        return pfnApi();
     207    SetLastError(ERROR_NOT_SUPPORTED);
     208    return NULL;
     209}
     210
     211extern "C"
     212__declspec(dllexport)
     213BOOL WINAPI CreateTimerQueueTimer(PHANDLE phTimer, HANDLE hTimerQueue, WAITORTIMERCALLBACK pfnCallback, PVOID pvUser,
     214                                  DWORD msDueTime, DWORD msPeriod, ULONG fFlags)
     215{
     216    RESOLVE_ME(CreateTimerQueueTimer);
     217    if (pfnApi)
     218        return pfnApi(phTimer, hTimerQueue, pfnCallback, pvUser, msDueTime, msPeriod, fFlags);
     219    SetLastError(ERROR_NOT_SUPPORTED);
     220    return FALSE;
     221}
     222
     223extern "C"
     224__declspec(dllexport)
     225BOOL WINAPI DeleteTimerQueueTimer(HANDLE hTimerQueue, HANDLE hTimer, HANDLE hEvtCompletion)
     226{
     227    RESOLVE_ME(DeleteTimerQueueTimer);
     228    if (pfnApi)
     229        return pfnApi(hTimerQueue, hTimer, hEvtCompletion);
     230    SetLastError(ERROR_NOT_SUPPORTED);
     231    return FALSE;
     232}
     233
     234/* This is used by several APIs. */
     235
     236extern "C"
     237__declspec(dllexport)
     238VOID WINAPI InitializeSListHead(PSLIST_HEADER pHead)
     239{
     240    RESOLVE_ME(InitializeSListHead);
     241    if (pfnApi)
     242        pfnApi(pHead);
     243    else /* fallback: */
     244        pHead->Alignment = 0;
     245}
     246
     247
     248extern "C"
     249__declspec(dllexport)
     250PSLIST_ENTRY WINAPI InterlockedFlushSList(PSLIST_HEADER pHead)
     251{
     252    RESOLVE_ME(InterlockedFlushSList);
     253    if (pfnApi)
     254        return pfnApi(pHead);
     255
     256    /* fallback: */
     257    PSLIST_ENTRY pRet = NULL;
     258    if (pHead->Next.Next)
     259    {
     260        for (;;)
     261        {
     262            SLIST_HEADER OldHead = *pHead;
     263            SLIST_HEADER NewHead;
     264            NewHead.Alignment = 0;
     265            NewHead.Sequence  = OldHead.Sequence + 1;
     266            if (ASMAtomicCmpXchgU64(&pHead->Alignment, NewHead.Alignment, OldHead.Alignment))
     267            {
     268                pRet = OldHead.Next.Next;
     269                break;
     270            }
     271        }
     272    }
     273    return pRet;
     274}
     275
     276extern "C"
     277__declspec(dllexport)
     278PSLIST_ENTRY WINAPI InterlockedPopEntrySList(PSLIST_HEADER pHead)
     279{
     280    RESOLVE_ME(InterlockedPopEntrySList);
     281    if (pfnApi)
     282        return pfnApi(pHead);
     283
     284    /* fallback: */
     285    PSLIST_ENTRY pRet = NULL;
     286    for (;;)
     287    {
     288        SLIST_HEADER OldHead = *pHead;
     289        pRet = OldHead.Next.Next;
     290        if (pRet)
     291        {
     292            SLIST_HEADER NewHead;
     293            __try
     294            {
     295                NewHead.Next.Next = pRet->Next;
     296            }
     297            __except(EXCEPTION_EXECUTE_HANDLER)
     298            {
     299                continue;
     300            }
     301            NewHead.Depth     = OldHead.Depth - 1;
     302            NewHead.Sequence  = OldHead.Sequence + 1;
     303            if (ASMAtomicCmpXchgU64(&pHead->Alignment, NewHead.Alignment, OldHead.Alignment))
     304                break;
     305        }
     306        else
     307            break;
     308    }
     309    return pRet;
     310}
     311
     312extern "C"
     313__declspec(dllexport)
     314PSLIST_ENTRY WINAPI InterlockedPushEntrySList(PSLIST_HEADER pHead, PSLIST_ENTRY pEntry)
     315{
     316    RESOLVE_ME(InterlockedPushEntrySList);
     317    if (pfnApi)
     318        return pfnApi(pHead, pEntry);
     319
     320    /* fallback: */
     321    PSLIST_ENTRY pRet = NULL;
     322    for (;;)
     323    {
     324        SLIST_HEADER OldHead = *pHead;
     325        pRet = OldHead.Next.Next;
     326        pEntry->Next = pRet;
     327        SLIST_HEADER NewHead;
     328        NewHead.Next.Next = pEntry;
     329        NewHead.Depth     = OldHead.Depth + 1;
     330        NewHead.Sequence  = OldHead.Sequence + 1;
     331        if (ASMAtomicCmpXchgU64(&pHead->Alignment, NewHead.Alignment, OldHead.Alignment))
     332            break;
     333    }
     334    return pRet;
     335}
     336
     337extern "C"
     338__declspec(dllexport)
     339WORD WINAPI QueryDepthSList(PSLIST_HEADER pHead)
     340{
     341    RESOLVE_ME(QueryDepthSList);
     342    if (pfnApi)
     343        return pfnApi(pHead);
     344    return pHead->Depth;
     345}
     346
     347
     348/* curl drags these in: */
     349extern "C"
     350__declspec(dllexport)
     351BOOL WINAPI VerifyVersionInfoA(LPOSVERSIONINFOEXA pInfo, DWORD fTypeMask, DWORDLONG fConditionMask)
     352{
     353    RESOLVE_ME(VerifyVersionInfoA);
     354    if (pfnApi)
     355        return pfnApi(pInfo, fTypeMask, fConditionMask);
     356
     357    /* fallback to make curl happy: */
     358    OSVERSIONINFOEXA VerInfo;
     359    RT_ZERO(VerInfo);
     360    VerInfo.dwOSVersionInfoSize = sizeof(VerInfo);
     361    if (!GetVersionEx((OSVERSIONINFO *)&VerInfo))
     362    {
     363        RT_ZERO(VerInfo);
     364        VerInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
     365        AssertReturn(GetVersionEx((OSVERSIONINFO *)&VerInfo), FALSE);
     366    }
     367
     368    BOOL fRet = TRUE;
     369    for (unsigned i = 0; i < 8 && fRet; i++)
     370        if (fTypeMask & RT_BIT_32(i))
     371        {
     372            uint32_t uLeft, uRight;
     373            switch (RT_BIT_32(i))
     374            {
     375#define MY_CASE(a_Num, a_Member) case a_Num: uLeft = VerInfo.a_Member; uRight = pInfo->a_Member; break
     376                MY_CASE(VER_MINORVERSION,       dwMinorVersion);
     377                MY_CASE(VER_MAJORVERSION,       dwMajorVersion);
     378                MY_CASE(VER_BUILDNUMBER,        dwBuildNumber);
     379                MY_CASE(VER_PLATFORMID,         dwPlatformId);
     380                MY_CASE(VER_SERVICEPACKMINOR,   wServicePackMinor);
     381                MY_CASE(VER_SERVICEPACKMAJOR,   wServicePackMinor);
     382                MY_CASE(VER_SUITENAME,          wSuiteMask);
     383                MY_CASE(VER_PRODUCT_TYPE,       wProductType);
     384#undef  MY_CASE
     385                default: uLeft = uRight = 0; AssertFailed();
     386            }
     387            switch ((uint8_t)(fConditionMask >> (i*8)))
     388            {
     389                case VER_EQUAL:             fRet = uLeft == uRight; break;
     390                case VER_GREATER:           fRet = uLeft >  uRight; break;
     391                case VER_GREATER_EQUAL:     fRet = uLeft >= uRight; break;
     392                case VER_LESS:              fRet = uLeft <  uRight; break;
     393                case VER_LESS_EQUAL:        fRet = uLeft <= uRight; break;
     394                case VER_AND:               fRet = (uLeft & uRight) == uRight; break;
     395                case VER_OR:                fRet = (uLeft & uRight) != 0; break;
     396                default:                    fRet = FALSE; AssertFailed(); break;
     397            }
     398        }
     399
     400    return fRet;
     401}
     402
     403extern "C"
     404__declspec(dllexport)
     405ULONGLONG WINAPI VerSetConditionMask(ULONGLONG fConditionMask, DWORD fTypeMask, BYTE bOperator)
     406{
     407    RESOLVE_ME(VerSetConditionMask);
     408    if (pfnApi)
     409        return pfnApi(fConditionMask, fTypeMask, bOperator);
     410
     411    /* fallback: */
     412    for (unsigned i = 0; i < 8; i++)
     413        if (fTypeMask & RT_BIT_32(i))
     414        {
     415            uint64_t fMask  = 0xff << (i*8);
     416            fConditionMask &= ~fMask;
     417            fConditionMask |= (uint64_t)bOperator << (i*8);
     418
     419        }
     420    return fConditionMask;
     421}
     422
     423
     424
     425/* Dummy to force dragging in this object in the link, so the linker
     426   won't accidentally use the symbols from kernel32. */
    144427extern "C" int vcc100_kernel32_fakes_cpp(void)
    145428{

  • trunk/src/VBox/Runtime/r3/win/vcc100-kernel32-fakesA.asm

    r57865 r57905  
    2525MAKE_IMPORT_ENTRY HeapSetInformation, 16
    2626MAKE_IMPORT_ENTRY HeapQueryInformation, 20
     27MAKE_IMPORT_ENTRY CreateTimerQueue, 0
     28MAKE_IMPORT_ENTRY CreateTimerQueueTimer, 28
     29MAKE_IMPORT_ENTRY DeleteTimerQueueTimer, 12
     30MAKE_IMPORT_ENTRY InitializeSListHead, 4
     31MAKE_IMPORT_ENTRY InterlockedFlushSList, 4
     32MAKE_IMPORT_ENTRY InterlockedPopEntrySList, 4
     33MAKE_IMPORT_ENTRY InterlockedPushEntrySList, 8
     34MAKE_IMPORT_ENTRY QueryDepthSList, 4
     35MAKE_IMPORT_ENTRY VerifyVersionInfoA, 16
     36MAKE_IMPORT_ENTRY VerSetConditionMask, 16
    2737
    2838
     39
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