Changeset 1618

Timestamp:

Nov 7, 2004, 3:19:42 PM (21 years ago)

Author:

bird

Message:

More signal debugging and cleanup.

Location:

trunk/src/emx

Files:

• include/InnoTekLIBC/backend.h (modified) (4 diffs, 1 prop)
• include/InnoTekLIBC/libc.h (modified) (2 diffs, 1 prop)
• include/InnoTekLIBC/thread.h (modified) (6 diffs, 1 prop)
• src/lib/libc.def (modified) (1 diff, 1 prop)
• src/lib/process/_signal_os2.c (modified) (4 diffs, 1 prop)
• src/lib/process/_signal_sysv.c (modified) (3 diffs, 1 prop)
• src/lib/process/bsd_signal.c (modified) (3 diffs, 1 prop)
• src/lib/process/killpg.c (modified) (1 diff, 1 prop)
• src/lib/process/pause.c (modified) (1 diff, 1 prop)
• src/lib/process/raise.c (modified) (1 diff, 1 prop)
• src/lib/process/sigblock.c (modified) (1 diff, 1 prop)
• src/lib/process/sighold.c (modified) (1 diff, 1 prop)
• src/lib/process/sigignore.c (modified) (1 diff, 1 prop)
• src/lib/process/siginterrupt.c (modified) (2 diffs, 1 prop)
• src/lib/process/siginterrupt_data.c (modified) (1 diff, 1 prop)
• src/lib/process/signal.c (modified) (1 diff, 1 prop)
• src/lib/process/sigpause.c (modified) (1 diff, 1 prop)
• src/lib/process/sigpause_bsd.c (modified) (1 diff, 1 prop)
• src/lib/process/sigpending.c (modified) (2 diffs, 1 prop)
• src/lib/process/sigprocmask.c (modified) (1 diff, 1 prop)
• src/lib/process/sigrelse.c (modified) (1 diff, 1 prop)
• src/lib/process/sigsetmask.c (modified) (1 diff, 1 prop)
• src/lib/process/sigsuspend.c (modified) (2 diffs, 1 prop)
• src/lib/process/sigtimedwait.c (modified) (3 diffs, 1 prop)
• src/lib/process/sigvec.c (modified) (1 diff, 1 prop)
• src/lib/process/sigwait.c (modified) (1 diff, 1 prop)
• src/lib/process/sigwaitinfo.c (modified) (1 diff, 1 prop)
• src/lib/process/thread_internals.c (modified) (2 diffs, 1 prop)
• src/lib/sys/__init.c (modified) (1 diff, 1 prop)
• src/lib/sys/__initdll.c (modified) (1 diff, 1 prop)
• src/lib/sys/b_signalInterrupt.c (added)
• src/lib/sys/b_signalMask.c (modified) (1 diff, 1 prop)
• src/lib/sys/b_signalPending.c (added)
• src/lib/sys/b_signalStack.c (modified) (2 diffs, 1 prop)
• src/lib/sys/b_signalSuspend.c (modified) (2 diffs, 1 prop)
• src/lib/sys/b_signalWait.c (modified) (1 diff, 1 prop)
• src/lib/sys/b_threadInit.c (modified) (2 diffs, 1 prop)
• src/lib/sys/exceptions.c (modified) (1 diff, 1 prop)
• src/lib/sys/sharedpm.c (modified) (1 diff, 1 prop)
• src/lib/sys/signals.c (modified) (13 diffs, 1 prop)
• src/lib/sys/signals.h (modified) (2 diffs, 1 prop)

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

@@ -560 +560 @@
  *
  * @returns 0 on success.
- * @returns -Negative errno on failure.
+ * @returns  on failure.
  * @param   iSignalNo   Signal number.
  * @param   pSigAct     Pointer to new signal action.
@@ -570 +570 @@
 
 /**
+
+
+
+
+
+
+
+
+
+
+
+
+
  * Changes and/or queries the alternative signal stack settings of a thread.
  *
@@ -584 +597 @@
  *
  * @returns 0 on success.
- * @returns -1 and errno set to EINVAL on failure.
+ * @returns  on failure.
  * @param   pThrd       Thread to apply this to.
  * @param   iHow        Describes the action taken if pSigSetNew not NULL. Recognized
@@ -604 +617 @@
 int __libc_Back_signalMask(__LIBC_PTHREAD pThrd, int iHow, const sigset_t * __restrict pSigSetNew, sigset_t * __restrict pSigSetOld);
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 /** @} */
 

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

@@ -29 +29 @@
 
 #include <sys/cdefs.h>
+
 
 __BEGIN_DECLS
@@ -41 +42 @@
 extern int __libc_gfNoUnix;
 
+
+
+
+
+
+
+
 __END_DECLS
 

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

@@ -50 +50 @@
 *******************************************************************************/
 struct _uheap;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 /**
@@ -150 +174 @@
 
     /** Thread status, chiefly used for the u member of the thread structure. */
-    enum enmLIBCThreadStatus
+    enum enmLIBCThreadStatus
     {
         /** The thread status must be queried from the OS. */
@@ -158 +182 @@
         /** The thread is in a sigwait(), sigwaitinfo(), or sigtimedwait() call. */
         enmLIBCThreadStatus_sigwait,
+
+
     }               enmStatus;
 
@@ -166 +192 @@
     {
         /** enmLIBCThreadStatus_startup:    Begin Thread Arguments. */
-        struct __libc_thread_startup
+        struct __libc_thread_startup
         {
             /** Thread argument. */
@@ -175 +201 @@
 
         /** enmLIBCThreadStatus_sigwait:    Thread blocked in sigwait(), sigwaitinfo() or sigtimedwait(). */
-        struct __libc_thread_sigwait
-        {
-            /** The signals we're waiting for. */
-            sigset_t    SigSetWait;
-            /** The where to return signal info. */
-            siginfo_t  *pSigInfo;
-        } SigWait;
+        __LIBC_PTHREAD_SIGWAIT      pSigWait;
+        /** enmLIBCThreadStatus_sigsuspend: Thread blocked in sigsuspend(). */
+        __LIBC_PTHREAD_SIGSUSPEND   pSigSuspend;
     } u;
 
@@ -211 +233 @@
 } __LIBC_THREAD;
 
+
 #ifndef __LIBC_THREAD_DECLARED
 #define __LIBC_THREAD_DECLARED

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

@@ -1239 +1239 @@
     "___libc_Back_signalStack" @1261
     "___libc_Back_signalMask" @1262
+
+
+
+

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

@@ -31 +31 @@
 #include <signal.h>
 #include <errno.h>
