tcptimer.c

Go to the documentation of this file.

/* TCP timer code.
 *
 */

#include <stdio.h>
#include <pthread.h>
#include <assert.h>
#include <semaphore.h>

#include "misc.h"
#include "tcpproxy.h"
#include "tcp.h"
#include "tcptimer.h"

/* Timer queue event structure. */
typedef struct timerq_event {
    long time_left;             /* Time left to go (ms).                */
    long time_queued;           /* Time this entry was queued (ms).     */
    void (*func)(void *);       /* Function to call at time.            */
    void *arg;                  /* Pointer to function argument.        */
    struct timerq_event *next;  /* Next event in the timer queue.       */
} Ttimerq_event;

static const struct timespec tick = { TIMER_MTICK/1000, 1000000*TIMER_MTICK };
static pthread_mutex_t timerq_mut = PTHREAD_MUTEX_INITIALIZER;
static Ttimerq_event *timerq_head = NULL;

/*----------------------------------------------------------------------
 * init_timer -  perform timer initialisation.
 *----------------------------------------------------------------------
 */
void init_timer()
{
    //DPRINT("init_timer: entered.\n");
}

/*----------------------------------------------------------------------
 * cleanup_timer -  performs timer cleanup
 *----------------------------------------------------------------------
 */
void cleanup_timer()
{
    Ttimerq_event *event;  /* Pointer to an event.  */
    int count = 0;

    //DPRINT("cleanup_timer: entered.\n");

    while(timerq_head != NULL) {
        event = timerq_head;
        timerq_head = timerq_head->next;
        xfree(event);
        count++;
    }
    
    if(count > 0)
        DPRINT("cleanup_timer: cleared %d events from the queue.\n", count);
}

/*----------------------------------------------------------------------
 * clear_timer -  clear the specified timer
 *                returns the time in milliseconds that the event spent
 *                in the queue, or -1 if the timer is not in the queue.
 *----------------------------------------------------------------------
 */
long clear_timer(void (*func)(void *), void *arg)
{
    Ttimerq_event *ptr, *prev_ptr;
    long dur;
    
    //DPRINT("clear_timer: entered.\n");

    mutex_lock("clear_timer", &timerq_mut);

    prev_ptr = NULL;
    for(ptr=timerq_head; ptr; ptr=ptr->next) {
        if(ptr->func == func && ptr->arg == arg) {
            //DPRINT("clear_timer: removing event.\n");
            /* Calculate time event spent in the queue. */
            dur = get_mclock() - ptr->time_queued;

            /* Remove event from queue. */
            if(prev_ptr)
                prev_ptr->next = ptr->next;
            else
                timerq_head = ptr->next;
            if(ptr->next)  /* Add time_left to next event in the queue. */
              ptr->next->time_left += ptr->time_left;

            mutex_unlock("clear_timer", &timerq_mut);
            xfree(ptr);
            return dur;
        }
    }
    mutex_unlock("clear_timer", &timerq_mut);
    return -1;
}

/*----------------------------------------------------------------------
 * clear_tcp_timer -  clear timers for the specified TCP connection
 *----------------------------------------------------------------------
 */
void clear_tcp_timers(void *arg)
{
    //DPRINT("clear_tcp_timers: entered.\n");
    clear_timer(tcp_timeout, arg);
}

/*----------------------------------------------------------------------
 * left_timer -  returns the time left for a timer, or -1 if the timer
 *               is not in the queue.
 *----------------------------------------------------------------------
 */
long left_timer(void (*func)(void *), void *arg)
{
    Ttimerq_event *ptr;
    long dur = 0;
    
    DPRINT("left_timer: entered.\n");

    mutex_lock("left_timer", &timerq_mut);
    for(ptr=timerq_head; ptr; ptr=ptr->next) {
        dur += ptr->time_left;
        if(ptr->func == func && ptr->arg == arg) {
            mutex_unlock("left_timer", &timerq_mut);
            return dur;
        }
    }
    mutex_unlock("left_timer", &timerq_mut);
    return -1;
}

/*----------------------------------------------------------------------
 * add_timer -  adds a TCP timer with pointers to the function to be
 *              called, and a tcp control block.
 *----------------------------------------------------------------------
 */
int add_timer(long mdelay, void (*func)(void *), void *arg)
{
    Ttimerq_event *event;
    Ttimerq_event *ptr, *prev_ptr;
    
    //DPRINT("add_timer: entered.\n");

    assert(mdelay >= 0);

    /* Allocate memory for and fill new event. */
    event = (Ttimerq_event *) xmalloc(sizeof(Ttimerq_event));
    event->time_left = mdelay;
    event->time_queued = get_mclock();
    event->func = func;
    event->arg = arg;
    event->next = NULL;

    clear_timer(func, arg);  /* Clear any duplicate timers. */

    mutex_lock("add_timer", &timerq_mut);

    if(timerq_head == NULL) {      /* Queue is empty, so just set head to event */
        //DPRINT("add_timer: queue empty, adding to head.\n");
        timerq_head = event;
        mutex_unlock("add_timer", &timerq_mut);
        return 0;
    }

    /* Search the list for insertion point. */
    prev_ptr = NULL;
    for(ptr=timerq_head; ptr; ptr=ptr->next) {
        if(event->time_left < ptr->time_left)  /* Need to insert event before ptr. */
            break;
        /* Decrement time left of new event by time left of events we pass. */
        event->time_left -= ptr->time_left;
        prev_ptr = ptr;
    }

    if(prev_ptr)
        prev_ptr->next = event;
    else
        timerq_head = event;
    event->next = ptr;
    if(ptr)
        ptr->time_left -= event->time_left;    

    mutex_unlock("add_timer", &timerq_mut);    
    return 0;
}

/*----------------------------------------------------------------------
 * tcp_timer -  entry point of timer thread
 *----------------------------------------------------------------------
 */
void tcp_timer(void *sig_mask)
{
    long now, last_run, delta;    /* Times in milliseconds.             */
    struct timespec time_rem;     /* Remaining time set by nanosleep.   */
    Ttimerq_event *event;         /* Temporary event variable.          */
    Ttimerq_event *expired_head;  /* Head of list of expired events.    */
    Ttimerq_event *expired_tail;  /* Tail of list of expired events.    */

    //DPRINT("tcp_timer: entered.\n");

    if(pthread_sigmask(SIG_BLOCK, sig_mask, NULL)) {
        EPRINT("tcp_timer: error blocking signals.\n");
    }

    last_run = get_mclock();
    
    while(!request_exit) {      
        while(nanosleep(&time_rem, &time_rem) == -1)
            DPRINT("tcp_timer: nanosleep returned -1, sleeping again.\n");

        mutex_lock("tcp_timer", &timerq_mut);

        now = get_mclock();
        delta = now - last_run;

        last_run = now;
        expired_head = timerq_head;

        /* Work through event list; expired events automatically
         * 'added' to expired list. */
        while(timerq_head != NULL && timerq_head->time_left <= delta) {
            delta -= timerq_head->time_left;
            timerq_head = timerq_head->next;
        }
        if(timerq_head != NULL)
            timerq_head->time_left -= delta;

        /* Assign timerq_hd to expired_tl (hd isn't usable with mutex unlocked. */
        expired_tail = timerq_head;

        mutex_unlock("tcp_timer", &timerq_mut);

        /* Now activate expired events, with timerq_mut unlocked. */
        while(expired_head != timerq_head) {
            event = expired_head;
            expired_head = expired_head->next;
            event->func(event->arg);  /* Call function. */
            xfree(event);           
        }
    }
}

---