Changeset 1631

Timestamp:

Nov 14, 2004, 8:03:24 PM (21 years ago)

Author:

bird

Message:

Bugfixing signals and stuff.

Location:

trunk/src/emx

Files:

• include/InnoTekLIBC/sharedpm.h (modified) (1 diff, 1 prop)
• src/lib/process/beginthr.c (modified) (1 diff, 1 prop)
• src/lib/process/waitpid.c (modified) (2 diffs, 1 prop)
• src/lib/sys/__select.c (modified) (6 diffs, 1 prop)
• src/lib/sys/__spawnve.c (modified) (2 diffs, 1 prop)
• src/lib/sys/b_process.h (modified) (1 diff, 1 prop)
• src/lib/sys/b_processWait.c (modified) (22 diffs, 1 prop)
• src/lib/sys/b_signalStack.c (modified) (1 diff, 1 prop)
• src/lib/sys/backend.h (modified) (1 diff, 1 prop)
• src/lib/sys/libcfork.c (modified) (3 diffs, 1 prop)
• src/lib/sys/sharedpm.c (modified) (5 diffs, 1 prop)
• src/lib/sys/signals.c (modified) (11 diffs, 1 prop)

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

@@ -675 +675 @@
 
 /**
+ * Validates a process group id.
+ *
+ * @returns 0 if valid.
+ * @returns -ESRCH if not valid.
+ * @param   pgrp            Process group id to validate. 0 if the same as
+ *                          the same as the current process.
+ * @param   fOnlyChildren   Restrict the search to immediate children.
+ */
+int __libc_spmValidPGrp(pid_t pgrp, int fOnlyChildren);
+
+
+/**
  * Identificators which can be obtained using __libc_spmGetId().
  */

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

@@ -101 +101 @@
     int rc = __libc_back_threadCreate(pfnStart, cbStack, pvArg, 0);
     if (rc >= 0)
-        LIBCLOG_RETURN_INT(-1);
+        LIBCLOG_RETURN_INT(rc);
     errno = -rc;
     LIBCLOG_RETURN_INT(-1);

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

@@ -84 +84 @@
     /* do the call */
     siginfo_t SigInfo = {0};
-    int rc = waitid(P_ALL, 0, &SigInfo, WEXITED);
+    int rc = waitid(P_ALL, 0, &SigInfo, fOptions | WEXITED);
     if (!rc)
     {
@@ -108 +108 @@
                            SigInfo.si_pid, SigInfo.si_pid, iStatus);
     }
-    errno = -rc;
-    LIBCLOG_RETURN_INT(-1);
+    LIBCLOG_RETURN_INT(rc);
 }
 

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

@@ -27 +27 @@
 #include "libc-alias.h"
 #define INCL_FSMACROS
-#define INCL_DOSPROCESS
+#define INCL_DOSSEMAPHORES
+#define INCL_ERRORS
 #include <os2emx.h>
 #include <stdlib.h>
@@ -37 +38 @@
 #include <emx/syscalls.h>
 #include "syscalls.h"
+#include "backend.h"
 
 
@@ -48 +50 @@
     int rc;
     if (!tv)
-        rc = DosSleep(~0);
+        rc = DosWaitEventSem(__libc_back_ghevWait, SEM_INDEFINITE_WAIT);
     else
     {
@@ -54 +56 @@
         if (!cMillies && tv->tv_usec)
             cMillies = 1;
-        rc = DosSleep(cMillies);
+        rc = DosWaitEventSem(__libc_back_ghevWait, cMillies);
     }
     FS_RESTORE();
@@ -61 +63 @@
      * Return.
      */
-    if (!rc)
+    if (!rc || rc == ERROR_TIMEOUT || rc == ERROR_SEM_TIMEOUT)
         return 0;
     errno = __libc_native2errno(rc);
@@ -174 +176 @@
         rc = pfnSelect(nfds, readfds, writefds, exceptfds, tv, &rc2);
     }