-#include <InnoTekLIBC/signals.h>
+#include <InnoTekLIBC/libc.h>
+#include <InnoTekLIBC/backend.h>
 #define __LIBC_LOG_GROUP __LIBC_LOG_GRP_SIGNAL
 #include <InnoTekLIBC/logstrict.h>
@@ -54 +55 @@
     {
         LIBC_ASSERTM_FAILED("invalid signal number for SIG_ACK %d\n", iSignalNo);
+
+
+
+
+
+
         LIBCLOG_RETURN_P(SIG_ERR);
     }
@@ -96 +103 @@
 
         /*
-         * Gain exclusive access to the signal stuff.
-         */
-        if (__libc_back_signalSemRequest())
-            LIBCLOG_RETURN_P(SIG_ERR);
-
-        /*
          * Do work.
          */
         if (__SIGSET_ISSET(&__libc_gSignalRestartMask, iSignalNo))
             SigAct.sa_flags |= SA_RESTART;
-        rc = __libc_back_signalAction(iSignalNo, &SigAct, &SigActOld);
-
-        /*
-         * Release semaphore.
-         */
-        __libc_back_signalSemRelease();
+        rc = __libc_Back_signalAction(iSignalNo, &SigAct, &SigActOld);
 
         /*
@@ -118 +114 @@
         if (!rc)
             LIBCLOG_RETURN_P(SigActOld.__sigaction_u.__sa_handler);
+
     }
     LIBCLOG_RETURN_P(SIG_ERR);

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

@@ -31 +31 @@
 #include <signal.h>
 #include <errno.h>
-#include <InnoTekLIBC/signals.h>
+#include <InnoTekLIBC/libc.h>
+#include <InnoTekLIBC/backend.h>
 #define __LIBC_LOG_GROUP __LIBC_LOG_GRP_SIGNAL
 #include <InnoTekLIBC/logstrict.h>
@@ -59 +60 @@
         LIBCLOG_RETURN_P(SIG_ERR);
     }
+
+
+
+
+
+
     if (!__SIGSET_SIG_VALID(iSignalNo))
     {
@@ -74 +81 @@
 
     /*
-     * Gain exclusive access to the signal stuff.
-     */
-    if (__libc_back_signalSemRequest())
-        LIBCLOG_RETURN_P(SIG_ERR);
-
-    /*
      * Change signal action.
      */
     if (__SIGSET_ISSET(&__libc_gSignalRestartMask, iSignalNo))
         SigAct.sa_flags |= SA_RESTART;
-    rc = __libc_back_signalAction(iSignalNo, &SigAct, &SigActOld);
-
-    /*
-     * Release semaphore.
-     */
-    __libc_back_signalSemRelease();
-
-    /*
-     * Check for errors and return.
-     */
-    if (rc)
-        LIBCLOG_RETURN_P(SIG_ERR);
-    LIBCLOG_RETURN_P(SigActOld.__sigaction_u.__sa_handler);
+    rc = __libc_Back_signalAction(iSignalNo, &SigAct, &SigActOld);
+    if (!rc)
+        LIBCLOG_RETURN_P(SigActOld.__sigaction_u.__sa_handler);
+    errno = -rc;
+    LIBCLOG_RETURN_P(SIG_ERR);
 }
 

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

@@ -31 +31 @@
 #include <signal.h>
 #include <errno.h>
-#include <InnoTekLIBC/signals.h>
+#include <InnoTekLIBC/libc.h>
+#include <InnoTekLIBC/backend.h>
 #define __LIBC_LOG_GROUP __LIBC_LOG_GRP_SIGNAL
 #include <InnoTekLIBC/logstrict.h>
@@ -59 +60 @@
         LIBCLOG_RETURN_P(SIG_ERR);
     }
+
+
+
+
+
+
     if (!__SIGSET_SIG_VALID(iSignalNo))
     {
@@ -75 +82 @@
 
     /*
-     * Gain exclusive access to the signal stuff.
-     */
-    if (__libc_back_signalSemRequest())
-        LIBCLOG_RETURN_P(SIG_ERR);
-
-    /*
      * Change signal action.
      */
     if (__SIGSET_ISSET(&__libc_gSignalRestartMask, iSignalNo))
         SigAct.sa_flags |= SA_RESTART;
-    rc = __libc_back_signalAction(iSignalNo, &SigAct, &SigActOld);
-
-    /*
-     * Release semaphore.
-     */
-    __libc_back_signalSemRelease();
-
-    /*
-     * Check for errors and return.
-     */
-    if (rc)
-        LIBCLOG_RETURN_P(SIG_ERR);
-    LIBCLOG_RETURN_P(SigActOld.__sigaction_u.__sa_handler);
+    rc = __libc_Back_signalAction(iSignalNo, &SigAct, &SigActOld);
+    if (!rc)
+        LIBCLOG_RETURN_P(SigActOld.__sigaction_u.__sa_handler);
+    errno = -rc;
+    LIBCLOG_RETURN_P(SIG_ERR);
 }
 

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

@@ -31 +31 @@
 #include <signal.h>
 #include <errno.h>
-#include <InnoTekLIBC/signals.h>
+#include <InnoTekLIBC/.h>
 #define __LIBC_LOG_GROUP __LIBC_LOG_GRP_SIGNAL
 #include <InnoTekLIBC/logstrict.h>

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

@@ -30 +30 @@
 *******************************************************************************/
 #include "libc-alias.h"
+
 #include <signal.h>
 #include <errno.h>
-#include <InnoTekLIBC/signals.h>
-#include <InnoTekLIBC/thread.h>
 #define __LIBC_LOG_GROUP __LIBC_LOG_GRP_SIGNAL
 #include <InnoTekLIBC/logstrict.h>

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

@@ -32 +32 @@
 #include <signal.h>
 #include <process.h>
-#include <InnoTekLIBC/signals.h>
 #define __LIBC_LOG_GROUP __LIBC_LOG_GRP_SIGNAL
 #include <InnoTekLIBC/logstrict.h>

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

@@ -31 +31 @@
 #include "libc-alias.h"
 #include <signal.h>
-#include <errno.h>
-#include <InnoTekLIBC/signals.h>
-#include <InnoTekLIBC/thread.h>
+#include <InnoTekLIBC/backend.h>
 #define __LIBC_LOG_GROUP __LIBC_LOG_GRP_SIGNAL
 #include <InnoTekLIBC/logstrict.h>

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

@@ -32 +32 @@
 #include <signal.h>
 #include <errno.h>
