Beispiel #1
0
int main(int argc, char *argv[])
{
	struct sigevent ev;
	timer_t tid;
	struct itimerspec its;

	ev.sigev_notify = SIGEV_SIGNAL;
	ev.sigev_signo = SIGTOTEST;

	if (timer_create(CLOCK_REALTIME, &ev, &tid) != 0) {
		perror("timer_create() did not return success\n");
		return PTS_UNRESOLVED;
	}

	if (timer_delete(tid) != 0) {
		perror("timer_delete() did not return success\n");
		return PTS_UNRESOLVED;
	}

	its.it_interval.tv_sec = 0;
	its.it_interval.tv_nsec = 0;
	its.it_value.tv_sec = TIMERSEC;
	its.it_value.tv_nsec = 0;

	if (timer_settime(tid, 0, &its, NULL) == -1) {
		if (errno==EINVAL) {
			printf("Test PASSED\n");
			return PTS_PASS;
		} else {
			printf("errno!=EINVAL after a timer_delete()\n");
			return PTS_FAIL;
		}
	} else {
		printf("timer_settime() did not fail after timer_delete()\n");
		return PTS_FAIL;
	}

	printf("This code should not be executed\n");
	return PTS_UNRESOLVED;
}
Beispiel #2
0
int main()
{
    struct itimerspec ts;
    struct sigaction  sa;
    struct sigevent   sev;
    timer_t tid;
    int j;

    /* Establish handler for notification signal */

    sa.sa_flags = SA_SIGINFO;
    sa.sa_sigaction = handler;
    sigemptyset(&sa.sa_mask);
    if (sigaction(TIMER_SIG, &sa, NULL) == -1){
        perror("sigaction");
	}

    /* Create and start timer  */

    ts.it_interval.tv_sec = 2;
    ts.it_interval.tv_nsec = 10;
    ts.it_value.tv_sec = 1;
    ts.it_value.tv_nsec = 20;

   /* pass timer id to handler */
    sev.sigev_value.sival_ptr = &tid;
    sev.sigev_notify = SIGEV_SIGNAL;    /* Notify via signal */
    sev.sigev_signo = SIGRTMAX;        /* Notify using this signal */

    if (timer_create(CLOCK_REALTIME, &sev, &tid) == -1){
            perror("timer_create");
	    exit(1);
	   }

        if (timer_settime(tid, 0, &ts, NULL) == -1)
            perror("timer_settime");

    for (;;)                            /* Wait for incoming timer signals */
        pause();
}
Beispiel #3
0
int
main(int argc, char **argv)
{
	struct sigevent ev;
	struct itimerspec ts;
	sigset_t set;
	timer_t tid;
	char *cmd = argv[0];

	ev.sigev_notify = SIGEV_SIGNAL;
	ev.sigev_signo = SIGUSR1;

	if (timer_create(CLOCK_REALTIME, &ev, &tid) == -1) {
		(void) fprintf(stderr, "%s: cannot create CLOCK_HIGHRES "
		    "timer: %s\n", cmd, strerror(errno));
		exit(EXIT_FAILURE);
	}

	(void) sigemptyset(&set);
	(void) sigaddset(&set, SIGUSR1);
	(void) sigprocmask(SIG_BLOCK, &set, NULL);

	ts.it_value.tv_sec = 1;
	ts.it_value.tv_nsec = 0;
	ts.it_interval.tv_sec = 0;
	ts.it_interval.tv_nsec = NANOSEC / 2;

	if (timer_settime(tid, TIMER_RELTIME, &ts, NULL) == -1) {
		(void) fprintf(stderr, "%s: timer_settime() failed: %s\n",
		    cmd, strerror(errno));
		exit(EXIT_FAILURE);
	}

	for (;;) {
		(void) sigwait(&set);
	}

	/*NOTREACHED*/
	return (0);
}
Beispiel #4
0
static int dynticks_start_timer(struct qemu_alarm_timer *t)
{
    struct sigevent ev;
    timer_t host_timer;
    struct sigaction act;

    sigfillset(&act.sa_mask);
    act.sa_flags = 0;
    act.sa_handler = host_alarm_handler;

    sigaction(SIGALRM, &act, NULL);

    /* 
     * Initialize ev struct to 0 to avoid valgrind complaining
     * about uninitialized data in timer_create call
     */
    memset(&ev, 0, sizeof(ev));
    ev.sigev_value.sival_int = 0;
    ev.sigev_notify = SIGEV_SIGNAL;
#ifdef SIGEV_THREAD_ID
    if (qemu_signalfd_available()) {
        ev.sigev_notify = SIGEV_THREAD_ID;
        ev._sigev_un._tid = qemu_get_thread_id();
    }
#endif /* SIGEV_THREAD_ID */
    ev.sigev_signo = SIGALRM;

    if (timer_create(CLOCK_REALTIME, &ev, &host_timer)) {
        perror("timer_create");

        /* disable dynticks */
        fprintf(stderr, "Dynamic Ticks disabled\n");

        return -1;
    }

    t->timer = host_timer;

    return 0;
}
Beispiel #5
0
asyncOp *selectNewAsyncOp(asyncBase *base)
{
  asyncOp *op = new asyncOp;
  if (op) {
    struct sigevent sEvent;
    op->internalBuffer = 0;
    op->internalBufferSize = 0;
    op->list = 0;
    op->next = 0;
    op->prev = 0;
    sEvent.sigev_notify = SIGEV_SIGNAL;
    sEvent.sigev_signo = SIGRTMIN;
    sEvent.sigev_value.sival_ptr = op;
    if (timer_create(CLOCK_REALTIME, &sEvent, &op->timerId) == -1) {
      fprintf(stderr,
              " * newSelectOp: timer_create error %s\n",
              strerror(errno));
    }
  }

  return op;
}
Beispiel #6
0
DLLEXPORT int jl_profile_start_timer(void)
{
    struct sigevent sigprof;
    struct sigaction sa;
    sigset_t ss;

    // Make sure SIGUSR2 is unblocked
    sigemptyset(&ss);
    sigaddset(&ss, SIGUSR2);
    if (sigprocmask(SIG_UNBLOCK, &ss, NULL) == -1)
        return -4;

    // Establish the signal handler
    memset(&sa, 0, sizeof(struct sigaction));
    sa.sa_flags = SA_SIGINFO;
    sa.sa_sigaction = profile_bt;
    sigemptyset(&sa.sa_mask);
    if (sigaction(SIGUSR2, &sa, NULL) == -1)
        return -1;

    // Establish the signal event
    memset(&sigprof, 0, sizeof(struct sigevent));
    sigprof.sigev_notify = SIGEV_SIGNAL;
    sigprof.sigev_signo = SIGUSR2;
    sigprof.sigev_value.sival_ptr = &timerprof;
    if (timer_create(CLOCK_REALTIME, &sigprof, &timerprof) == -1)
        return -2;

    // Start the timer
    itsprof.it_interval.tv_sec = nsecprof/GIGA;
    itsprof.it_interval.tv_nsec = nsecprof%GIGA;
    itsprof.it_value.tv_sec = nsecprof/GIGA;
    itsprof.it_value.tv_nsec = nsecprof%GIGA;
    if (timer_settime(timerprof, 0, &itsprof, NULL) == -1)
        return -3;

    running = 1;
    return 0;
}
Beispiel #7
0
err_t http_cache_init(struct ip_addr server, const char *path,
                     void (*callback)(void))
{
    struct timer *cache_timer;      /* timer for triggering cache timeouts */
    init_callback = callback;

    /* FIXME: Start the trace */
#if ENABLE_WEB_TRACING
    printf("Starting tracing\n");

    errval_t err = trace_control(TRACE_EVENT(TRACE_SUBSYS_NET,
                                    TRACE_EVENT_NET_START, 0),
                        TRACE_EVENT(TRACE_SUBSYS_NET,
                                    TRACE_EVENT_NET_STOP, 0), 0);
    if(err_is_fail(err)) {
        USER_PANIC_ERR(err, "trace_control failed");
    }
    trace_event(TRACE_SUBSYS_NET, TRACE_EVENT_NET_START, 0);
#else // ENABLE_WEB_TRACING
    printf("Tracing not enabled\n");
#endif // ENABLE_WEB_TRACING

    my_nfs_client = nfs_mount(server, path, mount_callback, NULL);
    assert(my_nfs_client != NULL);
    /* creating the empty cache */
    cache_table = NULL;
    create_404_page_cache();

    cache_timer = timer_create(MAX_STALENESS, true, cache_timeout_event,
            cache_table);
    assert (cache_timer != NULL);
    if (cache_timer == NULL) {
        printf ("http_cache_init failed in timer_create\n");
        return ERR_MEM;
    }
    timer_start(cache_timer);
    DEBUGPRINT ("http_cache_init done\n");
    return ERR_OK;
} /* end function: http_cache_init */
Beispiel #8
0
static int set_timer(timer_t *tid, unsigned int timeout)
{
	struct sigevent sigev = {};
	struct itimerspec it = {};

	sigev.sigev_notify = SIGEV_SIGNAL;
	sigev.sigev_signo = SIGRTMIN;
	sigev.sigev_value.sival_ptr = tid;

	if (timer_create(CLOCK_MONOTONIC, &sigev, tid)) {
		ploop_err(errno, "timer_create");
		return -1;
	}
	it.it_value.tv_sec = timeout;
	it.it_value.tv_nsec = 0;

	if (timer_settime(*tid, 0, &it, NULL)) {
		ploop_err(errno, "timer_settime");
		return -1;
	}
	return 0;
}
Beispiel #9
0
void streamVideo(send_frame_data_t *data) {
    // The following snippet is used to create and start a new timer that runs
    // every 40 ms.
    deleteTimer(data);
    struct sigevent play_event;
    struct itimerspec play_interval;

    memset(&play_event, 0, sizeof(play_event));
    play_event.sigev_notify = SIGEV_THREAD;
    play_event.sigev_value.sival_ptr = data;
    play_event.sigev_notify_function = send_frame;

    play_interval.it_interval.tv_sec = 0;
    play_interval.it_interval.tv_nsec = 40 * 1000000; // 40 ms in ns
    play_interval.it_value.tv_sec = 0;
    play_interval.it_value.tv_nsec = 1; // can't be zero


    timer_create(CLOCK_REALTIME, &play_event, &data->play_timer);
    timer_settime(data->play_timer, 0, &play_interval, NULL);

}
TEST(time, timer_create) {
  sigevent_t se;
  memset(&se, 0, sizeof(se));
  se.sigev_notify = SIGEV_THREAD;
  se.sigev_notify_function = NoOpNotifyFunction;
  timer_t timer_id;
  ASSERT_EQ(0, timer_create(CLOCK_MONOTONIC, &se, &timer_id));

  pid_t pid = fork();
  ASSERT_NE(-1, pid) << strerror(errno);

  if (pid == 0) {
    // Timers are not inherited by the child.
    ASSERT_EQ(-1, timer_delete(timer_id));
    ASSERT_EQ(EINVAL, errno);
    _exit(0);
  }

  AssertChildExited(pid, 0);

  ASSERT_EQ(0, timer_delete(timer_id));
}
void *time_update( void *ptr )
{
	 struct sigevent         event;
	 struct itimerspec       itime;
	 timer_t                 timer_id;
	 int                     chid, rcvid;
	 my_message_t            msg;

	 chid = ChannelCreate(0);

	 event.sigev_notify = SIGEV_PULSE;
	 event.sigev_coid = ConnectAttach(ND_LOCAL_NODE, 0,
	                                    chid,
	                                    _NTO_SIDE_CHANNEL, 0);
	 event.sigev_priority = getprio(0);
	 event.sigev_code = MY_PULSE_CODE;
	 timer_create(CLOCK_REALTIME, &event, &timer_id);

	 itime.it_value.tv_sec = 0;
	 /* 100 ms = .1 secs */
	 itime.it_value.tv_nsec = 100000000;
	 itime.it_interval.tv_sec = 0;
	 /* 100 ms = .1 secs */
	 itime.it_interval.tv_nsec = 100000000;
	 timer_settime(timer_id, 0, &itime, NULL);
	 // This for loop will update the global_time for every 100 ms which is 1 minute in simulation time.
	 for (;;) {
	     rcvid = MsgReceive(chid, &msg, sizeof(msg), NULL);
	     if (rcvid == 0) { /* we got a pulse */
	          if (msg.pulse.code == MY_PULSE_CODE) {
	          	if (global_time > 0)
	        	  global_time--;
	          	else
	          		break;
	            //printf("we got a pulse from our timer and time = %d\n", global_time);
	          } /* else other pulses ... */
	     } /* else other messages ... */
    }
}
Beispiel #12
0
AlarmTimer::AlarmTimer(void)
	:timerId(0),armed(false),expired(false)
	{
	/* Initialize the alarm timer class if this is the first one: */
	if(numAlarmTimers==0)
		{
		/* Install the signal handler: */
		struct sigaction sigAction;
		sigAction.sa_sigaction=signalHandler;
		sigemptyset(&sigAction.sa_mask);
		sigAction.sa_flags=SA_SIGINFO;
		sigaction(SIGRTMIN,&sigAction,NULL);
		}
	++numAlarmTimers;
	
	/* Create a per-process timer: */
	struct sigevent timerEvent;
	timerEvent.sigev_notify=SIGEV_SIGNAL;
	timerEvent.sigev_signo=SIGRTMIN;
	timerEvent.sigev_value.sival_ptr=this;
	timer_create(CLOCK_REALTIME,&timerEvent,&timerId);
	}
