Changeset 1986

Timestamp:

May 9, 2005, 7:02:45 AM (20 years ago)

Author:

bird

Message:

SysV Shared Memory.

Location:

trunk/src/emx

Files:

• ChangeLog.LIBC (modified) (1 diff, 1 prop)
• include/InnoTekLIBC/backend.h (modified) (2 diffs, 1 prop)
• include/InnoTekLIBC/logstrict.h (modified) (1 diff, 1 prop)
• include/InnoTekLIBC/sharedpm.h (modified) (1 diff, 1 prop)
• include/sys/shm.h (modified) (7 diffs, 1 prop)
• src/lib/libc.def (modified) (1 diff, 1 prop)
• src/lib/process/semctl.c (modified) (1 diff, 1 prop)
• src/lib/process/shmat.c (added)
• src/lib/process/shmctl.c (added)
• src/lib/process/shmdt.c (added)
• src/lib/process/shmget.c (added)
• src/lib/sys/safesems.c (added)
• src/lib/sys/sysv_sem.c (modified) (36 diffs, 1 prop)
• src/lib/sys/sysv_shm.c (added)

trunk/src/emx/ChangeLog.LIBC

@@ -7 +7 @@
         o Added a signal notification callback to the thread structure.
         o Changed tcpip term callback to more generic exitlist callback (SPM).
+        o Ported the BSD SysV Shared Memory module.
 
 2005-05-05: knut st. osmundsen <bird-gccos2-spam@anduin.net>

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

@@ -894 +894 @@
 /** @defgroup grp_Back_sysvipc LIBC Backend - SysV IPC
  * @{ */
+
+/**
+ * sysget syscall.
+ */
+int __libc_Back_sysvSemGet(key_t key, int nsems, int semflg);
+
+/**
+ * semop syscall.
+ */
+int __libc_Back_sysvSemOp(int semid, struct sembuf *sops_user, size_t nsops);
+
 /**
  * semctl syscall
@@ -899 +910 @@
 int __libc_Back_sysvSemCtl(int semid, int semnum, int cmd, union semun real_arg);
 
-/**
- * sysget syscall.
- */
-int __libc_Back_sysvSemGet(key_t key, int nsems, int semflg);
-
-/**
- * semop syscall.
- */
-int __libc_Back_sysvSemOp(int semid, struct sembuf *sops_user, size_t nsops);
+
+/**
+ * shmget.
+ */
+int __libc_Back_sysvShmGet(key_t key, size_t size, int shmflg);
+
+/**
+ * shmat.
+ */
+int __libc_Back_sysvShmAt(int shmid, const void *shmaddr, int shmflg, void **ppvActual);
+
+/**
+ * shmdt.
+ */
+int __libc_Back_sysvShmDt(const void *shmaddr);
+
+/**
+ * shmctl.
+ */
+int __libc_Back_sysvShmCtl(int shmid, int cmd, struct shmid_ds *bufptr);
+
+/** @} */
+
+
+/** @defgroup grp_Back_safesem LIBC Backend - Internal Signal-Safe Semaphores.
+ * @{ */
+
+/**
+ * Creates a safe mutex sem.
+ *
+ * @returns 0 on success.
+ * @returns Negative error code (errno.h) on failure.
+ * @param   phmtx       Where to store the semaphore handle.
+ * @param   fShared     Set if the semaphore should be sharable between processes.
+ */
+int __libc_Back_safesemMtxCreate(uintptr_t *phmtx, int fShared);
+
+/**
+ * Opens a shared safe mutex sem.
+ *
+ * @returns 0 on success.
+ * @returns Negative error code (errno.h) on failure.
+ * @param   hmtx        The semaphore handle.
+ */
+int __libc_Back_safesemMtxOpen(uintptr_t hmtx);
+
+/**
+ * Closes a shared safe mutex sem.
+ *
+ * @returns 0 on success.
+ * @returns Negative error code (errno.h) on failure.
+ * @param   hmtx        The semaphore handle.
+ */
+int __libc_Back_safesemMtxClose(uintptr_t hmtx);
+
+/**
+ * Locks a mutex semaphore.
+ *
+ * @returns 0 on success.
+ * @returns Negative errno on failure.
+ * @param   hmtx    Handle to the mutex.
+ */
+int __libc_Back_safesemMtxLock(uintptr_t hmtx);
+
+/**
+ * Unlocks a mutex semaphore.
+ *
+ * @returns 0 on success.
+ * @returns Negative errno on failure.
+ * @param   hmtx    Handle to the mutex.
+ */
+int __libc_Back_safesemMtxUnlock(uintptr_t hmtx);
+
+/**
+ * Creates a safe event sem.
+ *
+ * @returns 0 on success.
+ * @returns Negative error code (errno.h) on failure.
+ * @param   phev        Where to store the semaphore handle.
+ * @param   fShared     Set if the semaphore should be sharable between processes.
+ */
+int __libc_Back_safesemEvCreate(uintptr_t *phev, 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);
+
+/**
+ * Closes a shared safe mutex sem.
+ *
+ * @returns 0 on success.
+ * @returns Negative error code (errno.h) on failure.
+ * @param   hev         The semaphore handle.
+ */
+int __libc_Back_safesemEvClose(uintptr_t hev);
+
+/**
+ * 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.
+ * @param   pvUser      User argument to pfnComplete.
+ */
+int __libc_Back_safesemEvSleep(uintptr_t hev, uintptr_t hmtx, void (*pfnComplete)(void *pvUser), void *pvUser);
+
+/**
+ * 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.
+ */
+int __libc_Back_safesemEvWakeup(uintptr_t hev);
+
 
 /** @} */

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

