Changeset 1615 for trunk/src

Timestamp:

Nov 6, 2004, 9:35:32 AM (21 years ago)

Author:

bird

Message:

signals are finally getting somewhere...

Location:

trunk/src/emx

Files:

• include/InnoTekLIBC/sharedpm.h (modified) (4 diffs, 1 prop)
• include/InnoTekLIBC/signals.h (modified) (3 diffs, 1 prop)
• include/sys/signal.h (modified) (3 diffs, 1 prop)
• src/lib/libc.def (modified) (1 diff, 1 prop)
• src/lib/process/kill.c (modified) (2 diffs, 1 prop)
• src/lib/sys/b_signalSendPGrp.c (modified) (1 diff, 1 prop)
• src/lib/sys/b_signalSendPid.c (modified) (3 diffs, 1 prop)
• src/lib/sys/b_signalVerifyPGrp.c (modified) (1 diff, 1 prop)
• src/lib/sys/b_signalVerifyPid.c (modified) (1 diff, 1 prop)
• src/lib/sys/exceptions.c (modified) (22 diffs, 1 prop)
• src/lib/sys/sharedpm.c (modified) (10 diffs, 1 prop)
• src/lib/sys/signals.c (modified) (31 diffs, 1 prop)

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

@@ -109 +109 @@
 
 
+/** The maximum number of signals a process can have pending on other processes concurrently. */
+#define __LIBC_SPM_SIGNALS_MAX_SENT 48
+
 /**
  * Signal (queued).
@@ -118 +121 @@
     /** Pointer to the next signal. */
     struct __libc_SPMSignal    *pNext;
+    /** Sender process.
+     * This is used to decrement the cSigsSent count of the sender. */
+    pid_t                       pidSender;
+
     /** Signal info. */
     siginfo_t                   Info;
@@ -277 +284 @@
      * For signals which aren't queable only one signal can be queued.
      */
-    __LIBC_PSPMSIGNAL           pSigHead;
-    /** Number of queued signals.
-     * After it passes 48 signals, only SIGCHLD will be queued.
-     * This means siqueue() won't work 100% according to spec. */
-    unsigned                    cSigsQueued;
+    volatile __LIBC_PSPMSIGNAL  pSigHead;
+    /** Number of signals send.
+     * After __LIBC_SPM_SIGNALS_MAX_SENT signals only SIGCHLD will be allowed sent.
+     */
+    volatile unsigned           cSigsSent;
 
     /** Reserved pool pointer field with default value 0. */
@@ -653 +660 @@
 
 /**
- * De-queues one or more pending signals.
+ * Get the signal set of pending signals.
+ *
+ * @returns Number of pending signals on success.
+ * @returns 0 if no signals are pending.
+ * @returns Negative error code (errno.h) on failure.
+ * @param   pSigSet     Where to create the set of pending signals.
+ */
+int     __libc_spmSigPending(sigset_t *pSigSet);
+
+/**
+ * De-queues one or more pending signals of a specific type.
+ *
  * @returns Number of de-queued signals on success.
  * @returns Negative error code (errno.h) on failure.
+ * @param   iSignalNo   Signal type to dequeue.
  * @param   paSignals   Where to store the signals.
  * @param   cSignals    Size of the signal array.
  * @param   cbSignal    Size of one signal entry.
  */
-int     __libc_spmSigDequeue(siginfo_t *paSignals, unsigned cSignals, size_t cbSignal);
+int     __libc_spmSigDequeue(int iSignalNo, siginfo_t *paSignals, unsigned cSignals, size_t cbSignal);
 
 

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

@@ -32 +32 @@
 *******************************************************************************/
 /** @defgroup __libc_back_signalRaise_return    __libc_back_signalRaise() returns.
+ * These are only valid for positive return values.
  * @{ */
 /** Try restart any interrupted system call. */
@@ -44 +45 @@
 /** If set the passed in SIGQUEUED structure was used. */
 #define __LIBC_BSRR_USED_QUEUED 0x40
-/** Failure. */
-#define __LIBC_BSRR_ERROR       0xffffff22
 /** @} */
 
@@ -94 +93 @@
 int         __libc_back_signalSuspend(void);
 int         __libc_back_signalWait(const struct timespec *pTimeout);
-int         __libc_back_signalVerifyPid(pid_t pid);
-int         __libc_back_signalVerifyPGrp(pid_t pgid);
-int         __libc_back_signalSendPid(pid_t pid, int iSignalNo);
 int         __libc_back_signalSendPidOther(pid_t pid, int iSignalNo);
-int         __libc_back_signalSendPGrp(pid_t pgrp, int iSignalNo);
 int         __libc_back_signalAction(int iSignalNo, const struct sigaction *pSigAct, struct sigaction *pSigActOld);
-unsigned    __libc_back_signalRaise(int iSignalNo, siginfo_t *pSigInfo, void *pvXcptOrQueued, unsigned fFlags);
 int         __libc_back_signalRaisePoked(void *pvXcptParams, int tidPoker);
 void        __libc_back_signalOS2V1Handler16bit(unsigned short uSignal, unsigned short uArg);
 void        __libc_back_signalOS2V1Handler32bit(unsigned uSignal, unsigned uArg);
 
+
+/**
+ * Raises a signal in the current process.
+ *
+ * @returns On success a flag mask out of the __LIBC_BSRR_* #defines is returned.
+ * @returns On failure a negative error code (errno.h) is returned.
+ * @param   iSignalNo           Signal to raise.
+ * @param   pSigInfo            Pointer to signal info for this signal.
+ *                              NULL is allowed.
+ * @param   pvXcptOrQueued      Exception handler parameter list.
+ *                              Or if __LIBC_BSRF_QUEUED is set, a pointer to locally malloced
+ *                              SIGQUEUED node.
+ * @param   fFlags              Flags of the #defines __LIBC_BSRF_* describing how to
+ *                              deliver the signal.
+ *
+ * @remark  This Backend Signal API does NOT require the caller to own the signal semaphore.
+ */
+int __libc_Back_signalRaise(int iSignalNo, siginfo_t *pSigInfo, void *pvXcptOrQueued, unsigned fFlags);
+
+/**
+ * Send a signal to a process.
+ *
+ * @returns 0 on if signal sent.
+ * @returns -errno on failure.
+ *
+ * @param   pid         Process Id of the process which the signal is to be sent to.
+ * @param   iSignalNo   The signal to send.
+ * @remark  This Backend Signal API does NOT require the caller to own the signal semaphore.
+ */
+int     __libc_Back_signalSendPid(pid_t pid, int iSignalNo);
+
+/**
+ * Verify the existance of another process and that the current process
+ * is allowed to signal it.
+ *
+ * @return 0 on success.
+ * @return -ESRCH if pid doesn't exist.
+ * @return -EPERM if we aren't allowed to signal the pid.
+ * @param   pid     Process Id for the process which we wanna signal.
+ * @todo    Do EPERM check, no ideas here yet.
+ * @remark  This Backend Signal API does NOT require the caller to own the signal semaphore.
+ */
+int     __libc_Back_signalVerifyPid(pid_t pid);
+
+/**
+ * Not implemented.
+ *
+ * @returns -ENOSYS.
+ * @param   pgrp        Process group (positive).
+ *                      0 means the process group of this process.
+ *                      1 means all process in the system.
+ * @param   iSignalNo   Signal to send to all the processes in the group.
+ */
+int     __libc_Back_signalSendPGrp(pid_t pgrp, int iSignalNo);
+
+/**
+ * Verify the existance of a process group and that the current process
+ * is allowed to signal it.
+ *
+ * @return 0 on success.
+ * @return -ESRCH if pgid doesn't exist.
+ * @return -EPERM if we aren't allowed to signal the pgid.
+ * @param   pgid    Process group id which the current process intend to signal.
+ * @todo    Do EPERM check, no ideas here yet.
+ * @remark  This Backend Signal API does NOT require the caller to own the signal semaphore.
+ */
+int     __libc_Back_signalVerifyPGrp(pid_t pgid);
+
+
 __END_DECLS
 

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

@@ -147 +147 @@
 /** Take signal on a registerd stack_t. */
 #define SA_ONSTACK          0x00000001
-/** Restart system call on signal return. Not implemented on OS/2. */
+/** Restart system call on signal return. */
 #define SA_RESTART          0x00000002
 /** Reset signal handler to SIG_DFL when deliving the signal. */
@@ -395 +395 @@
     /** Timestamp when the signal was generated - LIBC extension. */
     unsigned        si_timestamp;
+    /** Flags - LIBC extension. __LIBC_SI_* */
+    unsigned        si_flags;
     /** Process sending the signal. */
     __pid_t         si_pid;
@@ -412 +414 @@
     int             si_fd;
     /** Reserve a little bit for future usage. */
-    unsigned        auReserved[4];
+    unsigned        auReserved[3];
 } siginfo_t;
+
+#ifdef __BSD_VISIBLE
+/** Signals LIBC flags.
+ * @{ */
+/** If set the signal was queue. */
+#define __LIBC_SI_QUEUED        0x00000001
+/** @} */
+#endif
 #endif
 

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

@@ -1230 +1230 @@
     "__std_sigwait" @1252
     "__std_sigwaitinfo" @1253
+    "_gpSigQueueHead" @1254
+    "_gpSigQueueTail" @1255
+    "___libc_Back_signalRaise" @1256
+    "___libc_Back_signalSendPGrp" @1257
+    "___libc_Back_signalSendPid" @1258
+    "___libc_Back_signalVerifyPGrp" @1259
+    "___libc_Back_signalVerifyPid" @1260

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

@@ -75 +75 @@
      */
     if (pid > 0)
-        rc = __libc_back_signalVerifyPid(pid);
+        rc = __libc_Back_signalVerifyPid(pid);
     else /* (pid <= 0) */
