timer.c File Reference

---

Detailed Description

CDiameterPeer Timer Process.

Author:

Dragos Vingarzan vingarzan -at- fokus dot fraunhofer dot de

Definition in file timer.c.

#include <time.h>
#include <stdlib.h>
#include <unistd.h>
#include "utils.h"
#include "globals.h"
#include "worker.h"
#include "timer.h"

Go to the source code of this file.

Defines
#define	TIMER_RESOLUTION   1
	how many seconds to sleep on each timer iteration
Functions
int	dp_add_pid (pid_t pid)
	Add a pid to the local process list.
void	dp_del_pid (pid_t pid)
	Delete a pid from the process list.
void	timer_loop ()
	Loop that checks every TIMER_RESOLUTION seconds if some timer expired.
int	add_timer (int expires_in, int one_time, callback_f cb, void *ptr)
	Adds a timer to the timer list.
void	timer_cdp_init ()
	Init the timer structures.
void	timer_cdp_destroy ()
	Destroy the timer structures.
void	timer_process (int returns)
	Timer Process function.
Variables
timer_cb_list_t *	timers = 0
	list of timers
gen_lock_t *	timers_lock = 0
	lock for the list of timers

---

Define Documentation

#define TIMER_RESOLUTION   1

how many seconds to sleep on each timer iteration

Definition at line 75 of file timer.c.

Referenced by timer_loop().

---

Function Documentation

int dp_add_pid

(

pid_t

pid

)

[inline]

Add a pid to the local process list.

Parameters:

pid

newly forked pid

Returns:

1 on success or 0 on error

Definition at line 95 of file diameter_peer.c.

{
    pid_list_t *n;
    lock_get(pid_list_lock);
    n = shm_malloc(sizeof(pid_list_t));
    if (!n){
        LOG_NO_MEM("shm",sizeof(pid_list_t));
        lock_release(pid_list_lock);
        return 0;
    }
    n->pid = pid;
    n->next = 0;
    n->prev = pid_list->tail;
    if (!pid_list->head) pid_list->head = n;
    if (pid_list->tail) pid_list->tail->next = n;
    pid_list->tail = n;
    lock_release(pid_list_lock);
    return 1;
}

void dp_del_pid

(

pid_t

pid

)

[inline]

Delete a pid from the process list.

Parameters:

pid

- the pid to remove

Definition at line 132 of file diameter_peer.c.

{   
    pid_list_t *i;
    lock_get(pid_list_lock);
    i = pid_list->head;
    if (!i) {
        lock_release(pid_list_lock);
        return;
    }
    while(i && i->pid!=pid) i = i->next;
    if (i){
        if (i->prev) i->prev->next = i->next;
        else pid_list->head = i->next;
        if (i->next) i->next->prev = i->prev;
        else pid_list->tail = i->prev;
        shm_free(i);
    }
    lock_release(pid_list_lock);
}

void timer_loop

(

)

Loop that checks every TIMER_RESOLUTION seconds if some timer expired.

On expires, the callback is called. The callback should return rapidly in order to avoid blocking the timer process. If the timer is "one_time", then it is removed from the timers list.

Returns:

on shutdown

Definition at line 84 of file timer.c.

References _timer_cb_t::cb, _timer_cb_t::expires, timer_cb_list_t::head, _timer_cb_t::interval, _timer_cb_t::next, _timer_cb_t::one_time, _timer_cb_t::prev, _timer_cb_t::ptr, shutdownx, timer_cb_list_t::tail, TIMER_RESOLUTION, timers, and timers_lock.

Referenced by timer_process().

{
    time_t now;
    timer_cb_t *i;
    callback_f cb=0;
    void *ptr=0;
    
    while(1){
        if (shutdownx && *shutdownx) break;
        now = time(0);
        //LOG(L_DBG,"DBG:timer_loop(): The time is %u\n",(unsigned int)now);
    
        do {
            cb = 0;
            lock_get(timers_lock);
            i = timers->head;
            while(i && i->expires>now) i = i->next;
            if (i){
                cb = i->cb;
                ptr = *(i->ptr);
                if (i->one_time){
                    if (i->prev) i->prev->next = i->next;
                    else timers->head = i->next;
                    if (i->next) i->next->prev = i->prev;
                    else timers->tail = i->next;
                    shm_free(i);
                }else{
                    i->expires = now + i->interval;
                }
            }
            lock_release(timers_lock);
    
            if (cb) cb(now,ptr);
    
        } while(cb);
                
        sleep(TIMER_RESOLUTION);
    }
}

