upstream/bind9
1
0
Fork 0
mirror of https://github.com/isc-projects/bind9.git synced 2026-02-26 11:32:01 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

Refactor isc_timer_reset() use with semantic patch

Browse source 
Add and apply semantic patch to remove expires argument from the
isc_timer_reset() calls through the codebase.
This commit is contained in:
Ondřej Surý 2022-03-11 23:08:17 +01:00 committed by Evan Hunt
parent 6437bcc488
commit e6ca2a651f
12 changed files with 63 additions and 116 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
bin/named/server.c
View file

@ -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));
/*

6
cocci/isc_timer_reset.spatch Normal file
View file

@ -0,0 +1,6 @@
@@
expression E1, E2, E3, E4;
@@
- isc_timer_reset(E1, E2, NULL, E3, E4)
+ isc_timer_reset(E1, E2, E3, E4)

6
lib/dns/catz.c
View file

@ -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;
}

18
lib/dns/nta.c
View file

@ -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);

14
lib/dns/resolver.c
View file

@ -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);

10
lib/dns/rpz.c
View file

@ -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);

4
lib/dns/zone.c
View file

@ -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,

3
lib/isc/include/isc/timer.h
View file

@ -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)
/***

14
lib/isc/ratelimiter.c
View file

@ -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;

9
lib/isc/tests/task_test.c
View file

@ -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);

77
lib/isc/tests/timer_test.c
View file

@ -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;

2
lib/isc/timer.c
View file

@ -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;