@@ -184 +184 @@
 #define __LIBC_LOG_GRP_MMAN         16
 
+/** Backend SysV IPC APIs. */
+#define __LIBC_LOG_GRP_BACK_IPC     17
 /** Backend Thread APIs. */
 #define __LIBC_LOG_GRP_BACK_THREAD  18

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

@@ -557 +557 @@
     /** 116 - Pointer to SysV Sempahore globals. */
     struct __libc_SysV_Sem             *pSysVSem;
-
-    /*  120 - The rest of the block, up to cbProcess, is undefined in this version.
+    /** 120 - Pointer to SysV Shared Memory globals. */
+    struct __libc_SysV_Shm             *pSysVShm;
+    /** 124 - Pointer to SysV Message Queue globals. */
+    struct __libc_SysV_Msg             *pSysVMsg;
+
+    /*  128 - The rest of the block, up to cbProcess, is undefined in this version.
      * Future versions of LIBC may use this area assuming it's initalized with zeros.
      */

trunk/src/emx/include/sys/shm.h

@@ -39 +39 @@
 /** @file
  * FreeBSD 5.3
+ * @changed the SHMLBA to 64KB.
  */
 
@@ -48 +49 @@
 #define SHM_RDONLY  010000  /* Attach read-only (else read-write) */
 #define SHM_RND     020000  /* Round attach address to SHMLBA */
-#define SHMLBA      PAGE_SIZE /* Segment low boundary address multiple */
+#define SHMLBA      (0x10000) /* Segment low boundary address multiple */
 
 /* "official" access mode definitions; somewhat braindead since you have
@@ -63 +64 @@
 #define SHM_INFO        14
 
+#ifdef __EMX__
+typedef __uint32_t shmatt_t;
+#endif
+
 struct shmid_ds {
         struct ipc_perm shm_perm;       /* operation permission structure */
+#ifdef __EMX__
+        size_t          shm_segsz;      /* size of segment in bytes */
+#else
         int             shm_segsz;      /* size of segment in bytes */
+#endif
         pid_t           shm_lpid;   /* process ID of last shared memory op */
         pid_t           shm_cpid;       /* process ID of creator */
-        short           shm_nattch;     /* number of current attaches */
+#ifdef __EMX__
+        shmatt_t        shm_nattch;     /* number of current attaches */
+#else
+        short           shm_nattch;     /* number of current attaches */
+#endif
         time_t          shm_atime;      /* time of last shmat() */
         time_t          shm_dtime;      /* time of last shmdt() */
@@ -88 +101 @@
                 shmall;         /* max amount of shared memory (pages) */
 };
+#ifndef __EMX__
 extern struct shminfo   shminfo;
 extern struct shmid_ds  *shmsegs;
+#endif
 
 struct shm_info {
@@ -100 +115 @@
 };
 
+#ifndef __EMX__
 struct thread;
 struct proc;
@@ -106 +122 @@
 void    shmexit(struct vmspace *);
 void    shmfork(struct proc *, struct proc *);
+#endif /* !__EMX__ */
 #else /* !_KERNEL */
 
@@ -116 +133 @@
 
 __BEGIN_DECLS
+#ifndef __EMX__
 int shmsys(int, ...);
+#endif
 void *shmat(int, const void *, int);
 int shmget(key_t, size_t, int);

trunk/src/emx/src/lib/libc.def

@@ -1529 +1529 @@
     "__getenv_long" @1534
     "__getenv_longlong" @1535