int add_timer	(	int	expires_in,
		int	one_time,
		callback_f	cb,
		void *	ptr
	)

Adds a timer to the timer list.

Parameters:

	expires_in	- time until expiration in seconds
	one_time	- if after expiration it should be removed or kept in the timers list
	cb	- callback function to be called on expiration
	ptr	- generic pointer to pass to the callback on expiration

Returns:

1 on success or 0 on failure

Definition at line 132 of file timer.c.

References _timer_cb_t::cb, _timer_cb_t::expires, timer_cb_list_t::head, _timer_cb_t::interval, LOG_NO_MEM, _timer_cb_t::next, _timer_cb_t::one_time, _timer_cb_t::prev, _timer_cb_t::ptr, timer_cb_list_t::tail, timers, and timers_lock.

Referenced by peer_manager_init(), and trans_init().

{
    timer_cb_t *n;
    if (expires_in==0){
        LOG(L_ERR,"ERROR:add_timer(): Minimum expiration time is 1 second!\n");
        return 0;
    }
    n = shm_malloc(sizeof(timer_cb_t));
    if (!n){
        LOG_NO_MEM("shm",sizeof(timer_cb_t));
        return 0;
    }
    n->ptr = shm_malloc(sizeof(void*));
    if (!n){
        LOG_NO_MEM("shm",sizeof(void*));
        shm_free(n);
        return 0;
    }
    n->expires = expires_in + time(0);
    n->one_time = one_time;
    n->interval = expires_in;
    n->cb = cb;
    *(n->ptr) = ptr;

    lock_get(timers_lock);
        n->prev = timers->tail;
        n->next = 0;
        if (!timers->head) timers->head = n;
        if (timers->tail) timers->tail->next = n;
        timers->tail = n;
    lock_release(timers_lock);
    return 1;
}

void timer_cdp_init

(

)

Init the timer structures.

Definition at line 169 of file timer.c.

References timer_cb_list_t::head, timer_cb_list_t::tail, timers, and timers_lock.

Referenced by diameter_peer_init().

{
    timers = shm_malloc(sizeof(timer_cb_list_t));
    timers->head=0;
    timers->tail=0;
    timers_lock = lock_alloc();
    timers_lock = lock_init(timers_lock);   
}

void timer_cdp_destroy

(

)

Destroy the timer structures.

Definition at line 181 of file timer.c.

References timer_cb_list_t::head, _timer_cb_t::next, _timer_cb_t::ptr, timers, and timers_lock.

Referenced by diameter_peer_destroy().

{
    timer_cb_t *n,*i;
/*  lock_get(timers_lock);*/
    i = timers->head;
    while(i){
        n = i->next;
        if (i->ptr) shm_free(i->ptr);
        shm_free(i);
        i = n;
    }
    shm_free(timers);
    lock_destroy(timers_lock);
    lock_dealloc((void*)timers_lock);
}

void timer_process

(

int

returns

)

Timer Process function.

It calls timer_loop().

Parameters:

returns

- whether on shutdown this function should return or exit

Returns:

if returns is set then on shutdown, else never and on shutdown it exits

Definition at line 203 of file timer.c.

References dp_del_pid(), memlog, and timer_loop().

Referenced by diameter_peer_start().

{
    LOG(L_INFO,"INFO:Timer process starting up...\n");
        
    timer_loop();
    
    LOG(L_INFO,"INFO:... Timer process finished\n");
    if (!returns) {
#ifdef CDP_FOR_SER
#else
#ifdef PKG_MALLOC
    #ifdef PKG_MALLOC
        LOG(memlog, "Timer Memory status (pkg):\n");
        //pkg_status();
        #ifdef pkg_sums
            pkg_sums();
        #endif 
    #endif
#endif
        dp_del_pid(getpid());       
#endif      
        
        exit(0);
    }
}

---

Variable Documentation

timer_cb_list_t* timers = 0

list of timers

Definition at line 71 of file timer.c.

Referenced by add_timer(), timer_cdp_destroy(), timer_cdp_init(), and timer_loop().

gen_lock_t* timers_lock = 0

lock for the list of timers

Definition at line 72 of file timer.c.

Referenced by add_timer(), timer_cdp_destroy(), timer_cdp_init(), and timer_loop().

---