Changeset 1618 for trunk/src/emx/src/lib/sys/signals.c

Timestamp:

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

Author:

bird

Message:

More signal debugging and cleanup.

File:

• trunk/src/emx/src/lib/sys/signals.c (modified) (13 diffs, 1 prop)

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.
  *