Changeset 33269 in vbox for trunk/src/VBox/Runtime/r3/posix

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/src/VBox/Runtime/r3/posix

Files:

• RTMemProtect-posix.cpp (moved) (moved from trunk/src/VBox/Runtime/r3/posix/alloc-posix.cpp ) (1 diff)
• rtmempage-exec-mmap-heap-posix.cpp (added)
• rtmempage-exec-mmap-posix.cpp (added)
• semevent-posix.cpp (modified) (13 diffs)

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

@@ -35 +35 @@
 #include <iprt/string.h>
 
-#include <stdlib.h>
-#ifndef RT_OS_FREEBSD /* Deprecated on FreeBSD */
-# include <malloc.h>
-#endif
 #include <errno.h>
 #include <sys/mman.h>
-
-
-/*******************************************************************************
-*   Defined Constants And Macros                                               *
-*******************************************************************************/
-#if !defined(RT_USE_MMAP_EXEC) && (defined(RT_OS_LINUX))
-# define RT_USE_MMAP_EXEC
-#endif
-
-#if !defined(RT_USE_MMAP_PAGE) && 0 /** @todo mmap is too slow for full scale EF setup. */
-# define RT_USE_MMAP_PAGE
-#endif
-
-
-/*******************************************************************************
-*   Structures and Typedefs                                                    *
-*******************************************************************************/
-#ifdef RT_USE_MMAP_EXEC
-/**
- * RTMemExecAlloc() header used when using mmap for allocating the memory.
- */
-typedef struct RTMEMEXECHDR
-{
-    /** Magic number (RTMEMEXECHDR_MAGIC). */
-    size_t      uMagic;
-    /** The size we requested from mmap. */
-    size_t      cb;
-# if ARCH_BITS == 32
-    uint32_t    Alignment[2];
-# endif
-} RTMEMEXECHDR, *PRTMEMEXECHDR;
-
-/** Magic for RTMEMEXECHDR. */
-# define RTMEMEXECHDR_MAGIC (~(size_t)0xfeedbabe)
-
-#endif  /* RT_USE_MMAP_EXEC */
-
-
-
-RTDECL(void *) RTMemExecAllocTag(size_t cb, const char *pszTag) RT_NO_THROW
-{
-    AssertMsg(cb, ("Allocating ZERO bytes is really not a good idea! Good luck with the next assertion!\n"));
-
-#ifdef RT_USE_MMAP_EXEC
-    /*
-     * Use mmap to get low memory.
-     */
-    size_t cbAlloc = RT_ALIGN_Z(cb + sizeof(RTMEMEXECHDR), PAGE_SIZE);
-    void *pv = mmap(NULL, cbAlloc, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE | MAP_ANONYMOUS
-# if defined(RT_ARCH_AMD64) && defined(MAP_32BIT)
-                    | MAP_32BIT
-# endif
-                    , -1, 0);
-    AssertMsgReturn(pv != MAP_FAILED, ("errno=%d cb=%#zx\n", errno, cb), NULL);
-    PRTMEMEXECHDR pHdr = (PRTMEMEXECHDR)pv;
-    pHdr->uMagic = RTMEMEXECHDR_MAGIC;
-    pHdr->cb = cbAlloc;
-    pv = pHdr + 1;
-
-#else
-    /*
-     * Allocate first.
-     */
-    cb = RT_ALIGN_Z(cb, 32);
-    void *pv = NULL;
-    int rc = posix_memalign(&pv, 32, cb);
-    AssertMsg(!rc && pv, ("posix_memalign(%zd) failed!!! rc=%d\n", cb, rc));
-    if (pv && !rc)
-    {
-        /*
-         * Add PROT_EXEC flag to the page.
-         *
-         * This is in violation of the SuS where I think it saith that mprotect() shall
-         * only be used with mmap()'ed memory. Works on linux and OS/2 LIBC v0.6.
-         */
-        memset(pv, 0xcc, cb);
-        void   *pvProt = (void *)((uintptr_t)pv & ~PAGE_OFFSET_MASK);
-        size_t  cbProt = ((uintptr_t)pv & PAGE_OFFSET_MASK) + cb;
-        cbProt = RT_ALIGN_Z(cbProt, PAGE_SIZE);
-        rc = mprotect(pvProt, cbProt, PROT_READ | PROT_WRITE | PROT_EXEC);
-        if (rc)
-        {
-            AssertMsgFailed(("mprotect(%p, %#zx,,) -> rc=%d, errno=%d\n", pvProt, cbProt, rc, errno));
-            free(pv);
-            pv = NULL;
-        }
-    }
-#endif
-    return pv;
-}
-
-
-RTDECL(void)    RTMemExecFree(void *pv) RT_NO_THROW
-{
-    if (pv)
-    {
-#ifdef RT_USE_MMAP_EXEC
-        PRTMEMEXECHDR pHdr = (PRTMEMEXECHDR)pv - 1;
-        AssertMsgReturnVoid(RT_ALIGN_P(pHdr, PAGE_SIZE) == pHdr, ("pHdr=%p pv=%p\n", pHdr, pv));
-        AssertMsgReturnVoid(pHdr->uMagic == RTMEMEXECHDR_MAGIC, ("pHdr=%p(uMagic=%#zx) pv=%p\n", pHdr, pHdr->uMagic, pv));
-        int rc = munmap(pHdr, pHdr->cb);
-        AssertMsg(!rc, ("munmap -> %d errno=%d\n", rc, errno)); NOREF(rc);
-#else
-        free(pv);
-#endif
-    }
-}
-
-
-RTDECL(void *) RTMemPageAllocTag(size_t cb, const char *pszTag) RT_NO_THROW
-{
-#ifdef RT_USE_MMAP_PAGE
-    size_t  cbAligned = RT_ALIGN_Z(cb, PAGE_SIZE);
-    void   *pv = mmap(NULL, cbAligned, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
-    AssertMsgReturn(pv != MAP_FAILED, ("errno=%d cb=%#zx\n", errno, cb), NULL);
-    return pv;
-
-#else
-# if defined(RT_OS_FREEBSD) /** @todo huh? we're using posix_memalign in the next function... */
-    void *pv;
-    int rc = posix_memalign(&pv, PAGE_SIZE, RT_ALIGN_Z(cb, PAGE_SIZE));
-    if (!rc)
-        return pv;
-    return NULL;
-# else /* !RT_OS_FREEBSD */
-    return memalign(PAGE_SIZE, cb);
-# endif
-#endif
-}
-
-
-RTDECL(void *) RTMemPageAllocZTag(size_t cb, const char *pszTag) RT_NO_THROW
-{
-#ifdef RT_USE_MMAP_PAGE
-    size_t  cbAligned = RT_ALIGN_Z(cb, PAGE_SIZE);
-    void   *pv = mmap(NULL, cbAligned, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
-    AssertMsgReturn(pv != MAP_FAILED, ("errno=%d cb=%#zx\n", errno, cb), NULL);
-    return pv;
-
-#else
-    void *pv;
-    int rc = posix_memalign(&pv, PAGE_SIZE, RT_ALIGN_Z(cb, PAGE_SIZE));
-    if (!rc)
-    {
-        RT_BZERO(pv, RT_ALIGN_Z(cb, PAGE_SIZE));
-        return pv;
-    }
-    return NULL;
-#endif
-}
-
-
-RTDECL(void) RTMemPageFree(void *pv, size_t cb) RT_NO_THROW
-{
-    if (pv)
-    {
-        Assert(!((uintptr_t)pv & PAGE_OFFSET_MASK));
-
-#ifdef RT_USE_MMAP_PAGE
-        size_t cbAligned = RT_ALIGN_Z(cb, PAGE_SIZE);
-        int rc = munmap(pv, cbAligned);
-        AssertMsg(!rc, ("munmap(%p, %#zx) -> %d errno=%d\n", pv, cbAligned, rc, errno)); NOREF(rc);
-#else
-        free(pv);
-#endif
-    }
-}
 
 

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

@@ -37 +37 @@
 #include <iprt/lockvalidator.h>
 
+#include "internal/mem.h"
 #include "internal/strict.h"
 
@@ -79 +80 @@
     bool volatile       fEverHadSignallers;
 #endif
+    /** The creation flags. */
+    uint32_t            fFlags;
 };
 
@@ -100 +103 @@
 RTDECL(int)  RTSemEventCreateEx(PRTSEMEVENT phEventSem, uint32_t fFlags, RTLOCKVALCLASS hClass, const char *pszNameFmt, ...)
 {
-    AssertReturn(!(fFlags & ~RTSEMEVENT_FLAGS_NO_LOCK_VAL), VERR_INVALID_PARAMETER);
+    AssertReturn(!(fFlags & ~(RTSEMEVENT_FLAGS_NO_LOCK_VAL | RTSEMEVENT_FLAGS_BOOTSTRAP_HACK)), VERR_INVALID_PARAMETER);
+    Assert(!(fFlags & RTSEMEVENT_FLAGS_BOOTSTRAP_HACK) || (fFlags & RTSEMEVENT_FLAGS_NO_LOCK_VAL));
 
     /*
@@ -106 +110 @@
      */
     int rc;
-    struct RTSEMEVENTINTERNAL *pThis = (struct RTSEMEVENTINTERNAL *)RTMemAlloc(sizeof(struct RTSEMEVENTINTERNAL));
+    struct RTSEMEVENTINTERNAL *pThis;
+    if (!(fFlags & RTSEMEVENT_FLAGS_BOOTSTRAP_HACK))
+        pThis = (struct RTSEMEVENTINTERNAL *)RTMemAlloc(sizeof(*pThis));
+    else
+        pThis = (struct RTSEMEVENTINTERNAL *)rtMemBaseAlloc(sizeof(*pThis));
     if (pThis)
     {
@@ -132 +140 @@
                         pthread_condattr_destroy(&CondAttr);
 
-                        ASMAtomicXchgU32(&pThis->u32State, EVENT_STATE_NOT_SIGNALED);
-                        ASMAtomicXchgU32(&pThis->cWaiters, 0);
+                        ASMAtomicWriteU32(&pThis->u32State, EVENT_STATE_NOT_SIGNALED);
+                        ASMAtomicWriteU32(&pThis->cWaiters, 0);
+                        pThis->fFlags = fFlags;
 #ifdef RTSEMEVENT_STRICT
                         if (!pszNameFmt)
@@ -166 +175 @@
 
         rc = RTErrConvertFromErrno(rc);
-        RTMemFree(pThis);
+        if (!(fFlags & RTSEMEVENT_FLAGS_BOOTSTRAP_HACK))
+            RTMemFree(pThis);
+        else
+            rtMemBaseFree(pThis);
     }
     else
@@ -193 +205 @@
     for (int i = 30; i > 0; i--)
     {
-        ASMAtomicXchgU32(&pThis->u32State, EVENT_STATE_UNINITIALIZED);
+        ASMAtomicWriteU32(&pThis->u32State, EVENT_STATE_UNINITIALIZED);
         rc = pthread_cond_destroy(&pThis->Cond);
         if (rc != EBUSY)
@@ -229 +241 @@
     RTLockValidatorRecSharedDelete(&pThis->Signallers);
 #endif
-    RTMemFree(pThis);
+    if (!(pThis->fFlags & RTSEMEVENT_FLAGS_BOOTSTRAP_HACK))
+        RTMemFree(pThis);
+    else
+        rtMemBaseFree(pThis);
     return VINF_SUCCESS;
 }
@@ -268 +283 @@
     if (pThis->u32State == EVENT_STATE_NOT_SIGNALED)
     {
-        ASMAtomicXchgU32(&pThis->u32State, EVENT_STATE_SIGNALED);
+        ASMAtomicWriteU32(&pThis->u32State, EVENT_STATE_SIGNALED);
         rc = pthread_cond_signal(&pThis->Cond);
         AssertMsg(!rc, ("Failed to signal event sem %p, rc=%d.\n", hEventSem, rc));
@@ -330 +345 @@
             if (pThis->u32State == EVENT_STATE_SIGNALED)
             {
-                ASMAtomicXchgU32(&pThis->u32State, EVENT_STATE_NOT_SIGNALED);
+                ASMAtomicWriteU32(&pThis->u32State, EVENT_STATE_NOT_SIGNALED);
                 ASMAtomicDecU32(&pThis->cWaiters);
                 rc = pthread_mutex_unlock(&pThis->Mutex);
@@ -345 +360 @@
             /* wait */
 #ifdef RTSEMEVENT_STRICT
-            RTTHREAD hThreadSelf = RTThreadSelfAutoAdopt();
+            RTTHREAD hThreadSelf = !(pThis->fFlags & RTSEMEVENT_FLAGS_BOOTSTRAP_HACK)
+                                 ? RTThreadSelfAutoAdopt()
+                                 : RTThreadSelf();
             if (pThis->fEverHadSignallers)
             {
@@ -416 +433 @@
             if (pThis->u32State == EVENT_STATE_SIGNALED)
             {
-                ASMAtomicXchgU32(&pThis->u32State, EVENT_STATE_NOT_SIGNALED);
+                ASMAtomicWriteU32(&pThis->u32State, EVENT_STATE_NOT_SIGNALED);
                 ASMAtomicDecU32(&pThis->cWaiters);
                 rc = pthread_mutex_unlock(&pThis->Mutex);
@@ -439 +456 @@
             /* wait */
 #ifdef RTSEMEVENT_STRICT
-            RTTHREAD hThreadSelf = RTThreadSelfAutoAdopt();
+            RTTHREAD hThreadSelf = !(pThis->fFlags & RTSEMEVENT_FLAGS_BOOTSTRAP_HACK)
+                                 ? RTThreadSelfAutoAdopt()
+                                 : RTThreadSelf();
             if (pThis->fEverHadSignallers)
             {