-    else if (tv)
-    {
-        FS_VAR();
-        /* wait for the given amount of time. */
-        rc2 = rc = 0;
-        FS_SAVE_LOAD();
-        DosSleep(tv->tv_sec * 1000 + tv->tv_usec / 1000);
-        FS_RESTORE();
-    }
     else
     {

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

@@ -275 +275 @@
 
             /*
-             * Notify the process waiter system.
-             */
-            __libc_back_processWaitNotifyExec();
-
-            /*
              * Create the process.
              */
@@ -290 +285 @@
                 __atomic_cmpxchg32((volatile uint32_t *)(void *)&pEmbryo->pid, (uint32_t)resc.codeTerminate, 0);
                 LIBCLOG_MSG("Spawned pid=%04lx (%ld)\n", resc.codeTerminate, resc.codeTerminate);
+                __libc_back_processWaitNotifyExec(resc.codeTerminate);
 
                 /* cleanup embryo and other stuff. */

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

@@ -37 +37 @@
 
 void __libc_back_processWaitNotifyTerm(void);
-void __libc_back_processWaitNotifyExec(void);
+void __libc_back_processWaitNotifyExec(pid_t pid);
 void __libc_back_processWaitNotifyChild(siginfo_t *pSigInfo);
 void __libc_back_processWaitNotifyNoWait(int fNoWaitStatus);

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

@@ -84 +84 @@
 
 
+/** Pointer to child process info node. */
+typedef struct WAITCHILD *PWAITCHILD;
+/**
+ * Child Process info node.
+ */
+typedef struct WAITCHILD
+{
+    /** Pointer to the next one. */
+    volatile PWAITCHILD pNext;
+    /** Process Id. */
+    pid_t               pid;
+} WAITCHILD;
+
 
 /*******************************************************************************
@@ -102 +115 @@
 /** Index into the preallocated nodes. */
 static volatile unsigned    giWaitPreAlloced;
+/** List of known children. */
+static volatile PWAITCHILD  gpChildrenHead;
+/** Number of known child processes. */
+static volatile unsigned    gcChildren;
+/** Total number of born child processes. */
+static volatile unsigned    gcBirths;
+/** Total number of died child processes. */
+static volatile unsigned    gcDeaths;
 
 /** If this flag is set we don't care for wait status info.
@@ -110 +131 @@
 /** The event semaphore the callers are sleeping on. */
 static volatile HEV         ghevWait;
+/** The event semaphore the wait thread are sleeping on. */
+static volatile HEV         ghevBirth;
 
 /** Thread ID of the wait thread. */
 static volatile TID         gtidThread;
 /** Termination indicator. Used to help the wait thread terminate fast. */
-static volatile int         gfTerminate;
+static volatile unsigned    gfTerminate;
 
 
@@ -146 +169 @@
         if (rc)
             abort();
+        rc = DosCreateEventSemEx(NULL, (PHEV)&ghevBirth, 0, FALSE);
+        if (rc)
+            abort();
+
 
         /* done */
@@ -164 +191 @@
     {
         /* kill the thread */
-        gfTerminate = TRUE;
+        __atomic_xchg(&gfTerminate, 1);
+        DosKillThread(gtidThread);
         gtidThread = 0;
-        DosKillThread(gtidThread);
-
-        /* destroy the event semaphore. */
-        HEV hev = ghevWait;
-        ghevWait = NULLHANDLE;
-        if (hev)
-            DosPostEventSem(hev);
+    }
+
+    /* destroy the birth event semaphore. */
+    HEV hev = ghevBirth;
+    ghevBirth = NULLHANDLE;
+    if (hev)
+    {
+        DosPostEventSem(hev);
+        DosCloseEventSem(hev);
+    }
+
+    /* destroy the wait event semaphore. */
+    hev = ghevWait;
+    ghevWait = NULLHANDLE;
+    if (hev)
+    {
+        DosPostEventSem(hev);
+        DosCloseEventSem(hev);
     }
 }
@@ -218 +257 @@
     pWait->pNext = NULL;
     pWait->pPrev = gpWaitTail;
-    if (!pWait->pPrev)
+    if (pWait->pPrev)
+        pWait->pPrev->pNext = pWait;
+    else
         gpWaitHead = pWait;
     gpWaitTail = pWait;
