/* Managers */
static isc_nm_t *netmgr = NULL;
-static isc_loopmgr_t *loopmgr = NULL;
static dns_dispatchmgr_t *dispatchmgr = NULL;
static dns_requestmgr_t *requestmgr = NULL;
static ns_interfacemgr_t *interfacemgr = NULL;
dns_client_detach(&client);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
static void
}
/* Create client */
- CHECK(dns_client_create(mctx, loopmgr, netmgr, 0, tlsctx_client_cache,
- &client, srcaddr4, srcaddr6));
+ CHECK(dns_client_create(mctx, netmgr, 0, tlsctx_client_cache, &client,
+ srcaddr4, srcaddr6));
dns_client_setmaxrestarts(client, restarts);
dns_client_setmaxqueries(client, maxtotal);
}
isc_mem_put(mctx, namelist, sizeof(*namelist));
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
dns_client_detach(&client);
}
ns_server_detach(&sctx);
}
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
static void
NULL, 0));
CHECK(dns_message_setopt(message, opt));
- CHECK(dns_requestmgr_create(mctx, loopmgr, dispatchmgr, NULL, NULL,
+ CHECK(dns_requestmgr_create(mctx, dispatchmgr, NULL, NULL,
&requestmgr));
dns_view_attach(view, &(dns_view_t *){ NULL });
ns_server_create(mctx, matchview, &sctx);
- CHECK(dns_dispatchmgr_create(mctx, loopmgr, netmgr, &dispatchmgr));
+ CHECK(dns_dispatchmgr_create(mctx, netmgr, &dispatchmgr));
if (use_ipv4) {
isc_sockaddr_any(&any);
CHECK(dns_dispatch_createudp(dispatchmgr, a, &dispatch6));
}
- CHECK(ns_interfacemgr_create(mctx, sctx, loopmgr, netmgr, dispatchmgr,
- NULL, &interfacemgr));
+ CHECK(ns_interfacemgr_create(mctx, sctx, netmgr, dispatchmgr, NULL,
+ &interfacemgr));
- dns_view_create(mctx, loopmgr, dispatchmgr, dns_rdataclass_in,
- "_default", &view);
- CHECK(dns_cache_create(loopmgr, dns_rdataclass_in, "", mctx, &cache));
+ dns_view_create(mctx, dispatchmgr, dns_rdataclass_in, "_default",
+ &view);
+ CHECK(dns_cache_create(dns_rdataclass_in, "", mctx, &cache));
dns_view_setcache(view, cache, false);
dns_cache_detach(&cache);
dns_view_setdstport(view, destport);
argc--;
argv++;
- isc_managers_create(&mctx, 1, &loopmgr, &netmgr);
- loop = isc_loop_main(loopmgr);
+ isc_managers_create(&mctx, 1, &netmgr);
+ loop = isc_loop_main();
parse_args(argc, argv);
isc_tlsctx_cache_create(mctx, &tlsctx_client_cache);
isc_loop_setup(loop, fulltrace ? run_server : run_resolve, NULL);
- isc_loopmgr_run(loopmgr);
+ isc_loopmgr_run();
cleanup:
if (tlsctx_client_cache != NULL) {
dns_master_styledestroy(&style, mctx);
}
- isc_managers_destroy(&mctx, &loopmgr, &netmgr);
+ isc_managers_destroy(&mctx, &netmgr);
return 0;
}
}
batchname = NULL;
}
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
static void
dig_startup(void) {
debug("dig_startup()");
- isc_loopmgr_setup(loopmgr, run_loop, NULL);
- isc_loopmgr_run(loopmgr);
+ isc_loopmgr_setup(run_loop, NULL);
+ isc_loopmgr_run();
}
void
unsigned int extrabytes;
isc_mem_t *mctx = NULL;
isc_nm_t *netmgr = NULL;
-isc_loopmgr_t *loopmgr = NULL;
isc_loop_t *mainloop = NULL;
isc_sockaddr_t localaddr;
isc_refcount_t sendcount = 0;
return;
}
- isc_loopmgr_blocking(loopmgr);
+ isc_loopmgr_blocking();
result = isc_getaddresses(opt, 0, sockaddrs, DIG_MAX_ADDRESSES, &count);
- isc_loopmgr_nonblocking(loopmgr);
+ isc_loopmgr_nonblocking();
if (result != ISC_R_SUCCESS) {
fatal("couldn't get address for '%s': %s", opt,
isc_result_totext(result));
fatal("can't find either v4 or v6 networking");
}
- isc_managers_create(&mctx, 1, &loopmgr, &netmgr);
+ isc_managers_create(&mctx, 1, &netmgr);
logconfig = isc_logconfig_get();
isc_log_createandusechannel(logconfig, "debug", ISC_LOG_TOFILEDESC,
ISC_LOGMODULE_DEFAULT);
isc_log_setdebuglevel(0);
- mainloop = isc_loop_main(loopmgr);
+ mainloop = isc_loop_main();
}
typedef struct dig_ednsoptname {
int count;
isc_result_t result;
- isc_loopmgr_blocking(loopmgr);
+ isc_loopmgr_blocking();
result = isc_getaddresses(host, myport, sockaddr, 1, &count);
- isc_loopmgr_nonblocking(loopmgr);
+ isc_loopmgr_nonblocking();
if (result != ISC_R_SUCCESS) {
return result;
}
dig_server_t *srv;
char tmp[ISC_NETADDR_FORMATSIZE];
- isc_loopmgr_blocking(loopmgr);
+ isc_loopmgr_blocking();
result = isc_getaddresses(host, 0, sockaddrs, DIG_MAX_ADDRESSES,
&count);
- isc_loopmgr_nonblocking(loopmgr);
+ isc_loopmgr_nonblocking();
SET_IF_NOT_NULL(resultp, result);
if (result != ISC_R_SUCCESS) {
if (resultp == NULL) {
isc_mem_stats(mctx, stderr);
}
- isc_managers_destroy(&mctx, &loopmgr, &netmgr);
+ isc_managers_destroy(&mctx, &netmgr);
#if ENABLE_LEAK_DETECTION
isc__crypto_setdestroycheck(true);
#include <isc/sockaddr.h>
#include <isc/time.h>
+#include <dns/fixedname.h>
#include <dns/rdatalist.h>
#include <dst/dst.h>
extern unsigned int digestbits;
extern dns_tsigkey_t *tsigkey;
extern bool validated;
-extern isc_loopmgr_t *loopmgr;
extern isc_loop_t *mainloop;
extern bool free_now;
extern bool debugging, debugtiming, memdebugging;
static void
host_shutdown(void) {
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
static void
setup_text_key();
}
- isc_loopmgr_setup(loopmgr, run_loop, NULL);
- isc_loopmgr_run(loopmgr);
+ isc_loopmgr_setup(run_loop, NULL);
+ isc_loopmgr_run();
cancel_all();
destroy_libs();
UNUSED(arg);
- isc_loopmgr_blocking(loopmgr);
+ isc_loopmgr_blocking();
ptr = readline("> ");
- isc_loopmgr_nonblocking(loopmgr);
+ isc_loopmgr_nonblocking();
if (ptr == NULL) {
return;
}
static void
process_next_command(void *arg ISC_ATTR_UNUSED) {
- isc_loop_t *loop = isc_loop_main(loopmgr);
+ isc_loop_t *loop = isc_loop_main();
if (cmdline == NULL) {
in_use = false;
} else {
static void
start_next_command(void) {
- isc_loop_t *loop = isc_loop_main(loopmgr);
+ isc_loop_t *loop = isc_loop_main();
if (!in_use) {
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
return;
}
cmdline = NULL;
- isc_loopmgr_pause(loopmgr);
+ isc_loopmgr_pause();
if (interactive) {
isc_work_enqueue(loop, readline_next_command,
process_next_command, loop);
isc_work_enqueue(loop, fgets_next_command, process_next_command,
loop);
}
- isc_loopmgr_resume(loopmgr);
+ isc_loopmgr_resume();
}
static void
set_search_domain(domainopt);
}
if (in_use) {
- isc_loopmgr_setup(loopmgr, run_loop, NULL);
+ isc_loopmgr_setup(run_loop, NULL);
} else {
- isc_loopmgr_setup(loopmgr, read_loop, NULL);
+ isc_loopmgr_setup(read_loop, NULL);
}
in_use = !in_use;
- isc_loopmgr_run(loopmgr);
+ isc_loopmgr_run();
puts("");
debug("done, and starting to shut down");
static const char *directory = NULL, *dsdir = NULL;
static isc_mutex_t namelock;
static isc_nm_t *netmgr = NULL;
-static isc_loopmgr_t *loopmgr = NULL;
static dns_db_t *gdb; /* The database */
static dns_dbversion_t *gversion; /* The database version */
static dns_dbiterator_t *gdbiter; /* The database iterator */
if (atomic_load(&finished)) {
ended++;
if (ended == nloops) {
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
UNLOCK(&namelock);
return;
if (!found) {
ended++;
if (ended == nloops) {
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
UNLOCK(&namelock);
return;
directory = ".";
}
- isc_managers_create(&mctx, nloops, &loopmgr, &netmgr);
+ isc_managers_create(&mctx, nloops, &netmgr);
setup_logging();
* There is more work to do. Spread it out over multiple
* processors if possible.
*/
- isc_loopmgr_setup(loopmgr, assignwork, NULL);
- isc_loopmgr_teardown(loopmgr, abortwork, NULL);
- isc_loopmgr_run(loopmgr);
+ isc_loopmgr_setup(assignwork, NULL);
+ isc_loopmgr_teardown(abortwork, NULL);
+ isc_loopmgr_run();
if (!atomic_load(&finished)) {
fatal("process aborted by user");
isc_mem_stats(mctx, stdout);
}
- isc_managers_destroy(&mctx, &loopmgr, &netmgr);
+ isc_managers_destroy(&mctx, &netmgr);
if (printstats) {
timer_finish = isc_time_now();
/* Do not flush master files */
named_server_flushonshutdown(named_g_server, false);
named_os_shutdownmsg(cmdline, *text);
- isc_loopmgr_shutdown(named_g_loopmgr);
+ isc_loopmgr_shutdown();
result = ISC_R_SHUTTINGDOWN;
} else if (command_compare(command, NAMED_COMMAND_STOP)) {
/*
#endif /* ifdef HAVE_LIBSCF */
named_server_flushonshutdown(named_g_server, true);
named_os_shutdownmsg(cmdline, *text);
- isc_loopmgr_shutdown(named_g_loopmgr);
+ isc_loopmgr_shutdown();
result = ISC_R_SHUTTINGDOWN;
} else if (command_compare(command, NAMED_COMMAND_ADDZONE) ||
command_compare(command, NAMED_COMMAND_MODZONE))
controlconnection_ref(conn);
/* Trigger the command asynchronously. */
- isc_async_run(named_g_mainloop, control_command, conn);
+ isc_async_run(isc_loop_main(), control_command, conn);
return;
close(sockfd);
named_server_flushonshutdown(named_g_server,
false);
- isc_loopmgr_shutdown(named_g_loopmgr);
+ isc_loopmgr_shutdown();
return NULL;
}
raise(SIGSTOP);
close(sockfd);
named_server_flushonshutdown(named_g_server, false);
- isc_loopmgr_shutdown(named_g_loopmgr);
+ isc_loopmgr_shutdown();
return NULL;
}
close(listenfd);
named_server_flushonshutdown(named_g_server,
false);
- isc_loopmgr_shutdown(named_g_loopmgr);
+ isc_loopmgr_shutdown();
return NULL;
}
raise(SIGSTOP);
close(sockfd);
close(listenfd);
named_server_flushonshutdown(named_g_server, false);
- isc_loopmgr_shutdown(named_g_loopmgr);
+ isc_loopmgr_shutdown();
#ifdef __AFL_LOOP
/*
free(buf);
close(sockfd);
named_server_flushonshutdown(named_g_server, false);
- isc_loopmgr_shutdown(named_g_loopmgr);
+ isc_loopmgr_shutdown();
return NULL;
}
#ifdef ENABLE_AFL
if (getenv("AFL_CMIN")) {
named_server_flushonshutdown(named_g_server, false);
- isc_loopmgr_shutdown(named_g_loopmgr);
+ isc_loopmgr_shutdown();
return;
}
EXTERN isc_mem_t *named_g_mctx INIT(NULL);
EXTERN unsigned int named_g_cpus INIT(0);
-EXTERN isc_loop_t *named_g_mainloop INIT(NULL);
-EXTERN isc_loopmgr_t *named_g_loopmgr INIT(NULL);
EXTERN bool named_g_loopmgr_running INIT(false);
EXTERN dns_dispatchmgr_t *named_g_dispatchmgr INIT(NULL);
EXTERN unsigned int named_g_cpus_detected INIT(1);
"thread count limit)"
: "");
- isc_managers_create(&named_g_mctx, named_g_cpus, &named_g_loopmgr,
- &named_g_netmgr);
+ isc_managers_create(&named_g_mctx, named_g_cpus, &named_g_netmgr);
isc_nm_maxudp(named_g_netmgr, maxudp);
* Pause the loop manager in fatal.
*/
named_g_loopmgr_running = true;
- isc_loopmgr_run(named_g_loopmgr);
+ isc_loopmgr_run();
#ifdef HAVE_LIBSCF
if (named_smf_want_disable == 1) {
}
}
- isc_managers_destroy(&named_g_mctx, &named_g_loopmgr, &named_g_netmgr);
+ isc_managers_destroy(&named_g_mctx, &named_g_netmgr);
#if ENABLE_LEAK_DETECTION
isc__crypto_setdestroycheck(true);
maps[i] = NULL;
dns_view_initsecroots(view);
- dns_view_initntatable(view, named_g_loopmgr);
+ dns_view_initntatable(view);
if (auto_root && view->rdclass == dns_rdataclass_in) {
const cfg_obj_t *builtin_keys = NULL;
}
nsdname_on = nsdname_enabled ? DNS_RPZ_ALL_ZBITS : 0;
- result = dns_rpz_new_zones(view, named_g_loopmgr, &view->rpzs);
+ result = dns_rpz_new_zones(view, &view->rpzs);
if (result != ISC_R_SUCCESS) {
return result;
}
ns_cfgctx_t *cfg = NULL;
dns_zone_t *zone = NULL;
- if (isc_loop_shuttingdown(isc_loop_get(named_g_loopmgr, isc_tid()))) {
+ if (isc_loop_shuttingdown(isc_loop_get(isc_tid()))) {
goto cleanup;
}
zoneobj = cfg_listelt_value(cfg_list_first(zlist));
/* Mark view unfrozen so that zone can be added */
- isc_loopmgr_pause(named_g_loopmgr);
+ isc_loopmgr_pause();
dns_view_thaw(cz->view);
result = configure_zone(cfg->config, zoneobj, cfg->vconfig, cz->view,
&cz->cbd->server->viewlist,
&cz->cbd->server->keystorelist, cfg->actx, true,
false, true, cz->mod);
dns_view_freeze(cz->view);
- isc_loopmgr_resume(named_g_loopmgr);
+ isc_loopmgr_resume();
if (result != ISC_R_SUCCESS) {
isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
char cname[DNS_NAME_FORMATSIZE];
const char *file = NULL;
- if (isc_loop_shuttingdown(isc_loop_get(named_g_loopmgr, isc_tid()))) {
+ if (isc_loop_shuttingdown(isc_loop_get(isc_tid()))) {
goto cleanup;
}
- isc_loopmgr_pause(named_g_loopmgr);
+ isc_loopmgr_pause();
dns_name_format(dns_catz_entry_getname(cz->entry), cname,
DNS_NAME_FORMATSIZE);
"zone '%s' deleted",
cname);
resume:
- isc_loopmgr_resume(named_g_loopmgr);
+ isc_loopmgr_resume();
cleanup:
if (zone != NULL) {
dns_zone_detach(&zone);
dns_catz_zone_attach(origin, &cz->origin);
dns_view_weakattach(view, &cz->view);
- isc_async_run(named_g_mainloop, action, cz);
+ isc_async_run(isc_loop_main(), action, cz);
return ISC_R_SUCCESS;
}
dns_catz_zones_detach(&pview->catzs);
dns_catz_prereconfig(view->catzs);
} else {
- view->catzs = dns_catz_zones_new(view->mctx, named_g_loopmgr,
+ view->catzs = dns_catz_zones_new(view->mctx,
&ns_catz_zonemodmethods);
}
}
CHECKM(dns_dt_create(named_g_mctx, dmode, dpath, &fopt,
- named_g_mainloop, &named_g_server->dtenv),
+ isc_loop_main(), &named_g_server->dtenv),
"unable to create dnstap environment");
CHECKM(dns_dt_setupfile(named_g_server->dtenv, max_size, rolls,
* is simply a named cache that is not shared.
*/
if (cache == NULL) {
- CHECK(dns_cache_create(named_g_loopmgr, view->rdclass,
- cachename, mctx, &cache));
+ CHECK(dns_cache_create(view->rdclass, cachename, mctx,
+ &cache));
}
nsc = isc_mem_get(mctx, sizeof(*nsc));
if (dctx == NULL) {
const void *hashinit = isc_hash_get_initializer();
dns_dyndb_createctx(mctx, hashinit, view,
- named_g_server->zonemgr,
- named_g_loopmgr, &dctx);
+ named_g_server->zonemgr, &dctx);
}
CHECK(configure_dyndb(dyndb, mctx, dctx));
}
INSIST(view == NULL);
- dns_view_create(named_g_mctx, named_g_loopmgr, named_g_dispatchmgr,
- viewclass, viewname, &view);
+ dns_view_create(named_g_mctx, named_g_dispatchmgr, viewclass, viewname,
+ &view);
isc_nonce_buf(view->secret, sizeof(view->secret));
* view->lock (dns_view_findzonecut) while holding keytable->lock
* (dns_keytable_forall)
*/
- isc_async_run(named_g_mainloop, tat_send, tat);
+ isc_async_run(isc_loop_main(), tat_send, tat);
}
static void
}
dotat_arg.view = view;
- dotat_arg.loop = named_g_mainloop;
+ dotat_arg.loop = isc_loop_main();
dns_keytable_forall(secroots, dotat, &dotat_arg);
dns_keytable_detach(&secroots);
}
/*
* Require the reconfiguration to happen always on the main loop
*/
- REQUIRE(isc_loop() == named_g_mainloop);
+ REQUIRE(isc_loop() == isc_loop_main());
ISC_LIST_INIT(kasplist);
ISC_LIST_INIT(keystorelist);
ISC_LIST_INIT(altsecrets);
/* Ensure exclusive access to configuration data. */
- isc_loopmgr_pause(named_g_loopmgr);
+ isc_loopmgr_pause();
/* Create the ACL configuration context */
if (named_g_aclconfctx != NULL) {
* listen-on option. This requires the loopmgr to be
* temporarily resumed.
*/
- isc_loopmgr_resume(named_g_loopmgr);
+ isc_loopmgr_resume();
result = ns_interfacemgr_scan(server->interfacemgr, true, true);
- isc_loopmgr_pause(named_g_loopmgr);
+ isc_loopmgr_pause();
/*
* Check that named is able to TCP listen on at least one
*/
named_g_defaultconfigtime = isc_time_now();
- isc_loopmgr_resume(named_g_loopmgr);
+ isc_loopmgr_resume();
exclusive = false;
/* Take back root privileges temporarily */
cleanup_exclusive:
if (exclusive) {
- isc_loopmgr_resume(named_g_loopmgr);
+ isc_loopmgr_resume();
}
isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
zl->server = server;
zl->reconfig = reconfig;
- isc_loopmgr_pause(named_g_loopmgr);
+ isc_loopmgr_pause();
isc_refcount_init(&zl->refs, 1);
isc_mem_put(server->mctx, zl, sizeof(*zl));
}
- isc_loopmgr_resume(named_g_loopmgr);
+ isc_loopmgr_resume();
return result;
}
dns_zonemgr_create(named_g_mctx, named_g_netmgr, &server->zonemgr);
- CHECKFATAL(dns_dispatchmgr_create(named_g_mctx, named_g_loopmgr,
- named_g_netmgr, &named_g_dispatchmgr),
+ CHECKFATAL(dns_dispatchmgr_create(named_g_mctx, named_g_netmgr,
+ &named_g_dispatchmgr),
"creating dispatch manager");
dns_dispatchmgr_setstats(named_g_dispatchmgr, server->resolverstats);
#endif /* if defined(HAVE_GEOIP2) */
CHECKFATAL(ns_interfacemgr_create(named_g_mctx, server->sctx,
- named_g_loopmgr, named_g_netmgr,
- named_g_dispatchmgr, geoip,
- &server->interfacemgr),
+ named_g_netmgr, named_g_dispatchmgr,
+ geoip, &server->interfacemgr),
"creating interface manager");
- isc_timer_create(named_g_mainloop, interface_timer_tick, server,
+ isc_timer_create(isc_loop_main(), interface_timer_tick, server,
&server->interface_timer);
- isc_timer_create(named_g_mainloop, tat_timer_tick, server,
+ isc_timer_create(isc_loop_main(), tat_timer_tick, server,
&server->tat_timer);
- isc_timer_create(named_g_mainloop, pps_timer_tick, server,
+ isc_timer_create(isc_loop_main(), pps_timer_tick, server,
&server->pps_timer);
CHECKFATAL(cfg_parser_create(named_g_mctx, &named_g_parser),
named_statschannels_shutdown(server);
- isc_loopmgr_pause(named_g_loopmgr);
+ isc_loopmgr_pause();
isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
ISC_LOG_INFO, "shutting down%s",
dns_db_detach(&server->in_roothints);
- isc_loopmgr_resume(named_g_loopmgr);
+ isc_loopmgr_resume();
}
static isc_result_t
server->sctx->fuzznotify = named_fuzz_notify;
#endif /* ifdef ENABLE_AFL */
- named_g_mainloop = isc_loop_main(named_g_loopmgr);
-
- isc_loop_setup(named_g_mainloop, run_server, server);
- isc_loop_teardown(named_g_mainloop, shutdown_server, server);
+ isc_loop_setup(isc_loop_main(), run_server, server);
+ isc_loop_teardown(isc_loop_main(), shutdown_server, server);
/* Add SIGHUP reload handler */
- server->sighup = isc_signal_new(
- named_g_loopmgr, named_server_reloadwanted, server, SIGHUP);
+ server->sighup = isc_signal_new(named_server_reloadwanted, server,
+ SIGHUP);
/* Add SIGUSR2 closelogs handler */
- server->sigusr1 = isc_signal_new(
- named_g_loopmgr, named_server_closelogswanted, server, SIGUSR1);
+ server->sigusr1 = isc_signal_new(named_server_closelogswanted, server,
+ SIGUSR1);
isc_stats_create(server->mctx, &server->sockstats,
isc_sockstatscounter_max);
static void
fatal(const char *msg, isc_result_t result) {
if (named_g_loopmgr_running) {
- isc_loopmgr_pause(named_g_loopmgr);
+ isc_loopmgr_pause();
}
isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
ISC_LOG_CRITICAL, "%s: %s", msg,
REQUIRE(signum == SIGHUP);
- isc_async_run(named_g_mainloop, named_server_reload, server);
+ isc_async_run(isc_loop_main(), named_server_reload, server);
}
/*
REQUIRE(signum == SIGUSR1);
- isc_async_run(named_g_mainloop, named_server_closelogs, server);
+ isc_async_run(isc_loop_main(), named_server_closelogs, server);
}
#ifdef JEMALLOC_API_SUPPORTED
dns_cache_getname(dctx->view->view->cache));
result = dns_master_dumptostreamasync(
dctx->mctx, dctx->cache, NULL, style, dctx->fp,
- named_g_mainloop, dumpdone, dctx, &dctx->mdctx);
+ isc_loop_main(), dumpdone, dctx, &dctx->mdctx);
if (result == ISC_R_SUCCESS) {
return;
}
/* Look for the view name. */
ptr = next_token(lex, text);
- isc_loopmgr_pause(named_g_loopmgr);
+ isc_loopmgr_pause();
ISC_LIST_FOREACH (server->viewlist, view, link) {
if ((ptr != NULL && strcasecmp(ptr, view->name) != 0) ||
strcasecmp("_bind", view->name) == 0)
result = ISC_R_FAILURE;
}
cleanup:
- isc_loopmgr_resume(named_g_loopmgr);
+ isc_loopmgr_resume();
return result;
}
/* Look for the view name. */
ptr = next_token(lex, NULL);
- isc_loopmgr_pause(named_g_loopmgr);
+ isc_loopmgr_pause();
flushed = true;
found = false;
result = ISC_R_FAILURE;
}
}
- isc_loopmgr_resume(named_g_loopmgr);
+ isc_loopmgr_resume();
return result;
}
/* Look for the view name. */
viewname = next_token(lex, NULL);
- isc_loopmgr_pause(named_g_loopmgr);
+ isc_loopmgr_pause();
flushed = true;
found = false;
ISC_LIST_FOREACH (server->viewlist, view, link) {
}
result = ISC_R_FAILURE;
}
- isc_loopmgr_resume(named_g_loopmgr);
+ isc_loopmgr_resume();
return result;
}
}
if (zone == NULL) {
- isc_loopmgr_pause(named_g_loopmgr);
+ isc_loopmgr_pause();
tresult = ISC_R_SUCCESS;
ISC_LIST_FOREACH (server->viewlist, view, link) {
result = dns_view_apply(view, false, NULL, synczone,
tresult = result;
}
}
- isc_loopmgr_resume(named_g_loopmgr);
+ isc_loopmgr_resume();
isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
ISC_LOG_INFO, "dumping all zones%s: %s",
cleanup ? ", removing journal files" : "",
return tresult;
}
- isc_loopmgr_pause(named_g_loopmgr);
+ isc_loopmgr_pause();
result = synczone(zone, &cleanup);
- isc_loopmgr_resume(named_g_loopmgr);
+ isc_loopmgr_resume();
dns_view_t *view = dns_zone_getview(zone);
if (strcmp(view->name, "_default") == 0 ||
return result;
}
if (mayberaw == NULL) {
- isc_loopmgr_pause(named_g_loopmgr);
+ isc_loopmgr_pause();
tresult = ISC_R_SUCCESS;
ISC_LIST_FOREACH (server->viewlist, view, link) {
result = dns_view_freezezones(view, freeze);
tresult = result;
}
}
- isc_loopmgr_resume(named_g_loopmgr);
+ isc_loopmgr_resume();
isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
ISC_LOG_INFO, "%s all zones: %s",
freeze ? "freezing" : "thawing",
return DNS_R_NOTDYNAMIC;
}
- isc_loopmgr_pause(named_g_loopmgr);
+ isc_loopmgr_pause();
frozen = dns_zone_getupdatedisabled(mayberaw);
if (freeze) {
if (frozen) {
}
}
}
- isc_loopmgr_resume(named_g_loopmgr);
+ isc_loopmgr_resume();
if (msg != NULL) {
(void)putstr(text, msg);
goto cleanup;
}
- isc_loopmgr_pause(named_g_loopmgr);
+ isc_loopmgr_pause();
#ifndef HAVE_LMDB
/*
*/
result = isc_stdio_open(view->new_zone_file, "a", &fp);
if (result != ISC_R_SUCCESS) {
- isc_loopmgr_resume(named_g_loopmgr);
+ isc_loopmgr_resume();
TCHECK(putstr(text, "unable to create '"));
TCHECK(putstr(text, view->new_zone_file));
TCHECK(putstr(text, "': "));
/* Make sure we can open the NZD database */
result = nzd_writable(view);
if (result != ISC_R_SUCCESS) {
- isc_loopmgr_resume(named_g_loopmgr);
+ isc_loopmgr_resume();
TCHECK(putstr(text, "unable to open NZD database for '"));
TCHECK(putstr(text, view->new_zone_db));
TCHECK(putstr(text, "'"));
NULL, NULL, NULL, view->name,
view->rdclass, cfg->actx, cfg->mctx);
if (result != ISC_R_SUCCESS) {
- isc_loopmgr_resume(named_g_loopmgr);
+ isc_loopmgr_resume();
goto cleanup;
}
false, false);
dns_view_freeze(view);
- isc_loopmgr_resume(named_g_loopmgr);
+ isc_loopmgr_resume();
if (result != ISC_R_SUCCESS) {
TCHECK(putstr(text, "configure_zone failed: "));
}
#endif /* ifndef HAVE_LMDB */
- isc_loopmgr_pause(named_g_loopmgr);
+ isc_loopmgr_pause();
#ifndef HAVE_LMDB
/* Make sure we can open the configuration save file */
TCHECK(putstr(text, view->new_zone_file));
TCHECK(putstr(text, "': "));
TCHECK(putstr(text, isc_result_totext(result)));
- isc_loopmgr_resume(named_g_loopmgr);
+ isc_loopmgr_resume();
goto cleanup;
}
(void)isc_stdio_close(fp);
TCHECK(putstr(text, view->new_zone_db));
TCHECK(putstr(text, "'"));
result = ISC_R_FAILURE;
- isc_loopmgr_resume(named_g_loopmgr);
+ isc_loopmgr_resume();
goto cleanup;
}
#endif /* HAVE_LMDB */
NULL, NULL, NULL, view->name,
view->rdclass, cfg->actx, cfg->mctx);
if (result != ISC_R_SUCCESS) {
- isc_loopmgr_resume(named_g_loopmgr);
+ isc_loopmgr_resume();
goto cleanup;
}
false, true);
dns_view_freeze(view);
- isc_loopmgr_resume(named_g_loopmgr);
+ isc_loopmgr_resume();
if (result != ISC_R_SUCCESS) {
TCHECK(putstr(text, "configure_zone failed: "));
now = isc_stdtime_now();
- isc_loopmgr_pause(named_g_loopmgr);
+ isc_loopmgr_pause();
ISC_LIST_FOREACH (server->viewlist, view, link) {
if (viewname != NULL && strcmp(view->name, viewname) != 0) {
continue;
}
cleanup_exclusive:
- isc_loopmgr_resume(named_g_loopmgr);
+ isc_loopmgr_resume();
cleanup:
view->name);
CHECK(putstr(text, msg));
- isc_loopmgr_pause(named_g_loopmgr);
+ isc_loopmgr_pause();
/* Remove and clean up managed keys zone from view */
mkzone = view->managed_keys;
result = ISC_R_SUCCESS;
cleanup:
- isc_loopmgr_resume(named_g_loopmgr);
+ isc_loopmgr_resume();
return result;
}
}
}
- isc_loopmgr_pause(named_g_loopmgr);
+ isc_loopmgr_pause();
ISC_LIST_FOREACH (server->viewlist, view, link) {
dns_ttl_t stale_ttl = 0;
}
cleanup:
- isc_loopmgr_resume(named_g_loopmgr);
+ isc_loopmgr_resume();
if (isc_buffer_usedlength(*text) > 0) {
(void)putnull(text);
static bool usegsstsig = false;
static bool local_only = false;
static isc_nm_t *netmgr = NULL;
-static isc_loopmgr_t *loopmgr = NULL;
static isc_mem_t *gmctx = NULL;
static dns_dispatchmgr_t *dispatchmgr = NULL;
static dns_requestmgr_t *requestmgr = NULL;
irs_resconf_destroy(&resconf);
- result = dns_dispatchmgr_create(gmctx, loopmgr, netmgr, &dispatchmgr);
+ result = dns_dispatchmgr_create(gmctx, netmgr, &dispatchmgr);
check_result(result, "dns_dispatchmgr_create");
set_source_ports(dispatchmgr);
dns_transport_set_always_verify_remote(transport,
tls_always_verify_remote);
- result = dns_requestmgr_create(gmctx, loopmgr, dispatchmgr, dispatchv4,
+ result = dns_requestmgr_create(gmctx, dispatchmgr, dispatchv4,
dispatchv6, &requestmgr);
check_result(result, "dns_requestmgr_create");
int count = 0;
isc_result_t result;
- isc_loopmgr_blocking(loopmgr);
+ isc_loopmgr_blocking();
result = isc_getaddresses(host, port, sockaddr, naddrs, &count);
- isc_loopmgr_nonblocking(loopmgr);
+ isc_loopmgr_nonblocking();
if (result != ISC_R_SUCCESS) {
error("couldn't get address for '%s': %s", host,
isc_result_totext(result));
result = dns_request_create(requestmgr, updatemsg, srcaddr, primary,
req_transport, req_tls_ctx_cache, options,
tsigkey, timeout, timeout, udp_timeout,
- udp_retries, isc_loop_main(loopmgr),
+ udp_retries, isc_loop_main(),
update_completed, NULL, &request);
check_result(result, "dns_request_create");
result = dns_request_create(
requestmgr, soaquery, srcaddr, addr, req_transport,
req_tls_ctx_cache, options, NULL, timeout, timeout,
- udp_timeout, udp_retries, isc_loop_main(loopmgr),
- recvsoa, reqinfo, &request);
+ udp_timeout, udp_retries, isc_loop_main(), recvsoa,
+ reqinfo, &request);
check_result(result, "dns_request_create");
requests++;
return;
srcaddr = localaddr4;
}
- result = dns_request_create(
- requestmgr, msg, srcaddr, destaddr, req_transport,
- req_tls_ctx_cache, options, default_servers ? NULL : tsigkey,
- timeout, timeout, udp_timeout, udp_retries,
- isc_loop_main(loopmgr), recvsoa, reqinfo, request);
+ result = dns_request_create(requestmgr, msg, srcaddr, destaddr,
+ req_transport, req_tls_ctx_cache, options,
+ default_servers ? NULL : tsigkey, timeout,
+ timeout, udp_timeout, udp_retries,
+ isc_loop_main(), recvsoa, reqinfo, request);
check_result(result, "dns_request_create");
requests++;
}
result = dns_request_create(requestmgr, msg, srcaddr, destaddr,
req_transport, req_tls_ctx_cache, options,
tsigkey, timeout, timeout, udp_timeout,
- udp_retries, isc_loop_main(loopmgr),
- recvgss, reqinfo, request);
+ udp_retries, isc_loop_main(), recvgss,
+ reqinfo, request);
check_result(result, "dns_request_create");
if (debugging) {
show_message(stdout, msg, "Outgoing update query:");
isc_mutex_destroy(&answer_lock);
ddebug("Shutting down managers");
- isc_managers_destroy(&gmctx, &loopmgr, &netmgr);
+ isc_managers_destroy(&gmctx, &netmgr);
}
static void
}
reset_system();
- isc_loopmgr_blocking(loopmgr);
+ isc_loopmgr_blocking();
more = user_interaction();
- isc_loopmgr_nonblocking(loopmgr);
+ isc_loopmgr_nonblocking();
if (!more) {
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
return;
}
pre_parse_args(argc, argv);
- isc_managers_create(&gmctx, 1, &loopmgr, &netmgr);
+ isc_managers_create(&gmctx, 1, &netmgr);
parse_args(argc, argv);
isc_nm_setkeepalivetimeout(netmgr, timeoutms);
isc_nm_setadvertisedtimeout(netmgr, timeoutms);
- isc_loopmgr_setup(loopmgr, setup_system, NULL);
- isc_loopmgr_setup(loopmgr, getinput, NULL);
- isc_loopmgr_teardown(loopmgr, shutdown_program, NULL);
- isc_loopmgr_run(loopmgr);
+ isc_loopmgr_setup(setup_system, NULL);
+ isc_loopmgr_setup(getinput, NULL);
+ isc_loopmgr_teardown(shutdown_program, NULL);
+ isc_loopmgr_run();
cleanup();
bool verbose;
static isc_nm_t *netmgr = NULL;
-static isc_loopmgr_t *loopmgr = NULL;
static const char *admin_conffile = NULL;
static const char *admin_keyfile = NULL;
isccc_sexpr_free(&response);
isccc_ccmsg_disconnect(ccmsg);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
static void
serial = isc_random32();
- isc_managers_create(&rndc_mctx, 1, &loopmgr, &netmgr);
- isc_loopmgr_setup(loopmgr, rndc_start, NULL);
+ isc_managers_create(&rndc_mctx, 1, &netmgr);
+ isc_loopmgr_setup(rndc_start, NULL);
isc_nm_setinitialtimeout(netmgr, timeout);
isc_nm_setprimariestimeout(netmgr, timeout);
get_addresses(servername, (in_port_t)remoteport);
}
- isc_loopmgr_run(loopmgr);
+ isc_loopmgr_run();
isccc_ccmsg_invalidate(&rndc_ccmsg);
isc_mem_stats(rndc_mctx, stderr);
}
- isc_managers_destroy(&rndc_mctx, &loopmgr, &netmgr);
+ isc_managers_destroy(&rndc_mctx, &netmgr);
if (failed) {
return 1;
dns_view_attach(dctx->view, &inst->view);
dns_zonemgr_attach(dctx->zmgr, &inst->zmgr);
- inst->loopmgr = dctx->loopmgr;
/* Register new DNS DB implementation. */
result = dns_db_register(db_name, create_db, inst, mctx, &inst->db_imp);
/* These are needed for zone creation. */
dns_view_t *view;
dns_zonemgr_t *zmgr;
- isc_loopmgr_t *loopmgr;
bool exiting;
dns_zone_t *zone1;
static isc_mem_t *mctx = NULL;
static dns_requestmgr_t *requestmgr = NULL;
-static isc_loopmgr_t *loopmgr = NULL;
static bool have_src = false;
static isc_sockaddr_t srcaddr;
static isc_sockaddr_t dstaddr;
dns_request_destroy(&request);
if (--onfly == 0) {
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
return;
}
result = dns_request_create(
requestmgr, message, have_src ? &srcaddr : NULL, &dstaddr, NULL,
NULL, DNS_REQUESTOPT_TCP, NULL, TIMEOUT, TIMEOUT, 0, 0,
- isc_loop_main(loopmgr), recvresponse, message, &request);
+ isc_loop_main(), recvresponse, message, &request);
CHECK("dns_request_create", result);
return ISC_R_SUCCESS;
} while (result == ISC_R_SUCCESS);
if (onfly == 0) {
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
return;
}
}
isc_sockaddr_fromin(&dstaddr, &inaddr, port);
- isc_managers_create(&mctx, 1, &loopmgr, &netmgr);
+ isc_managers_create(&mctx, 1, &netmgr);
- RUNCHECK(dns_dispatchmgr_create(mctx, loopmgr, netmgr, &dispatchmgr));
+ RUNCHECK(dns_dispatchmgr_create(mctx, netmgr, &dispatchmgr));
RUNCHECK(dns_dispatch_createudp(
dispatchmgr, have_src ? &srcaddr : &bind_any, &dispatchv4));
- RUNCHECK(dns_requestmgr_create(mctx, loopmgr, dispatchmgr, dispatchv4,
- NULL, &requestmgr));
+ RUNCHECK(dns_requestmgr_create(mctx, dispatchmgr, dispatchv4, NULL,
+ &requestmgr));
- dns_view_create(mctx, loopmgr, NULL, 0, "_test", &view);
+ dns_view_create(mctx, NULL, 0, "_test", &view);
- isc_loopmgr_setup(loopmgr, sendqueries, NULL);
- isc_loopmgr_teardown(loopmgr, teardown_view, view);
- isc_loopmgr_teardown(loopmgr, teardown_requestmgr, requestmgr);
- isc_loopmgr_teardown(loopmgr, teardown_dispatchv4, dispatchv4);
- isc_loopmgr_teardown(loopmgr, teardown_dispatchmgr, dispatchmgr);
+ isc_loopmgr_setup(sendqueries, NULL);
+ isc_loopmgr_teardown(teardown_view, view);
+ isc_loopmgr_teardown(teardown_requestmgr, requestmgr);
+ isc_loopmgr_teardown(teardown_dispatchv4, dispatchv4);
+ isc_loopmgr_teardown(teardown_dispatchmgr, dispatchmgr);
- isc_loopmgr_run(loopmgr);
+ isc_loopmgr_run();
- isc_managers_destroy(&mctx, &loopmgr, &netmgr);
+ isc_managers_destroy(&mctx, &netmgr);
return 0;
}
"http-plain-get" };
static isc_mem_t *mctx = NULL;
-static isc_loopmgr_t *loopmgr = NULL;
static isc_nm_t *netmgr = NULL;
static protocol_t protocol;
static void
setup(void) {
- isc_managers_create(&mctx, workers, &loopmgr, &netmgr);
+ isc_managers_create(&mctx, workers, &netmgr);
}
static void
isc_tlsctx_free(&tls_ctx);
}
- isc_managers_destroy(&mctx, &loopmgr, &netmgr);
+ isc_managers_destroy(&mctx, &netmgr);
}
static void
static const char *protocols[] = { "udp", "tcp", "dot", "https", "http-plain" };
static isc_mem_t *mctx = NULL;
-static isc_loopmgr_t *loopmgr = NULL;
static isc_nm_t *netmgr = NULL;
static protocol_t protocol;
static void
setup(void) {
- isc_managers_create(&mctx, workers, &loopmgr, &netmgr);
+ isc_managers_create(&mctx, workers, &netmgr);
}
static void
isc_tlsctx_free(&tls_ctx);
}
- isc_managers_destroy(&mctx, &loopmgr, &netmgr);
+ isc_managers_destroy(&mctx, &netmgr);
}
static void
#define MAXTRIES 0xffffffff
static isc_mem_t *mctx = NULL;
-static isc_loopmgr_t *loopmgr = NULL;
static dns_requestmgr_t *requestmgr = NULL;
static const char *batchname = NULL;
static FILE *batchfp = NULL;
dns_request_destroy(&request);
if (--onfly == 0) {
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
return;
}
result = dns_request_create(
requestmgr, message, have_src ? &srcaddr : NULL, &dstaddr, NULL,
NULL, options, NULL, query->timeout, query->timeout,
- query->udptimeout, query->udpretries, isc_loop_main(loopmgr),
+ query->udptimeout, query->udpretries, isc_loop_main(),
recvresponse, message, &request);
CHECK("dns_request_create", result);
}
if (onfly == 0) {
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
}
static void
setup(void *arg ISC_ATTR_UNUSED) {
- RUNCHECK(dns_dispatchmgr_create(mctx, loopmgr, netmgr, &dispatchmgr));
+ RUNCHECK(dns_dispatchmgr_create(mctx, netmgr, &dispatchmgr));
set_source_ports(dispatchmgr);
dispatchmgr, have_src ? &srcaddr : &bind_any, &dispatchvx));
RUNCHECK(dns_requestmgr_create(
- mctx, loopmgr, dispatchmgr, have_ipv4 ? dispatchvx : NULL,
+ mctx, dispatchmgr, have_ipv4 ? dispatchvx : NULL,
have_ipv6 ? dispatchvx : NULL, &requestmgr));
- dns_view_create(mctx, loopmgr, NULL, 0, "_mdig", &view);
+ dns_view_create(mctx, NULL, 0, "_mdig", &view);
}
/*% Main processing routine for mdig */
preparse_args(argc, argv);
- isc_managers_create(&mctx, 1, &loopmgr, &netmgr);
+ isc_managers_create(&mctx, 1, &netmgr);
isc_nonce_buf(cookie_secret, sizeof(cookie_secret));
fatal("can't choose between IPv4 and IPv6");
}
- isc_loopmgr_setup(loopmgr, setup, NULL);
- isc_loopmgr_setup(loopmgr, sendqueries, ISC_LIST_HEAD(queries));
- isc_loopmgr_teardown(loopmgr, teardown, NULL);
+ isc_loopmgr_setup(setup, NULL);
+ isc_loopmgr_setup(sendqueries, ISC_LIST_HEAD(queries));
+ isc_loopmgr_teardown(teardown, NULL);
/*
* Stall to the start of a new second.
} while (1);
}
- isc_loopmgr_run(loopmgr);
+ isc_loopmgr_run();
ISC_LIST_FOREACH (queries, query, link) {
if (query->ednsopts != NULL) {
isc_mem_free(mctx, default_query.ecs_addr);
}
- isc_managers_destroy(&mctx, &loopmgr, &netmgr);
+ isc_managers_destroy(&mctx, &netmgr);
return 0;
}
This document aims to describe the design of the basic event loop handling in
the BIND 9.
-Every application is expected to create and use a single ``isc_loopmgr_t``
-instance.
+Every application is expected to run ``isc_loopmgr_create()``, either
+directly or indirectly via ``isc_managers_create()``. This creates a
+single loop manager.
## Event Loops
#define HMACSHA256 "\x0bhmac-sha256"
static isc_stdtime_t fuzztime = 0x622acce1;
-static isc_loopmgr_t *loopmgr = NULL;
static dns_view_t *view = NULL;
static dns_tsigkey_t *tsigkey = NULL;
static dns_tsigkeyring_t *ring = NULL;
isc_mem_create("fuzz", &mctx);
- isc_loopmgr_create(mctx, 1, &loopmgr);
+ isc_loopmgr_create(mctx, 1);
- dns_view_create(mctx, loopmgr, NULL, dns_rdataclass_in, "view", &view);
+ dns_view_create(mctx, NULL, dns_rdataclass_in, "view", &view);
dns_tsigkeyring_create(mctx, &ring);
dns_tsigkeyring_create(mctx, &emptyring);
struct dns_adb {
unsigned int magic;
uint32_t nloops;
- isc_loopmgr_t *loopmgr;
isc_mutex_t lock;
isc_mem_t *mctx;
*/
void
-dns_adb_create(isc_mem_t *mem, isc_loopmgr_t *loopmgr, dns_view_t *view,
- dns_adb_t **adbp) {
+dns_adb_create(isc_mem_t *mem, dns_view_t *view, dns_adb_t **adbp) {
REQUIRE(mem != NULL);
REQUIRE(view != NULL);
REQUIRE(adbp != NULL && *adbp == NULL);
- uint32_t nloops = isc_loopmgr_nloops(loopmgr);
+ uint32_t nloops = isc_loopmgr_nloops();
dns_adb_t *adb = isc_mem_get(mem, sizeof(dns_adb_t));
*adb = (dns_adb_t){
.references = 1,
.nloops = nloops,
- .loopmgr = loopmgr,
.magic = DNS_ADB_MAGIC,
};
* shutting down ADB.
*/
dns_adb_ref(adb);
- isc_async_run(isc_loop_main(adb->loopmgr), dns_adb_shutdown_async, adb);
+ isc_async_run(isc_loop_main(), dns_adb_shutdown_async, adb);
}
/*
bcentry_alive(struct cds_lfht *ht, dns_bcentry_t *bad, isc_stdtime_t now);
dns_badcache_t *
-dns_badcache_new(isc_mem_t *mctx, isc_loopmgr_t *loopmgr) {
- REQUIRE(loopmgr != NULL);
-
- uint32_t nloops = isc_loopmgr_nloops(loopmgr);
+dns_badcache_new(isc_mem_t *mctx) {
+ uint32_t nloops = isc_loopmgr_nloops();
dns_badcache_t *bc = isc_mem_get(mctx, sizeof(*bc));
*bc = (dns_badcache_t){
.magic = BADCACHE_MAGIC,
isc_mem_t *mctx; /* Memory context for the dns_cache object */
isc_mem_t *hmctx; /* Heap memory */
isc_mem_t *tmctx; /* Tree memory */
- isc_loopmgr_t *loopmgr;
char *name;
isc_refcount_t references;
* XXX this is only used by the RBT cache, and can
* be removed when it is.
*/
- dns_db_setloop(db, isc_loop_main(cache->loopmgr));
+ dns_db_setloop(db, isc_loop_main());
*dbp = db;
*hmctxp = hmctx;
}
isc_result_t
-dns_cache_create(isc_loopmgr_t *loopmgr, dns_rdataclass_t rdclass,
- const char *cachename, isc_mem_t *mctx, dns_cache_t **cachep) {
+dns_cache_create(dns_rdataclass_t rdclass, const char *cachename,
+ isc_mem_t *mctx, dns_cache_t **cachep) {
isc_result_t result;
dns_cache_t *cache = NULL;
- REQUIRE(loopmgr != NULL);
REQUIRE(cachename != NULL);
REQUIRE(cachep != NULL && *cachep == NULL);
*cache = (dns_cache_t){
.rdclass = rdclass,
.name = isc_mem_strdup(mctx, cachename),
- .loopmgr = loopmgr,
.references = ISC_REFCOUNT_INITIALIZER(1),
.magic = CACHE_MAGIC,
};
isc_refcount_t references;
isc_mutex_t lock;
dns_catz_zonemodmethods_t *zmm;
- isc_loopmgr_t *loopmgr;
dns_view_t *view;
atomic_bool shuttingdown;
};
}
dns_catz_zones_t *
-dns_catz_zones_new(isc_mem_t *mctx, isc_loopmgr_t *loopmgr,
- dns_catz_zonemodmethods_t *zmm) {
+dns_catz_zones_new(isc_mem_t *mctx, dns_catz_zonemodmethods_t *zmm) {
REQUIRE(mctx != NULL);
- REQUIRE(loopmgr != NULL);
REQUIRE(zmm != NULL);
dns_catz_zones_t *catzs = isc_mem_get(mctx, sizeof(*catzs));
- *catzs = (dns_catz_zones_t){ .loopmgr = loopmgr,
- .zmm = zmm,
- .magic = DNS_CATZ_ZONES_MAGIC };
+ *catzs = (dns_catz_zones_t){
+ .zmm = zmm,
+ .magic = DNS_CATZ_ZONES_MAGIC,
+ };
isc_mutex_init(&catzs->lock);
isc_refcount_init(&catzs->references, 1);
static isc_result_t
createview(isc_mem_t *mctx, dns_rdataclass_t rdclass, isc_nm_t *nm,
- isc_tlsctx_cache_t *tlsctx_client_cache, isc_loopmgr_t *loopmgr,
+ isc_tlsctx_cache_t *tlsctx_client_cache,
dns_dispatchmgr_t *dispatchmgr, dns_dispatch_t *dispatchv4,
dns_dispatch_t *dispatchv6, dns_view_t **viewp) {
isc_result_t result;
dns_view_t *view = NULL;
- dns_view_create(mctx, loopmgr, dispatchmgr, rdclass,
- DNS_CLIENTVIEW_NAME, &view);
+ dns_view_create(mctx, dispatchmgr, rdclass, DNS_CLIENTVIEW_NAME, &view);
/* Initialize view security roots */
dns_view_initsecroots(view);
}
isc_result_t
-dns_client_create(isc_mem_t *mctx, isc_loopmgr_t *loopmgr, isc_nm_t *nm,
- unsigned int options, isc_tlsctx_cache_t *tlsctx_client_cache,
+dns_client_create(isc_mem_t *mctx, isc_nm_t *nm, unsigned int options,
+ isc_tlsctx_cache_t *tlsctx_client_cache,
dns_client_t **clientp, const isc_sockaddr_t *localaddr4,
const isc_sockaddr_t *localaddr6) {
isc_result_t result;
client = isc_mem_get(mctx, sizeof(*client));
*client = (dns_client_t){
- .loop = isc_loop_get(loopmgr, 0),
+ .loop = isc_loop_get(0),
.nm = nm,
.max_restarts = DEF_MAX_RESTARTS,
.max_queries = DEF_MAX_QUERIES,
};
- result = dns_dispatchmgr_create(mctx, loopmgr, nm,
- &client->dispatchmgr);
+ result = dns_dispatchmgr_create(mctx, nm, &client->dispatchmgr);
if (result != ISC_R_SUCCESS) {
goto cleanup_client;
}
/* Create the default view for class IN */
result = createview(mctx, dns_rdataclass_in, nm, tlsctx_client_cache,
- isc_loop_getloopmgr(client->loop),
client->dispatchmgr, dispatchv4, dispatchv6, &view);
if (result != ISC_R_SUCCESS) {
goto cleanup_references;
*/
isc_result_t
-dns_dispatchmgr_create(isc_mem_t *mctx, isc_loopmgr_t *loopmgr, isc_nm_t *nm,
+dns_dispatchmgr_create(isc_mem_t *mctx, isc_nm_t *nm,
dns_dispatchmgr_t **mgrp) {
dns_dispatchmgr_t *mgr = NULL;
isc_portset_t *v4portset = NULL;
mgr = isc_mem_get(mctx, sizeof(dns_dispatchmgr_t));
*mgr = (dns_dispatchmgr_t){
.magic = 0,
- .nloops = isc_loopmgr_nloops(loopmgr),
+ .nloops = isc_loopmgr_nloops(),
};
#if DNS_DISPATCH_TRACE
struct fstrm_file_options *ffwopt = NULL;
struct fstrm_writer_options *fwopt = NULL;
struct fstrm_writer *fw = NULL;
- isc_loopmgr_t *loopmgr = NULL;
REQUIRE(VALID_DTENV(env));
- loopmgr = isc_loop_getloopmgr(env->loop);
- isc_loopmgr_pause(loopmgr);
+ isc_loopmgr_pause();
/*
* Check that we can create a new fw object.
fstrm_writer_options_destroy(&fwopt);
}
- isc_loopmgr_resume(loopmgr);
+ isc_loopmgr_resume();
return result;
}
void
dns_dyndb_createctx(isc_mem_t *mctx, const void *hashinit, dns_view_t *view,
- dns_zonemgr_t *zmgr, isc_loopmgr_t *loopmgr,
- dns_dyndbctx_t **dctxp) {
+ dns_zonemgr_t *zmgr, dns_dyndbctx_t **dctxp) {
dns_dyndbctx_t *dctx;
REQUIRE(dctxp != NULL && *dctxp == NULL);
dctx = isc_mem_get(mctx, sizeof(*dctx));
*dctx = (dns_dyndbctx_t){
- .loopmgr = loopmgr,
.hashinit = hashinit,
};
if (dctx->zmgr != NULL) {
dns_zonemgr_detach(&dctx->zmgr);
}
- dctx->loopmgr = NULL;
isc_mem_putanddetach(&dctx->mctx, dctx, sizeof(*dctx));
}
****/
void
-dns_adb_create(isc_mem_t *mem, isc_loopmgr_t *loopmgr, dns_view_t *view,
- dns_adb_t **newadb);
+dns_adb_create(isc_mem_t *mem, dns_view_t *view, dns_adb_t **newadb);
/*%<
* Create a new ADB.
*
***/
dns_badcache_t *
-dns_badcache_new(isc_mem_t *mctx, isc_loopmgr_t *loopmgr);
+dns_badcache_new(isc_mem_t *mctx);
/*%
* Allocate and initialize a badcache and store it in '*bcp'.
*
#endif
isc_result_t
-dns_cache_create(isc_loopmgr_t *loopmgr, dns_rdataclass_t rdclass,
- const char *cachename, isc_mem_t *mctx, dns_cache_t **cachep);
+dns_cache_create(dns_rdataclass_t rdclass, const char *cachename,
+ isc_mem_t *mctx, dns_cache_t **cachep);
/*%<
* Create a new DNS cache.
*
};
dns_catz_zones_t *
-dns_catz_zones_new(isc_mem_t *mctx, isc_loopmgr_t *loopmgr,
- dns_catz_zonemodmethods_t *zmm);
+dns_catz_zones_new(isc_mem_t *mctx, dns_catz_zonemodmethods_t *zmm);
/*%<
* Allocate a new catz_zones object, a collection storing all catalog zones
* for a view.
} dns_clientresume_t; /* too long? */
isc_result_t
-dns_client_create(isc_mem_t *mctx, isc_loopmgr_t *loopmgr, isc_nm_t *nm,
- unsigned int options, isc_tlsctx_cache_t *tlsctx_client_cache,
+dns_client_create(isc_mem_t *mctx, isc_nm_t *nm, unsigned int options,
+ isc_tlsctx_cache_t *tlsctx_client_cache,
dns_client_t **clientp, const isc_sockaddr_t *localaddr4,
const isc_sockaddr_t *localaddr6);
/*%<
} dns_dispatchopt_t;
isc_result_t
-dns_dispatchmgr_create(isc_mem_t *mctx, isc_loopmgr_t *loopmgr, isc_nm_t *nm,
- dns_dispatchmgr_t **mgrp);
+dns_dispatchmgr_create(isc_mem_t *mctx, isc_nm_t *nm, dns_dispatchmgr_t **mgrp);
/*%<
* Creates a new dispatchmgr object, and sets the available ports
* to the default range (1024-65535).
isc_mem_t *mctx;
dns_view_t *view;
dns_zonemgr_t *zmgr;
- isc_loopmgr_t *loopmgr;
const bool *refvar; /* unused, but retained for API compatibility */
};
void
dns_dyndb_createctx(isc_mem_t *mctx, const void *hashinit, dns_view_t *view,
- dns_zonemgr_t *zmgr, isc_loopmgr_t *loopmgr,
- dns_dyndbctx_t **dctxp);
+ dns_zonemgr_t *zmgr, dns_dyndbctx_t **dctxp);
/*%
* Create a dyndb initialization context structure, with
* pointers to structures in the server that the dyndb module will
#define VALID_NTATABLE(nt) ISC_MAGIC_VALID(nt, NTATABLE_MAGIC)
void
-dns_ntatable_create(dns_view_t *view, isc_loopmgr_t *loopmgr,
- dns_ntatable_t **ntatablep);
+dns_ntatable_create(dns_view_t *view, dns_ntatable_t **ntatablep);
/*%<
* Create an NTA table in view 'view'.
*
#define DNS_REQUESTOPT_LARGE 0x00000008U
isc_result_t
-dns_requestmgr_create(isc_mem_t *mctx, isc_loopmgr_t *loopmgr,
- dns_dispatchmgr_t *dispatchmgr,
+dns_requestmgr_create(isc_mem_t *mctx, dns_dispatchmgr_t *dispatchmgr,
dns_dispatch_t *dispatchv4, dns_dispatch_t *dispatchv6,
dns_requestmgr_t **requestmgrp);
/*%<
#define DNS_QMIN_MAX_NO_DELEGATION 3
isc_result_t
-dns_resolver_create(dns_view_t *view, isc_loopmgr_t *loopmgr, isc_nm_t *nm,
- unsigned int options, isc_tlsctx_cache_t *tlsctx_cache,
+dns_resolver_create(dns_view_t *view, isc_nm_t *nm, unsigned int options,
+ isc_tlsctx_cache_t *tlsctx_cache,
dns_dispatch_t *dispatchv4, dns_dispatch_t *dispatchv6,
dns_resolver_t **resp);
unsigned int magic;
isc_refcount_t references;
isc_mem_t *mctx;
- isc_loopmgr_t *loopmgr;
dns_rpz_popt_t p;
dns_rpz_zone_t *zones[DNS_RPZ_MAX_ZONES];
dns_name_t *selfname);
isc_result_t
-dns_rpz_new_zones(dns_view_t *view, isc_loopmgr_t *loopmgr,
- dns_rpz_zones_t **rpzsp);
+dns_rpz_new_zones(dns_view_t *view, dns_rpz_zones_t **rpzsp);
isc_result_t
dns_rpz_new_zone(dns_rpz_zones_t *rpzs, dns_rpz_zone_t **rpzp);
***/
dns_unreachcache_t *
-dns_unreachcache_new(isc_mem_t *mctx, isc_loopmgr_t *loopmgr,
- const uint16_t expire_min_s, const uint16_t expire_max_s,
+dns_unreachcache_new(isc_mem_t *mctx, const uint16_t expire_min_s,
+ const uint16_t expire_max_s,
const uint16_t backoff_eligible_s);
/*%
* Allocate and initialize an unreachable cache. A newly entered entry expires
#endif /* HAVE_LMDB */
void
-dns_view_create(isc_mem_t *mctx, isc_loopmgr_t *loopmgr,
- dns_dispatchmgr_t *dispmgr, dns_rdataclass_t rdclass,
- const char *name, dns_view_t **viewp);
+dns_view_create(isc_mem_t *mctx, dns_dispatchmgr_t *dispmgr,
+ dns_rdataclass_t rdclass, const char *name, dns_view_t **viewp);
/*%<
* Create a view.
*
*/
void
-dns_view_initntatable(dns_view_t *view, isc_loopmgr_t *loopmgr);
+dns_view_initntatable(dns_view_t *view);
/*%<
* Initialize the negative trust anchor table for the view.
*
* Requires:
* \li 'view' is valid.
- * \li 'loopmgr' is a valid loopmgr.
*/
isc_result_t
isc_mem_t *mctx;
dns_view_t *view;
isc_rwlock_t rwlock;
- isc_loopmgr_t *loopmgr;
isc_refcount_t references;
dns_qpmulti_t *table;
atomic_bool shuttingdown;
#endif
void
-dns_ntatable_create(dns_view_t *view, isc_loopmgr_t *loopmgr,
- dns_ntatable_t **ntatablep) {
+dns_ntatable_create(dns_view_t *view, dns_ntatable_t **ntatablep) {
dns_ntatable_t *ntatable = NULL;
REQUIRE(ntatablep != NULL && *ntatablep == NULL);
ntatable = isc_mem_get(view->mctx, sizeof(*ntatable));
*ntatable = (dns_ntatable_t){
- .loopmgr = loopmgr,
+ .mctx = isc_mem_ref(view->mctx),
};
- isc_mem_attach(view->mctx, &ntatable->mctx);
dns_view_weakattach(view, &ntatable->view);
isc_rwlock_init(&ntatable->rwlock);
struct qpcache {
/* Unlocked. */
dns_db_t common;
- /* Loopmgr */
- isc_loopmgr_t *loopmgr;
/* Locks the data in this struct */
isc_rwlock_t lock;
/* Locks the tree structure (prevents nodes appearing/disappearing) */
deadlink))
{
/* Queue was empty, trigger new cleaning */
- isc_loop_t *loop = isc_loop_get(qpdb->loopmgr,
- node->locknum);
+ isc_loop_t *loop = isc_loop_get(node->locknum);
qpcache_ref(qpdb);
isc_async_run(loop, cleanup_deadnodes_cb, qpdb);
isc_mem_t *hmctx = mctx;
isc_loop_t *loop = isc_loop();
int i;
- isc_loopmgr_t *loopmgr = isc_loop_getloopmgr(loop);
- size_t nloops = isc_loopmgr_nloops(loopmgr);
+ size_t nloops = isc_loopmgr_nloops();
/* This database implementation only supports cache semantics */
REQUIRE(type == dns_dbtype_cache);
.common.rdclass = rdclass,
.common.attributes = DNS_DBATTR_CACHE,
.common.references = 1,
- .loopmgr = isc_loop_getloopmgr(loop),
.references = 1,
.buckets_count = nloops,
};
isc_rwlock_init(&qpdb->lock);
TREE_INITLOCK(&qpdb->tree_lock);
- qpdb->buckets_count = isc_loopmgr_nloops(qpdb->loopmgr);
+ qpdb->buckets_count = isc_loopmgr_nloops();
dns_rdatasetstats_create(mctx, &qpdb->rrsetstats);
for (i = 0; i < (int)qpdb->buckets_count; i++) {
unsigned int magic;
isc_mem_t *mctx;
isc_refcount_t references;
- isc_loopmgr_t *loopmgr;
atomic_bool shuttingdown;
***/
isc_result_t
-dns_requestmgr_create(isc_mem_t *mctx, isc_loopmgr_t *loopmgr,
- dns_dispatchmgr_t *dispatchmgr,
+dns_requestmgr_create(isc_mem_t *mctx, dns_dispatchmgr_t *dispatchmgr,
dns_dispatch_t *dispatchv4, dns_dispatch_t *dispatchv6,
dns_requestmgr_t **requestmgrp) {
REQUIRE(requestmgrp != NULL && *requestmgrp == NULL);
dns_requestmgr_t *requestmgr = isc_mem_get(mctx, sizeof(*requestmgr));
*requestmgr = (dns_requestmgr_t){
.magic = REQUESTMGR_MAGIC,
- .loopmgr = loopmgr,
};
isc_mem_attach(mctx, &requestmgr->mctx);
- uint32_t nloops = isc_loopmgr_nloops(requestmgr->loopmgr);
+ uint32_t nloops = isc_loopmgr_nloops();
requestmgr->requests = isc_mem_cget(requestmgr->mctx, nloops,
sizeof(requestmgr->requests[0]));
for (size_t i = 0; i < nloops; i++) {
ISC_LIST_INIT(requestmgr->requests[i]);
/* unreferenced in requests_cancel() */
- isc_loop_ref(isc_loop_get(requestmgr->loopmgr, i));
+ isc_loop_ref(isc_loop_get(i));
}
dns_dispatchmgr_attach(dispatchmgr, &requestmgr->dispatchmgr);
if (dispatchv4 != NULL) {
dns_dispatchset_create(requestmgr->mctx, dispatchv4,
&requestmgr->dispatches4,
- isc_loopmgr_nloops(requestmgr->loopmgr));
+ isc_loopmgr_nloops());
}
if (dispatchv6 != NULL) {
dns_dispatchset_create(requestmgr->mctx, dispatchv6,
&requestmgr->dispatches6,
- isc_loopmgr_nloops(requestmgr->loopmgr));
+ isc_loopmgr_nloops());
}
isc_refcount_init(&requestmgr->references, 1);
req_sendevent(request, ISC_R_CANCELED);
}
- isc_loop_unref(isc_loop_get(requestmgr->loopmgr, tid));
+ isc_loop_unref(isc_loop_get(tid));
dns_requestmgr_detach(&requestmgr);
}
synchronize_rcu();
isc_tid_t tid = isc_tid();
- uint32_t nloops = isc_loopmgr_nloops(requestmgr->loopmgr);
+ uint32_t nloops = isc_loopmgr_nloops();
for (size_t i = 0; i < nloops; i++) {
dns_requestmgr_ref(requestmgr);
continue;
}
- isc_loop_t *loop = isc_loop_get(requestmgr->loopmgr, i);
+ isc_loop_t *loop = isc_loop_get(i);
isc_async_run(loop, requests_cancel, requestmgr);
}
}
INSIST(atomic_load(&requestmgr->shuttingdown));
- size_t nloops = isc_loopmgr_nloops(requestmgr->loopmgr);
+ size_t nloops = isc_loopmgr_nloops();
for (size_t i = 0; i < nloops; i++) {
INSIST(ISC_LIST_EMPTY(requestmgr->requests[i]));
}
isc_mutex_t lock;
isc_mutex_t primelock;
dns_rdataclass_t rdclass;
- isc_loopmgr_t *loopmgr;
isc_nm_t *nm;
dns_view_t *view;
bool frozen;
}
isc_result_t
-dns_resolver_create(dns_view_t *view, isc_loopmgr_t *loopmgr, isc_nm_t *nm,
- unsigned int options, isc_tlsctx_cache_t *tlsctx_cache,
+dns_resolver_create(dns_view_t *view, isc_nm_t *nm, unsigned int options,
+ isc_tlsctx_cache_t *tlsctx_cache,
dns_dispatch_t *dispatchv4, dns_dispatch_t *dispatchv6,
dns_resolver_t **resp) {
dns_resolver_t *res = NULL;
res = isc_mem_get(view->mctx, sizeof(*res));
*res = (dns_resolver_t){
- .loopmgr = loopmgr,
.rdclass = view->rdclass,
.nm = nm,
.options = options,
.maxdepth = DEFAULT_RECURSION_DEPTH,
.maxqueries = DEFAULT_MAX_QUERIES,
.alternates = ISC_LIST_INITIALIZER,
- .nloops = isc_loopmgr_nloops(loopmgr),
+ .nloops = isc_loopmgr_nloops(),
.maxvalidations = DEFAULT_MAX_VALIDATIONS,
.maxvalidationfails = DEFAULT_MAX_VALIDATION_FAILURES,
};
res->rdspools = isc_mem_cget(res->mctx, res->nloops,
sizeof(res->rdspools[0]));
for (size_t i = 0; i < res->nloops; i++) {
- isc_loop_t *loop = isc_loop_get(res->loopmgr, i);
+ isc_loop_t *loop = isc_loop_get(i);
isc_mem_t *pool_mctx = isc_loop_getmctx(loop);
dns_message_createpools(pool_mctx, &res->namepools[i],
isc_stats_attach(stats, &res->stats);
/* initialize the bucket "counter"; it's a static value */
- set_stats(res, dns_resstatscounter_buckets,
- isc_loopmgr_nloops(res->loopmgr));
+ set_stats(res, dns_resstatscounter_buckets, isc_loopmgr_nloops());
}
void
* Get ready for a new set of policy zones for a view.
*/
isc_result_t
-dns_rpz_new_zones(dns_view_t *view, isc_loopmgr_t *loopmgr,
- dns_rpz_zones_t **rpzsp) {
+dns_rpz_new_zones(dns_view_t *view, dns_rpz_zones_t **rpzsp) {
dns_rpz_zones_t *rpzs = NULL;
isc_mem_t *mctx = NULL;
rpzs = isc_mem_get(mctx, sizeof(*rpzs));
*rpzs = (dns_rpz_zones_t){
- .loopmgr = loopmgr,
.magic = DNS_RPZ_ZONES_MAGIC,
};
bool alive_or_waiting);
dns_unreachcache_t *
-dns_unreachcache_new(isc_mem_t *mctx, isc_loopmgr_t *loopmgr,
- const uint16_t expire_min_s, const uint16_t expire_max_s,
+dns_unreachcache_new(isc_mem_t *mctx, const uint16_t expire_min_s,
+ const uint16_t expire_max_s,
const uint16_t backoff_eligible_s) {
- REQUIRE(loopmgr != NULL);
REQUIRE(expire_min_s > 0);
REQUIRE(expire_min_s <= expire_max_s);
- uint32_t nloops = isc_loopmgr_nloops(loopmgr);
+ uint32_t nloops = isc_loopmgr_nloops();
dns_unreachcache_t *uc = isc_mem_get(mctx, sizeof(*uc));
*uc = (dns_unreachcache_t){
.magic = UNREACHCACHE_MAGIC,
#include <lmdb.h>
#endif /* ifdef HAVE_LMDB */
+#include <isc/async.h>
#include <isc/atomic.h>
#include <isc/dir.h>
#include <isc/file.h>
#define UNREACH_BACKOFF_ELIGIBLE_SEC ((uint16_t)120)
void
-dns_view_create(isc_mem_t *mctx, isc_loopmgr_t *loopmgr,
- dns_dispatchmgr_t *dispatchmgr, dns_rdataclass_t rdclass,
- const char *name, dns_view_t **viewp) {
+dns_view_create(isc_mem_t *mctx, dns_dispatchmgr_t *dispatchmgr,
+ dns_rdataclass_t rdclass, const char *name,
+ dns_view_t **viewp) {
dns_view_t *view = NULL;
isc_result_t result;
char buffer[1024];
dns_tsigkeyring_create(view->mctx, &view->dynamickeys);
- view->failcache = dns_badcache_new(view->mctx, loopmgr);
+ view->failcache = dns_badcache_new(view->mctx);
view->unreachcache = dns_unreachcache_new(
- view->mctx, loopmgr, UNREACH_HOLD_TIME_INITIAL_SEC,
+ view->mctx, UNREACH_HOLD_TIME_INITIAL_SEC,
UNREACH_HOLD_TIME_MAX_SEC, UNREACH_BACKOFF_ELIGIBLE_SEC);
isc_mutex_init(&view->new_zone_lock);
*targetp = source;
}
-void
-dns_view_detach(dns_view_t **viewp) {
- dns_view_t *view = NULL;
+static void
+shutdown_view(dns_view_t *view) {
+ dns_zone_t *mkzone = NULL, *rdzone = NULL;
+ dns_zt_t *zonetable = NULL;
+ dns_resolver_t *resolver = NULL;
+ dns_adb_t *adb = NULL;
+ dns_requestmgr_t *requestmgr = NULL;
+ dns_dispatchmgr_t *dispatchmgr = NULL;
- REQUIRE(viewp != NULL && DNS_VIEW_VALID(*viewp));
+ isc_refcount_destroy(&view->references);
- view = *viewp;
- *viewp = NULL;
+ /* Shutdown the attached objects first */
+ if (view->resolver != NULL) {
+ dns_resolver_shutdown(view->resolver);
+ }
- if (isc_refcount_decrement(&view->references) == 1) {
- dns_zone_t *mkzone = NULL, *rdzone = NULL;
- dns_zt_t *zonetable = NULL;
- dns_resolver_t *resolver = NULL;
- dns_adb_t *adb = NULL;
- dns_requestmgr_t *requestmgr = NULL;
- dns_dispatchmgr_t *dispatchmgr = NULL;
+ rcu_read_lock();
+ adb = rcu_dereference(view->adb);
+ if (adb != NULL) {
+ dns_adb_shutdown(adb);
+ }
+ rcu_read_unlock();
- isc_refcount_destroy(&view->references);
+ if (view->requestmgr != NULL) {
+ dns_requestmgr_shutdown(view->requestmgr);
+ }
- /* Shutdown the attached objects first */
- if (view->resolver != NULL) {
- dns_resolver_shutdown(view->resolver);
- }
+ /* Swap the pointers under the lock */
+ LOCK(&view->lock);
- rcu_read_lock();
- adb = rcu_dereference(view->adb);
- if (adb != NULL) {
- dns_adb_shutdown(adb);
+ if (view->resolver != NULL) {
+ resolver = view->resolver;
+ view->resolver = NULL;
+ }
+
+ rcu_read_lock();
+ zonetable = rcu_xchg_pointer(&view->zonetable, NULL);
+ if (zonetable != NULL) {
+ if (view->flush) {
+ dns_zt_flush(zonetable);
}
- rcu_read_unlock();
+ }
+ adb = rcu_xchg_pointer(&view->adb, NULL);
+ dispatchmgr = rcu_xchg_pointer(&view->dispatchmgr, NULL);
+ rcu_read_unlock();
- if (view->requestmgr != NULL) {
- dns_requestmgr_shutdown(view->requestmgr);
+ if (view->requestmgr != NULL) {
+ requestmgr = view->requestmgr;
+ view->requestmgr = NULL;
+ }
+ if (view->managed_keys != NULL) {
+ mkzone = view->managed_keys;
+ view->managed_keys = NULL;
+ if (view->flush) {
+ dns_zone_flush(mkzone);
+ }
+ }
+ if (view->redirect != NULL) {
+ rdzone = view->redirect;
+ view->redirect = NULL;
+ if (view->flush) {
+ dns_zone_flush(rdzone);
}
+ }
+ if (view->catzs != NULL) {
+ dns_catz_zones_shutdown(view->catzs);
+ dns_catz_zones_detach(&view->catzs);
+ }
+ if (view->ntatable_priv != NULL) {
+ dns_ntatable_shutdown(view->ntatable_priv);
+ }
+ UNLOCK(&view->lock);
- /* Swap the pointers under the lock */
- LOCK(&view->lock);
+ /* Detach outside view lock */
+ if (resolver != NULL) {
+ dns_resolver_detach(&resolver);
+ }
- if (view->resolver != NULL) {
- resolver = view->resolver;
- view->resolver = NULL;
- }
+ synchronize_rcu();
+ if (dispatchmgr != NULL) {
+ dns_dispatchmgr_detach(&dispatchmgr);
+ }
+ if (adb != NULL) {
+ dns_adb_detach(&adb);
+ }
+ if (zonetable != NULL) {
+ dns_zt_detach(&zonetable);
+ }
+ if (requestmgr != NULL) {
+ dns_requestmgr_detach(&requestmgr);
+ }
+ if (mkzone != NULL) {
+ dns_zone_detach(&mkzone);
+ }
+ if (rdzone != NULL) {
+ dns_zone_detach(&rdzone);
+ }
- rcu_read_lock();
- zonetable = rcu_xchg_pointer(&view->zonetable, NULL);
- if (zonetable != NULL) {
- if (view->flush) {
- dns_zt_flush(zonetable);
- }
- }
- adb = rcu_xchg_pointer(&view->adb, NULL);
- dispatchmgr = rcu_xchg_pointer(&view->dispatchmgr, NULL);
- rcu_read_unlock();
+ dns_view_weakdetach(&view);
+}
- if (view->requestmgr != NULL) {
- requestmgr = view->requestmgr;
- view->requestmgr = NULL;
- }
- if (view->managed_keys != NULL) {
- mkzone = view->managed_keys;
- view->managed_keys = NULL;
- if (view->flush) {
- dns_zone_flush(mkzone);
- }
- }
- if (view->redirect != NULL) {
- rdzone = view->redirect;
- view->redirect = NULL;
- if (view->flush) {
- dns_zone_flush(rdzone);
- }
- }
- if (view->catzs != NULL) {
- dns_catz_zones_shutdown(view->catzs);
- dns_catz_zones_detach(&view->catzs);
- }
- if (view->ntatable_priv != NULL) {
- dns_ntatable_shutdown(view->ntatable_priv);
- }
- UNLOCK(&view->lock);
+void
+dns_view_detach(dns_view_t **viewp) {
+ dns_view_t *view = NULL;
- /* Detach outside view lock */
- if (resolver != NULL) {
- dns_resolver_detach(&resolver);
- }
- synchronize_rcu();
- if (dispatchmgr != NULL) {
- dns_dispatchmgr_detach(&dispatchmgr);
- }
- if (adb != NULL) {
- dns_adb_detach(&adb);
- }
- if (zonetable != NULL) {
- dns_zt_detach(&zonetable);
- }
- if (requestmgr != NULL) {
- dns_requestmgr_detach(&requestmgr);
- }
- if (mkzone != NULL) {
- dns_zone_detach(&mkzone);
- }
- if (rdzone != NULL) {
- dns_zone_detach(&rdzone);
- }
+ REQUIRE(viewp != NULL && DNS_VIEW_VALID(*viewp));
- dns_view_weakdetach(&view);
+ view = *viewp;
+ *viewp = NULL;
+
+ if (isc_refcount_decrement(&view->references) == 1) {
+ shutdown_view(view);
}
}
dns_dispatch_t *dispatchv6) {
isc_result_t result;
isc_mem_t *mctx = NULL;
- isc_loopmgr_t *loopmgr = isc_loop_getloopmgr(isc_loop());
REQUIRE(DNS_VIEW_VALID(view));
REQUIRE(!view->frozen);
REQUIRE(view->resolver == NULL);
REQUIRE(view->dispatchmgr != NULL);
- result = dns_resolver_create(view, loopmgr, netmgr, options,
- tlsctx_cache, dispatchv4, dispatchv6,
- &view->resolver);
+ result = dns_resolver_create(view, netmgr, options, tlsctx_cache,
+ dispatchv4, dispatchv6, &view->resolver);
if (result != ISC_R_SUCCESS) {
return result;
}
isc_mem_create("ADB", &mctx);
- dns_adb_create(mctx, loopmgr, view, &view->adb);
+ dns_adb_create(mctx, view, &view->adb);
isc_mem_detach(&mctx);
- result = dns_requestmgr_create(view->mctx, loopmgr, view->dispatchmgr,
+ result = dns_requestmgr_create(view->mctx, view->dispatchmgr,
dispatchv4, dispatchv6,
&view->requestmgr);
if (result != ISC_R_SUCCESS) {
}
void
-dns_view_initntatable(dns_view_t *view, isc_loopmgr_t *loopmgr) {
+dns_view_initntatable(dns_view_t *view) {
REQUIRE(DNS_VIEW_VALID(view));
if (view->ntatable_priv != NULL) {
dns_ntatable_detach(&view->ntatable_priv);
}
- dns_ntatable_create(view, loopmgr, &view->ntatable_priv);
+ dns_ntatable_create(view, &view->ntatable_priv);
}
isc_result_t
unsigned int magic;
isc_mem_t *mctx;
isc_refcount_t refs;
- isc_loopmgr_t *loopmgr;
isc_nm_t *netmgr;
uint32_t workers;
isc_mem_t **mctxpool;
dns_zonemgr_create(isc_mem_t *mctx, isc_nm_t *netmgr, dns_zonemgr_t **zmgrp) {
dns_zonemgr_t *zmgr = NULL;
isc_loop_t *loop = isc_loop();
- isc_loopmgr_t *loopmgr = isc_loop_getloopmgr(loop);
REQUIRE(mctx != NULL);
REQUIRE(netmgr != NULL);
zmgr = isc_mem_get(mctx, sizeof(*zmgr));
*zmgr = (dns_zonemgr_t){
- .loopmgr = loopmgr,
.netmgr = netmgr,
- .workers = isc_loopmgr_nloops(loopmgr),
+ .workers = isc_loopmgr_nloops(),
.transfersin = 10,
.transfersperns = 2,
};
REQUIRE(zone->timer == NULL);
REQUIRE(zone->zmgr == NULL);
- isc_loop_t *loop = isc_loop_get(zmgr->loopmgr, zone->tid);
+ isc_loop_t *loop = isc_loop_get(zone->tid);
isc_loop_attach(loop, &zone->loop);
zonemgr_keymgmt_add(zmgr, zone, &zone->kfio);
REQUIRE(VALID_LOOP(loop));
REQUIRE(cb != NULL);
- isc_loop_t *helper = &loop->loopmgr->helpers[loop->tid];
-
+ isc_loop_t *helper = isc_loop_helper(loop);
isc_job_t *job = isc_mem_get(helper->mctx, sizeof(*job));
*job = (isc_job_t){
.cb = cb,
#include <inttypes.h>
+#include <urcu/compiler.h>
+#include <urcu/system.h>
+
#include <isc/job.h>
#include <isc/mem.h>
#include <isc/refcount.h>
isc_loop(void) {
return isc__loop_local;
}
+
void
-isc_loopmgr_create(isc_mem_t *mctx, uint32_t nloops, isc_loopmgr_t **loopmgrp);
+isc_loopmgr_create(isc_mem_t *mctx, uint32_t nloops);
/*%<
* Create a loop manager supporting 'nloops' loops.
*
*/
void
-isc_loopmgr_destroy(isc_loopmgr_t **loopmgrp);
+isc_loopmgr_destroy(void);
/*%<
- * Destroy the loop manager pointed to by 'loopmgrp'.
- *
- * Requires:
- *\li 'loopmgr' points to a valid loop manager.
+ * Destroy the loop manager.
*/
void
-isc_loopmgr_shutdown(isc_loopmgr_t *loopmgr);
+isc_loopmgr_shutdown(void);
/*%<
- * Request shutdown of the loop manager 'loopmgr'.
+ * Request shutdown of the loop manager.
*
* This will stop all signal handlers and send shutdown events to
* all active loops. As a final action on shutting down, each loop
* will run the function (or functions) set by isc_loopmgr_teardown()
* or isc_loop_teardown().
- *
- * Requires:
- *\li 'loopmgr' is a valid loop manager.
*/
void
-isc_loopmgr_run(isc_loopmgr_t *loopmgr);
+isc_loopmgr_run(void);
/*%<
- * Run the loops in 'loopmgr'. Each loop will start by running the
+ * Run the loops in loop manager. Each loop will start by running the
* function (or functions) set by isc_loopmgr_setup() or isc_loop_setup().
- *
- * Requires:
- *\li 'loopmgr' is a valid loop manager.
*/
void
-isc_loopmgr_pause(isc_loopmgr_t *loopmgr);
+isc_loopmgr_pause(void);
/*%<
- * Send pause events to all running loops in 'loopmgr' except the
+ * Send pause events to all running loops in loop manager except the
* current one. This can only be called from a running loop.
* All the paused loops will wait until isc_loopmgr_resume() is
* run in the calling loop before continuing.
*
* Requires:
- *\li 'loopmgr' is a valid loop manager.
+ *\li We are in a running loop.
+ */
+
+bool
+isc_loopmgr_paused(void);
+/*%<
+ * Returns true if the loopmgr has been paused and not yet resumed.
+ *
+ * Requires:
*\li We are in a running loop.
*/
void
-isc_loopmgr_resume(isc_loopmgr_t *loopmgr);
+isc_loopmgr_resume(void);
/*%<
- * Send resume events to all paused loops in 'loopmgr'. This can
+ * Send resume events to all paused loops in loop manager. This can
* only be called by a running loop (which must therefore be the
* loop that called isc_loopmgr_pause()).
*
* Requires:
- *\li 'loopmgr' is a valid loop manager.
*\li We are in a running loop.
*/
uint32_t
-isc_loopmgr_nloops(isc_loopmgr_t *loopmgr);
+isc_loopmgr_nloops(void);
isc_job_t *
isc_loop_setup(isc_loop_t *loop, isc_job_cb cb, void *cbarg);
*/
void
-isc_loopmgr_setup(isc_loopmgr_t *loopmgr, isc_job_cb cb, void *cbarg);
+isc_loopmgr_setup(isc_job_cb cb, void *cbarg);
void
-isc_loopmgr_teardown(isc_loopmgr_t *loopmgr, isc_job_cb cb, void *cbarg);
+isc_loopmgr_teardown(isc_job_cb cb, void *cbarg);
/*%<
* Schedule actions to be run when starting, and when shutting down,
* *all* of the loops in loopmgr.
* isc_loop_teardown() on each of the loops in turn.
*
* Requires:
- *\li 'loopmgr' is a valid loop manager.
- *\li 'loopmgr' is paused or has not yet been started.
+ *\li loopmgr is paused or has not yet been started.
*/
isc_mem_t *
*/
isc_loop_t *
-isc_loop_main(isc_loopmgr_t *loopmgr);
+isc_loop_main(void);
/*%<
- * Returns the main loop for the 'loopmgr' (which is 'loopmgr->loops[0]',
+ * Returns the main loop for the loop manager (which is 'loops[0]',
* regardless of how many loops there are).
- *
- * Requires:
- *\li 'loopmgr' is a valid loop manager.
*/
isc_loop_t *
-isc_loop_get(isc_loopmgr_t *loopmgr, isc_tid_t tid);
+isc_loop_get(isc_tid_t tid);
/*%<
* Return the loop object associated with the 'tid' threadid
*
* Requires:
- *\li 'loopmgr' is a valid loop manager.
*\li 'tid' is smaller than number of initialized loops
*/
-#
-
#if ISC_LOOP_TRACE
#define isc_loop_ref(ptr) isc_loop__ref(ptr, __func__, __FILE__, __LINE__)
#define isc_loop_unref(ptr) isc_loop__unref(ptr, __func__, __FILE__, __LINE__)
*/
void
-isc_loopmgr_blocking(isc_loopmgr_t *loopmgr);
+isc_loopmgr_blocking(void);
void
-isc_loopmgr_nonblocking(isc_loopmgr_t *loopmgr);
+isc_loopmgr_nonblocking(void);
/*%<
* isc_loopmgr_blocking() stops the SIGINT and SIGTERM signal handlers
* during blocking operations, for example while waiting for user
* interaction; isc_loopmgr_nonblocking() restarts them.
- *
- * Requires:
- *\li 'loopmgr' is a valid loop manager.
- */
-
-isc_loopmgr_t *
-isc_loop_getloopmgr(isc_loop_t *loop);
-/*%<
- * Return the loopmgr associated with 'loop'.
- *
- * Requires:
- *\li 'loop' is a valid loop.
*/
isc_time_t
*
* \li 'loop' is a valid loop and the loop tid matches the current tid.
*/
+
+isc_loop_t *
+isc_loop_helper(isc_loop_t *loop);
+/*%<
+ * Returns the helper thread corresponding to the thread ID for 'loop'.
+ *
+ * Requires:
+ *
+ * \li 'loop' is a valid loop.
+ */
#pragma once
-#include <isc/loop.h>
#include <isc/netmgr.h>
#include <isc/result.h>
#include <isc/timer.h>
typedef struct isc_managers isc_managers_t;
void
-isc_managers_create(isc_mem_t **mctx, uint32_t workers,
- isc_loopmgr_t **loopmgrp, isc_nm_t **netmgrp);
+isc_managers_create(isc_mem_t **mctx, uint32_t workers, isc_nm_t **netmgrp);
void
-isc_managers_destroy(isc_mem_t **mctx, isc_loopmgr_t **loopmgrp,
- isc_nm_t **netmgrp);
+isc_managers_destroy(isc_mem_t **mctx, isc_nm_t **netmgrp);
*/
void
-isc_netmgr_create(isc_mem_t *mctx, isc_loopmgr_t *loopmgr, isc_nm_t **netgmrp);
+isc_netmgr_create(isc_mem_t *mctx, isc_nm_t **netgmrp);
/*%<
* Creates a new network manager and starts it running when loopmgr is started.
*/
typedef void (*isc_signal_cb)(void *, int);
isc_signal_t *
-isc_signal_new(isc_loopmgr_t *loopmgr, isc_signal_cb cb, void *cbarg,
- int signum);
+isc_signal_new(isc_signal_cb cb, void *cbarg, int signum);
/*%<
* Create a new signal handler for loop manager 'loopmgr', handling
* the signal value 'signum'.
typedef struct isc_interfaceiter isc_interfaceiter_t; /*%< Interface Iterator */
typedef struct isc_lex isc_lex_t; /*%< Lex */
typedef struct isc_loop isc_loop_t; /*%< Event loop */
-typedef struct isc_loopmgr isc_loopmgr_t; /*%< Event loop manager */
typedef struct isc_mem isc_mem_t; /*%< Memory */
typedef struct isc_mempool isc_mempool_t; /*%< Memory Pool */
typedef struct isc_netaddr isc_netaddr_t; /*%< Net Address */
#include <sys/types.h>
#include <unistd.h>
+#include <urcu/system.h>
+
#include <isc/async.h>
#include <isc/atomic.h>
#include <isc/barrier.h>
*/
thread_local isc_loop_t *isc__loop_local = NULL;
+isc_loopmgr_t *isc__loopmgr = NULL;
static void
ignore_signal(int sig, void (*handler)(int)) {
}
void
-isc_loopmgr_shutdown(isc_loopmgr_t *loopmgr) {
+isc_loopmgr_shutdown(void) {
+ isc_loopmgr_t *loopmgr = isc__loopmgr;
if (!atomic_compare_exchange_strong(&loopmgr->shuttingdown,
&(bool){ false }, true))
{
}
static void
-isc__loopmgr_signal(void *arg, int signum) {
- isc_loopmgr_t *loopmgr = (isc_loopmgr_t *)arg;
-
+isc__loopmgr_signal(void *arg ISC_ATTR_UNUSED, int signum) {
switch (signum) {
case SIGINT:
case SIGTERM:
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
break;
default:
UNREACHABLE();
static void
pause_loop(isc_loop_t *loop) {
- isc_loopmgr_t *loopmgr = loop->loopmgr;
+ isc_loopmgr_t *loopmgr = isc__loopmgr;
rcu_thread_offline();
static void
resume_loop(isc_loop_t *loop) {
- isc_loopmgr_t *loopmgr = loop->loopmgr;
+ isc_loopmgr_t *loopmgr = isc__loopmgr;
(void)isc_barrier_wait(&loopmgr->resuming);
loop->paused = false;
static void
shutdown_cb(uv_async_t *handle) {
isc_loop_t *loop = uv_handle_get_data(handle);
- isc_loopmgr_t *loopmgr = loop->loopmgr;
+ isc_loopmgr_t *loopmgr = isc__loopmgr;
/* Make sure, we can't be called again */
uv_close(&loop->shutdown_trigger, shutdown_trigger_close_cb);
}
static void
-loop_init(isc_loop_t *loop, isc_loopmgr_t *loopmgr, isc_tid_t tid,
- const char *kind) {
+loop_init(isc_loop_t *loop, isc_tid_t tid, const char *kind) {
*loop = (isc_loop_t){
.tid = tid,
- .loopmgr = loopmgr,
.run_jobs = ISC_LIST_INITIALIZER,
};
int r = uv_prepare_start(&helper->quiescent, quiescent_cb);
UV_RUNTIME_CHECK(uv_prepare_start, r);
- isc_barrier_wait(&helper->loopmgr->starting);
+ isc_barrier_wait(&isc__loopmgr->starting);
r = uv_run(&helper->loop, UV_RUN_DEFAULT);
UV_RUNTIME_CHECK(uv_run, r);
/* Invalidate the helper early */
helper->magic = 0;
- isc_barrier_wait(&helper->loopmgr->stopping);
+ isc_barrier_wait(&isc__loopmgr->stopping);
return NULL;
}
static void *
loop_thread(void *arg) {
isc_loop_t *loop = (isc_loop_t *)arg;
- isc_loopmgr_t *loopmgr = loop->loopmgr;
+ isc_loopmgr_t *loopmgr = isc__loopmgr;
isc_loop_t *helper = &loopmgr->helpers[loop->tid];
char name[32];
/* Initialize the thread_local variables*/
#endif
void
-isc_loopmgr_create(isc_mem_t *mctx, uint32_t nloops, isc_loopmgr_t **loopmgrp) {
- isc_loopmgr_t *loopmgr = NULL;
-
- REQUIRE(loopmgrp != NULL && *loopmgrp == NULL);
+isc_loopmgr_create(isc_mem_t *mctx, uint32_t nloops) {
+ REQUIRE(isc__loopmgr == NULL);
REQUIRE(nloops > 0);
+ isc_loopmgr_t *loopmgr = NULL;
+
threadpool_initialize(nloops);
isc__tid_initcount(nloops);
loopmgr = isc_mem_get(mctx, sizeof(*loopmgr));
*loopmgr = (isc_loopmgr_t){
.nloops = nloops,
+ .magic = LOOPMGR_MAGIC,
};
isc_mem_attach(mctx, &loopmgr->mctx);
sizeof(loopmgr->loops[0]));
for (size_t i = 0; i < loopmgr->nloops; i++) {
isc_loop_t *loop = &loopmgr->loops[i];
- loop_init(loop, loopmgr, i, "loop");
+ loop_init(loop, i, "loop");
}
loopmgr->helpers = isc_mem_cget(loopmgr->mctx, loopmgr->nloops,
sizeof(loopmgr->helpers[0]));
for (size_t i = 0; i < loopmgr->nloops; i++) {
isc_loop_t *loop = &loopmgr->helpers[i];
- loop_init(loop, loopmgr, i, "helper");
+ loop_init(loop, i, "helper");
}
- loopmgr->sigint = isc_signal_new(loopmgr, isc__loopmgr_signal, loopmgr,
- SIGINT);
- loopmgr->sigterm = isc_signal_new(loopmgr, isc__loopmgr_signal, loopmgr,
+ isc__loopmgr = loopmgr;
+
+ loopmgr->sigint = isc_signal_new(isc__loopmgr_signal, loopmgr, SIGINT);
+ loopmgr->sigterm = isc_signal_new(isc__loopmgr_signal, loopmgr,
SIGTERM);
isc_signal_start(loopmgr->sigint);
isc_signal_start(loopmgr->sigterm);
-
- loopmgr->magic = LOOPMGR_MAGIC;
-
- *loopmgrp = loopmgr;
}
isc_job_t *
REQUIRE(VALID_LOOP(loop));
REQUIRE(cb != NULL);
- isc_loopmgr_t *loopmgr = loop->loopmgr;
+ isc_loopmgr_t *loopmgr = isc__loopmgr;
isc_job_t *job = isc_mem_get(loop->mctx, sizeof(*job));
*job = (isc_job_t){
.cb = cb,
isc_loop_teardown(isc_loop_t *loop, isc_job_cb cb, void *cbarg) {
REQUIRE(VALID_LOOP(loop));
- isc_loopmgr_t *loopmgr = loop->loopmgr;
+ isc_loopmgr_t *loopmgr = isc__loopmgr;
isc_job_t *job = isc_mem_get(loop->mctx, sizeof(*job));
*job = (isc_job_t){
.cb = cb,
}
void
-isc_loopmgr_setup(isc_loopmgr_t *loopmgr, isc_job_cb cb, void *cbarg) {
- REQUIRE(VALID_LOOPMGR(loopmgr));
- REQUIRE(!atomic_load(&loopmgr->running) ||
- atomic_load(&loopmgr->paused));
+isc_loopmgr_setup(isc_job_cb cb, void *cbarg) {
+ REQUIRE(VALID_LOOPMGR(isc__loopmgr));
+ REQUIRE(!atomic_load(&isc__loopmgr->running) ||
+ atomic_load(&isc__loopmgr->paused));
- for (size_t i = 0; i < loopmgr->nloops; i++) {
- isc_loop_t *loop = &loopmgr->loops[i];
+ for (size_t i = 0; i < isc__loopmgr->nloops; i++) {
+ isc_loop_t *loop = &isc__loopmgr->loops[i];
(void)isc_loop_setup(loop, cb, cbarg);
}
}
void
-isc_loopmgr_teardown(isc_loopmgr_t *loopmgr, isc_job_cb cb, void *cbarg) {
- REQUIRE(VALID_LOOPMGR(loopmgr));
- REQUIRE(!atomic_load(&loopmgr->running) ||
- atomic_load(&loopmgr->paused));
+isc_loopmgr_teardown(isc_job_cb cb, void *cbarg) {
+ REQUIRE(VALID_LOOPMGR(isc__loopmgr));
+ REQUIRE(!atomic_load(&isc__loopmgr->running) ||
+ atomic_load(&isc__loopmgr->paused));
- for (size_t i = 0; i < loopmgr->nloops; i++) {
- isc_loop_t *loop = &loopmgr->loops[i];
+ for (size_t i = 0; i < isc__loopmgr->nloops; i++) {
+ isc_loop_t *loop = &isc__loopmgr->loops[i];
(void)isc_loop_teardown(loop, cb, cbarg);
}
}
void
-isc_loopmgr_run(isc_loopmgr_t *loopmgr) {
- REQUIRE(VALID_LOOPMGR(loopmgr));
- RUNTIME_CHECK(atomic_compare_exchange_strong(&loopmgr->running,
+isc_loopmgr_run(void) {
+ REQUIRE(VALID_LOOPMGR(isc__loopmgr));
+ RUNTIME_CHECK(atomic_compare_exchange_strong(&isc__loopmgr->running,
&(bool){ false }, true));
/*
/*
* The thread 0 is this one.
*/
- for (size_t i = 1; i < loopmgr->nloops; i++) {
+ for (size_t i = 1; i < isc__loopmgr->nloops; i++) {
char name[32];
- isc_loop_t *loop = &loopmgr->loops[i];
+ isc_loop_t *loop = &isc__loopmgr->loops[i];
isc_thread_create(loop_thread, loop, &loop->thread);
isc_thread_setname(loop->thread, name);
}
- isc_thread_main(loop_thread, &loopmgr->loops[0]);
+ isc_thread_main(loop_thread, &isc__loopmgr->loops[0]);
}
void
-isc_loopmgr_pause(isc_loopmgr_t *loopmgr) {
- REQUIRE(VALID_LOOPMGR(loopmgr));
+isc_loopmgr_pause(void) {
+ REQUIRE(VALID_LOOPMGR(isc__loopmgr));
REQUIRE(isc_tid() != ISC_TID_UNKNOWN);
if (isc_log_wouldlog(ISC_LOG_DEBUG(1))) {
"loop exclusive mode: starting");
}
- for (size_t i = 0; i < loopmgr->nloops; i++) {
- isc_loop_t *helper = &loopmgr->helpers[i];
+ for (size_t i = 0; i < isc__loopmgr->nloops; i++) {
+ isc_loop_t *helper = &isc__loopmgr->helpers[i];
int r = uv_async_send(&helper->pause_trigger);
UV_RUNTIME_CHECK(uv_async_send, r);
}
- for (size_t i = 0; i < loopmgr->nloops; i++) {
- isc_loop_t *loop = &loopmgr->loops[i];
+ for (size_t i = 0; i < isc__loopmgr->nloops; i++) {
+ isc_loop_t *loop = &isc__loopmgr->loops[i];
/* Skip current loop */
if (i == (size_t)isc_tid()) {
UV_RUNTIME_CHECK(uv_async_send, r);
}
- RUNTIME_CHECK(atomic_compare_exchange_strong(&loopmgr->paused,
+ RUNTIME_CHECK(atomic_compare_exchange_strong(&isc__loopmgr->paused,
&(bool){ false }, true));
- pause_loop(CURRENT_LOOP(loopmgr));
+ pause_loop(CURRENT_LOOP(isc__loopmgr));
if (isc_log_wouldlog(ISC_LOG_DEBUG(1))) {
isc_log_write(ISC_LOGCATEGORY_GENERAL, ISC_LOGMODULE_OTHER,
}
void
-isc_loopmgr_resume(isc_loopmgr_t *loopmgr) {
- REQUIRE(VALID_LOOPMGR(loopmgr));
+isc_loopmgr_resume(void) {
+ REQUIRE(VALID_LOOPMGR(isc__loopmgr));
if (isc_log_wouldlog(ISC_LOG_DEBUG(1))) {
isc_log_write(ISC_LOGCATEGORY_GENERAL, ISC_LOGMODULE_OTHER,
ISC_LOG_DEBUG(1), "loop exclusive mode: ending");
}
- RUNTIME_CHECK(atomic_compare_exchange_strong(&loopmgr->paused,
+ RUNTIME_CHECK(atomic_compare_exchange_strong(&isc__loopmgr->paused,
&(bool){ true }, false));
- resume_loop(CURRENT_LOOP(loopmgr));
+ resume_loop(CURRENT_LOOP(isc__loopmgr));
if (isc_log_wouldlog(ISC_LOG_DEBUG(1))) {
isc_log_write(ISC_LOGCATEGORY_GENERAL, ISC_LOGMODULE_OTHER,
}
}
-void
-isc_loopmgr_destroy(isc_loopmgr_t **loopmgrp) {
- isc_loopmgr_t *loopmgr = NULL;
+bool
+isc_loopmgr_paused(void) {
+ REQUIRE(VALID_LOOPMGR(isc__loopmgr));
- REQUIRE(loopmgrp != NULL);
- REQUIRE(VALID_LOOPMGR(*loopmgrp));
+ return atomic_load(&isc__loopmgr->paused);
+}
- loopmgr = *loopmgrp;
- *loopmgrp = NULL;
+void
+isc_loopmgr_destroy(void) {
+ isc_loopmgr_t *loopmgr = isc__loopmgr;
RUNTIME_CHECK(atomic_compare_exchange_strong(&loopmgr->running,
&(bool){ true }, false));
+ isc__loopmgr = NULL;
+
/* Wait for all helpers to finish */
for (size_t i = 0; i < loopmgr->nloops; i++) {
isc_loop_t *helper = &loopmgr->helpers[i];
}
uint32_t
-isc_loopmgr_nloops(isc_loopmgr_t *loopmgr) {
- REQUIRE(VALID_LOOPMGR(loopmgr));
+isc_loopmgr_nloops(void) {
+ REQUIRE(VALID_LOOPMGR(isc__loopmgr));
- return loopmgr->nloops;
+ return isc__loopmgr->nloops;
}
isc_mem_t *
}
isc_loop_t *
-isc_loop_main(isc_loopmgr_t *loopmgr) {
- REQUIRE(VALID_LOOPMGR(loopmgr));
+isc_loop_main(void) {
+ REQUIRE(VALID_LOOPMGR(isc__loopmgr));
- return DEFAULT_LOOP(loopmgr);
+ return DEFAULT_LOOP(isc__loopmgr);
}
isc_loop_t *
-isc_loop_get(isc_loopmgr_t *loopmgr, isc_tid_t tid) {
- REQUIRE(VALID_LOOPMGR(loopmgr));
- REQUIRE((uint32_t)tid < loopmgr->nloops);
+isc_loop_get(isc_tid_t tid) {
+ REQUIRE(VALID_LOOPMGR(isc__loopmgr));
+ REQUIRE((uint32_t)tid < isc__loopmgr->nloops);
- return LOOP(loopmgr, tid);
+ return LOOP(isc__loopmgr, tid);
}
void
-isc_loopmgr_blocking(isc_loopmgr_t *loopmgr) {
- REQUIRE(VALID_LOOPMGR(loopmgr));
+isc_loopmgr_blocking(void) {
+ REQUIRE(VALID_LOOPMGR(isc__loopmgr));
- isc_signal_stop(loopmgr->sigterm);
- isc_signal_stop(loopmgr->sigint);
+ isc_signal_stop(isc__loopmgr->sigterm);
+ isc_signal_stop(isc__loopmgr->sigint);
}
void
-isc_loopmgr_nonblocking(isc_loopmgr_t *loopmgr) {
- REQUIRE(VALID_LOOPMGR(loopmgr));
+isc_loopmgr_nonblocking(void) {
+ REQUIRE(VALID_LOOPMGR(isc__loopmgr));
- isc_signal_start(loopmgr->sigint);
- isc_signal_start(loopmgr->sigterm);
-}
-
-isc_loopmgr_t *
-isc_loop_getloopmgr(isc_loop_t *loop) {
- REQUIRE(VALID_LOOP(loop));
-
- return loop->loopmgr;
+ isc_signal_start(isc__loopmgr->sigint);
+ isc_signal_start(isc__loopmgr->sigterm);
}
isc_time_t
return loop->shuttingdown;
}
+
+isc_loop_t *
+isc_loop_helper(isc_loop_t *loop) {
+ REQUIRE(VALID_LOOP(loop));
+
+ return &isc__loopmgr->helpers[loop->tid];
+}
isc_refcount_t references;
isc_thread_t thread;
- isc_loopmgr_t *loopmgr;
-
uv_loop_t loop;
isc_tid_t tid;
#define LOOPMGR_MAGIC ISC_MAGIC('L', 'o', 'o', 'M')
#define VALID_LOOPMGR(t) ISC_MAGIC_VALID(t, LOOPMGR_MAGIC)
-struct isc_loopmgr {
+typedef struct isc_loopmgr {
int magic;
isc_mem_t *mctx;
/* per-thread objects */
isc_loop_t *loops;
isc_loop_t *helpers;
-};
+} isc_loopmgr_t;
/*
* Signal Handler
* information regarding copyright ownership.
*/
+#include <isc/loop.h>
#include <isc/managers.h>
#include <isc/rwlock.h>
#include <isc/util.h>
#include <isc/uv.h>
void
-isc_managers_create(isc_mem_t **mctxp, uint32_t workers,
- isc_loopmgr_t **loopmgrp, isc_nm_t **netmgrp) {
+isc_managers_create(isc_mem_t **mctxp, uint32_t workers, isc_nm_t **netmgrp) {
REQUIRE(mctxp != NULL && *mctxp == NULL);
isc_mem_create("managers", mctxp);
INSIST(*mctxp != NULL);
- REQUIRE(loopmgrp != NULL && *loopmgrp == NULL);
- isc_loopmgr_create(*mctxp, workers, loopmgrp);
- INSIST(*loopmgrp != NULL);
+ isc_loopmgr_create(*mctxp, workers);
REQUIRE(netmgrp != NULL && *netmgrp == NULL);
- isc_netmgr_create(*mctxp, *loopmgrp, netmgrp);
+ isc_netmgr_create(*mctxp, netmgrp);
INSIST(*netmgrp != NULL);
isc_rwlock_setworkers(workers);
}
void
-isc_managers_destroy(isc_mem_t **mctxp, isc_loopmgr_t **loopmgrp,
- isc_nm_t **netmgrp) {
+isc_managers_destroy(isc_mem_t **mctxp, isc_nm_t **netmgrp) {
REQUIRE(mctxp != NULL && *mctxp != NULL);
- REQUIRE(loopmgrp != NULL && *loopmgrp != NULL);
REQUIRE(netmgrp != NULL && *netmgrp != NULL);
/*
*/
isc_nm_detach(netmgrp);
- isc_loopmgr_destroy(loopmgrp);
+ isc_loopmgr_destroy();
isc_mem_detach(mctxp);
}
void
isc_nm_http_set_endpoints(isc_nmsocket_t *listener,
isc_nm_http_endpoints_t *eps) {
- isc_loopmgr_t *loopmgr = NULL;
-
REQUIRE(VALID_NMSOCK(listener));
REQUIRE(listener->type == isc_nm_httplistener);
REQUIRE(VALID_HTTP_ENDPOINTS(eps));
- loopmgr = listener->worker->netmgr->loopmgr;
-
atomic_store(&eps->in_use, true);
- for (size_t i = 0; i < isc_loopmgr_nloops(loopmgr); i++) {
+ for (size_t i = 0; i < isc_loopmgr_nloops(); i++) {
isc__networker_t *worker =
&listener->worker->netmgr->workers[i];
http_endpoints_data_t *data = isc_mem_cget(worker->loop->mctx,
http_init_listener_endpoints(isc_nmsocket_t *listener,
isc_nm_http_endpoints_t *epset) {
size_t nworkers;
- isc_loopmgr_t *loopmgr = NULL;
REQUIRE(VALID_NMSOCK(listener));
REQUIRE(listener->worker != NULL && VALID_NM(listener->worker->netmgr));
REQUIRE(VALID_HTTP_ENDPOINTS(epset));
- loopmgr = listener->worker->netmgr->loopmgr;
- nworkers = (size_t)isc_loopmgr_nloops(loopmgr);
+ nworkers = (size_t)isc_loopmgr_nloops();
INSIST(nworkers > 0);
listener->h2->listener_endpoints =
int magic;
isc_refcount_t references;
isc_mem_t *mctx;
- isc_loopmgr_t *loopmgr;
uint32_t nloops;
isc__networker_t *workers;
#endif
void
-isc_netmgr_create(isc_mem_t *mctx, isc_loopmgr_t *loopmgr, isc_nm_t **netmgrp) {
+isc_netmgr_create(isc_mem_t *mctx, isc_nm_t **netmgrp) {
isc_nm_t *netmgr = NULL;
#ifdef MAXIMAL_UV_VERSION
netmgr = isc_mem_get(mctx, sizeof(*netmgr));
*netmgr = (isc_nm_t){
- .loopmgr = loopmgr,
- .nloops = isc_loopmgr_nloops(loopmgr),
+ .nloops = isc_loopmgr_nloops(),
};
isc_mem_attach(mctx, &netmgr->mctx);
netmgr->workers = isc_mem_cget(mctx, netmgr->nloops,
sizeof(netmgr->workers[0]));
- isc_loopmgr_teardown(loopmgr, netmgr_teardown, netmgr);
+ isc_loopmgr_teardown(netmgr_teardown, netmgr);
netmgr->magic = NM_MAGIC;
for (size_t i = 0; i < netmgr->nloops; i++) {
- isc_loop_t *loop = isc_loop_get(netmgr->loopmgr, i);
+ isc_loop_t *loop = isc_loop_get(i);
isc__networker_t *worker = &netmgr->workers[i];
*worker = (isc__networker_t){
static void
set_tlsctx_workers(isc_nmsocket_t *listener, isc_tlsctx_t *tlsctx) {
- const size_t nworkers =
- (size_t)isc_loopmgr_nloops(listener->worker->netmgr->loopmgr);
+ const size_t nworkers = (size_t)isc_loopmgr_nloops();
/* Update the TLS context reference for every worker thread. */
for (size_t i = 0; i < nworkers; i++) {
isc__networker_t *worker =
REQUIRE(VALID_NMSOCK(listener));
REQUIRE(ctx != NULL);
- nworkers =
- (size_t)isc_loopmgr_nloops(listener->worker->netmgr->loopmgr);
+ nworkers = (size_t)isc_loopmgr_nloops();
INSIST(nworkers > 0);
listener->tlsstream.listener_tls_ctx = isc_mem_cget(
#include "loop_p.h"
isc_signal_t *
-isc_signal_new(isc_loopmgr_t *loopmgr, isc_signal_cb cb, void *cbarg,
- int signum) {
- isc_loop_t *loop = NULL;
- isc_signal_t *signal = NULL;
+isc_signal_new(isc_signal_cb cb, void *cbarg, int signum) {
int r;
+ isc_loop_t *loop = isc_loop_main();
+ isc_signal_t *signal = isc_mem_get(isc_loop_getmctx(loop),
+ sizeof(*signal));
- loop = DEFAULT_LOOP(loopmgr);
-
- signal = isc_mem_get(isc_loop_getmctx(loop), sizeof(*signal));
*signal = (isc_signal_t){
.magic = SIGNAL_MAGIC,
.cb = cb,
isc_timer_t **timerp) {
int r;
isc_timer_t *timer;
- isc_loopmgr_t *loopmgr = NULL;
REQUIRE(cb != NULL);
REQUIRE(timerp != NULL && *timerp == NULL);
REQUIRE(VALID_LOOP(loop));
-
- loopmgr = loop->loopmgr;
-
- REQUIRE(VALID_LOOPMGR(loopmgr));
REQUIRE(loop == isc_loop());
timer = isc_mem_get(loop->mctx, sizeof(*timer));
void
isc_timer_start(isc_timer_t *timer, isc_timertype_t type,
const isc_interval_t *interval) {
- isc_loopmgr_t *loopmgr = NULL;
isc_loop_t *loop = NULL;
int r;
REQUIRE(VALID_LOOP(loop));
- loopmgr = loop->loopmgr;
-
- REQUIRE(VALID_LOOPMGR(loopmgr));
-
switch (type) {
case isc_timertype_once:
timer->timeout = isc_interval_ms(interval);
ISC_REFCOUNT_IMPL(ns_clientmgr, clientmgr_destroy);
isc_result_t
-ns_clientmgr_create(ns_server_t *sctx, isc_loopmgr_t *loopmgr,
- dns_aclenv_t *aclenv, isc_tid_t tid,
+ns_clientmgr_create(ns_server_t *sctx, dns_aclenv_t *aclenv, isc_tid_t tid,
ns_clientmgr_t **managerp) {
ns_clientmgr_t *manager = NULL;
isc_mem_t *mctx = NULL;
.tid = tid,
.recursing = ISC_LIST_INITIALIZER,
};
- isc_loop_attach(isc_loop_get(loopmgr, tid), &manager->loop);
+ isc_loop_attach(isc_loop_get(tid), &manager->loop);
isc_mutex_init(&manager->reclock);
dns_aclenv_attach(aclenv, &manager->aclenv);
isc_refcount_init(&manager->references, 1);
*/
isc_result_t
-ns_clientmgr_create(ns_server_t *sctx, isc_loopmgr_t *loopmgr,
- dns_aclenv_t *aclenv, isc_tid_t tid,
+ns_clientmgr_create(ns_server_t *sctx, dns_aclenv_t *aclenv, isc_tid_t tid,
ns_clientmgr_t **managerp);
/*%<
* Create a client manager.
***/
isc_result_t
-ns_interfacemgr_create(isc_mem_t *mctx, ns_server_t *sctx,
- isc_loopmgr_t *loopmgr, isc_nm_t *nm,
+ns_interfacemgr_create(isc_mem_t *mctx, ns_server_t *sctx, isc_nm_t *nm,
dns_dispatchmgr_t *dispatchmgr,
dns_geoip_databases_t *geoip, ns_interfacemgr_t **mgrp);
/*%<
unsigned int magic; /*%< Magic number */
isc_refcount_t references;
isc_mutex_t lock;
- isc_mem_t *mctx; /*%< Memory context */
- ns_server_t *sctx; /*%< Server context */
- isc_loopmgr_t *loopmgr; /*%< Loop manager */
- isc_nm_t *nm; /*%< Net manager */
- uint32_t ncpus; /*%< Number of workers */
+ isc_mem_t *mctx; /*%< Memory context */
+ ns_server_t *sctx; /*%< Server context */
+ isc_nm_t *nm; /*%< Net manager */
+ uint32_t ncpus; /*%< Number of workers */
dns_dispatchmgr_t *dispatchmgr;
unsigned int generation; /*%< Current generation no */
ns_listenlist_t *listenon4;
}
isc_result_t
-ns_interfacemgr_create(isc_mem_t *mctx, ns_server_t *sctx,
- isc_loopmgr_t *loopmgr, isc_nm_t *nm,
+ns_interfacemgr_create(isc_mem_t *mctx, ns_server_t *sctx, isc_nm_t *nm,
dns_dispatchmgr_t *dispatchmgr,
dns_geoip_databases_t *geoip, ns_interfacemgr_t **mgrp) {
isc_result_t result;
mgr = isc_mem_get(mctx, sizeof(*mgr));
*mgr = (ns_interfacemgr_t){
- .loopmgr = loopmgr,
.nm = nm,
.dispatchmgr = dispatchmgr,
.generation = 1,
- .ncpus = isc_loopmgr_nloops(loopmgr),
+ .ncpus = isc_loopmgr_nloops(),
};
isc_mem_attach(mctx, &mgr->mctx);
mgr->clientmgrs = isc_mem_cget(mgr->mctx, mgr->ncpus,
sizeof(mgr->clientmgrs[0]));
for (size_t i = 0; i < mgr->ncpus; i++) {
- result = ns_clientmgr_create(mgr->sctx, mgr->loopmgr,
- mgr->aclenv, (int)i,
+ result = ns_clientmgr_create(mgr->sctx, mgr->aclenv, (int)i,
&mgr->clientmgrs[i]);
RUNTIME_CHECK(result == ISC_R_SUCCESS);
}
#include <dns/qp.h>
#include <dns/types.h>
-#include "loop_p.h"
#include "qp_p.h"
#include <tests/qp.h>
struct thread_args {
struct bench_state *bctx; /* (in) */
isc_barrier_t *barrier; /* (in) */
- isc_loopmgr_t *loopmgr; /* (in) */
isc_job_t job; /* (in) */
isc_job_cb cb; /* (in) */
dns_qpmulti_t *multi; /* (in) */
isc_job_run(isc_loop(), &args->job, args->cb, args);
return;
}
- isc_async_run(isc_loop_main(args->loopmgr), collect, args);
+ isc_async_run(isc_loop_main(), collect, args);
}
#if ZIPF
struct bench_state {
isc_mem_t *mctx;
isc_barrier_t barrier;
- isc_loopmgr_t *loopmgr;
dns_qpmulti_t *multi;
enum benchmode mode;
size_t bytes;
case init:
goto init_max_items_rw;
- fini:;
- isc_loopmgr_t *loopmgr = bctx->loopmgr;
+ fini:
dns_qpmulti_destroy(&bctx->multi);
isc_mem_putanddetach(&bctx->mctx, bctx, bctx->bytes);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
return;
init_max_items_rw:
bctx->thread[t] = (struct thread_args){
.bctx = bctx,
.barrier = &bctx->barrier,
- .loopmgr = bctx->loopmgr,
.multi = bctx->multi,
.max_item = bctx->max_item,
.zipf_skew = bctx->zipf_skew,
.tx_per_loop = mut ? bctx->mut_tx_per_loop
: bctx->read_tx_per_loop,
};
- isc_async_run(isc_loop_get(bctx->loopmgr, t), first_loop,
- &bctx->thread[t]);
+ isc_async_run(isc_loop_get(t), first_loop, &bctx->thread[t]);
}
}
}
static void
-startup(void *arg) {
- isc_loopmgr_t *loopmgr = arg;
+startup(void *arg ISC_ATTR_UNUSED) {
isc_loop_t *loop = isc_loop();
isc_mem_t *mctx = isc_loop_getmctx(loop);
- uint32_t nloops = isc_loopmgr_nloops(loopmgr);
+ uint32_t nloops = isc_loopmgr_nloops();
size_t bytes = sizeof(struct bench_state) +
sizeof(struct thread_args) * nloops;
struct bench_state *bctx = isc_mem_cget(mctx, 1, bytes);
*bctx = (struct bench_state){
- .loopmgr = loopmgr,
.bytes = bytes,
.nloops = nloops,
};
}
struct ticker {
- isc_loopmgr_t *loopmgr;
isc_mem_t *mctx;
isc_timer_t *timer;
};
}
static void
-setup_tickers(isc_mem_t *mctx, isc_loopmgr_t *loopmgr) {
- uint32_t nloops = isc_loopmgr_nloops(loopmgr);
+setup_tickers(isc_mem_t *mctx) {
+ uint32_t nloops = isc_loopmgr_nloops();
for (uint32_t i = 0; i < nloops; i++) {
- isc_loop_t *loop = isc_loop_get(loopmgr, i);
+ isc_loop_t *loop = isc_loop_get(i);
struct ticker *ticker = isc_mem_get(mctx, sizeof(*ticker));
*ticker = (struct ticker){
- .loopmgr = loopmgr,
+ .mctx = isc_mem_ref(mctx),
};
- isc_mem_attach(mctx, &ticker->mctx);
isc_loop_setup(loop, start_ticker, ticker);
isc_loop_teardown(loop, stop_ticker, ticker);
}
int
main(void) {
- isc_loopmgr_t *loopmgr = NULL;
isc_mem_t *mctx = NULL;
setlinebuf(stdout);
init_logging();
init_items(mctx);
- isc_loopmgr_create(mctx, nloops, &loopmgr);
- setup_tickers(mctx, loopmgr);
- isc_loop_setup(isc_loop_main(loopmgr), startup, loopmgr);
- isc_loopmgr_run(loopmgr);
- isc_loopmgr_destroy(&loopmgr);
+ isc_loopmgr_create(mctx, nloops);
+ setup_tickers(mctx);
+ isc_loop_setup(isc_loop_main(), startup, NULL);
+ isc_loopmgr_run();
+ isc_loopmgr_destroy();
isc_mem_free(mctx, item);
isc_mem_checkdestroyed(stdout);
dns_name_fromstring(name, "example.com.", NULL, 0, NULL);
- bc = dns_badcache_new(mctx, loopmgr);
+ bc = dns_badcache_new(mctx);
dns_badcache_add(bc, name, dns_rdatatype_aaaa, flags, now + 60);
flags = 0;
dns_badcache_destroy(&bc);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
ISC_LOOP_TEST_IMPL(expire) {
dns_name_fromstring(name, "example.com.", NULL, 0, NULL);
- bc = dns_badcache_new(mctx, loopmgr);
+ bc = dns_badcache_new(mctx);
dns_badcache_add(bc, name, dns_rdatatype_aaaa, flags, now + 60);
dns_badcache_add(bc, name, dns_rdatatype_a, flags, now + 60);
dns_badcache_destroy(&bc);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
ISC_LOOP_TEST_IMPL(print) {
dns_name_fromstring(name, "example.com.", NULL, 0, NULL);
- bc = dns_badcache_new(mctx, loopmgr);
+ bc = dns_badcache_new(mctx);
dns_badcache_add(bc, name, dns_rdatatype_a, flags, expire);
dns_badcache_add(bc, name, dns_rdatatype_aaaa, flags, expire);
dns_badcache_destroy(&bc);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
ISC_LOOP_TEST_IMPL(flush) {
dns_name_fromstring(name, "example.com.", NULL, 0, NULL);
- bc = dns_badcache_new(mctx, loopmgr);
+ bc = dns_badcache_new(mctx);
dns_badcache_add(bc, name, dns_rdatatype_aaaa, flags, now + 60);
result = dns_badcache_find(bc, name, dns_rdatatype_aaaa, &flags, now);
dns_badcache_destroy(&bc);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
ISC_LOOP_TEST_IMPL(flushname) {
isc_result_t result;
uint32_t flags = BADCACHE_TEST_FLAG;
- bc = dns_badcache_new(mctx, loopmgr);
+ bc = dns_badcache_new(mctx);
dns_name_fromstring(name, "example.com.", NULL, 0, NULL);
dns_badcache_add(bc, name, dns_rdatatype_aaaa, flags, now + 60);
dns_badcache_destroy(&bc);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
ISC_LOOP_TEST_IMPL(flushtree) {
isc_result_t result;
uint32_t flags = BADCACHE_TEST_FLAG;
- bc = dns_badcache_new(mctx, loopmgr);
+ bc = dns_badcache_new(mctx);
dns_name_fromstring(name, "example.com.", NULL, 0, NULL);
dns_badcache_add(bc, name, dns_rdatatype_aaaa, flags, now + 60);
dns_badcache_destroy(&bc);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
ISC_LOOP_TEST_IMPL(purge) {
isc_result_t result;
uint32_t flags = BADCACHE_TEST_FLAG;
- bc = dns_badcache_new(mctx, loopmgr);
+ bc = dns_badcache_new(mctx);
dns_name_fromstring(name, "example.com.", NULL, 0, NULL);
dns_badcache_add(bc, name, dns_rdatatype_aaaa, flags, now);
dns_badcache_destroy(&bc);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
ISC_TEST_LIST_START
dns_db_detachnode(db, &node);
dns_db_detach(&db);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
/* test getservestalettl and setservestalettl */
assert_int_equal(ttl, 6 * 3600);
dns_db_detach(&db);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
/* check DNS_DBFIND_STALEOK works */
}
dns_db_detach(&db);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
/* database class */
assert_int_equal(dns_db_class(db), dns_rdataclass_in);
dns_db_detach(&db);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
/* database type */
assert_true(dns_db_iscache(db));
assert_false(dns_db_iszone(db));
dns_db_detach(&db);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
/* database versions */
dns_db_closeversion(db, &ver, false);
dns_db_detach(&db);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
ISC_TEST_LIST_START
static void
test_dispatch_shutdown(test_dispatch_t *test) {
test_dispatch_done(test);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
static int
uv_os_sock_t socket = -1;
/* Create just 1 loop for this test */
- isc_loopmgr_create(mctx, 1, &loopmgr);
- mainloop = isc_loop_main(loopmgr);
+ isc_loopmgr_create(mctx, 1);
setup_netmgr(state);
- isc_netmgr_create(mctx, loopmgr, &connect_nm);
+ isc_netmgr_create(mctx, &connect_nm);
udp_connect_addr = (isc_sockaddr_t){ .length = 0 };
isc_sockaddr_fromin6(&udp_connect_addr, &in6addr_loopback, 0);
UNUSED(arg);
- result = dns_dispatchmgr_create(mctx, loopmgr, connect_nm,
- &dispatchmgr);
+ result = dns_dispatchmgr_create(mctx, connect_nm, &dispatchmgr);
assert_int_equal(result, ISC_R_SUCCESS);
result = make_dispatchset(dispatchmgr, 1, &dset);
dns_dispatchmgr_detach(&dispatchmgr);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
/* test dispatch set per-loop dispatch */
UNUSED(arg);
- result = dns_dispatchmgr_create(mctx, loopmgr, connect_nm,
- &dispatchmgr);
+ result = dns_dispatchmgr_create(mctx, connect_nm, &dispatchmgr);
assert_int_equal(result, ISC_R_SUCCESS);
result = make_dispatchset(dispatchmgr, 1, &dset);
dns_dispatchset_destroy(&dset);
dns_dispatchmgr_detach(&dispatchmgr);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
static atomic_bool first = true;
assert_ptr_equal(test1->dispatch, test2->dispatch);
result = dns_dispatch_add(
- test2->dispatch, isc_loop_main(loopmgr), 0, T_CLIENT_CONNECT,
+ test2->dispatch, isc_loop_main(), 0, T_CLIENT_CONNECT,
T_CLIENT_INIT, &tcp_server_addr, NULL, NULL, connected_shutdown,
client_senddone, response_noop, test2, &test2->id,
&test2->dispentry);
assert_ptr_not_equal(test3->dispatch, test4->dispatch);
result = dns_dispatch_add(
- test4->dispatch, isc_loop_main(loopmgr), 0, T_CLIENT_CONNECT,
+ test4->dispatch, isc_loop_main(), 0, T_CLIENT_CONNECT,
T_CLIENT_INIT, &tcp_server_addr, NULL, NULL, connected_shutdown,
client_senddone, response_noop, test4, &test4->id,
&test4->dispentry);
testdata.region.base = testdata.message;
testdata.region.length = sizeof(testdata.message);
- result = dns_dispatchmgr_create(mctx, loopmgr, connect_nm,
- &test->dispatchmgr);
+ result = dns_dispatchmgr_create(mctx, connect_nm, &test->dispatchmgr);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_dispatch_createtcp(test->dispatchmgr, &tcp_connect_addr,
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_dispatch_add(
- test->dispatch, isc_loop_main(loopmgr), 0, T_CLIENT_SHORT,
+ test->dispatch, isc_loop_main(), 0, T_CLIENT_SHORT,
T_CLIENT_INIT, &tcp_server_addr, NULL, NULL, timeout_connected,
client_senddone, response_timeout, test, &test->id,
&test->dispentry);
assert_int_equal(result, ISC_R_SUCCESS);
/* ensure we stop listening after the test is done */
- isc_loop_teardown(isc_loop_main(loopmgr), stop_listening, sock);
+ isc_loop_teardown(isc_loop_main(), stop_listening, sock);
/* Client */
- result = dns_dispatchmgr_create(mctx, loopmgr, connect_nm,
- &test->dispatchmgr);
+ result = dns_dispatchmgr_create(mctx, connect_nm, &test->dispatchmgr);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_dispatch_createtcp(test->dispatchmgr, &tcp_connect_addr,
&test->dispatch);
assert_int_equal(result, ISC_R_SUCCESS);
- result = dns_dispatch_add(test->dispatch, isc_loop_main(loopmgr), 0,
+ result = dns_dispatch_add(test->dispatch, isc_loop_main(), 0,
T_CLIENT_CONNECT, T_CLIENT_SHORT,
&tcp_server_addr, NULL, NULL, connected,
client_senddone, response_timeout, test,
accept_cb, NULL, 0, NULL, NULL, ISC_NM_PROXY_NONE, &sock);
assert_int_equal(result, ISC_R_SUCCESS);
- isc_loop_teardown(isc_loop_main(loopmgr), stop_listening, sock);
+ isc_loop_teardown(isc_loop_main(), stop_listening, sock);
/* Client */
testdata.region.base = testdata.message;
testdata.region.length = sizeof(testdata.message);
- result = dns_dispatchmgr_create(mctx, loopmgr, connect_nm,
- &test->dispatchmgr);
+ result = dns_dispatchmgr_create(mctx, connect_nm, &test->dispatchmgr);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_dispatch_createtcp(test->dispatchmgr, &tcp_connect_addr,
&test->dispatch);
assert_int_equal(result, ISC_R_SUCCESS);
- result = dns_dispatch_add(test->dispatch, isc_loop_main(loopmgr), 0,
+ result = dns_dispatch_add(test->dispatch, isc_loop_main(), 0,
T_CLIENT_CONNECT, T_CLIENT_INIT,
&tcp_server_addr, NULL, NULL, connected,
client_senddone, response_shutdown, test,
&sock);
assert_int_equal(result, ISC_R_SUCCESS);
- isc_loop_teardown(isc_loop_main(loopmgr), stop_listening, sock);
+ isc_loop_teardown(isc_loop_main(), stop_listening, sock);
/* Client */
testdata.region.base = testdata.message;
testdata.region.length = sizeof(testdata.message);
- result = dns_dispatchmgr_create(mctx, loopmgr, connect_nm,
- &test->dispatchmgr);
+ result = dns_dispatchmgr_create(mctx, connect_nm, &test->dispatchmgr);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_dispatch_createtcp(test->dispatchmgr, &tls_connect_addr,
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_dispatch_add(
- test->dispatch, isc_loop_main(loopmgr), 0, T_CLIENT_CONNECT,
+ test->dispatch, isc_loop_main(), 0, T_CLIENT_CONNECT,
T_CLIENT_INIT, &tls_server_addr, tls_transport,
tls_tlsctx_client_cache, connected, client_senddone,
response_shutdown, test, &test->id, &test->dispentry);
assert_int_equal(result, ISC_R_SUCCESS);
/* ensure we stop listening after the test is done */
- isc_loop_teardown(isc_loop_main(loopmgr), stop_listening, sock);
+ isc_loop_teardown(isc_loop_main(), stop_listening, sock);
/* Client */
- result = dns_dispatchmgr_create(mctx, loopmgr, connect_nm,
- &test->dispatchmgr);
+ result = dns_dispatchmgr_create(mctx, connect_nm, &test->dispatchmgr);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_dispatch_createudp(test->dispatchmgr, &udp_connect_addr,
&test->dispatch);
assert_int_equal(result, ISC_R_SUCCESS);
- result = dns_dispatch_add(test->dispatch, isc_loop_main(loopmgr), 0,
+ result = dns_dispatch_add(test->dispatch, isc_loop_main(), 0,
T_CLIENT_CONNECT, T_CLIENT_SHORT,
&udp_server_addr, NULL, NULL, connected,
client_senddone, response_timeout, test,
nameserver, NULL, &sock);
assert_int_equal(result, ISC_R_SUCCESS);
- isc_loop_teardown(isc_loop_main(loopmgr), stop_listening, sock);
+ isc_loop_teardown(isc_loop_main(), stop_listening, sock);
/* Client */
testdata.region.base = testdata.message;
testdata.region.length = sizeof(testdata.message);
- result = dns_dispatchmgr_create(mctx, loopmgr, connect_nm,
- &test->dispatchmgr);
+ result = dns_dispatchmgr_create(mctx, connect_nm, &test->dispatchmgr);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_dispatch_createudp(test->dispatchmgr, &udp_connect_addr,
&test->dispatch);
assert_int_equal(result, ISC_R_SUCCESS);
- result = dns_dispatch_add(test->dispatch, isc_loop_main(loopmgr), 0,
+ result = dns_dispatch_add(test->dispatch, isc_loop_main(), 0,
T_CLIENT_CONNECT, T_CLIENT_INIT,
&udp_server_addr, NULL, NULL, connected,
client_senddone, response_getnext, test,
assert_int_equal(result, ISC_R_SUCCESS);
/* ensure we stop listening after the test is done */
- isc_loop_teardown(isc_loop_main(loopmgr), stop_listening, sock);
+ isc_loop_teardown(isc_loop_main(), stop_listening, sock);
- result = dns_dispatchmgr_create(mctx, loopmgr, connect_nm,
- &test->dispatchmgr);
+ result = dns_dispatchmgr_create(mctx, connect_nm, &test->dispatchmgr);
assert_int_equal(result, ISC_R_SUCCESS);
/* Client */
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_dispatch_add(
- test->dispatch, isc_loop_main(loopmgr), 0, T_CLIENT_CONNECT,
+ test->dispatch, isc_loop_main(), 0, T_CLIENT_CONNECT,
T_CLIENT_INIT, &tcp_server_addr, NULL, NULL, connected_gettcp,
client_senddone, response_noop, test, &test->id,
&test->dispentry);
assert_int_equal(result, ISC_R_SUCCESS);
/* ensure we stop listening after the test is done */
- isc_loop_teardown(isc_loop_main(loopmgr), stop_listening, sock);
+ isc_loop_teardown(isc_loop_main(), stop_listening, sock);
/* Client - unshared */
- result = dns_dispatchmgr_create(mctx, loopmgr, connect_nm,
- &test->dispatchmgr);
+ result = dns_dispatchmgr_create(mctx, connect_nm, &test->dispatchmgr);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_dispatch_createtcp(
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_dispatch_add(
- test->dispatch, isc_loop_main(loopmgr), 0, T_CLIENT_CONNECT,
+ test->dispatch, isc_loop_main(), 0, T_CLIENT_CONNECT,
T_CLIENT_INIT, &tcp_server_addr, NULL, NULL, connected_newtcp,
client_senddone, response_noop, test, &test->id,
&test->dispentry);
fstrm_iothr_options_destroy(&fopt);
}
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
/* send dnstap messages */
dns_dt_close(&handle);
}
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
/* dnstap message to text */
if (handle != NULL) {
dns_dt_close(&handle);
}
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
ISC_TEST_LIST_START
#include <stdlib.h>
#include <unistd.h>
+#include "isc/loop.h"
+
#define UNIT_TESTING
#include <cmocka.h>
ISC_R_SUCCESS);
dns_keytable_create(view, &keytable);
- dns_ntatable_create(view, loopmgr, &ntatable);
+ dns_ntatable_create(view, &ntatable);
/* Add a normal key */
dns_test_namefromstring("example.com.", &fn);
dns_keynode_detach(&keynode);
destroy_tables();
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
/* delete keys from the keytable */
destroy_tables();
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
/* delete key nodes from the keytable */
destroy_tables();
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
/* check find-variant operations */
destroy_tables();
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
/* check issecuredomain() */
destroy_tables();
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
/* check dns_keytable_dump() */
destroy_tables();
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
/* check negative trust anchors */
result = dns_view_getsecroots(myview, &keytable);
assert_int_equal(result, ISC_R_SUCCESS);
- dns_view_initntatable(myview, loopmgr);
+ dns_view_initntatable(myview);
result = dns_view_getntatable(myview, &ntatable);
assert_int_equal(result, ISC_R_SUCCESS);
assert_false(covered);
assert_true(issecure);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
/* Clean up */
dns_ntatable_detach(&ntatable);
dns_db_detach(&db);
isc_mem_detach(&mctx2);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
ISC_LOOP_TEST_IMPL(overmempurge_longname) {
dns_db_detach(&db);
isc_mem_detach(&mctx2);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
ISC_TEST_LIST_START
}
dns_qpmulti_destroy(&qpm);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
ISC_RUN_TEST_IMPL(qpmulti) {
setup_loopmgr(NULL);
setup_logging();
setup_items();
- isc_loop_setup(isc_loop_main(loopmgr), many_transactions, NULL);
- isc_loopmgr_run(loopmgr);
+ isc_loop_setup(isc_loop_main(), many_transactions, NULL);
+ isc_loopmgr_run();
rcu_barrier();
- isc_loopmgr_destroy(&loopmgr);
+ isc_loopmgr_destroy();
}
ISC_TEST_LIST_START
isc_result_t result;
isc_tlsctx_cache_create(mctx, &tlsctx_cache);
- result = dns_resolver_create(view, loopmgr, netmgr, 0, tlsctx_cache,
- dispatch, NULL, resolverp);
+ result = dns_resolver_create(view, netmgr, 0, tlsctx_cache, dispatch,
+ NULL, resolverp);
assert_int_equal(result, ISC_R_SUCCESS);
}
mkres(&resolver);
destroy_resolver(&resolver);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
/* dns_resolver_gettimeout */
assert_true(timeout > 0);
destroy_resolver(&resolver);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
/* dns_resolver_settimeout */
assert_true(timeout == default_timeout + 1);
destroy_resolver(&resolver);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
/* dns_resolver_settimeout */
assert_int_equal(timeout, default_timeout);
destroy_resolver(&resolver);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
/* dns_resolver_settimeout below minimum */
assert_in_range(timeout, default_timeout, 3999999);
destroy_resolver(&resolver);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
/* dns_resolver_settimeout over maximum */
assert_in_range(timeout, default_timeout, 3999999);
destroy_resolver(&resolver);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
ISC_TEST_LIST_START
isc_sockaddr_fromin6(&src_addrv6, &in6addr_loopback, src_port);
isc_sockaddr_fromin6(&dst_addrv6, &in6addr_loopback, dst_port);
- uc = dns_unreachcache_new(mctx, loopmgr, EXPIRE_MIN_S, EXPIRE_MAX_S,
+ uc = dns_unreachcache_new(mctx, EXPIRE_MIN_S, EXPIRE_MAX_S,
BACKOFF_ELGIBLE_S);
dns_unreachcache_add(uc, &dst_addrv4, &src_addrv4);
dns_unreachcache_add(uc, &dst_addrv6, &src_addrv6);
dns_unreachcache_destroy(&uc);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
ISC_LOOP_TEST_IMPL(expire) {
isc_sockaddr_fromin(&src_addrv4, &localhost4, src_port);
isc_sockaddr_fromin(&dst_addrv4, &localhost4, dst_port);
- uc = dns_unreachcache_new(mctx, loopmgr, EXPIRE_MIN_S, EXPIRE_MAX_S,
+ uc = dns_unreachcache_new(mctx, EXPIRE_MIN_S, EXPIRE_MAX_S,
BACKOFF_ELGIBLE_S);
/* Two adds to "confirm" the addition. */
dns_unreachcache_add(uc, &dst_addrv4, &src_addrv4);
dns_unreachcache_destroy(&uc);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
ISC_LOOP_TEST_IMPL(flush) {
isc_sockaddr_fromin(&src_addrv4, &localhost4, src_port);
isc_sockaddr_fromin(&dst_addrv4, &localhost4, dst_port);
- uc = dns_unreachcache_new(mctx, loopmgr, EXPIRE_MIN_S, EXPIRE_MAX_S,
+ uc = dns_unreachcache_new(mctx, EXPIRE_MIN_S, EXPIRE_MAX_S,
BACKOFF_ELGIBLE_S);
/* Two adds to "confirm" the addition. */
dns_unreachcache_add(uc, &dst_addrv4, &src_addrv4);
dns_unreachcache_destroy(&uc);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
ISC_TEST_LIST_START
assert_string_equal(dns_zone_getfile(zone), longname);
dns_zone_detach(&zone);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
ISC_TEST_LIST_START
dns_zonemgr_detach(&myzonemgr);
assert_null(myzonemgr);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
/* manage and release a zone */
dns_zonemgr_detach(&myzonemgr);
assert_null(myzonemgr);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
/* create and release a zone */
dns_zonemgr_detach(&myzonemgr);
assert_null(myzonemgr);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
ISC_TEST_LIST_START
/* The view was left attached in dns_test_makezone() */
dns_view_detach(&view);
dns_zone_detach(&zone);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
static isc_result_t
dns_zone_detach(&zone);
dns_view_detach(&view);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
return ISC_R_SUCCESS;
}
dns_zone_detach(&zone3);
dns_view_detach(&view);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
return ISC_R_SUCCESS;
}
#include <isc/util.h>
#include <isc/uv.h>
-extern isc_mem_t *mctx;
-extern isc_loop_t *mainloop;
-extern isc_loopmgr_t *loopmgr;
-extern isc_nm_t *netmgr;
-extern int ncpus;
-extern unsigned int workers;
-extern bool debug;
+extern isc_mem_t *mctx;
+extern isc_nm_t *netmgr;
+extern int ncpus;
+extern unsigned int workers;
+extern bool debug;
int
setup_mctx(void **state);
} \
;
-#define ISC_LOOP_TEST_CUSTOM_IMPL(name, setup, teardown) \
- void run_test_##name(void **state ISC_ATTR_UNUSED); \
- void loop_test_##name(void *arg ISC_ATTR_UNUSED); \
- void run_test_##name(void **state ISC_ATTR_UNUSED) { \
- isc_job_cb setup_loop = setup; \
- isc_job_cb teardown_loop = teardown; \
- if (setup_loop != NULL) { \
- isc_loop_setup(mainloop, setup_loop, state); \
- } \
- if (teardown_loop != NULL) { \
- isc_loop_teardown(mainloop, teardown_loop, state); \
- } \
- isc_loop_setup(mainloop, loop_test_##name, state); \
- isc_loopmgr_run(loopmgr); \
- } \
+#define ISC_LOOP_TEST_CUSTOM_IMPL(name, setup, teardown) \
+ void run_test_##name(void **state ISC_ATTR_UNUSED); \
+ void loop_test_##name(void *arg ISC_ATTR_UNUSED); \
+ void run_test_##name(void **state ISC_ATTR_UNUSED) { \
+ isc_job_cb setup_loop = setup; \
+ isc_job_cb teardown_loop = teardown; \
+ if (setup_loop != NULL) { \
+ isc_loop_setup(isc_loop_main(), setup_loop, state); \
+ } \
+ if (teardown_loop != NULL) { \
+ isc_loop_teardown(isc_loop_main(), teardown_loop, \
+ state); \
+ } \
+ isc_loop_setup(isc_loop_main(), loop_test_##name, state); \
+ isc_loopmgr_run(); \
+ } \
void loop_test_##name(void *arg ISC_ATTR_UNUSED)
#define ISC_LOOP_TEST_IMPL(name) ISC_LOOP_TEST_CUSTOM_IMPL(name, NULL, NULL)
static atomic_uint scheduled = 0;
static void
-async_cb(void *arg) {
+async_cb(void *arg ISC_ATTR_UNUSED) {
isc_tid_t tid = isc_tid();
- UNUSED(arg);
-
atomic_fetch_add(&scheduled, 1);
if (tid > 0) {
- isc_loop_t *loop = isc_loop_get(loopmgr, tid - 1);
- isc_async_run(loop, async_cb, loopmgr);
+ isc_loop_t *loop = isc_loop_get(tid - 1);
+ isc_async_run(loop, async_cb, NULL);
} else {
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
}
static void
-async_setup_cb(void *arg) {
- isc_tid_t tid = isc_loopmgr_nloops(loopmgr) - 1;
- isc_loop_t *loop = isc_loop_get(loopmgr, tid);
-
- UNUSED(arg);
+async_setup_cb(void *arg ISC_ATTR_UNUSED) {
+ isc_tid_t tid = isc_loopmgr_nloops() - 1;
+ isc_loop_t *loop = isc_loop_get(tid);
- isc_async_run(loop, async_cb, loopmgr);
+ isc_async_run(loop, async_cb, NULL);
}
ISC_RUN_TEST_IMPL(isc_async_run) {
- isc_loop_setup(isc_loop_main(loopmgr), async_setup_cb, loopmgr);
- isc_loopmgr_run(loopmgr);
- assert_int_equal(atomic_load(&scheduled), loopmgr->nloops);
+ isc_loop_setup(isc_loop_main(), async_setup_cb, NULL);
+ isc_loopmgr_run();
+ assert_int_equal(atomic_load(&scheduled), isc_loopmgr_nloops());
}
static char string[32] = "";
}
static void
-async_multiple(void *arg) {
+async_multiple(void *arg ISC_ATTR_UNUSED) {
isc_loop_t *loop = isc_loop();
- UNUSED(arg);
-
isc_async_run(loop, append, &n1);
isc_async_run(loop, append, &n2);
isc_async_run(loop, append, &n3);
isc_async_run(loop, append, &n4);
isc_async_run(loop, append, &n5);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
ISC_RUN_TEST_IMPL(isc_async_multiple) {
string[0] = '\0';
- isc_loop_setup(isc_loop_main(loopmgr), async_multiple, loopmgr);
- isc_loopmgr_run(loopmgr);
+ isc_loop_setup(isc_loop_main(), async_multiple, NULL);
+ isc_loopmgr_run();
assert_string_equal(string, "12345");
}
nm = isc_mem_cget(mctx, MAX_NM, sizeof(nm[0]));
for (size_t i = 0; i < MAX_NM; i++) {
- isc_netmgr_create(mctx, loopmgr, &nm[i]);
+ isc_netmgr_create(mctx, &nm[i]);
assert_non_null(nm[i]);
}
if (have_expected_csends(atomic_fetch_add(&csends, 1) + 1) ||
have_expected_creads(atomic_fetch_add(&creads, 1) + 1))
{
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
} else {
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
}
RESET_RETURN;
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
static void
&tcp_listen_addr, 0, NULL, NULL, endpoints,
0, get_proxy_type(), &listen_sock);
assert_int_equal(result, ISC_R_SUCCESS);
- isc_loop_teardown(mainloop, listen_sock_close, listen_sock);
+ isc_loop_teardown(isc_loop_main(), listen_sock_close, listen_sock);
sockaddr_to_url(&tcp_listen_addr, false, req_url, sizeof(req_url),
ISC_NM_HTTP_DEFAULT_PATH);
.length = send_msg.len },
noop_read_cb, NULL, atomic_load(&use_TLS), 30000);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
assert_int_equal(0, atomic_load(&csends));
assert_int_equal(0, atomic_load(&creads));
&tcp_listen_addr, 0, NULL, NULL, endpoints,
0, get_proxy_type(), &listen_sock);
assert_int_equal(result, ISC_R_SUCCESS);
- isc_loop_teardown(mainloop, listen_sock_close, listen_sock);
+ isc_loop_teardown(isc_loop_main(), listen_sock_close, listen_sock);
sockaddr_to_url(&tcp_listen_addr, false, req_url, sizeof(req_url),
ISC_NM_HTTP_DEFAULT_PATH);
.length = send_msg.len },
noop_read_cb, NULL, atomic_load(&use_TLS), 30000);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
ISC_LOOP_TEST_IMPL(doh_noresponse_POST) {
}
isc_nmhandle_detach(&handle);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
static void
&tcp_listen_addr, 0, NULL, NULL, endpoints,
0, get_proxy_type(), &listen_sock);
assert_int_equal(result, ISC_R_SUCCESS);
- isc_loop_teardown(mainloop, listen_sock_close, listen_sock);
+ isc_loop_teardown(isc_loop_main(), listen_sock_close, listen_sock);
/*
* Accept connections but don't send responses, forcing client
isc_async_current(doh_connect_thread, connect_nm);
}
if (sends <= 0) {
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
}
atomic_load(&use_TLS), 30000);
if (sends <= 0) {
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
}
doh_receive_reply_cb, NULL, atomic_load(&use_TLS),
30000);
- isc_loop_teardown(mainloop, listen_sock_close, listen_sock);
+ isc_loop_teardown(isc_loop_main(), listen_sock_close, listen_sock);
}
static int
NULL, ctx, NULL, client_sess_cache, 5000,
get_proxy_type(), NULL);
- isc_loop_teardown(mainloop, listen_sock_close, listen_sock);
+ isc_loop_teardown(isc_loop_main(), listen_sock_close, listen_sock);
}
static int
isc_nm_t *connect_nm = nm[1];
isc_result_t result = ISC_R_SUCCESS;
isc_nmsocket_t *listen_sock = NULL;
- size_t nthreads = isc_loopmgr_nloops(loopmgr);
+ size_t nthreads = isc_loopmgr_nloops();
isc_quota_t *quotap = init_listener_quota(workers);
atomic_store(&total_sends, 1000);
assert_int_equal(result, ISC_R_SUCCESS);
for (size_t i = 0; i < nthreads; i++) {
- isc_async_run(isc_loop_get(loopmgr, i), doh_connect_thread,
- connect_nm);
+ isc_async_run(isc_loop_get(i), doh_connect_thread, connect_nm);
}
- isc_loop_teardown(mainloop, listen_sock_close, listen_sock);
+ isc_loop_teardown(isc_loop_main(), listen_sock_close, listen_sock);
}
static int
.length = send_msg.len },
doh_receive_reply_cb, NULL, true, 30000);
- isc_loop_teardown(mainloop, listen_sock_close, listen_sock);
+ isc_loop_teardown(isc_loop_main(), listen_sock_close, listen_sock);
}
ISC_RUN_TEST_IMPL(doh_parse_GET_query_string) {
isc_mem_put(mctx, ta, sizeof(*ta));
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
static void
atomic_init(&scheduled, 0);
atomic_init(&executed, 0);
- isc_loopmgr_setup(loopmgr, job_run_cb, NULL);
+ isc_loopmgr_setup(job_run_cb, NULL);
- isc_loopmgr_run(loopmgr);
+ isc_loopmgr_run();
assert_int_equal(atomic_load(&scheduled), atomic_load(&executed));
}
}
static void
-job_multiple(void *arg) {
- UNUSED(arg);
-
+job_multiple(void *arg ISC_ATTR_UNUSED) {
/* These will be processed in normal order */
- isc_job_run(mainloop, &n1.job, append, &n1);
- isc_job_run(mainloop, &n2.job, append, &n2);
- isc_job_run(mainloop, &n3.job, append, &n3);
- isc_job_run(mainloop, &n4.job, append, &n4);
- isc_job_run(mainloop, &n5.job, append, &n5);
- isc_loopmgr_shutdown(loopmgr);
+ isc_job_run(isc_loop_main(), &n1.job, append, &n1);
+ isc_job_run(isc_loop_main(), &n2.job, append, &n2);
+ isc_job_run(isc_loop_main(), &n3.job, append, &n3);
+ isc_job_run(isc_loop_main(), &n4.job, append, &n4);
+ isc_job_run(isc_loop_main(), &n5.job, append, &n5);
+ isc_loopmgr_shutdown();
}
ISC_RUN_TEST_IMPL(isc_job_multiple) {
string[0] = '\0';
- isc_loop_setup(isc_loop_main(loopmgr), job_multiple, loopmgr);
- isc_loopmgr_run(loopmgr);
+ isc_loop_setup(isc_loop_main(), job_multiple, NULL);
+ isc_loopmgr_run();
assert_string_equal(string, "12345");
}
#include <sys/types.h>
#include <unistd.h>
+#include "isc/attributes.h"
+
#define UNIT_TESTING
#include <cmocka.h>
static atomic_uint scheduled = 0;
static void
-count(void *arg) {
- UNUSED(arg);
-
+count(void *arg ISC_ATTR_UNUSED) {
atomic_fetch_add(&scheduled, 1);
}
static void
-shutdown_loopmgr(void *arg) {
- UNUSED(arg);
-
- while (atomic_load(&scheduled) != loopmgr->nloops) {
+shutdown_loopmgr(void *arg ISC_ATTR_UNUSED) {
+ while (atomic_load(&scheduled) != isc_loopmgr_nloops()) {
isc_thread_yield();
}
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
ISC_RUN_TEST_IMPL(isc_loopmgr) {
atomic_store(&scheduled, 0);
- isc_loopmgr_setup(loopmgr, count, loopmgr);
- isc_loop_setup(mainloop, shutdown_loopmgr, loopmgr);
+ isc_loopmgr_setup(count, NULL);
+ isc_loop_setup(isc_loop_main(), shutdown_loopmgr, NULL);
- isc_loopmgr_run(loopmgr);
+ isc_loopmgr_run();
- assert_int_equal(atomic_load(&scheduled), loopmgr->nloops);
+ assert_int_equal(atomic_load(&scheduled), isc_loopmgr_nloops());
}
static void
runjob(void *arg ISC_ATTR_UNUSED) {
- isc_async_current(count, loopmgr);
+ isc_async_current(count, NULL);
if (isc_tid() == 0) {
- isc_async_current(shutdown_loopmgr, loopmgr);
+ isc_async_current(shutdown_loopmgr, NULL);
}
}
ISC_RUN_TEST_IMPL(isc_loopmgr_runjob) {
atomic_store(&scheduled, 0);
- isc_loopmgr_setup(loopmgr, runjob, loopmgr);
- isc_loopmgr_run(loopmgr);
- assert_int_equal(atomic_load(&scheduled), loopmgr->nloops);
+ isc_loopmgr_setup(runjob, NULL);
+ isc_loopmgr_run();
+ assert_int_equal(atomic_load(&scheduled), isc_loopmgr_nloops());
}
static void
-pause_loopmgr(void *arg) {
- UNUSED(arg);
+pause_loopmgr(void *arg ISC_ATTR_UNUSED) {
+ isc_loopmgr_pause();
- isc_loopmgr_pause(loopmgr);
+ assert_true(isc_loopmgr_paused());
- assert_true(atomic_load(&loopmgr->paused));
-
- for (size_t i = 0; i < loopmgr->nloops; i++) {
- isc_loop_t *loop = &loopmgr->loops[i];
+ for (size_t i = 0; i < isc_loopmgr_nloops(); i++) {
+ isc_loop_t *loop = isc_loop_get(i);
assert_true(loop->paused);
}
- atomic_init(&scheduled, loopmgr->nloops);
+ atomic_init(&scheduled, isc_loopmgr_nloops());
- isc_loopmgr_resume(loopmgr);
+ isc_loopmgr_resume();
}
ISC_RUN_TEST_IMPL(isc_loopmgr_pause) {
- isc_loop_setup(mainloop, pause_loopmgr, loopmgr);
- isc_loop_setup(mainloop, shutdown_loopmgr, loopmgr);
- isc_loopmgr_run(loopmgr);
+ isc_loop_setup(isc_loop_main(), pause_loopmgr, NULL);
+ isc_loop_setup(isc_loop_main(), shutdown_loopmgr, NULL);
+ isc_loopmgr_run();
}
static void
-send_sigint(void *arg) {
- UNUSED(arg);
-
+send_sigint(void *arg ISC_ATTR_UNUSED) {
kill(getpid(), SIGINT);
}
ISC_RUN_TEST_IMPL(isc_loopmgr_sigint) {
- isc_loop_setup(mainloop, send_sigint, loopmgr);
- isc_loopmgr_run(loopmgr);
+ isc_loop_setup(isc_loop_main(), send_sigint, NULL);
+ isc_loopmgr_run();
}
static void
-send_sigterm(void *arg) {
- UNUSED(arg);
-
+send_sigterm(void *arg ISC_ATTR_UNUSED) {
kill(getpid(), SIGINT);
}
ISC_RUN_TEST_IMPL(isc_loopmgr_sigterm) {
- isc_loop_setup(mainloop, send_sigterm, loopmgr);
- isc_loopmgr_run(loopmgr);
+ isc_loop_setup(isc_loop_main(), send_sigterm, NULL);
+ isc_loopmgr_run();
}
ISC_TEST_LIST_START
*/
#include <openssl/err.h>
+#include "isc/loop.h"
+
#define UNIT_TESTING
#include <cmocka.h>
isc_nonce_buf(&send_magic, sizeof(send_magic));
setup_loopmgr(state);
- isc_netmgr_create(mctx, loopmgr, &listen_nm);
+ isc_netmgr_create(mctx, &listen_nm);
assert_non_null(listen_nm);
isc_nm_setinitialtimeout(listen_nm, T_INIT);
isc_nm_setprimariestimeout(listen_nm, T_PRIMARIES);
isc_nm_setkeepalivetimeout(listen_nm, T_KEEPALIVE);
isc_nm_setadvertisedtimeout(listen_nm, T_ADVERTISED);
- isc_netmgr_create(mctx, loopmgr, &connect_nm);
+ isc_netmgr_create(mctx, &connect_nm);
assert_non_null(connect_nm);
isc_nm_setinitialtimeout(connect_nm, T_INIT);
isc_nm_setprimariestimeout(connect_nm, T_PRIMARIES);
break;
case ISC_R_SUCCESS:
if (have_expected_csends(atomic_fetch_add(&csends, 1) + 1)) {
- do_csends_shutdown(loopmgr);
+ do_csends_shutdown();
}
break;
default:
assert_true(magic == send_magic);
if (have_expected_creads(atomic_fetch_add(&creads, 1) + 1)) {
- do_creads_shutdown(loopmgr);
+ do_creads_shutdown();
}
if (magic == send_magic && allow_send_back) {
/* We are finished, initiate the shutdown */
if (have_expected_cconnects(atomic_fetch_add(&cconnects, 1) + 1)) {
- do_cconnects_shutdown(loopmgr);
+ do_cconnects_shutdown();
} else if (do_send) {
isc_async_current(stream_recv_send_connect,
cbarg == NULL
break;
case ISC_R_SUCCESS:
if (have_expected_ssends(atomic_fetch_add(&ssends, 1) + 1)) {
- do_ssends_shutdown(loopmgr);
+ do_ssends_shutdown();
}
break;
default:
assert_true(magic == send_magic);
if (have_expected_sreads(atomic_fetch_add(&sreads, 1) + 1)) {
- do_sreads_shutdown(loopmgr);
+ do_sreads_shutdown();
}
assert_true(region->length >= sizeof(magic));
}
if (have_expected_saccepts(atomic_fetch_add(&saccepts, 1) + 1)) {
- do_saccepts_shutdown(loopmgr);
+ do_saccepts_shutdown();
}
isc_nmhandle_attach(handle, &(isc_nmhandle_t *){ NULL });
}
if (have_expected_saccepts(atomic_fetch_add(&saccepts, 1) + 1)) {
- do_saccepts_shutdown(loopmgr);
+ do_saccepts_shutdown();
}
if (stream_use_PROXY) {
isc_refcount_decrement(&active_creads);
isc_nmhandle_detach(&handle);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
isc_quota_t *
assert_int_equal(eresult, ISC_R_SUCCESS);
if (have_expected_cconnects(atomic_fetch_add(&cconnects, 1) + 1)) {
- do_cconnects_shutdown(loopmgr);
+ do_cconnects_shutdown();
return;
}
}
result = stream_listen(noop_accept_cb, NULL, 128, NULL, &listen_sock);
assert_int_equal(result, ISC_R_SUCCESS);
- isc_loop_teardown(mainloop, stop_listening, listen_sock);
+ isc_loop_teardown(isc_loop_main(), stop_listening, listen_sock);
connect_readcb = NULL;
stream_connect(connect_success_cb, NULL, T_CONNECT);
isc_refcount_decrement(&active_creads);
isc_nmhandle_detach(&handle);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
static void
result = stream_listen(noop_accept_cb, NULL, 128, NULL, &listen_sock);
assert_int_equal(result, ISC_R_SUCCESS);
- isc_loop_teardown(mainloop, stop_listening, listen_sock);
+ isc_loop_teardown(isc_loop_main(), stop_listening, listen_sock);
stream_connect(noresponse_connectcb, NULL, T_CONNECT);
}
noanswer = true;
result = stream_listen(stream_accept_cb, NULL, 128, NULL, &listen_sock);
assert_int_equal(result, ISC_R_SUCCESS);
- isc_loop_teardown(mainloop, stop_listening, listen_sock);
+ isc_loop_teardown(isc_loop_main(), stop_listening, listen_sock);
/*
* Shorten all the client timeouts to 0.05 seconds.
result = stream_listen(stream_accept_cb, NULL, 128, quotap,
&listen_sock);
assert_int_equal(result, ISC_R_SUCCESS);
- isc_loop_teardown(mainloop, stop_listening, listen_sock);
+ isc_loop_teardown(isc_loop_main(), stop_listening, listen_sock);
stream_connect(connect_connect_cb, NULL, T_CONNECT);
}
result = stream_listen(stream_accept_cb, NULL, 128, quotap,
&listen_sock);
assert_int_equal(result, ISC_R_SUCCESS);
- isc_loop_teardown(mainloop, stop_listening, listen_sock);
+ isc_loop_teardown(isc_loop_main(), stop_listening, listen_sock);
stream_connect(connect_connect_cb, NULL, T_CONNECT);
result = stream_listen(stream_accept_cb, NULL, 128, quotap,
&listen_sock);
assert_int_equal(result, ISC_R_SUCCESS);
- isc_loop_teardown(mainloop, stop_listening, listen_sock);
+ isc_loop_teardown(isc_loop_main(), stop_listening, listen_sock);
for (size_t i = 0; i < workers; i++) {
- isc_async_run(isc_loop_get(loopmgr, i),
- stream_recv_send_connect,
+ isc_async_run(isc_loop_get(i), stream_recv_send_connect,
get_stream_connect_function());
}
}
assert_int_equal(result, ISC_R_SUCCESS);
- isc_loop_teardown(mainloop, stop_listening, listen_sock);
+ isc_loop_teardown(isc_loop_main(), stop_listening, listen_sock);
}
static void
if (have_expected_csends(atomic_fetch_add(&csends, 1) + 1)) {
if (csends_shutdown) {
isc_nm_cancelread(handle);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
}
break;
assert_true(magic == send_magic);
if (have_expected_creads(atomic_fetch_add(&creads, 1) + 1)) {
- do_creads_shutdown(loopmgr);
+ do_creads_shutdown();
}
if (magic == send_magic && allow_send_back) {
if (have_expected_cconnects(atomic_fetch_add(&cconnects, 1) +
1))
{
- do_cconnects_shutdown(loopmgr);
+ do_cconnects_shutdown();
} else if (do_send) {
isc_async_current(udp_enqueue_connect, cbarg);
}
isc_nmhandle_detach(&handle);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
static void
isc_nmhandle_detach(&handle);
atomic_fetch_add(&creads, 1);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
static void
void
udp_shutdown_connect(void **arg ISC_ATTR_UNUSED) {
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
/*
* isc_nm_udpconnect() is synchronous, so we need to launch this on the
* async loop.
atomic_fetch_add(&csends, 1);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
isc_nmhandle_detach(&handle);
isc_refcount_decrement(&active_csends);
case ISC_R_CANCELED:
/* The read has been canceled */
atomic_fetch_add(&creads, 1);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
break;
default:
UNREACHABLE();
udp_start_listening(ISC_NM_LISTEN_ALL, udp_listen_read_cb);
for (size_t i = 0; i < workers; i++) {
- isc_async_run(isc_loop_get(loopmgr, i), udp_enqueue_connect,
- NULL);
+ isc_async_run(isc_loop_get(i), udp_enqueue_connect, NULL);
}
}
switch (eresult) {
case ISC_R_SUCCESS:
if (have_expected_ssends(atomic_fetch_add(&ssends, 1) + 1)) {
- do_ssends_shutdown(loopmgr);
+ do_ssends_shutdown();
} else {
isc_nmhandle_t *sendhandle = NULL;
isc_nmhandle_attach(handle, &sendhandle);
assert_true(magic == send_magic);
if (have_expected_creads(atomic_fetch_add(&creads, 1) + 1)) {
- do_creads_shutdown(loopmgr);
+ do_creads_shutdown();
detach = true;
}
ISC_LOOP_TEST_IMPL(ratelimiter_create) {
assert_null(rl);
expect_assert_failure(isc_ratelimiter_create(NULL, &rl));
- expect_assert_failure(isc_ratelimiter_create(mainloop, NULL));
+ expect_assert_failure(isc_ratelimiter_create(isc_loop_main(), NULL));
assert_null(rl);
- isc_ratelimiter_create(mainloop, &rl);
+ isc_ratelimiter_create(isc_loop_main(), &rl);
isc_ratelimiter_shutdown(rl);
isc_ratelimiter_detach(&rl);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
ISC_LOOP_TEST_IMPL(ratelimiter_shutdown) {
expect_assert_failure(isc_ratelimiter_shutdown(NULL));
expect_assert_failure(isc_ratelimiter_shutdown(rl));
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
ISC_LOOP_TEST_IMPL(ratelimiter_detach) {
expect_assert_failure(isc_ratelimiter_detach(NULL));
expect_assert_failure(isc_ratelimiter_detach(&rl));
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
static int ticks = 0;
isc_ratelimiter_shutdown(rl);
isc_ratelimiter_detach(&rl);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
ISC_LOOP_SETUP_IMPL(ratelimiter_common) {
assert_null(rl);
isc_time_set(&tick_time, 0, 0);
start_time = isc_time_now();
- isc_ratelimiter_create(mainloop, &rl);
+ isc_ratelimiter_create(isc_loop_main(), &rl);
}
ISC_LOOP_SETUP_IMPL(ratelimiter_enqueue) {
rlstat_t *rlstat = isc_mem_get(mctx, sizeof(*rlstat));
*rlstat = (rlstat_t){ 0 };
- result = isc_ratelimiter_enqueue(rl, mainloop, tick, rlstat,
+ result = isc_ratelimiter_enqueue(rl, isc_loop_main(), tick, rlstat,
&rlstat->event);
assert_int_equal(result, ISC_R_SUCCESS);
assert_non_null(rlstat->event);
rlstat_t *rlstat = isc_mem_get(mctx, sizeof(*rlstat));
*rlstat = (rlstat_t){ 0 };
- expect_assert_failure(
- isc_ratelimiter_enqueue(NULL, mainloop, tick, NULL, &event));
+ expect_assert_failure(isc_ratelimiter_enqueue(NULL, isc_loop_main(),
+ tick, NULL, &event));
expect_assert_failure(
isc_ratelimiter_enqueue(rl, NULL, tick, NULL, &event));
expect_assert_failure(
- isc_ratelimiter_enqueue(rl, mainloop, tick, NULL, NULL));
+ isc_ratelimiter_enqueue(rl, isc_loop_main(), tick, NULL, NULL));
- assert_int_equal(isc_ratelimiter_enqueue(rl, mainloop, tick, rlstat,
- &rlstat->event),
+ assert_int_equal(isc_ratelimiter_enqueue(rl, isc_loop_main(), tick,
+ rlstat, &rlstat->event),
ISC_R_SUCCESS);
assert_non_null(rlstat->event);
isc_ratelimiter_shutdown(rl);
- assert_int_equal(
- isc_ratelimiter_enqueue(rl, mainloop, tick, NULL, &event),
- ISC_R_SHUTTINGDOWN);
+ assert_int_equal(isc_ratelimiter_enqueue(rl, isc_loop_main(), tick,
+ NULL, &event),
+ ISC_R_SHUTTINGDOWN);
assert_null(event);
}
rlstat_t *rlstat = isc_mem_get(mctx, sizeof(*rlstat));
*rlstat = (rlstat_t){ 0 };
- assert_int_equal(isc_ratelimiter_enqueue(rl, mainloop, tick, rlstat,
- &rlstat->event),
+ assert_int_equal(isc_ratelimiter_enqueue(rl, isc_loop_main(), tick,
+ rlstat, &rlstat->event),
ISC_R_SUCCESS);
assert_int_equal(isc_ratelimiter_dequeue(rl, &rlstat->event),
ISC_R_SUCCESS);
/* Set up a mock ratelimiter event that isn't actually scheduled */
*fake = (isc_rlevent_t){ .link = ISC_LINK_INITIALIZER };
- isc_loop_attach(mainloop, &fake->loop);
+ isc_loop_attach(isc_loop_main(), &fake->loop);
isc_ratelimiter_attach(rl, &fake->rl);
assert_int_equal(isc_ratelimiter_dequeue(rl, &fake), ISC_R_NOTFOUND);
isc_loop_detach(&fake->loop);
isc_ratelimiter_shutdown(rl);
isc_ratelimiter_detach(&rl);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
static isc_time_t tock_time;
rlstat = isc_mem_get(mctx, sizeof(*rlstat));
*rlstat = (rlstat_t){ 0 };
- assert_int_equal(isc_ratelimiter_enqueue(rl, mainloop, tock, rlstat,
- &rlstat->event),
+ assert_int_equal(isc_ratelimiter_enqueue(rl, isc_loop_main(), tock,
+ rlstat, &rlstat->event),
ISC_R_SUCCESS);
rlstat = isc_mem_get(mctx, sizeof(*rlstat));
*rlstat = (rlstat_t){ 0 };
- assert_int_equal(isc_ratelimiter_enqueue(rl, mainloop, tick, rlstat,
- &rlstat->event),
+ assert_int_equal(isc_ratelimiter_enqueue(rl, isc_loop_main(), tick,
+ rlstat, &rlstat->event),
ISC_R_SUCCESS);
}
rlstat = isc_mem_get(mctx, sizeof(*rlstat));
*rlstat = (rlstat_t){ 0 };
- assert_int_equal(isc_ratelimiter_enqueue(rl, mainloop, tock, rlstat,
- &rlstat->event),
+ assert_int_equal(isc_ratelimiter_enqueue(rl, isc_loop_main(), tock,
+ rlstat, &rlstat->event),
ISC_R_SUCCESS);
rlstat = isc_mem_get(mctx, sizeof(*rlstat));
*rlstat = (rlstat_t){ 0 };
- assert_int_equal(isc_ratelimiter_enqueue(rl, mainloop, tick, rlstat,
- &rlstat->event),
+ assert_int_equal(isc_ratelimiter_enqueue(rl, isc_loop_main(), tick,
+ rlstat, &rlstat->event),
ISC_R_SUCCESS);
}
isc_result_t result = stream_listen(stream_accept_cb, NULL, 128, NULL,
&listen_sock);
assert_int_equal(result, ISC_R_SUCCESS);
- isc_loop_teardown(mainloop, stop_listening, listen_sock);
+ isc_loop_teardown(isc_loop_main(), stop_listening, listen_sock);
/* Schedule the shutdown before the connect */
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
stream_connect(shutdownconnect_connectcb, NULL, T_CONNECT);
}
atomic_fetch_add(&cconnects, 1);
/* Schedule the shutdown before read and send */
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
isc_refcount_increment0(&active_creads);
isc_nmhandle_ref(handle);
isc_result_t result = stream_listen(stream_accept_cb, NULL, 128, NULL,
&listen_sock);
assert_int_equal(result, ISC_R_SUCCESS);
- isc_loop_teardown(mainloop, stop_listening, listen_sock);
+ isc_loop_teardown(isc_loop_main(), stop_listening, listen_sock);
stream_connect(shutdownread_connectcb, NULL, T_CONNECT);
}
NULL, 128, NULL, NULL, get_proxy_type(), &listen_sock);
assert_int_equal(result, ISC_R_SUCCESS);
- isc_loop_teardown(mainloop, stop_listening, listen_sock);
+ isc_loop_teardown(isc_loop_main(), stop_listening, listen_sock);
}
static void
start_listening(ISC_NM_LISTEN_ALL, listen_accept_cb, listen_read_cb);
for (size_t i = 0; i < workers; i++) {
- isc_async_run(isc_loop_get(loopmgr, i),
- stream_recv_send_connect, tcpdns_connect);
+ isc_async_run(isc_loop_get(i), stream_recv_send_connect,
+ tcpdns_connect);
}
}
lasttime = isc_time_now();
UNLOCK(&lasttime_mx);
- isc_timer_create(mainloop, action, (void *)timertype, &timer);
+ isc_timer_create(isc_loop_main(), action, (void *)timertype, &timer);
isc_timer_start(timer, timertype, interval);
}
atomic_store(&errcnt, ISC_R_SUCCESS);
- isc_loop_setup(mainloop, setup_test_run, &arg);
- isc_loopmgr_run(loopmgr);
+ isc_loop_setup(isc_loop_main(), setup_test_run, &arg);
+ isc_loopmgr_run();
assert_int_equal(atomic_load(&errcnt), ISC_R_SUCCESS);
if (atomic_load(&eventcnt) == nevents) {
endtime = isc_time_now();
isc_timer_destroy(&timer);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
}
isc_mutex_unlock(&lasttime_mx);
isc_timer_destroy(&timer);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
/* timer type once idles out */
}
} else {
isc_timer_destroy(&timer);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
}
*/
if (tick == 0) {
isc_timer_destroy(&tickertimer);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
}
isc_interval_set(&interval, seconds, 0);
tickertimer = NULL;
- isc_timer_create(mainloop, tick_event, NULL, &tickertimer);
+ isc_timer_create(isc_loop_main(), tick_event, NULL, &tickertimer);
isc_timer_start(tickertimer, isc_timertype_ticker, &interval);
oncetimer = NULL;
isc_interval_set(&interval, (seconds * 2) + 1, 0);
- isc_timer_create(mainloop, once_event, NULL, &oncetimer);
+ isc_timer_create(isc_loop_main(), once_event, NULL, &oncetimer);
isc_timer_start(oncetimer, isc_timertype_once, &interval);
}
timer_event(void *arg ISC_ATTR_UNUSED) {
if (--timer_ticks == 0) {
isc_timer_destroy(&timer);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
timer_stop = isc_loop_now(isc_loop());
} else {
isc_timer_start(timer, timer_type, &timer_interval);
ISC_LOOP_TEST_CUSTOM_IMPL(reschedule_up, setup_loop_reschedule_up,
teardown_loop_timer_expect) {
- isc_timer_create(mainloop, timer_event, NULL, &timer);
+ isc_timer_create(isc_loop_main(), timer_event, NULL, &timer);
/* Schedule the timer to fire immediately */
isc_interval_set(&timer_interval, 0, 0);
ISC_LOOP_TEST_CUSTOM_IMPL(reschedule_down, setup_loop_reschedule_down,
teardown_loop_timer_expect) {
- isc_timer_create(mainloop, timer_event, NULL, &timer);
+ isc_timer_create(isc_loop_main(), timer_event, NULL, &timer);
/* Schedule the timer to fire at 10 seconds */
isc_interval_set(&timer_interval, 10, 0);
ISC_LOOP_TEST_CUSTOM_IMPL(reschedule_from_callback,
setup_loop_reschedule_from_callback,
teardown_loop_timer_expect) {
- isc_timer_create(mainloop, timer_event, NULL, &timer);
+ isc_timer_create(isc_loop_main(), timer_event, NULL, &timer);
isc_interval_set(&timer_interval, 0, NS_PER_SEC / 2);
isc_timer_start(timer, timer_type, &timer_interval);
}
ISC_LOOP_TEST_CUSTOM_IMPL(zero, setup_loop_zero, teardown_loop_timer_expect) {
- isc_timer_create(mainloop, timer_event, NULL, &timer);
+ isc_timer_create(isc_loop_main(), timer_event, NULL, &timer);
/* Schedule the timer to fire immediately (in the next event loop) */
isc_interval_set(&timer_interval, 0, 0);
ISC_LOOP_TEST_CUSTOM_IMPL(reschedule_ticker, setup_loop_reschedule_ticker,
teardown_loop_timer_expect) {
- isc_timer_create(mainloop, timer_event, NULL, &timer);
+ isc_timer_create(isc_loop_main(), timer_event, NULL, &timer);
/* Schedule the timer to fire immediately (in the next event loop) */
isc_interval_set(&timer_interval, 0, 0);
&listen_sock);
assert_int_equal(result, ISC_R_SUCCESS);
- isc_loop_teardown(mainloop, stop_listening, listen_sock);
+ isc_loop_teardown(isc_loop_main(), stop_listening, listen_sock);
}
static void
start_listening(ISC_NM_LISTEN_ALL, listen_accept_cb, listen_read_cb);
for (size_t i = 0; i < workers; i++) {
- isc_async_run(isc_loop_get(loopmgr, i),
- stream_recv_send_connect, tlsdns_connect);
+ isc_async_run(isc_loop_get(i), stream_recv_send_connect,
+ tlsdns_connect);
}
}
isc_refcount_decrement(&active_cconnects);
assert_int_equal(eresult, ISC_R_NOMEMORY);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
/* UDP */
RESET_RETURN;
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
ISC_LOOP_TEST_IMPL(mock_listenudp_uv_udp_bind) {
RESET_RETURN;
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
ISC_LOOP_TEST_IMPL(mock_listenudp_uv_udp_recv_start) {
RESET_RETURN;
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
ISC_LOOP_TEST_IMPL(mock_udpconnect_uv_udp_open) {
isc_refcount_increment0(&active_cconnects);
isc_nm_udpconnect(netmgr, &udp_connect_addr, &udp_listen_addr,
udp_connect_nomemory_cb, NULL, UDP_T_CONNECT);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
RESET_RETURN;
}
isc_refcount_increment0(&active_cconnects);
isc_nm_udpconnect(netmgr, &udp_connect_addr, &udp_listen_addr,
udp_connect_nomemory_cb, NULL, UDP_T_CONNECT);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
RESET_RETURN;
}
isc_refcount_increment0(&active_cconnects);
isc_nm_udpconnect(netmgr, &udp_connect_addr, &udp_listen_addr,
udp_connect_nomemory_cb, NULL, UDP_T_CONNECT);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
RESET_RETURN;
}
isc_refcount_increment0(&active_cconnects);
isc_nm_udpconnect(netmgr, &udp_connect_addr, &udp_listen_addr,
connect_success_cb, NULL, UDP_T_CONNECT);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
RESET_RETURN;
}
isc_refcount_increment0(&active_cconnects);
isc_nm_udpconnect(netmgr, &udp_connect_addr, &udp_listen_addr,
connect_success_cb, NULL, UDP_T_CONNECT);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
RESET_RETURN;
}
static atomic_uint scheduled = 0;
static void
-work_cb(void *arg) {
- UNUSED(arg);
-
+work_cb(void *arg ISC_ATTR_UNUSED) {
atomic_fetch_add(&scheduled, 1);
assert_int_equal(isc_tid(), ISC_TID_UNKNOWN);
}
static void
-after_work_cb(void *arg) {
- UNUSED(arg);
-
+after_work_cb(void *arg ISC_ATTR_UNUSED) {
assert_int_equal(atomic_load(&scheduled), 1);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loopmgr_shutdown();
}
static void
-work_enqueue_cb(void *arg) {
- UNUSED(arg);
- isc_tid_t tid = isc_loopmgr_nloops(loopmgr) - 1;
+work_enqueue_cb(void *arg ISC_ATTR_UNUSED) {
+ isc_tid_t tid = isc_loopmgr_nloops() - 1;
- isc_loop_t *loop = isc_loop_get(loopmgr, tid);
+ isc_loop_t *loop = isc_loop_get(tid);
- isc_work_enqueue(loop, work_cb, after_work_cb, loopmgr);
+ isc_work_enqueue(loop, work_cb, after_work_cb, NULL);
}
ISC_RUN_TEST_IMPL(isc_work_enqueue) {
atomic_init(&scheduled, 0);
- isc_loop_setup(isc_loop_main(loopmgr), work_enqueue_cb, loopmgr);
+ isc_loop_setup(isc_loop_main(), work_enqueue_cb, NULL);
- isc_loopmgr_run(loopmgr);
+ isc_loopmgr_run();
assert_int_equal(atomic_load(&scheduled), 1);
}
dns_dispatchmgr_t *dispatchmgr = NULL;
if (with_dispatchmgr) {
- result = dns_dispatchmgr_create(mctx, loopmgr, netmgr,
- &dispatchmgr);
+ result = dns_dispatchmgr_create(mctx, netmgr, &dispatchmgr);
if (result != ISC_R_SUCCESS) {
return result;
}
}
- dns_view_create(mctx, loopmgr, dispatchmgr, dns_rdataclass_in, name,
- &view);
+ dns_view_create(mctx, dispatchmgr, dns_rdataclass_in, name, &view);
if (dispatchmgr != NULL) {
dns_dispatchmgr_detach(&dispatchmgr);
}
if (with_cache) {
- result = dns_cache_create(loopmgr, dns_rdataclass_in, "", mctx,
- &cache);
+ result = dns_cache_create(dns_rdataclass_in, "", mctx, &cache);
if (result != ISC_R_SUCCESS) {
dns_view_detach(&view);
return result;
#include <tests/isc.h>
isc_mem_t *mctx = NULL;
-isc_loop_t *mainloop = NULL;
-isc_loopmgr_t *loopmgr = NULL;
isc_nm_t *netmgr = NULL;
unsigned int workers = 0;
bool debug = false;
setup_workers(state);
- isc_loopmgr_create(mctx, workers, &loopmgr);
- mainloop = isc_loop_main(loopmgr);
+ isc_loopmgr_create(mctx, workers);
return 0;
}
teardown_loopmgr(void **state ISC_ATTR_UNUSED) {
REQUIRE(netmgr == NULL);
- mainloop = NULL;
- isc_loopmgr_destroy(&loopmgr);
+ isc_loopmgr_destroy();
return 0;
}
int
setup_netmgr(void **state ISC_ATTR_UNUSED) {
- REQUIRE(loopmgr != NULL);
-
adjustnofile();
- isc_netmgr_create(mctx, loopmgr, &netmgr);
+ isc_netmgr_create(mctx, &netmgr);
return 0;
}
int
teardown_netmgr(void **state ISC_ATTR_UNUSED) {
- REQUIRE(loopmgr != NULL);
-
isc_nm_detach(&netmgr);
return 0;
ns_server_create(mctx, matchview, &sctx);
- result = dns_dispatchmgr_create(mctx, loopmgr, netmgr, &dispatchmgr);
+ result = dns_dispatchmgr_create(mctx, netmgr, &dispatchmgr);
if (result != ISC_R_SUCCESS) {
goto cleanup;
}
- result = ns_interfacemgr_create(mctx, sctx, loopmgr, netmgr,
- dispatchmgr, NULL, &interfacemgr);
+ result = ns_interfacemgr_create(mctx, sctx, netmgr, dispatchmgr, NULL,
+ &interfacemgr);
if (result != ISC_R_SUCCESS) {
goto cleanup;
}
- isc_loop_setup(mainloop, scan_interfaces, NULL);
+ isc_loop_setup(isc_loop_main(), scan_interfaces, NULL);
return 0;
isc_nmhandle_detach(&client->inner.handle);
isc_nmhandle_detach(&handle);
- isc_loop_teardown(mainloop, shutdown_interfacemgr, NULL);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loop_teardown(isc_loop_main(), shutdown_interfacemgr, NULL);
+ isc_loopmgr_shutdown();
}
ISC_TEST_LIST_START
run_sfcache_test(&tests[i]);
}
- isc_loop_teardown(mainloop, shutdown_interfacemgr, NULL);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loop_teardown(isc_loop_main(), shutdown_interfacemgr, NULL);
+ isc_loopmgr_shutdown();
}
/*****
run_start_test(&tests[i]);
}
- isc_loop_teardown(mainloop, shutdown_interfacemgr, NULL);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loop_teardown(isc_loop_main(), shutdown_interfacemgr, NULL);
+ isc_loopmgr_shutdown();
}
/*****
run_hookasync_test(&tests[i]);
}
- isc_loop_teardown(mainloop, shutdown_interfacemgr, NULL);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loop_teardown(isc_loop_main(), shutdown_interfacemgr, NULL);
+ isc_loopmgr_shutdown();
}
/*****
run_hookasync_e2e_test(&tests[i]);
}
- isc_loop_teardown(mainloop, shutdown_interfacemgr, NULL);
- isc_loopmgr_shutdown(loopmgr);
+ isc_loop_teardown(isc_loop_main(), shutdown_interfacemgr, NULL);
+ isc_loopmgr_shutdown();
}
ISC_TEST_LIST_START
projects / thirdparty / bind9.git / commitdiff
