Refactor isc_timer_reset() use with semantic patch

Add and apply semantic patch to remove expires argument from the
isc_timer_reset() calls through the codebase.

diff --git a/bin/named/server.c b/bin/named/server.c
index 7bb62cb1e0fc9aed144eb9b916b235475c0cc095..28bc75d89e9540dcc7a7b0d7cb6c2ab2049f831d 100644 (file)
--- a/bin/named/server.c
+++ b/bin/named/server.c
@@ -9059,13 +9059,11 @@ load_configuration(const char *filename, named_server_t *server,
        interface_interval = cfg_obj_asduration(obj);
        if (interface_interval == 0) {
                CHECK(isc_timer_reset(server->interface_timer,
-                                     isc_timertype_inactive, NULL, NULL,
-                                     true));
+                                     isc_timertype_inactive, NULL, true));
        } else if (server->interface_interval != interface_interval) {
                isc_interval_set(&interval, interface_interval, 0);
                CHECK(isc_timer_reset(server->interface_timer,
-                                     isc_timertype_ticker, NULL, &interval,
-                                     false));
+                                     isc_timertype_ticker, &interval, false));
        }
        server->interface_interval = interface_interval;
 
@@ -9086,22 +9084,20 @@ load_configuration(const char *filename, named_server_t *server,
        heartbeat_interval = cfg_obj_asuint32(obj) * 60;
        if (heartbeat_interval == 0) {
                CHECK(isc_timer_reset(server->heartbeat_timer,
-                                     isc_timertype_inactive, NULL, NULL,
-                                     true));
+                                     isc_timertype_inactive, NULL, true));
        } else if (server->heartbeat_interval != heartbeat_interval) {
                isc_interval_set(&interval, heartbeat_interval, 0);
                CHECK(isc_timer_reset(server->heartbeat_timer,
-                                     isc_timertype_ticker, NULL, &interval,
-                                     false));
+                                     isc_timertype_ticker, &interval, false));
        }
        server->heartbeat_interval = heartbeat_interval;
 
        isc_interval_set(&interval, 1200, 0);
