// eCrashSymbolTable symbol_table;
#endif
/* initialise semaphores here. Patch by Matt and davew
- * its called here as they are needed by lprintf for thread safety
+ * its called here as they are needed by CtdlLogPrintf for thread safety
*/
CtdlInitBase64Table();
InitialiseSemaphores();
/* any other parameter makes it crash and burn */
else {
- lprintf(CTDL_EMERG, "citserver: usage: "
+ CtdlLogPrintf(CTDL_EMERG, "citserver: usage: "
"citserver "
"[-lLogFacility] "
"[-d] [-f] [-D] "
}
/* Tell 'em who's in da house */
- lprintf(CTDL_NOTICE, "\n");
- lprintf(CTDL_NOTICE, "\n");
- lprintf(CTDL_NOTICE,
+ CtdlLogPrintf(CTDL_NOTICE, "\n");
+ CtdlLogPrintf(CTDL_NOTICE, "\n");
+ CtdlLogPrintf(CTDL_NOTICE,
"*** Citadel server engine v%d.%02d ***\n",
(REV_LEVEL/100), (REV_LEVEL%100));
- lprintf(CTDL_NOTICE,
+ CtdlLogPrintf(CTDL_NOTICE,
"Copyright (C) 1987-2007 by the Citadel development team.\n");
- lprintf(CTDL_NOTICE,
+ CtdlLogPrintf(CTDL_NOTICE,
"This program is distributed under the terms of the GNU "
"General Public License.\n");
- lprintf(CTDL_NOTICE, "\n");
- lprintf(CTDL_DEBUG, "Called as: %s\n", argv[0]);
- lprintf(CTDL_INFO, "%s\n", libcitadel_version_string());
+ CtdlLogPrintf(CTDL_NOTICE, "\n");
+ CtdlLogPrintf(CTDL_DEBUG, "Called as: %s\n", argv[0]);
+ CtdlLogPrintf(CTDL_INFO, "%s\n", libcitadel_version_string());
/* Load site-specific parameters, and set the ipgm secret */
- lprintf(CTDL_INFO, "Loading citadel.config\n");
+ CtdlLogPrintf(CTDL_INFO, "Loading citadel.config\n");
get_config();
config.c_ipgm_secret = rand();
put_config();
*/
master_startup();
- lprintf(CTDL_INFO, "Acquiring control record\n");
+ CtdlLogPrintf(CTDL_INFO, "Acquiring control record\n");
get_control();
/*
do_async_loop,
CitadelServiceTCP);
+
+ /*
+ * Run any upgrade entry points
+ */
+ CtdlLogPrintf(CTDL_INFO, "Upgrading modules.\n");
+ upgrade_modules();
+
+
/*
* Load any server-side extensions available here.
*/
- lprintf(CTDL_INFO, "Initializing server extensions\n");
+ CtdlLogPrintf(CTDL_INFO, "Initializing server extensions\n");
size = strlen(ctdl_home_directory) + 9;
initialise_modules(0);
getpwuid_r(config.c_ctdluid, &pw, pwbuf, sizeof(pwbuf), &pwp);
#endif
if (pwp == NULL)
- lprintf(CTDL_CRIT, "WARNING: getpwuid(%ld): %s\n"
+ CtdlLogPrintf(CTDL_CRIT, "WARNING: getpwuid(%ld): %s\n"
"Group IDs will be incorrect.\n", (long)CTDLUID,
strerror(errno));
else {
initgroups(pw.pw_name, pw.pw_gid);
if (setgid(pw.pw_gid))
- lprintf(CTDL_CRIT, "setgid(%ld): %s\n", (long)pw.pw_gid,
+ CtdlLogPrintf(CTDL_CRIT, "setgid(%ld): %s\n", (long)pw.pw_gid,
strerror(errno));
}
- lprintf(CTDL_INFO, "Changing uid to %ld\n", (long)CTDLUID);
+ CtdlLogPrintf(CTDL_INFO, "Changing uid to %ld\n", (long)CTDLUID);
if (setuid(CTDLUID) != 0) {
- lprintf(CTDL_CRIT, "setuid() failed: %s\n", strerror(errno));
+ CtdlLogPrintf(CTDL_CRIT, "setuid() failed: %s\n", strerror(errno));
}
#if defined (HAVE_SYS_PRCTL_H) && defined (PR_SET_DUMPABLE)
prctl(PR_SET_DUMPABLE, 1);
int i;
struct CtdlThreadNode *last_worker;
- /* We can't use CT_PUSH() here so we do it the long way
- * So we can still use CT for current thread */
- struct CtdlThreadNode *_this_cit_thread;
-
/*
* Initialise the thread system
*/
ctdl_thread_internal_init();
- _this_cit_thread = CtdlThreadSelf();
/*
* Now create a bunch of worker threads.
*/
if (exit_signal)
CtdlThreadStopAll();
check_sched_shutdown();
- begin_critical_section(S_THREAD_LIST);
- ctdl_thread_internal_calc_loadavg();
- end_critical_section(S_THREAD_LIST);
-
+ if (CT->state > CTDL_THREAD_STOP_REQ)
+ {
+ begin_critical_section(S_THREAD_LIST);
+ ctdl_thread_internal_calc_loadavg();
+ end_critical_section(S_THREAD_LIST);
+
+ ctdl_thread_internal_check_scheduled(); /* start scheduled threads */
+ }
+
/* Reduce the size of the worker thread pool if necessary. */
- if ((CtdlThreadGetWorkers() > config.c_min_workers) && (CtdlThreadWorkerAvg < 20))
+ if ((CtdlThreadGetWorkers() > config.c_min_workers) && (CtdlThreadWorkerAvg < 20) && (CT->state > CTDL_THREAD_STOP_REQ))
{
/* Ask a worker thread to stop as we no longer need it */
begin_critical_section(S_THREAD_LIST);
last_worker = CtdlThreadList;
while (last_worker)
{
+ pthread_mutex_lock(&last_worker->ThreadMutex);
if (last_worker->flags & CTDLTHREAD_WORKER && last_worker->state > CTDL_THREAD_STOPPING)
+ {
+ pthread_mutex_unlock(&last_worker->ThreadMutex);
break;
- else
- last_worker = last_worker->next;
+ }
+ pthread_mutex_unlock(&last_worker->ThreadMutex);
+ last_worker = last_worker->next;
}
end_critical_section(S_THREAD_LIST);
if (last_worker)
* If all our workers are working hard, start some more to help out
* with things
*/
- begin_critical_section(S_THREAD_LIST);
/* FIXME: come up with a better way to dynamically alter the number of threads
* based on the system load
*/
// if ((CtdlThreadGetWorkers() < config.c_max_workers) && (CtdlThreadGetWorkers() < num_sessions))
// && (CtdlThreadLoadAvg < 90) )
- if ((CtdlThreadGetWorkers() < config.c_max_workers) && (CtdlThreadWorkerAvg > 60) && (CtdlThreadLoadAvg < 90) )
+ if ((CtdlThreadGetWorkers() < config.c_max_workers) && (CtdlThreadGetWorkerAvg() > 60) && (CtdlThreadGetLoadAvg() < 90) && (CT->state > CTDL_THREAD_STOP_REQ))
{
- end_critical_section(S_THREAD_LIST);
for (i=0; i<5 ; i++)
// for (i=0; i< (num_sessions - CtdlThreadGetWorkers()) ; i++)
// for (i=0; i< (10 - (55 - CtdlThreadWorkerAvg) / CtdlThreadWorkerAvg / CtdlThreadGetWorkers()) ; i++)
{
- begin_critical_section(S_THREAD_LIST);
- ctdl_internal_create_thread("Worker Thread",
+// begin_critical_section(S_THREAD_LIST);
+ CtdlThreadCreate("Worker Thread",
CTDLTHREAD_BIGSTACK + CTDLTHREAD_WORKER,
worker_thread,
NULL
);
- end_critical_section(S_THREAD_LIST);
+// end_critical_section(S_THREAD_LIST);
}
}
- else
- end_critical_section(S_THREAD_LIST);
- begin_critical_section(S_THREAD_LIST);
- ctdl_internal_thread_gc();
- end_critical_section(S_THREAD_LIST);
+ CtdlThreadGC();
if (CtdlThreadGetCount() <= 1) // Shutting down clean up the garbage collector
{
- begin_critical_section(S_THREAD_LIST);
- ctdl_internal_thread_gc();
- end_critical_section(S_THREAD_LIST);
+ CtdlThreadGC();
}
if (CtdlThreadGetCount())