Changeset 2298

Timestamp:

Aug 22, 2005, 2:14:50 AM (20 years ago)

Author:

bird

Message:

Tried to workaround the race conditions in libc_Back_safesemEvSleep/Wakeup.
These might affect SysV sems. (2nd try)

Location:

trunk/src/emx

Files:

• ChangeLog.LIBC (modified) (1 diff, 1 prop)
• include/InnoTekLIBC/backend.h (modified) (9 diffs, 1 prop)
• src/lib/sys/safesems.c (modified) (24 diffs, 1 prop)
• src/lib/sys/sysv_sem.c (modified) (32 diffs, 1 prop)
• src/lib/sys/sysv_shm.c (modified) (22 diffs, 1 prop)

trunk/src/emx/ChangeLog.LIBC

@@ -6 +6 @@
     - libc:
         o Tried to workaround the race conditions in __libc_Back_safesemEvSleep/Wakeup.
-          These might affect SysV sems and shm.
+          These might affect SysV sems.
         o Corrected the declarations of _DLL_InitTerm.
 

trunk/src/emx/include/InnoTekLIBC/backend.h

@@ -967 +967 @@
  * @{ */
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 /**
  * Creates a safe mutex sem.
@@ -972 +988 @@
  * @returns 0 on success.
  * @returns Negative error code (errno.h) on failure.
- * @param   phmtx       Where to store the semaphore handle.
+ * @param   pe.
  * @param   fShared     Set if the semaphore should be sharable between processes.
  */
-int __libc_Back_safesemMtxCreate(uintptr_t *phmtx, int fShared);
+int __libc_Back_safesemMtxCreate(mtx, int fShared);
 
 /**
@@ -982 +998 @@
  * @returns 0 on success.
  * @returns Negative error code (errno.h) on failure.
- * @param   hmtx        The semaphore handle.
- */
-int __libc_Back_safesemMtxOpen(uintptr_t hmtx);
+ * @param   e.
+ */
+int __libc_Back_safesemMtxOpen(mtx);
 
 /**
@@ -991 +1007 @@
  * @returns 0 on success.
  * @returns Negative error code (errno.h) on failure.
- * @param   hmtx        The semaphore handle.
- */
-int __libc_Back_safesemMtxClose(uintptr_t hmtx);
+ * @param   e.
+ */
+int __libc_Back_safesemMtxClose(mtx);
 
 /**
@@ -1000 +1016 @@
  * @returns 0 on success.
  * @returns Negative errno on failure.
- * @param   hmtx    Handle to the mutex.
- */
-int __libc_Back_safesemMtxLock(uintptr_t hmtx);
+ * @param   .
+ */
+int __libc_Back_safesemMtxLock(mtx);
 
 /**
@@ -1009 +1025 @@
  * @returns 0 on success.
  * @returns Negative errno on failure.
- * @param   hmtx    Handle to the mutex.
- */
-int __libc_Back_safesemMtxUnlock(uintptr_t hmtx);
+ * @param   pmtx        Pointer to the semaphore structure.
+ */
+int __libc_Back_safesemMtxUnlock(__LIBC_PSAFESEMMTX pmtx);
+
+
+/** 
+ * Safe Event Semaphore structure.
+ *
+ * For shared semaphores this structure must be in shared memory so all users 
+ * actually use the very same structure.
+ *
+ * @remark  The event semaphore business is difficult because the lack of 
+ *          atomic mutex release + event wait apis in OS/2. We have to 
+ *          jump around the place to get this working nearly safly...
+ */
+typedef struct __LIBC_SAFESEMEV
+{
+#ifdef __OS2__
+    /** The event semaphore. */
+    unsigned long       hev;
+#endif 
+    /** Number of threads which are supposed to be blocking on the above event semaphore. */
+    uint32_t volatile   cWaiters;
+    /** The mutex semaphore used to protect the event semaphore. */
+    __LIBC_PSAFESEMMTX  pmtx;
+    /** Set if the semaphore is shared. 
+     * If shared this structure is allocated from SPM, else it's from the heap. */
+    unsigned            fShared;
+} __LIBC_SAFESEMEV;
+/** Pointer to a SAFESEM Event structure. */
+typedef __LIBC_SAFESEMEV *__LIBC_PSAFESEMEV;
 
 /**
@@ -1018 +1062 @@
  * @returns 0 on success.
  * @returns Negative error code (errno.h) on failure.
- * @param   phev        Where to store the semaphore handle.
+ * @param   pev         Pointer to the semaphore structure to initialize.
+ * @param   pmtx        Pointer to the mutex semaphore which protects the event semaphore.
  * @param   fShared     Set if the semaphore should be sharable between processes.
  */
-int __libc_Back_safesemEvCreate(uintptr_t *phev, int fShared);
+int __libc_Back_safesemEvCreate(, int fShared);
 
 /**
  * Opens a shared safe event sem.
  *
- * @returns 0 on success.
- * @returns Negative error code (errno.h) on failure.
- * @param   hev         The semaphore handle.
- */
-int __libc_Back_safesemEvOpen(uintptr_t hev);
+ * The caller is responsible for opening the associated mutex 
+ * semaphore before calling this function.
+ *
+ * @returns 0 on success.
+ * @returns Negative error code (errno.h) on failure.
+ * @param   pev         Pointer to the semaphore structure to open.
+ */
+int __libc_Back_safesemEvOpen(__LIBC_PSAFESEMEV pev);
 
 /**
@@ -1037 +1085 @@
  * @returns 0 on success.
  * @returns Negative error code (errno.h) on failure.
- * @param   hev         The semaphore handle.
- */
-int __libc_Back_safesemEvClose(uintptr_t hev);
+ * @param   e.
+ */
+int __libc_Back_safesemEvClose(ev);
 
 /**
  * Sleep on a semaphore.
  *
- * This is the most difficult thing we're doing in this file.
- *
- * @returns 0 on success.
- * @returns Negative error code (errno.h) on failure.
- *
- * @param   hev         The semaphore to sleep on.
- * @param   hmtx        The semaphore protecting hev and which is to be unlocked while
- *                      sleeping and reaquired upon waking up.
- * @param   pfnComplete Function to execute on signal and on wait completion.
+ * The caller must own the associated mutex semaphore. The mutex semaphore will 
+ * be released as we go to sleep and reclaimed when we wake up. 
+ *
+ * The pfnComplete callback is used to correct state before signals are handled. 
+ * It will always be called be for this function returns, and it'll either be under
+ * the protection of the signal mutex or the associated mutex (both safe sems).
+ *
+ * This is the most difficult thing we're doing in this API. On OS/2 we have 
+ * potential (at least theoretically) race conditions...
+ *
+ * @returns 0 on success.
+ * @returns Negative error code (errno.h) on failure.
+ *
+ * @param   pev         Pointer to the semaphore structure to sleep on.
+ * @param   pfnComplete Function to execute on signal or on wait completion.
  * @param   pvUser      User argument to pfnComplete.
  */
-int __libc_Back_safesemEvSleep(uintptr_t hev, uintptr_t hmtx, void (*pfnComplete)(void *pvUser), void *pvUser);
+int __libc_Back_safesemEvSleep(, void (*pfnComplete)(void *pvUser), void *pvUser);
 
 /**
@@ -1062 +1116 @@
  * @returns 0 on success.
  * @returns Negative error code (errno.h) on failure.
- * @param   hev         Event semaphore to post.
- * @param   hmtx        The semaphore protecting hev (see __libc_Back_safesemEvSleep).
- *                      The caller should own this semaphore, it's purpose is debug strictness only!
- */
-int __libc_Back_safesemEvWakeup(uintptr_t hev, uintptr_t hmtx);
+ * @param   pev         Pointer to the semaphore structure to post.
+ */
+int __libc_Back_safesemEvWakeup(__LIBC_PSAFESEMEV pev);
 
 

trunk/src/emx/src/lib/sys/safesems.c

@@ -38 +38 @@
 #include <sys/errno.h>
 #include "syscalls.h"
-#include <emx/umalloc.h>
+#include <sys/builtin.h>
+#include <InnoTekLIBC/FastInfoBlocks.h>
 #include <InnoTekLIBC/thread.h>
 #include <InnoTekLIBC/backend.h>
-#include <InnoTekLIBC/sharedpm.h>
 #define __LIBC_LOG_GROUP    __LIBC_LOG_GRP_BACK_IPC
 #include <InnoTekLIBC/logstrict.h>
@@ -49 +49 @@
 *   Structures and Typedefs                                                    *
 *******************************************************************************/
-/**
- * Event semaphore tracking structure.
- *
- * The event semaphore business is difficult because the lack of 
- * atomic mutex release + event wait apis in OS/2. We have to 
- * jump around the place to get this working nearly safly...
- */      
-typedef struct __LIBC_SAFESEMEV
-{
-    /** The event semaphore. */
-    HEV                 hev;
-    /** Number of threads which are supposed to be blocking on the above event semaphore. */
-    uint32_t volatile   cWaiters;
-    /** Number of processes using the semaphore. */
-    uint32_t volatile   cUsers;
-    /** Set if the semaphore is shared. 
-     * If shared this structure is allocated from SPM, else it's from the heap. */
-    unsigned            fShared;
-#ifdef __LIBC_STRICT
-    /** The mutex semaphore used to protect the event semaphore. 
-     * Strict builds only. */
-    uintptr_t           hmtx;
-#endif
-} __LIBC_SAFESEMEV, *__LIBC_PSAFESEMEV;
-
-
 /**
  * Arguments to semEvSleepSignalCallback().
@@ -100 +74 @@
  * @returns 0 on success.
  * @returns Negative error code (errno.h) on failure.
- * @param   phmtx       Where to store the semaphore handle.
+ * @param   pe.
  * @param   fShared     Set if the semaphore should be sharable between processes.
  */
-int __libc_Back_safesemMtxCreate(uintptr_t *phmtx, int fShared)
-{
-    FS_VAR_SAVE_LOAD();
-    HMTX hmtx = NULLHANDLE;
-    int rc = DosCreateMutexSemEx(NULL, &hmtx, fShared ? DC_SEM_SHARED : 0, FALSE);
-    FS_RESTORE();
+int __libc_Back_safesemMtxCreate(__LIBC_PSAFESEMMTX pmtx, int fShared)
+{
+    LIBCLOG_ENTER("pmtx=%p fShared=%d\n", (void *)pmtx, fShared);
+    pmtx->hmtx = NULLHANDLE;
+    int rc = DosCreateMutexSemEx(NULL, &pmtx->hmtx, fShared ? DC_SEM_SHARED : 0, FALSE);
     if (rc)
-        return -__libc_native2errno(rc);
-    *phmtx = hmtx;
-    return 0;
+        rc = -__libc_native2errno(rc);
+    LIBCLOG_RETURN_MSG(rc, "ret %d hmtx=%#lx\n", rc, pmtx->hmtx);
 }
 
@@ -121 +93 @@
  * @returns 0 on success.
  * @returns Negative error code (errno.h) on failure.
- * @param   hmtx        The semaphore handle.
- */
-int __libc_Back_safesemMtxOpen(uintptr_t hmtx)
-{
-    FS_VAR_SAVE_LOAD();
-    HMTX hmtxOS2 = hmtx;
-    int rc = DosOpenMutexSemEx(NULL, &hmtxOS2);
-    FS_RESTORE();
+ * @param   pmtx        Pointer to the semaphore structure.
+ */
+int __libc_Back_safesemMtxOpen(__LIBC_PSAFESEMMTX pmtx)
+{
+    LIBCLOG_ENTER("pmtx=%p:{.hmtx=%#lx}\n", (void *)pmtx, pmtx->hmtx);
+    int rc = DosOpenMutexSemEx(NULL, &pmtx->hmtx);
     if (rc)
-        return -__libc_native2errno(rc);
-    return 0;
+        r -__libc_native2errno(rc);
+    ;
 }
 
@@ -140 +110 @@
  * @returns 0 on success.
  * @returns Negative error code (errno.h) on failure.
- * @param   hmtx        The semaphore handle.
- */
-int __libc_Back_safesemMtxClose(uintptr_t hmtx)
-{
-    FS_VAR_SAVE_LOAD();
-    int rc = DosCloseMutexSemEx(hmtx);
-    FS_RESTORE();
-    if (rc)
-        return -__libc_native2errno(rc);
-    return 0;
+ * @param   pmtx        Pointer to the semaphore structure.
+ */
+int __libc_Back_safesemMtxClose(__LIBC_PSAFESEMMTX pmtx)
+{
+    LIBCLOG_ENTER("pmtx=%p:{.hmtx=%#lx}\n", (void *)pmtx, pmtx->hmtx);
+    int rc = DosCloseMutexSemEx(pmtx->hmtx);
+    if (!rc)
+        rc = -__libc_native2errno(rc);
+    LIBCLOG_RETURN_INT(rc);
 }
 
@@ -157 +126 @@
  * stack available. If there isn't, a crash is usually the
  * result.
+
  * @internal
  */
@@ -175 +145 @@
  * @returns 0 on success.
  * @returns Negative errno on failure.
- * @param   hmtx    Handle to the mutex.
- */
-int __libc_Back_safesemMtxLock(uintptr_t hmtx)
-{
-    LIBCLOG_ENTER("hmtx=%#x\n", hmtx);
-    ULONG       ul;
+ * @param   pmtx        Pointer to the semaphore structure.
+ */
+int __libc_Back_safesemMtxLock(__LIBC_PSAFESEMMTX pmtx)
+{
+    LIBCLOG_ENTER("pmtx=%p:{.hmtx=%#lx}\n", (void *)pmtx, pmtx->hmtx);
+    ULONG       ul = 0;
+    HMTX        hmtx = pmtx->hmtx;
     int         rc;
     FS_VAR();
@@ -194 +165 @@
 
     /*
-     * Request semaphore and enter "must complete section" to avoid signal trouble.
+     * Request semaphore and enter "mustcomplete section" to avoid signal trouble.
      */
     FS_SAVE_LOAD();
+
+
+
+
+
+
+
+
+
+
+
     rc = DosRequestMutexSem(hmtx, 30*1000);
     DosEnterMustComplete(&ul);
@@ -207 +189 @@
     /* failure out */
     DosExitMustComplete(&ul);
-    LIBC_ASSERTM_FAILED("DosRequestMutexSem(%x) failed with rc=%d!\n", hmtx, rc);
+    LIBC_ASSERTM_FAILED("DosRequestMutexSem(%hmtx, rc);
     rc = -__libc_native2errno(rc);
     FS_RESTORE();
@@ -219 +201 @@
  * @returns 0 on success.
  * @returns Negative errno on failure.
- * @param   hmtx    Handle to the mutex.
- */
-int __libc_Back_safesemMtxUnlock(uintptr_t hmtx)
-{
-    LIBCLOG_ENTER("hmtx=%#x\n", hmtx);
-    ULONG   ul = 0;
-    int     rc;
+ * @param   .
+ */
+int __libc_Back_safesemMtxUnlock(mtx)
+{
+    LIBCLOG_ENTER("hmtx);
+    ULONG   ul = 0;
+    int     rc;
     FS_VAR();
 
@@ -232 +214 @@
      */
     FS_SAVE_LOAD();
-    rc = DosReleaseMutexSem(hmtx);
+    rc = DosReleaseMutexSem(hmtx);
     if (rc)
     {
         FS_RESTORE();
-        LIBC_ASSERTM_FAILED("DosReleaseMutexSem(%x) -> %d\n", hmtx, rc);
+        LIBC_ASSERTM_FAILED("DosReleaseMutexSem(%hmtx, rc);
         rc = -__libc_native2errno(rc);
         LIBCLOG_RETURN_INT(rc);
@@ -248 +230 @@
 
 
+
 /**
  * Creates a safe event sem.
@@ -253 +236 @@
  * @returns 0 on success.
  * @returns Negative error code (errno.h) on failure.
- * @param   phev        Where to store the semaphore handle.
+ * @param   pev         Pointer to the semaphore structure to initialize.
+ * @param   pmtx        Pointer to the mutex semaphore which protects the event semaphore.
  * @param   fShared     Set if the semaphore should be sharable between processes.
  */
-int __libc_Back_safesemEvCreate(uintptr_t *phev, int fShared)
-{
-    LIBCLOG_ENTER("phev=%p fShared=%d\n", (void *)phev, fShared);
-    int rc;
-    __LIBC_PSAFESEMEV pEv = NULL;
-    FS_VAR_SAVE_LOAD();
-    if (fShared)
-    {
-        /*
-         * Allocate from SPM, be very careful.
-         */
-        __LIBC_SPMXCPTREGREC RegRec;
-        rc = __libc_spmLock(&RegRec, NULL);
-        if (!rc)
-        {
-            pEv = __libc_spmAllocLocked(sizeof(*pEv));
-            if (pEv)
-            {
-                pEv->hev = NULLHANDLE;
-                pEv->cWaiters = 0;
-                pEv->cUsers = 1;
-                pEv->fShared = fShared;
-#ifdef __LIBC_STRICT
-                pEv->hmtx = 0;
-#endif 
-            
-                rc = DosCreateEventSemEx(NULL, &pEv->hev, fShared ? DC_SEM_SHARED : 0, FALSE);
-                if (rc)
-                {
-                    __libc_spmFree(pEv);
-                    rc = -__libc_native2errno(rc);
-                }
-            }
-            else
-                rc = -ENOMEM;
-            __libc_spmUnlock(&RegRec);
-        }
-    }
-    else
-    {
-        /*
-         * Allocate from high mem heap.
-         */
-        pEv = _hmalloc(sizeof(*pEv));
-        if (pEv)
-        {
-            pEv->hev = NULLHANDLE;
-            pEv->cWaiters = 0;
-            pEv->cUsers = 1;
-            pEv->fShared = fShared;
-#ifdef __LIBC_STRICT
-            pEv->hmtx = 0;
-#endif 
-
-            rc = DosCreateEventSemEx(NULL, &pEv->hev, fShared ? DC_SEM_SHARED : 0, FALSE);
-            if (rc)
-            {
-                free(pEv);
-                rc = -__libc_native2errno(rc);
-            }
-        }
-        else
-            rc = -ENOMEM;
-    }
-    FS_RESTORE();
-
-    if (!rc)
-        *phev = (uintptr_t)pEv;
-    LIBCLOG_RETURN_MSG(rc, "ret %d *phev=%#x\n", rc, *phev);
+int __libc_Back_safesemEvCreate(__LIBC_PSAFESEMEV pev, __LIBC_PSAFESEMMTX pmtx, int fShared)
+{
+    LIBCLOG_ENTER("phev=%p pmtx=%p:{.hmtx=%#lx} fShared=%d\n", (void *)pev, (void *)pmtx, pmtx->hmtx, fShared);
+
+    pev->hev        = NULLHANDLE;
+    pev->cWaiters   = 0;
+    pev->pmtx       = pmtx;
+    pev->fShared    = fShared;
+
+    int rc = DosCreateEventSemEx(NULL, &pev->hev, fShared ? DC_SEM_SHARED : 0, FALSE);
+    if (rc)
+        rc = -__libc_native2errno(rc);
+
+    LIBCLOG_RETURN_MSG(rc, "ret %d pev->hev=%#lx\n", rc, pev->hev);
 }
 
@@ -331 +260 @@
  * Opens a shared safe event sem.
  *
- * @returns 0 on success.
- * @returns Negative error code (errno.h) on failure.
- * @param   hev         The semaphore handle.
- */
-int __libc_Back_safesemEvOpen(uintptr_t hev)
-{
-    LIBCLOG_ENTER("hev=%#x\n", hev);
-    __LIBC_PSAFESEMEV pEv = (__LIBC_PSAFESEMEV)hev;
-    FS_VAR_SAVE_LOAD();
-    int rc = DosOpenEventSemEx(NULL, &pEv->hev);
-    FS_RESTORE();
-    if (!rc)
-        __atomic_increment_u32(&pEv->cUsers);
-    else
-        rc = -__libc_native2errno(rc);
+ * The caller is responsible for opening the associated mutex
+ * semaphore before calling this function.
+ *
+ * @returns 0 on success.
+ * @returns Negative error code (errno.h) on failure.
+ * @param   pev         Pointer to the semaphore structure to open.
+ */
+int __libc_Back_safesemEvOpen(__LIBC_PSAFESEMEV pev)
+{
+    LIBCLOG_ENTER("pev=%p:{.hev=%#lx .cWaiters=%d .pmtx=%p .fShared=%d}\n",
+                  (void *)pev, pev->hev, pev->cWaiters, (void *)pev->pmtx, pev->fShared);
+
+    int rc = DosOpenEventSemEx(NULL, &pev->hev);
+    if (rc)
+        rc = -__libc_native2errno(rc);
+
     LIBCLOG_RETURN_INT(rc);
 }
@@ -355 +285 @@
  * @returns 0 on success.
  * @returns Negative error code (errno.h) on failure.
- * @param   hev         The semaphore handle.
- */
-int __libc_Back_safesemEvClose(uintptr_t hev)
-{
-    LIBCLOG_ENTER("hev=%#x\n", hev);
-    __LIBC_PSAFESEMEV pEv = (__LIBC_PSAFESEMEV)hev;
-    FS_VAR_SAVE_LOAD();
-    int rc = DosCloseEventSemEx(pEv->hev);
-    FS_RESTORE();
-    if (!rc)
-    {
-        if (    pEv->cUsers
-            &&  !__atomic_decrement_u32(&pEv->cUsers))
-        {
-            pEv->hev = NULLHANDLE;
-            if (pEv->fShared)
-                __libc_spmFree(pEv);
-            else
-                free(pEv);
-        }
-    }
-    else
-        rc = -__libc_native2errno(rc);
+ * @param   pev         Pointer to the semaphore structure to close.
+ */
+int __libc_Back_safesemEvClose(__LIBC_PSAFESEMEV pev)
+{
+    LIBCLOG_ENTER("pev=%p:{.hev=%#lx .cWaiters=%d .pmtx=%p .fShared=%d}\n",
+                  (void *)pev, pev->hev, pev->cWaiters, (void *)pev->pmtx, pev->fShared);
+
+    int rc = DosCloseEventSemEx(pev->hev);
+    if (rc)
+        rc = -__libc_native2errno(rc);
+
     LIBCLOG_RETURN_INT(rc);
 }
@@ -398 +316 @@
         int rc = DosSetPriority(PRTYS_THREAD, pArgs->ulOldPri >> 8, pArgs->ulOldPri & 0xff, 0);
         if (rc)
-            __libc_Back_panic(0, NULL, "DosSetPriority(PRTYS_THREAD, %x, %x, 0) -> %d\n", 
+            __libc_Back_panic(0, NULL, "DosSetPriority(PRTYS_THREAD, %x, %x, 0) -> %d
                               (unsigned)pArgs->ulOldPri >> 8, (unsigned)pArgs->ulOldPri & 0xff, rc);
         pArgs->fDone = 1;
@@ -409 +327 @@
  * Sleep on a semaphore.
  *
- * This is the most difficult thing we're doing in this file.
- *
- * @returns 0 on success.
- * @returns Negative error code (errno.h) on failure.
- *
- * @param   hev         The semaphore to sleep on.
- * @param   hmtx        The semaphore protecting hev and which is to be unlocked while
- *                      sleeping and reaquired upon waking up.
- * @param   pfnComplete Function to execute on signal and on wait completion.
+ * The caller must own the associated mutex semaphore. The mutex semaphore will
+ * be released as we go to sleep and reclaimed when we wake up.
+ *
+ * The pfnComplete callback is used to correct state before signals are handled.
+ * It will always be called be for this function returns, and it'll either be under
+ * the protection of the signal mutex or the associated mutex (both safe sems).
+ *
+ * This is the most difficult thing we're doing in this API. On OS/2 we have
+ * potential (at least theoretically) race conditions...
+ *
+ * @returns 0 on success.
+ * @returns Negative error code (errno.h) on failure.
+ *
+ * @param   pev         Pointer to the semaphore structure to sleep on.
+ * @param   pfnComplete Function to execute on signal or on wait completion.
  * @param   pvUser      User argument to pfnComplete.
  */
-int __libc_Back_safesemEvSleep(uintptr_t hev, uintptr_t hmtx, void (*pfnComplete)(void *pvUser), void *pvUser)
-{
-    LIBCLOG_ENTER("hev=%#x hmtx=%#x pfnComplete=%p pvUser=%p\n", hev, hmtx, (void *)pfnComplete, pvUser);
-    __LIBC_PSAFESEMEV pEv = (__LIBC_PSAFESEMEV)hev;
-
-#ifdef __LIBC_STRICT
-    /*
-     * Keep track of hmtx.
-     */
-    if (pEv->hmtx)
-        LIBC_ASSERTM(pEv->hmtx == hmtx, "pEv->hmtx=%#x hmtx=%#x\n", pEv->hmtx, hmtx);
-    else
-        pEv->hmtx = hmtx;
-#endif 
+int __libc_Back_safesemEvSleep(__LIBC_PSAFESEMEV pev, void (*pfnComplete)(void *pvUser), void *pvUser)
+{
+    LIBCLOG_ENTER("pev=%p:{.hev=%#lx .cWaiters=%d .pmtx=%p .fShared=%d} pfnComplete=%p pvUser=%p\n",
+                  (void *)pev, pev->hev, pev->cWaiters, (void *)pev->pmtx, pev->fShared, (void *)pfnComplete, pvUser);
 
     /*
@@ -446 +360 @@
         PPIB    pPib;
         DosGetInfoBlocks(&pTib, &pPib);
-    
+
         struct SignalArgs Args;
         Args.ulOldPri       = pTib->tib_ptib2->tib2_ulpri;
@@ -453 +367 @@
         Args.pfnComplete    = pfnComplete;
         Args.pvUser         = pvUser;
-    
+
+        /* install signal callback. */
         pThrd->pvSigCallbackUser = &Args;
         pThrd->pfnSigCallback    = semEvSleepSignalCallback;
-    
+
         /*
-         * Raise priority to time critical to increase our chances of actually getting 
+         * Raise priority to time critical to increase our chances of actually getting
          * blocked before something bad like rescheduling or signaling strikes us.
          */
@@ -468 +383 @@
             LIBC_ASSERTM(!rc, "DosSetPriority(PRTYS_THREAD, PRTYC_TIMECRITICAL, 0, 0) -> %d\n", rc);
         }
-    
+
         /*
          * Release the sempahore and exit the must complete section.
          */
-        __atomic_increment_u32(&pEv->cWaiters);
-        rc = __libc_Back_safesemMtxUnlock(hmtx);
+        __atomic_increment_u32(&pv->cWaiters);
+        rc = __libc_Back_safesemMtxUnlock(mtx);
         if (!rc)
         {
@@ -481 +396 @@
             int rc2 = 0;
             if (!Args.fDone)
-                rc2 = DosWaitEventSem(pEv->hev, SEM_INDEFINITE_WAIT);
-    
+                rc2 = DosWaitEventSem(pv->hev, SEM_INDEFINITE_WAIT);
+
             /*
-             * Reclaim the ownership of the sempahore (w/must-complete) and deregister 
-             * the signal notification callback before we check if we was interrupted or not during the wait.
+             * Reclaim the ownership of the mutex and handle event semaphore errors.
              */
-            __atomic_decrement_u32(&pEv->cWaiters);
+            __atomic_decrement_u32(&pv->cWaiters);
             LIBCLOG_MSG("woke up - rc2=%d\n", rc2);
-            rc = __libc_Back_safesemMtxLock(hmtx);
-            pThrd->pfnSigCallback = NULL;
-            pThrd->pvSigCallbackUser = NULL;
-            if (!Args.fDone)
-            {
-                /* 
-                 * Not interrupted.
-                 * Check for errors, do completion and restore priority. 
-                 */
-                if (rc2)
-                    rc = -__libc_native2errno(rc2);
-                pfnComplete(pvUser);
-                rc2 = DosSetPriority(PRTYS_THREAD, Args.ulOldPri >> 8, Args.ulOldPri & 0xff, 0);
-                if (rc2)
-                    __libc_Back_panic(0, NULL, "DosSetPriority(PRTYS_THREAD, %x, %x, 0) -> %d\n", 
-                                      (unsigned)Args.ulOldPri >> 8, (unsigned)Args.ulOldPri & 0xff, rc2);
-            }
-            else if (!rc)
-                rc = -EINTR;
-    
+            rc = __libc_Back_safesemMtxLock(pev->pmtx);
+            if (!rc && rc2)
+                rc = -__libc_native2errno(rc2);
+
+            /*
+             * Restore priority before resetting the semaphore.
+             */
+            rc2 = DosSetPriority(PRTYS_THREAD, Args.ulOldPri >> 8, Args.ulOldPri & 0xff, 0);
+            if (rc2)
+                __libc_Back_panic(0, NULL, "DosSetPriority(PRTYS_THREAD, %x, %x, 0) -> %d (1)\n",
+                                  (unsigned)Args.ulOldPri >> 8, (unsigned)Args.ulOldPri & 0xff, rc2);
+            if (pev->cWaiters > 0)
+                DosSleep(0); /* hurry up guys */
+
             /*
              * Reset the event semaphore.
              */
             ULONG ulIgnore;
-            rc2 = DosResetEventSem(pEv->hev, &ulIgnore);
-            LIBC_ASSERTM(!rc2 && ERROR_ALREADY_RESET, "DosResetEventSem(%#lx,)->%d\n", pEv->hev, rc2);
+            rc2 = DosResetEventSem(pv->hev, &ulIgnore);
+            LIBC_ASSERTM(!rc2 && ERROR_ALREADY_RESET, "DosResetEventSem(%#lx,)->%d\n", pv->hev, rc2);
         }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
         FS_RESTORE();
     }
     else
+
+
         rc = -ENOSYS;
+
 
     LIBCLOG_RETURN_INT(rc);
@@ -528 +467 @@
  * Wakes up all threads sleeping on a given event semaphore.
  *
- * @returns 0 on success.
- * @returns Negative error code (errno.h) on failure.
- * @param   hev         Event semaphore to post.
- * @param   hmtx        The semaphore protecting hev (see __libc_Back_safesemEvSleep).
- *                      The caller should own this semaphore, it's purpose is debug strictness only!
- */
-int __libc_Back_safesemEvWakeup(uintptr_t hev, uintptr_t hmtx)
-{
-    LIBCLOG_ENTER("hev=%#x hmtx=%#x\n", hev, hmtx);
-    __LIBC_PSAFESEMEV pEv = (__LIBC_PSAFESEMEV)hev;
+ * The caller must own the associated mutex semaphore when calling this
+ * function.
+ *
+ * @returns 0 on success.
+ * @returns Negative error code (errno.h) on failure.
+ * @param   pev         Pointer to the semaphore structure to post.
+ */
+int __libc_Back_safesemEvWakeup(__LIBC_PSAFESEMEV pev)
+{
+    LIBCLOG_ENTER("pev=%p:{.hev=%#lx .cWaiters=%d .pmtx=%p .fShared=%d}\n",
+                  (void *)pev, pev->hev, pev->cWaiters, (void *)pev->pmtx, pev->fShared);
     FS_VAR_SAVE_LOAD();
     int rc;
@@ -543 +483 @@
 #ifdef __LIBC_STRICT
     /*
-     * Check hmtx.
+     * Check .
      */
-    LIBC_ASSERTM(!pEv->hmtx || pEv->hmtx == hmtx, "pEv->hmtx=%#x hmtx=%#x\n", pEv->hmtx, hmtx);
     ULONG   cNesting;
     PID     pid;
     TID     tid;
-    rc = DosQueryMutexSem(hmtx, &pid, &tid, &cNesting);
-    LIBC_ASSERTM(!rc, "DosQueryMutexSem(%#x,,,) -> %d\n", hmtx, rc);
+    rc = DosQueryMutexSem(hmtx, &pid, &tid, &cNesting);
+    LIBC_ASSERTM(!rc, "DosQueryMutexSem(%#hmtx, rc);
     if (!rc)
         LIBC_ASSERTM(pid == fibGetPid() && tid == fibGetTid(),
                      "pid=%d fibGetPid()->%d  tid=%d fibGetTid()->%d\n", (int)pid, fibGetPid(), (int)tid, fibGetTid());
-#endif 
+#endif
 
     /*
      * Post it.
      */
-    rc = DosPostEventSem(hev);
+    rc = DosPostEventSem(hev);
     if (!rc)
     {
-        if (!rc && pEv->cWaiters)
+        if (v->cWaiters)
         {
-            /* give the waiting threads a fair chance to get past the DosWaitEventSem() call. */
+            /*  */
             unsigned cYields = 3;
             do
             {
                 DosSleep(0);
-                LIBCLOG_MSG("cWaiters=%d cYields=%d\n", pEv->cWaiters, cYields);
-            } while (pEv->cWaiters && --cYields > 0);
+                LIBCLOG_MSG("cWaiters=%d cYields=%d\n", pv->cWaiters, cYields);
+            } while (pv->cWaiters && --cYields > 0);
         }
     }
@@ -580 +519 @@
             rc = -__libc_native2errno(rc);
     }
+
     FS_RESTORE();
     LIBCLOG_RETURN_INT(rc);

trunk/src/emx/src/lib/sys/sysv_sem.c

@@ -51 +51 @@
     struct semid_ds u;
     /** Event semaphore to wait on. */
-    uintptr_t       hev;
-    /** Mutex protecting the semid_ds and hev members. */
-    uintptr_t       hmtx;
+    ev;
+    /** Mutex protecting the semid_ds and ev members. */
+    mtx;
 };
 
@@ -74 +74 @@
     struct sem         *sem;
     /** Mutex protecting the undo list and other global sem stuff. */
-    uintptr_t           hmtx;
+    mtx;
     /** list of active undo structures. */
     SLIST_HEAD(, sem_undo) semu_list;
@@ -95 +95 @@
 //static int    *semu;          /* undo structure pool */
 
-//#define SEMUNDO_MTX           gpGlobals->hmtx
-#define SEMUNDO_LOCK()          __libc_Back_safesemMtxLock(gpGlobals->hmtx);
-#define SEMUNDO_UNLOCK()        __libc_Back_safesemMtxUnlock(gpGlobals->hmtx);
-#define SEMUNDO_LOCKASSERT(how) do {} while (0) //mtx_assert(gpGlobals->hmtx, (how));
+//#define SEMUNDO_MTX           gpGlobals->mtx
+#define SEMUNDO_LOCK()          __libc_Back_safesemMtxLock(mtx);
+#define SEMUNDO_UNLOCK()        __libc_Back_safesemMtxUnlock(mtx);
+#define SEMUNDO_LOCKASSERT(how) do {} while (0) //mtx_assert(mtx, (how));
 
 struct sem {
@@ -306 +306 @@
             bzero(pGlobals, cb);
             //pGlobals->cUsers    = 0;
-            pGlobals->uVersion  = 1;
+            pGlobals->uVersion  = ;
             //pGlobals->semtot    = 0;
             uint8_t *pu8  = (uint8_t *)(pGlobals + 1);
@@ -322 +322 @@
         }
     }
+
+
+
+
+
+
+
+
+
 
     /*
@@ -330 +339 @@
     {
         /* create */
-        rc = __libc_Back_safesemMtxCreate(&pGlobals->hmtx, 1);
+        rc = __libc_Back_safesemMtxCreate(&pGlobals->mtx, 1);
         for (i = 0; i < pGlobals->seminfo.semmni && !rc; i++)
-            rc = __libc_Back_safesemMtxCreate(&pGlobals->sema[i].hmtx, 1);
+            rc = __libc_Back_safesemMtxCreate(&pGlobals->sema[i].mtx, 1);
         for (i = 0; i < pGlobals->seminfo.semmni && !rc; i++)
-            rc = __libc_Back_safesemEvCreate(&pGlobals->sema[i].hev, 1);
+            rc = __libc_Back_safesemEvCreate(&pGlobals->sema[i]., 1);
     }
     else
     {
         /* open */
-        rc = __libc_Back_safesemMtxOpen(pGlobals->hmtx);
+        rc = __libc_Back_safesemMtxOpen(mtx);
         for (i = 0; i < pGlobals->seminfo.semmni && !rc; i++)
-            rc = __libc_Back_safesemMtxOpen(pGlobals->sema[i].hmtx);
+            rc = __libc_Back_safesemMtxOpen(mtx);
         for (i = 0; i < pGlobals->seminfo.semmni && !rc; i++)
-            rc = __libc_Back_safesemEvOpen(pGlobals->sema[i].hev);
+            rc = __libc_Back_safesemEvOpen(ev);
     }
     __atomic_increment_u32(&pGlobals->cUsers);
@@ -562 +571 @@
         u_short usval, count;
         uid_t uid;
-        uintptr_t hmtx;
+        mtx;
         int semid_in = semid;
 
@@ -580 +589 @@
         error = 0;
         rval = 0;
-        hmtx = NULLHANDLE;
+        ;
 
         switch(cmd) {
@@ -587 +596 @@
                         LIBCLOG_ERROR_RETURN_INT(-EINVAL);
                 semaptr = &sema[semid];
-                __libc_Back_safesemMtxLock(hmtx = semaptr->hmtx);
+                __libc_Back_safesemMtxLock(mtx);
                 if ((semaptr->u.sem_perm.mode & SEM_ALLOC) == 0) {
                         error = EINVAL;
@@ -594 +603 @@
                 if ((error = -__libc_spmCanIPC(&semaptr->u.sem_perm, IPC_R)))
                         goto done2;
-                __libc_Back_safesemMtxUnlock(hmtx); hmtx = NULLHANDLE;
+                __libc_Back_safesemMtxUnlock(;
                 memcpy(real_arg.buf, &semaptr->u, sizeof(struct semid_ds));
                 rval = IXSEQ_TO_IPCID(semid, semaptr->u.sem_perm);
@@ -608 +617 @@
         switch (cmd) {
         case IPC_RMID:
-                __libc_Back_safesemMtxLock(hmtx = semaptr->hmtx);
+                __libc_Back_safesemMtxLock(mtx);
                 if ((error = semvalid(semid_in, semaptr)) != 0)
                         goto done2;
@@ -628 +637 @@
                 semundo_clear(semid, -1);
                 SEMUNDO_UNLOCK();
-                __libc_Back_safesemEvWakeup(semaptr->hev, semaptr->hmtx);
+                __libc_Back_safesemEvWakeup();
                 break;
 
@@ -634 +643 @@
                 if ((error = copyin(real_arg.buf, &sbuf, sizeof(sbuf))) != 0)
                         goto done2;
-                __libc_Back_safesemMtxLock(hmtx = semaptr->hmtx);
+                __libc_Back_safesemMtxLock(mtx);
                 if ((error = semvalid(semid_in, semaptr)) != 0)
                         goto done2;
@@ -647 +656 @@
 
         case IPC_STAT:
-                __libc_Back_safesemMtxLock(hmtx = semaptr->hmtx);
+                __libc_Back_safesemMtxLock(mtx);
                 if ((error = semvalid(semid_in, semaptr)) != 0)
                         goto done2;
@@ -653 +662 @@
                         goto done2;
                 sbuf = semaptr->u;
-                __libc_Back_safesemMtxUnlock(hmtx); hmtx = NULLHANDLE;
+                __libc_Back_safesemMtxUnlock(;
                 error = copyout(semaptr, real_arg.buf,
                                 sizeof(struct semid_ds));
@@ -659 +668 @@
 
         case GETNCNT:
-                __libc_Back_safesemMtxLock(hmtx = semaptr->hmtx);
+                __libc_Back_safesemMtxLock(mtx);
                 if ((error = semvalid(semid_in, semaptr)) != 0)
                         goto done2;
@@ -672 +681 @@
 
         case GETPID:
-                __libc_Back_safesemMtxLock(hmtx = semaptr->hmtx);
+                __libc_Back_safesemMtxLock(mtx);
                 if ((error = semvalid(semid_in, semaptr)) != 0)
                         goto done2;
@@ -685 +694 @@
 
         case GETVAL:
-                __libc_Back_safesemMtxLock(hmtx = semaptr->hmtx);
+                __libc_Back_safesemMtxLock(mtx);
                 if ((error = semvalid(semid_in, semaptr)) != 0)
                         goto done2;
@@ -699 +708 @@
         case GETALL:
                 array = _hmalloc(sizeof(*array) * semaptr->u.sem_nsems);
-                __libc_Back_safesemMtxLock(hmtx = semaptr->hmtx);
+                __libc_Back_safesemMtxLock(mtx);
                 if ((error = semvalid(semid_in, semaptr)) != 0)
                         goto done2;
@@ -706 +715 @@
                 for (i = 0; i < semaptr->u.sem_nsems; i++)
                         array[i] = semaptr->u.sem_base[i].semval;
-                __libc_Back_safesemMtxUnlock(hmtx); hmtx = NULLHANDLE;
+                __libc_Back_safesemMtxUnlock(;
                 error = copyout(array, real_arg.array,
                     i * sizeof(real_arg.array[0]));
@@ -712 +721 @@
 
         case GETZCNT:
-                __libc_Back_safesemMtxLock(hmtx = semaptr->hmtx);
+                __libc_Back_safesemMtxLock(mtx);
                 if ((error = semvalid(semid_in, semaptr)) != 0)
                         goto done2;
@@ -725 +734 @@
 
         case SETVAL:
-                __libc_Back_safesemMtxLock(hmtx = semaptr->hmtx);
+                __libc_Back_safesemMtxLock(mtx);
                 if ((error = semvalid(semid_in, semaptr)) != 0)
                         goto done2;
@@ -742 +751 @@
                 semundo_clear(semid, semnum);
                 SEMUNDO_UNLOCK();
-                __libc_Back_safesemEvWakeup(semaptr->hev, semaptr->hmtx);
+                __libc_Back_safesemEvWakeup();
                 break;
 
         case SETALL:
-                __libc_Back_safesemMtxLock(hmtx = semaptr->hmtx);
+                __libc_Back_safesemMtxLock(mtx);
 raced:
                 if ((error = semvalid(semid_in, semaptr)) != 0)
                         goto done2;
                 count = semaptr->u.sem_nsems;
-                __libc_Back_safesemMtxUnlock(hmtx); hmtx = NULLHANDLE;
+                __libc_Back_safesemMtxUnlock(;
                 array = _hmalloc(sizeof(*array) * count);
                 error = copyin(real_arg.array, array, count * sizeof(*array));
                 if (error)
                         break;
-                __libc_Back_safesemMtxLock(hmtx = semaptr->hmtx);
+                __libc_Back_safesemMtxLock(mtx);
                 if ((error = semvalid(semid_in, semaptr)) != 0)
                         goto done2;
@@ -778 +787 @@
                 semundo_clear(semid, -1);
                 SEMUNDO_UNLOCK();
-                __libc_Back_safesemEvWakeup(semaptr->hev, semaptr->hmtx);
+                __libc_Back_safesemEvWakeup();
                 break;
 
@@ -787 +796 @@
 
 done2:
-        if (hmtx)
-                __libc_Back_safesemMtxUnlock(hmtx);
+        if (mtx)
+                __libc_Back_safesemMtxUnlock(mtx);
 
         if (array != NULL)
@@ -821 +830 @@
         struct semid_kernel * sema = gpGlobals->sema;
 
-        error = __libc_Back_safesemMtxLock(gpGlobals->hmtx);
+        error = __libc_Back_safesemMtxLock(mtx);
         if (error)
             LIBCLOG_ERROR_RETURN_INT(error);
@@ -899 +908 @@
         error = -IXSEQ_TO_IPCID(semid, sema[semid].u.sem_perm);
 done2:
-        __libc_Back_safesemMtxUnlock(gpGlobals->hmtx);
+        __libc_Back_safesemMtxUnlock(mtx);
         if (!error)
                 LIBCLOG_RETURN_INT(-error);
@@ -991 +1000 @@
 
         semaptr = &sema[semid];
-        error = __libc_Back_safesemMtxLock(semaptr->hmtx);
+        error = __libc_Back_safesemMtxLock(mtx);
         if (error) {
                 if (sops != small_sops)
@@ -1113 +1122 @@
                 __atomic_increment_u16(Args.pu16);
                 DPRINTF(("semop:  good night (%d)!\n", sopptr->sem_op));
-                error = -__libc_Back_safesemEvSleep(semaptr->hev, semaptr->hmtx, SleepDone, &Args);
+                error = -__libc_Back_safesemEvSleep(, SleepDone, &Args);
                 DPRINTF(("semop:  good morning (error=%d)!\n", error));
                 /* return code is checked below, after sem[nz]cnt-- */
@@ -1208 +1217 @@
         if (do_wakeup) {
                 DPRINTF(("semop:  doing wakeup\n"));
-                __libc_Back_safesemEvWakeup(semaptr->hev, semaptr->hmtx);
+                __libc_Back_safesemEvWakeup();
                 DPRINTF(("semop:  back from wakeup\n"));
         }
         DPRINTF(("semop:  done\n"));
 done2:
-        __libc_Back_safesemMtxUnlock(semaptr->hmtx);
+        __libc_Back_safesemMtxUnlock(mtx);
         if (sops != small_sops)
                 free(sops);
@@ -1272 +1281 @@
                         semaptr = &gpGlobals->sema[semid];
                         SEMUNDO_LOCK();
-                        __libc_Back_safesemMtxUnlock(semaptr->hmtx);
+                        __libc_Back_safesemMtxUnlock(mtx);
                         if ((semaptr->u.sem_perm.mode & SEM_ALLOC) == 0) {
                                 panic("semexit - semid not allocated");
@@ -1298 +1307 @@
                                 semaptr->u.sem_base[semnum].semval += adjval;
 
-                        __libc_Back_safesemEvWakeup(semaptr->hev, semaptr->hmtx);
+                        __libc_Back_safesemEvWakeup();
                         DPRINTF(("semexit:  back from wakeup\n"));
                     skip:
-                        __libc_Back_safesemMtxUnlock(semaptr->hmtx);
+                        __libc_Back_safesemMtxUnlock(mtx);
                         SEMUNDO_UNLOCK();
                 }

trunk/src/emx/src/lib/sys/sysv_shm.c

@@ -30 +30 @@
  */
 
+
 #include "libc-alias.h"
 #include <sys/cdefs.h>
@@ -65 +66 @@
 /* debug printf */
 #define DPRINTF(a)      LIBCLOG_MSG a
+
+
+
+
+
 
 
@@ -82 +88 @@
     volatile uint32_t   cUsers;
     /** Mutex protecting everything. */
-    uintptr_t           hmtx;
+    mtx;
     /** Event semaphore which the daemon should sleep on.
      * This is posted whenever a memory object is created or deleted. */
-    uintptr_t           hevDaemon;
+    evDaemon;
 
     int                 shm_last_free;
@@ -286 +292 @@
         pGlobals->shm_nused--;
         shmseg->shm_perm.mode = SHMSEG_FREE;
-        __libc_Back_safesemEvWakeup(pGlobals->hevDaemon, pGlobals->hmtx);
+        __libc_Back_safesemEvWakeup();
 }
 
@@ -314 +320 @@
                 pGlobals->shm_last_free = segnum;
         }
-        __libc_Back_safesemEvWakeup(pGlobals->hevDaemon, pGlobals->hmtx);
+        __libc_Back_safesemEvWakeup();
         return (0);
 }
@@ -344 +350 @@
         }
         
-        error = __libc_Back_safesemMtxLock(gpGlobals->hmtx);
+        error = __libc_Back_safesemMtxLock(mtx);
         if (error)
             LIBCLOG_ERROR_RETURN_INT(error);
@@ -365 +371 @@
         error = shm_delete_mapping(shmmap_s, 0);
 done2:
-        __libc_Back_safesemMtxUnlock(gpGlobals->hmtx);
+        __libc_Back_safesemMtxUnlock(mtx);
         return (-error);
 }
@@ -394 +400 @@
         struct __libc_SysV_Shm *pGlobals = gpGlobals;
         
-        error = __libc_Back_safesemMtxLock(pGlobals->hmtx);
+        error = __libc_Back_safesemMtxLock(mtx);
         if (error)
             LIBCLOG_ERROR_RETURN_INT(error);
@@ -403 +409 @@
         shmmap_s = g_vm_shm;
         if (shmmap_s == NULL) {
-                __libc_Back_safesemMtxUnlock(pGlobals->hmtx);
+                __libc_Back_safesemMtxUnlock(mtx);
                 size = shminfo.shmseg * sizeof(struct shmmap_state);
                 shmmap_s = _hmalloc(size);
@@ -410 +416 @@
                 for (i = 0; i < shminfo.shmseg; i++)
                         shmmap_s[i].shmid = -1;
-                __libc_Back_safesemMtxLock(pGlobals->hmtx);
+                __libc_Back_safesemMtxLock(mtx);
                 if (!g_vm_shm)
                     g_vm_shm = shmmap_s;
@@ -479 +485 @@
         
 done2:
-        __libc_Back_safesemMtxUnlock(pGlobals->hmtx);
+        __libc_Back_safesemMtxUnlock(mtx);
         *ppvActual = (void *)attach_va;
         if (!error)
@@ -516 +522 @@
         struct __libc_SysV_Shm *pGlobals = gpGlobals;
         
-        error = __libc_Back_safesemMtxLock(pGlobals->hmtx);
+        error = __libc_Back_safesemMtxLock(mtx);
         if (error)
             return error;
@@ -602 +608 @@
         }
 done2:
-        __libc_Back_safesemMtxUnlock(pGlobals->hmtx);
+        __libc_Back_safesemMtxUnlock(mtx);
         if (error)
             rval = -error;
@@ -755 +761 @@
         struct __libc_SysV_Shm *pGlobals = gpGlobals;
         
-        rval = __libc_Back_safesemMtxLock(pGlobals->hmtx);
+        rval = __libc_Back_safesemMtxLock(mtx);
         if (rval)
             LIBCLOG_ERROR_RETURN_INT(rval);
@@ -778 +784 @@
         rval = shmget_allocate_segment(key, size, mode);
 done2:
-        __libc_Back_safesemMtxUnlock(pGlobals->hmtx);
+        __libc_Back_safesemMtxUnlock(mtx);
         if (rval >= 0)
             LIBCLOG_RETURN_INT(rval);
@@ -812 +818 @@
                 struct shmmap_state *shm = g_vm_shm;
                 if (shm) {
-                    __libc_Back_safesemMtxLock(pGlobals->hmtx);
+                    __libc_Back_safesemMtxLock(mtx);
                     int c = shminfo.shmseg;
                     while (c-- > 0)
@@ -819 +825 @@
                             pGlobals->shmsegs[IPCID_TO_IX(shm->shmid)].shm_nattch++;
                     }
-                    __libc_Back_safesemMtxUnlock(pGlobals->hmtx);
+                    __libc_Back_safesemMtxUnlock(mtx);
                 }
             }
@@ -839 +845 @@
         if (pGlobals && !fDone) {
                 fDone = 1;
-                __libc_Back_safesemMtxLock(pGlobals->hmtx);
+                __libc_Back_safesemMtxLock(mtx);
                 struct shmmap_state *shm = g_vm_shm;
                 if (shm) {
@@ -874 +880 @@
                     }
                 }
-                __libc_Back_safesemMtxUnlock(pGlobals->hmtx);
+                __libc_Back_safesemMtxUnlock(mtx);
                 __atomic_decrement_u32(&pGlobals->cUsers);
                 gpGlobals = NULL;
@@ -937 +943 @@
             /* init globals */
             bzero(pGlobals, cb);
-            pGlobals->uVersion = 1;
+            pGlobals->uVersion = ;
             pGlobals->cUsers = 0;
             //pGlobals->shm_last_free = 0;
@@ -956 +962 @@
         }
     }
+
+
+
+
+
+
+
+
+
 
     /*
@@ -963 +978 @@
     {
         /* create */
-        rc = __libc_Back_safesemMtxCreate(&pGlobals->hmtx, 1);
+        rc = __libc_Back_safesemMtxCreate(&pGlobals->mtx, 1);
         if (!rc)
-            rc = __libc_Back_safesemEvCreate(&pGlobals->hevDaemon, 1);
+            rc = __libc_Back_safesemEvCreate(&pGlobals->, 1);
     }
     else
     {
         /* open */
-        rc = __libc_Back_safesemMtxOpen(pGlobals->hmtx);
+        rc = __libc_Back_safesemMtxOpen(mtx);
         if (!rc)
-            rc = __libc_Back_safesemEvOpen(pGlobals->hevDaemon);
+            rc = __libc_Back_safesemEvOpen(evDaemon);
     }
     __atomic_increment_u32(&pGlobals->cUsers);