gwthread-pthread.c File Reference

#include <unistd.h>
#include <errno.h>
#include <pthread.h>
#include <signal.h>
#include <string.h>
#include "gwlib/gwlib.h"
#include <openssl/err.h>

Include dependency graph for gwthread-pthread.c:

Go to the source code of this file.

Data Structures
struct	threadinfo
struct	new_thread_args
Defines
#define	THREADTABLE_SIZE   1024
#define	THREAD(t)   (threadtable[(t) % THREADTABLE_SIZE])
Functions
void	lock (void)
void	unlock (void)
void	flushpipe (int fd)
long	fill_threadinfo (pthread_t id, const char *name, gwthread_func_t *func, struct threadinfo *ti)
threadinfo *	getthreadinfo (void)
void	alert_joiners (void)
void	delete_threadinfo (void)
void	gwthread_init (void)
void	gwthread_shutdown (void)
void *	new_thread (void *arg)
int	block_user_signals (sigset_t *old_set_storage)
void	restore_user_signals (sigset_t *old_set)
long	spawn_thread (gwthread_func_t *func, const char *name, void *arg)
long	gwthread_create_real (gwthread_func_t *func, const char *name, void *arg)
void	gwthread_join (long thread)
void	gwthread_join_all (void)
void	gwthread_wakeup_all (void)
void	gwthread_join_every (gwthread_func_t *func)
long	gwthread_self (void)
long	gwthread_self_pid (void)
void	gwthread_self_ids (long *tid, long *pid)
void	gwthread_wakeup (long thread)
int	gwthread_pollfd (int fd, int events, double timeout)
int	gwthread_poll (struct pollfd *fds, long numfds, double timeout)
void	gwthread_sleep (double seconds)
void	gwthread_sleep_micro (double dseconds)
int	gwthread_cancel (long thread)
int	gwthread_shouldhandlesignal (int signal)
int	gwthread_dumpsigmask (void)
Variables
threadinfo *	threadtable [THREADTABLE_SIZE]
long	active_threads = 0
long	next_threadnumber
threadinfo	mainthread
pthread_key_t	tsd_key
pthread_mutex_t	threadtable_lock

---

Define Documentation

#define THREAD (  t   )     (threadtable[(t) % THREADTABLE_SIZE])

Definition at line 107 of file gwthread-pthread.c. Referenced by delete_threadinfo(), fill_threadinfo(), gwthread_cancel(), gwthread_join(), gwthread_join_all(), gwthread_join_every(), gwthread_wakeup(), and gwthread_wakeup_all().

#define THREADTABLE_SIZE   1024

Definition at line 78 of file gwthread-pthread.c. Referenced by fill_threadinfo().

---

Function Documentation

void alert_joiners (  void   )  [static]

Definition at line 232 of file gwthread-pthread.c. References getthreadinfo(), gwlist_extract_first(), and threadinfo::joiners. Referenced by new_thread(). { struct threadinfo *threadinfo; pthread_cond_t *joiner_cond; threadinfo = getthreadinfo(); if (!threadinfo->joiners) return; while ((joiner_cond = gwlist_extract_first(threadinfo->joiners))) { pthread_cond_broadcast(joiner_cond); } }

Here is the call graph for this function:

int block_user_signals (  sigset_t *  old_set_storage  )  [static]

Definition at line 397 of file gwthread-pthread.c. References error(). Referenced by gwthread_create_real(). { int ret; sigset_t block_signals; ret = sigemptyset(&block_signals); if (ret != 0) { error(errno, "gwthread-pthread: Couldn't initialize signal set"); return -1; } ret = sigaddset(&block_signals, SIGHUP); ret |= sigaddset(&block_signals, SIGTERM); ret |= sigaddset(&block_signals, SIGQUIT); ret |= sigaddset(&block_signals, SIGINT); if (ret != 0) { error(0, "gwthread-pthread: Couldn't add signal to signal set"); return -1; } ret = pthread_sigmask(SIG_BLOCK, &block_signals, old_set_storage); if (ret != 0) { error(ret, "gwthread-pthread: Couldn't disable signals for thread creation"); return -1; } return 0; }