@@ -233 +274 @@
     PTIB        pTib;
     DosGetInfoBlocks(&pTib, &pPib);
+    DosSetPriority(PRTYS_THREAD, PRTYC_REGULAR, 1, 0);
 
     /*
@@ -240 +282 @@
     for (;!gfTerminate;)
     {
-        for (;!gfTerminate;)
-        {
+        /*
+         * Check for exit condition.
+         */
+        fInternalTerm = gfTerminate;
+        if (pPib->pib_flstatus & (0x40/*dying*/ | 0x04/*exiting all*/ | 0x02/*Exiting Thread 1*/ | 0x01/*ExitList */))
+        {
+            LIBCLOG_MSG("Terminating thread, exit conditions detected. pib_flstatus=%#lx\n",  pPib->pib_flstatus);
+            fInternalTerm = 1;
+        }
+
+        /*
+         * Wait for children.
+         */
+        WAITINFO Wait;
+        int rc = waitChild(&Wait, fInternalTerm, 0 /* any child */);
+        if (!rc)
+        {
+            /* enter semaphore protection. */
+            rc = waitSemRequest(1);
+
             /*
-             * Check for exit condition.
+             * Need we bother inserting it?
              */
-            fInternalTerm = gfTerminate;
-            if (pPib->pib_flstatus & (0x40/*dying*/ | 0x04/*exiting all*/ | 0x02/*Exiting Thread 1*/ | 0x01/*ExitList */))
+            if (!gfNoWaitStatus)
+                waitAllocInsert(&Wait);
+
+            /*
+             * Increment death number and decrement number of (known) children.
+             */
+            __atomic_increment(&gcDeaths);
+
+            /*
+             * Remove the child from the list.
+             */
+            PWAITCHILD pPrev = NULL;
+            PWAITCHILD pChild = gpChildrenHead;
+            while (pChild)
             {
-                LIBCLOG_MSG("Terminating thread, exit conditions detected. pib_flstatus=%#lx\n",  pPib->pib_flstatus);
-                fInternalTerm = TRUE;
+                if (pChild->pid == Wait.pid)
+                {
+                    if (pPrev)
+                        pPrev->pNext = pChild->pNext;
+                    else
+                        gpChildrenHead = pChild->pNext;
+                    __atomic_decrement_min(&gcChildren, 0);
+                    break;
+                }
+
+                /* next */
+                pPrev = pChild;
+                pChild = pChild->pNext;
             }
 
             /*
-             * Wait for children.
+             * Wake up any waiters.
              */
-            WAITINFO Wait;
-            int rc = waitChild(&Wait, fInternalTerm, 0 /* any child */);
+            if (DosPostEventSem(ghevWait) == ERROR_INVALID_HANDLE)
+                fInternalTerm = 1;
+
+            /*
+             * Leave semaphore protection and wait again unless someone's hinting it's time to quit...
+             */
             if (!rc)
-            {
-                /*
-                 * Need we bother inserting it?
-                 */
-                rc = waitSemRequest(1);
-                if (!rc && !gfNoWaitStatus)
-                    rc = waitAllocInsert(&Wait);
-
-                /*
-                 * Wake up any waiters.
-                 */
-                int rcOS2 = DosPostEventSem(ghevWait);
-                if (!rc)
-                    waitSemRelease();
-                if (rc || (rcOS2 && rcOS2 != ERROR_TOO_MANY_POSTS && rcOS2 != ERROR_ALREADY_POSTED))
-                    fInternalTerm = 1;
-                rc = 0;
-            }
-            if (rc || fInternalTerm)
+                waitSemRelease();
+            if (fInternalTerm)
                 break;
-        }
-
-        /*
-         * Check if we're encouraged to quit.
-         */
-        if (fInternalTerm || gfTerminate)
-            break;
+            continue;
+        }
 
         /*
@@ -293 +358 @@
          * using the nowait option on the API call.
          */
