Changeset 1575 for trunk/src

Timestamp:

Oct 10, 2004, 1:14:29 PM (21 years ago)

Author:

bird

Message:

Signal changes - enabled by NEW_SIGNALS.

File:

• trunk/src/emx/src/lib/process/thread_internals.c (modified) (9 diffs, 1 prop)

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

@@ -35 +35 @@
 #include <errno.h>
 #include <sys/smutex.h>
+#include <sys/builtin.h>
+#include <sys/fmutex.h>
 #include <emx/umalloc.h>
 #include <emx/syscalls.h>
 #include <InnoTekLIBC/thread.h>
 #include <InnoTekLIBC/backend.h>
+#include <InnoTekLIBC/signals.h>
 #define __LIBC_LOG_GROUP __LIBC_LOG_GRP_THREAD
 #include <InnoTekLIBC/logstrict.h>
@@ -51 +54 @@
 static int              gfPreAllocThrd;
 
+/** Mutex for the thread database. */
+static _fmutex          gmtxThrdDB;
+/** Thread database. (Protected gmtxThrdDB.) */
+static __LIBC_PTHREAD   gpThrdDB;
+/** Number of threads in the thread database. (Protected gmtxThrdDB.) */
+static unsigned         gcThrdDBEntries;
+/** Zombie thread database. (Protected gmtxThrdDB.) */
+static __LIBC_PTHREAD   gpThrdDBZombies;
+/** Number of threads in the zombie thread database. (Protected gmtxThrdDB.) */
+static unsigned         gcThrdDBZombies;
+
 /** Head of the thread termination callback list. */
 static __LIBC_PTHREADTERMCBREGREC   gpTermHead;
@@ -63 +77 @@
  * Initialize a thread structure.
  *
- * @param   pThrd   Pointer to the thread structure which is to be initialized.
+ * @param   pThrd       Pointer to the thread structure which is to be initialized.
+ * @param   pParentThrd Pointer to the thread structure for the parent thread.
+ *                      If NULL and thread id is 1 then inherit from parent process.
+ *                      If NULL and thread is not null or no record of parent then
+ *                      use defaults.
  */
-static void threadInit(__LIBC_PTHREAD pThrd)
+static void threadInit(__LIBC_PTHREAD pThrd, const __LIBC_PTHREAD pParentThrd)
 {
     bzero(pThrd, sizeof(*pThrd));
     pThrd->iRand = 1;
-    __libc_Back_threadInit(pThrd);
+    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);
+}
+
+
+void __libc_threadUse(__LIBC_PTHREAD pThrd)
+{
+    LIBCLOG_ENTER("pThrd=%p\n", (void *)pThrd);
+    int     rc;
+
+    /*
+     * Check that pThrd isn't already in use and set gpTLS to point at pThrd.
+     */
+    assert(!pThrd->pNext && !pThrd->tid && !*__libc_gpTLS);
+    *__libc_gpTLS = pThrd;
+
+    /*
+     * Set the thread id of this thread.
+     */
+    pThrd->tid = _gettid();
+
+    /*
+     * Insert this thread into the thread database.
+     * Note that there might be a dead thread by the same id in the database.
+     * This have to be removed of course.
+     */
+    /** @todo rewrite to use a read/write semaphore, not mutex. */
+    if (gmtxThrdDB.fs == _FMS_UNINIT)
+        _fmutex_create(&gmtxThrdDB, 0);
+
+    rc = _fmutex_request(&gmtxThrdDB, 0);
+    if (!rc)
+    {
+        /* Remove any zombie threads. */
+        __LIBC_PTHREAD pPrev = NULL;
+        __LIBC_PTHREAD p = gpThrdDB;
+        while (p)
+        {
+            if (p->tid == pThrd->tid)
+            {
+                /* remove it and place it in the zombie list */
+                __LIBC_PTHREAD pNext = p->pNext;
+                if (pPrev)
+                    pPrev->pNext = pNext;
+                else
+                    gpThrdDB = pNext;
+                gcThrdDBEntries--;
+
+                p->pNext = gpThrdDBZombies;
+                gpThrdDBZombies = p;
+                gcThrdDBZombies++;
+                p = pNext;
+                /* paranoid as always, we continue scanning the entire list. */
+            }
+            else
+            {
+                /* next */
+                pPrev = p;
+                p = p->pNext;
+            }
+        }
+
+        /* Insert it */
+        pThrd->pNext = gpThrdDB;
+        gpThrdDB = pThrd;
+        gcThrdDBEntries++;
+
+        _fmutex_release(&gmtxThrdDB);
+    }
+
+    LIBCLOG_RETURN_VOID();
 }
 
@@ -81 +198 @@
         /*
          * Setup a temporary thread block on the stack so _hmalloc()
-         * can't end up calling us recursivly if something goes wrong
+         * can't end up calling us recursivly if something goes wrong.
          */
         __LIBC_THREAD   Thrd;
-        threadInit(&Thrd);
+        threadInit(&Thrd, NULL);
         *__libc_gpTLS   = &Thrd;
 