Here is the call graph for this function:

void delete_threadinfo (  void   )  [static]

Definition at line 245 of file gwthread-pthread.c. References active_threads, getthreadinfo(), gw_assert, gwlist_destroy(), threadinfo::joiners, mainthread, threadinfo::number, THREAD, threadinfo::wakefd_recv, and threadinfo::wakefd_send. Referenced by new_thread(). { struct threadinfo *threadinfo; threadinfo = getthreadinfo(); gwlist_destroy(threadinfo->joiners, NULL); if (threadinfo->wakefd_recv != -1) close(threadinfo->wakefd_recv); if (threadinfo->wakefd_send != -1) close(threadinfo->wakefd_send); if (threadinfo->number != -1) { THREAD(threadinfo->number) = NULL; active_threads--; } gw_assert(threadinfo != &mainthread); gw_free(threadinfo); }

Here is the call graph for this function:

long fill_threadinfo (  pthread_t  id, const char *  name, gwthread_func_t *  func, struct threadinfo *  ti )  [static]

Definition at line 167 of file gwthread-pthread.c. References active_threads, error(), threadinfo::func, gw_assert, threadinfo::joiners, threadinfo::name, next_threadnumber, threadinfo::number, threadinfo::pid, threadinfo::self, socket_set_blocking(), THREAD, THREADTABLE_SIZE, threadinfo::wakefd_recv, and threadinfo::wakefd_send. Referenced by gwthread_init(), and spawn_thread(). { int pipefds[2]; long first_try; gw_assert(active_threads < THREADTABLE_SIZE); /* initialize to default values */ ti->self = id; ti->name = name; ti->func = func; ti->pid = -1; ti->wakefd_recv = -1; ti->wakefd_send = -1; ti->joiners = NULL; ti->number = -1; if (pipe(pipefds) < 0) { error(errno, "cannot allocate wakeup pipe for new thread"); return -1; } ti->wakefd_recv = pipefds[0]; ti->wakefd_send = pipefds[1]; socket_set_blocking(ti->wakefd_recv, 0); socket_set_blocking(ti->wakefd_send, 0); /* Find a free table entry and claim it. */ first_try = next_threadnumber; do { ti->number = next_threadnumber++; /* Check if we looped all the way around the thread table. */ if (ti->number == first_try + THREADTABLE_SIZE) { error(0, "Cannot have more than %d active threads", THREADTABLE_SIZE); ti->number = -1; return -1; } } while (THREAD(ti->number) != NULL); THREAD(ti->number) = ti; active_threads++; return ti->number; }

Here is the call graph for this function:

void flushpipe (  int  fd  )  [static]

Definition at line 153 of file gwthread-pthread.c. Referenced by gwthread_poll(), gwthread_pollfd(), gwthread_sleep(), and gwthread_sleep_micro(). { unsigned char buf[128]; ssize_t bytes; do { bytes = read(fd, buf, sizeof(buf)); } while (bytes > 0); }

struct threadinfo* getthreadinfo (  void   )  [static]

Definition at line 214 of file gwthread-pthread.c. References gw_assert, panic, threadinfo::self, and tsd_key. Referenced by alert_joiners(), delete_threadinfo(), gwthread_poll(), gwthread_pollfd(), gwthread_sleep(), and gwthread_sleep_micro(). { struct threadinfo *threadinfo; threadinfo = pthread_getspecific(tsd_key); if (threadinfo == NULL) { panic(0, "gwthread-pthread: pthread_getspecific failed"); } else { gw_assert(pthread_equal(threadinfo->self, pthread_self())); } return threadinfo; }

int gwthread_cancel (  long  thread  )

