gwthread.h File Reference

#include "gw-config.h"

Go to the source code of this file.

Macros
#define	MAIN_THREAD_ID   0
#define	gwthread_create(func, arg)   (gwthread_create_real(func, __FILE__ ":" #func, arg))

Typedefs
typedef void	gwthread_func_t(void *arg)

Functions
void	gwthread_init (void)
void	gwthread_shutdown (void)
long	gwthread_create_real (gwthread_func_t *func, const char *funcname, void *arg)
void	gwthread_join (long thread)
void	gwthread_join_every (gwthread_func_t *func)
void	gwthread_join_all (void)
long	gwthread_self (void)
long	gwthread_self_pid (void)
void	gwthread_self_ids (long *tid, long *pid)
void	gwthread_wakeup (long thread)
void	gwthread_wakeup_all (void)
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)

Macro Definition Documentation

gwthread_create

#define gwthread_create	(		func,
			arg
	)		(gwthread_create_real(func, __FILE__ ":" #func, arg))

Definition at line 90 of file gwthread.h.

Referenced by accept_thread(), add_service(), fdset_create_real(), gw_timerset_create(), heartbeat_start(), httpadmin_start(), httpd_emu_create(), init_smsbox(), main(), main_for_producer_and_consumer(), radius_acct_init(), receive_smpp_thread(), run_smppbox(), run_smsbox(), run_sqlbox(), run_wapbox(), smpp_emu(), smpp_emu_handle_pdu(), smsbox_start(), smsc2_start(), smsc_at2_create(), smsc_cgw_create(), smsc_cimd2_create(), smsc_emi2_create(), smsc_emu_create(), smsc_fake_create(), smsc_http_create(), smsc_oisd_create(), smsc_smasi_create(), smsc_smpp_create(), smsc_soap_create(), smsc_wrapper_create(), soap_server_start(), soap_start_cb(), sql_to_bearerbox(), sqlboxc_run(), start_client_threads(), start_http_thread(), start_server_thread(), start_wap(), store_file_load(), timers_init(), wait_for_connections(), wap_appl_init(), wap_push_ota_init(), wap_push_ppg_init(), wapbox_start(), wsp_push_client_init(), wsp_session_init(), wsp_unit_init(), wtp_initiator_init(), and wtp_resp_init().

MAIN_THREAD_ID

#define MAIN_THREAD_ID   0

Definition at line 77 of file gwthread.h.

Referenced by gwthread_create_real(), httpd_shutdown(), sms_router(), smsboxc_run(), udp_receiver(), and wapboxc_run().

Typedef Documentation

gwthread_func_t

typedef void gwthread_func_t(void *arg)

Definition at line 79 of file gwthread.h.

Function Documentation

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 *	funcname,
		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.

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