Changeset 1625

Timestamp:

Nov 8, 2004, 2:06:54 AM (21 years ago)

Author:

bird

Message:

Debugging and writing signals.

Location:

trunk/src/emx/src/lib

Files:

• process/bsd_signal.c (modified) (1 diff, 1 prop)
• process/signal.c (modified) (1 diff, 1 prop)
• process/sigprocmask.c (modified) (1 diff, 1 prop)
• process/sigqueue.c (added)
• process/sigset.c (added)
• sys/b_signalQueue.c (added)
• sys/b_signalSuspend.c (modified) (1 diff, 1 prop)
• sys/sharedpm.c (modified) (2 diffs, 1 prop)
• sys/signals.c (modified) (5 diffs, 1 prop)
• sys/signals.h (modified) (1 diff, 1 prop)

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

@@ -79 +79 @@
     SigAct.sa_flags                   = 0;
     __SIGSET_EMPTY(&SigAct.sa_mask);
-
+    if (__SIGSET_ISSET(&__libc_gSignalRestartMask, iSignalNo))
+        SigAct.sa_flags |= SA_RESTART;
 
     /*
      * Change signal action.
      */
-    if (__SIGSET_ISSET(&__libc_gSignalRestartMask, iSignalNo))
-        SigAct.sa_flags |= SA_RESTART;
     rc = __libc_Back_signalAction(iSignalNo, &SigAct, &SigActOld);
     if (!rc)

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

@@ -36 +36 @@
 
 /**
- * Defaul signal() style is BSD.
+ * Default signal() style is BSD.
  *
  * @returns pointer to previous signal handler.

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

@@ -50 +50 @@
  *                      values are SIG_BLOCK, SIG_UNBLOCK or SIG_SETMASK.
  *
- *                      SIG_BLOCK means to or the sigset pointed to by pSigSetNew with
+ *                      SIG_BLOCK means to OR the sigset pointed to by pSigSetNew with
  *                          the signal mask for the current thread.
- *                      SIG_UNBLOCK means to and the 0 complement of the sigset pointed
+ *                      SIG_UNBLOCK means to AND the 0 complement of the sigset pointed
  *                          to by pSigSetNew with the signal mask of the current thread.
- *                      SIG_SETMASK means to set the signal mask of the current thread
+ *                      SIG_SETMASK means to REPLACE the signal mask of the current thread
  *                          to the sigset pointed to by pSigSetNew.
  *

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

@@ -68 +68 @@
     pThrd->enmStatus            = enmLIBCThreadStatus_sigsuspend;
 
+    /** @todo The specs say no rescheduling of signals in sigsuspend()... I'm not sure if that's a great idea. */
+
     /*
      * Perform signal wait and return.

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

@@ -956 +956 @@
              */
             if (    (   gpSPMHdr->cSigActive < gpSPMHdr->cSigMaxActive
-                     && gpSPMSelf->cSigsSent < __LIBC_SPM_SIGNALS_MAX_SENT)
+                     && gpSPMSelf->cSigsSent < _POSIX_SIGQUEUE_MAX)
                 || pSignal->si_signo == SIGCHLD)
             {
@@ -1023 +1023 @@
             {
                 LIBCLOG_MSG("Limit reached: cSigActive=%d cSigMaxActive=%d cSigsSent=%d (max %d)\n",
-                            gpSPMHdr->cSigActive, gpSPMHdr->cSigMaxActive, pProcess->cSigsSent, __LIBC_SPM_SIGNALS_MAX_SENT);
+                            gpSPMHdr->cSigActive, gpSPMHdr->cSigMaxActive, pProcess->cSigsSent, _POSIX_SIGQUEUE_MAX);
                 rc = -EAGAIN;
             }

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

@@ -78 +78 @@
 #include <malloc.h>
 #include <386/builtin.h>
+#include <emx/umalloc.h>
 #include <InnoTekLIBC/thread.h>
 #include <InnoTekLIBC/fork.h>
@@ -529 +530 @@
  * 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]);
