citadel/threads.c

   1 /*
   2  * Thread handling stuff for Citadel server
   3  *
   4  * Copyright (c) 1987-2011 by the citadel.org team
   5  *
   6  * This program is open source software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  19  */
  20
  21 #include <stdlib.h>
  22 #include <unistd.h>
  23 #include <stdio.h>
  24 #include <sys/types.h>
  25 #include <errno.h>
  26 #include <sys/socket.h>
  27 #include <unistd.h>
  28 #include <fcntl.h>
  29 #include <signal.h>
  30 #include <syslog.h>
  31
  32 #include "sysdep.h"
  33 #if TIME_WITH_SYS_TIME
  34 # include <sys/time.h>
  35 # include <time.h>
  36 #else
  37 # if HAVE_SYS_TIME_H
  38 #  include <sys/time.h>
  39 # else
  40 #  include <time.h>
  41 # endif
  42 #endif
  43
  44 #ifdef HAVE_SYSCALL_H
  45 # include <syscall.h>
  46 #else
  47 # if HAVE_SYS_SYSCALL_H
  48 #  include <sys/syscall.h>
  49 # endif
  50 #endif
  51
  52 #include <libcitadel.h>
  53
  54 #include "threads.h"
  55 #include "ctdl_module.h"
  56 #include "modules_init.h"
  57 #include "housekeeping.h"
  58 #include "config.h"
  59 #include "citserver.h"
  60 #include "sysdep_decls.h"
  61 #include "context.h"
  62 #include "event_client.h"
  63
  64
  65 int num_workers = 0;                            /* Current number of worker threads */
  66 int active_workers = 0;                         /* Number of ACTIVE worker threads */
  67 pthread_key_t ThreadKey;
  68 pthread_mutex_t Critters[MAX_SEMAPHORES];       /* Things needing locking */
  69 struct thread_tsd masterTSD;
  70 int server_shutting_down = 0;                   /* set to nonzero during shutdown */
  71
  72
  73
  74 void InitializeSemaphores(void)
  75 {
  76         int i;
  77
  78         /* Set up a bunch of semaphores to be used for critical sections */
  79         for (i=0; i<MAX_SEMAPHORES; ++i) {
  80                 pthread_mutex_init(&Critters[i], NULL);
  81         }
  82 }
  83
  84
  85
  86
  87 /*
  88  * Obtain a semaphore lock to begin a critical section.
  89  * but only if no one else has one
  90  */
  91 int try_critical_section(int which_one)
  92 {
  93         /* For all types of critical sections except those listed here,
  94          * ensure nobody ever tries to do a critical section within a
  95          * transaction; this could lead to deadlock.
  96          */
  97         if (    (which_one != S_FLOORCACHE)
  98                 && (which_one != S_RPLIST)
  99         ) {
 100                 cdb_check_handles();
 101         }
 102         return (pthread_mutex_trylock(&Critters[which_one]));
 103 }
 104
 105
 106 /*
 107  * Obtain a semaphore lock to begin a critical section.
 108  */
 109 void begin_critical_section(int which_one)
 110 {
 111         /* For all types of critical sections except those listed here,
 112          * ensure nobody ever tries to do a critical section within a
 113          * transaction; this could lead to deadlock.
 114          */
 115         if (    (which_one != S_FLOORCACHE)
 116                 && (which_one != S_RPLIST)
 117         ) {
 118                 cdb_check_handles();
 119         }
 120         pthread_mutex_lock(&Critters[which_one]);
 121 }
 122
 123 /*
 124  * Release a semaphore lock to end a critical section.
 125  */
 126 void end_critical_section(int which_one)
 127 {
 128         pthread_mutex_unlock(&Critters[which_one]);
 129 }
 130
 131
 132
 133
 134 /*
 135  * Return a pointer to our thread-specific (not session-specific) data.
 136  */
 137 struct thread_tsd *MyThread(void) {
 138         register struct thread_tsd *c;
 139         return ((c = (struct thread_tsd *) pthread_getspecific(ThreadKey), c == NULL) ? &masterTSD : c);
 140 }
 141
 142
 143
 144 /*
 145  * Called by CtdlThreadCreate()
 146  * We have to pass through here before starting our thread in order to create a set of data
 147  * that is thread-specific rather than session-specific.
 148  */
 149 void *CTC_backend(void *supplied_start_routine)
 150 {
 151         struct thread_tsd *mytsd;
 152         void *(*start_routine)(void*) = supplied_start_routine;
 153
 154         mytsd = (struct thread_tsd *) malloc(sizeof(struct thread_tsd));
 155         memset(mytsd, 0, sizeof(struct thread_tsd));
 156         pthread_setspecific(ThreadKey, (const void *) mytsd);
 157
 158         start_routine(NULL);
 159
 160         free(mytsd);
 161         return(NULL);
 162 }
 163
 164
 165 /*
 166  * Function to create a thread.
 167  */
 168 void CtdlThreadCreate(void *(*start_routine)(void*))
 169 {
 170         pthread_t thread;
 171         pthread_attr_t attr;
 172         int ret = 0;
 173
 174
 175         ret = pthread_attr_init(&attr);
 176         ret = pthread_attr_setstacksize(&attr, THREADSTACKSIZE);
 177         ret = pthread_create(&thread, &attr, CTC_backend, (void *)start_routine);
 178         if (ret != 0) syslog(LOG_EMERG, "pthread_create() : %s", strerror(errno));
 179 }
 180
 181
 182 void InitializeMasterTSD(void) {
 183         memset(&masterTSD, 0, sizeof(struct thread_tsd));
 184 }
 185
 186
 187 /*
 188  * Initialize the thread system
 189  */
 190 void go_threading(void)
 191 {
 192         if (pthread_key_create(&ThreadKey, NULL) != 0) {
 193                 syslog(LOG_EMERG, "pthread_key_create() : %s", strerror(errno));
 194                 abort();
 195         }
 196
 197         /* Second call to module init functions now that threading is up */
 198         initialise_modules(1);
 199
 200         /* Begin with one worker thread.  We will expand the pool if necessary */
 201         CtdlThreadCreate(worker_thread);
 202
 203         /* The supervisor thread monitors worker threads and spawns more of them if it finds that
 204          * they are all in use.  FIXME make the 256 max threads a configurable value.
 205          */
 206         while (!server_shutting_down) {
 207                 if ((active_workers == num_workers) && (num_workers < 256)) {
 208                         CtdlThreadCreate(worker_thread);
 209                 }
 210                 usleep(1000);
 211         }
 212
 213         /* When we get to this point we are getting ready to shut down our Citadel server */
 214
 215         terminate_all_sessions();               /* close all client sockets */
 216         CtdlShutdownServiceHooks();             /* close all listener sockets to prevent new connections */
 217         PerformSessionHooks(EVT_SHUTDOWN);      /* run any registered shutdown hooks */
 218
 219         int countdown = 30;
 220         while ( (num_workers > 0) && (countdown-- > 0)) {
 221                 syslog(LOG_DEBUG, "Waiting %d seconds for %d worker threads to exit",
 222                         countdown, num_workers
 223                 );
 224                 usleep(1000);
 225         }
 226 }