-       CHECK(isc_timer_reset(server->pps_timer, isc_timertype_ticker, NULL,
+       CHECK(isc_timer_reset(server->pps_timer, isc_timertype_ticker,
                              &interval, false));
 
        isc_interval_set(&interval, named_g_tat_interval, 0);
-       CHECK(isc_timer_reset(server->tat_timer, isc_timertype_ticker, NULL,
+       CHECK(isc_timer_reset(server->tat_timer, isc_timertype_ticker,
                              &interval, false));
 
        /*

diff --git a/cocci/isc_timer_reset.spatch b/cocci/isc_timer_reset.spatch
new file mode 100644 (file)
index 0000000..b89907f
--- /dev/null
+++ b/cocci/isc_timer_reset.spatch
@@ -0,0 +1,6 @@
+@@
+expression E1, E2, E3, E4;
+@@
+
+- isc_timer_reset(E1, E2, NULL, E3, E4)
++ isc_timer_reset(E1, E2, E3, E4)

diff --git a/lib/dns/catz.c b/lib/dns/catz.c
index 7459f7f6866446b263416322022f34cbaef04085..3fc22aae7702b56407f3173a2a5cefd30e6d458a 100644 (file)
--- a/lib/dns/catz.c
+++ b/lib/dns/catz.c
@@ -1672,7 +1672,7 @@ dns_catz_update_taskaction(isc_task_t *task, isc_event_t *event) {
        zone->updatepending = false;
        dns_catz_update_from_db(zone->db, zone->catzs);
        result = isc_timer_reset(zone->updatetimer, isc_timertype_inactive,
-                                NULL, NULL, true);
+                                NULL, true);
        RUNTIME_CHECK(result == ISC_R_SUCCESS);
        isc_event_free(&event);
        result = isc_time_now(&zone->lastupdated);
@@ -1733,8 +1733,8 @@ dns_catz_dbupdate_callback(dns_db_t *db, void *fn_arg) {
                                         0);
                        dns_db_currentversion(db, &zone->dbversion);
                        result = isc_timer_reset(zone->updatetimer,
-                                                isc_timertype_once, NULL,
-                                                &interval, true);
+                                                isc_timertype_once, &interval,
+                                                true);
                        if (result != ISC_R_SUCCESS) {
                                goto cleanup;
                        }

diff --git a/lib/dns/nta.c b/lib/dns/nta.c
index 1126202d237cb237e48da7898ab95d8ced746276..49f4ddef47d580a44a5b2fb9377bbc8028842e35 100644 (file)
--- a/lib/dns/nta.c
+++ b/lib/dns/nta.c
@@ -74,9 +74,8 @@ nta_detach(isc_mem_t *mctx, dns_nta_t **ntap) {
                isc_refcount_destroy(&nta->refcount);
                nta->magic = 0;
                if (nta->timer != NULL) {
-                       (void)isc_timer_reset(nta->timer,
-                                             isc_timertype_inactive, NULL,
-                                             NULL, true);
+                       (void)isc_timer_reset(
+                               nta->timer, isc_timertype_inactive, NULL, true);
                        isc_timer_detach(&nta->timer);
                }
                if (dns_rdataset_isassociated(&nta->rdataset)) {
@@ -233,7 +232,7 @@ fetch_done(isc_task_t *task, isc_event_t *event) {
         */
        if (nta->timer != NULL && nta->expiry - now < view->nta_recheck) {
                (void)isc_timer_reset(nta->timer, isc_timertype_inactive, NULL,
-                                     NULL, true);
+                                     true);
        }
        nta_detach(view->mctx, &nta);
        dns_view_weakdetach(&view);
@@ -292,8 +291,8 @@ settimer(dns_ntatable_t *ntatable, dns_nta_t *nta, uint32_t lifetime) {
        isc_timer_create(ntatable->timermgr, ntatable->task, checkbogus, nta,
                         &nta->timer);
        isc_interval_set(&interval, view->nta_recheck, 0);
-       result = isc_timer_reset(nta->timer, isc_timertype_ticker, NULL,
-                                &interval, false);
+       result = isc_timer_reset(nta->timer, isc_timertype_ticker, &interval,
+                                false);
        if (result != ISC_R_SUCCESS) {
                isc_timer_detach(&nta->timer);
        }
@@ -480,9 +479,8 @@ again:
                              "deleting expired NTA at %s", nb);
 
                if (nta->timer != NULL) {
-                       (void)isc_timer_reset(nta->timer,
-                                             isc_timertype_inactive, NULL,
-                                             NULL, true);
+                       (void)isc_timer_reset(
+                               nta->timer, isc_timertype_inactive, NULL, true);
                        isc_timer_detach(&nta->timer);
                }
 
@@ -693,7 +691,7 @@ dns_ntatable_shutdown(dns_ntatable_t *ntatable) {
                        if (nta->timer != NULL) {
                                (void)isc_timer_reset(nta->timer,
                                                      isc_timertype_inactive,
-                                                     NULL, NULL, true);
+                                                     NULL, true);
                        }
                }
                result = dns_rbtnodechain_next(&chain, NULL, NULL);

diff --git a/lib/dns/resolver.c b/lib/dns/resolver.c
index 1f1b5efad979eb219f7aa6861f0c3cdd8dc6c67c..689d6d953ff89b022c326e336536317d75dcf5ad 100644 (file)
--- a/lib/dns/resolver.c
+++ b/lib/dns/resolver.c
@@ -1273,8 +1273,8 @@ fctx_starttimer(fetchctx_t *fctx) {
                                 isc_time_nanoseconds(&tmp));
        }
 
-       return (isc_timer_reset(fctx->timer, isc_timertype_once, NULL,
-                               &interval, true));
+       return (isc_timer_reset(fctx->timer, isc_timertype_once, &interval,
+                               true));
 }
 
 static inline void
@@ -1288,7 +1288,7 @@ fctx_stoptimer(fetchctx_t *fctx) {
         * cannot fail in that case.
         */
        result = isc_timer_reset(fctx->timer, isc_timertype_inactive, NULL,
-                                NULL, true);
+                                true);
        if (result != ISC_R_SUCCESS) {
                UNEXPECTED_ERROR(__FILE__, __LINE__, "isc_timer_reset(): %s",
                                 isc_result_totext(result));
@@ -1746,7 +1746,7 @@ fctx_sendevents(fetchctx_t *fctx, isc_result_t result, int line) {
                        }
                        isc_interval_set(&i, 20 * 60, 0);
                        result = isc_timer_reset(fctx->res->spillattimer,
-                                                isc_timertype_ticker, NULL, &i,
+                                                isc_timertype_ticker, &i,
                                                 true);
                        RUNTIME_CHECK(result == ISC_R_SUCCESS);
                }