-#include <InnoTekLIBC/signals.h>
 #include <InnoTekLIBC/thread.h>
+
 #define __LIBC_LOG_GROUP __LIBC_LOG_GRP_SIGNAL
 #include <InnoTekLIBC/logstrict.h>

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

@@ -32 +32 @@
 #include <signal.h>
 #include <errno.h>
-#include <InnoTekLIBC/signals.h>
 #include <InnoTekLIBC/thread.h>
+
 #define __LIBC_LOG_GROUP __LIBC_LOG_GRP_SIGNAL
 #include <InnoTekLIBC/logstrict.h>

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

@@ -33 +33 @@
 #include <signal.h>
 #include <errno.h>
-#include <InnoTekLIBC/signals.h>
-#include <InnoTekLIBC/thread.h>
+#include <InnoTekLIBC/backend.h>
 #define __LIBC_LOG_GROUP __LIBC_LOG_GRP_SIGNAL
 #include <InnoTekLIBC/logstrict.h>
@@ -52 +51 @@
 {
     LIBCLOG_ENTER("iSignalNo=%d fFlag=%d\n", iSignalNo, fFlag);
-    struct sigaction    SigAct = {{0}};
-    int                 rc;
-    int                 rc2 = 0;
 
     /*
-     * Validate.
+     * .
      */
-    if (!__SIGSET_SIG_VALID(iSignalNo))
-    {
-        LIBC_ASSERTM_FAILED("Invalid signal no %d\n", iSignalNo);
-        errno = EINVAL;
-        LIBCLOG_RETURN_INT(-1);
-    }
-
-    /*
-     * Gain exclusive access to the signal stuff.
-     */
-    if (__libc_back_signalSemRequest())
-        LIBCLOG_RETURN_INT(-1);
-
-    /*
-     * Get the previous signal action.
-     */
-    rc = __libc_back_signalAction(iSignalNo, NULL, &SigAct);
+    int rc = __libc_Back_signalInterrupt(iSignalNo, fFlag);
     if (!rc)
-    {
-        if (fFlag)
-        {   /* interrupt */
-            SigAct.sa_flags &= ~SA_RESTART;
-            __SIGSET_CLEAR(&__libc_gSignalRestartMask, iSignalNo);
-        }
-        else
-        {   /* restart */
-            SigAct.sa_flags |= SA_RESTART;
-            __SIGSET_SET(&__libc_gSignalRestartMask, iSignalNo);
-        }
-        rc2 = __libc_back_signalAction(iSignalNo, &SigAct, NULL);
-    }
-
-    /*
-     * Release semaphore.
-     */
-    __libc_back_signalSemRelease();
-
-
-    /*
-     * Check for failure and return.
-     */
-    LIBC_ASSERTM(!rc2, "Impossible!\n");
-    if (rc || rc2)
-        LIBCLOG_RETURN_INT(-1);
-
-    LIBCLOG_RETURN_INT(0);
+        LIBCLOG_RETURN_INT(0);
+    errno = -rc;
+    LIBCLOG_RETURN_INT(-1);
 }

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

@@ -29 +29 @@
 *******************************************************************************/
 #include "libc-alias.h"
-#include <InnoTekLIBC/signals.h>
+#include <InnoTekLIBC/.h>
 
 

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

@@ -30 +30 @@
 #include "libc-alias.h"
 #include <signal.h>
-#include <InnoTekLIBC/signals.h>
+#include <InnoTekLIBC/.h>
 #define __LIBC_LOG_GROUP __LIBC_LOG_GRP_SIGNAL
 #include <InnoTekLIBC/logstrict.h>

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

@@ -34 +34 @@
 #include <signal.h>
 #include <errno.h>
-#include <InnoTekLIBC/signals.h>
-#include <InnoTekLIBC/thread.h>
+#include <InnoTekLIBC/backend.h>
 #define __LIBC_LOG_GROUP __LIBC_LOG_GRP_SIGNAL
 #include <InnoTekLIBC/logstrict.h>

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

@@ -32 +32 @@
 #include <signal.h>
 #include <errno.h>
-#include <InnoTekLIBC/signals.h>
-#include <InnoTekLIBC/thread.h>
+#include <InnoTekLIBC/backend.h>
 #define __LIBC_LOG_GROUP __LIBC_LOG_GRP_SIGNAL
 #include <InnoTekLIBC/logstrict.h>
+
+
+
 
 

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

@@ -31 +31 @@
 #include "libc-alias.h"
 #include <signal.h>
-#include <InnoTekLIBC/signals.h>
-#include <InnoTekLIBC/thread.h>
+#include <.h>
+#include <InnoTekLIBC/d.h>
 #define __LIBC_LOG_GROUP __LIBC_LOG_GRP_SIGNAL
 #include <InnoTekLIBC/logstrict.h>
@@ -47 +47 @@
 {
     LIBCLOG_ENTER("pSigSet=%p\n", (void *)pSigSet);
-    __LIBC_THREAD  *pThrd = __libc_threadCurrent();
-    sigset_t        SigSet;
 
-    __SIGSET_EMPTY(&SigSet);            /* touch it! (paranoia) */
-
-    /*
-     * Gain exclusive access to the signal stuff.
-     */
-    if (__libc_back_signalSemRequest())
-        LIBCLOG_RETURN_INT(-1);
-
-    /*
-     * Or the blocked and pending members for this thread.
-     */
-    __SIGSET_OR(&SigSet, &__libc_gSignalPending, &pThrd->SigSetPending);
-    __SIGSET_AND(&SigSet, &pThrd->SigSetBlocked, &SigSet);
-
-    /*
-     * Release semaphore.
-     */
-    __libc_back_signalSemRelease();
-
-    /*
-     * Copy the set.
-     */
-    *pSigSet = SigSet;
-
-    LIBCLOG_RETURN_MSG(0, "ret 0 (*pSigSet={%08lx %08lx})\n", SigSet.__bitmap[1], SigSet.__bitmap[0]);
+    int rc = __libc_Back_signalPending(pSigSet);
+    if (!rc)
+        LIBCLOG_RETURN_MSG(0, "ret 0 (*pSigSet={%08lx %08lx})\n", pSigSet->__bitmap[1], pSigSet->__bitmap[0]);
+    errno = -rc;
+    LIBCLOG_RETURN_INT(-1);
 }
 

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

@@ -80 +80 @@
         if (pSigSetOld)
             *pSigSetOld = SigSetOld;