+        if (fInternalTerm || gfTerminate)
+            break;
         if (pPib->pib_flstatus & (0x40/*dying*/ | 0x04/*exiting all*/ | 0x02/*Exiting Thread 1*/ | 0x01/*ExitList */))
         {
             LIBCLOG_MSG("Terminating thread, exit conditions detected. pib_flstatus=%#lx\n",  pPib->pib_flstatus);
-            fInternalTerm = TRUE;
+            fInternalTerm = 1;
             continue;
         }
 
-        DosWaitEventSem(ghevWait, 30*1000);
+        if (rc == ERROR_WAIT_NO_CHILDREN)
+        {
+            DosWaitEventSem(ghevBirth, 5*1000);
+            ULONG cIgnore;
+            if (DosResetEventSem(ghevBirth, &cIgnore) == ERROR_INVALID_HANDLE)
+                fInternalTerm = 1;
+        }
+        else
+            LIBC_ASSERTM_FAILED("waitChild -> rc=%d expected ERROR_WAIT_NO_CHILDREN!\n", rc);
     }
 
@@ -485 +560 @@
  * it's time to start collect child status codes.
  */
-void __libc_back_processWaitNotifyExec(void)
-{
-    if (gtidThread)
-        return;
-
+void __libc_back_processWaitNotifyExec(pid_t pid)
+{
+    PWAITCHILD pChild = _hmalloc(sizeof(*pChild));
     waitSemRequest(0);
+
+    /*
+     * Tell wait thread that there is a child waiting.
+     */
+    if (pChild)
+    {
+        pChild->pid = pid;
+        pChild->pNext = gpChildrenHead;
+        gpChildrenHead = pChild;
+    }
+    __atomic_increment(&gcChildren);
+    __atomic_increment(&gcBirths);
+    int rc = DosPostEventSem(ghevBirth);
+    LIBC_ASSERTM(!rc, "DosPostEventSem(%#lx (birth)) -> %d\n", ghevBirth, rc);
+    rc = rc;
+
+    /*
+     * No wait thread? Create one.
+     */
     if (!gtidThread)
     {
@@ -500 +592 @@
         {
             gtidThread = tid;
-            LIBCLOG_MSG2("Create waitThread! tid=%#x (%d)\n", tid, tid);
+            LIBCLOG_MSG2("Created waitThread! tid=%#x (%d)\n", tid, tid);
         }
         else
@@ -509 +601 @@
         }
     }
+
     waitSemRelease();
 }
@@ -530 +623 @@
     __atomic_xchg(&gfNoWaitStatus, fNoWaitStatus);
 }
+
 
 /**
@@ -571 +665 @@
             /* insert it */
             waitInsertFIFO(pWait);
+            DosPostEventSem(ghevWait);
         }
         else
@@ -619 +714 @@
 
     /*
-     * Make sure there is a worker around.
-     */
-    if (!gtidThread)
-        __libc_back_processWaitNotifyExec();
-
-    /*
      * Validate options.
      */
@@ -676 +765 @@
         LIBCLOG_RETURN_MSG(rc, "%d mutex\n", rc);
     unsigned    cIterations = 0;
+    int         fInterrupted = 0;
     for (;; cIterations++)
     {
@@ -682 +772 @@
          */
         WAITINFO    Wait;
+        pid_t       pid = (pid_t)Id;
+        if (!pid && enmIdType == P_PGID)
+            pid = (pid_t)__libc_spmGetId(__LIBC_SPMID_PGRP);
         PWAITINFO   pInfo = gpWaitHead;
         while (pInfo)
@@ -712 +805 @@
             if (fFlag && (fFlag & fOptions))
             {
-                if (enmIdType == P_ALL)
-                    break;
-                if (    (enmIdType == P_PID  && pInfo->pid  == (pid_t)Id)
-                    ||  (enmIdType == P_PGID && pInfo->pgrp == (pid_t)Id))
+                if (    enmIdType == P_ALL
+                    ||  (enmIdType == P_PID  && pInfo->pid  == pid)
+                    ||  (enmIdType == P_PGID && pInfo->pgrp == pid))
                     break;
             }
@@ -755 +847 @@
                 waitInfoToSigInfo(&Wait, pSigInfo);
             /* return */
+            rc = 0;
             break;
         }