@@ -10031,8 +10031,7 @@ spillattimer_countdown(isc_task_t *task, isc_event_t *event) {
        }
        if (res->spillat <= res->spillatmin) {
                result = isc_timer_reset(res->spillattimer,
-                                        isc_timertype_inactive, NULL, NULL,
-                                        true);
+                                        isc_timertype_inactive, NULL, true);
                RUNTIME_CHECK(result == ISC_R_SUCCESS);
        }
        count = res->spillat;
@@ -10403,8 +10402,7 @@ dns_resolver_shutdown(dns_resolver_t *res) {
                        send_shutdown_events(res);
                }
                result = isc_timer_reset(res->spillattimer,
-                                        isc_timertype_inactive, NULL, NULL,
-                                        true);
+                                        isc_timertype_inactive, NULL, true);
                RUNTIME_CHECK(result == ISC_R_SUCCESS);
        }
        UNLOCK(&res->lock);

diff --git a/lib/dns/rpz.c b/lib/dns/rpz.c
index 863345999cc5a2f5585b4053925ff5081e731188..5905c8c1c10f32ed54201a6217303b635bf6f8b3 100644 (file)
--- a/lib/dns/rpz.c
+++ b/lib/dns/rpz.c
@@ -1616,8 +1616,8 @@ dns_rpz_dbupdate_callback(dns_db_t *db, void *fn_arg) {
                        isc_interval_set(&interval, (unsigned int)defer, 0);
                        dns_db_currentversion(zone->db, &zone->dbversion);
                        result = isc_timer_reset(zone->updatetimer,
-                                                isc_timertype_once, NULL,
-                                                &interval, true);
+                                                isc_timertype_once, &interval,
+                                                true);
                        if (result != ISC_R_SUCCESS) {
                                goto cleanup;
                        }
@@ -1669,7 +1669,7 @@ dns_rpz_update_taskaction(isc_task_t *task, isc_event_t *event) {
        zone->updaterunning = true;
        dns_rpz_update_from_db(zone);
        result = isc_timer_reset(zone->updatetimer, isc_timertype_inactive,
-                                NULL, NULL, true);
+                                NULL, true);
        RUNTIME_CHECK(result == ISC_R_SUCCESS);
        result = isc_time_now(&zone->lastupdated);
        RUNTIME_CHECK(result == ISC_R_SUCCESS);
@@ -1770,7 +1770,7 @@ finish_update(dns_rpz_zone_t *rpz) {
                                      dname, defer);
                        isc_interval_set(&interval, (unsigned int)defer, 0);
                        isc_timer_reset(rpz->updatetimer, isc_timertype_once,
-                                       NULL, &interval, true);
+                                       &interval, true);
                } else {
                        isc_event_t *event = NULL;
                        INSIST(!ISC_LINK_LINKED(&rpz->updateevent, ev_link));
@@ -2210,7 +2210,7 @@ rpz_detach(dns_rpz_zone_t **rpzp) {
                }
 
                isc_timer_reset(rpz->updatetimer, isc_timertype_inactive, NULL,
-                               NULL, true);
+                               true);
                isc_timer_detach(&rpz->updatetimer);
 
                isc_ht_destroy(&rpz->nodes);

