lib/isc/timer.c

34 #include <isc/timer.h>
82 	/*! Locked by timer lock. */
137 isc__timer_reset(isc_timer_t *timer, isc_timertype_t type,
141 isc__timer_gettype(isc_timer_t *timer);
143 isc__timer_touch(isc_timer_t *timer);
201 schedule(isc__timer_t *timer, isc_time_t *now, isc_boolean_t signal_ok) {
214 	REQUIRE(timer->type != isc_timertype_inactive);
220 	manager = timer->manager;
234 	if (timer->type != isc_timertype_once) {
235 		result = isc_time_add(now, &timer->interval, &due);
238 		if (timer->type == isc_timertype_limited &&
239 		    isc_time_compare(&timer->expires, &due) < 0)
240 			due = timer->expires;
242 		if (isc_time_isepoch(&timer->idle))
243 			due = timer->expires;
244 		else if (isc_time_isepoch(&timer->expires))
245 			due = timer->idle;
246 		else if (isc_time_compare(&timer->idle, &timer->expires) < 0)
247 			due = timer->idle;
249 			due = timer->expires;
253 	 * Schedule the timer.
256 	if (timer->index > 0) {
260 		cmp = isc_time_compare(&due, &timer->due);
261 		timer->due = due;
264 			isc_heap_increased(manager->heap, timer->index);
267 			isc_heap_decreased(manager->heap, timer->index);
274 		timer->due = due;
275 		result = isc_heap_insert(manager->heap, timer);
284 				   ISC_MSG_SCHEDULE, "schedule"), timer, due);
287 	 * If this timer is at the head of the queue, we need to ensure
289 	 * the current "next" timer.  We do this either by waking up the
319 	if (timer->index == 1 && signal_ok) {
326 	if (timer->index == 1 &&
327 	    isc_time_compare(&timer->due, &manager->due) < 0)
328 		manager->due = timer->due;
335 deschedule(isc__timer_t *timer) {
345 	manager = timer->manager;
346 	if (timer->index > 0) {
348 		if (timer->index == 1)
351 		isc_heap_delete(manager->heap, timer->index);
352 		timer->index = 0;
367 destroy(isc__timer_t *timer) {
368 	isc__timermgr_t *manager = timer->manager;
371 	 * The caller must ensure it is safe to destroy the timer.
376 	(void)isc_task_purgerange(timer->task,
377 				  timer,
381 	deschedule(timer);
382 	UNLINK(manager->timers, timer, link);
386 	isc_task_detach(&timer->task);
387 	DESTROYLOCK(&timer->lock);
388 	timer->common.impmagic = 0;
389 	timer->common.magic = 0;
390 	isc_mem_put(manager->mctx, timer, sizeof(*timer));
400 	isc__timer_t *timer;
405 	 * Create a new 'type' timer managed by 'manager'.  The timers
408 	 * called with 'arg' as the arg value.  The new timer is returned
440 	timer = isc_mem_get(manager->mctx, sizeof(*timer));
441 	if (timer == NULL)
444 	timer->manager = manager;
445 	timer->references = 1;
448 		result = isc_time_add(&now, interval, &timer->idle);
450 			isc_mem_put(manager->mctx, timer, sizeof(*timer));
454 		isc_time_settoepoch(&timer->idle);
456 	timer->type = type;
457 	timer->expires = *expires;
458 	timer->interval = *interval;
459 	timer->task = NULL;
460 	isc_task_attach(task, &timer->task);
461 	timer->action = action;
464 	 * evils here.  If the timer->arg member is made const, then
465 	 * it affects a great many recipients of the timer event
472 	DE_CONST(arg, timer->arg);
473 	timer->index = 0;
474 	result = isc_mutex_init(&timer->lock);
476 		isc_task_detach(&timer->task);
477 		isc_mem_put(manager->mctx, timer, sizeof(*timer));
480 	ISC_LINK_INIT(timer, link);
481 	timer->common.impmagic = TIMER_MAGIC;
482 	timer->common.magic = ISCAPI_TIMER_MAGIC;
483 	timer->common.methods = (isc_timermethods_t *)&timermethods;
488 	 * Note we don't have to lock the timer like we normally would because
493 		result = schedule(timer, &now, ISC_TRUE);
497 		APPEND(manager->timers, timer, link);
502 		timer->common.impmagic = 0;
503 		timer->common.magic = 0;
504 		DESTROYLOCK(&timer->lock);
505 		isc_task_detach(&timer->task);
506 		isc_mem_put(manager->mctx, timer, sizeof(*timer));
510 	*timerp = (isc_timer_t *)timer;
520 	isc__timer_t *timer = (isc__timer_t *)timer0;
526 	 * Change the timer's type, expires, and interval values to the given
527 	 * values.  If 'purge' is ISC_TRUE, any pending events from this timer
531 	REQUIRE(VALID_TIMER(timer));
532 	manager = timer->manager;
559 	LOCK(&timer->lock);
562 		(void)isc_task_purgerange(timer->task,
563 					  timer,
567 	timer->type = type;
568 	timer->expires = *expires;
569 	timer->interval = *interval;
571 		result = isc_time_add(&now, interval, &timer->idle);
573 		isc_time_settoepoch(&timer->idle);
579 			deschedule(timer);
582 			result = schedule(timer, &now, ISC_TRUE);
585 	UNLOCK(&timer->lock);
593 	isc__timer_t *timer = (isc__timer_t *)timer0;
596 	REQUIRE(VALID_TIMER(timer));
598 	LOCK(&timer->lock);
599 	t = timer->type;
600 	UNLOCK(&timer->lock);
607 	isc__timer_t *timer = (isc__timer_t *)timer0;
612 	 * Set the last-touched time of 'timer' to the current time.
615 	REQUIRE(VALID_TIMER(timer));
617 	LOCK(&timer->lock);
622 	 *	REQUIRE(timer->type == isc_timertype_once);
629 	result = isc_time_add(&now, &timer->interval, &timer->idle);
631 	UNLOCK(&timer->lock);
638 	isc__timer_t *timer = (isc__timer_t *)timer0;
641 	 * Attach *timerp to timer.
644 	REQUIRE(VALID_TIMER(timer));
647 	LOCK(&timer->lock);
648 	timer->references++;
649 	UNLOCK(&timer->lock);
651 	*timerp = (isc_timer_t *)timer;
656 	isc__timer_t *timer;
660 	 * Detach *timerp from its timer.
664 	timer = (isc__timer_t *)*timerp;
665 	REQUIRE(VALID_TIMER(timer));
667 	LOCK(&timer->lock);
668 	REQUIRE(timer->references > 0);
669 	timer->references--;
670 	if (timer->references == 0)
672 	UNLOCK(&timer->lock);
675 		destroy(timer);
685 	isc__timer_t *timer;
694 		timer = isc_heap_element(manager->heap, 1);
695 		INSIST(timer->type != isc_timertype_inactive);
696 		if (isc_time_compare(now, &timer->due) >= 0) {
697 			if (timer->type == isc_timertype_ticker) {
701 			} else if (timer->type == isc_timertype_limited) {
703 				cmp = isc_time_compare(now, &timer->expires);
713 			} else if (!isc_time_isepoch(&timer->expires) &&
715 						    &timer->expires) >= 0) {
722 				LOCK(&timer->lock);
723 				if (!isc_time_isepoch(&timer->idle) &&
725 						     &timer->idle) >= 0) {
728 				UNLOCK(&timer->lock);
735 					 * Idle timer has been touched;
742 						 timer);
752 							"posting"), timer);
757 							   timer,
759 							   timer->action,
760 							   timer->arg,
764 					event->due = timer->due;
765 					isc_task_send(timer->task,
776 			timer->index = 0;
781 				result = schedule(timer, now, ISC_FALSE);
789 							"timer"),
793 			manager->due = timer->due;
862 	isc__timer_t *timer;
864 	timer = what;
865 	REQUIRE(VALID_TIMER(timer));
867 	timer->index = index;
876 	 * Create a timer manager.
970 	 * Destroy a timer manager.