@@ -760 +853 @@
         /*
          * Verify the wait id (again).
-         */
+         *
+         * Because of the design we cannot use DosWaitChild to check if
+         * the process actually have any children. Which means we'll
+         * have to use some child counting and thread states to check this.
+         */
+        if (enmIdType == P_ALL)
+        {
+            /*
+             * It's enough to know that there are children around.
+             */
+            if (!gcChildren && !gpChildrenHead)
+            {
+                /** @todo Later we'll add support for waiting on processes spawned by direct calls to DosExecPgm.
+                 * Should call DosWaitChild to be 99% sure. */
+                waitSemRelease();
+                rc = -ECHILD;
+                break;
+            }
+        }
+        else if (enmIdType == P_PID)
+        {
+            /*
+             * In this case we'll have to make sure this PID exists
+             * AND that it's a child of ours.
+             */
+            PWAITCHILD pChild = gpChildrenHead;
+            for (;pChild; pChild = pChild->pNext)
+                if (pChild->pid == (pid_t)Id)
+                    break;
+            if (!pChild)
+            {
+                /** @todo Later we'll add support for waiting on processes spawned by direct calls to DosExecPgm.
+                 * Should call DosVerifyPidTid and DosGetPPid(). */
+                waitSemRelease();
+                rc = -ECHILD;           /* this ain't correct! */
+                break;
+            }
+        }
+        else
+        {
+            rc = __libc_spmValidPGrp((pid_t)Id, 1 /* only children */);
+            if (rc)
+            {
+                waitSemRelease();
+                rc = -ECHILD;
+                break;
+            }
+        }
         waitSemRelease();
-        if (    enmIdType == P_ALL
-            ||  enmIdType == P_PID)
-        {
-            /*
-             * All, or one specific, child process.
-             */
-            rc = waitChild(&Wait, 1 /* no wait */, enmIdType == P_PID ? (pid_t)Id : 0);
-            if (!rc)
-            {
-                /*
-                 * Need we bother inserting it?
-                 * Anyway we'll have to wake the other waiters so they can recheck
-                 * their stuff, like we're gonna do now.
-                 */
-                rc = waitSemRequest(1);
-                if (!rc && !gfNoWaitStatus)
-                    rc = waitAllocInsert(&Wait);
-                DosPostEventSem(ghevWait);
-                if (rc)
-                    break;
-                continue;
-            }
-        }
-        else
-        {
-            rc = __libc_Back_signalSendPGrp((pid_t)Id, 0);
-            if (rc)
-                LIBCLOG_RETURN_INT(rc);
-        }
-
-        /*
-         * Interpret OS/2 error codes.
-         */
-        if (rc == ERROR_NO_CHILDREN)
-            LIBCLOG_RETURN_INT(-ECHILD);
-        if (rc == ERROR_INVALID_PROCID)
-            LIBCLOG_RETURN_INT(-ESRCH);     /* waitid() -> EINVAL, wait[pid|3|4]() -> ECHILD */
-        if (rc == ERROR_NO_CHILD_PROCESS)
-            LIBCLOG_RETURN_INT(-EPERM);     /* waitid() -> EINVAL, wait[pid|3|4]() -> ECHILD */
-        if (rc != ERROR_CHILD_NOT_COMPLETE)
-            LIBCLOG_RETURN_MSG(-EINVAL, "%d (-EINVAL) OS/2 rc=%d\n", -EINVAL, rc);
-        if ((fOptions & WNOHANG))
-            LIBCLOG_RETURN_INT(-ECHILD);
+
+        /*
+         * Delayed interrupted condition.
+         */
+        if (fInterrupted)
+        {
+            rc = -EINTR;
+            break;
+        }
 
         /*
@@ -812 +918 @@
          * if it is we'll not gonna hang along here anylonger. Only 2nd and
          * subsequent iterations => 30 second timeout before deadlock is fixed.
-        */
+         */
         if (    cIterations >= 1
             &&  (pPib->pib_flstatus & (0x40/*dying*/ | 0x04/*exiting all*/ | 0x02/*Exiting Thread 1*/ | 0x01/*ExitList */))
@@ -819 +925 @@
         rc = DosWaitEventSem(ghevWait, 30*1000);
         if (rc == ERROR_INTERRUPT)
-            LIBCLOG_RETURN_INT(-EINTR);
-        if (!rc && rc != ERROR_TIMEOUT && rc != ERROR_SEM_TIMEOUT)
+            fInterrupted = 1;
+        else if (rc && rc != ERROR_TIMEOUT && rc != ERROR_SEM_TIMEOUT)
             LIBCLOG_RETURN_MSG(-EDEADLK, "%d (-DEADLK) waitsem -> rc=%d\n", -EDEADLK, rc);
 

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

@@ -76 +76 @@
             {
                 LIBC_ASSERTM_FAILED("ss_size=%d is too small. minimum size is %d\n", pStack->ss_size, MINSIGSTKSZ);
-                LIBCLOG_RETURN_INT(-EINVAL);
+                LIBCLOG_RETURN_INT(-ENOMEM);
             }
 

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

@@ -32 +32 @@
 __BEGIN_DECLS
 
+/** 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.
+ */
+extern unsigned long __libc_back_ghevWait;
+
 /**
  * Converts native error code to errno error code.

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

@@ -51 +51 @@
 #include "syscalls.h"
 #include "DosEx.h"
+#include "b_process.h"
 
 
@@ -403 +404 @@
                     forkParCompletionChild(pForkHandle, rc);
                 }
+
+                /*
+                 * Try reap the child in case of failure.
+                 */
+                if (rc < 0)
+                {
+                    FS_VAR();
+                    FS_SAVE_LOAD();
+                    RESULTCODES resc;
+                    PID         pibReaped;
+                    DosWaitChild(DCWA_PROCESS,DCWW_NOWAIT, &resc, &pibReaped, pid);
+                    FS_RESTORE();
+                }
             }
         }