-
-        LIBCLOG_RETURN_MSG(0, "ret 0 old={%08lx%08lx} new={%08lx%08lx}\n",
-                           SigSetOld.__bitmap[1], SigSetOld.__bitmap[0],
-                           SigSetNew.__bitmap[1], SigSetNew.__bitmap[0]);
+        LIBCLOG_RETURN_MSG(0, "ret 0 old={%08lx%08lx}\n", SigSetOld.__bitmap[1], SigSetOld.__bitmap[0]);
     }
     errno = -rc;

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

@@ -32 +32 @@
 #include <signal.h>
 #include <errno.h>
-#include <InnoTekLIBC/signals.h>
-#include <InnoTekLIBC/thread.h>
+#include <InnoTekLIBC/backend.h>
 #define __LIBC_LOG_GROUP __LIBC_LOG_GRP_SIGNAL
 #include <InnoTekLIBC/logstrict.h>

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

@@ -31 +31 @@
 #include "libc-alias.h"
 #include <signal.h>
-#include <errno.h>
-#include <InnoTekLIBC/signals.h>
-#include <InnoTekLIBC/thread.h>
+#include <InnoTekLIBC/backend.h>
 #define __LIBC_LOG_GROUP __LIBC_LOG_GRP_SIGNAL
 #include <InnoTekLIBC/logstrict.h>

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

@@ -33 +33 @@
 #include <signal.h>
 #include <errno.h>
-#include <InnoTekLIBC/signals.h>
 #include <InnoTekLIBC/thread.h>
+
 #define __LIBC_LOG_GROUP __LIBC_LOG_GRP_SIGNAL
 #include <InnoTekLIBC/logstrict.h>
@@ -49 +49 @@
     LIBCLOG_ENTER("pSigSet=%p {%08lx%08lx}\n",
                   (void *)pSigSet, pSigSet ? pSigSet->__bitmap[1] : 0, pSigSet ? pSigSet->__bitmap[0] : 0);
-    __LIBC_PTHREAD  pThrd = __libc_threadCurrent();
-    sigset_t        SigSet;
 
     /*
-     * Make copy of the input (we can safely crash here).
+     * .
      */
-    SigSet = *pSigSet;
-
-    /*
-     * Gain exclusive access to the signal stuff.
-     */
-    if (__libc_back_signalSemRequest())
+    int rc = __libc_Back_signalSuspend(pSigSet);
+    if (rc)
+    {
+        errno = -rc;
         LIBCLOG_RETURN_INT(-1);
-
-    /*
-     * Change the signal mask.
-     */
-    pThrd->SigSetBlockedOld     = pThrd->SigSetBlocked;
-    pThrd->fSigSetBlockedOld    = 1;
-    pThrd->SigSetBlocked        = SigSet;
-
-    /*
-     * Go to sleep but check for pending signals first.
-     *
-     * We have to do this call from within the sem+mustcomplete section.
-     * The backend function will leave the section.
-     */
-    __libc_back_signalSuspend();
-
-
-    /*
-     * Return interrupt failure.
-     */
-    errno = EINTR;
-    LIBCLOG_RETURN_INT(-1);
+    }
+    LIBCLOG_RETURN_INT(0);
 }

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

@@ -31 +31 @@
 #include "libc-alias.h"
 #include <signal.h>
-#include <assert.h>
-#include <InnoTekLIBC/signals.h>
+#include <errno.h>
 #include <InnoTekLIBC/thread.h>
+
 #define __LIBC_LOG_GROUP __LIBC_LOG_GRP_SIGNAL
 #include <InnoTekLIBC/logstrict.h>
@@ -40 +40 @@
 
 /**
- * Wait for a signal to become pending.
+ * Wait for one or more signals and remove and return the first of them
+ * to occur.
  *
- * @returns 0 on success.
+ * Will return immediately if one of the signals is already pending. If more than
+ * one signal is pending the signal with highest priority will be returned.
+ *
+ * @returns Signal number on success.
  * @returns -1 on failure, errno set.
  * @param   pSigSet     Signals to wait for.
  * @param   pSigInfo    Where to store the signal info for the signal
  *                      that we accepted.
+
  */
 int _STD(sigtimedwait)(const sigset_t *pSigSet, siginfo_t *pSigInfo, const struct timespec *pTimeout)
@@ -54 +59 @@
                   (void *)pSigInfo,
                   (void *)pTimeout, pTimeout ? pTimeout->tv_sec : ~0, pTimeout ? pTimeout->tv_nsec : ~0);
-    __LIBC_PTHREAD  pThrd = __libc_threadCurrent();
-    sigset_t        SigSet;
-    siginfo_t       SigInfo = {0};
-    struct timespec Timeout;
-    int             rc;
 
     /*
-     * Make copy of the input (we can safely crash here).
+     * .
      */
-    SigSet = *pSigSet;
-    if (pTimeout)
-        Timeout = *pTimeout;
+    siginfo_t SigInfo;
+    int rc = __libc_Back_signalWait(pSigSet, &SigInfo, pTimeout);
+    if (!rc)
+    {
+        if (pSigInfo)
+            *pSigInfo = SigInfo;
+        LIBCLOG_RETURN_MSG(rc, "ret %d (*pSigInfo={si_signo=%d, si_errno=%d, si_code=%#x, si_timestamp=%#x, si_flags=%#x, si_pid=%d, si_tid=%d, si_uid=%d, si_status=%d, si_addr=%p, si_value=%#08x, si_band=%ld})\n",
+                           rc, SigInfo.si_signo, SigInfo.si_errno, SigInfo.si_code, SigInfo.si_timestamp,
+                           SigInfo.si_flags, SigInfo.si_pid, SigInfo.si_tid, SigInfo.si_uid, SigInfo.si_status,
+                           SigInfo.si_addr, SigInfo.si_value.sigval_int, SigInfo.si_band);
+    }
 
