gwthread-pthread.c File Reference

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

Go to the source code of this file.

Data Structures
struct	threadinfo
struct	new_thread_args

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

Functions
static void	lock (void)
static void	unlock (void)
static void	flushpipe (int fd)
static long	fill_threadinfo (pthread_t id, const char *name, gwthread_func_t *func, struct threadinfo *ti)
static struct threadinfo *	getthreadinfo (void)
static void	alert_joiners (void)
static void	delete_threadinfo (void)
void	gwthread_init (void)
void	gwthread_shutdown (void)
static void	new_thread_cleanup (void *arg)
static void *	new_thread (void *arg)
static int	block_user_signals (sigset_t *old_set_storage)
static void	restore_user_signals (sigset_t *old_set)
static 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
static struct threadinfo *	threadtable [THREADTABLE_SIZE]
static long	active_threads = 0
static long	next_threadnumber
static struct threadinfo	mainthread
static pthread_key_t	tsd_key
static pthread_mutex_t	threadtable_lock

Macro Definition Documentation

THREAD

#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().

THREADTABLE_SIZE

#define THREADTABLE_SIZE   4096

Definition at line 78 of file gwthread-pthread.c.

Referenced by fill_threadinfo(), gwthread_init(), gwthread_join_all(), gwthread_join_every(), gwthread_shutdown(), gwthread_wakeup_all(), and spawn_thread().

Function Documentation

alert_joiners()

static void alert_joiners ( void  )

static

Definition at line 236 of file gwthread-pthread.c.

References getthreadinfo(), gwlist_extract_first(), and threadinfo::joiners.

Referenced by new_thread_cleanup().

{
    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);
    }
}

block_user_signals()

static int block_user_signals ( sigset_t *  old_set_storage )

static

Definition at line 415 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;
}

delete_threadinfo()

static void delete_threadinfo ( void  )

static

Definition at line 249 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_cleanup().

{
    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);
}

fill_threadinfo()

static 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, 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;
            close(ti->wakefd_recv);
            ti->wakefd_recv = -1;
            close(ti->wakefd_send);
            ti->wakefd_send = -1;
            return -1;
        }
    } while (THREAD(ti->number) != NULL);
    THREAD(ti->number) = ti;

    active_threads++;

    return ti->number;
}

flushpipe()

static 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);
}

getthreadinfo()

static struct threadinfo* getthreadinfo ( void  )

static

Definition at line 218 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;
}

gwthread_cancel()

int gwthread_cancel

(

long

thread

)

Definition at line 843 of file gwthread-pthread.c.

References debug(), gw_assert(), lock(), threadinfo::name, threadinfo::number, threadinfo::self, THREAD, and unlock().

Referenced by main().

{
    struct threadinfo *threadinfo;
    int ret;
    
    gw_assert(thread >= 0);
    
    lock();
    threadinfo = THREAD(thread);
    if (threadinfo == NULL || threadinfo->number != thread) {
        ret = -1;
    } else {
        ret = pthread_cancel(threadinfo->self);
        debug("gwlib.gwthread", 0, "Thread %ld (%s) canceled.",
              threadinfo->number, threadinfo->name);
    }
    unlock();
    return ret;
}

gwthread_create_real()

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

Definition at line 508 of file gwthread-pthread.c.

References new_thread_args::arg, block_user_signals(), new_thread_args::func, gwthread_self(), MAIN_THREAD_ID, 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;
}

gwthread_dumpsigmask()

int gwthread_dumpsigmask

(

void

)

Definition at line 878 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;
}

gwthread_init()

void gwthread_init

(

void

)

Definition at line 267 of file gwthread-pthread.c.

References active_threads, fill_threadinfo(), mainthread, panic, threadtable, threadtable_lock, THREADTABLE_SIZE, 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");
}

gwthread_join()

void gwthread_join

(

long

thread

)

Definition at line 541 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(), gw_timerset_destroy(), gw_timerset_elapsed_destroy(), gwthread_join_all(), heartbeat_stop(), httpd_emu_destroy(), httpsmsc_receiver(), httpsmsc_sender(), io_thread(), main(), oisd_shutdown_cb(), receive_smpp_thread(), run_smppbox(), run_smsbox(), run_sqlbox(), 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. */
    pthread_cleanup_push((void(*)(void*))pthread_mutex_unlock, &threadtable_lock);
    ret = pthread_cond_wait(&exit_cond, &threadtable_lock);
    pthread_cleanup_pop(0);
    unlock();

    if (ret != 0)
        warning(ret, "gwthread_join: error in pthread_cond_wait");

    pthread_cond_destroy(&exit_cond);
}