@@ -417 +431 @@
      * Return.
      */
+    if (rc >= 0)
+        __libc_back_processWaitNotifyExec(pid);
+
     _fmutex_release(&__libc_gmtxExec);
     if (rc >= 0)

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

@@ -73 +73 @@
 #define __LIBC_LOG_GROUP    __LIBC_LOG_GRP_BACK_SPM
 #include <InnoTekLIBC/logstrict.h>
+#include "b_process.h"
 #include "syscalls.h"
 
@@ -268 +269 @@
          */
         spmReleaseMutex(&RegRec);
-        *pNotify = NotifyTmp;
-    }
-
+        *pNotifyOut = NotifyTmp;
+    }
+
+    LIBCLOG_RETURN_INT(rc);
+}
+
+/**
+ * Validates a process group id.
+ *
+ * @returns 0 if valid.
+ * @returns -ESRCH if not valid.
+ * @param   pgrp            Process group id to validate. 0 if the same as
+ *                          the same as the current process.
+ * @param   fOnlyChildren   Restrict the search to immediate children.
+ */
+int __libc_spmValidPGrp(pid_t pgrp, int fOnlyChildren)
+{
+    LIBCLOG_ENTER("pgrp=%#x (%d) fOnlyChildren=%d\n", pgrp, pgrp, fOnlyChildren);
+
+    /*
+     * Set return code and reason.
+     */
+    __LIBC_SPMXCPTREGREC    RegRec;
+    int rc = spmRequestMutex(&RegRec);
+    if (!rc)
+    {
+        /*
+         * Iterate all living processes looking for matching pgrps.
+         * Quit when we've found a match.
+         */
+        rc = -ESRCH;
+        pid_t pid = fOnlyChildren ? gpSPMSelf->pid : 0;
+        if (!pgrp)
+            pgrp = gpSPMSelf->pgrp;
+        __LIBC_PSPMPROCESS pProcess = gpSPMHdr->apHeads[__LIBC_PROCSTATE_ALIVE];
+        for (; pProcess; pProcess = pProcess->pNext)
+            if (    pProcess->pgrp == pgrp
+                &&  (!pid || pProcess->pidParent == pid))
+            {
+                rc = 0;
+                break;
+            }
+
+        spmReleaseMutex(&RegRec);
+    }
     LIBCLOG_RETURN_INT(rc);
 }