diff --git a/lib/dns/zone.c b/lib/dns/zone.c
index 4d2178e66e28cc8d2f2cdcd40b2ec11d187cc727..92f66ff5f3143ee6be6a558526b6fcc4dc18b373 100644 (file)
--- a/lib/dns/zone.c
+++ b/lib/dns/zone.c
@@ -15272,7 +15272,7 @@ zone_settimer(dns_zone_t *zone, isc_time_t *now) {
        if (isc_time_isepoch(&next)) {
                zone_debuglog(zone, me, 10, "settimer inactive");
                result = isc_timer_reset(zone->timer, isc_timertype_inactive,
-                                        NULL, NULL, true);
+                                        NULL, true);
                if (result != ISC_R_SUCCESS) {
                        dns_zone_log(zone, ISC_LOG_ERROR,
                                     "could not deactivate zone timer: %s",
@@ -15296,7 +15296,7 @@ zone_settimer(dns_zone_t *zone, isc_time_t *now) {
                                         isc_time_nanoseconds(&tmp));
                }
 
-               result = isc_timer_reset(zone->timer, isc_timertype_once, NULL,
+               result = isc_timer_reset(zone->timer, isc_timertype_once,
                                         &interval, true);
                if (result != ISC_R_SUCCESS) {
                        dns_zone_log(zone, ISC_LOG_ERROR,

diff --git a/lib/isc/include/isc/timer.h b/lib/isc/include/isc/timer.h
index 6c3edd2cc055d210181005c34d96236873b3813f..1457d796f9e95d2be7cf3dbdd47aab48aa3bc7a6 100644 (file)
--- a/lib/isc/include/isc/timer.h
+++ b/lib/isc/include/isc/timer.h
@@ -88,8 +88,7 @@ typedef struct isc_timerevent {
 
 #define ISC_TIMEREVENT_FIRSTEVENT (ISC_EVENTCLASS_TIMER + 0)
 #define ISC_TIMEREVENT_TICK      (ISC_EVENTCLASS_TIMER + 1)
-#define ISC_TIMEREVENT_IDLE      (ISC_EVENTCLASS_TIMER + 2)
-#define ISC_TIMEREVENT_LIFE      (ISC_EVENTCLASS_TIMER + 3)
+#define ISC_TIMEREVENT_ONCE      (ISC_EVENTCLASS_TIMER + 2)
 #define ISC_TIMEREVENT_LASTEVENT  (ISC_EVENTCLASS_TIMER + 65535)
 
 /***

diff --git a/lib/isc/ratelimiter.c b/lib/isc/ratelimiter.c
index 9f48ab540110bc705017d477896c16f2d62b47ca..327144eb8282d79fd4a22eb24e8a569db777ea83 100644 (file)
--- a/lib/isc/ratelimiter.c
+++ b/lib/isc/ratelimiter.c
@@ -102,7 +102,7 @@ isc_ratelimiter_setinterval(isc_ratelimiter_t *rl, isc_interval_t *interval) {
         * If the timer is currently running, change its rate.
         */
        if (rl->state == isc_ratelimiter_ratelimited) {
-               result = isc_timer_reset(rl->timer, isc_timertype_ticker, NULL,
+               result = isc_timer_reset(rl->timer, isc_timertype_ticker,
                                         &rl->interval, false);
        }
        UNLOCK(&rl->lock);
@@ -150,7 +150,7 @@ isc_ratelimiter_enqueue(isc_ratelimiter_t *rl, isc_task_t *task,
                        ISC_LIST_APPEND(rl->pending, ev, ev_ratelink);
                }
        } else if (rl->state == isc_ratelimiter_idle) {
-               result = isc_timer_reset(rl->timer, isc_timertype_ticker, NULL,
+               result = isc_timer_reset(rl->timer, isc_timertype_ticker,
                                         &rl->interval, false);
                if (result == ISC_R_SUCCESS) {
                        ev->ev_sender = task;
@@ -211,8 +211,7 @@ ratelimiter_tick(isc_task_t *task, isc_event_t *event) {
                         * waste resources by having it fire periodically.
                         */
                        isc_result_t result = isc_timer_reset(
-                               rl->timer, isc_timertype_inactive, NULL, NULL,
-                               false);
+                               rl->timer, isc_timertype_inactive, NULL, false);
                        RUNTIME_CHECK(result == ISC_R_SUCCESS);
                        rl->state = isc_ratelimiter_idle;
                        pertic = 0; /* Force the loop to exit. */
@@ -235,8 +234,7 @@ isc_ratelimiter_shutdown(isc_ratelimiter_t *rl) {
 
        LOCK(&rl->lock);
        rl->state = isc_ratelimiter_shuttingdown;
-       (void)isc_timer_reset(rl->timer, isc_timertype_inactive, NULL, NULL,
-                             false);
+       (void)isc_timer_reset(rl->timer, isc_timertype_inactive, NULL, false);
        while ((ev = ISC_LIST_HEAD(rl->pending)) != NULL) {
                task = ev->ev_sender;
                ISC_LIST_UNLINK(rl->pending, ev, ev_ratelink);
@@ -311,7 +309,7 @@ isc_ratelimiter_stall(isc_ratelimiter_t *rl) {
                break;
        case isc_ratelimiter_ratelimited:
                result = isc_timer_reset(rl->timer, isc_timertype_inactive,
-                                        NULL, NULL, false);
+                                        NULL, false);
                RUNTIME_CHECK(result == ISC_R_SUCCESS);
        /* FALLTHROUGH */
        case isc_ratelimiter_idle:
@@ -337,7 +335,7 @@ isc_ratelimiter_release(isc_ratelimiter_t *rl) {
        case isc_ratelimiter_stalled:
                if (!ISC_LIST_EMPTY(rl->pending)) {
                        result = isc_timer_reset(rl->timer,
-                                                isc_timertype_ticker, NULL,
+                                                isc_timertype_ticker,
                                                 &rl->interval, false);
                        if (result == ISC_R_SUCCESS) {
                                rl->state = isc_ratelimiter_ratelimited;

diff --git a/lib/isc/tests/task_test.c b/lib/isc/tests/task_test.c
index 1730862d85539ec64844ae4ffd62b9a8cda2bd45..0a4d91e5e5ce4c25ef956866d4ad6bb98a7cf1ce 100644 (file)
--- a/lib/isc/tests/task_test.c
+++ b/lib/isc/tests/task_test.c
@@ -480,7 +480,6 @@ basic(void **state) {
        isc_event_t *event = NULL;
        isc_timer_t *ti1 = NULL;
        isc_timer_t *ti2 = NULL;
-       isc_time_t absolute;
        isc_interval_t interval;
        char *testarray[] = { one, one, one,   one,  one, one,   one,  one,
                              one, two, three, four, two, three, four, NULL };
@@ -506,19 +505,15 @@ basic(void **state) {
        result = isc_task_onshutdown(task4, basic_shutdown, four);
        assert_int_equal(result, ISC_R_SUCCESS);
 
-       isc_time_settoepoch(&absolute);
        isc_interval_set(&interval, 1, 0);
        isc_timer_create(timermgr, task1, basic_tick, tick, &ti1);
-       result = isc_timer_reset(ti1, isc_timertype_ticker, &absolute,
-                                &interval, false);
+       result = isc_timer_reset(ti1, isc_timertype_ticker, &interval, false);
        assert_int_equal(result, ISC_R_SUCCESS);
 
        ti2 = NULL;
-       isc_time_settoepoch(&absolute);
        isc_interval_set(&interval, 1, 0);
        isc_timer_create(timermgr, task2, basic_tick, tock, &ti2);
-       result = isc_timer_reset(ti2, isc_timertype_ticker, &absolute,
-                                &interval, false);
+       result = isc_timer_reset(ti2, isc_timertype_ticker, &interval, false);
        assert_int_equal(result, ISC_R_SUCCESS);
 
        sleep(2);

diff --git a/lib/isc/tests/timer_test.c b/lib/isc/tests/timer_test.c
index ac647e0b74633542c68cb98f84c9abd1389523bc..a41f7b8352347e8269121f7549daa341455579fa 100644 (file)
--- a/lib/isc/tests/timer_test.c
+++ b/lib/isc/tests/timer_test.c
@@ -102,8 +102,7 @@ shutdown(isc_task_t *task, isc_event_t *event) {
 }
 
 static void
-setup_test(isc_timertype_t timertype, isc_time_t *expires,
-          isc_interval_t *interval,
+setup_test(isc_timertype_t timertype, isc_interval_t *interval,
           void (*action)(isc_task_t *, isc_event_t *)) {
        isc_result_t result;
        isc_task_t *task = NULL;
@@ -131,7 +130,7 @@ setup_test(isc_timertype_t timertype, isc_time_t *expires,
        assert_int_equal(result, ISC_R_SUCCESS);
 
        isc_timer_create(timermgr, task, action, (void *)timertype, &timer);
-       result = isc_timer_reset(timer, timertype, expires, interval, false);
+       result = isc_timer_reset(timer, timertype, interval, false);
        assert_int_equal(result, ISC_R_SUCCESS);
 
        /*
@@ -207,7 +206,7 @@ ticktock(isc_task_t *task, isc_event_t *event) {
                print_message("# tick %d\n", tick);
        }
 
-       expected_event_type = ISC_TIMEREVENT_LIFE;
+       expected_event_type = ISC_TIMEREVENT_ONCE;
        if ((uintptr_t)event->ev_arg == isc_timertype_ticker) {
                expected_event_type = ISC_TIMEREVENT_TICK;
        }
@@ -259,7 +258,6 @@ ticktock(isc_task_t *task, isc_event_t *event) {
 /* timer type ticker */
 static void
 ticker(void **state) {
-       isc_time_t expires;
        isc_interval_t interval;
 
        UNUSED(state);
@@ -269,31 +267,8 @@ ticker(void **state) {
        nanoseconds = 500000000;
 
        isc_interval_set(&interval, seconds, nanoseconds);
-       isc_time_settoepoch(&expires);
-
-       setup_test(isc_timertype_ticker, &expires, &interval, ticktock);
-}
-
-/* timer type once reaches lifetime */
-static void
-once_life(void **state) {
-       isc_result_t result;
-       isc_time_t expires;
-       isc_interval_t interval;
-
-       UNUSED(state);
-
-       nevents = 1;
-       seconds = 1;
-       nanoseconds = 100000000;
-
-       isc_interval_set(&interval, seconds, nanoseconds);
-       result = isc_time_nowplusinterval(&expires, &interval);
-       assert_int_equal(result, ISC_R_SUCCESS);
-
-       isc_interval_set(&interval, 0, 0);
 
-       setup_test(isc_timertype_once, &expires, &interval, ticktock);
+       setup_test(isc_timertype_ticker, &interval, ticktock);
 }
 
 static void
@@ -335,7 +310,7 @@ test_idle(isc_task_t *task, isc_event_t *event) {
        isc_time_add(&now, &interval, &lasttime);
        isc_mutex_unlock(&lasttime_mx);
 
-       subthread_assert_int_equal(event->ev_type, ISC_TIMEREVENT_IDLE);
+       subthread_assert_int_equal(event->ev_type, ISC_TIMEREVENT_ONCE);
 
        isc_timer_detach(&timer);
        isc_task_shutdown(task);
@@ -345,8 +320,6 @@ test_idle(isc_task_t *task, isc_event_t *event) {
 /* timer type once idles out */
 static void
 once_idle(void **state) {
-       isc_result_t result;
-       isc_time_t expires;
        isc_interval_t interval;
 
        UNUSED(state);
@@ -355,13 +328,9 @@ once_idle(void **state) {
        seconds = 1;
        nanoseconds = 200000000;
 
-       isc_interval_set(&interval, seconds + 1, nanoseconds);
-       result = isc_time_nowplusinterval(&expires, &interval);
-       assert_int_equal(result, ISC_R_SUCCESS);
-
        isc_interval_set(&interval, seconds, nanoseconds);
 
-       setup_test(isc_timertype_once, &expires, &interval, test_idle);
+       setup_test(isc_timertype_once, &interval, test_idle);
 }
 
 /* timer reset */
@@ -372,7 +341,6 @@ test_reset(isc_task_t *task, isc_event_t *event) {
        isc_time_t base;
        isc_time_t ulim;
        isc_time_t llim;
-       isc_time_t expires;
        isc_interval_t interval;
 
        int tick = atomic_fetch_add(&eventcnt, 1);
@@ -413,19 +381,14 @@ test_reset(isc_task_t *task, isc_event_t *event) {
 
        if (_eventcnt < 3) {
                subthread_assert_int_equal(event->ev_type, ISC_TIMEREVENT_TICK);
-
                if (_eventcnt == 2) {
                        isc_interval_set(&interval, seconds, nanoseconds);
-                       result = isc_time_nowplusinterval(&expires, &interval);
-                       subthread_assert_result_equal(result, ISC_R_SUCCESS);
-
-                       isc_interval_set(&interval, 0, 0);
                        result = isc_timer_reset(timer, isc_timertype_once,
-                                                &expires, &interval, false);
+                                                &interval, false);
                        subthread_assert_result_equal(result, ISC_R_SUCCESS);
                }
        } else {
-               subthread_assert_int_equal(event->ev_type, ISC_TIMEREVENT_LIFE);
+               subthread_assert_int_equal(event->ev_type, ISC_TIMEREVENT_ONCE);
 
                isc_timer_detach(&timer);
                isc_task_shutdown(task);
@@ -436,7 +399,6 @@ test_reset(isc_task_t *task, isc_event_t *event) {
 
 static void
 reset(void **state) {
-       isc_time_t expires;
        isc_interval_t interval;
 
        UNUSED(state);
@@ -446,9 +408,8 @@ reset(void **state) {
        nanoseconds = 750000000;
 
        isc_interval_set(&interval, seconds, nanoseconds);
-       isc_time_settoepoch(&expires);
 
-       setup_test(isc_timertype_ticker, &expires, &interval, test_reset);
+       setup_test(isc_timertype_ticker, &interval, test_reset);
 }
 
 static atomic_bool startflag;
@@ -492,7 +453,7 @@ tick_event(isc_task_t *task, isc_event_t *event) {
                isc_time_settoepoch(&expires);
                isc_interval_set(&interval, seconds, 0);
                result = isc_timer_reset(tickertimer, isc_timertype_ticker,
-                                        &expires, &interval, true);
+                                        &interval, true);
                subthread_assert_result_equal(result, ISC_R_SUCCESS);
 
                isc_task_shutdown(task);
@@ -537,7 +498,6 @@ shutdown_purge(isc_task_t *task, isc_event_t *event) {
 static void
 purge(void **state) {
        isc_result_t result;
-       isc_time_t expires;
        isc_interval_t interval;
 
        UNUSED(state);
@@ -557,25 +517,21 @@ purge(void **state) {
        result = isc_task_create(taskmgr, 0, &task2);
        assert_int_equal(result, ISC_R_SUCCESS);
 
-       isc_time_settoepoch(&expires);
        isc_interval_set(&interval, seconds, 0);
 
        tickertimer = NULL;
        isc_timer_create(timermgr, task1, tick_event, NULL, &tickertimer);
-       result = isc_timer_reset(tickertimer, isc_timertype_ticker, &expires,
-                                &interval, false);
+       result = isc_timer_reset(tickertimer, isc_timertype_ticker, &interval,
+                                false);
        assert_int_equal(result, ISC_R_SUCCESS);
 
        oncetimer = NULL;
 
        isc_interval_set(&interval, (seconds * 2) + 1, 0);
-       result = isc_time_nowplusinterval(&expires, &interval);
-       assert_int_equal(result, ISC_R_SUCCESS);
 
-       isc_interval_set(&interval, 0, 0);
        isc_timer_create(timermgr, task2, once_event, NULL, &oncetimer);
-       result = isc_timer_reset(oncetimer, isc_timertype_once, &expires,
-                                &interval, false);
+       result = isc_timer_reset(oncetimer, isc_timertype_once, &interval,
+                                false);
        assert_int_equal(result, ISC_R_SUCCESS);
 
        /*
@@ -598,8 +554,9 @@ purge(void **state) {
 int
 main(int argc, char **argv) {
        const struct CMUnitTest tests[] = {
-               cmocka_unit_test(ticker),    cmocka_unit_test(once_life),
-               cmocka_unit_test(once_idle), cmocka_unit_test(reset),
+               cmocka_unit_test(ticker),
+               cmocka_unit_test(once_idle),
+               cmocka_unit_test(reset),
                cmocka_unit_test(purge),
        };
        int c;

diff --git a/lib/isc/timer.c b/lib/isc/timer.c
index 9926c0c9ed761b89e1a74910c52c3fa25409b783..720f972260b2b56325d1099103f88299f8698199 100644 (file)
--- a/lib/isc/timer.c
+++ b/lib/isc/timer.c
@@ -420,7 +420,7 @@ dispatch(isc_timermgr_t *manager, isc_time_t *now) {
                        need_schedule = true;
                        break;
                case isc_timertype_once:
-                       type = ISC_TIMEREVENT_IDLE;
+                       type = ISC_TIMEREVENT_ONCE;
                        post_event(manager, timer, type);
                        need_schedule = false;
                        break;