-    /*
-     * Gain exclusive access to the signal stuff.
-     */
-    if (__libc_back_signalSemRequest())
-        LIBCLOG_RETURN_INT(-1);
-
-    /*
-     * Mark thread as blocked in begin in sigtimedwait().
-     */
-    if (pThrd->enmStatus != enmLIBCThreadStatus_unknown)
-    {
-        LIBC_ASSERTM_FAILED("Must push thread state!\n");
-        __libc_back_signalSemRelease();
-        assert(0);
-        LIBCLOG_RETURN_INT(-1);
-    }
-    pThrd->enmStatus            = enmLIBCThreadStatus_sigwait;
-    pThrd->u.SigWait.SigSetWait = SigSet;
-    pThrd->u.SigWait.pSigInfo   = &SigInfo;
-
-    /*
-     * Go to sleep.
-     *
-     * We have to do this call from within the sem+mustcomplete section.
-     * The backend function will leave the section.
-     */
-    rc = __libc_back_signalWait(pTimeout ? &Timeout : NULL);
-
-    /*
-     * Store result.
-     */
-    if (pSigInfo)
-        *pSigInfo = SigInfo;
-
-    LIBCLOG_RETURN_MSG(rc, "ret %d (*pSigInfo={si_signo=%d, si_errno=%d, si_code=%#x, si_pid=%d, si_uid=%d, si_status=%d, si_addr=%p, si_value=%#08x, si_band=%ld})\n",
-                       rc, SigInfo.si_signo, SigInfo.si_errno, SigInfo.si_code, SigInfo.si_pid, SigInfo.si_uid,
-                       SigInfo.si_status, SigInfo.si_addr, SigInfo.si_value.sigval_int, SigInfo.si_band);
+    errno = -rc;
+    LIBCLOG_RETURN_INT(-1);
 }
 

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

@@ -32 +32 @@
 #include <signal.h>
 #include <errno.h>
-#include <InnoTekLIBC/signals.h>
 #include <InnoTekLIBC/thread.h>
+
 #define __LIBC_LOG_GROUP __LIBC_LOG_GRP_SIGNAL
 #include <InnoTekLIBC/logstrict.h>

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

@@ -31 +31 @@
 #include "libc-alias.h"
 #include <signal.h>
-#include <InnoTekLIBC/signals.h>
 #include <InnoTekLIBC/thread.h>
+
 #define __LIBC_LOG_GROUP __LIBC_LOG_GRP_SIGNAL
 #include <InnoTekLIBC/logstrict.h>

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

@@ -31 +31 @@
 #include "libc-alias.h"
 #include <signal.h>
-#include <InnoTekLIBC/signals.h>
 #include <InnoTekLIBC/thread.h>
+
 #define __LIBC_LOG_GROUP __LIBC_LOG_GRP_SIGNAL
 #include <InnoTekLIBC/logstrict.h>

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

@@ -41 +41 @@
 #include <InnoTekLIBC/thread.h>
 #include <InnoTekLIBC/backend.h>
-#include <InnoTekLIBC/signals.h>
 #define __LIBC_LOG_GROUP __LIBC_LOG_GRP_THREAD
 #include <InnoTekLIBC/logstrict.h>
@@ -88 +87 @@
     pThrd->iRand = 1;
     pThrd->cRefs = 1;
-    /* ASSUMES sigemptyset() is equivalent with memsetting a sigset_t. */
-    if (pParentThrd)
-    {
-        /*
-         * Gain exclusive access to the signal stuff.
-         */
-        int rc = __libc_back_signalSemRequest();
-
-        /*
-         * Copy signal stuff.
-         */
-        pThrd->SigSetBlocked    = pParentThrd->SigSetBlocked;
-        if (pParentThrd->fSigSetBlockedOld)
-        {
-            pThrd->SigSetBlockedOld     = pParentThrd->SigSetBlockedOld;
-            pThrd->fSigSetBlockedOld    = pParentThrd->fSigSetBlockedOld;
-        }
-
-        /*
-         * Release semaphore.
-         */
-        if (!rc)
-            __libc_back_signalSemRelease();
-    }
-    else
-    {
-        /** @todo try find info from parent process. */
-    }
-
     __libc_Back_threadInit(pThrd, pParentThrd);
 }

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

@@ -29 +29 @@
 #include <InnoTekLIBC/sharedpm.h>
 #include <InnoTekLIBC/backend.h>
-#include <InnoTekLIBC/signals.h>
 #define __LIBC_LOG_GROUP    __LIBC_LOG_GRP_INITTERM
 #include <InnoTekLIBC/logstrict.h>
+
 
 

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

@@ -35 +35 @@
 #include "syscalls.h"
 #include "fs.h"
+
 #include <InnoTekLIBC/thread.h>
 #include <InnoTekLIBC/libc.h>
-#include <InnoTekLIBC/signals.h>
+#include <InnoTekLIBC/.h>
 #define __LIBC_LOG_GROUP    __LIBC_LOG_GRP_INITTERM
 #include <InnoTekLIBC/logstrict.h>

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

@@ -48 +48 @@
  *
  * @returns 0 on success.
- * @returns -1 and errno set to EINVAL on failure.
+ * @returns  on failure.
  * @param   pThrd       Thread to apply this to.
  * @param   iHow        Describes the action taken if pSigSetNew not NULL. Recognized

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

@@ -30 +30 @@
 *******************************************************************************/
 #include "libc-alias.h"
-#define INCL_BASE
-#define INCL_FSMACROS
-#define INCL_DOSSIGNALS
-#include <os2emx.h>
-
 #include <signal.h>
 #include <errno.h>
@@ -41 +36 @@
 #define __LIBC_LOG_GROUP __LIBC_LOG_GRP_BACK_SIGNAL
 #include <InnoTekLIBC/logstrict.h>
-#include "syscalls.h"
+#include "sls.h"
 
 /**

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

@@ -29 +29 @@
 *   Header Files                                                               *
 *******************************************************************************/
-#define INCL_BASE
-#define INCL_FSMACROS
-#include <os2emx.h>
-
+#include "libc-alias.h"
 #include <signal.h>
 #include <errno.h>
-#include <InnoTekLIBC/signals.h>
-#define __LIBC_LOG_GROUP __LIBC_LOG_GRP_SIGNAL
+#include <InnoTekLIBC/thread.h>
+#include <InnoTekLIBC/backend.h>
+#define __LIBC_LOG_GROUP __LIBC_LOG_GRP_BACK_SIGNAL
 #include <InnoTekLIBC/logstrict.h>
-
-    
-/*******************************************************************************
-*   Structures and Typedefs                                                    *
-*******************************************************************************/
-/** Registration record for signalSuspendXcptHandler(). */
-typedef struct XCPTREGREC
-{
-    EXCEPTIONREGISTRATIONRECORD     Core;
-    /** This event semaphore is signaled when a signal has been
-     * processed by the current thread. */
-    HEV                             hev;
-} XCPTREGREC, *PXCPTREGREC;
-
-
-/*******************************************************************************
-*   Internal Functions                                                         *
-*******************************************************************************/
-static ULONG _System signalSuspendXcptHandler(PEXCEPTIONREPORTRECORD pXcptRec,  PEXCEPTIONREGISTRATIONRECORD pRegRec, PCONTEXTRECORD pCtx, PVOID pvSomething);
-
-
-/**
- * Exception handler use while waitin for signals to be 
- * delivered to this thread or the process being terminated.
- */
-static ULONG _System signalSuspendXcptHandler(PEXCEPTIONREPORTRECORD pXcptRec,  PEXCEPTIONREGISTRATIONRECORD pRegRec, PCONTEXTRECORD pCtx, PVOID pvSomething)
-{
-    /* a thread counter? */
-    /** @todo implement me! */
-    return XCPT_CONTINUE_SEARCH;
-}
+#include "signals.h"
 
 
@@ -75 +43 @@
  * The signal semaphore is owned.
  */