Definition at line 819 of file gwthread-pthread.c. References gw_assert, threadinfo::number, threadinfo::self, and THREAD. Referenced by main(). { struct threadinfo *threadinfo; gw_assert(thread >= 0); threadinfo = THREAD(thread); if (threadinfo == NULL || threadinfo->number != thread) { return -1; } else { return pthread_cancel(threadinfo->self); } }

long gwthread_create_real (  gwthread_func_t *  func, const char *  name, void *  arg )

Definition at line 488 of file gwthread-pthread.c. References block_user_signals(), gwthread_self(), name, restore_user_signals(), and spawn_thread(). { int sigtrick = 0; sigset_t old_signal_set; long thread_id; /* * We want to make sure that only the main thread handles signals, * so that each signal is handled exactly once. To do this, we * make sure that each new thread has all the signals that we * handle blocked. To avoid race conditions, we block them in * the spawning thread first, then create the new thread (which * inherits the settings), and then restore the old settings in * the spawning thread. This means that there is a brief period * when no signals will be processed, but during that time they * should be queued by the operating system. */ if (gwthread_self() == MAIN_THREAD_ID) sigtrick = block_user_signals(&old_signal_set) == 0; thread_id = spawn_thread(func, name, arg); /* * Restore the old signal mask. The new thread will have * inherited the resticted one, but the main thread needs * the old one back. */ if (sigtrick) restore_user_signals(&old_signal_set); return thread_id; }

Here is the call graph for this function:

int gwthread_dumpsigmask (  void   )

Definition at line 848 of file gwthread-pthread.c. References debug(), and warning(). { sigset_t signal_set; int signum; /* Grab the signal set data from our thread */ if (pthread_sigmask(SIG_BLOCK, NULL, &signal_set) != 0) { warning(0, "gwthread_dumpsigmask: Couldn't get signal mask."); return -1; } /* For each signal normally defined (there are usually only 32), * print a message if we don't block it. */ for (signum = 1; signum <= 32; signum++) { if (!sigismember(&signal_set, signum)) { debug("gwlib", 0, "gwthread_dumpsigmask: Signal Number %d will be caught.", signum); } } return 0; }

Here is the call graph for this function:

void gwthread_init (  void   )

Definition at line 263 of file gwthread-pthread.c. References active_threads, fill_threadinfo(), mainthread, panic, threadtable, threadtable_lock, and tsd_key. Referenced by gwlib_init(). { int ret; int i; pthread_mutex_init(&threadtable_lock, NULL); ret = pthread_key_create(&tsd_key, NULL); if (ret != 0) { panic(ret, "gwthread-pthread: pthread_key_create failed"); } for (i = 0; i < THREADTABLE_SIZE; i++) { threadtable[i] = NULL; } active_threads = 0; /* create main thread info */ if (fill_threadinfo(pthread_self(), "main", NULL, &mainthread) == -1) panic(0, "gwthread-pthread: unable to fill main threadinfo."); ret = pthread_setspecific(tsd_key, &mainthread); if (ret != 0) panic(ret, "gwthread-pthread: pthread_setspecific failed"); }

Here is the call graph for this function:

void gwthread_join (  long  thread  )