gwthread_join_all()

void gwthread_join_all

(

void

)

Definition at line 585 of file gwthread-pthread.c.

References gwthread_join(), gwthread_self(), THREAD, and THREADTABLE_SIZE.

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);
    }
}

gwthread_join_every()

void gwthread_join_every

(

gwthread_func_t *

func

)

Definition at line 607 of file gwthread-pthread.c.

References debug(), threadinfo::func, gwlist_append(), gwlist_create, threadinfo::joiners, lock(), threadinfo::name, threadinfo::number, THREAD, threadtable_lock, THREADTABLE_SIZE, 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);
        pthread_cleanup_push((void(*)(void*))pthread_mutex_unlock, &threadtable_lock);
        ret = pthread_cond_wait(&exit_cond, &threadtable_lock);
        pthread_cleanup_pop(0);
        if (ret != 0)
            warning(ret, "gwthread_join_all: error in pthread_cond_wait");
    }
    unlock();

    pthread_cond_destroy(&exit_cond);
}

gwthread_poll()

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

Definition at line 740 of file gwthread-pthread.c.

References error(), pollfd::events, pollfd::fd, flushpipe(), getthreadinfo(), poll, POLL_NOTIMEOUT, POLLIN, pollfd::revents, 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;
}

gwthread_pollfd()

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

Definition at line 706 of file gwthread-pthread.c.

References error(), pollfd::events, pollfd::fd, flushpipe(), getthreadinfo(), poll, POLL_NOTIMEOUT, POLLIN, 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;
}

gwthread_self()

long gwthread_self

(

void

)

Definition at line 650 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(), format(), 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_cleanup(), producer(), and push_thread().

{
    struct threadinfo *threadinfo;
    threadinfo = pthread_getspecific(tsd_key);
    if (threadinfo) 
        return threadinfo->number;
    else
        return -1;
}

gwthread_self_ids()

void gwthread_self_ids	(	long *	tid,
		long *	pid
	)

Definition at line 671 of file gwthread-pthread.c.

References threadinfo::number, threadinfo::pid, 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();
    }
}

gwthread_self_pid()

long gwthread_self_pid

(

void

)

Definition at line 661 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();
}

gwthread_shouldhandlesignal()

int gwthread_shouldhandlesignal

(

int

signal

)

Definition at line 867 of file gwthread-pthread.c.

Referenced by signal_handler().

                                           {
    return 1;
}

gwthread_shutdown()

void gwthread_shutdown

(

void

)

Definition at line 296 of file gwthread-pthread.c.

References debug(), gw_assert(), lock(), name, number, running, threadtable, threadtable_lock, THREADTABLE_SIZE, 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. */
}

gwthread_sleep()

void gwthread_sleep

(

double

seconds

)

Definition at line 780 of file gwthread-pthread.c.

References pollfd::events, pollfd::fd, flushpipe(), getthreadinfo(), poll, POLL_NOTIMEOUT, POLLIN, threadinfo::wakefd_recv, and warning().

Referenced by at2_detect_modem_type(), at2_device_thread(), at2_init_device(), at2_login_device(), at2_send_one_message(), at2_write(), at2_write_ctrlz(), at2_write_line(), bb_smscconn_receive_internal(), cgw_open_send_connection(), client_thread(), emi2_do_send(), emi2_wait(), heartbeat_thread(), httpd_check_authorization(), httpsmsc_send_cb(), httpsmsc_sender(), io_thread(), main(), main_connection_loop(), open_send_connection(), parachute_start(), poller(), port_remove(), push_thread(), reconnect(), restart_box(), send_message(), send_messages(), send_smpp_thread(), server_thread(), smasi_thread(), smpp_to_bearerbox(), sms_router(), sms_to_smsboxes(), smsbox_thread(), smsboxc_run(), smsc2_graceful_restart(), soap_listener(), soap_server(), sql_list(), sql_single(), 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);
    }
}

gwthread_sleep_micro()

void gwthread_sleep_micro

(

double

dseconds

)

Definition at line 808 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);
    }
}

gwthread_wakeup()

void gwthread_wakeup

(

long

thread

)