@@ -2009 +2052 @@
 {
     /*
+     * Notify the wait facilities.
+     */
+    __libc_back_processWaitNotifyTerm();
+
+    /*
      * Check if the memory is accessible, if it ain't we'll crash or do other
      * nasty things is the code below.
@@ -2265 +2313 @@
      */
     for (pProcess = gpSPMHdr->apHeads[enmState]; pProcess ; pProcess = pProcess->pNext)
-        if (pProcess->pid == pid && pProcess->enmState == enmState)
+        if (pProcess->pid == pid)
             LIBCLOG_RETURN_P(pProcess);
 
@@ -2428 +2476 @@
         pProcess->uVersion          = SPM_VERSION;
         pProcess->cReferences       = 1;
-        pProcess->enmState          = __LIBC_PROCSTATE_EMBRYO;
+        pProcess->enmState          = __LIBC_PROCSTATE_ALIVE;
         pProcess->pid               = pid;
         pProcess->pidParent         = pidParent;

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

@@ -85 +85 @@
 #include <InnoTekLIBC/logstrict.h>
 #include "syscalls.h"
+#include "backend.h"
 #include "b_signal.h"
 #include "b_process.h"
@@ -220 +221 @@
 static HMTX             ghmtxSignals;
 
-/** Signal Wait Event Semaphore.
+/** 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.
@@ -226 +227 @@
  * the exception and signal processing. DosWaitEventSem will return ERROR_INTERRUPT.
  */
-static HEV              ghevWait;
+HEV              __libc_back_ghevWait;
 
 static const char gaszSignalNames[__SIGSET_MAXSIGNALS][12] =
@@ -587 +588 @@
          * Create the wait semaphore.
          */
-        rc = DosCreateEventSemEx(NULL, &ghevWait, 0, 0);
+        rc = DosCreateEventSemEx(NULL, &__libc_back_ghevWait, 0, 0);
         if (!rc)
         {
@@ -1316 +1317 @@
         {
             /*
-             * Let's see if we can ignore it or successfully schedule it to a thread.
+             * Let's see if we can ignore it or successfully schedule it to a thread,
+             * or if it's SIGCHLD which might be required to get wait*() working right.
              */
             __LIBC_PTHREAD pThrdSig = NULL;
@@ -1322 +1324 @@
                 ||  (   gaSignalActions[iSignalNo].__sigaction_u.__sa_handler == SIG_DFL
                      && (gafSignalProperties[iSignalNo] & SPA_MASK) == SPA_IGNORE)
+                || iSignalNo == SIGCHLD
                 || (pThrdSig = signalScheduleThread(iSignalNo, pThrd)))
             {
@@ -1967 +1970 @@
     LIBCLOG_MSG("Calling DosExit(,127)\n");
     for (;;)
+    {
+        DosKillProcess(DKP_PROCESS, 0);
         DosExit(EXIT_THREAD, 127);
+    }
 }
 
@@ -2059 +2065 @@
     LIBCLOG_MSG("Calling DosExit(,127)\n");
     for (;;)
+    {
+        DosKillProcess(DKP_PROCESS, 0);
         DosExit(EXIT_THREAD, 127);
+    }
 }
 
@@ -2126 +2135 @@
      */
     __libc_back_signalSemRelease();
-    DosWaitEventSem(ghevWait, SEM_INDEFINITE_WAIT);
+    DosWaitEventSem(__libc_back_ghevWait, SEM_INDEFINITE_WAIT);
     return __libc_back_signalSemRequest();
 }
@@ -2179 +2188 @@
         SigInfo = *pSigInfo;
     SigInfo.si_signo        = iSignalNo;
-    if (pSigInfo)
+    if (!pSigInfo)
         SigInfo.si_code     = SI_USER;
     if (SigInfo.si_pid)
@@ -2982 +2991 @@
     for (;;)
     {
-        int rc = DosWaitEventSem(ghevWait, cMillies);
+        int rc = DosWaitEventSem(__libc_back_ghevWait, cMillies);
 
         /*