-int         __libc_back_signalSuspend(void)
+int         __libc_)
 {
-    LIBCLOG_ENTER("\n");
-    int         rc;
-    XCPTREGREC  XcptReg;
-    FS_VAR();
+    LIBCLOG_ENTER("pSigSet=%p {%08lx%08lx}\n",
+                  (void *)pSigSet, pSigSet ? pSigSet->__bitmap[1] : 0, pSigSet ? pSigSet->__bitmap[0] : 0);
+    __LIBC_PTHREAD              pThrd = __libc_threadCurrent();
+    sigset_t                    SigSet = *pSigSet;
+    __LIBC_THREAD_SIGSUSPEND    SigSuspend = {0};
 
     /*
-     * Register 
+     * 
      */
-    FS_SAVE_LOAD();
-    XcptReg.Core.ExceptionHandler = signalSuspendXcptHandler;
-    XcptReg.Core.prev_structure = (void *)~0;
-    rc = DosCreateEventSem(NULL, &XcptReg.hev, 0, FALSE);
-    if (!rc)
-    {
-        rc = DosSetExceptionHandler(&XcptReg.Core);
-        if (!rc)
-        {
-            PPIB    pPib;
-            PTIB    pTib;
-            
-            /*
-             * Time to release the semaphore.
-             */
-            __libc_back_signalSemRelease();
-            if (pTib->tib_ptib2->tib2_usMCCount)
-            {
-                LIBC_ASSERTM_FAILED("Deadlock avoided. tried to wait for signal with must complete count %d\n", pTib->tib_ptib2->tib2_usMCCount);
-                LIBCLOG_RETURN_INT(-EDEADLK);
-            }
+    int rc =__libc_back_signalSemRequest();
+    if (rc)
+        LIBCLOG_RETURN_INT(rc);
 
-            /*
-             * Wait loop.
-             */
-            DosGetInfoBlocks(&pTib, &pPib);
-            for (;;)
-            {
-                rc = DosWaitEventSem(XcptReg.hev, 30*1000);
-                if (!rc)
-                    break;
+    /*
+     .
+     */
+    ;
+    
+    
+    ;
+    
+    ;
 
-                /* Avoid deadlocks during termination. */
-                if (pPib->pib_flstatus & (0x40/*dying*/ | 0x04/*exiting all*/ | 0x02/*Exiting Thread 1*/ | 0x01/* ExitList */))
-                {
-                    LIBCLOG_MSG("resuming execution, anyhow. the process is terminating. (status=%#lx\n", pPib->pib_flstatus);
-                    break;
-                }
-            }
-
-            DosUnsetExceptionHandler(&XcptReg.Core);
-        }
-        DosCloseEventSem(XcptReg.hev);
-    }
-
-    FS_RESTORE();
-    LIBCLOG_RETURN_INT(0);
+    /*
+     * Perform signal wait and return.
+     */
+    rc = __libc_back_signalWait(pThrd, &SigSuspend.fDone, NULL);
+    if (rc != EAGAIN)
+        __libc_back_signalSemRelease();
+    LIBCLOG_RETURN_INT(rc);
 }
 

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

@@ -37 +37 @@
 #include <errno.h>
 #include <386/builtin.h>
-#include <InnoTekLIBC/signals.h>
+#include 
 #include <InnoTekLIBC/thread.h>
+
 #define __LIBC_LOG_GROUP __LIBC_LOG_GRP_SIGNAL
 #include <InnoTekLIBC/logstrict.h>
 
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
-int         __libc_back_signalWait(const struct timespec *pTimeout)
-{
-    LIBCLOG_ENTER("pTimeout=%p {tv_sec=%d tv_nsec=%ld}\n",
-                  (void *)pTimeout, 
-                  pTimeout->tv_sec,
-                  pTimeout->tv_nsec);
-    /** @todo Implement me */
-#if 0
-    sigset_t        SigSetPending;
+    __LIBC_PTHREAD  pThrd = __libc_threadCurrent();
+    sigset_t                        SigSet;
+    __LIBC_THREAD_SIGWAIT           SigWait = {0};
+    struct timespec                 Timeout;
+    int                             rc;
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
     if (    !__SIGSET_ISEMPTY(&pThrd->SigSetPending)
         ||  !__SIGSET_ISEMPTY(&__libc_gSignalPending))
     {
+
         __SIGSET_OR(&SigSetPending, &pThrd->SigSetPending, &__libc_gSignalPending);
-        __SIGSET_AND(&SigSetPending, &SigSetPending, &SigSet);
+        __SIGSET_AND(&SigSetPending, &SigSetPending, &SigSet);
         if (!__SIGSET_ISEMPTY(&SigSetPending))
-            rc = __libc_back_signalAccept();
+        {
+            rc = __libc_back_signalAccept(pThrd, 0, &SigSetPending, (siginfo_t *)&SigWait.SigInfo);
+            if (rc > 0)
+            {
+                if (pSigInfo)
+                    *pSigInfo = SigWait.SigInfo;
+                __libc_back_signalSemRelease();
+                LIBCLOG_RETURN_INT(rc);
+            }
+            LIBC_ASSERT_FAILED();
+        }
     }
-#endif 
-    LIBCLOG_RETURN_INT(-1);
+
+    /*
+     * Mark thread as blocked in sigtimedwait().
+     */
+    if (pThrd->enmStatus != enmLIBCThreadStatus_unknown)
+    {
+        LIBC_ASSERTM_FAILED("Must push thread state!\n");
+        __libc_back_signalSemRelease();
+        LIBCLOG_RETURN_INT(-EDEADLK);
+    }
+    SigWait.fDone           = 0;
+    SigWait.SigSetWait      = SigSet;
+    SigWait.SigInfo.si_signo= 0;
+    pThrd->u.pSigWait   = &SigWait;
+    pThrd->enmStatus    = enmLIBCThreadStatus_sigwait;
+
+    /*
+     * Wait till state changes back and then return according to the wait result.
+     *
+     * The result is a bit tricky. EAGAIN means time out and no semaphore. While
+     * EINTR means that we've been interrupted by the delivery of a signal, which
+     * might mean that we got what we waited for or that some other signal was
+     * delivered to this thread. Very simple. :-)
+     */
+    rc = __libc_back_signalWait(pThrd, &SigWait.fDone, pTimeout ? &Timeout : NULL);
+    if (rc != -EAGAIN)
+        __libc_back_signalSemRelease();
+    if (rc == -EINTR)
+    {
+        if (SigWait.fDone && SigWait.SigInfo.si_signo > 0)
+        {
+            rc = SigWait.SigInfo.si_signo;
+            if (pSigInfo)
+                *pSigInfo = SigWait.SigInfo;
+        }
+    }
+
+    LIBCLOG_RETURN_MSG(rc, "ret %d SigWait.SigInfo={si_signo=%d, si_errno=%d, si_code=%#x, si_timestamp=%#x, si_flags=%#x, si_pid=%d, si_tid=%d, si_uid=%d, si_status=%d, si_addr=%p, si_value=%#08x, si_band=%ld}\n",
+                       rc, SigWait.SigInfo.si_signo, SigWait.SigInfo.si_errno, SigWait.SigInfo.si_code, SigWait.SigInfo.si_timestamp,
+                       SigWait.SigInfo.si_flags, SigWait.SigInfo.si_pid, SigWait.SigInfo.si_tid, SigWait.SigInfo.si_uid, SigWait.SigInfo.si_status,
+                       SigWait.SigInfo.si_addr, SigWait.SigInfo.si_value.sigval_int, SigWait.SigInfo.si_band);
 }
 

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