-    "___libc_Back_sysvSemCtl" @1536
-    "___libc_Back_sysvSemGet" @1537
-    "___libc_Back_sysvSemOp" @1538
-    "__std_ftok" @1539
-    "__std_semctl" @1540
-    "__std_semget" @1541
-    "__std_semop" @1542
+    "___libc_Back_safesemEvClose" @1536
+    "___libc_Back_safesemEvCreate" @1537
+    "___libc_Back_safesemEvOpen" @1538
+    "___libc_Back_safesemEvSleep" @1539
+    "___libc_Back_safesemEvWakeup" @1540
+    "___libc_Back_safesemMtxClose" @1541
+    "___libc_Back_safesemMtxCreate" @1542
+    "___libc_Back_safesemMtxLock" @1543
+    "___libc_Back_safesemMtxOpen" @1544
+    "___libc_Back_safesemMtxUnlock" @1545
+    "___libc_Back_sysvSemCtl" @1546
+    "___libc_Back_sysvSemGet" @1547
+    "___libc_Back_sysvSemOp" @1548
+    "___libc_Back_sysvShmAt" @1549
+    "___libc_Back_sysvShmCtl" @1550
+    "___libc_Back_sysvShmDt" @1551
+    "___libc_Back_sysvShmGet" @1552
+    "__std_ftok" @1553
+    "__std_semctl" @1554
+    "__std_semget" @1555
+    "__std_semop" @1556
+    "__std_shmat" @1557
+    "__std_shmctl" @1558
+    "__std_shmdt" @1559
+    "__std_shmget" @1560

trunk/src/emx/src/lib/process/semctl.c

@@ -40 +40 @@
 
 /**
- * semop.
+ * semctl.
  */
 int _STD(semctl)(int semid, int semnum, int cmd, ...)

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

@@ -8 +8 @@
 
 #include "libc-alias.h"
+#include <sys/cdefs.h>
 //__FBSDID("$FreeBSD: src/sys/kern/sysv_sem.c,v 1.70.2.3 2005/03/22 17:20:07 sam Exp $");
-#include <sys/cdefs.h>
 
 #include <sys/types.h>
@@ -33 +33 @@
 #include <InnoTekLIBC/libc.h>
 #include <InnoTekLIBC/backend.h>
-#define __LIBC_LOG_GROUP    __LIBC_LOG_GRP_BACK_FS
+#define __LIBC_LOG_GROUP    __LIBC_LOG_GRP_BACK_IPC
 #include <InnoTekLIBC/logstrict.h>
 
@@ -51 +51 @@
     struct semid_ds u;
     /** Event semaphore to wait on. */
-    HEV             hev;
-    /** Mutex protecting the semid_ds and HEV members. */
-    HMTX            hmtx;
+    uintptr_t       hev;
+    /** Mutex protecting the semid_ds and hev members. */
+    uintptr_t       hmtx;
 };
 
@@ -74 +74 @@
     struct sem         *sem;
     /** Mutex protecting the undo list and other global sem stuff. */
-    HMTX                hmtx;
+    uintptr_t           hmtx;
     /** list of active undo structures. */
     SLIST_HEAD(, sem_undo) semu_list;
@@ -96 +96 @@
 
 //#define SEMUNDO_MTX           gpGlobals->hmtx
-#define SEMUNDO_LOCK()          semMtxLock(gpGlobals->hmtx);
-#define SEMUNDO_UNLOCK()        semMtxUnlock(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));
 
@@ -238 +238 @@
 #define TUNABLE_INT_FETCH(path, var) _getenv_int("LIBC_" path, (var))
 
-//static int  spmRequestMutexErrno(__LIBC_PSPMXCPTREGREC pRegRec);
-//static int  spmRequestMutex(__LIBC_PSPMXCPTREGREC pRegRec);
-//static int  spmReleaseMutex(__LIBC_PSPMXCPTREGREC pRegRec);
-
-//int __libc_spmLock(__LIBC_PSPMXCPTREGREC pRegRec);
-
 
 static int seminit(void)
@@ -290 +284 @@
          */
         size_t cb = sizeof(*gpGlobals);
-        cb += sizeof(struct semid_kernel) * seminfo.semmni;
+        cb += sizeof(struct semid_kernel) * si.semmni;
         cb += sizeof(struct sem) * si.semmns;
-        cb += seminfo.semmnu * seminfo.semusz;
+        cb += si.semmnu * si.semusz;
 
         /*
-         * Take the sem and allocate the memory.
+         * Retake the sem and allocate the memory.
          */
         rc = __libc_spmLock(&RegRec, &pSPMHdr);
@@ -321 +315 @@
             SLIST_INIT(&pGlobals->semu_list);
             pGlobals->semu       = (int *)pu8;
-            pGlobals->seminfo  = si;
+            pGlobals->seminfo    = si;
 
             /* Set globals. */
@@ -333 +327 @@
      */
     int i;
