Changeset 6727 in vbox

Timestamp:

Feb 1, 2008 5:06:53 PM (17 years ago)

Author:

vboxsync

Message:

Reimplemented mutex semaphores in sems-linux.cpp (64bit linux has bugs in pthreads lib function pthread_mutex_timedlock causing SEGV). Disabled at the moment as there are performance issues with lwip. The synchronization itself is apparently correct.

File:

• trunk/src/VBox/Runtime/r3/linux/sems-linux.cpp (modified) (6 diffs)

trunk/src/VBox/Runtime/r3/linux/sems-linux.cpp

@@ -85 +85 @@
 
 
+#ifndef VBOX_REWRITTEN_MUTEX
 /**
  * Posix internal representation of a Mutex semaphore. 
@@ -97 +98 @@
     volatile uint32_t   cNesting;
 };
+#else /* VBOX_REWRITTEN_MUTEX */
+/**
+ * Linux internal representation of a Mutex semaphore.
+ */
+struct RTSEMMUTEXINTERNAL
+{
+    /** Magic value. */
+    intptr_t volatile   iMagic;
+    /** The futex state variable.
+     * 0 means unlocked.
+     * 1 means locked, no waiters.
+     * 2 means locked, one or more waiters.
+     */
+    int32_t volatile    iState;
+    /** The owner of the mutex. */
+    volatile pthread_t  Owner;
+    /** Nesting count. */
+    volatile uint32_t   cNesting;
+};
+#endif /* VBOX_REWRITTEN_MUTEX */
 
 
@@ -281 +302 @@
                 return VERR_SEM_DESTROYED;
 
-            /* Did somebody wake us up us from RTSemEventSignal()? */
+            /* Did somebody wake us up from RTSemEventSignal()? */
             if (rc == 0)
                 return VINF_SUCCESS; 
@@ -535 +556 @@
         return false;
 
+#ifdef VBOX_REWRITTEN_MUTEX
+    if (pIntMutexSem->iMagic != RTSEMMUTEX_MAGIC)
+        return false;
+
+#endif /* VBOX_REWRITTEN_MUTEX */
     if (pIntMutexSem->cNesting == (uint32_t)~0)
         return false;
@@ -542 +568 @@
 
 
+#ifndef VBOX_REWRITTEN_MUTEX
 RTDECL(int)  RTSemMutexCreate(PRTSEMMUTEX pMutexSem)
 {
@@ -745 +772 @@
     return VINF_SUCCESS;
 }
