/*
- * $Id: sysdep.c 5882 2007-12-13 19:46:05Z davew $
+ * $Id$
*
* Citadel "system dependent" stuff.
- * See copyright.txt for copyright information.
+ * See COPYING for copyright information.
*
* Here's where we have the Citadel thread implimentation
*
*/
+#include <stdlib.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <sys/types.h>
#include <errno.h>
#include <sys/socket.h>
#include <unistd.h>
#include <fcntl.h>
+#include <signal.h>
#if TIME_WITH_SYS_TIME
# include <sys/time.h>
# endif
#endif
+#include <libcitadel.h>
+
#include "threads.h"
#include "ctdl_module.h"
#include "modules_init.h"
CtdlThreadNode *CtdlThreadList = NULL;
CtdlThreadNode *CtdlThreadSchedList = NULL;
-static citthread_t GC_thread;
+static CtdlThreadNode *GC_thread = NULL;
static char *CtdlThreadStates[CTDL_THREAD_LAST_STATE];
double CtdlThreadLoadAvg = 0;
double CtdlThreadWorkerAvg = 0;
int ret;
if ((ret = citthread_key_create(&ThreadKey, ctdl_thread_internal_dest_tsd))) {
- lprintf(CTDL_EMERG, "citthread_key_create: %s\n",
- strerror(ret));
+ CtdlLogPrintf(CTDL_EMERG, "citthread_key_create: %s\n", strerror(ret));
exit(CTDLEXIT_DB);
}
}
CtdlThreadNode *this_thread;
int ret = 0;
- GC_thread = citthread_self();
CtdlThreadStates[CTDL_THREAD_INVALID] = strdup ("Invalid Thread");
CtdlThreadStates[CTDL_THREAD_VALID] = strdup("Valid Thread");
CtdlThreadStates[CTDL_THREAD_CREATE] = strdup("Thread being Created");
this_thread->name = "Garbage Collection Thread";
- this_thread->tid = GC_thread;
+ this_thread->tid = citthread_self();
+ GC_thread = this_thread;
CT = this_thread;
num_threads++; // Increase the count of threads in the system.
begin_critical_section(S_THREAD_LIST);
this_thread = CtdlThreadList;
+ // Ask the GC thread to stop first so everything knows we are shutting down.
+ GC_thread->state = CTDL_THREAD_STOP_REQ;
while(this_thread)
{
#ifdef THREADS_USESIGNALS
- citthread_killl(this_thread->tid, SIGHUP);
+ 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);
- CtdlLogPrintf(CTDL_DEBUG, "Thread system stopping thread \"%s\" (%ld).\n", this_thread->name, this_thread->tid);
+ this_thread->stop_ticker = time(NULL);
+ CtdlLogPrintf(CTDL_DEBUG, "Thread system stopping thread \"%s\" (0x%08lx).\n",
+ this_thread->name, this_thread->tid);
this_thread = this_thread->next;
}
end_critical_section(S_THREAD_LIST);
state = CT->state;
-#ifdef THREADS_USERSIGNALS
+#ifdef THREADS_USESIGNALS
if (CT->signal)
+ {
CtdlLogPrintf(CTDL_DEBUG, "Thread \"%s\" caught signal %d.\n", CT->name, CT->signal);
+ CT->signal = 0;
+ }
#endif
if(state == CTDL_THREAD_STOP_REQ)
{
if (!(this_thread->thread_func))
return; // Don't stop garbage collector
#ifdef THREADS_USESIGNALS
- citthread_kill(this_thread->tid, SIGHUP);
+ 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);
+ this_thread->stop_ticker = time(NULL);
}
/*
* In here we were called by the current thread because it is exiting
* NB. WE ARE THE CURRENT THREAD
*/
- CtdlLogPrintf(CTDL_NOTICE, "Thread \"%s\" (%ld) exited.\n", CT->name, CT->tid);
+ CtdlLogPrintf(CTDL_NOTICE, "Thread \"%s\" (0x%08lx) exited.\n", CT->name, CT->tid);
#ifdef HAVE_BACKTRACE
eCrash_UnregisterThread();
that_thread = this_thread;
this_thread = this_thread->next;
+ if ((that_thread->state == CTDL_THREAD_STOP_REQ || that_thread->state == CTDL_THREAD_STOPPING)
+ && (!citthread_equal(that_thread->tid, citthread_self())))
+ CtdlLogPrintf(CTDL_DEBUG, "Waiting for thread %s (0x%08lx) to exit.\n", that_thread->name, that_thread->tid);
+ else
+ {
+ /**
+ * Catch the situation where a worker was asked to stop but couldn't and we are not
+ * shutting down.
+ */
+ that_thread->stop_ticker = 0;
+ }
+
+ if (that_thread->stop_ticker + 5 == time(NULL))
+ {
+ CtdlLogPrintf(CTDL_DEBUG, "Thread System: The thread \"%s\" (0x%08lx) failed to self terminate within 5 ticks. It would be cancelled now.\n", that_thread->name, that_thread->tid);
+ if ((that_thread->flags & CTDLTHREAD_WORKER) == 0)
+ CtdlLogPrintf(CTDL_INFO, "Thread System: A non worker thread would have been canceled this may cause message loss.\n");
+// that_thread->state = CTDL_THREAD_CANCELLED;
+ that_thread->stop_ticker++;
+// citthread_cancel(that_thread->tid);
+// continue;
+ }
+
/* Do we need to clean up this thread? */
- if (that_thread->state != CTDL_THREAD_EXITED)
+ if ((that_thread->state != CTDL_THREAD_EXITED) && (that_thread->state != CTDL_THREAD_CANCELLED))
{
if(that_thread->flags & CTDLTHREAD_WORKER)
workers++; /* Sanity check on number of worker threads */
else if (ret == ESRCH)
CtdlLogPrintf(CTDL_DEBUG, "Garbage collection, no thread to join on.\n");
else if (ret != 0)
- CtdlLogPrintf(CTDL_DEBUG, "Garbage collection, citthread_join returned an unknown error.\n");
+ CtdlLogPrintf(CTDL_DEBUG, "Garbage collection, citthread_join returned an unknown error(%d).\n", ret);
/*
* Now we own that thread entry
*/
- CtdlLogPrintf(CTDL_INFO, "Garbage Collection for thread \"%s\" (%ld).\n", that_thread->name, that_thread->tid);
+ CtdlLogPrintf(CTDL_INFO, "Garbage Collection for thread \"%s\" (0x%08lx).\n",
+ that_thread->name, that_thread->tid);
citthread_mutex_destroy(&that_thread->ThreadMutex);
citthread_cond_destroy(&that_thread->ThreadCond);
citthread_mutex_destroy(&that_thread->SleepMutex);
begin_critical_section(S_THREAD_LIST);
this_thread = (CtdlThreadNode *) arg;
gettimeofday(&this_thread->start_time, NULL); /* Time this thread started */
- citthread_mutex_lock(&this_thread->ThreadMutex);
+// citthread_mutex_lock(&this_thread->ThreadMutex);
// Register the cleanup function to take care of when we exit.
citthread_cleanup_push(ctdl_internal_thread_cleanup, NULL);
* Other wise there is a window to allow this threads creation to continue to full grown and
* therby prevent a shutdown of the server.
*/
- citthread_mutex_unlock(&this_thread->ThreadMutex);
+// citthread_mutex_unlock(&this_thread->ThreadMutex);
if (!CtdlThreadCheckStop())
{
#endif
// Tell the world we are here
- CtdlLogPrintf(CTDL_NOTICE, "Created a new thread \"%s\" (%ld). \n", this_thread->name, this_thread->tid);
-
-
+ CtdlLogPrintf(CTDL_NOTICE, "Created a new thread \"%s\" (0x%08lx).\n",
+ this_thread->name, this_thread->tid);
/*
* run the thread to do the work but only if we haven't been asked to stop
}
-
+
+
/*
- * Internal function to create a thread.
- * Must be called from within a S_THREAD_LIST critical section
- */
-CtdlThreadNode *ctdl_internal_create_thread(char *name, long flags, void *(*thread_func) (void *arg), void *args)
+ * Function to initialise an empty thread structure
+ */
+CtdlThreadNode *ctdl_internal_init_thread_struct(CtdlThreadNode *this_thread, long flags)
{
int ret = 0;
- CtdlThreadNode *this_thread;
-
- if (num_threads >= 32767)
- {
- CtdlLogPrintf(CTDL_EMERG, "Thread system. Thread list full.\n");
- return NULL;
- }
-
- this_thread = malloc(sizeof(CtdlThreadNode));
- if (this_thread == NULL) {
- CtdlLogPrintf(CTDL_EMERG, "Thread system, can't allocate CtdlThreadNode, exiting\n");
- return NULL;
- }
+
// Ensuring this is zero'd means we make sure the thread doesn't start doing its thing until we are ready.
memset (this_thread, 0, sizeof(CtdlThreadNode));
citthread_mutex_init (&(this_thread->SleepMutex), NULL);
citthread_cond_init (&(this_thread->SleepCond), NULL);
- citthread_mutex_lock(&this_thread->ThreadMutex);
-
this_thread->state = CTDL_THREAD_CREATE;
if ((ret = citthread_attr_init(&this_thread->attr))) {
}
}
+ /* Set this new thread with an avg_blocked of 2. We do this so that its creation affects the
+ * load average for the system. If we don't do this then we create a mass of threads at the same time
+ * because the creation didn't affect the load average.
+ */
+ this_thread->avg_blocked = 2;
+
+ return (this_thread);
+}
+
+
+
+
+/*
+ * Internal function to create a thread.
+ */
+CtdlThreadNode *ctdl_internal_create_thread(char *name, long flags, void *(*thread_func) (void *arg), void *args)
+{
+ int ret = 0;
+ CtdlThreadNode *this_thread;
+
+ if (num_threads >= 32767)
+ {
+ CtdlLogPrintf(CTDL_EMERG, "Thread system. Thread list full.\n");
+ return NULL;
+ }
+
+ this_thread = malloc(sizeof(CtdlThreadNode));
+ if (this_thread == NULL) {
+ CtdlLogPrintf(CTDL_EMERG, "Thread system, can't allocate CtdlThreadNode, exiting\n");
+ return NULL;
+ }
+
+ /* Initialise the thread structure */
+ if (ctdl_internal_init_thread_struct(this_thread, flags) == NULL)
+ {
+ free(this_thread);
+ CtdlLogPrintf(CTDL_EMERG, "Thread system, can't initialise CtdlThreadNode, exiting\n");
+ return NULL;
+ }
/*
* If we got here we are going to create the thread so we must initilise the structure
* first because most implimentations of threading can't create it in a stopped state
this_thread->flags = flags;
this_thread->thread_func = thread_func;
this_thread->user_args = args;
- /* Set this new thread with an avg_blocked of 2. We do this so that its creation affects the
- * load average for the system. If we don't do this then we create a mass of threads at the same time
- * because the creation didn't affect the load average.
- */
- this_thread->avg_blocked = 2;
+// citthread_mutex_lock(&this_thread->ThreadMutex);
+
+ begin_critical_section(S_THREAD_LIST);
/*
* We pass this_thread into the thread as its args so that it can find out information
* about itself and it has a bit of storage space for itself, not to mention that the REAL
*/
if ((ret = citthread_create(&this_thread->tid, &this_thread->attr, ctdl_internal_thread_func, this_thread) != 0))
{
-
+ end_critical_section(S_THREAD_LIST);
CtdlLogPrintf(CTDL_ALERT, "Thread system, Can't create thread: %s\n",
strerror(ret));
citthread_mutex_unlock(&this_thread->ThreadMutex);
CtdlThreadList = this_thread;
if (this_thread->next)
this_thread->next->prev = this_thread;
+ ctdl_thread_internal_calc_loadavg();
- citthread_mutex_unlock(&this_thread->ThreadMutex);
+// citthread_mutex_unlock(&this_thread->ThreadMutex);
+ end_critical_section(S_THREAD_LIST);
- ctdl_thread_internal_calc_loadavg();
return this_thread;
}
{
CtdlThreadNode *ret = NULL;
- begin_critical_section(S_THREAD_LIST);
ret = ctdl_internal_create_thread(name, flags, thread_func, args);
- end_critical_section(S_THREAD_LIST);
return ret;
}
*/
CtdlThreadNode *CtdlThreadSchedule(char *name, long flags, void *(*thread_func) (void *arg), void *args, time_t when)
{
- int ret = 0;
CtdlThreadNode *this_thread;
if (num_threads >= 32767)
CtdlLogPrintf(CTDL_EMERG, "Thread system, can't allocate CtdlThreadNode, exiting\n");
return NULL;
}
- // Ensuring this is zero'd means we make sure the thread doesn't start doing its thing until we are ready.
- memset (this_thread, 0, sizeof(CtdlThreadNode));
-
- /* Create the mutex's early so we can use them */
- citthread_mutex_init (&(this_thread->ThreadMutex), NULL);
- citthread_cond_init (&(this_thread->ThreadCond), NULL);
- citthread_mutex_init (&(this_thread->SleepMutex), NULL);
- citthread_cond_init (&(this_thread->SleepCond), NULL);
-
- this_thread->state = CTDL_THREAD_CREATE;
-
- if ((ret = citthread_attr_init(&this_thread->attr))) {
- citthread_mutex_destroy(&(this_thread->ThreadMutex));
- citthread_cond_destroy(&(this_thread->ThreadCond));
- citthread_mutex_destroy(&(this_thread->SleepMutex));
- citthread_cond_destroy(&(this_thread->SleepCond));
- CtdlLogPrintf(CTDL_EMERG, "Thread system, citthread_attr_init: %s\n", strerror(ret));
+ /* Initialise the thread structure */
+ if (ctdl_internal_init_thread_struct(this_thread, flags) == NULL)
+ {
free(this_thread);
+ CtdlLogPrintf(CTDL_EMERG, "Thread system, can't initialise CtdlThreadNode, exiting\n");
return NULL;
}
- /* Our per-thread stacks need to be bigger than the default size,
- * otherwise the MIME parser crashes on FreeBSD, and the IMAP service
- * crashes on 64-bit Linux.
- */
- if (flags & CTDLTHREAD_BIGSTACK)
- {
- CtdlLogPrintf(CTDL_INFO, "Thread system. Creating BIG STACK thread.\n");
- if ((ret = citthread_attr_setstacksize(&this_thread->attr, THREADSTACKSIZE))) {
- citthread_mutex_destroy(&(this_thread->ThreadMutex));
- citthread_cond_destroy(&(this_thread->ThreadCond));
- citthread_mutex_destroy(&(this_thread->SleepMutex));
- citthread_cond_destroy(&(this_thread->SleepCond));
- citthread_attr_destroy(&this_thread->attr);
- CtdlLogPrintf(CTDL_EMERG, "Thread system, citthread_attr_setstacksize: %s\n",
- strerror(ret));
- free(this_thread);
- return NULL;
- }
- }
-
/*
* If we got here we are going to create the thread so we must initilise the structure
* first because most implimentations of threading can't create it in a stopped state
this_thread->flags = flags;
this_thread->thread_func = thread_func;
this_thread->user_args = args;
- /* Set this new thread with an avg_blocked of 2. We do this so that its creation affects the
- * load average for the system. If we don't do this then we create a mass of threads at the same time
- * because the creation didn't affect the load average.
- */
- this_thread->avg_blocked = 2;
/*
* When to start this thread
{
int ret = 0;
+// citthread_mutex_lock(&that_thread->ThreadMutex);
+ begin_critical_section(S_THREAD_LIST);
/*
* We pass this_thread into the thread as its args so that it can find out information
* about itself and it has a bit of storage space for itself, not to mention that the REAL
*/
if ((ret = citthread_create(&this_thread->tid, &this_thread->attr, ctdl_internal_thread_func, this_thread) != 0))
{
-
- CtdlLogPrintf(CTDL_ALERT, "Thread system, Can't create thread: %s\n",
- strerror(ret));
+ end_critical_section(S_THREAD_LIST);
+ CtdlLogPrintf(CTDL_DEBUG, "Failed to start scheduled thread \"%s\": %s\n", this_thread->name, strerror(ret));
+// citthread_mutex_unlock(&this_thread->ThreadMutex);
+ citthread_mutex_destroy(&(this_thread->ThreadMutex));
+ citthread_cond_destroy(&(this_thread->ThreadCond));
+ citthread_mutex_destroy(&(this_thread->SleepMutex));
+ citthread_cond_destroy(&(this_thread->SleepCond));
+ citthread_attr_destroy(&this_thread->attr);
+ free(this_thread);
return NULL;
}
CtdlThreadList = this_thread;
if (this_thread->next)
this_thread->next->prev = this_thread;
+// citthread_mutex_unlock(&that_thread->ThreadMutex);
+
+ ctdl_thread_internal_calc_loadavg();
+ end_critical_section(S_THREAD_LIST);
+
return this_thread;
}
CtdlThreadNode *this_thread, *that_thread;
time_t now;
+ /* Don't start scheduled threads if the system wants single user mode */
+ if (CtdlWantSingleUser())
+ return;
+
if (try_critical_section(S_SCHEDULE_LIST))
return; /* If this list is locked we wait till the next chance */
#ifdef WITH_THREADLOG
CtdlLogPrintf(CTDL_DEBUG, "About to start scheduled thread \"%s\".\n", that_thread->name);
#endif
- begin_critical_section(S_THREAD_LIST);
if (CT->state > CTDL_THREAD_STOP_REQ)
{ /* Only start it if the system is not stopping */
- citthread_mutex_lock(&that_thread->ThreadMutex);
- if (ctdl_thread_internal_start_scheduled (that_thread) == NULL)
+ if (ctdl_thread_internal_start_scheduled (that_thread))
{
#ifdef WITH_THREADLOG
- CtdlLogPrintf(CTDL_DEBUG, "Failed to start scheduled thread \"%s\".\n", that_thread->name);
-#endif
- citthread_mutex_unlock(&that_thread->ThreadMutex);
- citthread_mutex_destroy(&(that_thread->ThreadMutex));
- citthread_cond_destroy(&(that_thread->ThreadCond));
- citthread_mutex_destroy(&(that_thread->SleepMutex));
- citthread_cond_destroy(&(that_thread->SleepCond));
- citthread_attr_destroy(&that_thread->attr);
- free(that_thread);
- }
- else
- {
- CtdlLogPrintf(CTDL_INFO, "Thread system, Started a scheduled thread \"%s\" (%ld).\n",
+ CtdlLogPrintf(CTDL_INFO, "Thread system, Started a scheduled thread \"%s\" (0x%08lx).\n",
that_thread->name, that_thread->tid);
- citthread_mutex_unlock(&that_thread->ThreadMutex);
- ctdl_thread_internal_calc_loadavg();
+#endif
}
}
- end_critical_section(S_THREAD_LIST);
}
+#ifdef WITH_THREADLOG
else
{
-#ifdef WITH_THREADLOG
- CtdlLogPrintf(CTDL_DEBUG, "Thread \"%s\" will start in %ld seconds.\n", that_thread->name, that_thread->when - time(NULL));
-#endif
+ CtdlLogPrintf(CTDL_DEBUG, "Thread \"%s\" will start in %ld seconds.\n",
+ that_thread->name, that_thread->when - time(NULL));
}
+#endif
}
end_critical_section(S_SCHEDULE_LIST);
}
*/
int CtdlThreadSelect(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout)
{
- int ret;
+ int ret = 0;
ctdl_thread_internal_change_state(CT, CTDL_THREAD_BLOCKED);
- ret = select(n, readfds, writefds, exceptfds, timeout);
- ctdl_thread_internal_change_state(CT, CTDL_THREAD_RUNNING);
+ if (!CtdlThreadCheckStop())
+ ret = select(n, readfds, writefds, exceptfds, timeout);
+ /**
+ * If the select returned <= 0 then it failed due to an error
+ * or timeout so this thread could stop if asked to do so.
+ * Anything else means it needs to continue unless the system is shutting down
+ */
+ if (ret <= 0)
+ {
+ /**
+ * select says nothing to do so we can change to running if we haven't been asked to stop.
+ */
+ ctdl_thread_internal_change_state(CT, CTDL_THREAD_RUNNING);
+ }
+ else
+ {
+ /**
+ * The select says this thread needs to do something useful.
+ * This thread was in an idle state so it may have been asked to stop
+ * but if the system isn't shutting down this thread is no longer
+ * idle and select has given it a task to do so it must not stop
+ * In this condition we need to force it into the running state.
+ * CtdlThreadGC will clear its ticker for us.
+ *
+ * FIXME: there is still a small hole here. It is possible for the sequence of locking
+ * to allow the state to get changed to STOP_REQ just after this code if the other thread
+ * has decided to change the state before this lock, it there fore has to wait till the lock
+ * completes but it will continue to change the state. We need something a bit better here.
+ */
+ citthread_mutex_lock(&CT->ThreadMutex); /* To prevent race condition of a sleeping thread */
+ if (GC_thread->state > CTDL_THREAD_STOP_REQ && CT->state <= CTDL_THREAD_STOP_REQ)
+ {
+ CtdlLogPrintf(CTDL_DEBUG, "Thread %s (0x%08lx) refused stop request.\n", CT->name, CT->tid);
+ CT->state = CTDL_THREAD_RUNNING;
+ }
+ citthread_mutex_unlock(&CT->ThreadMutex);
+ }
+
return ret;
}
if (last_worker)
{
#ifdef WITH_THREADLOG
- CtdlLogPrintf(CTDL_DEBUG, "Thread system, stopping excess worker thread \"%s\" (%ld).\n",
+ CtdlLogPrintf(CTDL_DEBUG, "Thread system, stopping excess worker thread \"%s\" (0x%08lx).\n",
last_worker->name,
last_worker->tid
);
for (i=0; i<5 ; i++)
{
#ifdef NEW_WORKER
- CtdlThreadCreate("Worker Thread",
+ CtdlThreadCreate("Worker Thread (new)",
CTDLTHREAD_BIGSTACK + CTDLTHREAD_WORKER,
new_worker_thread,
NULL
CtdlThreadGC();
}
+#ifdef THREADS_USESIGNALS
+ if (CtdlThreadGetCount() && CT->state > CTDL_THREAD_STOP_REQ)
+#else
if (CtdlThreadGetCount())
+#endif
CtdlThreadSleep(1);
}
/*
projects / citadel.git / blobdiff