-    FS_VAR_SAVE_LOAD();
     if (!pGlobals->cUsers)
     {
         /* create */
-
-        rc = DosCreateMutexSemEx(NULL, &pGlobals->hmtx, DC_SEM_SHARED, FALSE);
+        rc = __libc_Back_safesemMtxCreate(&pGlobals->hmtx, 1);
         for (i = 0; i < pGlobals->seminfo.semmni && !rc; i++)
-            rc = DosCreateMutexSemEx(NULL, &pGlobals->sema[i].hmtx, DC_SEM_SHARED, FALSE);
+            rc = __libc_Back_safesemMtxCreate(&pGlobals->sema[i].hmtx, 1);
         for (i = 0; i < pGlobals->seminfo.semmni && !rc; i++)
-            rc = DosCreateEventSemEx(NULL, &pGlobals->sema[i].hev, DC_SEM_SHARED, FALSE);
+            rc = __libc_Back_safesemEvCreate(&pGlobals->sema[i].hev, 1);
     }
     else
     {
         /* open */
-        rc = DosOpenMutexSemEx(NULL, &pGlobals->hmtx);
+        rc = __libc_Back_safesemMtxOpen(pGlobals->hmtx);
         for (i = 0; i < pGlobals->seminfo.semmni && !rc; i++)
-            rc = DosOpenMutexSemEx(NULL, &pGlobals->sema[i].hmtx);
+            rc = __libc_Back_safesemMtxOpen(pGlobals->sema[i].hmtx);
         for (i = 0; i < pGlobals->seminfo.semmni && !rc; i++)
-            rc = DosOpenEventSemEx(NULL, &pGlobals->sema[i].hev);
+            rc = __libc_Back_safesemEvOpen(pGlobals->sema[i].hev);
     }
     __atomic_increment_u32(&pGlobals->cUsers);