Definition at line 521 of file gwthread-pthread.c. References gw_assert, gwlist_append(), gwlist_create, threadinfo::joiners, lock, threadinfo::number, THREAD, threadtable_lock, unlock, and warning(). Referenced by cimd2_shutdown_cb(), emi2_sender(), fdset_destroy(), gwthread_join_all(), heartbeat_stop(), httpd_emu_destroy(), httpsmsc_send_cb(), main(), oisd_shutdown_cb(), receive_smpp_thread(), run_smsbox(), run_wapbox(), shutdown_cb(), smpp_emu(), smpp_emu_reader(), smsboxc_run(), smsc_cimd2_create(), smsc_emi2_create(), smsc_emu_destroy(), smsc_oisd_create(), smsc_smpp_create(), soap_server_stop(), soap_shutdown_cb(), store_file_shutdown(), timers_shutdown(), udp_sender(), and wrapper_sender(). { struct threadinfo *threadinfo; pthread_cond_t exit_cond; int ret; gw_assert(thread >= 0); lock(); threadinfo = THREAD(thread); if (threadinfo == NULL || threadinfo->number != thread) { /* The other thread has already exited */ unlock(); return; } /* Register our desire to be alerted when that thread exits, * and wait for it. */ ret = pthread_cond_init(&exit_cond, NULL); if (ret != 0) { warning(ret, "gwthread_join: cannot create condition variable."); unlock(); return; } if (!threadinfo->joiners) threadinfo->joiners = gwlist_create(); gwlist_append(threadinfo->joiners, &exit_cond); /* The wait immediately releases the lock, and reacquires it * when the condition is satisfied. So don't worry, we're not * blocking while keeping the table locked. */ ret = pthread_cond_wait(&exit_cond, &threadtable_lock); unlock(); if (ret != 0) warning(ret, "gwthread_join: error in pthread_cond_wait"); pthread_cond_destroy(&exit_cond); }

Here is the call graph for this function:

void gwthread_join_all (  void   )

Definition at line 563 of file gwthread-pthread.c. References gwthread_join(), gwthread_self(), and THREAD. Referenced by main(). { long i; long our_thread = gwthread_self(); for (i = 0; i < THREADTABLE_SIZE; ++i) { if (THREAD(our_thread) != THREAD(i)) gwthread_join(i); } }

Here is the call graph for this function:

void gwthread_join_every (  gwthread_func_t *  func  )

Definition at line 585 of file gwthread-pthread.c. References debug(), threadinfo::func, gwlist_append(), gwlist_create, threadinfo::joiners, lock, threadinfo::name, threadinfo::number, THREAD, threadtable_lock, unlock, and warning(). Referenced by client_shutdown(), http_close_all_ports(), httpadmin_stop(), main(), main_for_producer_and_consumer(), radius_acct_shutdown(), server_shutdown(), wap_appl_shutdown(), wap_push_ota_shutdown(), wap_push_ppg_shutdown(), wsp_push_client_shutdown(), wsp_session_shutdown(), wsp_unit_shutdown(), wtp_initiator_shutdown(), and wtp_resp_shutdown(). { struct threadinfo *ti; pthread_cond_t exit_cond; int ret; long i; ret = pthread_cond_init(&exit_cond, NULL); if (ret != 0) { warning(ret, "gwthread_join_every: cannot create condition variable."); unlock(); return; } /* * FIXME: To be really safe, this function should keep looping * over the table until it does a complete run without having * to call pthread_cond_wait. Otherwise, new threads could * start while we wait, and we'll miss them. */ lock(); for (i = 0; i < THREADTABLE_SIZE; ++i) { ti = THREAD(i); if (ti == NULL || ti->func != func) continue; debug("gwlib.gwthread", 0, "Waiting for %ld (%s) to terminate", ti->number, ti->name); if (!ti->joiners) ti->joiners = gwlist_create(); gwlist_append(ti->joiners, &exit_cond); ret = pthread_cond_wait(&exit_cond, &threadtable_lock); if (ret != 0) warning(ret, "gwthread_join_all: error in pthread_cond_wait"); } unlock(); pthread_cond_destroy(&exit_cond); }

Here is the call graph for this function:

int gwthread_poll (  struct pollfd *  fds, long  numfds, double  timeout )

Definition at line 716 of file gwthread-pthread.c. References error(), pollfd::fd, flushpipe(), getthreadinfo(), poll, and threadinfo::wakefd_recv. Referenced by poller(), and server_thread(). { struct pollfd *pollfds; struct threadinfo *threadinfo; int milliseconds; int ret; threadinfo = getthreadinfo(); /* Create a new pollfd array with an extra element for the * thread wakeup fd. */ pollfds = gw_malloc((numfds + 1) * sizeof(*pollfds)); pollfds[0].fd = threadinfo->wakefd_recv; pollfds[0].events = POLLIN; pollfds[0].revents = 0; memcpy(pollfds + 1, fds, numfds * sizeof(*pollfds)); milliseconds = timeout * 1000; if (milliseconds < 0) milliseconds = POLL_NOTIMEOUT; ret = poll(pollfds, numfds + 1, milliseconds); if (ret < 0) { if (errno != EINTR) error(errno, "gwthread_poll: error in poll"); gw_free(pollfds); return -1; } if (pollfds[0].revents) flushpipe(pollfds[0].fd); /* Copy the results back to the caller */ memcpy(fds, pollfds + 1, numfds * sizeof(*pollfds)); gw_free(pollfds); return ret; }