@@ -92 +209 @@
         {
             pThrd = _hmalloc(sizeof(__LIBC_THREAD));
-            assert(pThrd); /* deep, deep, depp, shit. abort the process in a controlled manner... */
+            assert(pThrd); /* deep, deep, deep, shit. abort the process in a controlled manner... */
         }
         *pThrd = Thrd;
 
-        *__libc_gpTLS = pThrd;
-        LIBCLOG_MSG("Created thread block %p\n", pThrd);
+        __libc_threadUse(pThrd);
+        LIBCLOG_MSG("Created thread block %p\n", (void*)pThrd);
     }
 
@@ -113 +230 @@
     __LIBC_PTHREAD pThrd = _hmalloc(sizeof(__LIBC_THREAD));
     if (pThrd)
-        threadInit(pThrd);
+        threadInit(pThrd, __libc_threadCurrentNoAuto());
     LIBCLOG_RETURN_P(pThrd);
 }
 
 
-void  __libc_threadFree(__LIBC_PTHREAD pThrd)
-{
-    LIBCLOG_ENTER("pThrd=%p\n", (void *)pThrd);
-    /*
-     * Clean up members.
-     */
-    __libc_Back_threadCleanup(pThrd);
-
-    /*
-     * Release storage.
-     */
-    if (pThrd != &gPreAllocThrd)
-        free(pThrd);
-    else
-        __lxchg(&gfPreAllocThrd, 0);
-    LIBCLOG_RETURN_VOID();
-}
-
+void __libc_threadDereference(__LIBC_PTHREAD pThrd)
+{
+    LIBCLOG_ENTER("pThrd=%p (tid=%d)\n", (void *)pThrd, pThrd->tid);
+    /*
+     * Take owner ship of the DB semaphore.
+     */
+    _fmutex_request(&gmtxThrdDB, 0);
+    if (pThrd->cRefs)
+        pThrd->cRefs--;
+    if (pThrd->cRefs)
+    {
+#ifdef DEBUG_LOGGING
+        unsigned cRefs = pThrd->cRefs;
+#endif
+        _fmutex_release(&gmtxThrdDB);
+        LIBCLOG_RETURN_MSG_VOID("ret void. cRefs=%d\n", cRefs);
+    }
+    LIBCLOG_MSG("unlinking and disposing the thread.\n");
+
+    /*
+     * Thread is dead, unlink it.
+     */
+    if (pThrd->tid)
+    {
+        if (pThrd == gpThrdDB)
+        {
+            gpThrdDB = pThrd->pNext;
+            gcThrdDBEntries--;
+        }
+        else
+        {
+            __LIBC_PTHREAD p;
+            for (p = gpThrdDB; p->pNext; p = p->pNext)
+                if (p->pNext == pThrd)
+                {
+                    p->pNext = pThrd->pNext;
+                    gcThrdDBEntries--;
+                    p = NULL;
+                    break;
+                }
+
+            /* not found? search zombie DB. */
+            if (p)
+            {
+                if (gpThrdDBZombies == pThrd)
+                {
+                    gpThrdDBZombies = pThrd->pNext;
+                    gcThrdDBZombies--;
+                }
+                else
+                {
+                    for (p = gpThrdDBZombies; p->pNext; p = p->pNext)
+                        if (p->pNext == pThrd)
+                        {
+                            p->pNext = pThrd->pNext;
+                            gcThrdDBZombies--;
+                            p = NULL;
+                            break;
+                        }
+                }
+            }
+
+            assert(p);                      /* it must be found! */
+            if (p)
+                pThrd = NULL;
+        }
+    }
+
+    _fmutex_release(&gmtxThrdDB);
+
+
+    /*
+     * Dispose of the thread
+     */
+    if (pThrd)
+    {
+        /*
+         * Clean up members.
+         */
+        __libc_Back_threadCleanup(pThrd);
+
+        /*
+         * Clear the TLS if it's for the current thread.
+         */
+        if (*__libc_gpTLS == pThrd)
+            *__libc_gpTLS = NULL;
+
+        /*
+         * Release storage.
+         */
+        if (pThrd != &gPreAllocThrd)
+            free(pThrd);
+        else
+            __lxchg(&gfPreAllocThrd, 0);
+    }
+
+    LIBCLOG_RETURN_MSG_VOID("ret (gcThrdDBEntires=%d gcThrdDBZombies=%d)\n", gcThrdDBEntries, gcThrdDBZombies);
+}
+
+
+__LIBC_PTHREAD __libc_threadLookup(unsigned tid)
+{
+    LIBCLOG_ENTER("tid=%d\n", tid);
+    int             rc;
+    __LIBC_PTHREAD  pThrd;
+
+    /* can't search something which isn't there. */
+    if (gmtxThrdDB.fs == _FMS_UNINIT)
+        LIBCLOG_RETURN_P(NULL);
+
+    rc = _fmutex_request(&gmtxThrdDB, 0);
+    if (rc)
+        LIBCLOG_RETURN_MSG(NULL, "ret NULL (fmutex f**ked. rc=%d)\n", rc);
+
+    for (pThrd = gpThrdDB; pThrd; pThrd = pThrd->pNext)
+        if (pThrd->tid == tid)
+        {
+            pThrd->cRefs++;
+            break;
+        }
+
+    _fmutex_release(&gmtxThrdDB);
+
+    LIBCLOG_RETURN_P(pThrd);
+}
+
+
+__LIBC_PTHREAD __libc_threadLookup2(int (pfnCallback)(__LIBC_PTHREAD pCur, __LIBC_PTHREAD pBest, void *pvParam), void *pvParam)
+{
+    LIBCLOG_ENTER("pfnCallback=%p pvParam=%p\n", (void *)pfnCallback, pvParam);
+    int             rc;
+    __LIBC_PTHREAD  pThrd;
+    __LIBC_PTHREAD  pBest = NULL;
+
+    /* can't search something which isn't there. */
+    if (gmtxThrdDB.fs == _FMS_UNINIT)
+        LIBCLOG_RETURN_P(NULL);
+
+    rc = _fmutex_request(&gmtxThrdDB, 0);
+    if (rc)
+        LIBCLOG_RETURN_MSG(NULL, "ret NULL (fmutex f**ked. rc=%d)\n", rc);
+
+    for (pThrd = gpThrdDB; pThrd; pThrd = pThrd->pNext)
+    {
+        rc = pfnCallback(pThrd, pBest, pvParam);
+        if (rc == 0)
+            continue;
+        else if (rc == 1)
+        {
+            pBest = pThrd;
+            continue;
+        }
+        else if (rc == 2)
+        {
+            pBest = pThrd;
+            break;
+        }
+        else if (rc == -1)
+            break;
+        else
+        {
+            LIBC_ASSERTM_FAILED("Callback returned %d, allowed values are 2, 1, 0 and -1!\n", rc);
+            break;
+        }
+    }
+
+    if (pBest)
+        pBest->cRefs++;
+
+    _fmutex_release(&gmtxThrdDB);
+
+    LIBCLOG_RETURN_MSG(pBest, "ret %p (tid=%d)\n", (void *)pBest, pBest ? pBest->tid : 0);
+}
+
+
+
+int         __libc_threadEnum(int (pfnCallback)(__LIBC_PTHREAD pCur, void *pvParam), void *pvParam)
+{
+    LIBCLOG_ENTER("pfnCallback=%p pvParam=%p\n", (void *)pfnCallback, pvParam);
+    int             rc;
+    __LIBC_PTHREAD  pThrd;
+
+    /* can't search something which isn't there. */
+    if (gmtxThrdDB.fs == _FMS_UNINIT)
+        LIBCLOG_RETURN_P(NULL);
+
+    rc = _fmutex_request(&gmtxThrdDB, 0);
+    if (rc)
+        LIBCLOG_RETURN_MSG(NULL, "ret NULL (fmutex f**ked. rc=%d)\n", rc);
+
+    for (pThrd = gpThrdDB; pThrd; pThrd = pThrd->pNext)
+    {
+        rc = pfnCallback(pThrd, pvParam);
+        if (rc == 0)
+            continue;
+        else if (rc == -1)
+            break;
+        else
+        {
+            LIBC_ASSERTM_FAILED("Callback returned %d, allowed values are 0 and -1!\n", rc);
+            break;
+        }
+    }
+
+    _fmutex_release(&gmtxThrdDB);
+
+    LIBCLOG_RETURN_INT(rc);
+}
 
 int     __libc_ThreadRegisterTermCallback(__LIBC_PTHREADTERMCBREGREC pRegRec)
@@ -151 +458 @@
         ||  pRegRec->fFlags)
     {
-        LIBC_ASSERTM(!pRegRec->pNext, "pNext must be NULL not %p\n", pRegRec->pNext);
+        LIBC_ASSERTM(!pRegRec->pNext, "pNext must be NULL not %p\n", (void * )pRegRec->pNext);
         LIBC_ASSERTM(pRegRec->pfnCallback, "pfnCallback not be NULL\n");
         LIBC_ASSERTM(!pRegRec->fFlags, "fFlags must be ZERO not %u\n", pRegRec->fFlags);
@@ -175 +482 @@
     {
         _smutex_release(&gsmtxTerm);
-        LIBC_ASSERTM_FAILED("Double registration of %p\n", pRegRec);
+        LIBC_ASSERTM_FAILED("Double registration of %p\n", (void *)pRegRec);
         LIBCLOG_RETURN_INT(-1);
     }
@@ -201 +508 @@
     {
         /* call it */
-        LIBCLOG_MSG("calling %p with %p\n", pCur->pfnCallback, pCur);
+        LIBCLOG_MSG("calling %p with %p\n", (void *)pCur->pfnCallback, (void *)pCur);
         pCur->pfnCallback(pCur, fFlags);