timer_proc.c

Go to the documentation of this file.

/* 
 * $Id$
 * 
 * Copyright (C) 2009 iptelorg GmbH
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
/*
 * timer_proc.c  - separate process timers
 * (unrelated to the main fast and slow timers)
 */
/*
 * History:
 * --------
 *  2009-03-10  initial version (andrei)
*/

#include "timer_proc.h"
#include "cfg/cfg_struct.h"
#include "pt.h"
#include "ut.h"
#include "mem/shm_mem.h"

#include <unistd.h>


int register_basic_timers(int timers)
{
        if(register_procs(timers)<0)
                return -1;
        cfg_register_child(timers);
        return 0;
}

int fork_basic_timer(int child_id, char* desc, int make_sock,
                                                timer_function* f, void* param, int interval)
{
        int pid;
        
        pid=fork_process(child_id, desc, make_sock);
        if (pid<0) return -1;
        if (pid==0){
                /* child */
                if (cfg_child_init()) return -1;
                for(;;){
                        sleep(interval);
                        cfg_update();
                        f(get_ticks(), param); /* ticks in s for compatibility with old
                                                                          timers */
                }
        }
        /* parent */
        return pid;
}

int fork_basic_utimer(int child_id, char* desc, int make_sock,
                                                utimer_function* f, void* param, int uinterval)
{
        int pid;
        ticks_t ts;
        
        pid=fork_process(child_id, desc, make_sock);
        if (pid<0) return -1;
        if (pid==0){
                /* child */
                if (cfg_child_init()) return -1;
                for(;;){
                        sleep_us(uinterval);
                        cfg_update();
                        ts = get_ticks_raw();
                        f(TICKS_TO_MS(ts), param); /* ticks in mili-seconds */
                }
        }
        /* parent */
        return pid;
}


int fork_local_timer_process(int child_id, char* desc, int make_sock,
                                                struct local_timer** lt_h)
{
        int pid;
        struct local_timer* lt;
        
        lt=shm_malloc(sizeof(*lt));
        if (lt==0) goto error;
        if (init_local_timer(lt, get_ticks_raw())<0) goto error;
        pid=fork_process(child_id, desc, make_sock);
        if (pid<0) goto error;
        *lt_h=lt;
        return pid;
error:
        if (lt) shm_free(lt);
        return -1;
}

int register_sync_timers(int timers)
{
        if(register_procs(timers)<0)
                return -1;
        cfg_register_child(timers);
        return 0;
}

int fork_sync_timer(int child_id, char* desc, int make_sock,
                                                timer_function* f, void* param, int interval)
{
        int pid;
        ticks_t ts1 = 0;
        ticks_t ts2 = 0;

        pid=fork_process(child_id, desc, make_sock);
        if (pid<0) return -1;
        if (pid==0){
                /* child */
                ts2 = interval;
                if (cfg_child_init()) return -1;
                for(;;){
                        if(ts2>0) sleep(ts2);
                        else sleep(1);
                        ts1 = get_ticks();
                        cfg_update();
                        f(get_ticks(), param); /* ticks in s for compatibility with old
                                                                          timers */
                        ts2 = interval - get_ticks() + ts1;
                }
        }
        /* parent */
        return pid;
}


int fork_sync_utimer(int child_id, char* desc, int make_sock,
                                                utimer_function* f, void* param, int uinterval)
{
        int pid;
        ticks_t ts1 = 0;
        ticks_t ts2 = 0;

        pid=fork_process(child_id, desc, make_sock);
        if (pid<0) return -1;
        if (pid==0){
                /* child */
                ts2 = uinterval;
                if (cfg_child_init()) return -1;
                for(;;){
                        if(ts2>0) sleep_us(uinterval);
                        else sleep_us(1);
                        ts1 = get_ticks_raw();
                        cfg_update();
                        f(TICKS_TO_MS(ts1), param); /* ticks in mili-seconds */
                        ts2 = uinterval - get_ticks_raw() + ts1;
                }
        }
        /* parent */
        return pid;
}


/* vi: set ts=4 sw=4 tw=79:ai:cindent: */