Here is the call graph for this function:

int gwthread_pollfd (  int  fd, int  events, double  timeout )

Definition at line 682 of file gwthread-pthread.c. References error(), pollfd::events, pollfd::fd, flushpipe(), getthreadinfo(), poll, pollfd::revents, and threadinfo::wakefd_recv. Referenced by accept_thread(), cgw_listener(), cgw_wait_command(), conn_flush(), conn_wait(), emi2_listener(), fake_listener(), gw_accept(), and wait_for_connections(). { struct pollfd pollfd[2]; struct threadinfo *threadinfo; int milliseconds; int ret; threadinfo = getthreadinfo(); pollfd[0].fd = threadinfo->wakefd_recv; pollfd[0].events = POLLIN; pollfd[0].revents = 0; pollfd[1].fd = fd; pollfd[1].events = events; pollfd[1].revents = 0; milliseconds = timeout * 1000; if (milliseconds < 0) milliseconds = POLL_NOTIMEOUT; ret = poll(pollfd, 2, milliseconds); if (ret < 0) { if (errno != EINTR) error(errno, "gwthread_pollfd: error in poll"); return -1; } if (pollfd[0].revents) flushpipe(pollfd[0].fd); return pollfd[1].revents; }

Here is the call graph for this function:

long gwthread_self (  void   )

Definition at line 626 of file gwthread-pthread.c. References threadinfo::number, and tsd_key. Referenced by client_thread(), conn_claim(), fdset_destroy(), fdset_listen(), fdset_register(), fdset_set_timeout(), fdset_unregister(), find_entry(), gw_prioqueue_consume(), gw_rwlock_unlock(), gw_rwlock_wrlock(), gwlist_consume(), gwlist_timed_consume(), gwlist_wait_until_nonempty(), gwthread_create_real(), gwthread_join_all(), gwthread_wakeup_all(), handle_action(), lock_in(), lock_out(), mutex_lock_real(), mutex_trylock_real(), new_thread(), openssl_init_locks(), producer(), and push_thread(). { struct threadinfo *threadinfo; threadinfo = pthread_getspecific(tsd_key); if (threadinfo) return threadinfo->number; else return -1; }

void gwthread_self_ids (  long *  tid, long *  pid )

Definition at line 647 of file gwthread-pthread.c. References threadinfo::number, threadinfo::pid, tid, and tsd_key. Referenced by format(). { struct threadinfo *threadinfo; threadinfo = pthread_getspecific(tsd_key); if (threadinfo) { *tid = threadinfo->number; *pid = (threadinfo->pid != -1) ? threadinfo->pid : getpid(); } else { *tid = -1; *pid = getpid(); } }

long gwthread_self_pid (  void   )

Definition at line 637 of file gwthread-pthread.c. References threadinfo::pid, and tsd_key. { struct threadinfo *threadinfo; threadinfo = pthread_getspecific(tsd_key); if (threadinfo && threadinfo->pid != -1) return (long) threadinfo->pid; else return (long) getpid(); }

int gwthread_shouldhandlesignal (  int  signal  )

Definition at line 837 of file gwthread-pthread.c. Referenced by signal_handler(). { return 1; }

void gwthread_shutdown (  void   )