-    FS_RESTORE();
 
     /*
@@ -369 +360 @@
     if (rc)
         rc = -__libc_native2errno(rc);
-    LIBCLOG_RETURN_INT(rc);
-}
-
-
-/**
- * This function checks that there is at least 2k of writable
- * stack available. If there isn't, a crash is usually the
- * result.
- * @internal
- */
-static int semMtxLockStackChecker(void)
-{
-    char volatile *pch = alloca(2048);
-    if (!pch)
-        return -1;
-    /* With any luck the compiler doesn't optimize this away. */
-    pch[0] = pch[1024] = pch[2044] = 0x7f;
-    return 0;
-}
-
-
-/**
- * Locks a mutex semaphore.
- *
- * @returns 0 on success.
- * @returns Negative errno on failure.
- * @param   hmtx    Handle to the mutex.
- */
-static int semMtxLock(HMTX hmtx)
-{
-    LIBCLOG_ENTER("hmtx=%#lx\n", hmtx);
-    ULONG       ul;
-    int         rc;
-    FS_VAR();
-
-    /*
-     * Check stack.
-     */
-    if (semMtxLockStackChecker())
-    {
-        LIBC_ASSERTM_FAILED("Too little stack left!\n");
-        LIBCLOG_RETURN_INT(-EFAULT);
-    }
-
-    /*
-     * Request semaphore and enter "must complete section" to avoid signal trouble.
-     */
-    FS_SAVE_LOAD();
-    rc = DosRequestMutexSem(hmtx, 30*1000);
-    DosEnterMustComplete(&ul);
-    if (!rc)
-    {
-        FS_RESTORE();
-        LIBCLOG_RETURN_INT(0);
-    }
-
-    /* failure out */
-    DosExitMustComplete(&ul);
-    LIBC_ASSERTM_FAILED("DosRequestMutexSem(%lu) failed with rc=%d!\n", hmtx, rc);
-    rc = -__libc_native2errno(rc);
-    FS_RESTORE();
-    LIBCLOG_RETURN_INT(rc);
-}
-
-
-/**
- * Unlocks a mutex semaphore.
- *
- * @returns 0 on success.
- * @returns Negative errno on failure.
- * @param   hmtx    Handle to the mutex.
- */
-static int semMtxUnlock(HMTX hmtx)
-{
-    LIBCLOG_ENTER("hmtx=%#lx\n", hmtx);
-    ULONG   ul = 0;
-    int     rc;
-    FS_VAR();
-
-    /*
-     * Release the semaphore.
-     */
-    FS_SAVE_LOAD();
-    rc = DosReleaseMutexSem(hmtx);
-    if (rc)
-    {
-        FS_RESTORE();
-        LIBC_ASSERTM_FAILED("DosReleaseMutexSem(%lu) -> %d\n", hmtx, rc);
-        rc = -__libc_native2errno(rc);
-        LIBCLOG_RETURN_INT(rc);
-    }
-
-    DosExitMustComplete(&ul);
-    FS_RESTORE();
-    LIBCLOG_RETURN_INT(0);
-}
-
-
-/**
- * Arguments to semEvSleepSignalCallback().
- */
-struct semEvSleepSignalCallback_args
-{
-    /** Set if pfnComplete have already been executed. */
-    volatile int            fDone;
-    /** Callback to execute. */
-    void                  (*pfnComplete)(int semid, struct semid_kernel *semaptr, uint16_t volatile *pu16);
-    /** Semaphore id. */
-    int                     semid;
-    /** Semaphore id we was sleeping on. */
-    struct semid_kernel    *semaptr;
-    /** Pointer to the value to decrement. */
-    uint16_t volatile      *pu16;
-};
-
-/**
- * Signal notification callback.
- */
-static void semEvSleepSignalCallback(int iSignal, void *pvUser)
-{
-    struct semEvSleepSignalCallback_args *pArgs = (struct semEvSleepSignalCallback_args *)pvUser;
-    if (!pArgs->fDone)
-    {
-        pArgs->pfnComplete(pArgs->semid, pArgs->semaptr, pArgs->pu16);
-        pArgs->fDone = 1;
-    }
-}
-
-/**
- * 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   semaptr     Semaphore to wakeup.
- * @param   pfnComplete Function to execute on signal and on wait completion.
- */
-static int semEvSleep(struct semid_kernel *semaptr, void (*pfnComplete)(int semid, struct semid_kernel *semaptr, uint16_t volatile *pu16), int semid, uint16_t volatile *pu16)
-{
-    LIBCLOG_ENTER("semaptr=%p pfnComplete=%p semid=%#x pu16=%p:{%d}\n", (void *)semaptr, (void *)pfnComplete, semid, (void *)pu16, *pu16);
-
-    /*
-     * Setup signal notification.
-     */
-    __LIBC_PTHREAD pThrd = __libc_threadCurrentNoAuto();
-    int rc;
-    if (pThrd)
-    {
-        struct semEvSleepSignalCallback_args Args;
-        Args.fDone               = 0;
-        Args.pfnComplete         = pfnComplete;
-        Args.semid               = semid;
-        Args.semaptr             = semaptr;
-        Args.pu16                = pu16;
-        pThrd->pvSigCallbackUser = &Args;
-        pThrd->pfnSigCallback    = semEvSleepSignalCallback;
-
-        /*
-         * Reset the event semaphore.
-         */
-        ULONG ulIgnore;
-        FS_VAR_SAVE_LOAD();
-        rc = DosResetEventSem(semaptr->hev, &ulIgnore);
-        if (!rc || rc == ERROR_ALREADY_RESET)
-        {
-            /*
-             * Release the sempahore and exit the must complete section.
-             */
-            rc = semMtxUnlock(semaptr->hev);
-            if (!rc)
-            {
-                /*
-                 * Now, lets wait.
-                 */
-                DosWaitEventSem(semaptr->hev, SEM_INDEFINITE_WAIT);
-
-                /*
-                 * Regain access to the semaphore and must complete section
-                 * before checking if we got an interrupt or not.
-                 */
-                rc = semMtxLock(semaptr->hmtx);
-                if (!Args.fDone)
-                    Args.pfnComplete(Args.semid, Args.semaptr, Args.pu16);
-                else if (!rc)
-                    rc = -EINTR;
-            }
-        }
-        else
-            rc = -__libc_native2errno(rc);
-        FS_RESTORE();
-    }
-    else
-        rc = -ENOSYS;
-
-    LIBCLOG_RETURN_INT(rc);
-}
-
-
-/**
- * Wakes up all threads sleeping on a given event semaphore.
- *
- * @returns 0 on success.
- * @returns Negative error code (errno.h) on failure.
- * @param   semaptr     Semaphore to wakeup.
- */
-static int semEvWakeup(struct semid_kernel *semaptr)
-{
-    LIBCLOG_ENTER("semaptr=%p\n", (void *)semaptr);
-    FS_VAR_SAVE_LOAD();
-    int rc = DosPostEventSem(semaptr->hev);
-    FS_RESTORE();
-    if (rc)
-    {
-        if (rc == ERROR_ALREADY_POSTED || rc == ERROR_TOO_MANY_POSTS)
-            rc = 0;
-        else
-            rc = -__libc_native2errno(rc);
-    }
     LIBCLOG_RETURN_INT(rc);
 }
@@ -789 +561 @@
         u_short usval, count;
         uid_t uid;
-        HMTX hmtx;
+        uintptr_t hmtx;
 
 
@@ -814 +586 @@
                         LIBCLOG_RETURN_INT(-EINVAL);
                 semaptr = &sema[semid];
-                semMtxLock(hmtx = semaptr->hmtx);
+                __libc_Back_safesemMtxLock(hmtx = semaptr->hmtx);
                 if ((semaptr->u.sem_perm.mode & SEM_ALLOC) == 0) {
                         error = EINVAL;
                         goto done2;
                 }
