diff --git a/bin/named/include/named/server.h b/bin/named/include/named/server.h index 8d2662d4b3..b3174b1523 100644 --- a/bin/named/include/named/server.h +++ b/bin/named/include/named/server.h @@ -37,11 +37,12 @@ #include -#define NAMED_EVENTCLASS ISC_EVENTCLASS(0x4E43) -#define NAMED_EVENT_RELOAD (NAMED_EVENTCLASS + 0) -#define NAMED_EVENT_DELZONE (NAMED_EVENTCLASS + 1) -#define NAMED_EVENT_COMMAND (NAMED_EVENTCLASS + 2) -#define NAMED_EVENT_TATSEND (NAMED_EVENTCLASS + 3) +#define NAMED_EVENTCLASS ISC_EVENTCLASS(0x4E43) +#define NAMED_EVENT_RELOAD (NAMED_EVENTCLASS + 0) +#define NAMED_EVENT_DELZONE (NAMED_EVENTCLASS + 1) +#define NAMED_EVENT_COMMAND (NAMED_EVENTCLASS + 2) +#define NAMED_EVENT_TATSEND (NAMED_EVENTCLASS + 3) +#define NAMED_EVENT_SHUTDOWN (NAMED_EVENTCLASS + 4) /*% * Name server state. Better here than in lots of separate global variables. @@ -134,6 +135,12 @@ named_server_destroy(named_server_t **serverp); * Destroy a server object, freeing its memory. */ +void +named_server_shutdown(named_server_t *server); +/*%< + * Initiate the server shutdown. + */ + void named_server_reloadwanted(named_server_t *server); /*%< diff --git a/bin/named/main.c b/bin/named/main.c index 2977dcbd7b..ddf002dd96 100644 --- a/bin/named/main.c +++ b/bin/named/main.c @@ -1258,6 +1258,8 @@ setup(void) { static void cleanup(void) { + named_server_shutdown(named_g_server); + destroy_managers(); if (named_g_mapped != NULL) { diff --git a/bin/named/server.c b/bin/named/server.c index 776e170384..b5a2118e20 100644 --- a/bin/named/server.c +++ b/bin/named/server.c @@ -9963,6 +9963,14 @@ shutdown_server(isc_task_t *task, isc_event_t *event) { isc_event_free(&event); } +void +named_server_shutdown(named_server_t *server) { + isc_event_t *event = + isc_event_allocate(named_g_mctx, server, NAMED_EVENT_SHUTDOWN, + shutdown_server, server, sizeof(*event)); + isc_task_send(server->task, &event); +} + /*% * Find a view that matches the source and destination addresses of a query. */ @@ -10069,8 +10077,6 @@ named_server_create(isc_mem_t *mctx, named_server_t **serverp) { server->sctx->fuzznotify = named_fuzz_notify; #endif /* ifdef ENABLE_AFL */ - CHECKFATAL(isc_task_onshutdown(server->task, shutdown_server, server), - "isc_task_onshutdown"); CHECKFATAL( isc_app_onrun(named_g_mctx, server->task, run_server, server), "isc_app_onrun"); diff --git a/bin/nsupdate/nsupdate.c b/bin/nsupdate/nsupdate.c index ec64f9c1a1..294ab0a3f1 100644 --- a/bin/nsupdate/nsupdate.c +++ b/bin/nsupdate/nsupdate.c @@ -752,12 +752,8 @@ maybeshutdown(void) { } static void -shutdown_program(isc_task_t *task, isc_event_t *event) { - REQUIRE(task == global_task); - UNUSED(task); - +shutdown_program(void) { ddebug("shutdown_program()"); - isc_event_free(&event); shuttingdown = true; maybeshutdown(); @@ -918,9 +914,6 @@ setup_system(void) { result = isc_task_create(taskmgr, 0, &global_task); check_result(result, "isc_task_create"); - result = isc_task_onshutdown(global_task, shutdown_program, NULL); - check_result(result, "isc_task_onshutdown"); - result = dst_lib_init(gmctx, NULL); check_result(result, "dst_lib_init"); is_dst_up = true; @@ -3412,6 +3405,8 @@ main(int argc, char **argv) { (void)isc_app_run(); + shutdown_program(); + cleanup(); isc_app_finish(); diff --git a/doc/design/tasks b/doc/design/tasks index 53faa9fdcb..ef616dc7f1 100644 --- a/doc/design/tasks +++ b/doc/design/tasks @@ -16,13 +16,8 @@ and termination model. Here's how things now work: When a task is shutdown: - Any "on shutdown" events for the task are posted - The "shutting down" attribute of the task is set - Any attempts to add shutdown events with isc_task_onshutdown() - will fail, since the task is already shutting down - Task shutdown can be initiated explicitly, via a call to isc_task_shutdown(), or implicitly, when the following conditions occur: @@ -32,7 +27,6 @@ or implicitly, when the following conditions occur: The task has an empty event queue - Task termination occurs when: The "shutting down" attribute of the task is set diff --git a/lib/dns/cache.c b/lib/dns/cache.c index b2d188ffc6..22b2c9deeb 100644 --- a/lib/dns/cache.c +++ b/lib/dns/cache.c @@ -410,6 +410,12 @@ dns_cache_detach(dns_cache_t **cachep) { * If the cleaner task exists, let it free the cache. */ if (isc_refcount_decrement(&cache->live_tasks) > 1) { + isc_event_t *event = isc_event_allocate( + cache->mctx, &cache->cleaner, + DNS_EVENT_CACHESHUTDOWN, + cleaner_shutdown_action, &cache->cleaner, + sizeof(*event)); + isc_task_send(cache->cleaner.task, &event); isc_task_shutdown(cache->cleaner.task); } else { cache_free(cache); @@ -476,17 +482,6 @@ cache_cleaner_init(dns_cache_t *cache, isc_taskmgr_t *taskmgr, isc_refcount_increment(&cleaner->cache->live_tasks); isc_task_setname(cleaner->task, "cachecleaner", cleaner); - result = isc_task_onshutdown(cleaner->task, - cleaner_shutdown_action, cache); - if (result != ISC_R_SUCCESS) { - isc_refcount_decrement0(&cleaner->cache->live_tasks); - UNEXPECTED_ERROR(__FILE__, __LINE__, - "cache cleaner: " - "isc_task_onshutdown() failed: %s", - isc_result_totext(result)); - goto cleanup; - } - cleaner->resched_event = isc_event_allocate( cache->mctx, cleaner, DNS_EVENT_CACHECLEAN, incremental_cleaning_action, cleaner, diff --git a/lib/dns/include/dns/events.h b/lib/dns/include/dns/events.h index a38effdf03..b2ad2e83ef 100644 --- a/lib/dns/include/dns/events.h +++ b/lib/dns/include/dns/events.h @@ -82,3 +82,4 @@ #define DNS_EVENT_TRYSTALE (ISC_EVENTCLASS_DNS + 59) #define DNS_EVENT_ZONEFLUSH (ISC_EVENTCLASS_DNS + 60) #define DNS_EVENT_CHECKDSSENDTOADDR (ISC_EVENTCLASS_DNS + 61) +#define DNS_EVENT_CACHESHUTDOWN (ISC_EVENTCLASS_DNS + 62) diff --git a/lib/isc/include/isc/task.h b/lib/isc/include/isc/task.h index a7ba304413..22ce1a6a25 100644 --- a/lib/isc/include/isc/task.h +++ b/lib/isc/include/isc/task.h @@ -266,35 +266,6 @@ isc_task_purgeevent(isc_task_t *task, isc_event_t *event); * or was marked unpurgeable. */ -isc_result_t -isc_task_onshutdown(isc_task_t *task, isc_taskaction_t action, void *arg); -/*%< - * Send a shutdown event with action 'action' and argument 'arg' when - * 'task' is shutdown. - * - * Notes: - * - *\li Shutdown events are posted in LIFO order. - * - * Requires: - * - *\li 'task' is a valid task. - * - *\li 'action' is a valid task action. - * - * Ensures: - * - *\li When the task is shutdown, shutdown events requested with - * isc_task_onshutdown() will be appended to the task's event queue. - * - * - * Returns: - * - *\li #ISC_R_SUCCESS - *\li #ISC_R_NOMEMORY - *\li #ISC_R_SHUTTINGDOWN Task is shutting down. - */ - void isc_task_shutdown(isc_task_t *task); /*%< @@ -302,10 +273,7 @@ isc_task_shutdown(isc_task_t *task); * * Notes: * - *\li Shutting down a task causes any shutdown events requested with - * isc_task_onshutdown() to be posted (in LIFO order). The task - * moves into a "shutting down" mode which prevents further calls - * to isc_task_onshutdown(). + *\li The task moves into a "shutting down" mode. * *\li Trying to shutdown a task that has already been shutdown has no * effect. @@ -314,10 +282,6 @@ isc_task_shutdown(isc_task_t *task); * *\li 'task' is a valid task. * - * Ensures: - * - *\li Any shutdown events requested with isc_task_onshutdown() have been - * posted (in LIFO order). */ void diff --git a/lib/isc/task.c b/lib/isc/task.c index 5df035e7c7..8e5d88ce1c 100644 --- a/lib/isc/task.c +++ b/lib/isc/task.c @@ -113,7 +113,6 @@ struct isc_task { isc_refcount_t references; isc_refcount_t running; isc_eventlist_t events; - isc_eventlist_t on_shutdown; unsigned int nevents; unsigned int quantum; isc_stdtime_t now; @@ -183,7 +182,6 @@ task_finished(isc_task_t *task) { isc_mem_t *mctx = manager->mctx; REQUIRE(EMPTY(task->events)); REQUIRE(task->nevents == 0); - REQUIRE(EMPTY(task->on_shutdown)); REQUIRE(task->state == task_state_done); XTRACE("task_finished"); @@ -249,7 +247,6 @@ isc__task_create_bound(isc_taskmgr_t *manager, unsigned int quantum, isc_refcount_init(&task->references, 1); isc_refcount_init(&task->running, 0); INIT_LIST(task->events); - INIT_LIST(task->on_shutdown); task->nevents = 0; task->quantum = (quantum > 0) ? quantum : manager->default_quantum; atomic_init(&task->shuttingdown, false); @@ -302,7 +299,6 @@ isc_task_attach(isc_task_t *source, isc_task_t **targetp) { static bool task_shutdown(isc_task_t *task) { bool was_idle = false; - isc_event_t *event, *prev; /* * Caller must be holding the task's lock. @@ -320,17 +316,6 @@ task_shutdown(isc_task_t *task) { } INSIST(task->state == task_state_ready || task->state == task_state_running); - - /* - * Note that we post shutdown events LIFO. - */ - for (event = TAIL(task->on_shutdown); event != NULL; - event = prev) { - prev = PREV(event, ev_link); - DEQUEUE(task->on_shutdown, event, ev_link); - ENQUEUE(task->events, event, ev_link); - task->nevents++; - } } return (was_idle); @@ -562,40 +547,6 @@ isc_task_purgeevent(isc_task_t *task, isc_event_t *event) { return (true); } -isc_result_t -isc_task_onshutdown(isc_task_t *task, isc_taskaction_t action, void *arg) { - bool disallowed = false; - isc_result_t result = ISC_R_SUCCESS; - isc_event_t *event; - - /* - * Send a shutdown event with action 'action' and argument 'arg' when - * 'task' is shutdown. - */ - - REQUIRE(VALID_TASK(task)); - REQUIRE(action != NULL); - - event = isc_event_allocate(task->manager->mctx, NULL, - ISC_TASKEVENT_SHUTDOWN, action, arg, - sizeof(*event)); - - if (TASK_SHUTTINGDOWN(task)) { - disallowed = true; - result = ISC_R_SHUTTINGDOWN; - } else { - LOCK(&task->lock); - ENQUEUE(task->on_shutdown, event, ev_link); - UNLOCK(&task->lock); - } - - if (disallowed) { - isc_mem_put(task->manager->mctx, event, sizeof(*event)); - } - - return (result); -} - void isc_task_shutdown(isc_task_t *task) { bool was_idle; diff --git a/lib/isc/tests/task_test.c b/lib/isc/tests/task_test.c index a7cffbd8bb..d32e063b55 100644 --- a/lib/isc/tests/task_test.c +++ b/lib/isc/tests/task_test.c @@ -205,17 +205,6 @@ basic_cb(isc_task_t *task, isc_event_t *event) { isc_event_free(&event); } -static void -basic_shutdown(isc_task_t *task, isc_event_t *event) { - UNUSED(task); - - if (verbose) { - print_message("# shutdown %s\n", (char *)event->ev_arg); - } - - isc_event_free(&event); -} - static void basic_tick(isc_task_t *task, isc_event_t *event) { UNUSED(task); @@ -260,15 +249,6 @@ basic(void **state) { result = isc_task_create(taskmgr, 0, &task4); assert_int_equal(result, ISC_R_SUCCESS); - result = isc_task_onshutdown(task1, basic_shutdown, one); - assert_int_equal(result, ISC_R_SUCCESS); - result = isc_task_onshutdown(task2, basic_shutdown, two); - assert_int_equal(result, ISC_R_SUCCESS); - result = isc_task_onshutdown(task3, basic_shutdown, three); - assert_int_equal(result, ISC_R_SUCCESS); - result = isc_task_onshutdown(task4, basic_shutdown, four); - assert_int_equal(result, ISC_R_SUCCESS); - isc_interval_set(&interval, 1, 0); isc_timer_create(timermgr, task1, basic_tick, tick, &ti1); result = isc_timer_reset(ti1, isc_timertype_ticker, &interval, false); @@ -421,53 +401,39 @@ task_exclusive(void **state) { * Max tasks test: * The task system can create and execute many tasks. Tests with 10000. */ -static void -maxtask_shutdown(isc_task_t *task, isc_event_t *event) { - UNUSED(task); - if (event->ev_arg != NULL) { - isc_task_destroy((isc_task_t **)&event->ev_arg); +static void +maxtask_cb(isc_task_t *task, isc_event_t *event) { + isc_result_t result; + uintptr_t ntasks = (uintptr_t)event->ev_arg; + + if (ntasks-- > 0) { + task = NULL; + + event->ev_arg = (void *)ntasks; + + /* + * Create a new task and forward the message. + */ + result = isc_task_create(taskmgr, 0, &task); + assert_int_equal(result, ISC_R_SUCCESS); + + isc_task_send(task, &event); + isc_task_detach(&task); } else { + isc_event_free(&event); + LOCK(&lock); atomic_store(&done, true); SIGNAL(&cv); UNLOCK(&lock); } - - isc_event_free(&event); -} - -static void -maxtask_cb(isc_task_t *task, isc_event_t *event) { - isc_result_t result; - - if (event->ev_arg != NULL) { - isc_task_t *newtask = NULL; - - event->ev_arg = (void *)(((uintptr_t)event->ev_arg) - 1); - - /* - * Create a new task and forward the message. - */ - result = isc_task_create(taskmgr, 0, &newtask); - assert_int_equal(result, ISC_R_SUCCESS); - - result = isc_task_onshutdown(newtask, maxtask_shutdown, - (void *)task); - assert_int_equal(result, ISC_R_SUCCESS); - - isc_task_send(newtask, &event); - } else if (task != NULL) { - isc_task_destroy(&task); - isc_event_free(&event); - } } static void manytasks(void **state) { - isc_mem_t *mctx = NULL; isc_event_t *event = NULL; - uintptr_t ntasks = 10000; + uintptr_t ntasks = 2; /* 0000; */ UNUSED(state); @@ -479,14 +445,9 @@ manytasks(void **state) { isc_mutex_init(&lock); isc_condition_init(&cv); - isc_mem_debugging = ISC_MEM_DEBUGRECORD; - isc_mem_create(&mctx); - - isc_managers_create(mctx, 4, 0, &netmgr, &taskmgr, NULL); - atomic_init(&done, false); - event = isc_event_allocate(mctx, (void *)1, 1, maxtask_cb, + event = isc_event_allocate(test_mctx, NULL, 1, maxtask_cb, (void *)ntasks, sizeof(*event)); assert_non_null(event); @@ -497,221 +458,10 @@ manytasks(void **state) { } UNLOCK(&lock); - isc_managers_destroy(&netmgr, &taskmgr, NULL); - - isc_mem_destroy(&mctx); isc_condition_destroy(&cv); isc_mutex_destroy(&lock); } -/* - * Shutdown test: - * When isc_task_shutdown() is called, shutdown events are posted - * in LIFO order. - */ - -static int nevents = 0; -static int nsdevents = 0; -static int senders[4]; -atomic_bool ready, all_done; - -static void -sd_sde1(isc_task_t *task, isc_event_t *event) { - UNUSED(task); - - assert_int_equal(nevents, 256); - assert_int_equal(nsdevents, 1); - ++nsdevents; - - if (verbose) { - print_message("# shutdown 1\n"); - } - - isc_event_free(&event); - - atomic_store(&all_done, true); -} - -static void -sd_sde2(isc_task_t *task, isc_event_t *event) { - UNUSED(task); - - assert_int_equal(nevents, 256); - assert_int_equal(nsdevents, 0); - ++nsdevents; - - if (verbose) { - print_message("# shutdown 2\n"); - } - - isc_event_free(&event); -} - -static void -sd_event1(isc_task_t *task, isc_event_t *event) { - UNUSED(task); - - LOCK(&lock); - while (!atomic_load(&ready)) { - WAIT(&cv, &lock); - } - UNLOCK(&lock); - - if (verbose) { - print_message("# event 1\n"); - } - - isc_event_free(&event); -} - -static void -sd_event2(isc_task_t *task, isc_event_t *event) { - UNUSED(task); - - ++nevents; - - if (verbose) { - print_message("# event 2\n"); - } - - isc_event_free(&event); -} - -static void -task_shutdown(void **state) { - isc_result_t result; - isc_eventtype_t event_type; - isc_event_t *event = NULL; - isc_task_t *task = NULL; - int i; - - UNUSED(state); - - nevents = nsdevents = 0; - event_type = 3; - atomic_init(&ready, false); - atomic_init(&all_done, false); - - LOCK(&lock); - - result = isc_task_create(taskmgr, 0, &task); - assert_int_equal(result, ISC_R_SUCCESS); - - /* - * This event causes the task to wait on cv. - */ - event = isc_event_allocate(test_mctx, &senders[1], event_type, - sd_event1, NULL, sizeof(*event)); - assert_non_null(event); - isc_task_send(task, &event); - - /* - * Now we fill up the task's event queue with some events. - */ - for (i = 0; i < 256; ++i) { - event = isc_event_allocate(test_mctx, &senders[1], event_type, - sd_event2, NULL, sizeof(*event)); - assert_non_null(event); - isc_task_send(task, &event); - } - - /* - * Now we register two shutdown events. - */ - result = isc_task_onshutdown(task, sd_sde1, NULL); - assert_int_equal(result, ISC_R_SUCCESS); - - result = isc_task_onshutdown(task, sd_sde2, NULL); - assert_int_equal(result, ISC_R_SUCCESS); - - isc_task_shutdown(task); - isc_task_detach(&task); - - /* - * Now we free the task by signaling cv. - */ - atomic_store(&ready, true); - SIGNAL(&cv); - UNLOCK(&lock); - - while (!atomic_load(&all_done)) { - isc_test_nap(1000); - } - - assert_int_equal(nsdevents, 2); -} - -/* - * Post-shutdown test: - * After isc_task_shutdown() has been called, any call to - * isc_task_onshutdown() will return ISC_R_SHUTTINGDOWN. - */ -static void -psd_event1(isc_task_t *task, isc_event_t *event) { - UNUSED(task); - - LOCK(&lock); - - while (!atomic_load(&done)) { - WAIT(&cv, &lock); - } - - UNLOCK(&lock); - - isc_event_free(&event); -} - -static void -psd_sde(isc_task_t *task, isc_event_t *event) { - UNUSED(task); - - isc_event_free(&event); -} - -static void -post_shutdown(void **state) { - isc_result_t result; - isc_eventtype_t event_type; - isc_event_t *event; - isc_task_t *task; - - UNUSED(state); - - atomic_init(&done, false); - event_type = 4; - - isc_condition_init(&cv); - - LOCK(&lock); - - task = NULL; - result = isc_task_create(taskmgr, 0, &task); - assert_int_equal(result, ISC_R_SUCCESS); - - /* - * This event causes the task to wait on cv. - */ - event = isc_event_allocate(test_mctx, &senders[1], event_type, - psd_event1, NULL, sizeof(*event)); - assert_non_null(event); - isc_task_send(task, &event); - - isc_task_shutdown(task); - - result = isc_task_onshutdown(task, psd_sde, NULL); - assert_int_equal(result, ISC_R_SHUTTINGDOWN); - - /* - * Release the task. - */ - atomic_store(&done, true); - - SIGNAL(&cv); - UNLOCK(&lock); - - isc_task_detach(&task); -} - /* * Helper for the purge tests below: */ @@ -738,6 +488,11 @@ pge_event1(isc_task_t *task, isc_event_t *event) { } UNLOCK(&lock); + LOCK(&lock); + atomic_store(&done, true); + SIGNAL(&cv); + UNLOCK(&lock); + isc_event_free(&event); } @@ -749,18 +504,6 @@ pge_event2(isc_task_t *task, isc_event_t *event) { isc_event_free(&event); } -static void -pge_sde(isc_task_t *task, isc_event_t *event) { - UNUSED(task); - - LOCK(&lock); - atomic_store(&done, true); - SIGNAL(&cv); - UNLOCK(&lock); - - isc_event_free(&event); -} - static void try_purgeevent(void) { isc_result_t result; @@ -781,9 +524,6 @@ try_purgeevent(void) { result = isc_task_create(taskmgr, 0, &task); assert_int_equal(result, ISC_R_SUCCESS); - result = isc_task_onshutdown(task, pge_sde, NULL); - assert_int_equal(result, ISC_R_SUCCESS); - /* * Block the task on cv. */ @@ -847,15 +587,11 @@ purgeevent(void **state) { int main(int argc, char **argv) { const struct CMUnitTest tests[] = { - cmocka_unit_test(manytasks), + cmocka_unit_test_setup_teardown(manytasks, _setup, _teardown), cmocka_unit_test_setup_teardown(all_events, _setup, _teardown), cmocka_unit_test_setup_teardown(basic, _setup2, _teardown), cmocka_unit_test_setup_teardown(create_task, _setup, _teardown), - cmocka_unit_test_setup_teardown(post_shutdown, _setup2, - _teardown), cmocka_unit_test_setup_teardown(purgeevent, _setup2, _teardown), - cmocka_unit_test_setup_teardown(task_shutdown, _setup4, - _teardown), cmocka_unit_test_setup_teardown(task_exclusive, _setup4, _teardown), }; diff --git a/lib/isc/tests/timer_test.c b/lib/isc/tests/timer_test.c index 0202422507..2ce80adc08 100644 --- a/lib/isc/tests/timer_test.c +++ b/lib/isc/tests/timer_test.c @@ -81,11 +81,9 @@ _teardown(void **state) { } static void -test_shutdown(isc_task_t *task, isc_event_t *event) { +test_shutdown(void) { isc_result_t result; - UNUSED(task); - /* * Signal shutdown processing complete. */ @@ -97,8 +95,6 @@ test_shutdown(isc_task_t *task, isc_event_t *event) { result = isc_mutex_unlock(&mx); assert_int_equal(result, ISC_R_SUCCESS); - - isc_event_free(&event); } static void @@ -121,9 +117,6 @@ setup_test(isc_timertype_t timertype, isc_interval_t *interval, result = isc_task_create(taskmgr, 0, &task); assert_int_equal(result, ISC_R_SUCCESS); - result = isc_task_onshutdown(task, test_shutdown, NULL); - assert_int_equal(result, ISC_R_SUCCESS); - isc_mutex_lock(&lasttime_mx); result = isc_time_now(&lasttime); isc_mutex_unlock(&lasttime_mx); @@ -200,6 +193,8 @@ ticktock(isc_task_t *task, isc_event_t *event) { isc_interval_t interval; isc_eventtype_t expected_event_type; + UNUSED(task); + int tick = atomic_fetch_add(&eventcnt, 1); if (verbose) { @@ -247,7 +242,7 @@ ticktock(isc_task_t *task, isc_event_t *event) { result = isc_time_now(&endtime); subthread_assert_result_equal(result, ISC_R_SUCCESS); isc_timer_destroy(&timer); - isc_task_shutdown(task); + test_shutdown(); } } @@ -280,6 +275,8 @@ test_idle(isc_task_t *task, isc_event_t *event) { isc_time_t llim; isc_interval_t interval; + UNUSED(task); + int tick = atomic_fetch_add(&eventcnt, 1); if (verbose) { @@ -315,7 +312,7 @@ test_idle(isc_task_t *task, isc_event_t *event) { isc_event_free(&event); isc_timer_destroy(&timer); - isc_task_shutdown(task); + test_shutdown(); } /* timer type once idles out */ @@ -344,6 +341,8 @@ test_reset(isc_task_t *task, isc_event_t *event) { isc_time_t llim; isc_interval_t interval; + UNUSED(task); + int tick = atomic_fetch_add(&eventcnt, 1); if (verbose) { @@ -395,7 +394,7 @@ test_reset(isc_task_t *task, isc_event_t *event) { isc_event_free(&event); isc_timer_destroy(&timer); - isc_task_shutdown(task); + test_shutdown(); } } @@ -458,7 +457,7 @@ tick_event(isc_task_t *task, isc_event_t *event) { &interval, true); subthread_assert_result_equal(result, ISC_R_SUCCESS); - isc_task_shutdown(task); + atomic_store(&shutdownflag, 1); } isc_event_free(&event); @@ -466,6 +465,8 @@ tick_event(isc_task_t *task, isc_event_t *event) { static void once_event(isc_task_t *task, isc_event_t *event) { + UNUSED(task); + if (verbose) { print_message("# once_event\n"); } @@ -475,24 +476,6 @@ once_event(isc_task_t *task, isc_event_t *event) { */ atomic_store(&startflag, true); - isc_event_free(&event); - isc_task_shutdown(task); -} - -static void -shutdown_purge(isc_task_t *task, isc_event_t *event) { - UNUSED(task); - UNUSED(event); - - if (verbose) { - print_message("# shutdown_event\n"); - } - - /* - * Signal shutdown processing complete. - */ - atomic_store(&shutdownflag, 1); - isc_event_free(&event); } @@ -513,9 +496,6 @@ purge(void **state) { result = isc_task_create(taskmgr, 0, &task1); assert_int_equal(result, ISC_R_SUCCESS); - result = isc_task_onshutdown(task1, shutdown_purge, NULL); - assert_int_equal(result, ISC_R_SUCCESS); - result = isc_task_create(taskmgr, 0, &task2); assert_int_equal(result, ISC_R_SUCCESS); diff --git a/lib/ns/tests/nstest.c b/lib/ns/tests/nstest.c index 1de321b0af..0676009626 100644 --- a/lib/ns/tests/nstest.c +++ b/lib/ns/tests/nstest.c @@ -159,6 +159,8 @@ static void shutdown_managers(isc_task_t *task, isc_event_t *event) { UNUSED(task); + isc_event_free(&event); + if (interfacemgr != NULL) { ns_interfacemgr_shutdown(interfacemgr); ns_interfacemgr_detach(&interfacemgr); @@ -170,8 +172,6 @@ shutdown_managers(isc_task_t *task, isc_event_t *event) { atomic_store(&shutdown_done, true); atomic_store(&run_managers, false); - - isc_event_free(&event); } static void @@ -179,6 +179,10 @@ cleanup_managers(void) { atomic_store(&shutdown_done, false); if (maintask != NULL) { + isc_event_t *event = isc_event_allocate( + mctx, NULL, ISC_TASKEVENT_TEST, shutdown_managers, NULL, + sizeof(*event)); + isc_task_send(maintask, &event); isc_task_shutdown(maintask); isc_task_destroy(&maintask); } @@ -227,7 +231,6 @@ create_managers(void) { isc_managers_create(mctx, ncpus, 0, &netmgr, &taskmgr, &timermgr); CHECK(isc_task_create_bound(taskmgr, 0, &maintask, 0)); isc_taskmgr_setexcltask(taskmgr, maintask); - CHECK(isc_task_onshutdown(maintask, shutdown_managers, NULL)); CHECK(ns_server_create(mctx, matchview, &sctx));