Definition at line 292 of file gwthread-pthread.c. References debug(), gw_assert, lock, name, number, running, threadtable, threadtable_lock, unlock, and warning(). Referenced by gwlib_shutdown(). { int ret; int running; int i; /* Main thread must not have disappeared */ gw_assert(threadtable[0] != NULL); lock(); running = 0; /* Start i at 1 to skip the main thread, which is supposed to be * still running. */ for (i = 1; i < THREADTABLE_SIZE; i++) { if (threadtable[i] != NULL) { debug("gwlib", 0, "Thread %ld (%s) still running", threadtable[i]->number, threadtable[i]->name); running++; } } unlock(); /* We can't do a full cleanup this way */ if (running) return; ret = pthread_mutex_destroy(&threadtable_lock); if (ret != 0) { warning(ret, "cannot destroy threadtable lock"); } /* We can't delete the tsd_key here, because gwthread_self() * still needs it to access the main thread's info. */ }

Here is the call graph for this function:

void gwthread_sleep (  double  seconds  )

Definition at line 756 of file gwthread-pthread.c. References pollfd::events, pollfd::fd, flushpipe(), getthreadinfo(), poll, threadinfo::wakefd_recv, and warning(). Referenced by at2_device_thread(), at2_init_device(), at2_login_device(), at2_send_one_message(), at2_write(), at2_write_ctrlz(), at2_write_line(), bb_smscconn_receive(), cgw_open_send_connection(), client_thread(), dbpool_conn_consume(), emi2_do_send(), emi2_wait(), heartbeat_thread(), http_queue_thread(), httpd_check_authorization(), httpsmsc_send(), httpsmsc_send_cb(), io_thread(), main(), main_connection_loop(), open_send_connection(), parachute_start(), poller(), port_remove(), push_thread(), reconnect(), send_message(), send_messages(), send_smpp_thread(), smasi_thread(), sms_router(), sms_to_smsboxes(), smsbox_thread(), smsboxc_run(), soap_listener(), soap_server(), store_dumper(), thread1(), thread2(), wait_for_connections(), wapboxc_run(), watch_timers(), and wrapper_receiver(). { struct pollfd pollfd; struct threadinfo *threadinfo; int milliseconds; int ret; threadinfo = getthreadinfo(); pollfd.fd = threadinfo->wakefd_recv; pollfd.events = POLLIN; milliseconds = seconds * 1000; if (milliseconds < 0) milliseconds = POLL_NOTIMEOUT; ret = poll(&pollfd, 1, milliseconds); if (ret < 0) { if (errno != EINTR && errno != EAGAIN) { warning(errno, "gwthread_sleep: error in poll"); } } if (ret == 1) { flushpipe(pollfd.fd); } }

Here is the call graph for this function:

void gwthread_sleep_micro (  double  dseconds  )

Definition at line 784 of file gwthread-pthread.c. References flushpipe(), getthreadinfo(), threadinfo::wakefd_recv, and warning(). { fd_set fd_set_recv; struct threadinfo *threadinfo; int fd; int ret; threadinfo = getthreadinfo(); fd = threadinfo->wakefd_recv; FD_ZERO(&fd_set_recv); FD_SET(fd, &fd_set_recv); if (dseconds < 0) { ret = select(fd + 1, &fd_set_recv, NULL, NULL, NULL); } else { struct timeval timeout; timeout.tv_sec = dseconds; timeout.tv_usec = (dseconds - timeout.tv_sec) * 1000000; ret = select(fd + 1, &fd_set_recv, NULL, NULL, &timeout); } if (ret < 0) { if (errno != EINTR && errno != EAGAIN) { warning(errno, "gwthread_sleep_micro: error in select()"); } } if (FD_ISSET(fd, &fd_set_recv)) { flushpipe(fd); } }

Here is the call graph for this function:

void gwthread_wakeup (  long  thread  )