@@ -33 +33 @@
 #include <emx/syscalls.h>
 #include "syscalls.h"
+
 #include <InnoTekLIBC/thread.h>
 #include <InnoTekLIBC/backend.h>
@@ -41 +42 @@
     pThrd->b.sys.fd.hdir = HDIR_CREATE;
     pThrd->b.sys.fd.cFiles = 0;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 }
 

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

@@ -37 +37 @@
 #include <errno.h>
 #include <386/builtin.h>
-#include <InnoTekLIBC/signals.h>
 #include <InnoTekLIBC/thread.h>
 #include <InnoTekLIBC/backend.h>
 #define __LIBC_LOG_GROUP __LIBC_LOG_GRP_SIGNAL
 #include <InnoTekLIBC/logstrict.h>
+
 
 

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

@@ -892 +892 @@
 {
     __atomic_xchg(&gpSPMSelf->fExeInited, 1);
-    return 0;
 }
 

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

@@ -1027 +1027 @@
          */
         if (   pThrdSig->enmStatus == enmLIBCThreadStatus_sigwait
-            && __SIGSET_ISSET(&pThrdSig->u.SigWait.SigSetWait, iSignalNo))
+            && __SIGSET_ISSET(&pThrdSig->u.SigSetWait, iSignalNo))
         {
             /*
              * Wake up a sigwait call.
              */
-            /** @todo install extra exception handler while accessing this. */
             if (pSigInfo)
-                *pThrdSig->u.SigWait.pSigInfo = *pSigInfo;
+                SigInfo = *pSigInfo;
             else
-            {
-                bzero(pThrdSig->u.SigWait.pSigInfo, sizeof(*pThrdSig->u.SigWait.pSigInfo));
-                pThrdSig->u.SigWait.pSigInfo->si_signo = iSignalNo;
-            }
+                bzero((void *)&pThrdSig->u.pSigWait->SigInfo, sizeof(pThrdSig->u.pSigWait->SigInfo));
+            pThrdSig->u.pSigWait->SigInfo.si_signo = iSignalNo;
+            pThrdSig->u.pSigWait->fDone = 1;
             pThrdSig->enmStatus = enmLIBCThreadStatus_unknown;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
             if (pThrdSig != pThrd)
                 __libc_back_signalPokeThread(pThrdSig);
-            LIBCLOG_MSG("wokeup sigwait in thread %d on signal %d.\n", pThrdSig->tid, iSignalNo);
+            LIBCLOG_MSG("wokeup sigwait in thread % on signal %d.\n", pThrdSig->tid, iSignalNo);
         }
         else
@@ -1116 +1129 @@
                 if (pThrdSig != pThrd)
                     __libc_back_signalPokeThread(pThrdSig);
-                LIBCLOG_MSG("setting %d pending on thread %d's and poking it.\n", pThrdSig->tid, iSignalNo);
+                LIBCLOG_MSG("setting %d pending on thread %'s and poking it.\n", pThrdSig->tid, iSignalNo);
             }
         }
@@ -1351 +1364 @@
 
     /*
-     * 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;
+     * Check if this was a sig*wait* case.
+     */
+    if (   pThrdSig->enmStatus == enmLIBCThreadStatus_sigwait
+        && __SIGSET_ISSET(&pThrdSig->u.pSigWait->SigSetWait, iSignalNo))
+    {
+        /*
+         * Store result with the thread.
+         */
+        if (pSig)
+            pThrdSig->u.pSigWait->SigInfo = pSig->SigInfo;
         else
-            pThrdSig->SigQueue.pHead = pSig;
-        pThrdSig->SigQueue.pTail = pSig;
-    }
-
-    /*
-     * In any case, we set the signal pending and poke the thread.
-     */
-    __SIGSET_SET(&pThrd->SigSetPending, iSignalNo);
-    if (pThrdSig != pThrd)
-        __libc_back_signalPokeThread(pThrdSig);
-    LIBCLOG_MSG("setting %d pending on thread %d's and poking it.\n", pThrdSig->tid, iSignalNo);
+            bzero((void *)&pThrdSig->u.pSigWait->SigInfo, sizeof(pThrdSig->u.pSigWait->SigInfo));
+        pThrdSig->u.pSigWait->SigInfo.si_signo = iSignalNo;
+        pThrdSig->u.pSigWait->fDone = 1;
+        pThrdSig->enmStatus = enmLIBCThreadStatus_unknown;
+
+        /*
+         * Free the signal node.
+         */
+        pSig->pNext = gpSigQueuedFree;
+        gpSigQueuedFree = pSig->pNext;
+        gcSigQueuedFree++;
+
+        /*
+         * Check if there is an unqueued pending signal which we should clear.
+         */
+        pSig = pThrdSig->SigQueue.pHead;
+        while (pSig && pSig->SigInfo.si_signo != iSignalNo)
+            pSig = pSig->pNext;
+        if (!pSig)
+            __SIGSET_CLEAR(&pThrdSig->SigSetPending, iSignalNo);
+        else
+            __SIGSET_SET(&pThrdSig->SigSetPending, iSignalNo);
+
+        /*
+         * Poke the thread.
+         */
+        if (pThrdSig != pThrd)
+            __libc_back_signalPokeThread(pThrdSig);
+        LIBCLOG_MSG("wokeup sigwait in thread %#x on signal %d.\n", pThrdSig->tid, iSignalNo);
+    }
+    else
+    {
+        /*
+         * 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.pHead = pSig;
+            pThrdSig->SigQueue.pTail = pSig;
+        }
+
+        /*
+         * And in any case set it pending.
+         */
+        __SIGSET_SET(&pThrd->SigSetPending, iSignalNo);
+
+        /*
+         * Poke the thread.
+         */
+        if (pThrdSig != pThrd)
+            __libc_back_signalPokeThread(pThrdSig);
+        LIBCLOG_MSG("setting %d pending on thread %#x's and poking it.\n", pThrdSig->tid, iSignalNo);
+    }
+
     LIBCLOG_RETURN_VOID();
 }