-                if ((error = __libc_spmCanIPC(&semaptr->u.sem_perm, IPC_R)))
-                        goto done2;
-                semMtxUnlock(hmtx); hmtx = NULLHANDLE;
+                if ((error = -__libc_spmCanIPC(&semaptr->u.sem_perm, IPC_R)))
+                        goto done2;
+                __libc_Back_safesemMtxUnlock(hmtx); hmtx = NULLHANDLE;
                 memcpy(real_arg.buf, &semaptr->u, sizeof(struct semid_ds));
                 rval = IXSEQ_TO_IPCID(semid, semaptr->u.sem_perm);
@@ -835 +607 @@
         switch (cmd) {
         case IPC_RMID:
-                semMtxLock(hmtx = semaptr->hmtx);
+                __libc_Back_safesemMtxLock(hmtx = semaptr->hmtx);
                 if ((error = semvalid(semid, semaptr)) != 0)
                         goto done2;
-                if ((error = __libc_spmCanIPC(&semaptr->u.sem_perm, IPC_M)))
+                if ((error = -__libc_spmCanIPC(&semaptr->u.sem_perm, IPC_M)))
                         goto done2;
                 uid = __libc_spmGetId(__LIBC_SPMID_EUID);
@@ -855 +627 @@
                 semundo_clear(semid, -1);
                 SEMUNDO_UNLOCK();
-                semEvWakeup(semaptr);
+                __libc_Back_safesemEvWakeup(semaptr->hev);
                 break;
 
@@ -861 +633 @@
                 if ((error = copyin(real_arg.buf, &sbuf, sizeof(sbuf))) != 0)
                         goto done2;
-                semMtxLock(hmtx = semaptr->hmtx);
+                __libc_Back_safesemMtxLock(hmtx = semaptr->hmtx);
                 if ((error = semvalid(semid, semaptr)) != 0)
                         goto done2;
-                if ((error = __libc_spmCanIPC(&semaptr->u.sem_perm, IPC_M)))
+                if ((error = -__libc_spmCanIPC(&semaptr->u.sem_perm, IPC_M)))
                         goto done2;
                 semaptr->u.sem_perm.uid = sbuf.sem_perm.uid;
@@ -874 +646 @@
 
         case IPC_STAT:
-                semMtxLock(hmtx = semaptr->hmtx);
+                __libc_Back_safesemMtxLock(hmtx = semaptr->hmtx);
                 if ((error = semvalid(semid, semaptr)) != 0)
                         goto done2;
-                if ((error = __libc_spmCanIPC(&semaptr->u.sem_perm, IPC_R)))
+                if ((error = -__libc_spmCanIPC(&semaptr->u.sem_perm, IPC_R)))
                         goto done2;
                 sbuf = semaptr->u;
-                semMtxUnlock(hmtx); hmtx = NULLHANDLE;
+                __libc_Back_safesemMtxUnlock(hmtx); hmtx = NULLHANDLE;
                 error = copyout(semaptr, real_arg.buf,
                                 sizeof(struct semid_ds));
@@ -886 +658 @@
 
         case GETNCNT:
-                semMtxLock(hmtx = semaptr->hmtx);
+                __libc_Back_safesemMtxLock(hmtx = semaptr->hmtx);
                 if ((error = semvalid(semid, semaptr)) != 0)
                         goto done2;
-                if ((error = __libc_spmCanIPC(&semaptr->u.sem_perm, IPC_R)))
+                if ((error = -__libc_spmCanIPC(&semaptr->u.sem_perm, IPC_R)))
                         goto done2;
                 if (semnum < 0 || semnum >= semaptr->u.sem_nsems) {
@@ -899 +671 @@
 
         case GETPID:
-                semMtxLock(hmtx = semaptr->hmtx);
+                __libc_Back_safesemMtxLock(hmtx = semaptr->hmtx);
                 if ((error = semvalid(semid, semaptr)) != 0)
                         goto done2;
-                if ((error = __libc_spmCanIPC(&semaptr->u.sem_perm, IPC_R)))
+                if ((error = -__libc_spmCanIPC(&semaptr->u.sem_perm, IPC_R)))
                         goto done2;
                 if (semnum < 0 || semnum >= semaptr->u.sem_nsems) {
@@ -912 +684 @@
 
         case GETVAL:
-                semMtxLock(hmtx = semaptr->hmtx);
+                __libc_Back_safesemMtxLock(hmtx = semaptr->hmtx);
                 if ((error = semvalid(semid, semaptr)) != 0)
                         goto done2;
-                if ((error = __libc_spmCanIPC(&semaptr->u.sem_perm, IPC_R)))
+                if ((error = -__libc_spmCanIPC(&semaptr->u.sem_perm, IPC_R)))
                         goto done2;
                 if (semnum < 0 || semnum >= semaptr->u.sem_nsems) {
@@ -926 +698 @@
         case GETALL:
                 array = _hmalloc(sizeof(*array) * semaptr->u.sem_nsems);
-                semMtxLock(hmtx = semaptr->hmtx);
+                __libc_Back_safesemMtxLock(hmtx = semaptr->hmtx);
                 if ((error = semvalid(semid, semaptr)) != 0)
                         goto done2;
-                if ((error = __libc_spmCanIPC(&semaptr->u.sem_perm, IPC_R)))
+                if ((error = -__libc_spmCanIPC(&semaptr->u.sem_perm, IPC_R)))
                         goto done2;
                 for (i = 0; i < semaptr->u.sem_nsems; i++)
                         array[i] = semaptr->u.sem_base[i].semval;
-                semMtxUnlock(hmtx); hmtx = NULLHANDLE;
+                __libc_Back_safesemMtxUnlock(hmtx); hmtx = NULLHANDLE;
                 error = copyout(array, real_arg.array,
                     i * sizeof(real_arg.array[0]));
@@ -939 +711 @@
 
         case GETZCNT:
-                semMtxLock(hmtx = semaptr->hmtx);
+                __libc_Back_safesemMtxLock(hmtx = semaptr->hmtx);
                 if ((error = semvalid(semid, semaptr)) != 0)
                         goto done2;
-                if ((error = __libc_spmCanIPC(&semaptr->u.sem_perm, IPC_R)))
+                if ((error = -__libc_spmCanIPC(&semaptr->u.sem_perm, IPC_R)))
                         goto done2;
                 if (semnum < 0 || semnum >= semaptr->u.sem_nsems) {
@@ -952 +724 @@
 
         case SETVAL:
-                semMtxLock(hmtx = semaptr->hmtx);
+                __libc_Back_safesemMtxLock(hmtx = semaptr->hmtx);
                 if ((error = semvalid(semid, semaptr)) != 0)
                         goto done2;
-                if ((error = __libc_spmCanIPC(&semaptr->u.sem_perm, IPC_W)))
+                if ((error = -__libc_spmCanIPC(&semaptr->u.sem_perm, IPC_W)))
                         goto done2;
                 if (semnum < 0 || semnum >= semaptr->u.sem_nsems) {
@@ -969 +741 @@
                 semundo_clear(semid, semnum);
                 SEMUNDO_UNLOCK();
-                semEvWakeup(semaptr);
+                __libc_Back_safesemEvWakeup(semaptr->hev);
                 break;
 
         case SETALL:
-                semMtxLock(hmtx = semaptr->hmtx);
+                __libc_Back_safesemMtxLock(hmtx = semaptr->hmtx);
 raced:
                 if ((error = semvalid(semid, semaptr)) != 0)
                         goto done2;
                 count = semaptr->u.sem_nsems;
-                semMtxUnlock(hmtx); hmtx = NULLHANDLE;
+                __libc_Back_safesemMtxUnlock(hmtx); hmtx = NULLHANDLE;
                 array = _hmalloc(sizeof(*array) * count);
                 error = copyin(real_arg.array, array, count * sizeof(*array));
                 if (error)
                         break;
-                semMtxLock(hmtx = semaptr->hmtx);
+                __libc_Back_safesemMtxLock(hmtx = semaptr->hmtx);
                 if ((error = semvalid(semid, semaptr)) != 0)
                         goto done2;
@@ -992 +764 @@
                         goto raced;
                 }
-                if ((error = __libc_spmCanIPC(&semaptr->u.sem_perm, IPC_W)))
+                if ((error = -__libc_spmCanIPC(&semaptr->u.sem_perm, IPC_W)))
                         goto done2;
                 for (i = 0; i < semaptr->u.sem_nsems; i++) {
@@ -1005 +777 @@
                 semundo_clear(semid, -1);
                 SEMUNDO_UNLOCK();
-                semEvWakeup(semaptr);
+                __libc_Back_safesemEvWakeup(semaptr->hev);
                 break;
 
@@ -1015 +787 @@
 done2:
         if (hmtx)
-                semMtxUnlock(hmtx);
+                __libc_Back_safesemMtxUnlock(hmtx);
 
         if (array != NULL)
@@ -1046 +818 @@
         struct semid_kernel * sema = gpGlobals->sema;
 
-        error = semMtxLock(gpGlobals->hmtx);
+        error = __libc_Back_safesemMtxLock(gpGlobals->hmtx);
         if (error)
             LIBCLOG_RETURN_INT(error);
@@ -1058 +830 @@
                 if (semid < seminfo.semmni) {
                         DPRINTF(("found public key\n"));
-                        if ((error = __libc_spmCanIPC(&sema[semid].u.sem_perm,
+                        if ((error = -__libc_spmCanIPC(&sema[semid].u.sem_perm,
                             semflg & 0700))) {
                                 goto done2;
@@ -1124 +896 @@
         errno = -IXSEQ_TO_IPCID(semid, sema[semid].u.sem_perm);
 done2:
-        semMtxUnlock(gpGlobals->hmtx);
+        __libc_Back_safesemMtxUnlock(gpGlobals->hmtx);
         LIBCLOG_RETURN_INT(-error);
 }
 
-
-static void __libc_Back_sysvSemSleepDone(int semid, struct semid_kernel *semaptr, uint16_t volatile *pu16)
+/**
+ * Args to __libc_Back_sysvSemSleepDone.
+ */
+struct SleepDoneArgs
 {
+    int semid;
+    struct semid_kernel *semaptr;
+    uint16_t volatile *pu16;
+};
+
+/**
+ * Wakeup function, called before signals are delivered.
+ */
+static void SleepDone(void *pvUser)
+{
+    struct SleepDoneArgs *pArgs = (struct SleepDoneArgs *)pvUser;
+
     /*
      * Make sure that the semaphore still exists
      */
-    if ((semaptr->u.sem_perm.mode & SEM_ALLOC) == 0 ||
-        semaptr->u.sem_perm.seq != IPCID_TO_SEQ(semid)) {
+    if ((pArgs->semaptr->u.sem_perm.mode & SEM_ALLOC) == 0 ||
+        pArgs->semaptr->u.sem_perm.seq != IPCID_TO_SEQ(pArgs->semid)) {
             return;
     }
@@ -1143 +929 @@
      * waiting processes.
      */
-    __atomic_decrement_u16(pu16);
+    __atomic_decrement_u16(pArgs->pu16);
 }
 
@@ -1199 +985 @@
 
         semaptr = &sema[semid];
-        error = semMtxLock(semaptr->hmtx);
+        error = __libc_Back_safesemMtxLock(semaptr->hmtx);
         if (error) {
                 if (sops != small_sops)
@@ -1232 +1018 @@
         }
 
-        if ((error = __libc_spmCanIPC(&semaptr->u.sem_perm, j))) {
+        if ((error = -__libc_spmCanIPC(&semaptr->u.sem_perm, j))) {
                 DPRINTF(("error = %d from ipaccess\n", error));
                 goto done2;
@@ -1315 +1101 @@
                 }
 
-                uint16_t volatile *pu16 = sopptr->sem_op == 0 ? &semptr->semzcnt : &semptr->semncnt;
-                __atomic_increment_u16(pu16);
+                struct SleepDoneArgs Args;
+                Args.semaptr = semaptr;
+                Args.semid = semid;
+                Args.pu16 = sopptr->sem_op == 0 ? &semptr->semzcnt : &semptr->semncnt;
+                __atomic_increment_u16(Args.pu16);
                 DPRINTF(("semop:  good night (%d)!\n", sopptr->sem_op));
-                error = -semEvSleep(semaptr, __libc_Back_sysvSemSleepDone, semid, pu16);
+                error = -__libc_Back_safesemEvSleep(semaptr->hev, semaptr->hmtx, SleepDone, &Args);
                 DPRINTF(("semop:  good morning (error=%d)!\n", error));
                 /* return code is checked below, after sem[nz]cnt-- */
@@ -1413 +1202 @@
         if (do_wakeup) {
                 DPRINTF(("semop:  doing wakeup\n"));
-                semEvWakeup(semaptr);
+                __libc_Back_safesemEvWakeup(semaptr->hev);
                 DPRINTF(("semop:  back from wakeup\n"));
         }
         DPRINTF(("semop:  done\n"));
 done2:
-        semMtxUnlock(semaptr->hmtx);
+        __libc_Back_safesemMtxUnlock(semaptr->hmtx);
         if (sops != small_sops)
                 free(sops);
@@ -1473 +1262 @@
                         semaptr = &gpGlobals->sema[semid];
                         SEMUNDO_LOCK();
-                        semMtxUnlock(semaptr->hmtx);
+                        __libc_Back_safesemMtxUnlock(semaptr->hmtx);
                         if ((semaptr->u.sem_perm.mode & SEM_ALLOC) == 0) {
                                 panic("semexit - semid not allocated");
@@ -1499 +1288 @@
                                 semaptr->u.sem_base[semnum].semval += adjval;
 
-                        semEvWakeup(semaptr);
+                        __libc_Back_safesemEvWakeup(semaptr->hev);
                         DPRINTF(("semexit:  back from wakeup\n"));
                     skip:
-                        semMtxUnlock(semaptr->hmtx);
+                        __libc_Back_safesemMtxUnlock(semaptr->hmtx);
                         SEMUNDO_UNLOCK();
                 }