+static volatile unsigned    gcSigQueuedFree = sizeof(gpaSigQueuedPreAlloced) / sizeof(gpaSigQueuedPreAlloced[0]);
 
 /** Flag indicating that this LIBC instance have installed the signal handler.
@@ -781 +782 @@
 
 /**
- * Worker called after __libc_Back_signalRaise() was called with a
- * preallocated signal queue entry. This function will make sure
- * we're not ending up with too many heap allocated packets in the
- * free list.
- */
-void __libc_Back_signalFreeWorker(void)
-{
-    LIBCLOG_ENTER("\n");
-    if (gcSigQueuedFree > sizeof(gpaSigQueuedPreAlloced) * 2 / sizeof(gpaSigQueuedPreAlloced[0]))
-    {
-        if (!__libc_back_signalSemRequest())
+ * Reschedule signals.
+ * Typically called after a block mask have been updated.
+ *
+ * @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.
+ */
+int __libc_back_signalReschedule(__LIBC_PTHREAD pThrd)
+{
+    LIBC_ASSERT(__libc_back_signalSemIsOwner());
+    signalScheduleSPM(pThrd);
+    signalScheduleProcess(pThrd);
+    return signalDeliver(pThrd, 0, NULL);
+}
+
+
+/**
+ * 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_signalQueueSelf(int iSignalNo, siginfo_t *pSigInfo)
+{
+    LIBCLOG_ENTER("iSignalNo=%d pSigInfo=%p\n", iSignalNo, (void *)pSigInfo);
+
+    /*
+     * Preallocate a queue entry to avoid entering and leaving the semaphore unecessary.
+     */
+    PSIGQUEUED pSigToFree = NULL;
+    PSIGQUEUED pSig = _hmalloc(sizeof(*pSig));
+
+    /*
+     * Take sempahore.
+     */
+    int rc = __libc_back_signalSemRequest();
+    if (!rc)
+    {
+        /*
+         * Release heap memory accumulated in node
+         */
+        if (gcSigQueuedFree > sizeof(gpaSigQueuedPreAlloced) * 2 / sizeof(gpaSigQueuedPreAlloced[0]))
         {
             /*
-             * Free nodes which was allocated from the heap until we're below the water line.
+             * No need for the preallocated one!
+             */
+            if (pSig)
+                pSig->pNext = NULL;
+            pSigToFree = pSig;
+
+            /*
+             * Unlink heap allocated nodes until we're below the waterline again
              */
             PSIGQUEUED pSigPrev = NULL;
-            PSIGQUEUED pSig = gpSigQueuedFree;
+            pSig = gpSigQueuedFree;
             int cToMany = gcSigQueuedFree - sizeof(gpaSigQueuedPreAlloced) * 2 / sizeof(gpaSigQueuedPreAlloced[0]);
             while (cToMany > 0)
@@ -810 +859 @@
                         gpSigQueuedFree = pSigNext;
 
-                    /* free */
-                    free(pSig);
+                    /* queue for free */
+                    pSig->pNext = pSigToFree;
+                    pSigToFree = pSig;
 
                     /* next */
@@ -822 +872 @@
                 }
             }
-            __libc_back_signalSemRelease();
-        }
-    }
-    LIBCLOG_RETURN_VOID();
-}
-
-
-/**
- * Reschedule signals.
- * Typically called after a block mask have been updated.
- *
- * @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.
- */
-int __libc_back_signalReschedule(__LIBC_PTHREAD pThrd)
-{
-    LIBC_ASSERT(__libc_back_signalSemIsOwner());
-    signalScheduleSPM(pThrd);
-    signalScheduleProcess(pThrd);
-    return signalDeliver(pThrd, 0, NULL);
+
+            pSig = NULL;
+        }
+
+        /*
+         * Raise the signal the normal way.
+         */
+        rc = __libc_Back_signalRaise(iSignalNo, pSigInfo, pSig, __LIBC_BSRF_QUEUED);
+        __libc_back_signalSemRelease();
+        if (rc > 0)
+            rc = 0;
+    }
+
+    /*
+     * Cleanup and return.
+     */
+    while (pSigToFree)
+    {
+        void *pvToFree = pSigToFree;
+        pSigToFree = pSigToFree->pNext;
+        free(pvToFree);
+    }
+    LIBCLOG_RETURN_INT(rc);
 }
 

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

@@ -49 +49 @@
 void        __libc_back_signalPokeProcess(void);
 int         __libc_back_signalReschedule(__LIBC_PTHREAD pThrd);
+int         __libc_back_signalQueueSelf(int iSignalNo, siginfo_t *pSigInfo);
 int         __libc_back_signalSuspend(void);
 int         __libc_back_signalAccept(__LIBC_PTHREAD pThrd, int iSignalNo, sigset_t *pSigSet, siginfo_t *pSigInfo);