-        rc = __libc_back_signalVerifyPGrp(-pid);
+        rc = __libc_Back_signalVerifyPGrp(-pid);
     if (!rc)
     {
@@ -90 +90 @@
          */
         if (pid > 0)
-            rc = __libc_back_signalSendPid(pid, iSignalNo);
+            rc = __libc_Back_signalSendPid(pid, iSignalNo);
         else
-            rc = __libc_back_signalSendPGrp(-pid, iSignalNo);
+            rc = __libc_Back_signalSendPGrp(-pid, iSignalNo);
         if (!rc)
             LIBCLOG_RETURN_INT(0);

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

@@ -52 +52 @@
  * @param   iSignalNo   Signal to send to all the processes in the group.
  */
-int         __libc_back_signalSendPGrp(pid_t pgrp, int iSignalNo)
+int         __libc_Back_signalSendPGrp(pid_t pgrp, int iSignalNo)
 {
     LIBC_ASSERTM_FAILED("__libc_back_signalSendPGrp is not implemented\n");

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

@@ -53 +53 @@
  * @remark  This Backend Signal API does NOT require the caller to own the signal semaphore.
  */
-int     __libc_back_signalSendPid(pid_t pid, int iSignalNo)
+int     __libc_Back_signalSendPid(pid_t pid, int iSignalNo)
 {
     LIBCLOG_ENTER("pid=%d iSignalNo=%d\n", pid, iSignalNo);
@@ -59 +59 @@
 
     /*
-     * Certain assumption are made.
+     * Validate input.
      */
-    LIBC_ASSERTM(__SIGSET_SIG_VALID(iSignalNo), "Invalid signal no. %d\n", iSignalNo);
-    LIBC_ASSERTM(pid > 0, "Invalid pid %d\n", pid);
+    if (!__SIGSET_SIG_VALID(iSignalNo))
+    {
+        LIBC_ASSERTM_FAILED("Invalid signal no. %d\n", iSignalNo);
+        LIBCLOG_RETURN_INT(-EINVAL);
+    }
+    if (pid < 0)
+    {
+        LIBC_ASSERTM_FAILED("Invalid pid %d\n", pid);
+        LIBCLOG_RETURN_INT(-EINVAL);
+    }
 
     /*
@@ -71 +79 @@
     else
     {
-        int old_errno =
-        rc = __libc_back_signalRaise(iSignalNo, NULL, NULL, 0);
+        rc = __libc_Back_signalRaise(iSignalNo, NULL, NULL, 0);
         if (rc > 0)
             rc = 0;

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

@@ -51 +51 @@
  * @remark  This Backend Signal API does NOT require the caller to own the signal semaphore.
  */
-int     __libc_back_signalVerifyPGrp(pid_t pgid)
+int     __libc_Back_signalVerifyPGrp(pid_t pgid)
 {
     LIBCLOG_ENTER("pgid=%d\n", pgid);

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

@@ -51 +51 @@
  * @remark  This Backend Signal API does NOT require the caller to own the signal semaphore.
  */
-int     __libc_back_signalVerifyPid(pid_t pid)
+int     __libc_Back_signalVerifyPid(pid_t pid)
 {
     LIBCLOG_ENTER("pid=%d\n", pid);

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

@@ -77 +77 @@
     __asm__ ("cld");                    /* usual paranoia.  */
     siginfo_t   SigInfo = {0};
-    int         rc;                     /* return from __libc_back_signalRaise() */
+    int         rc;                     /* return from __libc_Back_signalRaise() */
 
     if (pXcptRepRec->fHandlerFlags & (EH_UNWINDING | EH_EXIT_UNWIND))
@@ -116 +116 @@
                             case XCPT_SIGNAL_KILLPROC:  SigInfo.si_signo = SIGTERM; break;
                         }
-                        rc = __libc_back_signalRaise(SigInfo.si_signo,  0, &pXcptRepRec, __LIBC_BSRF_EXTERNAL);
+                        rc = __libc_Back_signalRaise(SigInfo.si_signo,  0, &pXcptRepRec, __LIBC_BSRF_EXTERNAL);
                         break;
                 }
@@ -156 +156 @@
             SigInfo.si_addr = (void*)pXcptRepRec->ExceptionInfo[1]; /* accessed memory address */
             SigInfo.si_code = SEGV_ACCERR;
-            rc = __libc_back_signalRaise(SigInfo.si_signo, &SigInfo, &pXcptRepRec, __LIBC_BSRF_HARDWARE | __LIBC_BSRF_THREAD);
+            rc = __libc_Back_signalRaise(SigInfo.si_signo, &SigInfo, &pXcptRepRec, __LIBC_BSRF_HARDWARE | __LIBC_BSRF_THREAD);
             break;
 
@@ -166 +166 @@
             SigInfo.si_code  = BUS_ADRALN;
             SigInfo.si_addr  = (void*)pXcptRepRec->ExceptionInfo[2]; /* accessed memory address */
-            rc = __libc_back_signalRaise(SigInfo.si_signo, &SigInfo, &pXcptRepRec, __LIBC_BSRF_HARDWARE | __LIBC_BSRF_THREAD);
+            rc = __libc_Back_signalRaise(SigInfo.si_signo, &SigInfo, &pXcptRepRec, __LIBC_BSRF_HARDWARE | __LIBC_BSRF_THREAD);
             break;
 
@@ -176 +176 @@
             SigInfo.si_code  = FPE_INTDIV;
             SigInfo.si_addr  = (void *)pCtx->ctx_RegEip;
-            rc = __libc_back_signalRaise(SigInfo.si_signo, &SigInfo, &pXcptRepRec, __LIBC_BSRF_HARDWARE | __LIBC_BSRF_THREAD);
+            rc = __libc_Back_signalRaise(SigInfo.si_signo, &SigInfo, &pXcptRepRec, __LIBC_BSRF_HARDWARE | __LIBC_BSRF_THREAD);
             break;
 
@@ -183 +183 @@
             SigInfo.si_code  = FPE_INTOVF;
             SigInfo.si_addr  = (void *)pCtx->ctx_RegEip;
-            rc = __libc_back_signalRaise(SigInfo.si_signo, &SigInfo, &pXcptRepRec, __LIBC_BSRF_HARDWARE | __LIBC_BSRF_THREAD);
+            rc = __libc_Back_signalRaise(SigInfo.si_signo, &SigInfo, &pXcptRepRec, __LIBC_BSRF_HARDWARE | __LIBC_BSRF_THREAD);
             break;
 
@@ -190 +190 @@
             SigInfo.si_code  = FPE_FLTDIV;
             SigInfo.si_addr  = (void *)pCtx->ctx_RegEip;
-            rc = __libc_back_signalRaise(SigInfo.si_signo, &SigInfo, &pXcptRepRec, __LIBC_BSRF_HARDWARE | __LIBC_BSRF_THREAD);
+            rc = __libc_Back_signalRaise(SigInfo.si_signo, &SigInfo, &pXcptRepRec, __LIBC_BSRF_HARDWARE | __LIBC_BSRF_THREAD);
             break;
 
@@ -197 +197 @@
             SigInfo.si_code  = FPE_FLTOVF;
             SigInfo.si_addr  = (void *)pCtx->ctx_RegEip;
-            rc = __libc_back_signalRaise(SigInfo.si_signo, &SigInfo, &pXcptRepRec, __LIBC_BSRF_HARDWARE | __LIBC_BSRF_THREAD);
+            rc = __libc_Back_signalRaise(SigInfo.si_signo, &SigInfo, &pXcptRepRec, __LIBC_BSRF_HARDWARE | __LIBC_BSRF_THREAD);
             break;
 
@@ -204 +204 @@
             SigInfo.si_code  = FPE_FLTUND;
             SigInfo.si_addr  = (void *)pCtx->ctx_RegEip;
-            rc = __libc_back_signalRaise(SigInfo.si_signo, &SigInfo, &pXcptRepRec, __LIBC_BSRF_HARDWARE | __LIBC_BSRF_THREAD);
+            rc = __libc_Back_signalRaise(SigInfo.si_signo, &SigInfo, &pXcptRepRec, __LIBC_BSRF_HARDWARE | __LIBC_BSRF_THREAD);
             break;
 
@@ -211 +211 @@
             SigInfo.si_code  = FPE_FLTINV; /* ??? */
             SigInfo.si_addr  = (void *)pCtx->ctx_RegEip;
-            rc = __libc_back_signalRaise(SigInfo.si_signo, &SigInfo, &pXcptRepRec, __LIBC_BSRF_HARDWARE | __LIBC_BSRF_THREAD);
+            rc = __libc_Back_signalRaise(SigInfo.si_signo, &SigInfo, &pXcptRepRec, __LIBC_BSRF_HARDWARE | __LIBC_BSRF_THREAD);
             break;
 
@@ -218 +218 @@
             SigInfo.si_code  = FPE_FLTRES;
             SigInfo.si_addr  = (void *)pCtx->ctx_RegEip;
-            rc = __libc_back_signalRaise(SigInfo.si_signo, &SigInfo, &pXcptRepRec, __LIBC_BSRF_HARDWARE | __LIBC_BSRF_THREAD);
+            rc = __libc_Back_signalRaise(SigInfo.si_signo, &SigInfo, &pXcptRepRec, __LIBC_BSRF_HARDWARE | __LIBC_BSRF_THREAD);
             break;
 
@@ -225 +225 @@
             SigInfo.si_code  = FPE_FLTINV;
             SigInfo.si_addr  = (void *)pCtx->ctx_RegEip;
-            rc = __libc_back_signalRaise(SigInfo.si_signo, &SigInfo, &pXcptRepRec, __LIBC_BSRF_HARDWARE | __LIBC_BSRF_THREAD);
+            rc = __libc_Back_signalRaise(SigInfo.si_signo, &SigInfo, &pXcptRepRec, __LIBC_BSRF_HARDWARE | __LIBC_BSRF_THREAD);
             break;
 
@@ -232 +232 @@
             SigInfo.si_code  = FPE_FLTINV; /* ??? */
             SigInfo.si_addr  = (void *)pCtx->ctx_RegEip;
-            rc = __libc_back_signalRaise(SigInfo.si_signo, &SigInfo, &pXcptRepRec, __LIBC_BSRF_HARDWARE | __LIBC_BSRF_THREAD);
+            rc = __libc_Back_signalRaise(SigInfo.si_signo, &SigInfo, &pXcptRepRec, __LIBC_BSRF_HARDWARE | __LIBC_BSRF_THREAD);
             break;
 
@@ -239 +239 @@
             SigInfo.si_code  = FPE_FLTSUB;
             SigInfo.si_addr  = (void *)pCtx->ctx_RegEip;
-            rc = __libc_back_signalRaise(SigInfo.si_signo, &SigInfo, &pXcptRepRec, __LIBC_BSRF_HARDWARE | __LIBC_BSRF_THREAD);
+            rc = __libc_Back_signalRaise(SigInfo.si_signo, &SigInfo, &pXcptRepRec, __LIBC_BSRF_HARDWARE | __LIBC_BSRF_THREAD);
             break;
 
@@ -250 +250 @@
             SigInfo.si_code  = ILL_ILLOPC; /* this could be any ILL_ILLO* */
             SigInfo.si_addr  = (void *)pCtx->ctx_RegEip;
-            rc = __libc_back_signalRaise(SigInfo.si_signo, &SigInfo, &pXcptRepRec, __LIBC_BSRF_HARDWARE | __LIBC_BSRF_THREAD);
+            rc = __libc_Back_signalRaise(SigInfo.si_signo, &SigInfo, &pXcptRepRec, __LIBC_BSRF_HARDWARE | __LIBC_BSRF_THREAD);
             break;
 
@@ -257 +257 @@
             SigInfo.si_code  = ILL_ILLADR; /* ?????? */
             SigInfo.si_addr  = (void *)pCtx->ctx_RegEip;
-            rc = __libc_back_signalRaise(SigInfo.si_signo, &SigInfo, &pXcptRepRec, __LIBC_BSRF_HARDWARE | __LIBC_BSRF_THREAD);
+            rc = __libc_Back_signalRaise(SigInfo.si_signo, &SigInfo, &pXcptRepRec, __LIBC_BSRF_HARDWARE | __LIBC_BSRF_THREAD);
             break;
 
@@ -264 +264 @@
             SigInfo.si_code  = ILL_PRVOPC; /* this could be ILL_PRVREG too. */
             SigInfo.si_addr  = (void *)pCtx->ctx_RegEip;
-            rc = __libc_back_signalRaise(SigInfo.si_signo, &SigInfo, &pXcptRepRec, __LIBC_BSRF_HARDWARE | __LIBC_BSRF_THREAD);
+            rc = __libc_Back_signalRaise(SigInfo.si_signo, &SigInfo, &pXcptRepRec, __LIBC_BSRF_HARDWARE | __LIBC_BSRF_THREAD);
             break;
 
@@ -274 +274 @@
             SigInfo.si_code  = TRAP_TRACE; /* (?) */
             SigInfo.si_addr  = (void *)pCtx->ctx_RegEip;
-            rc = __libc_back_signalRaise(SigInfo.si_signo, &SigInfo, &pXcptRepRec, __LIBC_BSRF_HARDWARE | __LIBC_BSRF_THREAD);
+            rc = __libc_Back_signalRaise(SigInfo.si_signo, &SigInfo, &pXcptRepRec, __LIBC_BSRF_HARDWARE | __LIBC_BSRF_THREAD);
             break;
         case XCPT_BREAKPOINT:
@@ -280 +280 @@
             SigInfo.si_code  = TRAP_BRKPT;
             SigInfo.si_addr  = (void *)pCtx->ctx_RegEip;
-            rc = __libc_back_signalRaise(SigInfo.si_signo, &SigInfo, &pXcptRepRec, __LIBC_BSRF_HARDWARE | __LIBC_BSRF_THREAD);
+            rc = __libc_Back_signalRaise(SigInfo.si_signo, &SigInfo, &pXcptRepRec, __LIBC_BSRF_HARDWARE | __LIBC_BSRF_THREAD);
             break;
 
@@ -291 +291 @@
             /*
              * This exception is special. We use it to poke threads with pending signals.
-             * __libc_back_signalRaisePoked() will retest the flag from within the semaphore
+             * __libc_Back_signalRaisePoked() will retest the flag from within the semaphore
              * protection and returns __LIBC_BSRR_ERROR if it fails.
              */
@@ -297 +297 @@
             if (    !pThrd
                 ||  !pThrd->fSigBeingPoked
-                ||  (rc = __libc_back_signalRaisePoked(&pXcptRepRec, pXcptRepRec->ExceptionInfo[0])) == __LIBC_BSRR_ERROR)
+                ||  (rc = __libc_back_signalRaisePoked(&pXcptRepRec, pXcptRepRec->ExceptionInfo[0])) < 0)
             {
                 #if 0 /** bird: no so sure about this. */
@@ -329 +329 @@
     }
 
-    return rc & __LIBC_BSRR_PASSITON ? XCPT_CONTINUE_SEARCH : XCPT_CONTINUE_EXECUTION;
+    return rc > 0 && (rc & __LIBC_BSRR_PASSITON) ? XCPT_CONTINUE_SEARCH : XCPT_CONTINUE_EXECUTION;
 }
 

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

@@ -895 +895 @@
      * This is mostly because we wanna crash before we take the sem.
      */
-#ifdef SIGRTMAX                         /* just make it build. */
     if (pSignal->si_signo <= 0 || pSignal->si_signo > SIGRTMAX)
     {
@@ -901 +900 @@
         LIBCLOG_RETURN_INT(-EINVAL);
     }
-#endif
     if (pSignal->auReserved[(sizeof(pSignal->auReserved) / sizeof(pSignal->auReserved[0])) - 1])
     {
@@ -939 +937 @@
              * Check that we're not exceeding any per process or system limits.
              */
-            if (!gpSPMHdr->cSigMaxActive)
-                gpSPMHdr->cSigMaxActive = 1024;
-            if (    (   gpSPMHdr->cSigActive  < gpSPMHdr->cSigMaxActive
-                     && pProcess->cSigsQueued < 48)
+            if (    (   gpSPMHdr->cSigActive < gpSPMHdr->cSigMaxActive
+                     && gpSPMSelf->cSigsSent < __LIBC_SPM_SIGNALS_MAX_SENT)
                 || pSignal->si_signo == SIGCHLD)
             {
@@ -968 +964 @@
                         pSig->cb = sizeof(*pSig);
                 }
+                /*
+                 * Copy the data and insert it into the queue.
+                 */
                 if (pSig)
                 {
-                    /*
-                     * Copy the data and insert it into the queue.
-                     */
-                    pSig->pNext = pProcess->pSigHead;
-                    pSig->Info = *pSignal;
-                    pProcess->pSigHead = pSig;
-                    pProcess->cSigsQueued++;
+                    pSig->pNext     = NULL;
+                    pSig->pidSender = gpSPMSelf->pid;
+                    pSig->Info      = *pSignal;
+
+                    /* insert */
+                    if (!pProcess->pSigHead)
+                        pProcess->pSigHead = pSig;
+                    else
+                    {
+                        __LIBC_PSPMSIGNAL pSigLast = pProcess->pSigHead;
+                        while (pSigLast->pNext)
+                            pSigLast = pSigLast->pNext;
+                        pSigLast->pNext = pSig;
+                    }
+
+                    /* update statistics */
+                    if (pProcess != gpSPMSelf)
+                        gpSPMSelf->cSigsSent++;
                     gpSPMHdr->cSigActive++;
-                    rc = 0;
                 }
                 else
@@ -988 +997 @@
             else
             {
-                LIBCLOG_MSG("Limit reached: cSigActive=%d cSigMaxActive=%d cSigsQueued=%d (max 48)\n",
-                            gpSPMHdr->cSigActive, gpSPMHdr->cSigMaxActive, pProcess->cSigsQueued);
+                LIBCLOG_MSG("Limit reached: cSigActive=%d cSigMaxActive=%d cSigsSent=%d (max %d)\n",
+                            gpSPMHdr->cSigActive, gpSPMHdr->cSigMaxActive, pProcess->cSigsSent, __LIBC_SPM_SIGNALS_MAX_SENT);
                 rc = -EAGAIN;
             }
@@ -1008 +1017 @@
 
 /**
- * De-queues one or more pending signals.
- * @returns Number of de-queued signals on success.
+ * Get the signal set of pending signals.
+ *
+ * @returns Number of pending signals on success.
+ * @returns 0 if no signals are pending.
  * @returns Negative error code (errno.h) on failure.
- * @param   paSignals   Where to store the signals.
- * @param   cSignals    Size of the signal array.
- * @param   cbSignal    Size of one signal entry.
- */
-int     __libc_spmSigDequeue(siginfo_t *paSignals, unsigned cSignals, size_t cbSignal)
-{
-    LIBCLOG_ENTER("paSignals=%p cSignals=%d cbSignal=%d\n", (void *)paSignals, cSignals, cbSignal);
-
-    /*
-     * Validate input.
-     */
-    if (sizeof(siginfo_t) > cbSignal)
-    {
-        LIBC_ASSERTM_FAILED("Invalid siginfo_t size: cbSignal=%d sizeof(siginfo_t)=%d\n", cbSignal, sizeof(siginfo_t));
-        LIBCLOG_RETURN_INT(-EINVAL);
-    }
-    bzero(paSignals, cSignals * cbSignal); /* This'll trap if it's wrong :-) */
+ * @param   pSigSet     Where to create the set of pending signals.
+ */
+int     __libc_spmSigPending(sigset_t *pSigSet)
+{
+    LIBCLOG_ENTER("pSigSet=%p\n", (void *)pSigSet);
+
+    /*
+     * Paranoid as always, work on stack copy.
+     */
+    sigset_t SigSet;
+    __SIGSET_EMPTY(&SigSet);
 
     /*
@@ -1040 +1045 @@
      * De-queue signals one-by-one.
      */
-    while (gpSPMSelf->pSigHead && cSignals-- > 0)
-    {
+    __LIBC_PSPMSIGNAL pSig = gpSPMSelf->pSigHead;
+    while (pSig)
+    {
+        rc++;
+        __SIGSET_SET(&SigSet, pSig->Info.si_signo);
+        pSig = pSig->pNext;
+    }
+
+    spmReleaseMutex(&RegRec);
+    *pSigSet = SigSet;
+    LIBCLOG_RETURN_MSG(rc, "ret %d *pSigSet={%08lx %08lx}", rc, pSigSet->__bitmap[1], pSigSet->__bitmap[0]);
+}
+
+/**
+ * De-queues one or more pending signals of a specific type.
+ *
+ * @returns Number of de-queued signals on success.
+ * @returns Negative error code (errno.h) on failure.
+ * @param   iSignalNo   Signal type to dequeue.
+ * @param   paSignals   Where to store the signals.
+ * @param   cSignals    Size of the signal array.
+ * @param   cbSignal    Size of one signal entry.
+ */
+int     __libc_spmSigDequeue(int iSignalNo, siginfo_t *paSignals, unsigned cSignals, size_t cbSignal)
+{
+    LIBCLOG_ENTER("paSignals=%p cSignals=%d cbSignal=%d\n", (void *)paSignals, cSignals, cbSignal);
+
+    /*
+     * Validate input.
+     */
+    if (sizeof(siginfo_t) > cbSignal)
+    {
+        LIBC_ASSERTM_FAILED("Invalid siginfo_t size: cbSignal=%d sizeof(siginfo_t)=%d\n", cbSignal, sizeof(siginfo_t));
+        LIBCLOG_RETURN_INT(-EINVAL);
+    }
+    bzero(paSignals, cSignals * cbSignal); /* This'll trap if it's wrong :-) */
+
+    /*
+     * Request sem.
+     */
+    __LIBC_SPMXCPTREGREC    RegRec;
+    int rc = spmRequestMutex(&RegRec);
+    if (rc)
+        LIBCLOG_RETURN_INT(rc);
+
+    /*
+     * De-queue signals one-by-one.
+     */
+    __LIBC_PSPMSIGNAL pSigPrev = NULL;
+    __LIBC_PSPMSIGNAL pSig = gpSPMSelf->pSigHead;
+    while (pSig && cSignals-- > 0)
+    {
+        /*
+         * Find it.
+         */
+        while (pSig && pSig->Info.si_signo != iSignalNo)
+        {
+            pSigPrev = pSig;
+            pSig = pSig->pNext;
+        }
+        if (!pSig)
+            break;
+
         /*
          * Copy it.
          */
-        __LIBC_PSPMSIGNAL pSig = gpSPMSelf->pSigHead;
         if (pSig->cb >= sizeof(siginfo_t))
             *paSignals = pSig->Info;
@@ -1054 +1119 @@
          * Unlink it and free it.
          */
-        gpSPMSelf->pSigHead = pSig->pNext;
-        if (gpSPMSelf->cSigsQueued > 0)
-            gpSPMSelf->cSigsQueued--;
+        /* statistics */
+        if (gpSPMSelf->pid != pSig->pidSender)
+        {
+            __LIBC_PSPMPROCESS pSender = spmQueryProcessInState(pSig->pidSender, __LIBC_PROCSTATE_ALIVE);
+            if (pSender)
+                pSender->cSigsSent--;
+        }
+        gpSPMHdr->cSigActive--;
+
+        /* unlink */
+        if (pSigPrev)
+            pSigPrev->pNext = pSig->pNext;
+        else
+            gpSPMSelf->pSigHead = pSig->pNext;
+
+        /* free */
+        __LIBC_PSPMSIGNAL pSigNext = pSig->pNext;
         if (gpSPMHdr->cSigFree < 32)
         {
@@ -1066 +1145 @@
             spmFree(pSig);
 
-        /* next */
+        /*
+         * Next.
+         */
+        pSig = pSigNext;
+        paSignals = (siginfo_t *)((char *)paSignals + cbSignal);
         rc++;
-        paSignals = (siginfo_t *)((char *)paSignals + cbSignal);
     }
 
@@ -1410 +1492 @@
         rc = DosGetNamedSharedMem(&pv, (PCSZ)SPM_MEMORY_NAME, PAG_READ | PAG_WRITE);
         if (!rc)
+        {
             gpSPMHdr = (__LIBC_PSPMHEADER)pv;
+            if (!gpSPMHdr->cSigMaxActive)
+                gpSPMHdr->cSigMaxActive = 1024;
+        }
         else
         {

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

@@ -30 +30 @@
  * LIBC fully implements the posix signal handling.
  *
- * Interprocess signaling is somewhat compatible with EMX, that is
- * some of the EMX signals didn't have the same values as BSD, and most
- * of them weren't implemented. Thus sending signals to non LIBC processes
- * even EMX processes may not work as expected.
- *
- * @todo write more!
+ * Interprocess signaling is only available when target is linked to LIBCxyz.DLL.
+ * When the target is a LIBC process the signal is queued in SPM before the
+ * target process is actually poked. When the target is a non-LIBC process the
+ * signal is attempted converted to EMX and signaled in the EMX fashion. This
+ * obviously means that certain restrictions applies when signaling EMX processes.
+ *
+ *
+ * Signals are pending in on of three places depending on how fare they are
+ * scheduled. Scheduling levels and pending location:
+ *          - Pending on the SPM process, not scheduled.
+ *          - Pending in process wide queues, not scheduled.
+ *          - Pending on thread, scheduled.
+ *
+ * There are generally speaking fource sources signals:
+ *          - Internal software signals in current thread, raise()/kill(getpid())/sigqueue(getpid()).
+ *          - Other thread, pthread_kill(). This needs no process scheduling, only
+ *            priority ordering on delivery.
+ *          - OS/2 hardware exceptions. Generally no scheduling required, these must be
+ *            handled promptly on the current thread.
+ *          - External signals, queued in SPM, EMX signals, or OS/2 signal exceptions.
+ *
+ * When talking scheduling this means we'll reschedule the entire process when:
+ *          - an external signal arrives.
+ *          - an internal software signal occurs (raise/kill/sigqueue).
+ *          - the signal mask of a thread changes.
+ *            Two cases, 1) unblocking a signal no, 2) blocking signal no with
+ *            pending signal. The 2nd case is very uncommon and could perhaps be
+ *            ignored or handled differently. -bird: we do that now!
+ *
  *
  */
@@ -69 +92 @@
 
 /** @defgroup libc_back_signals_properties  Signal Properties
+ * The return actions are ordered by precendece.
  * @{ */
+/** Return Action: Terminate. */
+#define SPR_KILL        0x0000
 /** Return Action: Restart instruction. */
-#define SPR_RESTART     0x0000
-/** Return Action: Next exception handler. */
-#define SPR_NEXT        0x0001
-/** Return Action: Terminate if primary exception handler, next exception handler if not. */
-#define SPR_NEXT_KILL   0x0002
-/** Return Action: Terminate. */
-#define SPR_KILL        0x0003
+#define SPR_CONTINUE    0x0001
 /** Return Action Mask */
-#define SPR_MASK        0x0003
+#define SPR_MASK        0x0001
 
 /** Action: Ignore the signal. */
@@ -110 +130 @@
 /** Property: This signal can be queued. */
 #define SPP_QUEUED      0x0800
+/** Property: Signal action cannot be automatically reset in SysV fashion. */
+#define SPP_NORESET     0x1000
 /** @} */
 
@@ -166 +188 @@
 
 
-/** A Signal queue.
- * This is created per signal number and is ordered in a FIFO order,
- * inserting at the tail and removing from the head.
- */
-typedef struct SignalQueue
-{
-    /** Pointer to the head. */
-    PSIGQUEUED  pHead;
-    /** Pointer to the tail. */
-    PSIGQUEUED  pTail;
-} SIGQUEUE, *PSIGQUEUE;
-
-
 /** Thread enumeration state data.
- * Used by signalSchedule() when enumerating threads.
+ * Used by signalScheduleThread() when enumerating threads.
  */
 typedef struct SigSchedEnumParam
@@ -205 +214 @@
 static HMTX             ghmtxSignals;
 
+/** Signal Wait Event Semaphore.
+ * This is an event semaphore which will never be posted (unless we wanna resolve
+ * some nasty deadlock in the future) but is used to wait for a signal to arrive.
+ * When a signal arrives the wait will be interrupted to allow for execution of
+ * the exception and signal processing. DosWaitEventSem will return ERROR_INTERRUPT.
+ */
+static HEV              ghevWait;
+
 /** Signal Properties.
  * Describes the default actions of a signal.
@@ -211 +228 @@
 {
     /* return action | default action | property [|anotherprop] */
-    SPR_RESTART | SPA_IGNORE,                                           /* SIG0 */
-    SPR_RESTART | SPA_KILL    | SPP_ANYTHRD,                            /* SIGHUP    1     /-- POSIX: Hangup */
-    SPR_RESTART | SPA_KILL    | SPP_ANYTHRD,                            /* SIGINT    2     /-- ANSI: Interrupt (Ctrl-C) */
-    SPR_RESTART | SPA_CORE    | SPP_ANYTHRD,                            /* SIGQUIT   3     /-- POSIX: Quit */
-    SPR_RESTART | SPA_NEXT_CORE,                                        /* SIGILL    4     /-- ANSI: Illegal instruction */
-    SPR_RESTART | SPA_NEXT_KILL,                                        /* SIGTRAP   5     /-- POSIX: Single step (debugging) */
-    SPR_KILL    | SPA_CORE,                                             /* SIGABRT   6     /-- ANSI: abort () */
-    SPR_RESTART | SPA_CORE    | SPP_ANYTHRD,                            /* SIGEMT    7     /-- BSD: EMT instruction */
-    SPR_RESTART | SPA_NEXT_CORE,                                        /* SIGFPE    8     /-- ANSI: Floating point */
-    SPR_KILL    | SPA_KILL | SPP_ANYTHRD | SPP_NOBLOCK | SPP_NOCATCH,   /* SIGKILL   9     /-- POSIX: Kill process */
-    SPR_RESTART | SPA_CORE,                                             /* SIGBUS   10     /-- BSD 4.2: Bus error */
-    SPR_RESTART | SPA_NEXT_CORE,                                        /* SIGSEGV  11     /-- ANSI: Segmentation fault */
-    SPR_RESTART | SPA_CORE,                                             /* SIGSYS   12     /-- Invalid argument to system call */
-    SPR_RESTART | SPA_KILL    | SPP_ANYTHRD,                            /* SIGPIPE  13     /-- POSIX: Broken pipe. */
-    SPR_RESTART | SPA_KILL    | SPP_ANYTHRD,                            /* SIGALRM  14     /-- POSIX: Alarm. */
-    SPR_RESTART | SPA_NEXT_KILL | SPP_ANYTHRD,                          /* SIGTERM  15     /-- ANSI: Termination, process killed */
-    SPR_RESTART | SPA_IGNORE,                                           /* SIGURG   16     /-- POSIX/BSD: urgent condition on IO channel */
-    SPR_RESTART | SPA_STOP | SPP_ANYTHRD | SPP_NOBLOCK | SPP_NOCATCH,   /* SIGSTOP  17     /-- POSIX: Sendable stop signal not from tty. unblockable. */
-    SPR_RESTART | SPA_STOPTTY | SPP_ANYTHRD,                            /* SIGTSTP  18     /-- POSIX: Stop signal from tty. */
-    SPR_RESTART | SPA_RESUME  | SPP_ANYTHRD,                            /* SIGCONT  19     /-- POSIX: Continue a stopped process. */
-    SPR_RESTART | SPA_IGNORE  | SPP_ANYTHRD | SPP_QUEUED,               /* SIGCHLD  20     /-- POSIX: Death or stop of a child process. (EMX: 18) */
-    SPR_RESTART | SPA_STOPTTY | SPP_ANYTHRD,                            /* SIGTTIN  21     /-- POSIX: To readers pgrp upon background tty read. */
-    SPR_RESTART | SPA_STOPTTY | SPP_ANYTHRD,                            /* SIGTTOU  22     /-- POSIX: To readers pgrp upon background tty write. */
-    SPR_RESTART | SPA_IGNORE  | SPP_ANYTHRD,                            /* SIGIO    23     /-- BSD: Input/output possible signal. */
-    SPR_RESTART | SPA_KILL,                                             /* SIGXCPU  24     /-- BSD 4.2: Exceeded CPU time limit. */
-    SPR_RESTART | SPA_KILL,                                             /* SIGXFSZ  25     /-- BSD 4.2: Exceeded file size limit. */
-    SPR_RESTART | SPA_KILL    | SPP_ANYTHRD,                            /* SIGVTALRM 26    /-- BSD 4.2: Virtual time alarm. */
-    SPR_RESTART | SPA_KILL    | SPP_ANYTHRD,                            /* SIGPROF  27     /-- BSD 4.2: Profiling time alarm. */
-    SPR_RESTART | SPA_IGNORE  | SPP_ANYTHRD,                            /* SIGWINCH 28     /-- BSD 4.3: Window size change (not implemented). */
-    SPR_RESTART | SPA_NEXT_KILL | SPP_ANYTHRD,                          /* SIGBREAK 29     /-- OS/2: Break (Ctrl-Break). (EMX: 21) */
-    SPR_RESTART | SPA_KILL    | SPP_ANYTHRD,                            /* SIGUSR1  30     /-- POSIX: User-defined signal #1 */
-    SPR_RESTART | SPA_KILL    | SPP_ANYTHRD,                            /* SIGUSR2  31     /-- POSIX: User-defined signal #2 */
-    SPR_RESTART | SPA_NEXT_KILL | SPP_ANYTHRD,                          /* SIGBREAK 32     /-- OS/2: Break (Ctrl-Break). (EMX: 21) */
+    SPR_CONTINUE | SPA_IGNORE,                                          /* SIG0 */
+    SPR_CONTINUE | SPA_KILL    | SPP_ANYTHRD,                           /* SIGHUP    1     /-- POSIX: Hangup */
+    SPR_CONTINUE | SPA_KILL    | SPP_ANYTHRD,                           /* SIGINT    2     /-- ANSI: Interrupt (Ctrl-C) */
+    SPR_CONTINUE | SPA_CORE    | SPP_ANYTHRD,                           /* SIGQUIT   3     /-- POSIX: Quit */
+    SPR_CONTINUE | SPA_NEXT_CORE | SPP_NORESET,                         /* SIGILL    4     /-- ANSI: Illegal instruction */
+    SPR_CONTINUE | SPA_NEXT_KILL | SPP_NORESET,                         /* SIGTRAP   5     /-- POSIX: Single step (debugging) */
+    SPR_KILL     | SPA_CORE,                                            /* SIGABRT   6     /-- ANSI: abort () */
+    SPR_CONTINUE | SPA_CORE    | SPP_ANYTHRD,                           /* SIGEMT    7     /-- BSD: EMT instruction */
+    SPR_CONTINUE | SPA_NEXT_CORE,                                       /* SIGFPE    8     /-- ANSI: Floating point */
+    SPR_KILL     | SPA_KILL | SPP_ANYTHRD | SPP_NOBLOCK | SPP_NOCATCH,  /* SIGKILL   9     /-- POSIX: Kill process */
+    SPR_CONTINUE | SPA_CORE,                                            /* SIGBUS   10     /-- BSD 4.2: Bus error */
+    SPR_CONTINUE | SPA_NEXT_CORE,                                       /* SIGSEGV  11     /-- ANSI: Segmentation fault */
+    SPR_CONTINUE | SPA_CORE,                                            /* SIGSYS   12     /-- Invalid argument to system call */
+    SPR_CONTINUE | SPA_KILL    | SPP_ANYTHRD,                           /* SIGPIPE  13     /-- POSIX: Broken pipe. */
+    SPR_CONTINUE | SPA_KILL    | SPP_ANYTHRD,                           /* SIGALRM  14     /-- POSIX: Alarm. */
+    SPR_CONTINUE | SPA_NEXT_KILL | SPP_ANYTHRD,                         /* SIGTERM  15     /-- ANSI: Termination, process killed */
+    SPR_CONTINUE | SPA_IGNORE,                                          /* SIGURG   16     /-- POSIX/BSD: urgent condition on IO channel */
+    SPR_CONTINUE | SPA_STOP | SPP_ANYTHRD | SPP_NOBLOCK | SPP_NOCATCH,  /* SIGSTOP  17     /-- POSIX: Sendable stop signal not from tty. unblockable. */
+    SPR_CONTINUE | SPA_STOPTTY | SPP_ANYTHRD,                           /* SIGTSTP  18     /-- POSIX: Stop signal from tty. */
+    SPR_CONTINUE | SPA_RESUME  | SPP_ANYTHRD,                           /* SIGCONT  19     /-- POSIX: Continue a stopped process. */
+    SPR_CONTINUE | SPA_IGNORE  | SPP_ANYTHRD | SPP_QUEUED,              /* SIGCHLD  20     /-- POSIX: Death or stop of a child process. (EMX: 18) */
+    SPR_CONTINUE | SPA_STOPTTY | SPP_ANYTHRD,                           /* SIGTTIN  21     /-- POSIX: To readers pgrp upon background tty read. */
+    SPR_CONTINUE | SPA_STOPTTY | SPP_ANYTHRD,                           /* SIGTTOU  22     /-- POSIX: To readers pgrp upon background tty write. */
+    SPR_CONTINUE | SPA_IGNORE  | SPP_ANYTHRD,                           /* SIGIO    23     /-- BSD: Input/output possible signal. */
+    SPR_CONTINUE | SPA_KILL,                                            /* SIGXCPU  24     /-- BSD 4.2: Exceeded CPU time limit. */
+    SPR_CONTINUE | SPA_KILL,                                            /* SIGXFSZ  25     /-- BSD 4.2: Exceeded file size limit. */
+    SPR_CONTINUE | SPA_KILL    | SPP_ANYTHRD,                           /* SIGVTALRM 26    /-- BSD 4.2: Virtual time alarm. */
+    SPR_CONTINUE | SPA_KILL    | SPP_ANYTHRD,                           /* SIGPROF  27     /-- BSD 4.2: Profiling time alarm. */
+    SPR_CONTINUE | SPA_IGNORE  | SPP_ANYTHRD,                           /* SIGWINCH 28     /-- BSD 4.3: Window size change (not implemented). */
+    SPR_CONTINUE | SPA_NEXT_KILL | SPP_ANYTHRD,                         /* SIGBREAK 29     /-- OS/2: Break (Ctrl-Break). (EMX: 21) */
+    SPR_CONTINUE | SPA_KILL    | SPP_ANYTHRD,                           /* SIGUSR1  30     /-- POSIX: User-defined signal #1 */
+    SPR_CONTINUE | SPA_KILL    | SPP_ANYTHRD,                           /* SIGUSR2  31     /-- POSIX: User-defined signal #2 */
+    SPR_CONTINUE | SPA_NEXT_KILL | SPP_ANYTHRD,                         /* SIGBREAK 32     /-- OS/2: Break (Ctrl-Break). (EMX: 21) */
     /* real time signals */
-    SPR_RESTART | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                  /* SIGRTMIN +  0 */
-    SPR_RESTART | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                  /* SIGRTMIN +  1 */
-    SPR_RESTART | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                  /* SIGRTMIN +  2 */
-    SPR_RESTART | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                  /* SIGRTMIN +  3 */
-    SPR_RESTART | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                  /* SIGRTMIN +  4 */
-    SPR_RESTART | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                  /* SIGRTMIN +  5 */
-    SPR_RESTART | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                  /* SIGRTMIN +  6 */
-    SPR_RESTART | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                  /* SIGRTMIN +  7 */
-    SPR_RESTART | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                  /* SIGRTMIN +  8 */
-    SPR_RESTART | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                  /* SIGRTMIN +  9 */
-    SPR_RESTART | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                  /* SIGRTMIN + 10 */
-    SPR_RESTART | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                  /* SIGRTMIN + 11 */
-    SPR_RESTART | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                  /* SIGRTMIN + 12 */
-    SPR_RESTART | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                  /* SIGRTMIN + 13 */
-    SPR_RESTART | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                  /* SIGRTMIN + 14 */
-    SPR_RESTART | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                  /* SIGRTMIN + 15 */
-    SPR_RESTART | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                  /* SIGRTMIN + 16 */
-    SPR_RESTART | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                  /* SIGRTMIN + 17 */
-    SPR_RESTART | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                  /* SIGRTMIN + 18 */
-    SPR_RESTART | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                  /* SIGRTMIN + 19 */
-    SPR_RESTART | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                  /* SIGRTMIN + 20 */
-    SPR_RESTART | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                  /* SIGRTMIN + 21 */
-    SPR_RESTART | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                  /* SIGRTMIN + 22 */
-    SPR_RESTART | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                  /* SIGRTMIN + 23 */
-    SPR_RESTART | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                  /* SIGRTMIN + 24 */
-    SPR_RESTART | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                  /* SIGRTMIN + 25 */
-    SPR_RESTART | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                  /* SIGRTMIN + 26 */
-    SPR_RESTART | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                  /* SIGRTMIN + 27 */
-    SPR_RESTART | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                  /* SIGRTMIN + 28 */
-    SPR_RESTART | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                  /* SIGRTMIN + 29 */
-    SPR_RESTART | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                  /* SIGRTMIN + 30 == SIGRTMAX */
+    SPR_CONTINUE | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                 /* SIGRTMIN +  0 */
+    SPR_CONTINUE | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                 /* SIGRTMIN +  1 */
+    SPR_CONTINUE | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                 /* SIGRTMIN +  2 */
+    SPR_CONTINUE | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                 /* SIGRTMIN +  3 */
+    SPR_CONTINUE | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                 /* SIGRTMIN +  4 */
+    SPR_CONTINUE | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                 /* SIGRTMIN +  5 */
+    SPR_CONTINUE | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                 /* SIGRTMIN +  6 */
+    SPR_CONTINUE | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                 /* SIGRTMIN +  7 */
+    SPR_CONTINUE | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                 /* SIGRTMIN +  8 */
+    SPR_CONTINUE | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                 /* SIGRTMIN +  9 */
+    SPR_CONTINUE | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                 /* SIGRTMIN + 10 */
+    SPR_CONTINUE | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                 /* SIGRTMIN + 11 */
+    SPR_CONTINUE | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                 /* SIGRTMIN + 12 */
+    SPR_CONTINUE | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                 /* SIGRTMIN + 13 */
+    SPR_CONTINUE | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                 /* SIGRTMIN + 14 */
+    SPR_CONTINUE | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                 /* SIGRTMIN + 15 */
+    SPR_CONTINUE | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                 /* SIGRTMIN + 16 */
+    SPR_CONTINUE | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                 /* SIGRTMIN + 17 */
+    SPR_CONTINUE | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                 /* SIGRTMIN + 18 */
+    SPR_CONTINUE | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                 /* SIGRTMIN + 19 */
+    SPR_CONTINUE | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                 /* SIGRTMIN + 20 */
+    SPR_CONTINUE | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                 /* SIGRTMIN + 21 */
+    SPR_CONTINUE | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                 /* SIGRTMIN + 22 */
+    SPR_CONTINUE | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                 /* SIGRTMIN + 23 */
+    SPR_CONTINUE | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                 /* SIGRTMIN + 24 */
+    SPR_CONTINUE | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                 /* SIGRTMIN + 25 */
+    SPR_CONTINUE | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                 /* SIGRTMIN + 26 */
+    SPR_CONTINUE | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                 /* SIGRTMIN + 27 */
+    SPR_CONTINUE | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                 /* SIGRTMIN + 28 */
+    SPR_CONTINUE | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                 /* SIGRTMIN + 29 */
+    SPR_CONTINUE | SPA_CORE | SPP_ANYTHRD | SPP_QUEUED,                 /* SIGRTMIN + 30 == SIGRTMAX */
 };
 
@@ -354 +371 @@
  * All access to this set is protected by the signal semaphore.
  */
-sigset_t        __libc_gSignalPending = {{0,0}};
-
-/** Signal Queues.
- * All access to this array is protected by the signal semaphore.
- */
-static SIGQUEUE     gaSignalQueues[__SIGSET_MAXSIGNALS] =
-{
-    { NULL, NULL },                                 /* SIG0 */
-    { NULL, NULL },                                 /* SIGHUP    1     /-- POSIX: Hangup */
-    { NULL, NULL },                                 /* SIGINT    2     /-- ANSI: Interrupt (Ctrl-C) */
-    { NULL, NULL },                                 /* SIGQUIT   3     /-- POSIX: Quit */
-    { NULL, NULL },                                 /* SIGILL    4     /-- ANSI: Illegal instruction */
-    { NULL, NULL },                                 /* SIGTRAP   5     /-- POSIX: Single step (debugging) */
-    { NULL, NULL },                                 /* SIGABRT   6     /-- ANSI: abort () */
-    { NULL, NULL },                                 /* SIGEMT    7     /-- BSD: EMT instruction */
-    { NULL, NULL },                                 /* SIGFPE    8     /-- ANSI: Floating point */
-    { NULL, NULL },                                 /* SIGKILL   9     /-- POSIX: Kill process */
-    { NULL, NULL },                                 /* SIGBUS   10     /-- BSD 4.2: Bus error */
-    { NULL, NULL },                                 /* SIGSEGV  11     /-- ANSI: Segmentation fault */
-    { NULL, NULL },                                 /* SIGSYS   12     /-- Invalid argument to system call */
-    { NULL, NULL },                                 /* SIGPIPE  13     /-- POSIX: Broken pipe. */
-    { NULL, NULL },                                 /* SIGALRM  14     /-- POSIX: Alarm. */
-    { NULL, NULL },                                 /* SIGTERM  15     /-- ANSI: Termination, process killed */
-    { NULL, NULL },                                 /* SIGURG   16     /-- POSIX/BSD: urgent condition on IO channel */
-    { NULL, NULL },                                 /* SIGSTOP  17     /-- POSIX: Sendable stop signal not from tty. unblockable. */
-    { NULL, NULL },                                 /* SIGTSTP  18     /-- POSIX: Stop signal from tty. */
-    { NULL, NULL },                                 /* SIGCONT  19     /-- POSIX: Continue a stopped process. */
-    { NULL, NULL },                                 /* SIGCHLD  20     /-- POSIX: Death or stop of a child process. (EMX: 18) */
-    { NULL, NULL },                                 /* SIGTTIN  21     /-- POSIX: To readers pgrp upon background tty read. */
-    { NULL, NULL },                                 /* SIGTTOU  22     /-- POSIX: To readers pgrp upon background tty write. */
-    { NULL, NULL },                                 /* SIGIO    23     /-- BSD: Input/output possible signal. */
-    { NULL, NULL },                                 /* SIGXCPU  24     /-- BSD 4.2: Exceeded CPU time limit. */
-    { NULL, NULL },                                 /* SIGXFSZ  25     /-- BSD 4.2: Exceeded file size limit. */
-    { NULL, NULL },                                 /* SIGVTALRM 26    /-- BSD 4.2: Virtual time alarm. */
-    { NULL, NULL },                                 /* SIGPROF  27     /-- BSD 4.2: Profiling time alarm. */
-    { NULL, NULL },                                 /* SIGWINCH 28     /-- BSD 4.3: Window size change (not implemented). */
-    { NULL, NULL },                                 /* SIGINFO  29     /-- BSD 4.3: Information request. */
-    { NULL, NULL },                                 /* SIGUSR1  30     /-- POSIX: User-defined signal #1 */
-    { NULL, NULL },                                 /* SIGUSR2  31     /-- POSIX: User-defined signal #2 */
-    { NULL, NULL },                                 /* SIGBREAK 30     /-- OS/2: Break (Ctrl-Break). (EMX: 21) */
-    /* realtime signals */
-    { NULL, NULL },                                 /* SIGRTMIN +  0 */
-    { NULL, NULL },                                 /* SIGRTMIN +  1 */
-    { NULL, NULL },                                 /* SIGRTMIN +  2 */
-    { NULL, NULL },                                 /* SIGRTMIN +  3 */
-    { NULL, NULL },                                 /* SIGRTMIN +  4 */
-    { NULL, NULL },                                 /* SIGRTMIN +  5 */
-    { NULL, NULL },                                 /* SIGRTMIN +  6 */
-    { NULL, NULL },                                 /* SIGRTMIN +  7 */
-    { NULL, NULL },                                 /* SIGRTMIN +  8 */
-    { NULL, NULL },                                 /* SIGRTMIN +  9 */
-    { NULL, NULL },                                 /* SIGRTMIN + 10 */
-    { NULL, NULL },                                 /* SIGRTMIN + 11 */
-    { NULL, NULL },                                 /* SIGRTMIN + 12 */
-    { NULL, NULL },                                 /* SIGRTMIN + 13 */
-    { NULL, NULL },                                 /* SIGRTMIN + 14 */
-    { NULL, NULL },                                 /* SIGRTMIN + 15 */
-    { NULL, NULL },                                 /* SIGRTMIN + 16 */
-    { NULL, NULL },                                 /* SIGRTMIN + 17 */
-    { NULL, NULL },                                 /* SIGRTMIN + 18 */
-    { NULL, NULL },                                 /* SIGRTMIN + 19 */
-    { NULL, NULL },                                 /* SIGRTMIN + 20 */
-    { NULL, NULL },                                 /* SIGRTMIN + 21 */
-    { NULL, NULL },                                 /* SIGRTMIN + 22 */
-    { NULL, NULL },                                 /* SIGRTMIN + 23 */
-    { NULL, NULL },                                 /* SIGRTMIN + 24 */
-    { NULL, NULL },                                 /* SIGRTMIN + 25 */
-    { NULL, NULL },                                 /* SIGRTMIN + 26 */
-    { NULL, NULL },                                 /* SIGRTMIN + 27 */
-    { NULL, NULL },                                 /* SIGRTMIN + 28 */
-    { NULL, NULL },                                 /* SIGRTMIN + 29 */
-    { NULL, NULL },                                 /* SIGRTMIN + 30 == SIGRTMAX */
-};
-
+sigset_t            __libc_gSignalPending = {{0,0}};
+
+/** Head of the queue of pending signals.
+ * All access to this set is protected by the signal semaphore.
+ */
+PSIGQUEUED          gpSigQueueHead = NULL;
+/** Tail of the queue of pending signals.
+ * All access to this set is protected by the signal semaphore.
+ */
+PSIGQUEUED          gpSigQueueTail = NULL;
 
 /** Array of statically allocated queued signals. */
-static SIGQUEUED    gpaSigQueuedPreAlloced[128] =
+static SIGQUEUED    gpaSigQueuedPreAlloced[64] =
 {
     { .pNext = &gpaSigQueuedPreAlloced[ 1], .enmHowFree = enmHowFree_PreAllocFree },    /* 0 */
@@ -502 +455 @@
  * All access to this array is protected by the signal semaphore.
  */
-static PSIGQUEUED    gpSigQueuedFree = &gpaSigQueuedPreAlloced[0];
+static PSIGQUEUED   gpSigQueuedFree = &gpaSigQueuedPreAlloced[0];
+/** Number of structures in the free queue. */
+static unsigned     gcSigQueuedFree = sizeof(gpaSigQueuedPreAlloced) / sizeof(gpaSigQueuedPreAlloced[0]);
 
 
@@ -508 +463 @@
 *   Internal Functions                                                         *
 *******************************************************************************/
-static unsigned         signalDeliver(int iSignalNo, siginfo_t *pSigInfo, void *pvXcpt);
-static __LIBC_PTHREAD   signalSchedule(int iSignalNo, __LIBC_PTHREAD pThrdCur);
-static int              signalScheduleWorker(__LIBC_PTHREAD pCur, __LIBC_PTHREAD pBest, void *pvParam);
+static int              signalSchedule(__LIBC_PTHREAD pThrd, int iSignalNo, siginfo_t *pSigInfo, unsigned fFlags, PSIGQUEUED pSigQueued);
+static void             signalScheduleSPM(__LIBC_PTHREAD pThrd);
+static void             signalScheduleProcess(__LIBC_PTHREAD pThrd);
+static void             signalScheduleToThread(__LIBC_PTHREAD pThrd, __LIBC_PTHREAD pThrdSig, int iSignalNo, PSIGQUEUED pSig);
+static __LIBC_PTHREAD   signalScheduleThread(int iSignalNo, __LIBC_PTHREAD pThrdCur);
+static int              signalScheduleThreadWorker(__LIBC_PTHREAD pCur, __LIBC_PTHREAD pBest, void *pvParam);
+static void             signalScheduleKickThreads(__LIBC_PTHREAD pThrd);
+static int              signalScheduleKickThreadsWorker(__LIBC_PTHREAD pCur, void *pvParam);
+static int              signalDeliver(__LIBC_PTHREAD pThrd, int iSignalNo, void *pvXcptParams);
+static void             signalTerminate(int iSignalNo) __dead2;
+static int              signalJobStop(int iSignalNo);
+static int              signalJobResume(void);
+static void             signalPokeThread(__LIBC_PTHREAD pThrdPoke);
 static int              signalActionWorker(__LIBC_PTHREAD pCur, void *pvParam);
 static unsigned         signalTimestamp(void);
@@ -534 +499 @@
     FS_SAVE_LOAD();
     rc = DosCreateMutexSemEx(NULL, &ghmtxSignals, 0, FALSE);
+    if (!rc)
+    {
+        /*
+         * Create the wait semaphore.
+         */
+        rc = DosCreateEventSemEx(NULL, &ghevWait, 0, 0);
+        if (!rc)
+        {
+            FS_RESTORE();
+            LIBCLOG_RETURN_INT(0);
+        }
+        else
+            LIBC_ASSERTM_FAILED("DosCreateEventSemEx failed with rc=%d\n", rc);
+
+        DosCloseMutexSemEx(ghmtxSignals);
+        ghmtxSignals = NULLHANDLE;
+    }
+    else
+        LIBC_ASSERTM_FAILED("DosCreateMutexSemEx failed with rc=%d\n", rc);
+
     FS_RESTORE();
-    if (rc)
-    {
-        LIBC_ASSERTM_FAILED("DosCreateMutexSemEx failed with rc=%d\n", rc);
-        LIBCLOG_RETURN_INT(-1);
-    }
-
-    LIBCLOG_RETURN_INT(0);
+    LIBCLOG_RETURN_INT(-1);
 }
 
@@ -689 +668 @@
  *
  * @returns On success a flag mask out of the __LIBC_BSRR_* #defines is returned.
- *
- *              __LIBC_BSRR_RESTART:    Try restart any interrupted system call.
- *              __LIBC_BSRR_INTERRUPT:  Go ahead interrupt system call in progress.
- *
- *              __LIBC_BSRR_CONTINUE:   If set execution should be resumed.
- *              __LIBC_BSRR_PASSITON:   If set execution should not be resumed but
- *                                      the signal should be passed on to the system.
- *
- * @returns __LIBC_BSRR_ERROR on failure, errno set.
+ * @returns On failure a negative error code (errno.h) is returned.
  * @param   iSignalNo           Signal to raise.
  * @param   pSigInfo            Pointer to signal info for this signal.
@@ -709 +680 @@
  * @remark  This Backend Signal API does NOT require the caller to own the signal semaphore.
  */
-unsigned __libc_back_signalRaise(int iSignalNo, siginfo_t *pSigInfo, void *pvXcptOrQueued, unsigned fFlags)
+int __libc_Back_signalRaise(int iSignalNo, siginfo_t *pSigInfo, void *pvXcptOrQueued, unsigned fFlags)
 {
     LIBCLOG_ENTER("iSignalNo=%d pSigInfo=%p pvXcptOrQueued=%p fFlags=%#x\n",
                   iSignalNo, (void *)pSigInfo, (void *)pvXcptOrQueued, fFlags);
-    __LIBC_PTHREAD  pThrd;
-    __LIBC_PTHREAD  pThrdSig = NULL;
-    int             rc = __LIBC_BSRR_ERROR;
-    LIBC_ASSERTM(__SIGSET_SIG_VALID(iSignalNo), "Invalid signal %d\n", iSignalNo);
-
-    /*
-     * Assert that we do not own the semaphore upon entry.
-     * This may happen is very special situation, but in general it shouldn't.
+
+    /*
+     * Can't be to careful!
      */
     LIBC_ASSERTM(!__libc_back_signalSemIsOwner(), "Thread owns the signal semaphore!!! Bad boy!!\n");
+    if (__SIGSET_SIG_VALID(iSignalNo) || iSignalNo == 0)
+    {
+        LIBC_ASSERTM_FAILED("Invalid signal %d\n", iSignalNo);
+        return -EINVAL;
+    }
 
     /*
@@ -728 +699 @@
      * There *MUST* be a current thread, if not, we're toast!
      */
-    pThrd = __libc_threadCurrentNoAuto();
+    __LIBC_PTHREAD  pThrd = __libc_threadCurrentNoAuto();
     if (!pThrd)
-        return __LIBC_BSRR_ERROR;
+    {
+        if (fFlags & (__LIBC_BSRF_EXTERNAL | __LIBC_BSRF_HARDWARE))
+        {
+            LIBC_ASSERTM_FAILED("No thread structure and we cannot safely create one!\n");
+            return __LIBC_BSRR_PASSITON | (__SIGSET_ISSET(&__libc_gSignalRestartMask, iSignalNo) ? __LIBC_BSRR_RESTART : __LIBC_BSRR_INTERRUPT);
+        }
+        pThrd = __libc_threadCurrent();
+        if (!pThrd)
+        {
+            LIBC_ASSERTM_FAILED("Failed to get thread structure!\n");
+            return -ENOMEM;
+        }
+    }
 
     /*
@@ -739 +722 @@
         if (!pSigInfo->si_timestamp)
             pSigInfo->si_timestamp = signalTimestamp();
+        if (fFlags & __LIBC_BSRF_QUEUED)
+            pSigInfo->si_flags |= __LIBC_SI_QUEUED;
         if (!pSigInfo->si_pid)
             pSigInfo->si_pid = _sys_pid;
@@ -744 +729 @@
             pSigInfo->si_tid = pThrd->tid;
     }
-
 
     /*
@@ -756 +740 @@
         LIBCLOG_MSG("we're toast!\n");
         DosWrite(HFILE_STDERR, szMsg, sizeof(szMsg) - 1, &cb);
-        for (;;)
-            DosExit(EXIT_PROCESS, 3);
-    }
-
-    /*
-     * Check if we're ignoring the signal.
+        signalTerminate(iSignalNo);
+    }
+
+    /*
+     * Schedule the signal.
+     */
+    int rc = signalSchedule(pThrd, iSignalNo, pSigInfo, fFlags, fFlags & __LIBC_BSRF_QUEUED ? pvXcptOrQueued : NULL);
+    if (rc >= 0)
+    {
+        /*
+         * Paranoia scheduling of the process.
+         */
+        signalScheduleSPM(pThrd);
+        signalScheduleProcess(pThrd);
+
+        /*
+         * Deliver signals pending on this thread.
+         */
+        int rc = signalDeliver(pThrd, fFlags & __LIBC_BSRF_HARDWARE ? iSignalNo : 0,  fFlags & __LIBC_BSRF_QUEUED ? NULL : pvXcptOrQueued);
+        if (rc >= 0 && __SIGSET_ISSET(&__libc_gSignalRestartMask, iSignalNo))
+            rc = (rc & ~(__LIBC_BSRR_INTERRUPT)) | __LIBC_BSRR_RESTART;
+    }
+
+    return rc;
+}
+
+
+/**
+ * Schedules a signal to the appropriate thread or leave it pending on the process.
+ *
+ * @returns 0 on success
+ * @returns Negative error code (errno.h) on failure.
+ * @param   pThrd               Current thread.
+ * @param   iSignalNo           Signal number of the signal to be scheduled.
+ * @param   pSigInfo            Pointer to signal info for this signal.
+ *                              NULL is allowed.
+ * @param   fFlags              Flags of the #defines __LIBC_BSRF_* describing how to
+ *                              deliver the signal.
+ * @param   pSigQueued          A pointer to locally malloced SIGQUEUED node. NULL is allowed and common.
+ */
+static int signalSchedule(__LIBC_PTHREAD pThrd, int iSignalNo, siginfo_t *pSigInfo, unsigned fFlags, PSIGQUEUED pSigQueued)
+{
+    LIBCLOG_ENTER("pThrd=%p iSignalNo=%d pSigInfo=%p fFlags=%#x pSigQueued=%p\n",
+                  (void *)pThrd, iSignalNo, (void *)pSigInfo, fFlags, (void *)pSigQueued);
+
+    LIBC_ASSERTM(__libc_back_signalSemIsOwner(), "Thread doesn't own the signal semaphore!!! Bad boy!!\n");
+
+    /*
+     * If we're ignoring the signal we just eat it up and return immediately.
      */
     if (    gaSignalActions[iSignalNo].__sigaction_u.__sa_handler == SIG_IGN
@@ -768 +795 @@
         )
     {
+        /* free any preallocated queued node. */
+        if (pSigQueued)
+        {
+            pSigQueued->pNext = gpSigQueuedFree;
+            gpSigQueuedFree = pSigQueued->pNext;
+            gcSigQueuedFree++;
+        }
+
+        LIBCLOG_MSG("Ignoring signal %d\n", iSignalNo);
+        LIBCLOG_RETURN_INT(0);
+    }
+
+
+    /*
+     * Try schedule the signal for a thread.
+     */
+    __LIBC_PTHREAD  pThrdSig = NULL;
+    if (    (fFlags & (__LIBC_BSRF_THREAD | __LIBC_BSRF_HARDWARE))
+        || !(gafSignalProperties[iSignalNo] & SPP_ANYTHRD))
+    {
         /*
-         * Release the signal sem and log the action.
+         * Must be scheduled for the current thread.
          */
-        __libc_back_signalSemRelease();
-        LIBCLOG_MSG("Ignoring signal %d\n", iSignalNo);
+        pThrdSig = pThrd;
     }
     else
     {
         /*
-         * Try schedule the signal for a thread.
+         * Schedule for any thread in the process (but obviously
+         * prefering the current thread when ever possible).
          */
-        if (    (fFlags & __LIBC_BSRF_THREAD)
-            || !(gafSignalProperties[iSignalNo] & SPP_ANYTHRD))
+         pThrdSig = signalScheduleThread(iSignalNo, pThrd);
+    }
+
+    int rc = 0;
+    if (pThrdSig)
+    {
+        /*
+         * Was it waited for?
+         */
+        if (   pThrdSig->enmStatus == enmLIBCThreadStatus_sigwait
+            && __SIGSET_ISSET(&pThrdSig->u.SigWait.SigSetWait, iSignalNo))
         {
             /*
-             * Must be scheduled for the current thread.
+             * Wake up a sigwait call.
              */
-            pThrdSig = pThrd;
+            /** @todo install extra exception handler while accessing this. */
+            if (pSigInfo)
+                *pThrdSig->u.SigWait.pSigInfo = *pSigInfo;
+            else
+            {
+                bzero(pThrdSig->u.SigWait.pSigInfo, sizeof(*pThrdSig->u.SigWait.pSigInfo));
+                pThrdSig->u.SigWait.pSigInfo->si_signo = iSignalNo;
+            }
+            pThrdSig->enmStatus = enmLIBCThreadStatus_unknown;
+            if (pThrdSig != pThrd)
+                signalPokeThread(pThrdSig);
+            LIBCLOG_MSG("wokeup sigwait in thread %d on signal %d.\n", pThrdSig->tid, iSignalNo);
         }
         else
         {
             /*
-             * Schedule for any thread in the process (but obviously
-             * prefering the current thread when ever possible).
+             * Not waited for, so just queue it if possible and mark it pending.
              */
-             pThrdSig = signalSchedule(iSignalNo, pThrd);
-        }
-
-
-        /*
-         * What to do with the signal.
-         */
-        if (!pThrdSig)
-        {
-            /*
-             * No recepient found, leave it pending somewhere.
-             *
-             * If a queued signal we ignore the ANYTHRD attribute because
-             * that's easier and the specs allow it.
-             */
-            if (    (gafSignalProperties[iSignalNo] & SPP_ANYTHRD)
-                ||  (fFlags & __LIBC_BSRF_QUEUED))
-            {
-                if (    (fFlags & __LIBC_BSRF_QUEUED)
-                    ||  (gafSignalProperties[iSignalNo] & SPP_QUEUED))
+            if (    (fFlags & __LIBC_BSRF_QUEUED)
+                ||  (gafSignalProperties[iSignalNo] & SPP_QUEUED))
+            {
+                /*
+                 * Queue the signal.
+                 */
+                if (!pSigQueued)
+                {   /* 'allocate' it. */
+                    pSigQueued = gpSigQueuedFree;
+                    if (pSigQueued)
+                        gpSigQueuedFree = pSigQueued->pNext;
+                }
+
+                /* got a sigqueued node? */
+                if (pSigQueued)
                 {
-                    /*
-                     * Queue the signal.
-                     */
-                    PSIGQUEUED  pSigQueued;
-                    rc = __LIBC_BSRR_RESTART | __LIBC_BSRR_CONTINUE;
-                    if ((fFlags & __LIBC_BSRF_QUEUED) && pvXcptOrQueued)
+                    if (pSigInfo)
+                        pSigQueued->SigInfo = *pSigInfo;
+                    else
+                        bzero(pSigQueued, sizeof(*pSigQueued));
+                    pSigQueued->SigInfo.si_signo = iSignalNo;
+
+                    /* insert into the queue, give hardware and kill priority (see signalDeliver()). */
+                    if (    (fFlags & __LIBC_BSRF_HARDWARE)
+                        ||  iSignalNo == SIGKILL)
                     {
-                        pSigQueued = (PSIGQUEUED)pvXcptOrQueued;
-                        rc |= __LIBC_BSRR_USED_QUEUED;
-                    }
-                    else
-                    {   /* 'allocate' it. */
-                        pSigQueued = gpSigQueuedFree;
-                        if (pSigQueued)
-                            gpSigQueuedFree = pSigQueued->pNext;
-                    }
-
-                    /* got a sigqueued node? */
-                    if (pSigQueued)
-                    {
-                        /* insert into the queue */
-                        if (pSigInfo)
-                            pSigQueued->SigInfo = *pSigInfo;
+                        pSigQueued->pPrev = NULL;
+                        pSigQueued->pNext = pThrdSig->SigQueue.pHead;
+                        if (pThrdSig->SigQueue.pHead)
+                            pThrdSig->SigQueue.pHead = pThrdSig->SigQueue.pHead->pPrev = pSigQueued;
                         else
-                            bzero(pSigQueued, sizeof(*pSigQueued));
-                        pSigQueued->SigInfo.si_signo = iSignalNo;
-                        pSigQueued->pNext = NULL;
-                        pSigQueued->pPrev = gaSignalQueues[iSignalNo].pTail;
-                        if (gaSignalQueues[iSignalNo].pTail)
-                            gaSignalQueues[iSignalNo].pTail = gaSignalQueues[iSignalNo].pTail->pNext = pSigQueued;
-                        else
-                            gaSignalQueues[iSignalNo].pTail = gaSignalQueues[iSignalNo].pHead = pSigQueued;
-                        __SIGSET_SET(&__libc_gSignalPending, iSignalNo);
-                        LIBCLOG_MSG("enqueued signal %d.\n", iSignalNo);
-                    }
-                    else
-                    {   /* arg! out of nodes :/ */
-                        errno = EAGAIN;
-                        rc = __LIBC_BSRR_ERROR;
-                    }
-                }
-                else
-                {
-                    /*
-                     * Add to the pending signals of this process.
-                     */
-                    __SIGSET_SET(&__libc_gSignalPending, iSignalNo);
-                    LIBCLOG_MSG("adding %d to pending signals of the current process.\n", iSignalNo);
-                    rc = __LIBC_BSRR_RESTART | __LIBC_BSRR_CONTINUE;
-                }
-            }
-            else
-            {
-                /*
-                 * Add to the pending signals of this thread.
-                 */
-                __SIGSET_SET(&pThrd->SigSetPending, iSignalNo);
-                LIBCLOG_MSG("adding %d to the pending signals of the current thread.\n", iSignalNo);
-                rc = __LIBC_BSRR_RESTART | __LIBC_BSRR_CONTINUE;
-            }
-
-            /*
-             * Leave the semaphore protection here.
-             */
-            __libc_back_signalSemRelease();
-        }
-        else
-        {
-            /*
-             * Make pending?
-             */
-            /** @todo checkup sigwait and arrival of signal not waited for. */
-            if (    __SIGSET_ISSET(&pThrdSig->SigSetBlocked, iSignalNo)
-                &&  (   pThrdSig->enmStatus != enmLIBCThreadStatus_sigwait
-                     || !__SIGSET_ISSET(&pThrdSig->u.SigWait.SigSetWait, iSignalNo))
-                &&  (   pThrdSig != pThrd
-                     || !(fFlags & __LIBC_BSRF_HARDWARE))
-                    )
-            {
-                /* set signal pending. */
-                __SIGSET_SET(&pThrd->SigSetPending, iSignalNo);
-                LIBCLOG_MSG("adding %d to the pending signals of thread %d.\n", iSignalNo, pThrdSig->tid);
-                rc = __LIBC_BSRR_RESTART | __LIBC_BSRR_CONTINUE;
-
-                /*
-                 * Release the signal thread and leave the semaphore protection.
-                 */
-                if (pThrdSig != pThrd)
-                    __libc_threadDereference(pThrdSig);
-                __libc_back_signalSemRelease();
-            }
-            else
-            {
-                /*
-                 * The signal is not blocked or it's waited for.
-                 */
-                if (    pThrdSig == pThrd
-                    &&  (   pThrdSig->enmStatus != enmLIBCThreadStatus_sigwait
-                         || __SIGSET_ISSET(&pThrdSig->u.SigWait.SigSetWait, iSignalNo)))
-                {
-                    /*
-                     * Deliver the signal to the current thread.
-                     * This function will release the semaphore for us.
-                     */
-                    rc = signalDeliver(iSignalNo, pSigInfo,
-                                                   !(fFlags & __LIBC_BSRF_QUEUED) ? pvXcptOrQueued : NULL);
-                }
-                else
-                {
-                    if (   pThrdSig->enmStatus == enmLIBCThreadStatus_sigwait
-                        && __SIGSET_ISSET(&pThrdSig->u.SigWait.SigSetWait, iSignalNo))
-                    {
-                        /*
-                         * Wake up a sigwait call.
-                         */
-                        /** @todo install extra exception handler while accessing this. */
-                        if (pSigInfo)
-                            *pThrdSig->u.SigWait.pSigInfo = *pSigInfo;
-                        else
-                        {
-                            bzero(pThrdSig->u.SigWait.pSigInfo, sizeof(*pThrdSig->u.SigWait.pSigInfo));
-                            pThrdSig->u.SigWait.pSigInfo->si_signo = iSignalNo;
-                        }
-                        pThrdSig->enmStatus = enmLIBCThreadStatus_unknown;
-                        if (pThrdSig != pThrd)
-                            __libc_back_signalPokeThread(pThrdSig->tid);
-                        LIBCLOG_MSG("work up sigwait in thread %d on signal %d\n", pThrdSig->tid, iSignalNo);
+                            pThrdSig->SigQueue.pHead = pThrdSig->SigQueue.pTail = pSigQueued;
                     }
                     else
                     {
-                        /*
-                         * Set pending / queue signal with another thread and poke it.
-                         */
-                        rc = __LIBC_BSRR_RESTART | __LIBC_BSRR_CONTINUE;
-                        if (    (fFlags & __LIBC_BSRF_QUEUED)
-                            ||  (gafSignalProperties[iSignalNo] & SPP_QUEUED))
-                        {
-                            /*
-                             * Queue the signal.
-                             */
-                            PSIGQUEUED  pSigQueued;
-                            if ((fFlags & __LIBC_BSRF_QUEUED) && pvXcptOrQueued)
-                            {
-                                pSigQueued = (PSIGQUEUED)pvXcptOrQueued;
-                                rc |= __LIBC_BSRR_USED_QUEUED;
-                            }
-                            else
-                            {   /* 'allocate' it. */
-                                pSigQueued = gpSigQueuedFree;
-                                if (pSigQueued)
-                                    gpSigQueuedFree = pSigQueued->pNext;
-                            }
-
-                            /* got a sigqueued node? */
-                            if (pSigQueued)
-                            {
-                                /* insert into the queue */
-                                if (pSigInfo)
-                                    pSigQueued->SigInfo = *pSigInfo;
-                                else
-                                    bzero(pSigQueued, sizeof(*pSigQueued));
-                                pSigQueued->SigInfo.si_signo = iSignalNo;
-                                pSigQueued->pNext = NULL;
-                                pSigQueued->pPrev = pThrdSig->SigQueue.pTail;
-                                if (pThrdSig->SigQueue.pTail)
-                                    pThrdSig->SigQueue.pTail = pThrdSig->SigQueue.pTail->pNext = pSigQueued;
-                                else
-                                    pThrdSig->SigQueue.pTail = pThrdSig->SigQueue.pHead = pSigQueued;
-                                LIBCLOG_MSG("enqueued signal %d.\n", iSignalNo);
-                            }
-                            else
-                            {   /* arg! out of nodes :/ */
-                                errno = EAGAIN;
-                                rc = __LIBC_BSRR_ERROR;
-                            }
-                        }
-
-                        /*
-                         * Set pending and poke the thread.
-                         */
-                        if (rc != __LIBC_BSRR_ERROR)
-                        {
-                            __SIGSET_SET(&pThrd->SigSetPending, iSignalNo);
-                            __libc_back_signalPokeThread(pThrdSig->tid);
-                            LIBCLOG_MSG("setting %d pending on thread %d's and poking it.\n", pThrdSig->tid, iSignalNo);
-                        }
-                    } /* if/else: sigwait / deliver other thread. */
-
-                    /*
-                     * Release the signal thread and leave the semaphore protection.
-                     */
-                    if (pThrdSig != pThrd)
-                        __libc_threadDereference(pThrdSig);
-                    __libc_back_signalSemRelease();
-                } /* if/else: curthread-deliver / sigwait-or-other-thread  */
-            } /* if/else: blocked-make-thread-pending / deliver */
-        } /* if/else: make pending / deliver */
-    } /* if/else: ignore / not ignored. */
+                        pSigQueued->pNext = NULL;
+                        pSigQueued->pPrev = pThrdSig->SigQueue.pTail;
+                        if (pThrdSig->SigQueue.pTail)
+                            pThrdSig->SigQueue.pTail = pThrdSig->SigQueue.pTail->pNext = pSigQueued;
+                        else
+                            pThrdSig->SigQueue.pTail = pThrdSig->SigQueue.pHead = pSigQueued;
+                    }
+                    LIBCLOG_MSG("enqueued signal %d.\n", iSignalNo);
+                }
+                else
+                {   /* arg! out of nodes :/ */
+                    LIBC_ASSERTM_FAILED("Out of queue nodes! iSignalNo=%d\n", iSignalNo);
+                    rc = -EAGAIN;
+                }
+            }
+
+            /*
+             * Set pending and poke the thread (if it's not ourself).
+             */
+            if (!rc)
+            {
+                __SIGSET_SET(&pThrd->SigSetPending, iSignalNo);
+                if (pThrdSig != pThrd)
+                    signalPokeThread(pThrdSig);
+                LIBCLOG_MSG("setting %d pending on thread %d's and poking it.\n", pThrdSig->tid, iSignalNo);
+            }
+        }
+    }
+    else
+    {
+        /*
+         * No thread ready for it, leave the signal on process level.
+         * Queue it if required and then mark it pending.
+         */
+        if (    (fFlags & __LIBC_BSRF_QUEUED)
+            ||  (gafSignalProperties[iSignalNo] & SPP_QUEUED))
+        {
+            /*
+             * Queue the signal.
+             */
+            if (!pSigQueued)
+            {   /* 'allocate' it. */
+                pSigQueued = gpSigQueuedFree;
+                if (pSigQueued)
+                    gpSigQueuedFree = pSigQueued->pNext;
+            }
+
+            /* got a sigqueued node? */
+            if (pSigQueued)
+            {
+                if (pSigInfo)
+                    pSigQueued->SigInfo = *pSigInfo;
+                else
+                    bzero(pSigQueued, sizeof(*pSigQueued));
+                pSigQueued->SigInfo.si_signo = iSignalNo;
+
+                /* insert into the queue */
+                pSigQueued->pNext = NULL;
+                pSigQueued->pPrev = gpSigQueueTail;
+                if (gpSigQueueTail)
+                    gpSigQueueTail = gpSigQueueTail->pNext = pSigQueued;
+                else
+                    gpSigQueueTail = gpSigQueueHead = pSigQueued;
+                LIBCLOG_MSG("enqueued signal %d.\n", iSignalNo);
+            }
+            else
+            {   /* arg! out of nodes :/ */
+                rc = -EAGAIN;
+                LIBC_ASSERTM_FAILED("Out of queue nodes! iSignalNo=%d\n", iSignalNo);
+            }
+        }
+
+        /*
+         * Add to the pending signals of this process.
+         */
+        if (rc >= 0)
+        {
+            __SIGSET_SET(&__libc_gSignalPending, iSignalNo);
+            LIBCLOG_MSG("adding %d to pending signals of the current process.\n", iSignalNo);
+        }
+    }
 
     return rc;
@@ -1017 +980 @@
 
 
-unsigned        signalDeliver(int iSignalNo, siginfo_t *pSigInfo, void *pvXcpt)
-{
-    /*
-     * Assert that we do own the semaphore upon entry.
-     * This may happen in a very special situation, but in general it shouldn't.
-     */
-    LIBC_ASSERTM(__libc_back_signalSemIsOwner(), "Thread does not own the signal semaphore!!!\n");
-
-
-    return -1;
+/**
+ * Checks if we can schedule any of the signals queued on the process in SPM.
+ *
+ * This means discarding (when ignored) or moving signals from pending at 1st
+ * level to 3rd level (thread). signalSchedule() is used to do the actual
+ * thead scheduling of the signals, which means that the caller must check
+ * the current thread for any deliverable signals upon return.
+ *
+ * @param   pThrd   Current thread.
+ */
+static void signalScheduleSPM(__LIBC_PTHREAD pThrd)
+{
+    LIBCLOG_ENTER("pThrd=%p\n", (void *)pThrd);
+    LIBC_ASSERTM(__libc_back_signalSemIsOwner(), "Thread doesn't own the signal semaphore!!! Bad boy!!\n");
+
+    /*
+     * Get the mask of pending signals.
+     */
+    sigset_t    SigSetPending;
+    int         cSignals = __libc_spmSigPending(&SigSetPending);
+
+    /*
+     * Iterate thru the pending signals and see if any of
+     * them can be delivered.
+     */
+    int         iSignalNo = 1;
+    while (cSignals > 0 && iSignalNo < __SIGSET_MAXSIGNALS)
+    {
+        if (__SIGSET_ISSET(&SigSetPending, iSignalNo))
+        {
+            /*
+             * Let's see if we can ignore it or successfully schedule it to a thread.
+             */
+            __LIBC_PTHREAD pThrdSig = NULL;
+            if (    gaSignalActions[iSignalNo].__sigaction_u.__sa_handler == SIG_IGN
+                ||  (   gaSignalActions[iSignalNo].__sigaction_u.__sa_handler == SIG_DFL
+                     && (gafSignalProperties[iSignalNo] & SPA_MASK) == SPA_IGNORE)
+                || (pThrdSig = signalScheduleThread(iSignalNo, pThrd)))
+            {
+                /*
+                 * Fetch signals of this type.
+                 */
+                siginfo_t SigInfo;
+                while (__libc_spmSigDequeue(iSignalNo, &SigInfo, 1, sizeof(SigInfo)) > 0)
+                {
+                    int rc = signalSchedule(pThrd, iSignalNo, &SigInfo,
+                                            __LIBC_BSRF_EXTERNAL | ((SigInfo.si_flags & __LIBC_SI_QUEUED) ? __LIBC_BSRF_QUEUED : 0),
+                                            NULL);
+                    if (rc >= 0)
+                        cSignals--;
+                    else
+                    {
+                        /* Shit! We failed to queue it on a thread. Try put it back in the 1st level queue. */
+                        LIBCLOG_MSG("failed to schedule signal %d for any thread!\n", iSignalNo);
+                        __libc_spmSigQueue(&SigInfo, _sys_pid, !!(SigInfo.si_flags & __LIBC_SI_QUEUED));
+                        break;
+                    }
+                }
+            }
+        }
+
+        /* next */
+        iSignalNo++;
+    }
+    LIBCLOG_RETURN_VOID();
+}
+
+
+/**
+ * Schedules all signals currently pending on the process (2nd level).
+ *
+ * @param   pThrd   Current Thread.
+ */
+static void signalScheduleProcess(__LIBC_PTHREAD pThrd)
+{
+    LIBCLOG_ENTER("pThrd=%p\n", (void *)pThrd);
+    LIBC_ASSERTM(__libc_back_signalSemIsOwner(), "Thread doesn't own the signal semaphore!!! Bad boy!!\n");
+
+    /*
+     * Process queued signals first (to get a more correct order).
+     */
+    sigset_t    SigDone;
+    __SIGSET_EMPTY(&SigDone);
+    PSIGQUEUED pSig = gpSigQueueHead;
+    while (pSig)
+    {
+        int iSignalNo = pSig->SigInfo.si_signo;
+        if (!__SIGSET_ISSET(&SigDone, iSignalNo))
+        {
+            __LIBC_PTHREAD pThrdSig = signalScheduleThread(iSignalNo, pThrd);
+            if (!pThrdSig)
+                __SIGSET_SET(&SigDone, iSignalNo);
+            else
+            {
+                /* unlink */
+                PSIGQUEUED pSigNext = pSig->pNext;
+                if (pSig->pPrev)
+                    pSig->pPrev->pNext = pSig->pNext;
+                else
+                    gpSigQueueHead     = pSig->pNext;
+                if (pSig->pNext)
+                    pSig->pNext->pPrev = pSig->pPrev;
+                else
+                    gpSigQueueTail     = pSig->pPrev;
+
+                /* schedule */
+                signalScheduleToThread(pThrd, pThrdSig, iSignalNo, pSig);
+                __SIGSET_CLEAR(&__libc_gSignalPending, iSignalNo);
+                __libc_threadDereference(pThrdSig);
+
+                /* next */
+                pSig = pSigNext;
+                continue;
+            }
+        }
+
+        /* next */
+        pSig = pSig->pNext;
+    }
+
+    /*
+     * Process pending signals (which was not queued).
+     */
+    int iSignalNo = 0;
+    while (iSignalNo++ < __SIGSET_MAXSIGNALS)
+    {
+        if (    !__SIGSET_ISSET(&SigDone, iSignalNo)
+            &&  __SIGSET_ISSET(&__libc_gSignalPending, iSignalNo))
+        {
+            __LIBC_PTHREAD pThrdSig = signalScheduleThread(iSignalNo, pThrd);
+            if (pThrdSig)
+            {
+                signalScheduleToThread(pThrd, pThrdSig, iSignalNo, NULL);
+                __SIGSET_CLEAR(&__libc_gSignalPending, iSignalNo);
+                __libc_threadDereference(pThrdSig);
+            }
+        }
+    }
+
+    /*
+     * Now kick all thread with pending signals which can be delivered.
+     */
+    signalScheduleKickThreads(pThrd);
+    LIBCLOG_RETURN_VOID();
+}
+
+
+/**
+ * Schedules a signal to a thread and notifies the thread.
+ *
+ * @param   pThrd       Current thread.
+ * @param   pThrdSig    Thread to schedule the signal to.
+ * @param   iSignalNo   Signal to schedule.
+ * @param   pSig        Signal queue node containing more info about the signal. (Optional)
+ */
+static void signalScheduleToThread(__LIBC_PTHREAD pThrd, __LIBC_PTHREAD pThrdSig, int iSignalNo, PSIGQUEUED pSig)
+{
+    LIBCLOG_ENTER("pThrd=%p pThrdSig=%p {.tid=%#x} iSignalNo=%d pSig=%p\n", (void *)pThrd, (void *)pThrdSig, pThrdSig->tid, iSignalNo, (void *)pSig);
+    /*
+     * If we've got a queue node, queue it.
+     */
+    if (pSig)
+    {
+        pSig->pNext = NULL;
+        pSig->pPrev = pThrdSig->SigQueue.pTail;
+        if (pThrdSig->SigQueue.pTail)
+            pThrdSig->SigQueue.pTail->pNext = pSig;
+        else
+            pThrdSig->SigQueue.pTail = pThrdSig->SigQueue.pHead = pSig;
+    }
+
+    /*
+     * In any case, we set the signal pending and poke the thread.
+     */
+    __SIGSET_SET(&pThrd->SigSetPending, iSignalNo);
+    if (pThrdSig != pThrd)
+        signalPokeThread(pThrdSig);
+    LIBCLOG_MSG("setting %d pending on thread %d's and poking it.\n", pThrdSig->tid, iSignalNo);
+    LIBCLOG_RETURN_VOID();
 }
 
@@ -1032 +1164 @@
 /**
  * Schedules the signal on a suitable thread.
+ *
  * @returns Pointer to a thread structure (referenced).
  * @returns NULL if no thread can handle the signal.
@@ -1037 +1170 @@
  * @param   pThrdCur    Pointer to the current thread.
  */
-__LIBC_PTHREAD  signalSchedule(int iSignalNo, __LIBC_PTHREAD pThrdCur)
-{
+__LIBC_PTHREAD  signalScheduleThread(int iSignalNo, __LIBC_PTHREAD pThrdCur)
+{
+    LIBC_ASSERTM(__libc_back_signalSemIsOwner(), "Thread does not own the signal semaphore!!!\n");
+
+    /*
+     * Enumerate all thread in the process and figure out which on
+     * is the best suited to receive the signal.
+     */
     SIGSCHEDENUMPARAM   EnumParam;
-    __LIBC_PTHREAD      pThrdSig;
-
-    /*
-     * Assert that we do own the semaphore upon entry.
-     * This may happen is very special situation, but in general it shouldn't.
-     */
-    LIBC_ASSERTM(__libc_back_signalSemIsOwner(), "Thread does not own the signal semaphore!!!\n");
-
-    /*
-     * Enumerate all thread in the process and figure out which is the best suited.
-     */
     EnumParam.iSignalNo = iSignalNo;
     EnumParam.pThrd     = pThrdCur;
-    pThrdSig = __libc_threadLookup2(signalScheduleWorker, &EnumParam);
-
-    return NULL;
+    return __libc_threadLookup2(signalScheduleThreadWorker, &EnumParam);
 }
 
@@ -1070 +1196 @@
  * @param   pvParam     User parameters (PSIGSCHEDENUMPARAM in our case).
  */
-int signalScheduleWorker(__LIBC_PTHREAD pCur, __LIBC_PTHREAD pBest, void *pvParam)
+static int signalScheduleThreadWorker(__LIBC_PTHREAD pCur, __LIBC_PTHREAD pBest, void *pvParam)
 {
     PSIGSCHEDENUMPARAM pParam = (PSIGSCHEDENUMPARAM)pvParam;
@@ -1108 +1234 @@
     /* ok, it's not blocking it so it's ok to use it. */
     return 1;
+}
+
+
+/**
+ * Enumerates all the threads in the process and poke the ones
+ * which have signals that can be process.
+ *
+ * @param   pThrd   Current thread.
+ */
+static void signalScheduleKickThreads(__LIBC_PTHREAD pThrd)
+{
+    __libc_threadEnum(signalScheduleKickThreadsWorker, (void *)pThrd);
+}
+
+
+/**
+ * Thread enumeration worker for signalScheduleKickThreads.
+ *
+ * It poke threads which have signals that can be delivered.
+ *
+ * @returns 0.
+ * @param   pCur        The current thread in the enumration.
+ * @param   pvParam     This thread.
+ */
+static int signalScheduleKickThreadsWorker(__LIBC_PTHREAD pCur, void *pvParam)
+{
+    /*
+     * Skip internal threads.
+     */
+    if (pCur->fInternalThread)
+        return 0;
+
+    /*
+     * Walk the queued signals and make sure they're pending.
+     * (Self check.)
+     */
+    PSIGQUEUED pSig = pCur->SigQueue.pHead;
+    while (pSig)
+    {
+        if (!__SIGSET_ISSET(&pCur->SigSetPending, pSig->SigInfo.si_signo))
+        {
+            LIBC_ASSERTM_FAILED("Signal %d is queued but not marked pending on thread %#x!\n", pSig->SigInfo.si_signo, pCur->tid);
+            __SIGSET_SET(&pCur->SigSetPending, pSig->SigInfo.si_signo);
+        }
+
+        /* next */
+        pSig = pSig->pNext;
+    }
+
+    /*
+     * Skip further processing of threads which have been poked
+     * or if if it's the current thread
+     */
+    if (    pCur->fSigBeingPoked
+        ||  pCur != (__LIBC_PTHREAD)pvParam)
+        return 0;
+
+    /*
+     * See if there are pending signals that can be delivered.
+     */
+    sigset_t    SigSet = pCur->SigSetPending;
+    __SIGSET_AND(&SigSet, &SigSet, &pCur->SigSetBlocked);
+    if (!__SIGSET_EMPTY(&SigSet))
+        __libc_back_signalPokeThread(pCur->tid);
+
+    return 0;
+}
+
+
+/**
+ * Deliver signals pending on the current thread.
+ *
+ * Caller must own the semaphore before calling, this function
+ * will release the semaphore no matter what happens!
+ *
+ * @returns On success a flag mask out of the __LIBC_BSRR_* #defines is returned.
+ * @returns On failure a negative error code (errno.h) is returned.
+ * @param   pThrd               Current thread.
+ * @param   iSignalNo           Deliver the first signal of this type no matter if it's
+ *                              blocked or not. This is for use with hardware signals only!
+ * @param   pvXcptParams        sPointer to exception parameter list is any.
+ */
+static int signalDeliver(__LIBC_PTHREAD pThrd, int iSignalNo, void *pvXcptParams)
+{
+    LIBCLOG_ENTER("pThrd=%p pvXcptParams=%p\n", (void *)pThrd, pvXcptParams);
+    int rcRet = __LIBC_BSRR_CONTINUE | __LIBC_BSRR_INTERRUPT;
+
+    /*
+     * Assert that we do own the semaphore upon entry.
+     */
+    LIBC_ASSERTM(__libc_back_signalSemIsOwner(), "Thread does not own the signal semaphore!!!\n");
+
+    for (;;)
+    {
+        /*
+         * Anything pending?
+         */
+        __sigset_t  SigDeliver = pThrd->SigSetPending;
+        __SIGSET_AND(&SigDeliver, &SigDeliver, &pThrd->SigSetBlocked);
+        if (__SIGSET_ISEMPTY(&SigDeliver))
+            break;
+
+        /*
+         * Deliver signals /execute signal default actions in this order:
+         *   0. Passed in signal (ignores blocking).
+         *   1. SIGKILL
+         *   2. Realtime signals. (queued)
+         *   3. SIGCHLD
+         *   4. SIGCONT
+         *   5. Ascending from pending mask.
+         *
+         * Note that 0 and 1 may be violating the POSIX specs.
+         */
+        if (!iSignalNo || !__SIGSET_ISSET(&pThrd->SigSetPending, iSignalNo))
+        {
+            iSignalNo = SIGKILL;
+            if (!__SIGSET_ISSET(&SigDeliver, SIGKILL))
+            {
+                iSignalNo = SIGRTMIN;
+                while (iSignalNo <= SIGRTMAX && !__SIGSET_ISSET(&SigDeliver, iSignalNo))
+                    iSignalNo++;
+                if (iSignalNo > SIGRTMAX)
+                {
+                    iSignalNo = SIGCHLD;
+                    if (!__SIGSET_ISSET(&SigDeliver, SIGCHLD))
+                    {
+                        iSignalNo = SIGCONT;
+                        if (!__SIGSET_ISSET(&SigDeliver, SIGCONT))
+                        {
+                            iSignalNo = 1;
+                            while (iSignalNo < SIGRTMIN && !__SIGSET_ISSET(&SigDeliver, iSignalNo))
+                                iSignalNo++;
+                            if (iSignalNo >= SIGRTMIN)
+                            {
+                                LIBC_ASSERTM_FAILED("Internal error!!!\n");
+                                LIBCLOG_RETURN_INT(__LIBC_BSRR_CONTINUE);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        /*
+         * Check if there is a queue element for the signal.
+         */
+        siginfo_t   SigInfo = {0};
+        PSIGQUEUED pSig = pThrd->SigQueue.pHead;
+        while (pSig)
+        {
+            if (pSig->SigInfo.si_signo == iSignalNo)
+            {
+                /* unlink */
+                if (pSig->pPrev)
+                    pSig->pPrev->pNext    = pSig->pNext;
+                else
+                    pThrd->SigQueue.pHead = pSig->pNext;
+                if (pSig->pNext)
+                    pSig->pNext->pPrev    = pSig->pPrev;
+                else
+                    pThrd->SigQueue.pTail = pSig->pPrev;
+
+                /*
+                 * Check if more signals of this type so we can update the
+                 * pending mask correctly.
+                 */
+                PSIGQUEUED pSigMore = pSig->pNext;
+                while (pSigMore && pSigMore->SigInfo.si_signo != iSignalNo)
+                    pSigMore = pSigMore->pNext;
+                if (!pSigMore)
+                    __SIGSET_CLEAR(&pThrd->SigSetPending, iSignalNo);
+
+                /*
+                 * Copy the signal to the SigInfo structure on the stack
+                 * and then release the signal queue structure.
+                 */
+                SigInfo = pSig->SigInfo;
+                break;
+            }
+        }
+
+        /*
+         * If no queued signal data, then we can simply clear it in the pending mask.
+         */
+        if (!pSig)
+        {
+            SigInfo.si_signo = iSignalNo;
+            __SIGSET_CLEAR(&pThrd->SigSetPending, iSignalNo);
+        }
+
+
+        /*
+         * What to do for this signal?
+         */
+        struct sigaction SigAction = gaSignalActions[iSignalNo];
+        if (    SigAction.__sigaction_u.__sa_handler == SIG_IGN
+            ||  (   SigAction.__sigaction_u.__sa_handler == SIG_DFL
+                 && (gafSignalProperties[iSignalNo] & SPA_MASK) == SPA_IGNORE)
+            )
+        {
+            /* Ignore the signal. */
+            iSignalNo = 0;
+            continue;
+        }
+
+        if (SigAction.__sigaction_u.__sa_handler == SIG_DFL)
+        {
+            /*
+             * Perform default action.
+             */
+            switch (gafSignalProperties[iSignalNo] & SPA_MASK)
+            {
+                /*
+                 * Ignore the signal in one of another way.
+                 */
+                case SPA_NEXT:
+                case SPA_IGNORE:
+                    break;
+
+                /*
+                 * Kill process / dump core (no cores for LIBC!).
+                 */
+                case SPA_NEXT_KILL:
+                case SPA_NEXT_CORE:
+                case SPA_KILL:
+                case SPA_CORE:
+                    signalTerminate(iSignalNo);
+                    break;
+
+                /*
+                 * Stop the current process.
+                 */
+                case SPA_STOP:
+                case SPA_STOPTTY:
+                    signalJobStop(iSignalNo);
+                    break;
+
+                /*
+                 * Resume the current process.
+                 */
+                case SPA_RESUME:
+                    signalJobResume();
+                    break;
+
+                default:
+                    LIBC_ASSERTM_FAILED("Invalid signal action property! iSignalNo=%d\n", iSignalNo);
+                    break;
+            }
+        }
+        else
+        {
+            /*
+             * Prepare call.
+             */
+            /* reset action in SysV fashion? */
+            if (    (SigAction.sa_flags & SA_RESETHAND)
+                && !(gafSignalProperties[iSignalNo] & SPP_NORESET))
+            {
+                gaSignalActions[iSignalNo].__sigaction_u.__sa_handler = SIG_DFL;
+                gaSignalActions[iSignalNo].sa_flags &= ~SA_SIGINFO;
+                SigAction.sa_flags |= SA_NODEFER;
+            }
+
+            /* adjust and apply the signal mask. */
+            if ((SigAction.sa_flags & (SA_ACK | SA_NODEFER)) != SA_NODEFER)
+                __SIGSET_SET(&SigAction.sa_mask, iSignalNo);
+            if (gafSignalProperties[iSignalNo] & SPP_NOBLOCK)
+                __SIGSET_CLEAR(&SigAction.sa_mask, iSignalNo);
+            sigset_t SigSetOld = pThrd->SigSetBlocked;
+            __SIGSET_OR(&pThrd->SigSetBlocked, &pThrd->SigSetBlocked, &SigAction.sa_mask);
+
+            void *pvCtx = NULL;
+            if (SigAction.sa_flags & SA_SIGINFO)
+            {
+                /** @todo Implement x86 signal context. */
+            }
+
+            /*
+             * Call the signal handler.
+             */
+            if (    !(SigAction.sa_flags & SA_ONSTACK)
+                ||  pThrd->fSigStackActive
+                ||  !pThrd->pvSigStack
+                ||  !pThrd->cbSigStack)
+            {
+                __libc_back_signalSemRelease();
+                SigAction.__sigaction_u.__sa_sigaction(iSignalNo, &SigInfo, pvCtx);
+            }
+            else
+            {
+                /*
+                 * Deliver on an alternative stack.
+                 */
+
+                /* get and save the tib stack pointer entries. */
+                PTIB pTib;
+                PPIB pPib;
+                FS_VAR();
+                FS_SAVE_LOAD();
+                DosGetInfoBlocks(&pTib, &pPib);
+                FS_RESTORE();
+                PVOID pvOldStack      = pTib->tib_pstack;
+                PVOID pvOldStackLimit = pTib->tib_pstacklimit;
+
+                /* Mark active before we touch the stack so we don't make the same mistake twice... */
+                pThrd->fSigStackActive = 1;
+                /* Setup stack frame for the call. */
+                uintptr_t *pStack = (uintptr_t *)((char *)pThrd->pvSigStack + pThrd->cbSigStack - sizeof(uintptr_t));
+                *pStack-- = 0; /* where we save esp */
+                *pStack-- = (uintptr_t)pvCtx;
+                *pStack-- = (uintptr_t)&SigInfo;
+                *pStack-- = iSignalNo;
+                pTib->tib_pstack      = pThrd->pvSigStack;
+                pTib->tib_pstacklimit = (char *)pThrd->pvSigStack + pThrd->cbSigStack;
+
+                /* release, switch and call. */
+                __libc_back_signalSemRelease();
+                __asm__ __volatile__ (
+                    "movl %%esp, %0\n\t"
+                    "movl %1, %%esp\n\t"
+                    "call *%2\n\t"
+                    "movl 12(%%esp), %%esp\n\t"
+                    : "=m" (*(uintptr_t *)((char *)pThrd->pvSigStack + pThrd->cbSigStack - sizeof(uintptr_t)))
+                    : "a" (pStack),
+                      "d" (SigAction.__sigaction_u.__sa_sigaction)
+                    : "ecx" );
+
+                /* Restore tib and release the stack. */
+                pTib->tib_pstack      = pvOldStack;
+                pTib->tib_pstacklimit = pvOldStackLimit;
+                pThrd->fSigStackActive = 0;
+            }
+
+            /*
+             * Handler returned, what to do now?
+             */
+            switch (gafSignalProperties[iSignalNo] & SPR_MASK)
+            {
+                /*
+                 * Kill the process.
+                 */
+                case SPR_KILL:
+                    signalTerminate(iSignalNo);
+                    break;
+
+                /*
+                 * Execution should continue on return, which is our default return.
+                 */
+                case SPR_CONTINUE:
+                    break;
+
+                default:
+                    LIBC_ASSERTM_FAILED("Invalid signal return action property! iSignalNo=%d\n", iSignalNo);
+                    break;
+            }
+
+            /*
+             * Re-take the signal semaphore and restore the signal mask.
+             */
+            if (__libc_back_signalSemRequest())
+                break;
+            pThrd->SigSetBlocked = SigSetOld;
+        }
+
+        iSignalNo = 0;
+    } /* forever */
+
+    LIBCLOG_RETURN_INT(rcRet);
+}
+
+
+/**
+ * Cause immediate process termination because of the given signal.
+ *
+ * @param   iSignalNo   Signal causing the termination.
+ */
+static void signalTerminate(int iSignalNo)
+{
+    /** @todo implement process termination by signal properly! */
+    /*
+     * Before we go crazy here, let's release the semaphore.
+     *
+     * If possible we'll stay in the must complete section to
+     * be sure we get to the exit. If not we'll have to mess with
+     * exception handlers and such now.
+     */
+    //if (__libc_back_signalSemIsOwner())
+    //    DosReleaseMutexSem(ghmtxSignals);
+
+    for (;;)
+        DosExit(EXIT_THREAD, 127);
+}
+
+/**
+ * Stop the process (job control emulation).
+ *
+ * @param   iSignalNo   Signal causing the stop.
+ */
+static int signalJobStop(int iSignalNo)
+{
+    /** @todo Job control: tell parent and ensure that thread 1 is frozen and unfrozen. */
+    DosWaitEventSem(ghevWait, SEM_INDEFINITE_WAIT);
+    return 0;
+}
+
+/**
+ * Resume the process (job control emulation).
+ *
+ * @param   iSignalNo   Signal causing the termination.
+ */
+static int signalJobResume(void)
+{
+    /** @todo Job control: tell parent and ensure that thread 1 is unfrozen. */
+    return 0;
 }
 
@@ -1189 +1729 @@
         SigInfo.si_tid  = pThrd->tid;
     SigInfo.si_timestamp= signalTimestamp();
-
-    rc = __libc_spmSigQueue(&SigInfo, pid, !!(gafSignalProperties[iSignalNo] & SPP_QUEUED));
+    if (gafSignalProperties[iSignalNo] & SPP_QUEUED)
+        SigInfo.si_flags |= __LIBC_SI_QUEUED;
+
+    rc = __libc_spmSigQueue(&SigInfo, pid, SigInfo.si_flags & __LIBC_SI_QUEUED);
     if (!rc)
     {
@@ -1268 +1810 @@
  * This is called by the 16-bit thunker.
  *
- * @param   uSignal     Signal number - SIG_PFLG_A.
+ * @param   uOS2Signal  Signal number - SIG_PFLG_A.
  * @param   uArg        LIBC sets this to 0 when the target is a LIBC process.
  *                      If the target is a non-LIBC process it's an EMX signal
  *                      number.
  */
-void __libc_back_signalOS2V1Handler32bit(unsigned uSignal, unsigned uArg)
-{
-    /*
-     * Check the process for pending signals.
-     */
-//@todo    __libc_back_signalPending();
+void __libc_back_signalOS2V1Handler32bit(unsigned uOS2Signal, unsigned uArg)
+{
+    LIBCLOG_ENTER("uOS2Signal=%u uArg=%u\n", uOS2Signal, uArg);
+
+    /*
+     * Can't be to careful!
+     */
+    LIBC_ASSERTM(!__libc_back_signalSemIsOwner(), "Thread owns the signal semaphore!!! That should be impossible...\n");
+
+    /*
+     * Get the current thread (1st thread, so that should be safe).
+     */
+    __LIBC_PTHREAD  pThrd = __libc_threadCurrentNoAuto();
+    if (!pThrd)
+    {
+        LIBC_ASSERTM_FAILED("Failed to get thread structure!\n");
+        LIBCLOG_RETURN_VOID();
+    }
+
+    /*
+     * Try schedule signals pending on 1st (SPM) and 2nd level (private).
+     */
+    signalScheduleSPM(pThrd);
+    signalScheduleProcess(pThrd);
 
     /*
@@ -1285 +1845 @@
     if (uArg)
     {
-        unsigned uSignalLIBC = 0;
+        unsigned iSignalNo = 0;
         switch (uArg)
         {
-            case EMX_SIGHUP  :  uSignalLIBC = SIGHUP;   break;
-            case EMX_SIGINT  :  uSignalLIBC = SIGINT;   break;
-            case EMX_SIGQUIT :  uSignalLIBC = SIGQUIT;  break;
-            case EMX_SIGILL  :  uSignalLIBC = SIGILL;   break;
-            case EMX_SIGTRAP :  uSignalLIBC = SIGTRAP;  break;
-            case EMX_SIGABRT :  uSignalLIBC = SIGABRT;  break;
-            case EMX_SIGEMT  :  uSignalLIBC = SIGEMT;   break;
-            case EMX_SIGFPE  :  uSignalLIBC = SIGFPE;   break;
-            case EMX_SIGKILL :  uSignalLIBC = SIGKILL;  break;
-            case EMX_SIGBUS  :  uSignalLIBC = SIGBUS;   break;
-            case EMX_SIGSEGV :  uSignalLIBC = SIGSEGV;  break;
-            case EMX_SIGSYS  :  uSignalLIBC = SIGSYS;   break;
-            case EMX_SIGPIPE :  uSignalLIBC = SIGPIPE;  break;
-            case EMX_SIGALRM :  uSignalLIBC = SIGALRM;  break;
-            case EMX_SIGTERM :  uSignalLIBC = SIGTERM;  break;
-            case EMX_SIGUSR1 :  uSignalLIBC = SIGUSR1;  break;
-            case EMX_SIGUSR2 :  uSignalLIBC = SIGUSR2;  break;
-            case EMX_SIGCHLD :  uSignalLIBC = SIGCHLD;  break;
-            case EMX_SIGBREAK:  uSignalLIBC = SIGBREAK; break;
-            case EMX_SIGWINCH:  uSignalLIBC = SIGWINCH; break;
-        }
-        if (uSignalLIBC)
+            case EMX_SIGHUP  :  iSignalNo = SIGHUP;   break;
+            case EMX_SIGINT  :  iSignalNo = SIGINT;   break;
+            case EMX_SIGQUIT :  iSignalNo = SIGQUIT;  break;
+            case EMX_SIGILL  :  iSignalNo = SIGILL;   break;
+            case EMX_SIGTRAP :  iSignalNo = SIGTRAP;  break;
+            case EMX_SIGABRT :  iSignalNo = SIGABRT;  break;
+            case EMX_SIGEMT  :  iSignalNo = SIGEMT;   break;
+            case EMX_SIGFPE  :  iSignalNo = SIGFPE;   break;
+            case EMX_SIGKILL :  iSignalNo = SIGKILL;  break;
+            case EMX_SIGBUS  :  iSignalNo = SIGBUS;   break;
+            case EMX_SIGSEGV :  iSignalNo = SIGSEGV;  break;
+            case EMX_SIGSYS  :  iSignalNo = SIGSYS;   break;
+            case EMX_SIGPIPE :  iSignalNo = SIGPIPE;  break;
+            case EMX_SIGALRM :  iSignalNo = SIGALRM;  break;
+            case EMX_SIGTERM :  iSignalNo = SIGTERM;  break;
+            case EMX_SIGUSR1 :  iSignalNo = SIGUSR1;  break;
+            case EMX_SIGUSR2 :  iSignalNo = SIGUSR2;  break;
+            case EMX_SIGCHLD :  iSignalNo = SIGCHLD;  break;
+            case EMX_SIGBREAK:  iSignalNo = SIGBREAK; break;
+            case EMX_SIGWINCH:  iSignalNo = SIGWINCH; break;
+        }
+        if (iSignalNo)
         {
             /*
-             * Ok, raise it.
-             * Don't know how we should handle the exit code here, so we'll
-             * ignore it for now.
+             * Shcedule the signal, ignore return code.
              */
-            __libc_back_signalRaise(uSignalLIBC, NULL, NULL, __LIBC_BSRF_EXTERNAL);
+            signalSchedule(pThrd, iSignalNo, NULL, __LIBC_BSRF_EXTERNAL, NULL);
         }
     }
@@ -1323 +1881 @@
      * Acknowledge the signal.
      */
-    DosSetSigHandler(NULL, NULL, NULL, SIGA_ACKNOWLEDGE, uSignal);
+    DosSetSigHandler(NULL, NULL, NULL, SIGA_ACKNOWLEDGE, uOS2Signal);
+
+    /*
+     * Deliver signals.
+     */
+    signalDeliver(pThrd, 0, NULL);
+    LIBCLOG_RETURN_VOID();
 }
 
@@ -1335 +1899 @@
 void        __libc_back_signalPokeThread(int tid)
 {
-    /*
-     * Assert that we do not own the semaphore upon entry.
-     * This may happen is very special situation, but in general it shouldn't.
-     */
     LIBC_ASSERTM(__libc_back_signalSemIsOwner(), "Thread must own signal sem!\n");
 
@@ -1345 +1905 @@
      */
     __LIBC_PTHREAD pThrdPoke = __libc_threadLookup(tid);
-    if (!pThrdPoke)
-        return;
+    if (pThrdPoke)
+    {
+        signalPokeThread(pThrdPoke);
+        __libc_threadDereference(pThrdPoke);
+    }
+}
+
+
+/**
+ * Pokes a thread in the current process, forcing it to
+ * evaluate pending signals.
+ *
+ * @param   pThrdPoke       Thread to poke.
+ */
+static void     signalPokeThread(__LIBC_PTHREAD pThrdPoke)
+{
+    LIBC_ASSERTM(__libc_back_signalSemIsOwner(), "Thread must own signal sem!\n");
 
     /*
@@ -1354 +1929 @@
     {
         __atomic_xchg(&pThrdPoke->fSigBeingPoked, 1);
-        int rc = DosKillThread(tid);
+        int rc = DosKillThread(pThrdPoke->tid);
         if (rc)
-            LIBC_ASSERTM_FAILED("DosKillThread(%d) -> rc=%d\n", tid, rc);
-    }
-
-    /*
-     * Release the thread.
-     */
-    __libc_threadDereference(pThrdPoke);
-}
-
-
-/** @todo implement this. */
+            LIBC_ASSERTM_FAILED("DosKillThread(%d) -> rc=%d\n", pThrdPoke->tid, rc);
+    }
+}
+
+
+
+/**
+ * Thread was poked, deliver signals for this thread.
+ */
 int         __libc_back_signalRaisePoked(void *pvXcptParams, int tidPoker)
 {
-    /*
-     * Assert that we do not own the semaphore upon entry.
-     */
     LIBC_ASSERTM(!__libc_back_signalSemIsOwner(), "Thread owns the signal semaphore!!! Bad boy!!\n");
 
@@ -1383 +1953 @@
          * Take signal semaphore.
          */
-        int SavedErrno = errno;
         int rc = __libc_back_signalSemRequest();
         if (!rc)
@@ -1390 +1959 @@
             {
                 /*
-                 * Clear the indicator.
+                 * Clear the indicator and deliver signals.
                  */
                 __atomic_xchg(&pThrd->fSigBeingPoked, 0);
-
-                /*
-                 * Check for pending signals.
-                 */
-
-                __libc_back_signalSemRelease();
-            }
-            else
-                __libc_back_signalSemRelease();
-        }
-        errno = SavedErrno;
+                rc = signalDeliver(pThrd, 0, pvXcptParams);
+                if (rc < 0)
+                    rc = __LIBC_BSRR_CONTINUE | __LIBC_BSRR_INTERRUPT;
+                return rc;
+            }
+
+            /*
+             * We weren't being poked.
+             */
+            __libc_back_signalSemRelease();
+        }
     }
     else
         LIBC_ASSERTM_FAILED("No thread structure! This is really impossible!\n");
 
-    return __LIBC_BSRR_ERROR;
+    return -EINVAL;
 }