-
+#else /* VBOX_REWRITTEN_MUTEX */
+RTDECL(int)  RTSemMutexCreate(PRTSEMMUTEX pMutexSem)
+{
+    /*
+     * Allocate semaphore handle.
+     */
+    struct RTSEMMUTEXINTERNAL *pIntMutexSem = (struct RTSEMMUTEXINTERNAL *)RTMemAlloc(sizeof(struct RTSEMMUTEXINTERNAL));
+    if (pIntMutexSem)
+    {
+        pIntMutexSem->iMagic   = RTSEMMUTEX_MAGIC;
+        pIntMutexSem->iState   = 0;
+        pIntMutexSem->Owner    = (pthread_t)~0;
+        pIntMutexSem->cNesting = 0;
+
+        *pMutexSem = pIntMutexSem;
+        return VINF_SUCCESS;
+    }
+
+    return VERR_NO_MEMORY;
+}
+
+
+RTDECL(int)  RTSemMutexDestroy(RTSEMMUTEX MutexSem)
+{
+    struct RTSEMMUTEXINTERNAL *pIntMutexSem = MutexSem;
+    /*
+     * Validate input.
+     */
+    if (!rtsemMutexValid(pIntMutexSem))
+    {
+        AssertMsgFailed(("Invalid handle %p!\n", MutexSem));
+        return VERR_INVALID_HANDLE;
+    }
+
+    /*
+     * Invalidate the semaphore and wake up anyone waiting on it.
+     */
+    ASMAtomicXchgSize(&pIntMutexSem->iMagic, RTSEMMUTEX_MAGIC + 1);
+    if (ASMAtomicXchgS32(&pIntMutexSem->iState, 0) > 0)
+    {
+        sys_futex(&pIntMutexSem->iState, FUTEX_WAKE, INT_MAX, NULL, NULL, 0);
+        usleep(1000);
+    }
+    pIntMutexSem->Owner    = (pthread_t)~0;
+    pIntMutexSem->cNesting = ~0;
+
+    /*
+     * Free the semaphore memory and be gone.
+     */
+    RTMemFree(pIntMutexSem);
+    return VINF_SUCCESS;
+}
+
+
+static int rtsemMutexRequest(RTSEMMUTEX MutexSem, unsigned cMillies, bool fAutoResume)
+{
+    /*
+     * Validate input.
+     */
+    struct RTSEMMUTEXINTERNAL *pIntMutexSem = MutexSem;
+    if (!rtsemMutexValid(pIntMutexSem))
+    {
+        AssertMsgFailed(("Invalid handle %p!\n", MutexSem));
+        return VERR_INVALID_HANDLE;
+    }
+
+    /*
+     * Check if nested request.
+     */
+    pthread_t Self = pthread_self();
+    if (    pIntMutexSem->Owner == Self
+        &&  pIntMutexSem->cNesting > 0)
+    {
+        pIntMutexSem->cNesting++;
+        return VINF_SUCCESS;
+    }
+
+    /*
+     * Convert timeout value.
+     */
+    struct timespec ts;
+    struct timespec *pTimeout = NULL;
+    if (cMillies != RT_INDEFINITE_WAIT)
+    {
+        ts.tv_sec  = cMillies / 1000;
+        ts.tv_nsec = (cMillies % 1000) * 1000000;
+        pTimeout = &ts;
+    }
+
+    /*
+     * Lock the mutex.
+     */
+    int32_t iOld;
+    ASMAtomicCmpXchgExS32(&pIntMutexSem->iState, 1, 0, &iOld);
+    if (iOld != 0)
+    {
+        iOld = ASMAtomicXchgS32(&pIntMutexSem->iState, 2);
+        while (iOld != 0)
+        {
+            /*
+             * Go to sleep.
+             */
+            long rc = sys_futex(&pIntMutexSem->iState, FUTEX_WAIT, 2, pTimeout, NULL, 0);
+            if (RT_UNLIKELY(pIntMutexSem->iMagic != RTSEMMUTEX_MAGIC))
+                return VERR_SEM_DESTROYED;
+
+            /*
+             * Act on the wakup code.
+             */
+            if (rc == -ETIMEDOUT)
+            {
+                Assert(pTimeout);
+                iOld = ASMAtomicXchgS32(&pIntMutexSem->iState, 2);
+                return VERR_TIMEOUT;
+            }
+            if (rc == 0)
+                /* we'll leave the loop now unless another thread is faster */;
+            else if (rc == -EWOULDBLOCK)
+                /* retry with new value. */;
+            else if (rc == -EINTR)
+            {
+                if (!fAutoResume)
+                    return VERR_INTERRUPTED;
+            }
+            else
+            {
+                /* this shouldn't happen! */
+                AssertMsgFailed(("rc=%ld errno=%d\n", rc, errno));
+                return RTErrConvertFromErrno(rc);
+            }
+
+            iOld = ASMAtomicXchgS32(&pIntMutexSem->iState, 2);
+        }
+    }
+
+    /*
+     * Set the owner and nesting.
+     */
+    pIntMutexSem->Owner = Self;
+    ASMAtomicXchgU32(&pIntMutexSem->cNesting, 1);
+    return VINF_SUCCESS;
+}
+
+
+RTDECL(int)  RTSemMutexRequest(RTSEMMUTEX MutexSem, unsigned cMillies)
+{
+    int rc = rtsemMutexRequest(MutexSem, cMillies, true);
+    Assert(rc != VERR_INTERRUPTED);
+    return rc;
+}
+
+
+RTDECL(int)  RTSemMutexRequestNoResume(RTSEMMUTEX MutexSem, unsigned cMillies)
+{
+    return rtsemMutexRequest(MutexSem, cMillies, false);
+}
+
+
+RTDECL(int)  RTSemMutexRelease(RTSEMMUTEX MutexSem)
+{
+    /*
+     * Validate input.
+     */
+    struct RTSEMMUTEXINTERNAL *pIntMutexSem = MutexSem;
+    if (!rtsemMutexValid(pIntMutexSem))
+    {
+        AssertMsgFailed(("Invalid handle %p!\n", MutexSem));
+        return VERR_INVALID_HANDLE;
+    }
+
+    /*
+     * Check if nested.
+     */
+    pthread_t Self = pthread_self();
+    if (    pIntMutexSem->Owner != Self
+        ||  pIntMutexSem->cNesting == (uint32_t)~0)
+    {
+        AssertMsgFailed(("Not owner of mutex %p!! Self=%08x Owner=%08x cNesting=%d\n",
+                         pIntMutexSem, Self, pIntMutexSem->Owner, pIntMutexSem->cNesting));
+        return VERR_NOT_OWNER;
+    }
+
+    /*
+     * If nested we'll just pop a nesting.
+     */
+    if (pIntMutexSem->cNesting > 1)
+    {
+        pIntMutexSem->cNesting--;
+        return VINF_SUCCESS;
+    }
+
+    /*
+     * Clear the state. (cNesting == 1)
+     */
+    pIntMutexSem->Owner = (pthread_t)~0;
+    ASMAtomicXchgU32(&pIntMutexSem->cNesting, 0);
+
+    /*
+     * Release the mutex.
+     */
+    int32_t iNew = ASMAtomicDecS32(&pIntMutexSem->iState);
+    if (iNew != 0)
+    {
+        /* somebody is waiting, try wake up one of them. */
+        pIntMutexSem->iState = 0;
+        (void)sys_futex(&pIntMutexSem->iState, FUTEX_WAKE, 1, NULL, NULL, 0);
+    }
+    return VINF_SUCCESS;
+}
+#endif /* VBOX_REWRITTEN_MUTEX */