Definition at line 660 of file gwthread-pthread.c. References gw_assert, lock, threadinfo::number, THREAD, unlock, and threadinfo::wakefd_send. Referenced by add_msg_cb(), at2_add_msg_cb(), at2_shutdown_cb(), at2_start_cb(), bb_smscconn_connected(), boxc_receiver(), cgw_add_msg_cb(), cgw_listener(), cgw_shutdown_cb(), cgw_start_cb(), cimd2_add_msg_cb(), cimd2_shutdown_cb(), cimd2_start_cb(), emi2_idleprocessing(), emi2_listener(), emi2_sender(), gwthread_wakeup_all(), gwtimer_start(), heartbeat_stop(), http_close_all_ports(), http_close_port(), http_open_port_if(), httpd_shutdown(), main(), oisd_add_msg_cb(), oisd_shutdown_cb(), oisd_start_cb(), run_smsbox(), send_msg_cb(), server_shutdown(), shutdown_cb(), smpp_emu(), sms_router(), smsboxc_run(), smsc2_restart_smsc(), smsc2_resume(), smsc2_shutdown(), smsc_cimd2_create(), smsc_emi2_create(), smsc_emu_destroy(), smsc_oisd_create(), smsc_smpp_create(), soap_add_msg_cb(), soap_server_stop(), soap_shutdown_cb(), start_cb(), store_file_shutdown(), submit_action(), submit_action_nosync(), timers_shutdown(), udp_receiver(), wapboxc_run(), wrapper_sender(), and wrapper_shutdown(). { unsigned char c = 0; struct threadinfo *threadinfo; int fd; gw_assert(thread >= 0); lock(); threadinfo = THREAD(thread); if (threadinfo == NULL || threadinfo->number != thread) { unlock(); return; } fd = threadinfo->wakefd_send; unlock(); write(fd, &c, 1); }

void gwthread_wakeup_all (  void   )

Definition at line 574 of file gwthread-pthread.c. References gwthread_self(), gwthread_wakeup(), and THREAD. Referenced by httpd_restart(), main(), and quit(). { long i; long our_thread = gwthread_self(); for (i = 0; i < THREADTABLE_SIZE; ++i) { if (THREAD(our_thread) != THREAD(i)) gwthread_wakeup(i); } }

Here is the call graph for this function:

void lock (  void   )  [inline, static]

Definition at line 131 of file gwthread-pthread.c. References panic, and threadtable_lock. { int ret; ret = pthread_mutex_lock(&threadtable_lock); if (ret != 0) { panic(ret, "gwthread-pthread: could not lock thread table"); } }

void* new_thread (  void *  arg  )  [static]