@@ -1386 +1449 @@
 {
     LIBC_ASSERTM(__libc_back_signalSemIsOwner(), "Thread does not own the signal semaphore!!!\n");
+
+
+
+
+
+
+
+
+
+
 
     /*
@@ -1423 +1496 @@
      */
     if (   pCur->enmStatus == enmLIBCThreadStatus_sigwait
-        && __SIGSET_ISSET(&pCur->u.SigWait.SigSetWait, pParam->iSignalNo))
+        && __SIGSET_ISSET(&pCur->u.SigSetWait, pParam->iSignalNo))
     {
         if (pCur == pParam->pThrd)
@@ -1443 +1516 @@
         ||  (   pBest
              && pBest->enmStatus == enmLIBCThreadStatus_sigwait
-             && __SIGSET_ISSET(&pCur->u.SigWait.SigSetWait, pParam->iSignalNo)))
+             && __SIGSET_ISSET(&pSigSetWait, pParam->iSignalNo)))
         return 0;
     /* ok, it's not blocking it so it's ok to use it. */
@@ -1552 +1625 @@
 
         /*
-         * Deliver signals /execute signal default actions in this order:
-         *   0. Passed in signal (ignores blocking).
-         *   1. SIGKILL
-         *   2. Realtime signals. (queued)
-         *   3. SIGTERM
-         *   4. SIGABRT
-         *   5. SIGCHLD
-         *   6. SIGCONT
-         *   7. 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 = SIGTERM;
-                    if (!__SIGSET_ISSET(&SigDeliver, SIGTERM))
-                    {
-                        iSignalNo = SIGABRT;
-                        if (!__SIGSET_ISSET(&SigDeliver, SIGABRT))
-                        {
-                            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;
-            }
-            /* next */
-            pSig = pSig->pNext;
-        }
-
-        /*
-         * 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?
-         */
+         * Accept the signal.
+         */
+        siginfo_t SigInfo;
+        if (iSignalNo && __SIGSET_ISSET(&pThrd->SigSetPending, iSignalNo))
+            iSignalNo = __libc_back_signalAccept(pThrd, iSignalNo, &SigDeliver, &SigInfo);
+        LIBC_ASSERTM(__SIGSET_SIG_VALID(iSignalNo), "iSignalNo=%d\n", iSignalNo);
         struct sigaction SigAction = gaSignalActions[iSignalNo];
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
         if (    SigAction.__sigaction_u.__sa_handler == SIG_IGN
             ||  (   SigAction.__sigaction_u.__sa_handler == SIG_DFL
@@ -1666 +1675 @@
         }
 
+
+
+
         if (SigAction.__sigaction_u.__sa_handler == SIG_DFL)
         {
@@ -1730 +1742 @@
             if (gafSignalProperties[iSignalNo] & SPP_NOBLOCK)
                 __SIGSET_CLEAR(&SigAction.sa_mask, iSignalNo);
-            sigset_t SigSetOld = pThrd->SigSetBlocked;
+            sigset_t SigSetOld = d;
             __SIGSET_OR(&pThrd->SigSetBlocked, &pThrd->SigSetBlocked, &SigAction.sa_mask);
 
@@ -1992 +2004 @@
 static int signalJobStop(int iSignalNo)
 {
-    LIBC_ASSERTM(__libc_threadCurrent()->tid == 1, "Invalid thread %d\n", __libc_threadCurrent()->tid);
+    LIBC_ASSERTM(__libc_threadCurrent()->tid == 1, "Invalid thread %\n", __libc_threadCurrent()->tid);
 
     /*
@@ -2019 +2031 @@
 static int signalJobResume(void)
 {
-    LIBC_ASSERTM(__libc_threadCurrent()->tid == 1, "Invalid thread %d\n", __libc_threadCurrent()->tid);
+    LIBC_ASSERTM(__libc_threadCurrent()->tid == 1, "Invalid thread %\n", __libc_threadCurrent()->tid);
 
     /*
@@ -2358 +2370 @@
  *
  * @returns 0 on success.
- * @returns -Negative errno on failure.
+ * @returns  on failure.
  * @param   iSignalNo   Signal number.
  * @param   pSigAct     Pointer to new signal action.
@@ -2557 +2569 @@
 
 /**
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
  * Gets the current timestamp.
  *

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

@@ -30 +30 @@
 #include <sys/cdefs.h>
 #include <signal.h>
+
 #include <InnoTekLIBC/backend.h>
-
-
-/** Signal set of the signals which will interrupt system call execution.
- * By default all signals will interrupt syscall execution, since OS/2 can't really
- * restart system calls easily.
- * Update is protected by the signal semaphore, however read access isn't.
- */
-extern sigset_t     __libc_gSignalRestartMask;
 
 /** Signal set for the signals which are pending on a process scope.
@@ -56 +49 @@
 void        __libc_back_signalPokeProcess(void);
 int         __libc_back_signalSuspend(void);
-int         __libc_back_signalWait(const struct timespec *pTimeout);
+int         __libc_back_signalAccept(__LIBC_PTHREAD pThrd, int iSignalNo, sigset_t *pSigSet, siginfo_t *pSigInfo);
+int         __libc_back_signalWait(__LIBC_PTHREAD pThrd, volatile int *pfDone, const struct timespec *pTimeout);
 int         __libc_back_signalSendPidOther(pid_t pid, int iSignalNo, siginfo_t *pSigInfo);
 int         __libc_back_signalAction(int iSignalNo, const struct sigaction *pSigAct, struct sigaction *pSigActOld);