Beispiel #13
0
int setTimer(long long int duration_ns, TimerCallback callback, int signo)
{
    printf("duration_ns = %lld\n", duration_ns);
	struct sigaction action;
	struct sigevent	evp;
	struct itimerspec ispec;
	timer_t timerid = 0;

	memset(&action, 0, sizeof(action));
	memset(&evp, 0, sizeof(evp));

	/* set signal handler */
	action.sa_sigaction = SignalHandler;
	action.sa_flags = SA_SIGINFO | SA_RESTART;
	sigemptyset(&action.sa_mask);
	if(sigaction(SIGRTMIN + 1, &action, NULL) < 0){
		perror("sigaction error");
		exit(1);
	}

	/* set intarval timer (10ms) */
	evp.sigev_notify = SIGEV_SIGNAL;
	evp.sigev_signo = signo;
    evp.sigev_value.sival_ptr = (void*)(callback);
	if(timer_create(CLOCK_REALTIME, &evp, &timerid) < 0){
		perror("timer_create error");
		exit(1);
	}
	ispec.it_interval.tv_sec = 0;
	ispec.it_interval.tv_nsec = 0; // 10000000; One shot timer
	ispec.it_value.tv_sec  = int(duration_ns / 1000000000LL);
	ispec.it_value.tv_nsec = int(duration_ns % 1000000000LL);
	if(timer_settime(timerid, 0, &ispec, NULL) < 0){
		perror("timer_settime error");
		exit(1);
	}

    return 0;
}
void GKI_init(void)
{
    pthread_mutexattr_t attr;
    tGKI_OS             *p_os;

    memset (&gki_cb, 0, sizeof (gki_cb));

    gki_buffer_init();
    gki_timers_init();
    alarm_service_init();

    gki_cb.com.OSTicks = (UINT32) times(0);

    pthread_mutexattr_init(&attr);

#ifndef __CYGWIN__
    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE_NP);