Definition at line 328 of file gwthread-pthread.c. References alert_joiners(), new_thread_args::arg, debug(), delete_threadinfo(), new_thread_args::failed, new_thread_args::func, gwthread_self(), lock, threadinfo::name, threadinfo::number, panic, threadinfo::pid, new_thread_args::ti, tsd_key, and unlock. Referenced by spawn_thread(). { int ret; struct new_thread_args *p = arg; /* Make sure we don't start until our parent has entered * our thread info in the thread table. */ lock(); /* check for initialization errors */ if (p->failed) { /* Must free p before signaling our exit, otherwise there is * a race with gw_check_leaks at shutdown. */ gw_free(p); delete_threadinfo(); unlock(); return NULL; } unlock(); /* This has to be done here, because pthread_setspecific cannot * be called by our parent on our behalf. That's why the ti * pointer is passed in the new_thread_args structure. */ /* Synchronization is not a problem, because the only thread * that relies on this call having been made is this one -- * no other thread can access our TSD anyway. */ ret = pthread_setspecific(tsd_key, p->ti); if (ret != 0) { panic(ret, "gwthread-pthread: pthread_setspecific failed"); } p->ti->pid = getpid(); debug("gwlib.gwthread", 0, "Thread %ld (%s) maps to pid %ld.", p->ti->number, p->ti->name, (long) p->ti->pid); (p->func)(p->arg); lock(); debug("gwlib.gwthread", 0, "Thread %ld (%s) terminates.", p->ti->number, p->ti->name); alert_joiners(); #ifdef HAVE_LIBSSL /* Clear the OpenSSL thread-specific error queue to avoid * memory leaks. */ ERR_remove_state(gwthread_self()); #endif /* HAVE_LIBSSL */ /* Must free p before signaling our exit, otherwise there is * a race with gw_check_leaks at shutdown. */ gw_free(p); delete_threadinfo(); unlock(); return NULL; }

Here is the call graph for this function:

void restore_user_signals (  sigset_t *  old_set  )  [static]

Definition at line 424 of file gwthread-pthread.c. References panic. Referenced by gwthread_create_real(). { int ret; ret = pthread_sigmask(SIG_SETMASK, old_set, NULL); if (ret != 0) { panic(ret, "gwthread-pthread: Couldn't restore signal set."); } }

long spawn_thread (  gwthread_func_t *  func, const char *  name, void *  arg )  [static]

Definition at line 435 of file gwthread-pthread.c. References active_threads, new_thread_args::arg, debug(), error(), fill_threadinfo(), new_thread_args::func, lock, name, new_thread(), new_thread_args::ti, unlock, and warning(). Referenced by gwthread_create_real(). { int ret; pthread_t id; struct new_thread_args *p = NULL; long new_thread_id; /* We want to pass both these arguments to our wrapper function * new_thread, but the pthread_create interface will only let * us pass one pointer. So we wrap them in a little struct. */ p = gw_malloc(sizeof(*p)); p->func = func; p->arg = arg; p->ti = gw_malloc(sizeof(*(p->ti))); p->failed = 0; /* Lock the thread table here, so that new_thread can block * on that lock. That way, the new thread won't start until * we have entered it in the thread table. */ lock(); if (active_threads >= THREADTABLE_SIZE) { unlock(); warning(0, "Too many threads, could not create new thread."); gw_free(p); return -1; } ret = pthread_create(&id, NULL, &new_thread, p); if (ret != 0) { unlock(); error(ret, "Could not create new thread."); gw_free(p); return -1; } ret = pthread_detach(id); if (ret != 0) { error(ret, "Could not detach new thread."); } new_thread_id = fill_threadinfo(id, name, func, p->ti); if (new_thread_id == -1) p->failed = 1; unlock(); if (new_thread_id != -1) debug("gwlib.gwthread", 0, "Started thread %ld (%s)", new_thread_id, name); else debug("gwlib.gwthread", 0, "Failed to start thread (%s)", name); return new_thread_id; }

Here is the call graph for this function:

void unlock (  void   )  [inline, static]

Definition at line 141 of file gwthread-pthread.c. References panic, and threadtable_lock. { int ret; ret = pthread_mutex_unlock(&threadtable_lock); if (ret != 0) { panic(ret, "gwthread-pthread: could not unlock thread table"); } }

---

Variable Documentation

long active_threads = 0 [static]

Definition at line 110 of file gwthread-pthread.c. Referenced by delete_threadinfo(), fill_threadinfo(), gwthread_init(), and spawn_thread().

struct threadinfo mainthread [static]

Definition at line 122 of file gwthread-pthread.c. Referenced by delete_threadinfo(), and gwthread_init().

long next_threadnumber [static]

Definition at line 116 of file gwthread-pthread.c. Referenced by fill_threadinfo().

struct threadinfo* threadtable[THREADTABLE_SIZE] [static]

Definition at line 106 of file gwthread-pthread.c. Referenced by gwthread_init(), and gwthread_shutdown().

pthread_mutex_t threadtable_lock [static]

Definition at line 129 of file gwthread-pthread.c. Referenced by gwthread_init(), gwthread_join(), gwthread_join_every(), gwthread_shutdown(), lock(), and unlock().

pthread_key_t tsd_key [static]

Definition at line 127 of file gwthread-pthread.c. Referenced by getthreadinfo(), gwthread_init(), gwthread_self(), gwthread_self_ids(), gwthread_self_pid(), and new_thread().

See file LICENSE for details about the license agreement for using, modifying, copying or deriving work from this software.