static void tick (isc_task_t * task, isc_event_t * event) { char *name = event->ev_arg; INSIST (event->ev_type == ISC_TIMEREVENT_TICK); printf ("task %s (%p) tick\n", name, task); tick_count++; if (ti3 != NULL && tick_count % 3 == 0) isc_timer_touch (ti3); if (ti3 != NULL && tick_count == 7) { isc_time_t expires; isc_interval_t interval; isc_interval_set (&interval, 5, 0); (void) isc_time_nowplusinterval (&expires, &interval); isc_interval_set (&interval, 4, 0); printf ("*** resetting ti3 ***\n"); RUNTIME_CHECK (isc_timer_reset (ti3, isc_timertype_once, &expires, &interval, ISC_TRUE) == ISC_R_SUCCESS); } isc_event_free (&event); }
isc_result_t dns_timer_setidle(isc_timer_t *timer, unsigned int maxtime, unsigned int idletime, isc_boolean_t purge) { isc_result_t result; isc_interval_t maxinterval, idleinterval; isc_time_t expires; /* Compute the time of expiry. */ isc_interval_set(&maxinterval, maxtime, 0); CHECK(isc_time_nowplusinterval(&expires, &maxinterval)); /* * Compute the idle interval, and add a spare nanosecond to * work around the silly limitation of the ISC timer interface * that you cannot specify an idle interval of zero. */ isc_interval_set(&idleinterval, idletime, 1); CHECK(isc_timer_reset(timer, isc_timertype_once, &expires, &idleinterval, purge)); failure: return (result); }
/** * Wait on semaphore. This operation will try to acquire a lock on the * semaphore. If the semaphore is already acquired as many times at it allows, * the function will block until someone releases the lock OR timeout expires. * * @return ISC_R_SUCCESS or ISC_R_TIMEDOUT or other errors from ISC libs */ isc_result_t semaphore_wait_timed(semaphore_t *const sem, const isc_interval_t * const timeout) { isc_result_t result; isc_time_t abs_timeout; REQUIRE(sem != NULL); CHECK(isc_time_nowplusinterval(&abs_timeout, timeout)); LOCK(&sem->mutex); while (sem->value <= 0) CHECK(WAITUNTIL(&sem->cond, &sem->mutex, &abs_timeout)); sem->value--; cleanup: UNLOCK(&sem->mutex); return result; }
static void t3(void) { int result; int isc_result; isc_time_t expires; isc_interval_t interval; t_assert("isc_timer_create", 3, T_REQUIRED, "%s", a3); if (threaded) { Tx_nfails = 0; Tx_nprobs = 0; Tx_nevents = 1; Tx_seconds = T3_SECONDS; Tx_nanoseconds = T3_NANOSECONDS; isc_interval_set(&interval, Tx_seconds + 1, Tx_nanoseconds); isc_result = isc_time_nowplusinterval(&expires, &interval); if (isc_result == ISC_R_SUCCESS) { isc_interval_set(&interval, Tx_seconds, Tx_nanoseconds); t_timers_x(isc_timertype_once, &expires, &interval, t3_te); } else { t_info("isc_time_nowplusinterval failed %s\n", isc_result_totext(isc_result)); ++Tx_nprobs; } result = T_UNRESOLVED; if ((Tx_nfails == 0) && (Tx_nprobs == 0)) result = T_PASS; else if (Tx_nfails) result = T_FAIL; t_result(result); } else require_threads(); }
static isc_result_t cache_node_create(ldap_cache_t *cache, ldapdb_rdatalist_t rdatalist, cache_node_t **nodep) { isc_result_t result; cache_node_t *node; REQUIRE(cache != NULL); REQUIRE(nodep != NULL && *nodep == NULL); CHECKED_MEM_GET_PTR(cache->mctx, node); ZERO_PTR(node); isc_mem_attach(cache->mctx, &node->mctx); node->rdatalist = rdatalist; CHECK(isc_time_nowplusinterval(&node->valid_until, &cache->cache_ttl)); *nodep = node; return ISC_R_SUCCESS; cleanup: SAFE_MEM_PUT_PTR(cache->mctx, node); return result; }
static int t_timers5(void) { char *p; int result; isc_mem_t *mctx; isc_taskmgr_t *tmgr; unsigned int workers; isc_result_t isc_result; isc_timermgr_t *timermgr; isc_event_t *event; isc_time_t expires; isc_interval_t interval; T5_startflag = 0; T5_shutdownflag = 0; T5_eventcnt = 0; workers = 2; p = t_getenv("ISC_TASK_WORKERS"); if (p != NULL) workers = atoi(p); mctx = NULL; isc_result = isc_mem_create(0, 0, &mctx); if (isc_result != ISC_R_SUCCESS) { t_info("isc_mem_create failed %s\n", isc_result_totext(isc_result)); return(T_UNRESOLVED); } isc_result = isc_mutex_init(&T5_mx); if (isc_result != ISC_R_SUCCESS) { t_info("isc_mutex_init failed %s\n", isc_result_totext(isc_result)); isc_mem_destroy(&mctx); return(T_UNRESOLVED); } isc_result = isc_condition_init(&T5_cv); if (isc_result != ISC_R_SUCCESS) { t_info("isc_condition_init failed %s\n", isc_result_totext(isc_result)); DESTROYLOCK(&T5_mx); isc_mem_destroy(&mctx); return(T_UNRESOLVED); } tmgr = NULL; isc_result = isc_taskmgr_create(mctx, workers, 0, &tmgr); if (isc_result != ISC_R_SUCCESS) { t_info("isc_taskmgr_create failed %s\n", isc_result_totext(isc_result)); DESTROYLOCK(&T5_mx); (void) isc_condition_destroy(&T5_cv); isc_mem_destroy(&mctx); return(T_UNRESOLVED); } timermgr = NULL; isc_result = isc_timermgr_create(mctx, &timermgr); if (isc_result != ISC_R_SUCCESS) { t_info("isc_timermgr_create failed %s\n", isc_result_totext(isc_result)); isc_taskmgr_destroy(&tmgr); DESTROYLOCK(&T5_mx); (void) isc_condition_destroy(&T5_cv); isc_mem_destroy(&mctx); return(T_UNRESOLVED); } T5_task1 = NULL; isc_result = isc_task_create(tmgr, 0, &T5_task1); if (isc_result != ISC_R_SUCCESS) { t_info("isc_task_create failed %s\n", isc_result_totext(isc_result)); isc_timermgr_destroy(&timermgr); isc_taskmgr_destroy(&tmgr); DESTROYLOCK(&T5_mx); (void) isc_condition_destroy(&T5_cv); isc_mem_destroy(&mctx); return(T_UNRESOLVED); } isc_result = isc_task_onshutdown(T5_task1, t5_shutdown_event, NULL); if (isc_result != ISC_R_SUCCESS) { t_info("isc_task_onshutdown failed %s\n", isc_result_totext(isc_result)); isc_timermgr_destroy(&timermgr); isc_task_destroy(&T5_task1); isc_taskmgr_destroy(&tmgr); DESTROYLOCK(&T5_mx); (void) isc_condition_destroy(&T5_cv); isc_mem_destroy(&mctx); return(T_UNRESOLVED); } T5_task2 = NULL; isc_result = isc_task_create(tmgr, 0, &T5_task2); if (isc_result != ISC_R_SUCCESS) { t_info("isc_task_create failed %s\n", isc_result_totext(isc_result)); isc_timermgr_destroy(&timermgr); isc_task_destroy(&T5_task1); isc_taskmgr_destroy(&tmgr); DESTROYLOCK(&T5_mx); (void) isc_condition_destroy(&T5_cv); isc_mem_destroy(&mctx); return(T_UNRESOLVED); } isc_result = isc_mutex_lock(&T5_mx); if (isc_result != ISC_R_SUCCESS) { t_info("isc_mutex_lock failed %s\n", isc_result_totext(isc_result)); isc_timermgr_destroy(&timermgr); isc_taskmgr_destroy(&tmgr); DESTROYLOCK(&T5_mx); (void) isc_condition_destroy(&T5_cv); isc_mem_destroy(&mctx); return(T_UNRESOLVED); } event = isc_event_allocate(mctx, (void *)1 , (isc_eventtype_t)1, t5_start_event, NULL, sizeof(*event)); isc_task_send(T5_task1, &event); isc_time_settoepoch(&expires); isc_interval_set(&interval, T5_SECONDS, 0); T5_tickertimer = NULL; isc_result = isc_timer_create(timermgr, isc_timertype_ticker, &expires, &interval, T5_task1, t5_tick_event, NULL, &T5_tickertimer); if (isc_result != ISC_R_SUCCESS) { isc_timermgr_destroy(&timermgr); (void) isc_condition_signal(&T5_cv); (void) isc_mutex_unlock(&T5_mx); isc_task_destroy(&T5_task1); isc_task_destroy(&T5_task2); isc_taskmgr_destroy(&tmgr); DESTROYLOCK(&T5_mx); (void) isc_condition_destroy(&T5_cv); isc_mem_destroy(&mctx); return(T_UNRESOLVED); } T5_oncetimer = NULL; isc_interval_set(&interval, (T5_SECONDS * T5_NTICKS) + 2, 0); isc_result = isc_time_nowplusinterval(&expires, &interval); if (isc_result != ISC_R_SUCCESS) { isc_timer_detach(&T5_tickertimer); isc_timermgr_destroy(&timermgr); (void)isc_condition_signal(&T5_cv); (void)isc_mutex_unlock(&T5_mx); isc_task_destroy(&T5_task1); isc_task_destroy(&T5_task2); isc_taskmgr_destroy(&tmgr); DESTROYLOCK(&T5_mx); (void) isc_condition_destroy(&T5_cv); isc_mem_destroy(&mctx); return(T_UNRESOLVED); } isc_interval_set(&interval, 0, 0); isc_result = isc_timer_create(timermgr, isc_timertype_once, &expires, &interval, T5_task2, t5_once_event, NULL, &T5_oncetimer); if (isc_result != ISC_R_SUCCESS) { isc_timer_detach(&T5_tickertimer); isc_timermgr_destroy(&timermgr); (void) isc_condition_signal(&T5_cv); (void) isc_mutex_unlock(&T5_mx); isc_task_destroy(&T5_task1); isc_task_destroy(&T5_task2); isc_taskmgr_destroy(&tmgr); DESTROYLOCK(&T5_mx); (void) isc_condition_destroy(&T5_cv); isc_mem_destroy(&mctx); ++T5_nprobs; return(T_UNRESOLVED); } /* * Wait for shutdown processing to complete. */ while (! T5_shutdownflag) { isc_result = isc_condition_wait(&T5_cv, &T5_mx); if (isc_result != ISC_R_SUCCESS) { t_info("isc_condition_waituntil failed %s\n", isc_result_totext(isc_result)); ++T5_nprobs; } } isc_result = isc_mutex_unlock(&T5_mx); if (isc_result != ISC_R_SUCCESS) { t_info("isc_mutex_unlock failed %s\n", isc_result_totext(isc_result)); ++T5_nprobs; } if (T5_eventcnt != 1) { t_info("processed %d events\n", T5_eventcnt); ++T5_nfails; } isc_timer_detach(&T5_tickertimer); isc_timer_detach(&T5_oncetimer); isc_timermgr_destroy(&timermgr); isc_task_destroy(&T5_task1); isc_task_destroy(&T5_task2); isc_taskmgr_destroy(&tmgr); DESTROYLOCK(&T5_mx); (void) isc_condition_destroy(&T5_cv); isc_mem_destroy(&mctx); result = T_UNRESOLVED; if ((T5_nfails == 0) && (T5_nprobs == 0)) result = T_PASS; else if (T5_nfails) result = T_FAIL; return (result); }
static void t4_te(isc_task_t *task, isc_event_t *event) { isc_result_t isc_result; isc_time_t now; isc_time_t base; isc_time_t ulim; isc_time_t llim; isc_time_t expires; isc_interval_t interval; ++Tx_eventcnt; t_info("tick %d\n", Tx_eventcnt); /* * Check expired time. */ isc_result = isc_time_now(&now); if (isc_result != ISC_R_SUCCESS) { t_info("isc_time_now failed %s\n", isc_result_totext(isc_result)); ++Tx_nprobs; } if (isc_result == ISC_R_SUCCESS) { interval.seconds = Tx_seconds; interval.nanoseconds = Tx_nanoseconds; isc_result = isc_time_add(&Tx_lasttime, &interval, &base); if (isc_result != ISC_R_SUCCESS) { t_info("isc_time_add failed %s\n", isc_result_totext(isc_result)); ++Tx_nprobs; } } if (isc_result == ISC_R_SUCCESS) { interval.seconds = Tx_FUDGE_SECONDS; interval.nanoseconds = Tx_FUDGE_NANOSECONDS; isc_result = isc_time_add(&base, &interval, &ulim); if (isc_result != ISC_R_SUCCESS) { t_info("isc_time_add failed %s\n", isc_result_totext(isc_result)); ++Tx_nprobs; } } if (isc_result == ISC_R_SUCCESS) { isc_result = isc_time_subtract(&base, &interval, &llim); if (isc_result != ISC_R_SUCCESS) { t_info("isc_time_subtract failed %s\n", isc_result_totext(isc_result)); ++Tx_nprobs; } } if (isc_result == ISC_R_SUCCESS) { if (isc_time_compare(&llim, &now) > 0) { t_info("timer range error: early by " "%lu microseconds\n", (unsigned long)isc_time_microdiff(&base, &now)); ++Tx_nfails; } else if (isc_time_compare(&ulim, &now) < 0) { t_info("timer range error: late by " "%lu microseconds\n", (unsigned long)isc_time_microdiff(&now, &base)); ++Tx_nfails; } Tx_lasttime = now; } if (Tx_eventcnt < 3) { if (event->ev_type != ISC_TIMEREVENT_TICK) { t_info("received event type %d, expected type %d\n", event->ev_type, ISC_TIMEREVENT_IDLE); ++Tx_nfails; } if (Tx_eventcnt == 2) { isc_interval_set(&interval, T4_SECONDS, T4_NANOSECONDS); isc_result = isc_time_nowplusinterval(&expires, &interval); if (isc_result == ISC_R_SUCCESS) { isc_interval_set(&interval, 0, 0); isc_result = isc_timer_reset(Tx_timer, isc_timertype_once, &expires, &interval, ISC_FALSE); if (isc_result != ISC_R_SUCCESS) { t_info("isc_timer_reset failed %s\n", isc_result_totext(isc_result)); ++Tx_nfails; } } else { t_info("isc_time_nowplusinterval failed %s\n", isc_result_totext(isc_result)); ++Tx_nprobs; } } } else { if (event->ev_type != ISC_TIMEREVENT_LIFE) { t_info("received event type %d, expected type %d\n", event->ev_type, ISC_TIMEREVENT_IDLE); ++Tx_nfails; } isc_timer_detach(&Tx_timer); isc_task_shutdown(task); } isc_event_free(&event); }