Definition at line 684 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(), client_destroy(), emi2_idleprocessing(), emi2_listener(), emi2_sender(), gw_timer_elapsed_start(), gw_timer_elapsed_start_cb(), gw_timer_start(), gw_timerset_destroy(), gw_timerset_elapsed_destroy(), gwthread_wakeup_all(), gwtimer_start(), heartbeat_stop(), http_close_all_ports(), http_close_port(), http_open_port_if(), httpd_shutdown(), httpsmsc_receiver(), httpsmsc_sender(), httpsmsc_shutdown(), io_thread(), 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_graceful_restart(), 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);
}

gwthread_wakeup_all()

void gwthread_wakeup_all

(

void

)

Definition at line 596 of file gwthread-pthread.c.

References gwthread_self(), gwthread_wakeup(), THREAD, and THREADTABLE_SIZE.

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);
    }
}

lock()

static void lock ( void  )

inlinestatic

Definition at line 131 of file gwthread-pthread.c.

References panic, and threadtable_lock.

Referenced by gwthread_cancel(), gwthread_join(), gwthread_join_every(), gwthread_shutdown(), gwthread_wakeup(), new_thread(), new_thread_cleanup(), and spawn_thread().

{
    int ret;

    ret = pthread_mutex_lock(&threadtable_lock);
    if (ret != 0) {
        panic(ret, "gwthread-pthread: could not lock thread table");
    }
}

new_thread()

static void* new_thread ( void *  arg )

static

Definition at line 354 of file gwthread-pthread.c.

References new_thread_args::arg, debug(), new_thread_args::failed, new_thread_args::func, lock(), threadinfo::name, new_thread_cleanup(), 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->ti);
        gw_free(p);
        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);

    /* set cancel cleanup function */
    pthread_cleanup_push(new_thread_cleanup, p);

    (p->func)(p->arg);

    pthread_cleanup_pop(0);

    new_thread_cleanup(p);

    return NULL;
}

new_thread_cleanup()

static void new_thread_cleanup ( void *  arg )

static

Definition at line 332 of file gwthread-pthread.c.

References alert_joiners(), new_thread_args::arg, debug(), delete_threadinfo(), gwthread_self(), lock(), threadinfo::name, threadinfo::number, new_thread_args::ti, and unlock().

Referenced by new_thread().

{
    struct new_thread_args *p = arg;

    lock();
    debug("gwlib.gwthread", 0, "Thread %ld (%s) terminates.",
          p->ti->number, p->ti->name);
    alert_joiners();
#ifdef HAVE_LIBSSL
#if OPENSSL_VERSION_NUMBER < 0x10100000L
    /* Clear the OpenSSL thread-specific error queue to avoid
     * memory leaks. */
    ERR_remove_state(gwthread_self());
#endif
#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();
}

restore_user_signals()

static void restore_user_signals ( sigset_t *  old_set )

static

Definition at line 442 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.");
    }
}

spawn_thread()

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

static

Definition at line 453 of file gwthread-pthread.c.

References active_threads, new_thread_args::arg, debug(), error(), new_thread_args::failed, fill_threadinfo(), new_thread_args::func, lock(), name, new_thread(), THREADTABLE_SIZE, new_thread_args::ti, and unlock().

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();
        error(0, "Too many threads, could not create new thread.");
        gw_free(p->ti);
        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->ti);
        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;
}

unlock()

static void unlock ( void  )

inlinestatic

Definition at line 141 of file gwthread-pthread.c.

References panic, and threadtable_lock.

Referenced by gwthread_cancel(), gwthread_join(), gwthread_join_every(), gwthread_shutdown(), gwthread_wakeup(), new_thread(), new_thread_cleanup(), and spawn_thread().

{
    int ret;

    ret = pthread_mutex_unlock(&threadtable_lock);
    if (ret != 0) {
        panic(ret, "gwthread-pthread: could not unlock thread table");
    }
}

Variable Documentation

active_threads

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().

mainthread

struct threadinfo mainthread

static

Definition at line 122 of file gwthread-pthread.c.

Referenced by delete_threadinfo(), and gwthread_init().

next_threadnumber

long next_threadnumber

static

Definition at line 116 of file gwthread-pthread.c.

Referenced by fill_threadinfo().

threadtable

struct threadinfo* threadtable[THREADTABLE_SIZE]

static

Definition at line 106 of file gwthread-pthread.c.

Referenced by gwthread_init(), and gwthread_shutdown().

threadtable_lock

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().

tsd_key

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().