* ctdl_internal_thread_func(): just use SYS_gettid if the system provides it. thit...

[citadel.git] / citadel / threads.c

diff --git a/citadel/threads.c b/citadel/threads.c
index e115306a2e1ed640719304008ec6f7d3fefd6c2d..b3f13a02e37e850f305e1b01c2412c5f7c36acc9 100644 (file)
--- a/citadel/threads.c
+++ b/citadel/threads.c
@@ -18,6 +18,7 @@
 #include <fcntl.h>
 #include <signal.h>
 
+#include "sysdep.h"
 #if TIME_WITH_SYS_TIME
 # include <sys/time.h>
 # include <time.h>
@@ -29,6 +30,14 @@
 # endif
 #endif
 
+#ifdef HAVE_SYSCALL_H
+# include <syscall.h>
+#else 
+# if HAVE_SYS_SYSCALL_H
+#  include <sys/syscall.h>
+# endif
+#endif
+
 #include <libcitadel.h>
 
 #include "threads.h"
@@ -345,10 +354,9 @@ void CtdlThreadStopAll(void)
        GC_thread->state = CTDL_THREAD_STOP_REQ;
        while(this_thread)
        {
-#ifdef THREADS_USESIGNALS
                if (!citthread_equal(this_thread->tid, GC_thread->tid))
                        citthread_kill(this_thread->tid, SIGHUP);
-#endif
+
                ctdl_thread_internal_change_state (this_thread, CTDL_THREAD_STOP_REQ);
                citthread_cond_signal(&this_thread->ThreadCond);
                citthread_cond_signal(&this_thread->SleepCond);
@@ -410,16 +418,18 @@ double CtdlThreadGetWorkerAvg(void)
 
 double CtdlThreadGetLoadAvg(void)
 {
-       double load_avg[3] ;
+       double load_avg[3] = {0.0, 0.0, 0.0};
 
-       int ret;
+       int ret = 0;
        int smp_num_cpus;
 
        /* Borrowed this straight from procps */
        smp_num_cpus = sysconf(_SC_NPROCESSORS_ONLN);
        if(smp_num_cpus<1) smp_num_cpus=1; /* SPARC glibc is buggy */
 
+#ifdef HAVE_GETLOADAVG
        ret = getloadavg(load_avg, 3);
+#endif
        if (ret < 0)
                return 0;
        return load_avg[0] / smp_num_cpus;
@@ -508,13 +518,13 @@ int CtdlThreadCheckStop(void)
        
        state = CT->state;
 
-#ifdef THREADS_USESIGNALS
        if (CT->signal)
        {
                CtdlLogPrintf(CTDL_DEBUG, "Thread \"%s\" caught signal %d.\n", CT->name, CT->signal);
+               if (CT->signal == SIGHUP)
+                       CT->state = CTDL_THREAD_STOP_REQ;
                CT->signal = 0;
        }
-#endif
        if(state == CTDL_THREAD_STOP_REQ)
        {
                CT->state = CTDL_THREAD_STOPPING;
@@ -544,10 +554,10 @@ void CtdlThreadStop(CtdlThreadNode *thread)
                return;
        if (!(this_thread->thread_func))
                return;         // Don't stop garbage collector
-#ifdef THREADS_USESIGNALS
+
        if (!citthread_equal(this_thread->tid, GC_thread->tid))
                citthread_kill(this_thread->tid, SIGHUP);
-#endif
+
        ctdl_thread_internal_change_state (this_thread, CTDL_THREAD_STOP_REQ);
        citthread_cond_signal(&this_thread->ThreadCond);
        citthread_cond_signal(&this_thread->SleepCond);
@@ -593,10 +603,20 @@ static void ctdl_internal_thread_cleanup(void *arg)
         * In here we were called by the current thread because it is exiting
         * NB. WE ARE THE CURRENT THREAD
         */
-       CtdlLogPrintf(CTDL_NOTICE, "Thread \"%s\" (0x%08lx) exited.\n", CT->name, CT->tid);
+       if (CT)
+       {
+               const char *name = CT->name;
+               const pid_t tid = CT->tid;
+
+               CtdlLogPrintf(CTDL_NOTICE, "Thread \"%s\" (0x%08lx) exited.\n", name, tid);
+       }
+       else 
+       {
+               CtdlLogPrintf(CTDL_NOTICE, "some ((unknown ? ? ?) Thread exited.\n");
+       }
        
        #ifdef HAVE_BACKTRACE
-       eCrash_UnregisterThread();
+///    eCrash_UnregisterThread();
        #endif
        
        citthread_mutex_lock(&CT->ThreadMutex);
@@ -661,7 +681,7 @@ void CtdlThreadGC (void)
        CtdlThreadNode *this_thread, *that_thread;
        int workers = 0, sys_workers;
        int ret=0;
-       
+
        begin_critical_section(S_THREAD_LIST);
        
        /* Handle exiting of garbage collector thread */
@@ -824,10 +844,13 @@ static void *ctdl_internal_thread_func (void *arg)
        
        // Register for tracing
        #ifdef HAVE_BACKTRACE
-       eCrash_RegisterThread(this_thread->name, 0);
+///    eCrash_RegisterThread(this_thread->name, 0);
        #endif
        
        // Tell the world we are here
+#if defined(HAVE_SYSCALL_H) && defined (SYS_gettid)
+       this_thread->reltid = syscall(SYS_gettid);
+#endif
        CtdlLogPrintf(CTDL_NOTICE, "Created a new thread \"%s\" (0x%08lx).\n",
                this_thread->name, this_thread->tid);
        
@@ -978,7 +1001,6 @@ CtdlThreadNode *ctdl_internal_create_thread(char *name, long flags, void *(*thre
                free(this_thread);
                return NULL;
        }
-       
        num_threads++;  // Increase the count of threads in the system.
        if(this_thread->flags & CTDLTHREAD_WORKER)
                num_workers++;
@@ -1265,8 +1287,10 @@ void go_threading(void)
        ctdl_thread_internal_init();
 
        /* Second call to module init functions now that threading is up */
-       if (!statcount)
+       if (!statcount) {
                initialise_modules(1);
+               CtdlThreadCreate("select_on_master", CTDLTHREAD_BIGSTACK, select_on_master, NULL);
+       }
        else {
                CtdlLogPrintf(CTDL_EMERG, "Running connection simulation stats\n");
                gettimeofday(&start, NULL);