VirtualBox

Changeset 33269 in vbox


Ignore:
Timestamp:
Oct 20, 2010 3:42:28 PM (14 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
66829
Message:

IPRT: A quick replacement of the RTMemPage* and RTMemExec* APIs on posix. (Turned out to be a bit more work than expected because of the electric fence heap and init dependencies.)

Location:
trunk
Files:
3 added
28 edited
1 moved

Legend:

Unmodified
Added
Removed

  • trunk/Config.kmk

    r33143 r33269  
    40084008TEMPLATE_VBOXGUESTR3XORGMOD_LIBS.$(KBUILD_TARGET)   = $(NO_SUCH_VARIABLE)
    40094009TEMPLATE_VBOXGUESTR3XORGMOD_CFLAGS                  = $(TEMPLATE_VBOXGUESTR3DLL_CFLAGS) -std=c99
    4010 TEMPLATE_VBOXGUESTR3XORGMOD_DEFS = $(TEMPLATE_VBOXGUESTR3DLL_DEFS) LOG_TO_BACKDOOR VBOX_GUESTR3XORGMOD
     4010TEMPLATE_VBOXGUESTR3XORGMOD_DEFS = $(TEMPLATE_VBOXGUESTR3DLL_DEFS) LOG_TO_BACKDOOR VBOX_GUESTR3XORGMOD RTMEM_NO_WRAP_TO_EF_APIS
    40114011ifeq ($(KBUILD_TARGET_ARCH),amd64)
    40124012 TEMPLATE_VBOXGUESTR3XORGMOD_DEFS += _XSERVER64

  • trunk/include/iprt/critsect.h

    r31155 r33269  
    100100/** Disables lock validation. */
    101101#define RTCRITSECT_FLAGS_NO_LOCK_VAL    UINT32_C(0x00000002)
     102/** Bootstrap hack for use with certain memory allocator locks only! */
     103#define RTCRITSECT_FLAGS_BOOTSTRAP_HACK UINT32_C(0x00000004)
    102104/** @} */
    103105

  • trunk/include/iprt/mem.h

    r32707 r33269  
    380380 *
    381381 * @param   pv      Pointer to memory block.
    382  */
    383 RTDECL(void)    RTMemExecFree(void *pv) RT_NO_THROW;
     382 * @param   cb      The allocation size.
     383 */
     384RTDECL(void)    RTMemExecFree(void *pv, size_t cb) RT_NO_THROW;
    384385
    385386#if defined(IN_RING0) && defined(RT_ARCH_AMD64) && defined(RT_OS_LINUX)

  • trunk/include/iprt/semaphore.h

    r33155 r33269  
    137137/** Disables lock validation. */
    138138#define RTSEMEVENT_FLAGS_NO_LOCK_VAL    UINT32_C(0x00000001)
     139/** Bootstrap hack for use with certain memory allocator locks only! */
     140#define RTSEMEVENT_FLAGS_BOOTSTRAP_HACK UINT32_C(0x00000004)
    139141/** @} */
    140142

  • trunk/src/VBox/Devices/Network/SrvIntNetR0.cpp

    r31323 r33269  
    51785178                if (!((pCur->fFlags ^ fFlags) & INTNET_OPEN_FLAGS_COMPATIBILITY_XOR_MASK))
    51795179                {
    5180 
    51815180                    /*
    51825181                     * Increment the reference and check that the session

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

    r33167 r33269  
    45424542    pImage->pNext  = 0;
    45434543    pImage->uState = SUP_IOCTL_LDR_FREE;
    4544     RTMemExecFree(pImage->pvImageAlloc);
     4544    RTMemExecFree(pImage->pvImageAlloc, pImage->cbImageBits + 31);
    45454545    pImage->pvImageAlloc = NULL;
    45464546    RTMemFree(pImage->pachStrTab);

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

    r33246 r33269  
    352352        common/table/avlroioport.cpp \
    353353        common/table/avlroogcptr.cpp \
     354        common/table/avlrpv.cpp \
    354355        common/table/avlruintptr.cpp \
    355356        common/table/avlrfoff.cpp \
    … …  
    523524        r3/linux/RTSystemQueryDmiString-linux.cpp \
    524525        r3/posix/RTFileQueryFsSizes-posix.cpp \
     526        r3/posix/RTMemProtect-posix.cpp \
    525527        r3/posix/RTSystemQueryOSInfo-posix.cpp \
    526         r3/posix/alloc-posix.cpp \
     528        r3/posix/RTTimeNow-posix.cpp \
     529        r3/posix/RTTimeSet-posix.cpp \
     530        r3/posix/rtmempage-exec-mmap-heap-posix.cpp \
    527531        r3/posix/dir-posix.cpp \
    528532        r3/posix/env-posix.cpp \
    … …  
    537541        r3/posix/process-posix.cpp \
    538542        r3/posix/rand-posix.cpp \
    539         r3/posix/RTTimeNow-posix.cpp \
    540         r3/posix/RTTimeSet-posix.cpp \
    541543        r3/posix/semrw-posix.cpp \
    542544        r3/posix/thread-posix.cpp \
    … …  
    603605        r3/os2/time-os2.cpp \
    604606        r3/posix/RTFileQueryFsSizes-posix.cpp \
     607        r3/posix/RTMemProtect-posix.cpp \
    605608        r3/posix/RTSystemQueryOSInfo-posix.cpp \
    606         r3/posix/alloc-posix.cpp \
     609        r3/posix/RTTimeNow-posix.cpp \
     610        r3/posix/RTTimeSet-posix.cpp \
     611        r3/posix/rtmempage-exec-mmap-heap-posix.cpp \
    607612        r3/posix/dir-posix.cpp \
    608613        r3/posix/env-posix.cpp \
    … …  
    613618        r3/posix/pathhost-posix.cpp \
    614619        r3/posix/process-posix.cpp \
    615         r3/posix/RTTimeNow-posix.cpp \
    616         r3/posix/RTTimeSet-posix.cpp \
    617620        r3/posix/timelocal-posix.cpp \
    618621        r3/posix/utf8-posix.cpp
    … …  
    829832        l4/utf8-l4env.cpp \
    830833        r3/posix/RTFileQueryFsSizes-posix.cpp \
    831         r3/posix/alloc-posix.cpp \
     834        r3/posix/RTMemProtect-posix.cpp \
     835        r3/posix/rtmempage-exec-mmap-heap-posix.cpp \
    832836        r3/posix/dir-posix.cpp \
    833837        r3/posix/env-posix.cpp \
    … …  
    949953        common/string/utf-16.cpp \
    950954        common/table/avlpv.cpp \
     955        generic/critsect-generic.cpp \
    951956        generic/pathhost-generic.cpp \
    952957        generic/RTAssertShouldPanic-generic.cpp \
    … …  
    956961        r3/fs.cpp
    957962RuntimeGuestR3Mini_SOURCES.freebsd = \
    958         r3/posix/alloc-posix.cpp \
     963        r3/posix/RTMemProtect-posix.cpp \
     964        r3/posix/rtmempage-exec-mmap-posix.cpp \
    959965        r3/posix/env-posix.cpp \
    960966        r3/posix/fileio-posix.cpp \
    … …  
    962968        r3/posix/utf8-posix.cpp
    963969RuntimeGuestR3Mini_SOURCES.linux = \
    964         r3/posix/alloc-posix.cpp \
     970        r3/posix/RTMemProtect-posix.cpp \
     971        r3/posix/rtmempage-exec-mmap-posix.cpp \
    965972        r3/posix/env-posix.cpp \
    966973        r3/posix/fileio-posix.cpp \
    … …  
    968975        r3/posix/utf8-posix.cpp
    969976RuntimeGuestR3Mini_SOURCES.solaris = \
    970         r3/posix/alloc-posix.cpp \
     977        r3/posix/RTMemProtect-posix.cpp \
     978        r3/posix/rtmempage-exec-mmap-posix.cpp \
    971979        r3/posix/env-posix.cpp \
    972980        r3/posix/fileio-posix.cpp \

  • trunk/src/VBox/Runtime/common/log/log.cpp

    r32355 r33269  
    430430            RTMemFree(*(void **)&pLogger->pfnLogger);
    431431#else
    432             RTMemExecFree(*(void **)&pLogger->pfnLogger);
     432            RTMemExecFree(*(void **)&pLogger->pfnLogger, 64);
    433433#endif
    434434        }
    … …  
    579579        RTMemFree(*(void **)&pLogger->pfnLogger);
    580580#else
    581         RTMemExecFree(*(void **)&pLogger->pfnLogger);
     581        RTMemExecFree(*(void **)&pLogger->pfnLogger, 64);
    582582#endif
    583583        pLogger->pfnLogger = NULL;

  • trunk/src/VBox/Runtime/common/misc/lockvalidator.cpp

    r30112 r33269  
    30593059{
    30603060    PRTLOCKVALRECUNION pRecU = (PRTLOCKVALRECUNION)pRec;
     3061    if (!pRecU)
     3062        return;
    30613063    AssertReturnVoid(pRecU->Core.u32Magic == RTLOCKVALRECEXCL_MAGIC);
    30623064    if (!pRecU->Excl.fEnabled)
    … …  
    31193121{
    31203122    PRTLOCKVALRECUNION pRecU = (PRTLOCKVALRECUNION)pRec;
     3123    if (!pRecU)
     3124        return VINF_SUCCESS;
    31213125    AssertReturn(pRecU->Core.u32Magic == RTLOCKVALRECEXCL_MAGIC, VERR_SEM_LV_INVALID_PARAMETER);
    31223126    if (!pRecU->Excl.fEnabled)
    … …  
    31563160{
    31573161    PRTLOCKVALRECUNION pRecU = (PRTLOCKVALRECUNION)pRec;
     3162    if (!pRecU)
     3163        return VINF_SUCCESS;
    31583164    AssertReturn(pRecU->Core.u32Magic == RTLOCKVALRECEXCL_MAGIC, VERR_SEM_LV_INVALID_PARAMETER);
    31593165    if (!pRecU->Excl.fEnabled)
    … …  
    32843290     */
    32853291    PRTLOCKVALRECUNION pRecU = (PRTLOCKVALRECUNION)pRec;
     3292    if (!pRecU)
     3293        return VINF_SUCCESS;
    32863294    AssertReturn(pRecU->Core.u32Magic == RTLOCKVALRECEXCL_MAGIC, VERR_SEM_LV_INVALID_PARAMETER);
    32873295    if (   !pRecU->Excl.fEnabled
    … …  
    33173325     */
    33183326    PRTLOCKVALRECUNION pRecU = (PRTLOCKVALRECUNION)pRec;
     3327    if (!pRecU)
     3328        return VINF_SUCCESS;
    33193329    AssertPtrReturn(pRecU, VERR_SEM_LV_INVALID_PARAMETER);
    33203330    AssertReturn(pRecU->Core.u32Magic == RTLOCKVALRECEXCL_MAGIC, VERR_SEM_LV_INVALID_PARAMETER);

  • trunk/src/VBox/Runtime/generic/critsect-generic.cpp

    r28800 r33269  
    5252                             const char *pszNameFmt, ...)
    5353{
    54     AssertReturn(fFlags <= (RTCRITSECT_FLAGS_NO_NESTING | RTCRITSECT_FLAGS_NO_LOCK_VAL), VERR_INVALID_PARAMETER);
     54    AssertReturn(!(fFlags & ~(RTCRITSECT_FLAGS_NO_NESTING | RTCRITSECT_FLAGS_NO_LOCK_VAL | RTCRITSECT_FLAGS_BOOTSTRAP_HACK)),
     55                 VERR_INVALID_PARAMETER);
    5556
    5657    /*
    … …  
    6566    int rc = VINF_SUCCESS;
    6667#ifdef RTCRITSECT_STRICT
    67     if (!pszNameFmt)
    68     {
    69         static uint32_t volatile s_iCritSectAnon = 0;
    70         rc = RTLockValidatorRecExclCreate(&pCritSect->pValidatorRec, hClass, uSubClass, pCritSect,
    71                                           !(fFlags & RTCRITSECT_FLAGS_NO_LOCK_VAL),
    72                                           "RTCritSect-%u", ASMAtomicIncU32(&s_iCritSectAnon) - 1);
    73     }
    74     else
    75     {
    76         va_list va;
    77         va_start(va, pszNameFmt);
    78         rc = RTLockValidatorRecExclCreateV(&pCritSect->pValidatorRec, hClass, uSubClass, pCritSect,
    79                                            !(fFlags & RTCRITSECT_FLAGS_NO_LOCK_VAL), pszNameFmt, va);
    80         va_end(va);
     68    if (!(fFlags & RTCRITSECT_FLAGS_BOOTSTRAP_HACK))
     69    {
     70        if (!pszNameFmt)
     71        {
     72            static uint32_t volatile s_iCritSectAnon = 0;
     73            rc = RTLockValidatorRecExclCreate(&pCritSect->pValidatorRec, hClass, uSubClass, pCritSect,
     74                                              !(fFlags & RTCRITSECT_FLAGS_NO_LOCK_VAL),
     75                                              "RTCritSect-%u", ASMAtomicIncU32(&s_iCritSectAnon) - 1);
     76        }
     77        else
     78        {
     79            va_list va;
     80            va_start(va, pszNameFmt);
     81            rc = RTLockValidatorRecExclCreateV(&pCritSect->pValidatorRec, hClass, uSubClass, pCritSect,
     82                                               !(fFlags & RTCRITSECT_FLAGS_NO_LOCK_VAL), pszNameFmt, va);
     83            va_end(va);
     84        }
    8185    }
    8286#endif
    8387    if (RT_SUCCESS(rc))
    8488    {
    85         rc = RTSemEventCreate(&pCritSect->EventSem);
     89        rc = RTSemEventCreateEx(&pCritSect->EventSem,
     90                                fFlags & RTCRITSECT_FLAGS_BOOTSTRAP_HACK
     91                                ? RTSEMEVENT_FLAGS_NO_LOCK_VAL | RTSEMEVENT_FLAGS_BOOTSTRAP_HACK
     92                                : RTSEMEVENT_FLAGS_NO_LOCK_VAL,
     93                                NIL_RTLOCKVALCLASS,
     94                                NULL);
    8695        if (RT_SUCCESS(rc))
    8796            return VINF_SUCCESS;
    … …  
    187196
    188197#ifdef RTCRITSECT_STRICT
    189     RTTHREAD        hThreadSelf = RTThreadSelfAutoAdopt();
    190     int rc9 = RTLockValidatorRecExclCheckOrder(pCritSect->pValidatorRec, hThreadSelf, pSrcPos, RT_INDEFINITE_WAIT);
    191     if (RT_FAILURE(rc9))
    192         return rc9;
     198    RTTHREAD hThreadSelf = pCritSect->pValidatorRec
     199                         ? RTThreadSelfAutoAdopt()
     200                         : RTThreadSelf();
     201    int      rc9;
     202    if (pCritSect->pValidatorRec) /* (bootstap) */
     203    {
     204         rc9 = RTLockValidatorRecExclCheckOrder(pCritSect->pValidatorRec, hThreadSelf, pSrcPos, RT_INDEFINITE_WAIT);
     205         if (RT_FAILURE(rc9))
     206             return rc9;
     207    }
    193208#endif
    194209

  • trunk/src/VBox/Runtime/r0drv/alloc-r0drv.cpp

    r32713 r33269  
    303303
    304304
    305 RTDECL(void)      RTMemExecFree(void *pv) RT_NO_THROW
     305RTDECL(void)      RTMemExecFree(void *pv, size_t cb) RT_NO_THROW
    306306{
    307307    PRTMEMHDR pHdr;

  • trunk/src/VBox/Runtime/r0drv/darwin/semevent-r0drv-darwin.cpp

    r33158 r33269  
    9696{
    9797    AssertCompile(sizeof(RTSEMEVENTINTERNAL) > sizeof(void *));
    98     AssertReturn(!(fFlags & ~RTSEMEVENT_FLAGS_NO_LOCK_VAL), VERR_INVALID_PARAMETER);
     98    AssertReturn(!(fFlags & ~(RTSEMEVENT_FLAGS_NO_LOCK_VAL | RTSEMEVENT_FLAGS_BOOTSTRAP_HACK)), VERR_INVALID_PARAMETER);
     99    Assert(!(fFlags & RTSEMEVENT_FLAGS_BOOTSTRAP_HACK) || (fFlags & RTSEMEVENT_FLAGS_NO_LOCK_VAL));
    99100    AssertPtrReturn(phEventSem, VERR_INVALID_POINTER);
    100101    RT_ASSERT_PREEMPTIBLE();

  • trunk/src/VBox/Runtime/r0drv/freebsd/semevent-r0drv-freebsd.c

    r33155 r33269  
    7474{
    7575    AssertCompile(sizeof(RTSEMEVENTINTERNAL) > sizeof(void *));
    76     AssertReturn(!(fFlags & ~RTSEMEVENT_FLAGS_NO_LOCK_VAL), VERR_INVALID_PARAMETER);
     76    AssertReturn(!(fFlags & ~(RTSEMEVENT_FLAGS_NO_LOCK_VAL | RTSEMEVENT_FLAGS_BOOTSTRAP_HACK)), VERR_INVALID_PARAMETER);
     77    Assert(!(fFlags & RTSEMEVENT_FLAGS_BOOTSTRAP_HACK) || (fFlags & RTSEMEVENT_FLAGS_NO_LOCK_VAL));
    7778    AssertPtrReturn(phEventSem, VERR_INVALID_POINTER);
    7879

  • trunk/src/VBox/Runtime/r0drv/linux/semevent-r0drv-linux.c

    r33155 r33269  
    7373    PRTSEMEVENTINTERNAL pThis;
    7474
    75     AssertReturn(!(fFlags & ~RTSEMEVENT_FLAGS_NO_LOCK_VAL), VERR_INVALID_PARAMETER);
     75    AssertReturn(!(fFlags & ~(RTSEMEVENT_FLAGS_NO_LOCK_VAL | RTSEMEVENT_FLAGS_BOOTSTRAP_HACK)), VERR_INVALID_PARAMETER);
     76    Assert(!(fFlags & RTSEMEVENT_FLAGS_BOOTSTRAP_HACK) || (fFlags & RTSEMEVENT_FLAGS_NO_LOCK_VAL));
     77
    7678    pThis = (PRTSEMEVENTINTERNAL)RTMemAlloc(sizeof(*pThis));
    7779    if (!pThis)

  • trunk/src/VBox/Runtime/r0drv/nt/semevent-r0drv-nt.cpp

    r33158 r33269  
    6868RTDECL(int)  RTSemEventCreateEx(PRTSEMEVENT phEventSem, uint32_t fFlags, RTLOCKVALCLASS hClass, const char *pszNameFmt, ...)
    6969{
    70     AssertReturn(!(fFlags & ~RTSEMEVENT_FLAGS_NO_LOCK_VAL), VERR_INVALID_PARAMETER);
     70    AssertReturn(!(fFlags & ~(RTSEMEVENT_FLAGS_NO_LOCK_VAL | RTSEMEVENT_FLAGS_BOOTSTRAP_HACK)), VERR_INVALID_PARAMETER);
     71    Assert(!(fFlags & RTSEMEVENT_FLAGS_BOOTSTRAP_HACK) || (fFlags & RTSEMEVENT_FLAGS_NO_LOCK_VAL));
    7172    AssertCompile(sizeof(RTSEMEVENTINTERNAL) > sizeof(void *));
    7273

  • trunk/src/VBox/Runtime/r0drv/os2/semevent-r0drv-os2.cpp

    r33155 r33269  
    7373RTDECL(int)  RTSemEventCreateEx(PRTSEMEVENT phEventSem, uint32_t fFlags, RTLOCKVALCLASS hClass, const char *pszNameFmt, ...)
    7474{
    75     AssertReturn(!(fFlags & ~RTSEMEVENT_FLAGS_NO_LOCK_VAL), VERR_INVALID_PARAMETER);
     75    AssertReturn(!(fFlags & ~(RTSEMEVENT_FLAGS_NO_LOCK_VAL | RTSEMEVENT_FLAGS_BOOTSTRAP_HACK)), VERR_INVALID_PARAMETER);
     76    Assert(!(fFlags & RTSEMEVENT_FLAGS_BOOTSTRAP_HACK) || (fFlags & RTSEMEVENT_FLAGS_NO_LOCK_VAL));
    7677    AssertCompile(sizeof(RTSEMEVENTINTERNAL) > sizeof(void *));
    7778    AssertPtrReturn(phEventSem, VERR_INVALID_POINTER);

  • trunk/src/VBox/Runtime/r0drv/solaris/semevent-r0drv-solaris.c

    r33155 r33269  
    101101{
    102102    AssertCompile(sizeof(RTSEMEVENTINTERNAL) > sizeof(void *));
    103     AssertReturn(!(fFlags & ~RTSEMEVENT_FLAGS_NO_LOCK_VAL), VERR_INVALID_PARAMETER);
     103    AssertReturn(!(fFlags & ~(RTSEMEVENT_FLAGS_NO_LOCK_VAL | RTSEMEVENT_FLAGS_BOOTSTRAP_HACK)), VERR_INVALID_PARAMETER);
     104    Assert(!(fFlags & RTSEMEVENT_FLAGS_BOOTSTRAP_HACK) || (fFlags & RTSEMEVENT_FLAGS_NO_LOCK_VAL));
    104105    AssertPtrReturn(phEventSem, VERR_INVALID_POINTER);
    105106    RT_ASSERT_PREEMPTIBLE();

  • trunk/src/VBox/Runtime/r3/alloc.cpp

    r32125 r33269  
    3939*******************************************************************************/
    4040#include "alloc-ef.h"
    41 #include <iprt/alloc.h>
     41#include <iprt/mem.h>
     42
    4243#include <iprt/asm.h>
    4344#include <iprt/assert.h>
    … …  
    4748#include <iprt/param.h>
    4849#include <iprt/string.h>
     50#include "internal/mem.h"
    4951
    5052#include <stdlib.h>
    … …  
    218220}
    219221
     222
     223
     224DECLHIDDEN(void *)  rtMemBaseAlloc(size_t cb)
     225{
     226    Assert(cb > 0 && cb < _1M);
     227    return malloc(cb);
     228}
     229
     230
     231DECLHIDDEN(void)    rtMemBaseFree(void *pv)
     232{
     233    free(pv);
     234}
     235

  • trunk/src/VBox/Runtime/r3/darwin/alloc-darwin.cpp

    r31158 r33269  
    6767
    6868
    69 RTDECL(void)    RTMemExecFree(void *pv) RT_NO_THROW
     69RTDECL(void)    RTMemExecFree(void *pv, size_t cb) RT_NO_THROW
    7070{
    7171    if (pv)

  • trunk/src/VBox/Runtime/r3/freebsd/alloc-freebsd.cpp

    r31158 r33269  
    6666
    6767
    68 RTDECL(void)    RTMemExecFree(void *pv) RT_NO_THROW
     68RTDECL(void)    RTMemExecFree(void *pv, size_t cb) RT_NO_THROW
    6969{
    7070    if (pv)

  • trunk/src/VBox/Runtime/r3/linux/semevent-linux.cpp

    r28800 r33269  
    5555#include <iprt/time.h>
    5656#include "internal/magics.h"
     57#include "internal/mem.h"
    5758#include "internal/strict.h"
    5859
    … …  
    9394    bool volatile       fEverHadSignallers;
    9495#endif
     96    /** The creation flags. */
     97    uint32_t            fFlags;
    9598};
    9699
    … …  
    121124RTDECL(int)  RTSemEventCreateEx(PRTSEMEVENT phEventSem, uint32_t fFlags, RTLOCKVALCLASS hClass, const char *pszNameFmt, ...)
    122125{
    123     AssertReturn(!(fFlags & ~RTSEMEVENT_FLAGS_NO_LOCK_VAL), VERR_INVALID_PARAMETER);
     126    AssertReturn(!(fFlags & ~(RTSEMEVENT_FLAGS_NO_LOCK_VAL | RTSEMEVENT_FLAGS_BOOTSTRAP_HACK)), VERR_INVALID_PARAMETER);
     127    Assert(!(fFlags & RTSEMEVENT_FLAGS_BOOTSTRAP_HACK) || (fFlags & RTSEMEVENT_FLAGS_NO_LOCK_VAL));
    124128
    125129    /*
    126130     * Allocate semaphore handle.
    127131     */
    128     struct RTSEMEVENTINTERNAL *pThis = (struct RTSEMEVENTINTERNAL *)RTMemAlloc(sizeof(struct RTSEMEVENTINTERNAL));
     132    struct RTSEMEVENTINTERNAL *pThis;
     133    if (!(fFlags & RTSEMEVENT_FLAGS_BOOTSTRAP_HACK))
     134        pThis = (struct RTSEMEVENTINTERNAL *)RTMemAlloc(sizeof(struct RTSEMEVENTINTERNAL));
     135    else
     136        pThis = (struct RTSEMEVENTINTERNAL *)rtMemBaseAlloc(sizeof(struct RTSEMEVENTINTERNAL));
    129137    if (pThis)
    130138    {
    … …  
    132140        pThis->cWaiters = 0;
    133141        pThis->fSignalled = 0;
     142        pThis->fFlags = fFlags;
    134143#ifdef RTSEMEVENT_STRICT
    135144        if (!pszNameFmt)
    … …  
    186195    RTLockValidatorRecSharedDelete(&pThis->Signallers);
    187196#endif
    188     RTMemFree(pThis);
     197    if (!(pThis->fFlags & RTSEMEVENT_FLAGS_BOOTSTRAP_HACK))
     198        RTMemFree(pThis);
     199    else
     200        rtMemBaseFree(pThis);
    189201    return VINF_SUCCESS;
    190202}
    … …  
    267279     */
    268280#ifdef RTSEMEVENT_STRICT
    269     RTTHREAD hThreadSelf = RTThreadSelfAutoAdopt();
     281    RTTHREAD hThreadSelf = !(pThis->fFlags & RTSEMEVENT_FLAGS_BOOTSTRAP_HACK)
     282                         ? RTThreadSelfAutoAdopt()
     283                         : RTThreadSelf();
    270284#else
    271285    RTTHREAD hThreadSelf = RTThreadSelf();

  • trunk/src/VBox/Runtime/r3/os2/sems-os2.cpp

    r28800 r33269  
    5252RTDECL(int)  RTSemEventCreateEx(PRTSEMEVENT phEventSem, uint32_t fFlags, RTLOCKVALCLASS hClass, const char *pszNameFmt, ...)
    5353{
    54     AssertReturn(!(fFlags & ~RTSEMEVENT_FLAGS_NO_LOCK_VAL), VERR_INVALID_PARAMETER);
     54    AssertReturn(!(fFlags & ~(RTSEMEVENT_FLAGS_NO_LOCK_VAL | RTSEMEVENT_FLAGS_BOOTSTRAP_HACK), VERR_INVALID_PARAMETER);
     55    Assert(!(fFlags & RTSEMEVENT_FLAGS_BOOTSTRAP_HACK) || (fFlags & RTSEMEVENT_FLAGS_NO_LOCK_VAL));
    5556
    5657    /*

  • trunk/src/VBox/Runtime/r3/posix/RTMemProtect-posix.cpp

    r33145 r33269  
    3535#include <iprt/string.h>
    3636
    37 #include <stdlib.h>
    38 #ifndef RT_OS_FREEBSD /* Deprecated on FreeBSD */
    39 # include <malloc.h>
    40 #endif
    4137#include <errno.h>
    4238#include <sys/mman.h>
    43 
    44 
    45 /*******************************************************************************
    46 *   Defined Constants And Macros                                               *
    47 *******************************************************************************/
    48 #if !defined(RT_USE_MMAP_EXEC) && (defined(RT_OS_LINUX))
    49 # define RT_USE_MMAP_EXEC
    50 #endif
    51 
    52 #if !defined(RT_USE_MMAP_PAGE) && 0 /** @todo mmap is too slow for full scale EF setup. */
    53 # define RT_USE_MMAP_PAGE
    54 #endif
    55 
    56 
    57 /*******************************************************************************
    58 *   Structures and Typedefs                                                    *
    59 *******************************************************************************/
    60 #ifdef RT_USE_MMAP_EXEC
    61 /**
    62  * RTMemExecAlloc() header used when using mmap for allocating the memory.
    63  */
    64 typedef struct RTMEMEXECHDR
    65 {
    66     /** Magic number (RTMEMEXECHDR_MAGIC). */
    67     size_t      uMagic;
    68     /** The size we requested from mmap. */
    69     size_t      cb;
    70 # if ARCH_BITS == 32
    71     uint32_t    Alignment[2];
    72 # endif
    73 } RTMEMEXECHDR, *PRTMEMEXECHDR;
    74 
    75 /** Magic for RTMEMEXECHDR. */
    76 # define RTMEMEXECHDR_MAGIC (~(size_t)0xfeedbabe)
    77 
    78 #endif  /* RT_USE_MMAP_EXEC */
    79 
    80 
    81 
    82 RTDECL(void *) RTMemExecAllocTag(size_t cb, const char *pszTag) RT_NO_THROW
    83 {
    84     AssertMsg(cb, ("Allocating ZERO bytes is really not a good idea! Good luck with the next assertion!\n"));
    85 
    86 #ifdef RT_USE_MMAP_EXEC
    87     /*
    88      * Use mmap to get low memory.
    89      */
    90     size_t cbAlloc = RT_ALIGN_Z(cb + sizeof(RTMEMEXECHDR), PAGE_SIZE);
    91     void *pv = mmap(NULL, cbAlloc, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE | MAP_ANONYMOUS
    92 # if defined(RT_ARCH_AMD64) && defined(MAP_32BIT)
    93                     | MAP_32BIT
    94 # endif
    95                     , -1, 0);
    96     AssertMsgReturn(pv != MAP_FAILED, ("errno=%d cb=%#zx\n", errno, cb), NULL);
    97     PRTMEMEXECHDR pHdr = (PRTMEMEXECHDR)pv;
    98     pHdr->uMagic = RTMEMEXECHDR_MAGIC;
    99     pHdr->cb = cbAlloc;
    100     pv = pHdr + 1;
    101 
    102 #else
    103     /*
    104      * Allocate first.
    105      */
    106     cb = RT_ALIGN_Z(cb, 32);
    107     void *pv = NULL;
    108     int rc = posix_memalign(&pv, 32, cb);
    109     AssertMsg(!rc && pv, ("posix_memalign(%zd) failed!!! rc=%d\n", cb, rc));
    110     if (pv && !rc)
    111     {
    112         /*
    113          * Add PROT_EXEC flag to the page.
    114          *
    115          * This is in violation of the SuS where I think it saith that mprotect() shall
    116          * only be used with mmap()'ed memory. Works on linux and OS/2 LIBC v0.6.
    117          */
    118         memset(pv, 0xcc, cb);
    119         void   *pvProt = (void *)((uintptr_t)pv & ~PAGE_OFFSET_MASK);
    120         size_t  cbProt = ((uintptr_t)pv & PAGE_OFFSET_MASK) + cb;
    121         cbProt = RT_ALIGN_Z(cbProt, PAGE_SIZE);
    122         rc = mprotect(pvProt, cbProt, PROT_READ | PROT_WRITE | PROT_EXEC);
    123         if (rc)
    124         {
    125             AssertMsgFailed(("mprotect(%p, %#zx,,) -> rc=%d, errno=%d\n", pvProt, cbProt, rc, errno));
    126             free(pv);
    127             pv = NULL;
    128         }
    129     }
    130 #endif
    131     return pv;
    132 }
    133 
    134 
    135 RTDECL(void)    RTMemExecFree(void *pv) RT_NO_THROW
    136 {
    137     if (pv)
    138     {
    139 #ifdef RT_USE_MMAP_EXEC
    140         PRTMEMEXECHDR pHdr = (PRTMEMEXECHDR)pv - 1;
    141         AssertMsgReturnVoid(RT_ALIGN_P(pHdr, PAGE_SIZE) == pHdr, ("pHdr=%p pv=%p\n", pHdr, pv));
    142         AssertMsgReturnVoid(pHdr->uMagic == RTMEMEXECHDR_MAGIC, ("pHdr=%p(uMagic=%#zx) pv=%p\n", pHdr, pHdr->uMagic, pv));
    143         int rc = munmap(pHdr, pHdr->cb);
    144         AssertMsg(!rc, ("munmap -> %d errno=%d\n", rc, errno)); NOREF(rc);
    145 #else
    146         free(pv);
    147 #endif
    148     }
    149 }
    150 
    151 
    152 RTDECL(void *) RTMemPageAllocTag(size_t cb, const char *pszTag) RT_NO_THROW
    153 {
    154 #ifdef RT_USE_MMAP_PAGE
    155     size_t  cbAligned = RT_ALIGN_Z(cb, PAGE_SIZE);
    156     void   *pv = mmap(NULL, cbAligned, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    157     AssertMsgReturn(pv != MAP_FAILED, ("errno=%d cb=%#zx\n", errno, cb), NULL);
    158     return pv;
    159 
    160 #else
    161 # if defined(RT_OS_FREEBSD) /** @todo huh? we're using posix_memalign in the next function... */
    162     void *pv;
    163     int rc = posix_memalign(&pv, PAGE_SIZE, RT_ALIGN_Z(cb, PAGE_SIZE));
    164     if (!rc)
    165         return pv;
    166     return NULL;
    167 # else /* !RT_OS_FREEBSD */
    168     return memalign(PAGE_SIZE, cb);
    169 # endif
    170 #endif
    171 }
    172 
    173 
    174 RTDECL(void *) RTMemPageAllocZTag(size_t cb, const char *pszTag) RT_NO_THROW
    175 {
    176 #ifdef RT_USE_MMAP_PAGE
    177     size_t  cbAligned = RT_ALIGN_Z(cb, PAGE_SIZE);
    178     void   *pv = mmap(NULL, cbAligned, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    179     AssertMsgReturn(pv != MAP_FAILED, ("errno=%d cb=%#zx\n", errno, cb), NULL);
    180     return pv;
    181 
    182 #else
    183     void *pv;
    184     int rc = posix_memalign(&pv, PAGE_SIZE, RT_ALIGN_Z(cb, PAGE_SIZE));
    185     if (!rc)
    186     {
    187         RT_BZERO(pv, RT_ALIGN_Z(cb, PAGE_SIZE));
    188         return pv;
    189     }
    190     return NULL;
    191 #endif
    192 }
    193 
    194 
    195 RTDECL(void) RTMemPageFree(void *pv, size_t cb) RT_NO_THROW
    196 {
    197     if (pv)
    198     {
    199         Assert(!((uintptr_t)pv & PAGE_OFFSET_MASK));
    200 
    201 #ifdef RT_USE_MMAP_PAGE
    202         size_t cbAligned = RT_ALIGN_Z(cb, PAGE_SIZE);
    203         int rc = munmap(pv, cbAligned);
    204         AssertMsg(!rc, ("munmap(%p, %#zx) -> %d errno=%d\n", pv, cbAligned, rc, errno)); NOREF(rc);
    205 #else
    206         free(pv);
    207 #endif
    208     }
    209 }
    21039
    21140

  • trunk/src/VBox/Runtime/r3/posix/semevent-posix.cpp

    r28800 r33269  
    3737#include <iprt/lockvalidator.h>
    3838
     39#include "internal/mem.h"
    3940#include "internal/strict.h"
    4041
    … …  
    7980    bool volatile       fEverHadSignallers;
    8081#endif
     82    /** The creation flags. */
     83    uint32_t            fFlags;
    8184};
    8285
    … …  
    100103RTDECL(int)  RTSemEventCreateEx(PRTSEMEVENT phEventSem, uint32_t fFlags, RTLOCKVALCLASS hClass, const char *pszNameFmt, ...)
    101104{
    102     AssertReturn(!(fFlags & ~RTSEMEVENT_FLAGS_NO_LOCK_VAL), VERR_INVALID_PARAMETER);
     105    AssertReturn(!(fFlags & ~(RTSEMEVENT_FLAGS_NO_LOCK_VAL | RTSEMEVENT_FLAGS_BOOTSTRAP_HACK)), VERR_INVALID_PARAMETER);
     106    Assert(!(fFlags & RTSEMEVENT_FLAGS_BOOTSTRAP_HACK) || (fFlags & RTSEMEVENT_FLAGS_NO_LOCK_VAL));
    103107
    104108    /*
    … …  
    106110     */
    107111    int rc;
    108     struct RTSEMEVENTINTERNAL *pThis = (struct RTSEMEVENTINTERNAL *)RTMemAlloc(sizeof(struct RTSEMEVENTINTERNAL));
     112    struct RTSEMEVENTINTERNAL *pThis;
     113    if (!(fFlags & RTSEMEVENT_FLAGS_BOOTSTRAP_HACK))
     114        pThis = (struct RTSEMEVENTINTERNAL *)RTMemAlloc(sizeof(*pThis));
     115    else
     116        pThis = (struct RTSEMEVENTINTERNAL *)rtMemBaseAlloc(sizeof(*pThis));
    109117    if (pThis)
    110118    {
    … …  
    132140                        pthread_condattr_destroy(&CondAttr);
    133141
    134                         ASMAtomicXchgU32(&pThis->u32State, EVENT_STATE_NOT_SIGNALED);
    135                         ASMAtomicXchgU32(&pThis->cWaiters, 0);
     142                        ASMAtomicWriteU32(&pThis->u32State, EVENT_STATE_NOT_SIGNALED);
     143                        ASMAtomicWriteU32(&pThis->cWaiters, 0);
     144                        pThis->fFlags = fFlags;
    136145#ifdef RTSEMEVENT_STRICT
    137146                        if (!pszNameFmt)
    … …  
    166175
    167176        rc = RTErrConvertFromErrno(rc);
    168         RTMemFree(pThis);
     177        if (!(fFlags & RTSEMEVENT_FLAGS_BOOTSTRAP_HACK))
     178            RTMemFree(pThis);
     179        else
     180            rtMemBaseFree(pThis);
    169181    }
    170182    else
    … …  
    193205    for (int i = 30; i > 0; i--)
    194206    {
    195         ASMAtomicXchgU32(&pThis->u32State, EVENT_STATE_UNINITIALIZED);
     207        ASMAtomicWriteU32(&pThis->u32State, EVENT_STATE_UNINITIALIZED);
    196208        rc = pthread_cond_destroy(&pThis->Cond);
    197209        if (rc != EBUSY)
    … …  
    229241    RTLockValidatorRecSharedDelete(&pThis->Signallers);
    230242#endif
    231     RTMemFree(pThis);
     243    if (!(pThis->fFlags & RTSEMEVENT_FLAGS_BOOTSTRAP_HACK))
     244        RTMemFree(pThis);
     245    else
     246        rtMemBaseFree(pThis);
    232247    return VINF_SUCCESS;
    233248}
    … …  
    268283    if (pThis->u32State == EVENT_STATE_NOT_SIGNALED)
    269284    {
    270         ASMAtomicXchgU32(&pThis->u32State, EVENT_STATE_SIGNALED);
     285        ASMAtomicWriteU32(&pThis->u32State, EVENT_STATE_SIGNALED);
    271286        rc = pthread_cond_signal(&pThis->Cond);
    272287        AssertMsg(!rc, ("Failed to signal event sem %p, rc=%d.\n", hEventSem, rc));
    … …  
    330345            if (pThis->u32State == EVENT_STATE_SIGNALED)
    331346            {
    332                 ASMAtomicXchgU32(&pThis->u32State, EVENT_STATE_NOT_SIGNALED);
     347                ASMAtomicWriteU32(&pThis->u32State, EVENT_STATE_NOT_SIGNALED);
    333348                ASMAtomicDecU32(&pThis->cWaiters);
    334349                rc = pthread_mutex_unlock(&pThis->Mutex);
    … …  
    345360            /* wait */
    346361#ifdef RTSEMEVENT_STRICT
    347             RTTHREAD hThreadSelf = RTThreadSelfAutoAdopt();
     362            RTTHREAD hThreadSelf = !(pThis->fFlags & RTSEMEVENT_FLAGS_BOOTSTRAP_HACK)
     363                                 ? RTThreadSelfAutoAdopt()
     364                                 : RTThreadSelf();
    348365            if (pThis->fEverHadSignallers)
    349366            {
    … …  
    416433            if (pThis->u32State == EVENT_STATE_SIGNALED)
    417434            {
    418                 ASMAtomicXchgU32(&pThis->u32State, EVENT_STATE_NOT_SIGNALED);
     435                ASMAtomicWriteU32(&pThis->u32State, EVENT_STATE_NOT_SIGNALED);
    419436                ASMAtomicDecU32(&pThis->cWaiters);
    420437                rc = pthread_mutex_unlock(&pThis->Mutex);
    … …  
    439456            /* wait */
    440457#ifdef RTSEMEVENT_STRICT
    441             RTTHREAD hThreadSelf = RTThreadSelfAutoAdopt();
     458            RTTHREAD hThreadSelf = !(pThis->fFlags & RTSEMEVENT_FLAGS_BOOTSTRAP_HACK)
     459                                 ? RTThreadSelfAutoAdopt()
     460                                 : RTThreadSelf();
    442461            if (pThis->fEverHadSignallers)
    443462            {

  • trunk/src/VBox/Runtime/r3/solaris/alloc-solaris.cpp

    r31158 r33269  
    8282
    8383
    84 RTDECL(void)    RTMemExecFree(void *pv) RT_NO_THROW
     84RTDECL(void)    RTMemExecFree(void *pv, size_t cb) RT_NO_THROW
    8585{
    8686    if (pv)

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

    r31158 r33269  
    7676
    7777
    78 RTDECL(void)    RTMemExecFree(void *pv) RT_NO_THROW
     78RTDECL(void)    RTMemExecFree(void *pv, size_t cb) RT_NO_THROW
    7979{
    8080    if (pv)

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

    r28800 r33269  
    4242#include <iprt/thread.h>
    4343#include "internal/magics.h"
     44#include "internal/mem.h"
    4445#include "internal/strict.h"
    4546
    … …  
    6061    bool volatile       fEverHadSignallers;
    6162#endif
     63    /** The creation flags. */
     64    uint32_t            fFlags;
    6265};
    6366
    … …  
    7275RTDECL(int)  RTSemEventCreateEx(PRTSEMEVENT phEventSem, uint32_t fFlags, RTLOCKVALCLASS hClass, const char *pszNameFmt, ...)
    7376{
    74     AssertReturn(!(fFlags & ~RTSEMEVENT_FLAGS_NO_LOCK_VAL), VERR_INVALID_PARAMETER);
    75 
    76     struct RTSEMEVENTINTERNAL *pThis = (struct RTSEMEVENTINTERNAL *)RTMemAlloc(sizeof(*pThis));
     77    AssertReturn(!(fFlags & ~(RTSEMEVENT_FLAGS_NO_LOCK_VAL | RTSEMEVENT_FLAGS_BOOTSTRAP_HACK)), VERR_INVALID_PARAMETER);
     78    Assert(!(fFlags & RTSEMEVENT_FLAGS_BOOTSTRAP_HACK) || (fFlags & RTSEMEVENT_FLAGS_NO_LOCK_VAL));
     79
     80    struct RTSEMEVENTINTERNAL *pThis;
     81    if (!(fFlags & RTSEMEVENT_FLAGS_BOOTSTRAP_HACK))
     82        pThis = (struct RTSEMEVENTINTERNAL *)RTMemAlloc(sizeof(*pThis));
     83    else
     84        pThis = (struct RTSEMEVENTINTERNAL *)rtMemBaseAlloc(sizeof(*pThis));
    7785    if (!pThis)
    7886        return VERR_NO_MEMORY;
    … …  
    8694    {
    8795        pThis->u32Magic = RTSEMEVENT_MAGIC;
     96        pThis->fFlags   = fFlags;
    8897#ifdef RTSEMEVENT_STRICT
    8998        if (!pszNameFmt)
    … …  
    111120
    112121    DWORD dwErr = GetLastError();
    113     RTMemFree(pThis);
     122    if (!(fFlags & RTSEMEVENT_FLAGS_BOOTSTRAP_HACK))
     123        RTMemFree(pThis);
     124    else
     125        rtMemBaseFree(pThis);
    114126    return RTErrConvertFromWin32(dwErr);
    115127}
    … …  
    134146        RTLockValidatorRecSharedDelete(&pThis->Signallers);
    135147#endif
    136         RTMemFree(pThis);
     148        if (!(pThis->fFlags & RTSEMEVENT_FLAGS_BOOTSTRAP_HACK))
     149            RTMemFree(pThis);
     150        else
     151            rtMemBaseFree(pThis);
    137152    }
    138153    else
    … …  
    218233     */
    219234#ifdef RTSEMEVENT_STRICT
    220     RTTHREAD hThreadSelf = RTThreadSelfAutoAdopt();
     235    RTTHREAD hThreadSelf = !(pThis->fFlags & RTSEMEVENT_FLAGS_BOOTSTRAP_HACK)
     236                         ? RTThreadSelfAutoAdopt()
     237                         : RTThreadSelf();
    221238    if (pThis->fEverHadSignallers)
    222239    {

  • trunk/src/VBox/Runtime/testcase/tstLdr-4.cpp

    r28800 r33269  
    9999        RTLDRMOD    hLdrMod;
    100100        void       *pvBits;
     101        size_t      cbBits;
    101102        const char *pszName;
    102103    }   aLoads[6] =
    103104    {
    104         { NULL, NULL, "foo" },
    105         { NULL, NULL, "bar" },
    106         { NULL, NULL, "foobar" },
    107         { NULL, NULL, "kLdr-foo" },
    108         { NULL, NULL, "kLdr-bar" },
    109         { NULL, NULL, "kLdr-foobar" }
     105        { NULL, NULL, 0, "foo" },
     106        { NULL, NULL, 0, "bar" },
     107        { NULL, NULL, 0, "foobar" },
     108        { NULL, NULL, 0, "kLdr-foo" },
     109        { NULL, NULL, 0, "kLdr-bar" },
     110        { NULL, NULL, 0, "kLdr-foobar" }
    110111    };
    111112    unsigned i;
    … …  
    137138            break;
    138139        }
    139         cbImage = cb;
     140        aLoads[i].cbBits = cbImage = cb;
    140141
    141142        /* Allocate bits. */
    … …  
    196197    {
    197198        if (aLoads[i].pvBits)
    198             RTMemExecFree(aLoads[i].pvBits);
     199            RTMemExecFree(aLoads[i].pvBits, aLoads[i].cbBits);
    199200        if (aLoads[i].hLdrMod)
    200201        {

  • trunk/src/recompiler/VBoxREMWrapper.cpp

    r31636 r33269  
    339339/** Pointer to the memory containing the loaded REM2 object/DLL. */
    340340static void    *g_pvREM2 = NULL;
     341/** The size of the memory g_pvREM2 is pointing to. */
     342static size_t   g_cbREM2 = 0;
    341343# ifdef VBOX_WITHOUT_REM_LDR_CYCLE
    342344/** Loader handle of the VBoxVMM DLL. */
    … …  
    402404    { REMPARMDESC_FLAGS_INT,        sizeof(const char *),       NULL }
    403405};
     406static const REMPARMDESC g_aArgsPTR_SIZE_T[] =
     407{
     408    { REMPARMDESC_FLAGS_INT,        sizeof(void *),             NULL },
     409    { REMPARMDESC_FLAGS_INT,        sizeof(size_t),             NULL }
     410};
    404411static const REMPARMDESC g_aArgsVM[] =
    405412{
    … …  
    10851092    { REMPARMDESC_FLAGS_INT,        sizeof(size_t),             NULL },
    10861093    { REMPARMDESC_FLAGS_INT,        sizeof(unsigned),           NULL }
    1087 };
    1088 static const REMPARMDESC g_aArgsRTMemPageFree[] =
    1089 {
    1090     { REMPARMDESC_FLAGS_INT,        sizeof(void *),             NULL },
    1091     { REMPARMDESC_FLAGS_INT,        sizeof(size_t),             NULL }
    10921094};
    10931095static const REMPARMDESC g_aArgsRTStrPrintf[] =
    … …  
    13201322    { "RTMemReallocTag",                        (void *)(uintptr_t)&RTMemReallocTag,                &g_aArgsRTMemReallocTag[0],                 RT_ELEMENTS(g_aArgsRTMemReallocTag),                   REMFNDESC_FLAGS_RET_INT,    sizeof(void *),     NULL },
    13211323    { "RTMemExecAllocTag",                      (void *)(uintptr_t)&RTMemExecAllocTag,              &g_aArgsSIZE_TTag[0],                       RT_ELEMENTS(g_aArgsSIZE_TTag),                         REMFNDESC_FLAGS_RET_INT,    sizeof(void *),     NULL },
    1322     { "RTMemExecFree",                          (void *)(uintptr_t)&RTMemExecFree,                  &g_aArgsPTR[0],                             RT_ELEMENTS(g_aArgsPTR),                               REMFNDESC_FLAGS_RET_VOID,   0,                  NULL },
     1324    { "RTMemExecFree",                          (void *)(uintptr_t)&RTMemExecFree,                  &g_aArgsPTR_SIZE_T[0],                      RT_ELEMENTS(g_aArgsPTR_SIZE_T),                        REMFNDESC_FLAGS_RET_VOID,   0,                  NULL },
    13231325    { "RTMemFree",                              (void *)(uintptr_t)&RTMemFree,                      &g_aArgsPTR[0],                             RT_ELEMENTS(g_aArgsPTR),                               REMFNDESC_FLAGS_RET_VOID,   0,                  NULL },
    13241326    { "RTMemPageAllocTag",                      (void *)(uintptr_t)&RTMemPageAllocTag,              &g_aArgsSIZE_TTag[0],                       RT_ELEMENTS(g_aArgsSIZE_TTag),                         REMFNDESC_FLAGS_RET_INT,    sizeof(void *),     NULL },
    1325     { "RTMemPageFree",                          (void *)(uintptr_t)&RTMemPageFree,                  &g_aArgsRTMemPageFree[0],                   RT_ELEMENTS(g_aArgsRTMemPageFree),                     REMFNDESC_FLAGS_RET_VOID,   0,                  NULL },
     1327    { "RTMemPageFree",                          (void *)(uintptr_t)&RTMemPageFree,                  &g_aArgsPTR_SIZE_T[0],                      RT_ELEMENTS(g_aArgsPTR_SIZE_T),                        REMFNDESC_FLAGS_RET_VOID,   0,                  NULL },
    13261328    { "RTMemProtect",                           (void *)(uintptr_t)&RTMemProtect,                   &g_aArgsRTMemProtect[0],                    RT_ELEMENTS(g_aArgsRTMemProtect),                      REMFNDESC_FLAGS_RET_INT,    sizeof(int),        NULL },
    13271329    { "RTStrPrintf",                            (void *)(uintptr_t)&RTStrPrintf,                    &g_aArgsRTStrPrintf[0],                     RT_ELEMENTS(g_aArgsRTStrPrintf),                       REMFNDESC_FLAGS_RET_INT | REMFNDESC_FLAGS_ELLIPSIS, sizeof(size_t), NULL },
    … …  
    19982000    if (RT_SUCCESS(rc))
    19992001    {
    2000         g_pvREM2 = RTMemExecAlloc(RTLdrSize(g_ModREM2));
     2002        g_cbREM2 = RTLdrSize(g_ModREM2);
     2003        g_pvREM2 = RTMemExecAlloc(g_cbREM);
    20012004        if (g_pvREM2)
    20022005        {
    … …  
    20282031                return rc;
    20292032            }
    2030             RTMemExecFree(g_pvREM2);
     2033
     2034            RTMemExecFree(g_pvREM2, g_cbREM2);
     2035            g_pvREM2 = NULL;
    20312036        }
     2037        g_cbREM2 = 0;
    20322038        RTLdrClose(g_ModREM2);
    20332039        g_ModREM2 = NIL_RTLDRMOD;
    … …  
    20492055    RTLdrClose(g_ModREM2);
    20502056    g_ModREM2 = NIL_RTLDRMOD;
    2051     RTMemExecFree(g_pvREM2);
     2057    RTMemExecFree(g_pvREM2, g_cbREM2);
    20522058    g_pvREM2 = NULL;
     2059    g_cbREM2 = 0;
    20532060
    20542061    /* clear the pointers. */
    … …  
    20692076        g_pExecMemHead = pCur->pNext;
    20702077        memset(pCur, 0xcc, pCur->cb);
    2071         RTMemExecFree(pCur);
     2078        RTMemExecFree(pCur, pCur->cb);
    20722079    }
    20732080#  endif
Note: See TracChangeset for help on using the changeset viewer.

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