#endif
    p_os = &gki_cb.os;
    pthread_mutex_init(&p_os->GKI_mutex, &attr);
    /* pthread_mutex_init(&GKI_sched_mutex, NULL); */
#if (GKI_DEBUG == TRUE)
    pthread_mutex_init(&p_os->GKI_trace_mutex, NULL);
#endif
    /* pthread_mutex_init(&thread_delay_mutex, NULL); */  /* used in GKI_delay */
    /* pthread_cond_init (&thread_delay_cond, NULL); */

    struct sigevent sigevent;
    memset(&sigevent, 0, sizeof(sigevent));
    sigevent.sigev_notify = SIGEV_THREAD;
    sigevent.sigev_notify_function = (void (*)(union sigval))bt_alarm_cb;
    sigevent.sigev_value.sival_ptr = NULL;
    if (timer_create(CLOCK_REALTIME, &sigevent, &posix_timer) == -1) {
        ALOGE("%s unable to create POSIX timer: %s", __func__, strerror(errno));
        timer_created = false;
    } else {
        timer_created = true;
    }
}
Beispiel #15
0
static int systimer_create(systimer_t* id, unsigned int period, int oneshot, systimer_proc callback, void* cbparam)
{
	struct sigevent sev;
	struct itimerspec tv;
	timer_context_t* ctx;

	ctx = (timer_context_t*)malloc(sizeof(timer_context_t));
	if(!ctx)
		return -ENOMEM;;

	memset(ctx, 0, sizeof(timer_context_t));
	ctx->callback = callback;
	ctx->cbparam = cbparam;

	memset(&sev, 0, sizeof(sev));
	sev.sigev_notify = SIGEV_THREAD;
	sev.sigev_value.sival_ptr = ctx;
	sev.sigev_notify_function = timer_schd_worker;
	if(0 != timer_create(CLOCK_MONOTONIC, &sev, &ctx->timerId))
	{
		free(ctx);
		return -errno;
	}

	tv.it_interval.tv_sec = period / 1000;
	tv.it_interval.tv_nsec = (period % 1000) * 1000000; // 10(-9)second
	tv.it_value.tv_sec = tv.it_interval.tv_sec;
	tv.it_value.tv_nsec = tv.it_interval.tv_nsec;
	if(0 != timer_settime(ctx->timerId, 0, &tv, NULL))
	{
		timer_delete(ctx->timerId);
		free(ctx);
		return -errno;
	}

	*id = (systimer_t)ctx;
	return 0;
}
Beispiel #16
0
Datei: 8-1.c Projekt: 1587/ltp
int main(void)
{
	struct sigevent ev;
	timer_t tid;
	struct itimerspec its, oits;

	ev.sigev_notify = SIGEV_SIGNAL;
	ev.sigev_signo = SIGCONT;

	its.it_interval.tv_sec = 0;
	its.it_interval.tv_nsec = 0;
	its.it_value.tv_sec = TIMERSEC;
	its.it_value.tv_nsec = 0;

	if (timer_create(CLOCK_REALTIME, &ev, &tid) != 0) {
		perror("timer_create() did not return success\n");
		return PTS_UNRESOLVED;
	}

	if (timer_settime(tid, 0, &its, &oits) != 0) {
		perror("timer_settime() did not return success\n");
		return PTS_UNRESOLVED;
	}

	if ((0 == oits.it_value.tv_sec) &&
	    (0 == oits.it_value.tv_nsec) &&
	    (0 == oits.it_interval.tv_sec) && (0 == oits.it_interval.tv_nsec)) {
		printf("Test PASSED\n");
		return PTS_PASS;
	}

	printf("Test FAILED:  value: tv_sec %d tv_nsec %d\n",
	       (int)oits.it_value.tv_sec, (int)oits.it_value.tv_nsec);
	printf("Test FAILED:  interval: tv_sec %d tv_nsec %d\n",
	       (int)oits.it_interval.tv_sec,
	       (int)oits.it_interval.tv_nsec);
	return PTS_FAIL;
}
Beispiel #17
0
int
rb_ports_sched_event(struct ev_entry *event, int when)
{
	timer_t *id;
	struct sigevent ev;
	port_notify_t not;
	struct itimerspec ts;

	event->comm_ptr = rb_malloc(sizeof(timer_t));
	id = event->comm_ptr;

	memset(&ev, 0, sizeof(ev));
	ev.sigev_notify = SIGEV_PORT;
	ev.sigev_value.sival_ptr = &not;

	memset(&not, 0, sizeof(not));
	not.portnfy_port = pe;
	not.portnfy_user = event;

	if(timer_create(CLOCK_REALTIME, &ev, id) < 0)
	{
		rb_lib_log("timer_create: %s\n", strerror(errno));
		return 0;
	}

	memset(&ts, 0, sizeof(ts));
	ts.it_value.tv_sec = when;
	ts.it_value.tv_nsec = 0;
	if(event->frequency != 0)
		ts.it_interval = ts.it_value;

	if(timer_settime(*id, 0, &ts, NULL) < 0)
	{
		rb_lib_log("timer_settime: %s\n", strerror(errno));
		return 0;
	}
	return 1;
}
Beispiel #18
0
int event_queue_add_timer(int eq, int *id, int sec) {

	static int timer_id = 0xffffff00;
	port_notify_t		pnotif;
	struct sigevent		sigev;
	itimerspec_t it;
	timer_t tid;

	timer_id++;

	pnotif.portnfy_port = eq;
	pnotif.portnfy_user = (void *) (long) timer_id;

	sigev.sigev_notify = SIGEV_PORT;
	sigev.sigev_value.sival_ptr = &pnotif;

	if (timer_create(CLOCK_REALTIME, &sigev, &tid) < 0) {
		uwsgi_error("timer_create()");
		return -1;
	}

	
	it.it_value.tv_sec = sec;
        it.it_value.tv_nsec = 0;

        it.it_interval.tv_sec = sec;
        it.it_interval.tv_nsec = 0;

	if (timer_settime(tid, 0, &it, NULL) < 0) {
		uwsgi_error("timer_settime()");
		return -1;
	}

	*id = timer_id;

	return *id;

}
Beispiel #19
0
utimer_t* utimer(
        socket_t* socket,
        packet_t* packet,
        timer_type_t type)
{
    utimer_t* new_timer = calloc(1, sizeof(utimer_t));
    new_timer->event = calloc(1, sizeof(struct sigevent));
    new_timer->event->sigev_notify = SIGEV_THREAD;   
    new_timer->event->sigev_notify_function = socket_timer_handler;
    new_timer->event->sigev_notify_attributes = NULL;    
    new_timer->event->sigev_signo = RUDP_SOCKET_SIGNAL;
    new_timer->event->sigev_value.sival_ptr = new_timer;    
    
    new_timer->socket = socket;
    new_timer->packet = packet;
    new_timer->type = type;

    timer_create(CLOCK_REALTIME, new_timer->event, &new_timer->timer);    
    
    debug_print("utimer(): %p\n", new_timer);
    
    return new_timer;
}
Beispiel #20
0
int main(int argc, char *argv[])
{
	struct sigevent ev;
	timer_t tid;

	ev.sigev_notify = SIGEV_SIGNAL;
	ev.sigev_signo = SIGALRM;

	if (timer_create(INVALIDCLOCKID, &ev, &tid) == -1) {
		if (EINVAL == errno) {
			printf("Test PASSED\n");
			return PTS_PASS;
		} else {
			printf("errno != EINVAL\n");
			printf("Test FAILED\n");
			return PTS_FAIL;
		}
	} else {
		printf("timer_create returned success\n");
		return PTS_UNRESOLVED;
	}
	return PTS_UNRESOLVED;
}
Beispiel #21
0
void MW_setTaskPeriod(double periodInSeconds, int sigNo)
{
  timer_t timerId;
  struct sigevent sev;
  struct itimerspec its;
  int ret;

  /* Create a timer */
  sev.sigev_notify = SIGEV_SIGNAL;
  sev.sigev_signo = sigNo;
  sev.sigev_value.sival_ptr = &timerId;
  ret = timer_create(CLOCK_REALTIME, &sev, &timerId);
  CHECK_STATUS(ret, "timer_create");

  /* Arm real-time scheduling timer */
  its.it_value.tv_sec = (time_t)periodInSeconds;
  its.it_value.tv_nsec = (periodInSeconds - (time_t)periodInSeconds) *
    1000000000;
  its.it_interval.tv_sec = its.it_value.tv_sec;
  its.it_interval.tv_nsec = its.it_value.tv_nsec;
  ret = timer_settime(timerId, 0, &its, NULL);
  CHECK_STATUS(ret, "timer_settime");
}
Beispiel #22
0
JL_DLLEXPORT int jl_profile_start_timer(void)
{
    struct sigevent sigprof;

    // Establish the signal event
    memset(&sigprof, 0, sizeof(struct sigevent));
    sigprof.sigev_notify = SIGEV_SIGNAL;
    sigprof.sigev_signo = SIGUSR1;
    sigprof.sigev_value.sival_ptr = &timerprof;
    if (timer_create(CLOCK_REALTIME, &sigprof, &timerprof) == -1)
        return -2;

    // Start the timer
    itsprof.it_interval.tv_sec = nsecprof/GIGA;
    itsprof.it_interval.tv_nsec = nsecprof%GIGA;
    itsprof.it_value.tv_sec = nsecprof/GIGA;
    itsprof.it_value.tv_nsec = nsecprof%GIGA;
    if (timer_settime(timerprof, 0, &itsprof, NULL) == -1)
        return -3;

    running = 1;
    return 0;
}
Beispiel #23
0
TEST(time, timer_create_SIGEV_SIGNAL) {
  sigevent_t se;
  memset(&se, 0, sizeof(se));
  se.sigev_notify = SIGEV_SIGNAL;
  se.sigev_signo = SIGUSR1;

  timer_t timer_id;
  ASSERT_EQ(0, timer_create(CLOCK_MONOTONIC, &se, &timer_id));

  ScopedSignalHandler ssh(SIGUSR1, timer_create_SIGEV_SIGNAL_signal_handler);

  ASSERT_EQ(0, timer_create_SIGEV_SIGNAL_signal_handler_invocation_count);

  itimerspec ts;
  ts.it_value.tv_sec =  0;
  ts.it_value.tv_nsec = 1;
  ts.it_interval.tv_sec = 0;
  ts.it_interval.tv_nsec = 0;
  ASSERT_EQ(0, timer_settime(timer_id, TIMER_ABSTIME, &ts, NULL));

  usleep(500000);
  ASSERT_EQ(1, timer_create_SIGEV_SIGNAL_signal_handler_invocation_count);
}
Beispiel #24
0
/*
int timer_helper::m_settimer(int timerID,callback_func func,int expireMS, int intervalMS)
{
	int res = -1;
	timer_t *t_timerid = new timer_t;
	struct sigevent evp;
	struct itimerspec its;
	struct sigaction sa;
	struct arg_callback *uc=new arg_callback;
	uc->timerid=timerID;
	uc->timerID=t_timerid;
	uc->mclass=this;
	sa.sa_flags = SA_SIGINFO;
	sa.sa_sigaction = timer_helper::timer_callback;
	sigemptyset(&sa.sa_mask);
	sigaction(SIGUSR1, &sa, NULL);
	evp.sigev_value.sival_ptr = uc;
	evp.sigev_notify = SIGEV_SIGNAL;
	evp.sigev_signo = SIGUSR1;
	res = timer_create(CLOCK_REALTIME, &evp, t_timerid);
	this->tt.insert(std::pair<int,timer_t *>(timerID,t_timerid));
	its.it_interval.tv_sec = 0;
	its.it_interval.tv_nsec = intervalMS * 1000000;
	its.it_value.tv_sec = 0;
	its.it_value.tv_nsec = expireMS * 1000000;
	timer_settime(*t_timerid, 0, &its, NULL);
	return res;
}
*/
void timer_helper::m_initTimer(timer_t *timerId, callback_func function)
{
	struct sigevent sev;
	struct sigaction sa;
	struct arg_callback *uc=new arg_callback;
	uc->timerID = timerId;
	uc->func = function;
	uc->mclass = this;
//	sev.sigev_notify = SIGEV_THREAD;
	sa.sa_flags = SA_SIGINFO;
	sa.sa_sigaction = timer_helper::timer_callback;
	sigemptyset(&sa.sa_mask);
	sigaction(SIGUSR1, &sa, NULL);
	sev.sigev_notify = SIGEV_SIGNAL;
	sev.sigev_signo = SIGUSR1;
	sev.sigev_value.sival_ptr = uc;
//	sev.sigev_notify_function = function;
	sev.sigev_notify_attributes = NULL;
	if (timer_create(CLOCK_REALTIME, &sev, timerId) == -1){
		throw std::runtime_error(std::string("ERROR:timer_create@timer_helper::m_initTimer!\n"));
	}
	this->ft.insert(std::pair<timer_t *,arg_callback *>(timerId,uc));
}
Beispiel #25
0
static bool lazy_initialize(void) {
  assert(alarms == NULL);

  pthread_mutex_init(&monitor, NULL);

  alarms = list_new(NULL);
  if (!alarms) {
    LOG_ERROR("%s unable to allocate alarm list.", __func__);
    return false;
  }

  struct sigevent sigevent;
  memset(&sigevent, 0, sizeof(sigevent));
  sigevent.sigev_notify = SIGEV_THREAD;
  sigevent.sigev_notify_function = (void (*)(union sigval))timer_callback;
  if (timer_create(CLOCK_ID, &sigevent, &timer) == -1) {
    LOG_ERROR("%s unable to create timer: %s", __func__, strerror(errno));
    return false;
  }

  alarm_expired = semaphore_new(0);
  if (!alarm_expired) {
    LOG_ERROR("%s unable to create alarm expired semaphore", __func__);
    return false;
  }

  callback_thread_active = true;
  callback_thread = thread_new("alarm_callbacks");
  if (!callback_thread) {
    LOG_ERROR("%s unable to create alarm callback thread.", __func__);
    return false;
  }

  thread_set_priority(callback_thread, CALLBACK_THREAD_PRIORITY_HIGH);
  thread_post(callback_thread, callback_dispatch, NULL);
  return true;
}
Beispiel #26
0
// XenonForceAlwaysOn is active - it doesn't need a timer, it is always on.
// Xenon needs to be started once per process.
// The number of milliseconds has to be greater than zero.
// We need to create a semaphore and a thread.
// If all of those happen, then we need a timer attached to a signal handler.
void Xenon::start(uint64_t msec) {
#ifndef __APPLE__
  TRACE(1, "XenonForceAlwaysOn %d\n", RuntimeOption::XenonForceAlwaysOn);
  if (!RuntimeOption::XenonForceAlwaysOn
      && m_timerid == 0
      && msec > 0
      && sem_init(&m_timerTriggered, 0, 0) == 0
      && pthread_create(&m_triggerThread, nullptr, s_waitThread,
          static_cast<void*>(&m_timerTriggered)) == 0) {

    time_t sec = msec / 1000;
    long nsec = (msec % 1000) * 1000000;
    TRACE(1, "Xenon::start periodic %ld seconds, %ld nanoseconds\n", sec, nsec);

    // for the initial timer, we want to stagger time for large installations
    unsigned int seed = time(nullptr);
    uint64_t msecInit = msec * (1.0 + rand_r(&seed) / (double)RAND_MAX);
    time_t fSec = msecInit / 1000;
    long fNsec = (msecInit % 1000) * 1000000;
    TRACE(1, "Xenon::start initial %ld seconds, %ld nanoseconds\n",
       fSec, fNsec);

    sigevent sev={};
    sev.sigev_notify = SIGEV_SIGNAL;
    sev.sigev_signo = SIGVTALRM;
    sev.sigev_value.sival_ptr = nullptr; // null for Xenon signals
    timer_create(CLOCK_REALTIME, &sev, &m_timerid);

    itimerspec ts={};
    ts.it_value.tv_sec = fSec;
    ts.it_value.tv_nsec = fNsec;
    ts.it_interval.tv_sec = sec;
    ts.it_interval.tv_nsec = nsec;
    timer_settime(m_timerid, 0, &ts, nullptr);
  }
#endif
}
Beispiel #27
0
int CTimer::InitSignalTimer(TimerProc proc, void* proc_arg){
	if(m_timer != 0){
		NLOG_ERROR("Timer Inited ! m_timer(=%ld) != 0", (long)m_timer);
		return -1;
	}

	m_timerArg.proc = proc;
	m_timerArg.args = proc_arg;
#if 0
	sigset_t sigset;
	sigfillset (&sigset);
	sigdelset (&sigset, SIGUSR2);
	sigprocmask (SIG_SETMASK, &sigset, NULL);
#endif

	struct sigaction action;
	memset(&action, 0, sizeof(action));
	sigemptyset(&action.sa_mask);
	action.sa_flags = SA_SIGINFO|SA_RESTART;
	action.sa_sigaction = &s_sigaction;
	if(sigaction(SIGUSR2, &action, NULL) <0){
		NLOG_ERROR("sigactin failed! err:%s", strerror(errno));
		return -1;
	}

	struct sigevent evt;
	memset(&evt, 0, sizeof(evt));
	evt.sigev_notify = SIGEV_SIGNAL;
	evt.sigev_signo = SIGUSR2;
	evt.sigev_value.sival_ptr = (void*)&m_timerArg;
	int ret = timer_create(CLOCK_REALTIME, &evt, &m_timer);
	if(m_name[0] == 0){//Name is NULL
		sprintf(m_name, "SignalTimer-%ld", (long)m_timer);
	}	

	return ret;
}
Beispiel #28
0
void storage_load(){
	APP_LOG(APP_LOG_LEVEL_INFO,"storage_load()");
	
	if(!persist_exists(STORAGE_KEY_VERSION)){ 
		APP_LOG(APP_LOG_LEVEL_WARNING,"no version"); 
		return;
	}
	if(persist_read_int(STORAGE_KEY_VERSION)!=STORAGE_VERSION){
		APP_LOG(APP_LOG_LEVEL_WARNING,"wrong version");
		return;
	}
	if(!persist_exists(STORAGE_KEY_COUNT)){ 
		APP_LOG(APP_LOG_LEVEL_ERROR,"no count"); 
		return;
	}
	uint8_t storage_count=(uint8_t)persist_read_int(STORAGE_KEY_COUNT);
 	APP_LOG(APP_LOG_LEVEL_INFO,"storage count: %d",storage_count);
	Timer* timer;
	int result;
	for(uint8_t i=0;i<storage_count;i++){
		if(!persist_exists(STORAGE_KEY_DATA+i)){ 
			APP_LOG(APP_LOG_LEVEL_ERROR,"missing timer %d in storage %d",i,STORAGE_KEY_DATA+i); 
			continue;
		}
		timer=timer_create();
		result=persist_read_data(STORAGE_KEY_DATA+i,timer,sizeof(Timer));
		if(result<0){
			APP_LOG(APP_LOG_LEVEL_ERROR,"read error timer %d in storage %d",i,STORAGE_KEY_DATA+i);
			timer_destroy(timer);
			continue;
		}
		timers_add(timer);
		APP_LOG(APP_LOG_LEVEL_INFO,"loaded timer %d",i);
	}
		
	APP_LOG(APP_LOG_LEVEL_INFO,"loaded");
}
Beispiel #29
0
/**
* @fn                   :tc_timer_timer_set_get_time
* @brief                :arm/disarm and fetch state of POSIX per-process timer
* @scenario             :arm/disarm and fetch state of POSIX per-process timer
* API's covered         :timer_create, timer_settime, timer_gettime
* Preconditions         :Creation of timer_id(timer_create)
* Postconditions        :none
* @return               :void
*/
static void tc_timer_timer_set_get_time(void)
{
	int ret_chk = ERROR;
	clockid_t clockid = CLOCK_REALTIME;
	struct sigevent st_sigevent;
	struct itimerspec st_timer_spec_set;
	struct itimerspec st_timer_spec_get;
	timer_t timer_id;

	/* Set and enable alarm */
	st_sigevent.sigev_notify = SIGEV_SIGNAL;
	st_sigevent.sigev_signo = sig_no;
	st_sigevent.sigev_value.sival_ptr = &timer_id;
	ret_chk = timer_create(clockid, &st_sigevent, &timer_id);
	TC_ASSERT_NEQ("timer_create", ret_chk, ERROR);
	TC_ASSERT_NOT_NULL("timer_create", timer_id);

	st_timer_spec_set.it_interval.tv_sec = 1;
	st_timer_spec_set.it_interval.tv_nsec = 0;	/* interval; */
	st_timer_spec_set.it_value.tv_sec = 1;
	st_timer_spec_set.it_value.tv_nsec = 0;	/* expire; */

	ret_chk = timer_settime(timer_id, 0, &st_timer_spec_set, NULL);	/* Flag =1 :TIMER_ABSTIME */
	TC_ASSERT_EQ_ERROR_CLEANUP("timer_settime", ret_chk, OK, errno, timer_delete(timer_id));

	usleep(USECINT);

	ret_chk = timer_gettime(timer_id, &st_timer_spec_get);
	TC_ASSERT_EQ_ERROR_CLEANUP("timer_gettime", ret_chk, OK, errno, timer_delete(timer_id));
	TC_ASSERT_GEQ_CLEANUP("timer_gettime", st_timer_spec_get.it_interval.tv_nsec, st_timer_spec_set.it_interval.tv_nsec, timer_delete(timer_id));
	TC_ASSERT_GEQ_CLEANUP("timer_gettime", st_timer_spec_get.it_interval.tv_sec, st_timer_spec_set.it_interval.tv_sec, timer_delete(timer_id));
	TC_ASSERT_GEQ_CLEANUP("timer_gettime", st_timer_spec_get.it_value.tv_sec, st_timer_spec_set.it_value.tv_sec, timer_delete(timer_id));
	TC_ASSERT_GEQ_CLEANUP("timer_gettime", st_timer_spec_get.it_value.tv_nsec, st_timer_spec_set.it_value.tv_nsec, timer_delete(timer_id));

	timer_delete(timer_id);
	TC_SUCCESS_RESULT();
}
Beispiel #30
-1
/* Start the timeout after which we'll receive a SIGALRM.
   Round DURATION up to the next representable value.
   Treat out-of-range values as if they were maximal,
   as that's more useful in practice than reporting an error.
   '0' means don't timeout.  */
static void
settimeout (double duration, bool warn)
{

/* timer_settime() provides potentially nanosecond resolution.
   setitimer() is more portable (to Darwin for example),
   but only provides microsecond resolution and thus is
   a little more awkward to use with timespecs, as well as being
   deprecated by POSIX.  Instead we fallback to single second
   resolution provided by alarm().  */

#if HAVE_TIMER_SETTIME
  struct timespec ts = dtotimespec (duration);
  struct itimerspec its = { {0, 0}, ts };
  timer_t timerid;
  if (timer_create (CLOCK_REALTIME, NULL, &timerid) == 0)
    {
      if (timer_settime (timerid, 0, &its, NULL) == 0)
        return;
      else
        {
          if (warn)
            error (0, errno, _("warning: timer_settime"));
          timer_delete (timerid);
        }
    }
  else if (warn && errno != ENOSYS)
    error (0, errno, _("warning: timer_create"));
#endif

  unsigned int timeint;
  if (UINT_MAX <= duration)
    timeint = UINT_MAX;
  else
    {
      unsigned int duration_floor = duration;
      timeint = duration_floor + (duration_floor < duration);
    }
  alarm (timeint);
}