diff --git a/bin/delv/delv.c b/bin/delv/delv.c index 487d4f0f3e..82bdef9845 100644 --- a/bin/delv/delv.c +++ b/bin/delv/delv.c @@ -1828,7 +1828,7 @@ main(int argc, char *argv[]) { /* Create client */ isc_tlsctx_cache_create(mctx, &tlsctx_client_cache); - result = dns_client_create(mctx, loopmgr, taskmgr, netmgr, 0, + result = dns_client_create(mctx, loopmgr, netmgr, 0, tlsctx_client_cache, &client, srcaddr4, srcaddr6); if (result != ISC_R_SUCCESS) { diff --git a/bin/named/server.c b/bin/named/server.c index 4176987b8c..9c84d1b49b 100644 --- a/bin/named/server.c +++ b/bin/named/server.c @@ -1120,7 +1120,7 @@ configure_view_dnsseckeys(dns_view_t *view, const cfg_obj_t *vconfig, return (ISC_R_UNEXPECTED); } - result = dns_view_initntatable(view, named_g_taskmgr, named_g_loopmgr); + result = dns_view_initntatable(view, named_g_loopmgr); if (result != ISC_R_SUCCESS) { isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR, @@ -4756,9 +4756,9 @@ configure_view(dns_view_t *view, dns_viewlist_t *viewlist, cfg_obj_t *config, ndisp = 4 * ISC_MIN(named_g_udpdisp, MAX_UDP_DISPATCH); CHECK(dns_view_createresolver( - view, named_g_loopmgr, named_g_taskmgr, ndisp, named_g_netmgr, - resopts, named_g_server->tlsctx_client_cache, - named_g_dispatchmgr, dispatch4, dispatch6)); + view, named_g_loopmgr, ndisp, named_g_netmgr, resopts, + named_g_server->tlsctx_client_cache, named_g_dispatchmgr, + dispatch4, dispatch6)); if (resstats == NULL) { CHECK(isc_stats_create(mctx, &resstats, @@ -7113,7 +7113,7 @@ heartbeat_timer_tick(void *arg) { typedef struct { isc_mem_t *mctx; - isc_task_t *task; + isc_loop_t *loop; dns_fetch_t *fetch; dns_view_t *view; dns_fixedname_t tatname; @@ -7136,26 +7136,24 @@ cid(const void *a, const void *b) { } static void -tat_done(isc_task_t *task, isc_event_t *event) { - dns_fetchevent_t *devent; - ns_tat_t *tat; +tat_done(void *arg) { + dns_fetchresponse_t *resp = (dns_fetchresponse_t *)arg; + ns_tat_t *tat = NULL; - INSIST(event != NULL && event->ev_type == DNS_EVENT_FETCHDONE); - INSIST(event->ev_arg != NULL); + INSIST(resp != NULL && resp->type == FETCHDONE); - UNUSED(task); + tat = resp->arg; - tat = event->ev_arg; - devent = (dns_fetchevent_t *)event; + INSIST(tat != NULL); /* Free resources which are not of interest */ - if (devent->node != NULL) { - dns_db_detachnode(devent->db, &devent->node); + if (resp->node != NULL) { + dns_db_detachnode(resp->db, &resp->node); } - if (devent->db != NULL) { - dns_db_detach(&devent->db); + if (resp->db != NULL) { + dns_db_detach(&resp->db); } - isc_event_free(&event); + isc_mem_putanddetach(&resp->mctx, resp, sizeof(*resp)); dns_resolver_destroyfetch(&tat->fetch); if (dns_rdataset_isassociated(&tat->rdataset)) { dns_rdataset_disassociate(&tat->rdataset); @@ -7164,13 +7162,12 @@ tat_done(isc_task_t *task, isc_event_t *event) { dns_rdataset_disassociate(&tat->sigrdataset); } dns_view_detach(&tat->view); - isc_task_detach(&tat->task); isc_mem_putanddetach(&tat->mctx, tat, sizeof(*tat)); } struct dotat_arg { dns_view_t *view; - isc_task_t *task; + isc_loop_t *loop; }; /*% @@ -7295,7 +7292,7 @@ tat_send(void *arg) { result = dns_resolver_createfetch( tat->view->resolver, tatname, dns_rdatatype_null, domain, &nameservers, NULL, NULL, 0, 0, 0, NULL, - tat->task, tat_done, tat, &tat->rdataset, + tat->loop, tat_done, tat, &tat->rdataset, &tat->sigrdataset, &tat->fetch); } @@ -7316,7 +7313,6 @@ tat_send(void *arg) { if (result != ISC_R_SUCCESS) { dns_view_detach(&tat->view); - isc_task_detach(&tat->task); isc_mem_putanddetach(&tat->mctx, tat, sizeof(*tat)); } } @@ -7348,7 +7344,7 @@ dotat(dns_keytable_t *keytable, dns_keynode_t *keynode, dns_name_t *keyname, return; } isc_mem_attach(view->mctx, &tat->mctx); - isc_task_attach(dotat_arg->task, &tat->task); + tat->loop = dotat_arg->loop; dns_view_attach(view, &tat->view); /* @@ -7389,7 +7385,7 @@ tat_timer_tick(void *arg) { } dotat_arg.view = view; - dotat_arg.task = server->task; + dotat_arg.loop = named_g_mainloop; (void)dns_keytable_forall(secroots, dotat, &dotat_arg); dns_keytable_detach(&secroots); } diff --git a/lib/dns/adb.c b/lib/dns/adb.c index a0e0101e56..02e713df1c 100644 --- a/lib/dns/adb.c +++ b/lib/dns/adb.c @@ -102,10 +102,8 @@ struct dns_adb { isc_mem_t *hmctx; dns_view_t *view; dns_resolver_t *res; - size_t nloops; - isc_taskmgr_t *taskmgr; - isc_task_t **tasks; + isc_loopmgr_t *loopmgr; isc_refcount_t references; @@ -667,12 +665,14 @@ import_rdataset(dns_adbname_t *adbname, dns_rdataset_t *rdataset, */ static void expire_name(dns_adbname_t *adbname, dns_adbstatus_t astat) { - REQUIRE(DNS_ADBNAME_VALID(adbname)); - REQUIRE(DNS_ADB_VALID(adbname->adb)); - isc_result_t result; + + REQUIRE(DNS_ADBNAME_VALID(adbname)); + dns_adb_t *adb = adbname->adb; + REQUIRE(DNS_ADB_VALID(adb)); + DP(DEF_LEVEL, "killing name %p", adbname); /* @@ -704,7 +704,7 @@ expire_name(dns_adbname_t *adbname, dns_adbstatus_t astat) { /* ... and LRU list */ ISC_LIST_UNLINK(adb->names_lru, adbname, link); - dns_adbname_detach(&adbname); + dns_adbname_unref(adbname); } /* @@ -1913,11 +1913,6 @@ destroy(dns_adb_t *adb) { isc_mutex_destroy(&adb->lock); isc_refcount_destroy(&adb->references); - for (size_t i = 0; i < adb->nloops; i++) { - isc_task_detach(&adb->tasks[i]); - } - isc_mem_put(adb->mctx, adb->tasks, adb->nloops * sizeof(adb->tasks[0])); - isc_stats_detach(&adb->stats); dns_resolver_detach(&adb->res); dns_view_weakdetach(&adb->view); @@ -1936,19 +1931,17 @@ ISC_REFCOUNT_IMPL(dns_adb, destroy); isc_result_t dns_adb_create(isc_mem_t *mem, dns_view_t *view, isc_loopmgr_t *loopmgr, - isc_taskmgr_t *taskmgr, dns_adb_t **newadb) { + dns_adb_t **newadb) { dns_adb_t *adb = NULL; isc_result_t result; REQUIRE(mem != NULL); REQUIRE(view != NULL); - REQUIRE(taskmgr != NULL); REQUIRE(newadb != NULL && *newadb == NULL); adb = isc_mem_get(mem, sizeof(dns_adb_t)); *adb = (dns_adb_t){ - .taskmgr = taskmgr, - .nloops = isc_loopmgr_nloops(loopmgr), + .loopmgr = loopmgr, .names_lru = ISC_LIST_INITIALIZER, .entries_lru = ISC_LIST_INITIALIZER, }; @@ -1979,22 +1972,9 @@ dns_adb_create(isc_mem_t *mem, dns_view_t *view, isc_loopmgr_t *loopmgr, isc_mutex_init(&adb->lock); - /* - * Allocate an internal task. - */ - adb->tasks = isc_mem_getx( - adb->mctx, adb->nloops * sizeof(adb->tasks[0]), ISC_MEM_ZERO); - for (size_t i = 0; i < adb->nloops; i++) { - result = isc_task_create(adb->taskmgr, &adb->tasks[i], i); - if (result != ISC_R_SUCCESS) { - goto free_tasks; - } - isc_task_setname(adb->tasks[i], "ADB", adb); - } - result = isc_stats_create(adb->mctx, &adb->stats, dns_adbstats_max); if (result != ISC_R_SUCCESS) { - goto free_tasks; + goto free_lock; } set_adbstat(adb, 0, dns_adbstats_nnames); @@ -2007,14 +1987,7 @@ dns_adb_create(isc_mem_t *mem, dns_view_t *view, isc_loopmgr_t *loopmgr, *newadb = adb; return (ISC_R_SUCCESS); -free_tasks: - for (size_t i = 0; i < adb->nloops; i++) { - if (adb->tasks[i] != NULL) { - isc_task_detach(&adb->tasks[i]); - } - } - isc_mem_put(adb->mctx, adb->tasks, adb->nloops * sizeof(adb->tasks[0])); - +free_lock: isc_mutex_destroy(&adb->lock); isc_rwlock_destroy(&adb->entries_lock); @@ -2062,7 +2035,7 @@ dns_adb_shutdown(dns_adb_t *adb) { * structure for each found and append it to the linked list * of addresses for this header. * - * - Name found, queries pending. In this case, if a task was + * - Name found, queries pending. In this case, if a loop was * passed in, allocate a job id, attach it to the name's job * list and remember to tell the caller that there will be * more info coming later. @@ -2920,9 +2893,9 @@ dbfind_name(dns_adbname_t *adbname, isc_stdtime_t now, dns_rdatatype_t rdtype) { } static void -fetch_callback(isc_task_t *task, isc_event_t *ev) { - dns_fetchevent_t *dev = (dns_fetchevent_t *)ev; - dns_adbname_t *name = NULL; +fetch_callback(void *arg) { + dns_fetchresponse_t *resp = (dns_fetchresponse_t *)arg; + dns_adbname_t *name = resp->arg; dns_adb_t *adb = NULL; dns_adbfetch_t *fetch = NULL; dns_adbstatus_t astat = DNS_ADB_NOMOREADDRESSES; @@ -2930,10 +2903,6 @@ fetch_callback(isc_task_t *task, isc_event_t *ev) { isc_result_t result; unsigned int address_type; - UNUSED(task); - - name = ev->ev_arg; - REQUIRE(DNS_ADBNAME_VALID(name)); dns_adb_attach(name->adb, &adb); @@ -2943,12 +2912,12 @@ fetch_callback(isc_task_t *task, isc_event_t *ev) { INSIST(NAME_FETCH_A(name) || NAME_FETCH_AAAA(name)); address_type = 0; - if (NAME_FETCH_A(name) && (name->fetch_a->fetch == dev->fetch)) { + if (NAME_FETCH_A(name) && (name->fetch_a->fetch == resp->fetch)) { address_type = DNS_ADBFIND_INET; fetch = name->fetch_a; name->fetch_a = NULL; } else if (NAME_FETCH_AAAA(name) && - (name->fetch_aaaa->fetch == dev->fetch)) + (name->fetch_aaaa->fetch == resp->fetch)) { address_type = DNS_ADBFIND_INET6; fetch = name->fetch_aaaa; @@ -2962,11 +2931,11 @@ fetch_callback(isc_task_t *task, isc_event_t *ev) { /* * Cleanup things we don't care about. */ - if (dev->node != NULL) { - dns_db_detachnode(dev->db, &dev->node); + if (resp->node != NULL) { + dns_db_detachnode(resp->db, &resp->node); } - if (dev->db != NULL) { - dns_db_detach(&dev->db); + if (resp->db != NULL) { + dns_db_detach(&resp->db); } /* @@ -2983,16 +2952,16 @@ fetch_callback(isc_task_t *task, isc_event_t *ev) { /* * If we got a negative cache response, remember it. */ - if (NCACHE_RESULT(dev->result)) { - dev->rdataset->ttl = ttlclamp(dev->rdataset->ttl); + if (NCACHE_RESULT(resp->result)) { + resp->rdataset->ttl = ttlclamp(resp->rdataset->ttl); if (address_type == DNS_ADBFIND_INET) { DP(NCACHE_LEVEL, "adb fetch name %p: " "caching negative entry for A (ttl %u)", - name, dev->rdataset->ttl); + name, resp->rdataset->ttl); name->expire_v4 = ISC_MIN(name->expire_v4, - dev->rdataset->ttl + now); - if (dev->result == DNS_R_NCACHENXDOMAIN) { + resp->rdataset->ttl + now); + if (resp->result == DNS_R_NCACHENXDOMAIN) { name->fetch_err = FIND_ERR_NXDOMAIN; } else { name->fetch_err = FIND_ERR_NXRRSET; @@ -3002,10 +2971,10 @@ fetch_callback(isc_task_t *task, isc_event_t *ev) { DP(NCACHE_LEVEL, "adb fetch name %p: " "caching negative entry for AAAA (ttl %u)", - name, dev->rdataset->ttl); + name, resp->rdataset->ttl); name->expire_v6 = ISC_MIN(name->expire_v6, - dev->rdataset->ttl + now); - if (dev->result == DNS_R_NCACHENXDOMAIN) { + resp->rdataset->ttl + now); + if (resp->result == DNS_R_NCACHENXDOMAIN) { name->fetch6_err = FIND_ERR_NXDOMAIN; } else { name->fetch6_err = FIND_ERR_NXRRSET; @@ -3018,16 +2987,16 @@ fetch_callback(isc_task_t *task, isc_event_t *ev) { /* * Handle CNAME/DNAME. */ - if (dev->result == DNS_R_CNAME || dev->result == DNS_R_DNAME) { - dev->rdataset->ttl = ttlclamp(dev->rdataset->ttl); + if (resp->result == DNS_R_CNAME || resp->result == DNS_R_DNAME) { + resp->rdataset->ttl = ttlclamp(resp->rdataset->ttl); clean_target(adb, &name->target); name->expire_target = INT_MAX; - result = set_target(adb, &name->name, dev->foundname, - dev->rdataset, &name->target); + result = set_target(adb, &name->name, resp->foundname, + resp->rdataset, &name->target); if (result == ISC_R_SUCCESS) { DP(NCACHE_LEVEL, "adb fetch name %p: caching alias target", name); - name->expire_target = dev->rdataset->ttl + now; + name->expire_target = resp->rdataset->ttl + now; } goto check_result; } @@ -3036,13 +3005,13 @@ fetch_callback(isc_task_t *task, isc_event_t *ev) { * Did we get back junk? If so, and there are no more fetches * sitting out there, tell all the finds about it. */ - if (dev->result != ISC_R_SUCCESS) { + if (resp->result != ISC_R_SUCCESS) { char buf[DNS_NAME_FORMATSIZE]; dns_name_format(&name->name, buf, sizeof(buf)); DP(DEF_LEVEL, "adb: fetch of '%s' %s failed: %s", buf, address_type == DNS_ADBFIND_INET ? "A" : "AAAA", - isc_result_totext(dev->result)); + isc_result_totext(resp->result)); /* * Don't record a failure unless this is the initial * fetch of a chain. @@ -3081,7 +3050,7 @@ check_result: out: dns_resolver_destroyfetch(&fetch->fetch); free_adbfetch(adb, &fetch); - isc_event_free(&ev); + isc_mem_putanddetach(&resp->mctx, resp, sizeof(*resp)); if (astat != DNS_ADB_CANCELED) { clean_finds_at_name(name, astat, address_type); } @@ -3101,7 +3070,6 @@ fetch_name(dns_adbname_t *adbname, bool start_at_zone, unsigned int depth, dns_rdataset_t rdataset; dns_rdataset_t *nameservers = NULL; unsigned int options; - uint32_t tid = isc_tid(); REQUIRE(DNS_ADBNAME_VALID(adbname)); @@ -3143,8 +3111,8 @@ fetch_name(dns_adbname_t *adbname, bool start_at_zone, unsigned int depth, */ result = dns_resolver_createfetch( adb->res, &adbname->name, type, name, nameservers, NULL, NULL, - 0, options, depth, qc, adb->tasks[tid], fetch_callback, adbname, - &fetch->rdataset, NULL, &fetch->fetch); + 0, options, depth, qc, isc_loop_current(adb->loopmgr), + fetch_callback, adbname, &fetch->rdataset, NULL, &fetch->fetch); if (result != ISC_R_SUCCESS) { DP(ENTER_LEVEL, "fetch_name: createfetch failed with %s", isc_result_totext(result)); diff --git a/lib/dns/client.c b/lib/dns/client.c index 1253dafe6a..72588ce0e6 100644 --- a/lib/dns/client.c +++ b/lib/dns/client.c @@ -25,7 +25,6 @@ #include #include #include -#include #include #include @@ -76,7 +75,6 @@ struct dns_client { unsigned int magic; unsigned int attributes; isc_mem_t *mctx; - isc_task_t *task; isc_loop_t *loop; isc_nm_t *nm; dns_dispatchmgr_t *dispatchmgr; @@ -135,7 +133,7 @@ typedef struct resarg { } resarg_t; static void -client_resfind(resctx_t *rctx, dns_fetchevent_t *event); +client_resfind(resctx_t *rctx, dns_fetchresponse_t *event); static void destroyrestrans(dns_clientrestrans_t **transp); @@ -203,8 +201,7 @@ getudpdispatch(int family, dns_dispatchmgr_t *dispatchmgr, static isc_result_t createview(isc_mem_t *mctx, dns_rdataclass_t rdclass, isc_loopmgr_t *loopmgr, - isc_taskmgr_t *taskmgr, isc_nm_t *nm, - isc_tlsctx_cache_t *tlsctx_client_cache, + isc_nm_t *nm, 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; @@ -221,7 +218,7 @@ createview(isc_mem_t *mctx, dns_rdataclass_t rdclass, isc_loopmgr_t *loopmgr, goto cleanup_view; } - result = dns_view_createresolver(view, loopmgr, taskmgr, 1, nm, 0, + result = dns_view_createresolver(view, loopmgr, 1, nm, 0, tlsctx_client_cache, dispatchmgr, dispatchv4, dispatchv6); if (result != ISC_R_SUCCESS) { @@ -243,9 +240,8 @@ cleanup_view: } isc_result_t -dns_client_create(isc_mem_t *mctx, isc_loopmgr_t *loopmgr, - isc_taskmgr_t *taskmgr, isc_nm_t *nm, unsigned int options, - isc_tlsctx_cache_t *tlsctx_client_cache, +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_t **clientp, const isc_sockaddr_t *localaddr4, const isc_sockaddr_t *localaddr6) { isc_result_t result; @@ -255,7 +251,6 @@ dns_client_create(isc_mem_t *mctx, isc_loopmgr_t *loopmgr, dns_view_t *view = NULL; REQUIRE(mctx != NULL); - REQUIRE(taskmgr != NULL); REQUIRE(nm != NULL); REQUIRE(tlsctx_client_cache != NULL); REQUIRE(clientp != NULL && *clientp == NULL); @@ -268,14 +263,9 @@ dns_client_create(isc_mem_t *mctx, isc_loopmgr_t *loopmgr, .nm = nm, }; - result = isc_task_create(taskmgr, &client->task, 0); - if (result != ISC_R_SUCCESS) { - goto cleanup_lock; - } - result = dns_dispatchmgr_create(mctx, nm, &client->dispatchmgr); if (result != ISC_R_SUCCESS) { - goto cleanup_task; + goto cleanup_client; } (void)setsourceports(mctx, client->dispatchmgr); @@ -310,7 +300,7 @@ dns_client_create(isc_mem_t *mctx, isc_loopmgr_t *loopmgr, isc_refcount_init(&client->references, 1); /* Create the default view for class IN */ - result = createview(mctx, dns_rdataclass_in, loopmgr, taskmgr, nm, + result = createview(mctx, dns_rdataclass_in, loopmgr, nm, tlsctx_client_cache, client->dispatchmgr, dispatchv4, dispatchv6, &view); if (result != ISC_R_SUCCESS) { @@ -345,9 +335,7 @@ cleanup_dispatchmgr: dns_dispatch_detach(&dispatchv6); } dns_dispatchmgr_detach(&client->dispatchmgr); -cleanup_task: - isc_task_detach(&client->task); -cleanup_lock: +cleanup_client: isc_mem_put(mctx, client, sizeof(*client)); return (result); @@ -368,8 +356,6 @@ destroyclient(dns_client_t *client) { dns_dispatchmgr_detach(&client->dispatchmgr); - isc_task_detach(&client->task); - client->magic = 0; isc_mem_putanddetach(&client->mctx, client, sizeof(*client)); @@ -459,15 +445,13 @@ putrdataset(isc_mem_t *mctx, dns_rdataset_t **rdatasetp) { } static void -fetch_done(isc_task_t *task, isc_event_t *event) { - resctx_t *rctx = event->ev_arg; - dns_fetchevent_t *fevent; +fetch_done(void *arg) { + dns_fetchresponse_t *resp = (dns_fetchresponse_t *)arg; + resctx_t *rctx = resp->arg; REQUIRE(RCTX_VALID(rctx)); - REQUIRE(rctx->client->task == task); - fevent = (dns_fetchevent_t *)event; - client_resfind(rctx, fevent); + client_resfind(rctx, resp); } static isc_result_t @@ -494,7 +478,7 @@ start_fetch(resctx_t *rctx) { result = dns_resolver_createfetch( rctx->view->resolver, dns_fixedname_name(&rctx->name), rctx->type, NULL, NULL, NULL, NULL, 0, fopts, 0, NULL, - rctx->client->task, fetch_done, rctx, rctx->rdataset, + rctx->client->loop, fetch_done, rctx, rctx->rdataset, rctx->sigrdataset, &rctx->fetch); return (result); @@ -521,8 +505,8 @@ view_find(resctx_t *rctx, dns_db_t **dbp, dns_dbnode_t **nodep, } static void -client_resfind(resctx_t *rctx, dns_fetchevent_t *event) { - isc_mem_t *mctx; +client_resfind(resctx_t *rctx, dns_fetchresponse_t *resp) { + isc_mem_t *mctx = NULL; isc_result_t tresult, result = ISC_R_SUCCESS; isc_result_t vresult = ISC_R_SUCCESS; bool want_restart; @@ -552,7 +536,7 @@ client_resfind(resctx_t *rctx, dns_fetchevent_t *event) { rctx->restarts++; want_restart = false; - if (event == NULL) { + if (resp == NULL) { fname = dns_fixedname_initname(&foundname); INSIST(!dns_rdataset_isassociated(rctx->rdataset)); INSIST(rctx->sigrdataset == NULL || @@ -582,16 +566,17 @@ client_resfind(resctx_t *rctx, dns_fetchevent_t *event) { goto done; } } else { - INSIST(event != NULL); - INSIST(event->fetch == rctx->fetch); + INSIST(resp != NULL); + INSIST(resp->fetch == rctx->fetch); dns_resolver_destroyfetch(&rctx->fetch); - db = event->db; - node = event->node; - result = event->result; - vresult = event->vresult; - fname = event->foundname; - INSIST(event->rdataset == rctx->rdataset); - INSIST(event->sigrdataset == rctx->sigrdataset); + db = resp->db; + node = resp->node; + result = resp->result; + vresult = resp->vresult; + fname = resp->foundname; + INSIST(resp->rdataset == rctx->rdataset); + INSIST(resp->sigrdataset == rctx->sigrdataset); + isc_mem_putanddetach(&resp->mctx, resp, sizeof(*resp)); } /* @@ -821,9 +806,6 @@ client_resfind(resctx_t *rctx, dns_fetchevent_t *event) { if (db != NULL) { dns_db_detach(&db); } - if (event != NULL) { - isc_event_free(ISC_EVENT_PTR(&event)); - } /* * Limit the number of restarts. diff --git a/lib/dns/include/dns/adb.h b/lib/dns/include/dns/adb.h index 3ca6365103..0b96ee081f 100644 --- a/lib/dns/include/dns/adb.h +++ b/lib/dns/include/dns/adb.h @@ -251,7 +251,7 @@ struct dns_adbaddrinfo { isc_result_t dns_adb_create(isc_mem_t *mem, dns_view_t *view, isc_loopmgr_t *loopmgr, - isc_taskmgr_t *taskmgr, dns_adb_t **newadb); + dns_adb_t **newadb); /*%< * Create a new ADB. * @@ -266,7 +266,7 @@ dns_adb_create(isc_mem_t *mem, dns_view_t *view, isc_loopmgr_t *loopmgr, * *\li 'view' be a pointer to a valid view. * - *\li 'taskmgr' be a pointer to a valid task manager. + *\li 'loopmgr' be a valid loop manager. * *\li 'newadb' != NULL && '*newadb' == NULL. * diff --git a/lib/dns/include/dns/client.h b/lib/dns/include/dns/client.h index ee0a4c2695..3bfde55f00 100644 --- a/lib/dns/include/dns/client.h +++ b/lib/dns/include/dns/client.h @@ -42,6 +42,7 @@ #include #include #include +#include #include #include @@ -97,9 +98,8 @@ typedef struct dns_clientresume { } dns_clientresume_t; /* too long? */ isc_result_t -dns_client_create(isc_mem_t *mctx, isc_loopmgr_t *loopmgr, - isc_taskmgr_t *taskmgr, isc_nm_t *nm, unsigned int options, - isc_tlsctx_cache_t *tlsctx_client_cache, +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_t **clientp, const isc_sockaddr_t *localaddr4, const isc_sockaddr_t *localaddr6); /*%< @@ -120,8 +120,6 @@ dns_client_create(isc_mem_t *mctx, isc_loopmgr_t *loopmgr, * *\li 'loopmgr' is a valid loop manager. - *\li 'taskmgr' is a valid task manager. - * *\li 'nm' is a valid network manager. * *\li 'tlsctx_client_cache' is a valid TLS context cache. diff --git a/lib/dns/include/dns/nta.h b/lib/dns/include/dns/nta.h index 7111b29545..6b1d573520 100644 --- a/lib/dns/include/dns/nta.h +++ b/lib/dns/include/dns/nta.h @@ -33,7 +33,6 @@ #include #include #include -#include #include #include @@ -47,8 +46,8 @@ ISC_LANG_BEGINDECLS #define VALID_NTATABLE(nt) ISC_MAGIC_VALID(nt, NTATABLE_MAGIC) isc_result_t -dns_ntatable_create(dns_view_t *view, isc_taskmgr_t *taskmgr, - isc_loopmgr_t *loopmgr, dns_ntatable_t **ntatablep); +dns_ntatable_create(dns_view_t *view, isc_loopmgr_t *loopmgr, + dns_ntatable_t **ntatablep); /*%< * Create an NTA table in view 'view'. * diff --git a/lib/dns/include/dns/resolver.h b/lib/dns/include/dns/resolver.h index 415f0f03ac..61429ddaf0 100644 --- a/lib/dns/include/dns/resolver.h +++ b/lib/dns/include/dns/resolver.h @@ -48,8 +48,8 @@ #include #include -#include #include +#include #include #include #include @@ -65,18 +65,23 @@ ISC_LANG_BEGINDECLS /*% - * A dns_fetchevent_t is sent when a 'fetch' completes. Any of 'db', - * 'node', 'rdataset', and 'sigrdataset' may be bound. It is the - * receiver's responsibility to detach before freeing the event. + * A dns_fetchresponse_t is sent to the caller when a fetch completes. + * Any of 'db', 'node', 'rdataset', and 'sigrdataset' may be bound; it + * is the receiver's responsibility to detach them, and also free the + * structure. + * * \brief * 'rdataset', 'sigrdataset', 'client' and 'id' are the values that were * supplied when dns_resolver_createfetch() was called. They are returned * to the caller so that they may be freed. */ -typedef struct dns_fetchevent { - ISC_EVENT_COMMON(struct dns_fetchevent); +typedef struct dns_fetchresponse dns_fetchresponse_t; + +struct dns_fetchresponse { dns_fetch_t *fetch; + isc_mem_t *mctx; isc_result_t result; + isc_result_t vresult; dns_rdatatype_t qtype; dns_db_t *db; dns_dbnode_t *node; @@ -86,8 +91,12 @@ typedef struct dns_fetchevent { dns_name_t *foundname; const isc_sockaddr_t *client; dns_messageid_t id; - isc_result_t vresult; -} dns_fetchevent_t; + isc_loop_t *loop; + isc_job_cb cb; + void *arg; + enum { FETCHDONE, TRYSTALE } type; + ISC_LINK(dns_fetchresponse_t) link; +}; /*% * The two quota types (fetches-per-zone and fetches-per-server) @@ -172,8 +181,8 @@ typedef enum { dns_quotatype_zone = 0, dns_quotatype_server } dns_quotatype_t; isc_result_t dns_resolver_create(dns_view_t *view, isc_loopmgr_t *loopmgr, - isc_taskmgr_t *taskmgr, unsigned int ndisp, isc_nm_t *nm, - unsigned int options, isc_tlsctx_cache_t *tlsctx_cache, + unsigned int ndisp, isc_nm_t *nm, unsigned int options, + isc_tlsctx_cache_t *tlsctx_cache, dns_dispatchmgr_t *dispatchmgr, dns_dispatch_t *dispatchv4, dns_dispatch_t *dispatchv6, dns_resolver_t **resp); @@ -189,9 +198,7 @@ dns_resolver_create(dns_view_t *view, isc_loopmgr_t *loopmgr, * *\li 'view' is a valid view. * - *\li 'taskmgr' is a valid task manager. - * - *\li 'ntasks' > 0. + *\li 'ndisp' > 0. * *\li 'nm' is a valid network manager. * @@ -285,10 +292,9 @@ dns_resolver_createfetch(dns_resolver_t *res, const dns_name_t *name, dns_forwarders_t *forwarders, const isc_sockaddr_t *client, dns_messageid_t id, unsigned int options, unsigned int depth, - isc_counter_t *qc, isc_task_t *task, - isc_taskaction_t action, void *arg, - dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset, - dns_fetch_t **fetchp); + isc_counter_t *qc, isc_loop_t *loop, isc_job_cb cb, + void *arg, dns_rdataset_t *rdataset, + dns_rdataset_t *sigrdataset, dns_fetch_t **fetchp); /*%< * Recurse to answer a question. * @@ -305,8 +311,8 @@ dns_resolver_createfetch(dns_resolver_t *res, const dns_name_t *name, * we figure out how selective forwarding will work. * *\li When the fetch completes (successfully or otherwise), a - * #DNS_EVENT_FETCHDONE event with action 'action' and arg 'arg' will be - * posted to 'task'. + * dns_fetchresponse_t option is sent to callback 'cb' with + * 'type' set to FETCHDONE. * *\li The values of 'rdataset' and 'sigrdataset' will be returned in * the FETCHDONE event. diff --git a/lib/dns/include/dns/validator.h b/lib/dns/include/dns/validator.h index a87cfbeb82..704b830799 100644 --- a/lib/dns/include/dns/validator.h +++ b/lib/dns/include/dns/validator.h @@ -135,7 +135,6 @@ struct dns_validator { dns_keytable_t *keytable; dst_key_t *key; dns_rdata_rrsig_t *siginfo; - isc_task_t *task; isc_loop_t *loop; isc_job_cb cb; void *arg; @@ -171,8 +170,8 @@ isc_result_t dns_validator_create(dns_view_t *view, dns_name_t *name, dns_rdatatype_t type, dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset, dns_message_t *message, unsigned int options, - isc_task_t *task, isc_loop_t *loop, isc_job_cb cb, - void *arg, dns_validator_t **validatorp); + isc_loop_t *loop, isc_job_cb cb, void *arg, + dns_validator_t **validatorp); /*%< * Start a DNSSEC validation. * diff --git a/lib/dns/include/dns/view.h b/lib/dns/include/dns/view.h index 464114ea67..f315def13c 100644 --- a/lib/dns/include/dns/view.h +++ b/lib/dns/include/dns/view.h @@ -104,7 +104,7 @@ struct dns_view { isc_mutex_t lock; bool frozen; - isc_task_t *task; + isc_loop_t *loop; bool cacheshared; /* Configurable data. */ @@ -388,10 +388,9 @@ dns_view_createzonetable(dns_view_t *view); isc_result_t dns_view_createresolver(dns_view_t *view, isc_loopmgr_t *loopmgr, - isc_taskmgr_t *taskmgr, unsigned int ndisp, - isc_nm_t *netmgr, unsigned int options, - isc_tlsctx_cache_t *tlsctx_cache, - dns_dispatchmgr_t *dispatchmgr, + unsigned int ndisp, isc_nm_t *netmgr, + unsigned int options, isc_tlsctx_cache_t *tlsctx_cache, + dns_dispatchmgr_t *dispatchmgr, dns_dispatch_t *dispatchv4, dns_dispatch_t *dispatchv6); /*%< * Create a resolver and address database for the view. @@ -402,9 +401,8 @@ dns_view_createresolver(dns_view_t *view, isc_loopmgr_t *loopmgr, * *\li 'view' does not have a resolver already. * - *\li The requirements of dns_resolver_create() apply to 'taskmgr', - * 'ndisp', 'netmgr', 'options', 'tlsctx_cache', 'dispatchv4', and - * 'dispatchv6'. + *\li The requirements of dns_resolver_create() apply to 'ndisp', + * 'netmgr', 'options', 'tlsctx_cache', 'dispatchv4', and 'dispatchv6'. * * Returns: * @@ -1008,8 +1006,7 @@ dns_view_iscacheshared(dns_view_t *view); */ isc_result_t -dns_view_initntatable(dns_view_t *view, isc_taskmgr_t *taskmgr, - isc_loopmgr_t *loopmgr); +dns_view_initntatable(dns_view_t *view, isc_loopmgr_t *loopmgr); /*%< * Initialize the negative trust anchor table for the view. * diff --git a/lib/dns/nta.c b/lib/dns/nta.c index 27a67e71a0..5096ce658a 100644 --- a/lib/dns/nta.c +++ b/lib/dns/nta.c @@ -47,7 +47,6 @@ struct dns_ntatable { dns_view_t *view; isc_rwlock_t rwlock; isc_loopmgr_t *loopmgr; - isc_task_t *task; /* Protected by atomics */ isc_refcount_t references; /* Locked by rwlock. */ @@ -92,6 +91,7 @@ dns__nta_destroy(dns__nta_t *nta) { dns_resolver_cancelfetch(nta->fetch); dns_resolver_destroyfetch(&nta->fetch); } + isc_loop_detach(&nta->loop); isc_mem_putanddetach(&nta->mctx, nta, sizeof(*nta)); } @@ -108,8 +108,8 @@ dns__nta_free(void *data, void *arg) { } isc_result_t -dns_ntatable_create(dns_view_t *view, isc_taskmgr_t *taskmgr, - isc_loopmgr_t *loopmgr, dns_ntatable_t **ntatablep) { +dns_ntatable_create(dns_view_t *view, isc_loopmgr_t *loopmgr, + dns_ntatable_t **ntatablep) { dns_ntatable_t *ntatable; isc_result_t result; @@ -123,16 +123,10 @@ dns_ntatable_create(dns_view_t *view, isc_taskmgr_t *taskmgr, isc_mem_attach(view->mctx, &ntatable->mctx); dns_view_weakattach(view, &ntatable->view); - result = isc_task_create(taskmgr, &ntatable->task, 0); - if (result != ISC_R_SUCCESS) { - goto cleanup_ntatable; - } - isc_task_setname(ntatable->task, "ntatable", ntatable); - result = dns_rbt_create(ntatable->mctx, dns__nta_free, NULL, &ntatable->table); if (result != ISC_R_SUCCESS) { - goto cleanup_task; + goto cleanup; } isc_rwlock_init(&ntatable->rwlock); @@ -144,10 +138,7 @@ dns_ntatable_create(dns_view_t *view, isc_taskmgr_t *taskmgr, return (ISC_R_SUCCESS); -cleanup_task: - isc_task_detach(&ntatable->task); - -cleanup_ntatable: +cleanup: isc_mem_putanddetach(&ntatable->mctx, ntatable, sizeof(*ntatable)); return (result); @@ -159,7 +150,6 @@ dns__ntatable_destroy(dns_ntatable_t *ntatable) { ntatable->magic = 0; dns_rbt_destroy(&ntatable->table); isc_rwlock_destroy(&ntatable->rwlock); - isc_task_detach(&ntatable->task); INSIST(ntatable->view == NULL); isc_mem_putanddetach(&ntatable->mctx, ntatable, sizeof(*ntatable)); } @@ -167,35 +157,33 @@ dns__ntatable_destroy(dns_ntatable_t *ntatable) { ISC_REFCOUNT_IMPL(dns_ntatable, dns__ntatable_destroy); static void -fetch_done(isc_task_t *task, isc_event_t *event) { - dns_fetchevent_t *devent = (dns_fetchevent_t *)event; - dns__nta_t *nta = devent->ev_arg; - isc_result_t eresult = devent->result; +fetch_done(void *arg) { + dns_fetchresponse_t *resp = (dns_fetchresponse_t *)arg; + dns__nta_t *nta = resp->arg; + isc_result_t eresult = resp->result; dns_ntatable_t *ntatable = nta->ntatable; dns_view_t *view = ntatable->view; isc_stdtime_t now; - UNUSED(task); - if (dns_rdataset_isassociated(&nta->rdataset)) { dns_rdataset_disassociate(&nta->rdataset); } if (dns_rdataset_isassociated(&nta->sigrdataset)) { dns_rdataset_disassociate(&nta->sigrdataset); } - if (nta->fetch == devent->fetch) { + if (nta->fetch == resp->fetch) { nta->fetch = NULL; } - dns_resolver_destroyfetch(&devent->fetch); + dns_resolver_destroyfetch(&resp->fetch); - if (devent->node != NULL) { - dns_db_detachnode(devent->db, &devent->node); + if (resp->node != NULL) { + dns_db_detachnode(resp->db, &resp->node); } - if (devent->db != NULL) { - dns_db_detach(&devent->db); + if (resp->db != NULL) { + dns_db_detach(&resp->db); } - isc_event_free(&event); + isc_mem_putanddetach(&resp->mctx, resp, sizeof(*resp)); isc_stdtime_get(&now); switch (eresult) { @@ -258,7 +246,7 @@ checkbogus(void *arg) { dns__nta_ref(nta); /* for dns_resolver_createfetch */ result = dns_resolver_createfetch( resolver, nta->name, dns_rdatatype_nsec, NULL, NULL, NULL, NULL, - 0, DNS_FETCHOPT_NONTA, 0, NULL, ntatable->task, fetch_done, nta, + 0, DNS_FETCHOPT_NONTA, 0, NULL, nta->loop, fetch_done, nta, &nta->rdataset, &nta->sigrdataset, &nta->fetch); if (result != ISC_R_SUCCESS) { dns__nta_detach(&nta); /* for dns_resolver_createfetch() */ @@ -295,11 +283,10 @@ nta_create(dns_ntatable_t *ntatable, const dns_name_t *name, nta = isc_mem_get(ntatable->mctx, sizeof(dns__nta_t)); *nta = (dns__nta_t){ .ntatable = ntatable, - .loop = isc_loop_current(ntatable->loopmgr), .magic = NTA_MAGIC, }; - isc_mem_attach(ntatable->mctx, &nta->mctx); + isc_loop_attach(isc_loop_current(ntatable->loopmgr), &nta->loop); dns_rdataset_init(&nta->rdataset); dns_rdataset_init(&nta->sigrdataset); diff --git a/lib/dns/resolver.c b/lib/dns/resolver.c index 189ef15fbf..a87d3d0341 100644 --- a/lib/dns/resolver.c +++ b/lib/dns/resolver.c @@ -33,7 +33,6 @@ #include #include #include -#include #include #include #include @@ -48,7 +47,6 @@ #include #include #include -#include #include #include #include @@ -244,7 +242,7 @@ STATIC_ASSERT(NS_PROCESSING_LIMIT > NS_RR_LIMIT, typedef struct fetchctx fetchctx_t; typedef struct query { - /* Locked by task event serialization. */ + /* Locked by loop event serialization. */ unsigned int magic; isc_refcount_t references; fetchctx_t *fctx; @@ -348,7 +346,7 @@ struct fetchctx { isc_mem_t *mctx; isc_stdtime_t now; - isc_task_t *restask; + isc_loop_t *loop; unsigned int tid; /* Atomic */ @@ -361,14 +359,13 @@ struct fetchctx { bool cloned; bool spilled; ISC_LINK(struct fetchctx) link; - ISC_LIST(dns_fetchevent_t) events; + ISC_LIST(dns_fetchresponse_t) resps; - /*% Locked by task event serialization. */ + /*% Locked by loop event serialization. */ dns_fixedname_t dfname; dns_name_t *domain; dns_rdataset_t nameservers; atomic_uint_fast32_t attributes; - isc_loop_t *loop; isc_timer_t *timer; isc_time_t expires; isc_time_t expires_try_stale; @@ -548,7 +545,6 @@ struct dns_resolver { dns_rdataclass_t rdclass; isc_loopmgr_t *loopmgr; isc_nm_t *nm; - isc_taskmgr_t *taskmgr; dns_view_t *view; bool frozen; unsigned int options; @@ -563,9 +559,6 @@ struct dns_resolver { isc_hashmap_t *counters; isc_rwlock_t counters_lock; - unsigned int ntasks; - isc_task_t **tasks; - uint32_t lame_ttl; ISC_LIST(alternate_t) alternates; dns_rbt_t *algorithms; @@ -705,7 +698,7 @@ fctx__done(fetchctx_t *fctx, isc_result_t result, const char *func, const char *file, unsigned int line); static void -resume_qmin(isc_task_t *task, isc_event_t *event); +resume_qmin(void *arg); static isc_result_t get_attached_fctx(dns_resolver_t *res, const dns_name_t *name, @@ -969,7 +962,7 @@ static isc_result_t valcreate(fetchctx_t *fctx, dns_message_t *message, dns_adbaddrinfo_t *addrinfo, dns_name_t *name, dns_rdatatype_t type, dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset, unsigned int valoptions, - isc_task_t *task, isc_loop_t *loop) { + isc_loop_t *loop) { dns_validator_t *validator = NULL; dns_valarg_t *valarg = NULL; isc_result_t result; @@ -988,8 +981,8 @@ valcreate(fetchctx_t *fctx, dns_message_t *message, dns_adbaddrinfo_t *addrinfo, } result = dns_validator_create(fctx->res->view, name, type, rdataset, - sigrdataset, message, valoptions, task, - loop, validated, valarg, &validator); + sigrdataset, message, valoptions, loop, + validated, valarg, &validator); RUNTIME_CHECK(result == ISC_R_SUCCESS); inc_stats(fctx->res, dns_resstatscounter_val); if ((valoptions & DNS_VALIDATOR_DEFER) == 0) { @@ -1741,8 +1734,7 @@ spillattimer_countdown(void *arg); static void fctx_sendevents(fetchctx_t *fctx, isc_result_t result) { - dns_fetchevent_t *event, *next_event; - isc_task_t *task; + dns_fetchresponse_t *resp = NULL, *next = NULL; unsigned int count = 0; bool logit = false; isc_time_t now; @@ -1766,46 +1758,42 @@ fctx_sendevents(fetchctx_t *fctx, isc_result_t result) { TIME_NOW(&now); fctx->duration = isc_time_microdiff(&now, &fctx->start); - for (event = ISC_LIST_HEAD(fctx->events); event != NULL; - event = next_event) - { - next_event = ISC_LIST_NEXT(event, ev_link); - ISC_LIST_UNLINK(fctx->events, event, ev_link); - if (event->ev_type == DNS_EVENT_TRYSTALE) { + for (resp = ISC_LIST_HEAD(fctx->resps); resp != NULL; resp = next) { + next = ISC_LIST_NEXT(resp, link); + ISC_LIST_UNLINK(fctx->resps, resp, link); + if (resp->type == TRYSTALE) { /* - * Not applicable to TRY STALE events, this function is + * Not applicable to TRYSTALE resps; this function is * called when the fetch has either completed or timed * out due to resolver-query-timeout being reached. */ - isc_task_detach((isc_task_t **)&event->ev_sender); - isc_event_free((isc_event_t **)&event); + isc_mem_putanddetach(&resp->mctx, resp, sizeof(*resp)); continue; } - task = event->ev_sender; - event->ev_sender = fctx; - event->vresult = fctx->vresult; + + resp->vresult = fctx->vresult; if (!HAVE_ANSWER(fctx)) { - event->result = result; + resp->result = result; } - INSIST(event->result != ISC_R_SUCCESS || - dns_rdataset_isassociated(event->rdataset) || + INSIST(resp->result != ISC_R_SUCCESS || + dns_rdataset_isassociated(resp->rdataset) || fctx->type == dns_rdatatype_any || fctx->type == dns_rdatatype_rrsig || fctx->type == dns_rdatatype_sig); /* - * Negative results must be indicated in event->result. + * Negative results must be indicated in resp->result. */ - if (dns_rdataset_isassociated(event->rdataset) && - NEGATIVE(event->rdataset)) + if (dns_rdataset_isassociated(resp->rdataset) && + NEGATIVE(resp->rdataset)) { - INSIST(event->result == DNS_R_NCACHENXDOMAIN || - event->result == DNS_R_NCACHENXRRSET); + INSIST(resp->result == DNS_R_NCACHENXDOMAIN || + resp->result == DNS_R_NCACHENXRRSET); } - FCTXTRACE("event"); - isc_task_sendanddetach(&task, ISC_EVENT_PTR(&event)); + FCTXTRACE("post response event"); + isc_async_run(resp->loop, resp->cb, resp); count++; } UNLOCK(&fctx->lock); @@ -2090,7 +2078,7 @@ fctx_setretryinterval(fetchctx_t *fctx, unsigned int rtt) { static isc_result_t resquery_timeout(resquery_t *query) { fetchctx_t *fctx = query->fctx; - dns_fetchevent_t *event = NULL, *next = NULL; + dns_fetchresponse_t *resp = NULL, *next = NULL; uint64_t timeleft; isc_time_t now; @@ -2118,20 +2106,16 @@ resquery_timeout(resquery_t *query) { * Send the TRYSTALE events. */ LOCK(&fctx->lock); - for (event = ISC_LIST_HEAD(fctx->events); event != NULL; event = next) { - isc_task_t *sender = NULL; - - next = ISC_LIST_NEXT(event, ev_link); - if (event->ev_type != DNS_EVENT_TRYSTALE) { + for (resp = ISC_LIST_HEAD(fctx->resps); resp != NULL; resp = next) { + next = ISC_LIST_NEXT(resp, link); + if (resp->type != TRYSTALE) { continue; } - ISC_LIST_UNLINK(fctx->events, event, ev_link); - - sender = event->ev_sender; - event->vresult = ISC_R_TIMEDOUT; - event->result = ISC_R_TIMEDOUT; - isc_task_sendanddetach(&sender, ISC_EVENT_PTR(&event)); + ISC_LIST_UNLINK(fctx->resps, resp, link); + resp->vresult = ISC_R_TIMEDOUT; + resp->result = ISC_R_TIMEDOUT; + isc_async_run(resp->loop, resp->cb, resp); } UNLOCK(&fctx->lock); @@ -4282,8 +4266,8 @@ fctx_try(fetchctx_t *fctx, bool retrying, bool badcache) { result = dns_resolver_createfetch( fctx->res, fctx->qminname, fctx->qmintype, fctx->domain, &fctx->nameservers, NULL, NULL, 0, options, 0, fctx->qc, - fctx->restask, resume_qmin, fctx, &fctx->qminrrset, - NULL, &fctx->qminfetch); + fctx->loop, resume_qmin, fctx, &fctx->qminrrset, NULL, + &fctx->qminfetch); if (result != ISC_R_SUCCESS) { fetchctx_unref(fctx); goto done; @@ -4315,21 +4299,18 @@ done: } static void -resume_qmin(isc_task_t *task, isc_event_t *event) { - dns_fetchevent_t *fevent = NULL; +resume_qmin(void *arg) { + dns_fetchresponse_t *resp = (dns_fetchresponse_t *)arg; + fetchctx_t *fctx = resp->arg; dns_resolver_t *res = NULL; - fetchctx_t *fctx = NULL; isc_result_t result; unsigned int findoptions = 0; dns_name_t *fname = NULL, *dcname = NULL; dns_fixedname_t ffixed, dcfixed; - UNUSED(task); - - REQUIRE(event->ev_type == DNS_EVENT_FETCHDONE); - fevent = (dns_fetchevent_t *)event; - fctx = event->ev_arg; REQUIRE(VALID_FCTX(fctx)); + REQUIRE(resp->type == FETCHDONE); + res = fctx->res; REQUIRE(fctx->tid == isc_tid()); @@ -4339,19 +4320,19 @@ resume_qmin(isc_task_t *task, isc_event_t *event) { fname = dns_fixedname_initname(&ffixed); dcname = dns_fixedname_initname(&dcfixed); - if (fevent->node != NULL) { - dns_db_detachnode(fevent->db, &fevent->node); + if (resp->node != NULL) { + dns_db_detachnode(resp->db, &resp->node); } - if (fevent->db != NULL) { - dns_db_detach(&fevent->db); + if (resp->db != NULL) { + dns_db_detach(&resp->db); } - if (dns_rdataset_isassociated(fevent->rdataset)) { - dns_rdataset_disassociate(fevent->rdataset); + if (dns_rdataset_isassociated(resp->rdataset)) { + dns_rdataset_disassociate(resp->rdataset); } - result = fevent->result; - isc_event_free(&event); + result = resp->result; + isc_mem_putanddetach(&resp->mctx, resp, sizeof(*resp)); LOCK(&fctx->lock); if (SHUTTINGDOWN(fctx)) { @@ -4470,7 +4451,7 @@ fctx_destroy(fetchctx_t *fctx) { uint_fast32_t nfctx; REQUIRE(VALID_FCTX(fctx)); - REQUIRE(ISC_LIST_EMPTY(fctx->events)); + REQUIRE(ISC_LIST_EMPTY(fctx->resps)); REQUIRE(ISC_LIST_EMPTY(fctx->queries)); REQUIRE(ISC_LIST_EMPTY(fctx->finds)); REQUIRE(ISC_LIST_EMPTY(fctx->altfinds)); @@ -4551,7 +4532,9 @@ fctx_shutdown(fetchctx_t *fctx) { } static void -fctx_start(fetchctx_t *fctx) { +fctx_start(void *arg) { + fetchctx_t *fctx = (fetchctx_t *)arg; + REQUIRE(VALID_FCTX(fctx)); FCTXTRACE("start"); @@ -4561,6 +4544,11 @@ fctx_start(fetchctx_t *fctx) { UNLOCK(&fctx->lock); goto detach; } + + /* + * Normal fctx startup. + */ + fctx->state = fetchstate_active; UNLOCK(&fctx->lock); /* @@ -4582,55 +4570,55 @@ detach: */ static void -fctx_add_event(fetchctx_t *fctx, isc_task_t *task, const isc_sockaddr_t *client, - dns_messageid_t id, isc_taskaction_t action, void *arg, +fctx_add_event(fetchctx_t *fctx, isc_loop_t *loop, const isc_sockaddr_t *client, + dns_messageid_t id, isc_job_cb cb, void *arg, dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset, - dns_fetch_t *fetch, isc_eventtype_t event_type) { - dns_fetchevent_t *event = NULL; + dns_fetch_t *fetch, int type) { + dns_fetchresponse_t *resp = NULL; FCTXTRACE("addevent"); - /* - * We store the task we're going to send this event to in the - * sender field. We'll make the fetch the sender when we - * actually send the event. - */ - isc_task_ref(task); - event = (dns_fetchevent_t *)isc_event_allocate( - fctx->mctx, task, event_type, action, arg, sizeof(*event)); - event->result = DNS_R_SERVFAIL; - event->qtype = fctx->type; - event->db = NULL; - event->node = NULL; - event->rdataset = rdataset; - event->sigrdataset = sigrdataset; - event->fetch = fetch; - event->client = client; - event->id = id; - event->foundname = dns_fixedname_initname(&event->fname); + resp = isc_mem_get(fctx->res->mctx, sizeof(*resp)); + *resp = (dns_fetchresponse_t){ + .result = DNS_R_SERVFAIL, + .qtype = fctx->type, + .rdataset = rdataset, + .sigrdataset = sigrdataset, + .fetch = fetch, + .client = client, + .id = id, + .type = type, + .loop = loop, + .cb = cb, + .arg = arg, + .link = ISC_LINK_INITIALIZER, + }; + isc_mem_attach(fctx->res->mctx, &resp->mctx); + + resp->foundname = dns_fixedname_initname(&resp->fname); /* - * Store the sigrdataset in the first event in case it is needed + * Store the sigrdataset in the first resp in case it is needed * by any of the events. */ - if (event->sigrdataset != NULL) { - ISC_LIST_PREPEND(fctx->events, event, ev_link); + if (resp->sigrdataset != NULL) { + ISC_LIST_PREPEND(fctx->resps, resp, link); } else { - ISC_LIST_APPEND(fctx->events, event, ev_link); + ISC_LIST_APPEND(fctx->resps, resp, link); } } static void -fctx_join(fetchctx_t *fctx, isc_task_t *task, const isc_sockaddr_t *client, - dns_messageid_t id, isc_taskaction_t action, void *arg, +fctx_join(fetchctx_t *fctx, isc_loop_t *loop, const isc_sockaddr_t *client, + dns_messageid_t id, isc_job_cb cb, void *arg, dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset, dns_fetch_t *fetch) { FCTXTRACE("join"); REQUIRE(!SHUTTINGDOWN(fctx)); - fctx_add_event(fctx, task, client, id, action, arg, rdataset, - sigrdataset, fetch, DNS_EVENT_FETCHDONE); + fctx_add_event(fctx, loop, client, id, cb, arg, rdataset, sigrdataset, + fetch, FETCHDONE); fetch->magic = DNS_FETCH_MAGIC; fetchctx_attach(fctx, &fetch->private); @@ -4681,7 +4669,6 @@ fctx_create(dns_resolver_t *res, const dns_name_t *name, dns_rdatatype_t type, .qmintype = type, .options = options, .tid = tid, - .restask = res->tasks[tid], .state = fetchstate_active, .depth = depth, .qmin_labels = 1, @@ -4910,7 +4897,7 @@ fctx_create(dns_resolver_t *res, const dns_name_t *name, dns_rdatatype_t type, dns_db_attach(res->view->cachedb, &fctx->cache); dns_adb_attach(res->view->adb, &fctx->adb); - ISC_LIST_INIT(fctx->events); + ISC_LIST_INIT(fctx->resps); ISC_LINK_INIT(fctx, link); fctx->magic = FCTX_MAGIC; @@ -5129,30 +5116,28 @@ same_question(fetchctx_t *fctx, dns_message_t *message) { static void clone_results(fetchctx_t *fctx) { - dns_fetchevent_t *event = NULL, *hevent = NULL; + dns_fetchresponse_t *resp = NULL, *hresp = NULL; FCTXTRACE("clone_results"); /* - * Set up any other events to have the same data as the first - * event. + * Set up any other resps to have the same data as the first. * * Caller must be holding the appropriate lock. */ fctx->cloned = true; - for (event = ISC_LIST_HEAD(fctx->events); event != NULL; - event = ISC_LIST_NEXT(event, ev_link)) + for (resp = ISC_LIST_HEAD(fctx->resps); resp != NULL; + resp = ISC_LIST_NEXT(resp, link)) { - /* This is the the head event; keep a pointer and move - * on */ - if (hevent == NULL) { - hevent = ISC_LIST_HEAD(fctx->events); + /* This is the head resp; keep a pointer and move on */ + if (hresp == NULL) { + hresp = ISC_LIST_HEAD(fctx->resps); continue; } - if (event->ev_type == DNS_EVENT_TRYSTALE) { + if (resp->type == TRYSTALE) { /* * We don't need to clone resulting data to this * type of event, as its associated callback is @@ -5165,31 +5150,31 @@ clone_results(fetchctx_t *fctx) { * Also, if we reached this point, then the * whole fetch context is done, it will cancel * timers, process associated callbacks of type - * DNS_EVENT_FETCHDONE, and silently remove/free - * events of type DNS_EVENT_TRYSTALE. + * FETCHDONE, and silently remove/free events of + * type TRYSTALE. */ continue; } - event->result = hevent->result; - dns_name_copy(hevent->foundname, event->foundname); - dns_db_attach(hevent->db, &event->db); - dns_db_attachnode(hevent->db, hevent->node, &event->node); + resp->result = hresp->result; + dns_name_copy(hresp->foundname, resp->foundname); + dns_db_attach(hresp->db, &resp->db); + dns_db_attachnode(hresp->db, hresp->node, &resp->node); - INSIST(hevent->rdataset != NULL); - INSIST(event->rdataset != NULL); - if (dns_rdataset_isassociated(hevent->rdataset)) { - dns_rdataset_clone(hevent->rdataset, event->rdataset); + INSIST(hresp->rdataset != NULL); + INSIST(resp->rdataset != NULL); + if (dns_rdataset_isassociated(hresp->rdataset)) { + dns_rdataset_clone(hresp->rdataset, resp->rdataset); } - INSIST(!(hevent->sigrdataset == NULL && - event->sigrdataset != NULL)); - if (hevent->sigrdataset != NULL && - dns_rdataset_isassociated(hevent->sigrdataset) && - event->sigrdataset != NULL) + INSIST(!(hresp->sigrdataset == NULL && + resp->sigrdataset != NULL)); + if (hresp->sigrdataset != NULL && + dns_rdataset_isassociated(hresp->sigrdataset) && + resp->sigrdataset != NULL) { - dns_rdataset_clone(hevent->sigrdataset, - event->sigrdataset); + dns_rdataset_clone(hresp->sigrdataset, + resp->sigrdataset); } } } @@ -5332,7 +5317,7 @@ validated(void *arg) { dns_adbaddrinfo_t *addrinfo = NULL; dns_dbnode_t *node = NULL; dns_dbnode_t *nsnode = NULL; - dns_fetchevent_t *hevent = NULL; + dns_fetchresponse_t *hresp = NULL; dns_name_t *name = NULL; dns_rdataset_t *ardataset = NULL; dns_rdataset_t *asigrdataset = NULL; @@ -5429,8 +5414,8 @@ validated(void *arg) { * started by a query with cd set) */ - hevent = ISC_LIST_HEAD(fctx->events); - if (hevent != NULL) { + hresp = ISC_LIST_HEAD(fctx->resps); + if (hresp != NULL) { if (!negative && !chaining && (fctx->type == dns_rdatatype_any || fctx->type == dns_rdatatype_rrsig || @@ -5441,8 +5426,8 @@ validated(void *arg) { * will iterate the node. */ } else { - ardataset = hevent->rdataset; - asigrdataset = hevent->sigrdataset; + ardataset = hresp->rdataset; + asigrdataset = hresp->sigrdataset; } } @@ -5503,6 +5488,7 @@ validated(void *arg) { add_bad(fctx, message, addrinfo, result, badns_validation); UNLOCK(&fctx->lock); + INSIST(fctx->validator == NULL); fctx->validator = ISC_LIST_HEAD(fctx->validators); @@ -5653,6 +5639,9 @@ validated(void *arg) { * cache the data, destroy now. */ dns_db_detachnode(fctx->cache, &node); + if (SHUTTINGDOWN(fctx)) { + maybe_cancel_validators(fctx); + } UNLOCK(&fctx->lock); goto cleanup_fetchctx; } @@ -5805,22 +5794,22 @@ answer_response: FCTX_ATTR_SET(fctx, FCTX_ATTR_HAVEANSWER); - if (hevent != NULL) { + if (hresp != NULL) { /* * Negative results must be indicated in vstat->result. */ - INSIST(hevent->rdataset != NULL); - if (dns_rdataset_isassociated(hevent->rdataset) && - NEGATIVE(hevent->rdataset)) + INSIST(hresp->rdataset != NULL); + if (dns_rdataset_isassociated(hresp->rdataset) && + NEGATIVE(hresp->rdataset)) { INSIST(eresult == DNS_R_NCACHENXDOMAIN || eresult == DNS_R_NCACHENXRRSET); } - hevent->result = eresult; - dns_name_copy(vstat->name, hevent->foundname); - dns_db_attach(fctx->cache, &hevent->db); - dns_db_transfernode(fctx->cache, &node, &hevent->node); + hresp->result = eresult; + dns_name_copy(vstat->name, hresp->foundname); + dns_db_attach(fctx->cache, &hresp->db); + dns_db_transfernode(fctx->cache, &node, &hresp->node); clone_results(fctx); } @@ -6006,7 +5995,7 @@ cache_name(fetchctx_t *fctx, dns_name_t *name, dns_message_t *message, bool secure_domain = false; bool have_answer = false; isc_result_t result, eresult = ISC_R_SUCCESS; - dns_fetchevent_t *event = NULL; + dns_fetchresponse_t *resp = NULL; unsigned int options; bool fail; unsigned int valoptions = 0; @@ -6046,12 +6035,12 @@ cache_name(fetchctx_t *fctx, dns_name_t *name, dns_message_t *message, if (name->attributes.answer && !need_validation) { have_answer = true; - event = ISC_LIST_HEAD(fctx->events); + resp = ISC_LIST_HEAD(fctx->resps); - if (event != NULL) { - adbp = &event->db; - dns_name_copy(name, event->foundname); - anodep = &event->node; + if (resp != NULL) { + adbp = &resp->db; + dns_name_copy(name, resp->foundname); + anodep = &resp->node; /* * If this is an ANY, SIG or RRSIG query, we're @@ -6066,8 +6055,8 @@ cache_name(fetchctx_t *fctx, dns_name_t *name, dns_message_t *message, fctx->type != dns_rdatatype_sig) || name->attributes.chaining) { - ardataset = event->rdataset; - asigrdataset = event->sigrdataset; + ardataset = resp->rdataset; + asigrdataset = resp->sigrdataset; } } } @@ -6332,7 +6321,7 @@ cache_name(fetchctx_t *fctx, dns_name_t *name, dns_message_t *message, fctx, message, addrinfo, name, rdataset->type, rdataset, sigrdataset, valoptions, - fctx->restask, fctx->loop); + fctx->loop); } } else if (CHAINING(rdataset)) { if (rdataset->type == dns_rdatatype_cname) { @@ -6441,23 +6430,23 @@ cache_name(fetchctx_t *fctx, dns_name_t *name, dns_message_t *message, result = valcreate(fctx, message, addrinfo, name, vtype, valrdataset, valsigrdataset, valoptions, - fctx->restask, fctx->loop); + fctx->loop); } if (result == ISC_R_SUCCESS && have_answer) { FCTX_ATTR_SET(fctx, FCTX_ATTR_HAVEANSWER); - if (event != NULL) { + if (resp != NULL) { /* * Negative results must be indicated in - * event->result. + * resp->result. */ - if (dns_rdataset_isassociated(event->rdataset) && - NEGATIVE(event->rdataset)) + if (dns_rdataset_isassociated(resp->rdataset) && + NEGATIVE(resp->rdataset)) { INSIST(eresult == DNS_R_NCACHENXDOMAIN || eresult == DNS_R_NCACHENXRRSET); } - event->result = eresult; + resp->result = eresult; if (adbp != NULL && *adbp != NULL) { if (anodep != NULL && *anodep != NULL) { dns_db_detachnode(*adbp, anodep); @@ -6590,7 +6579,7 @@ ncache_message(fetchctx_t *fctx, dns_message_t *message, dns_dbnode_t *node = NULL, **anodep = NULL; dns_rdataset_t *ardataset = NULL; bool need_validation = false, secure_domain = false; - dns_fetchevent_t *event = NULL; + dns_fetchresponse_t *resp = NULL; uint32_t ttl; unsigned int valoptions = 0; bool checknta = true; @@ -6663,8 +6652,7 @@ ncache_message(fetchctx_t *fctx, dns_message_t *message, * Do negative response validation. */ result = valcreate(fctx, message, addrinfo, name, fctx->type, - NULL, NULL, valoptions, fctx->restask, - fctx->loop); + NULL, NULL, valoptions, fctx->loop); /* * If validation is necessary, return now. Otherwise * continue to process the message, letting the @@ -6676,12 +6664,12 @@ ncache_message(fetchctx_t *fctx, dns_message_t *message, LOCK(&fctx->lock); if (!HAVE_ANSWER(fctx)) { - event = ISC_LIST_HEAD(fctx->events); - if (event != NULL) { - adbp = &event->db; - dns_name_copy(name, event->foundname); - anodep = &event->node; - ardataset = event->rdataset; + resp = ISC_LIST_HEAD(fctx->resps); + if (resp != NULL) { + adbp = &resp->db; + dns_name_copy(name, resp->foundname); + anodep = &resp->node; + ardataset = resp->rdataset; } } @@ -6711,8 +6699,8 @@ ncache_message(fetchctx_t *fctx, dns_message_t *message, if (!HAVE_ANSWER(fctx)) { FCTX_ATTR_SET(fctx, FCTX_ATTR_HAVEANSWER); - if (event != NULL) { - event->result = eresult; + if (resp != NULL) { + resp->result = eresult; if (adbp != NULL && *adbp != NULL) { if (anodep != NULL && *anodep != NULL) { dns_db_detachnode(*adbp, anodep); @@ -7222,36 +7210,39 @@ release_fctx(fetchctx_t *fctx) { } static void -resume_dslookup(isc_task_t *task, isc_event_t *event) { +resume_dslookup(void *arg) { + dns_fetchresponse_t *resp = (dns_fetchresponse_t *)arg; + fetchctx_t *fctx = resp->arg; + isc_loop_t *loop = resp->loop; isc_result_t result; - dns_fetchevent_t *fevent = (dns_fetchevent_t *)event; - fetchctx_t *fctx = event->ev_arg; dns_resolver_t *res = NULL; - dns_rdataset_t *nsrdataset = NULL; + dns_rdataset_t *frdataset = NULL, *nsrdataset = NULL; dns_rdataset_t nameservers; dns_fixedname_t fixed; dns_name_t *domain = NULL; unsigned int n; dns_fetch_t *fetch = NULL; - REQUIRE(event->ev_type == DNS_EVENT_FETCHDONE); - + REQUIRE(resp->type == FETCHDONE); REQUIRE(VALID_FCTX(fctx)); + res = fctx->res; REQUIRE(fctx->tid == isc_tid()); - UNUSED(task); FCTXTRACE("resume_dslookup"); - if (fevent->node != NULL) { - dns_db_detachnode(fevent->db, &fevent->node); + if (resp->node != NULL) { + dns_db_detachnode(resp->db, &resp->node); } - if (fevent->db != NULL) { - dns_db_detach(&fevent->db); + if (resp->db != NULL) { + dns_db_detach(&resp->db); } - result = fevent->result; + /* Preserve data from resp before freeing it. */ + frdataset = resp->rdataset; + result = resp->result; + isc_mem_putanddetach(&resp->mctx, resp, sizeof(*resp)); LOCK(&fctx->lock); if (SHUTTINGDOWN(fctx)) { @@ -7271,7 +7262,7 @@ resume_dslookup(isc_task_t *task, isc_event_t *event) { if (dns_rdataset_isassociated(&fctx->nameservers)) { dns_rdataset_disassociate(&fctx->nameservers); } - dns_rdataset_clone(fevent->rdataset, &fctx->nameservers); + dns_rdataset_clone(frdataset, &fctx->nameservers); fctx->ns_ttl = fctx->nameservers.ttl; fctx->ns_ttl_ok = true; @@ -7325,7 +7316,7 @@ resume_dslookup(isc_task_t *task, isc_event_t *event) { fetchctx_ref(fctx); result = dns_resolver_createfetch( res, fctx->nsname, dns_rdatatype_ns, domain, nsrdataset, - NULL, NULL, 0, fctx->options, 0, NULL, task, + NULL, NULL, 0, fctx->options, 0, NULL, loop, resume_dslookup, fctx, &fctx->nsrrset, NULL, &fctx->nsfetch); if (result != ISC_R_SUCCESS) { @@ -7343,12 +7334,10 @@ resume_dslookup(isc_task_t *task, isc_event_t *event) { cleanup: dns_resolver_destroyfetch(&fetch); - if (dns_rdataset_isassociated(fevent->rdataset)) { - dns_rdataset_disassociate(fevent->rdataset); + if (dns_rdataset_isassociated(frdataset)) { + dns_rdataset_disassociate(frdataset); } - isc_event_free(&event); - if (result != ISC_R_SUCCESS) { /* An error occurred, tear down whole fctx */ fctx_done_unref(fctx, result); @@ -7925,7 +7914,7 @@ resquery_response(isc_result_t eresult, isc_region_t *region, void *arg) { /* * rctx_respinit(): * Initialize the response context structure 'rctx' to all zeroes, then - * set the task, event, query and fctx information from + * set the loop, event, query and fctx information from * resquery_response(). */ static void @@ -9714,7 +9703,7 @@ rctx_chaseds(respctx_t *rctx, dns_message_t *message, fetchctx_ref(fctx); result = dns_resolver_createfetch( fctx->res, fctx->nsname, dns_rdatatype_ns, NULL, NULL, NULL, - NULL, 0, fctx->options, 0, NULL, fctx->restask, resume_dslookup, + NULL, 0, fctx->options, 0, NULL, fctx->loop, resume_dslookup, fctx, &fctx->nsrrset, NULL, &fctx->nsfetch); if (result != ISC_R_SUCCESS) { if (result == DNS_R_DUPLICATE) { @@ -9780,7 +9769,7 @@ rctx_done(respctx_t *rctx, isc_result_t result) { * If nobody's waiting for results, don't resend or try next server. */ LOCK(&fctx->lock); - if (ISC_LIST_EMPTY(fctx->events)) { + if (ISC_LIST_EMPTY(fctx->resps)) { rctx->next_server = false; rctx->resend = false; } @@ -10077,11 +10066,6 @@ dns_resolver__destroy(dns_resolver_t *res) { isc_mutex_destroy(&res->primelock); isc_mutex_destroy(&res->lock); - for (size_t i = 0; i < res->ntasks; i++) { - isc_task_detach(&res->tasks[i]); - } - isc_mem_put(res->mctx, res->tasks, res->ntasks * sizeof(res->tasks[0])); - INSIST(isc_hashmap_count(res->fctxs) == 0); isc_hashmap_destroy(&res->fctxs); isc_rwlock_destroy(&res->fctxs_lock); @@ -10139,12 +10123,11 @@ spillattimer_countdown(void *arg) { isc_result_t dns_resolver_create(dns_view_t *view, isc_loopmgr_t *loopmgr, - isc_taskmgr_t *taskmgr, unsigned int ndisp, isc_nm_t *nm, - unsigned int options, isc_tlsctx_cache_t *tlsctx_cache, + unsigned int ndisp, isc_nm_t *nm, unsigned int options, + isc_tlsctx_cache_t *tlsctx_cache, dns_dispatchmgr_t *dispatchmgr, dns_dispatch_t *dispatchv4, dns_dispatch_t *dispatchv6, dns_resolver_t **resp) { isc_result_t result = ISC_R_SUCCESS; - char name[sizeof("res4294967295")]; dns_resolver_t *res = NULL; /* @@ -10165,7 +10148,6 @@ dns_resolver_create(dns_view_t *view, isc_loopmgr_t *loopmgr, .loopmgr = loopmgr, .rdclass = view->rdclass, .nm = nm, - .taskmgr = taskmgr, .dispatchmgr = dispatchmgr, .options = options, .tlsctx_cache = tlsctx_cache, @@ -10177,7 +10159,6 @@ dns_resolver_create(dns_view_t *view, isc_loopmgr_t *loopmgr, .query_timeout = DEFAULT_QUERY_TIMEOUT, .maxdepth = DEFAULT_RECURSION_DEPTH, .maxqueries = DEFAULT_MAX_QUERIES, - .ntasks = isc_loopmgr_nloops(loopmgr), .alternates = ISC_LIST_INITIALIZER, }; @@ -10196,23 +10177,7 @@ dns_resolver_create(dns_view_t *view, isc_loopmgr_t *loopmgr, result = dns_badcache_init(res->mctx, DNS_RESOLVER_BADCACHESIZE, &res->badcache); if (result != ISC_R_SUCCESS) { - goto cleanup_res; - } - - res->tasks = isc_mem_getx( - res->mctx, res->ntasks * sizeof(res->tasks[0]), ISC_MEM_ZERO); - for (uint32_t i = 0; i < res->ntasks; i++) { - /* - * Since we have a pool of tasks we bind them to task - * queues to spread the load evenly - */ - result = isc_task_create(taskmgr, &res->tasks[i], i); - if (result != ISC_R_SUCCESS) { - goto cleanup_tasks; - } - - snprintf(name, sizeof(name), "res%" PRIu32, i); - isc_task_setname(res->tasks[i], name, res); + goto cleanup; } /* This needs to be case sensitive to not lowercase options and type */ @@ -10243,40 +10208,26 @@ dns_resolver_create(dns_view_t *view, isc_loopmgr_t *loopmgr, return (ISC_R_SUCCESS); -cleanup_tasks: - for (size_t i = 0; i < res->ntasks; i++) { - if (res->tasks[i] != NULL) { - isc_task_detach(&res->tasks[i]); - } - } - isc_mem_put(res->mctx, res->tasks, res->ntasks * sizeof(res->tasks[0])); - - dns_badcache_destroy(&res->badcache); - -cleanup_res: +cleanup: dns_view_weakdetach(&res->view); isc_mem_putanddetach(&res->mctx, res, sizeof(*res)); return (result); } static void -prime_done(isc_task_t *task, isc_event_t *event) { - dns_resolver_t *res; - dns_fetchevent_t *fevent; - dns_fetch_t *fetch; +prime_done(void *arg) { + dns_fetchresponse_t *resp = (dns_fetchresponse_t *)arg; + dns_resolver_t *res = resp->arg; + dns_fetch_t *fetch = NULL; dns_db_t *db = NULL; - REQUIRE(event->ev_type == DNS_EVENT_FETCHDONE); - fevent = (dns_fetchevent_t *)event; - res = event->ev_arg; + REQUIRE(resp->type == FETCHDONE); REQUIRE(VALID_RESOLVER(res)); isc_log_write(dns_lctx, DNS_LOGCATEGORY_RESOLVER, DNS_LOGMODULE_RESOLVER, ISC_LOG_INFO, "resolver priming query complete: %s", - isc_result_totext(fevent->result)); - - UNUSED(task); + isc_result_totext(resp->result)); LOCK(&res->primelock); fetch = res->primefetch; @@ -10285,7 +10236,7 @@ prime_done(isc_task_t *task, isc_event_t *event) { atomic_compare_exchange_enforced(&res->priming, &(bool){ true }, false); - if (fevent->result == ISC_R_SUCCESS && res->view->cache != NULL && + if (resp->result == ISC_R_SUCCESS && res->view->cache != NULL && res->view->hints != NULL) { dns_cache_attachdb(res->view->cache, &db); @@ -10293,20 +10244,19 @@ prime_done(isc_task_t *task, isc_event_t *event) { dns_db_detach(&db); } - if (fevent->node != NULL) { - dns_db_detachnode(fevent->db, &fevent->node); + if (resp->node != NULL) { + dns_db_detachnode(resp->db, &resp->node); } - if (fevent->db != NULL) { - dns_db_detach(&fevent->db); + if (resp->db != NULL) { + dns_db_detach(&resp->db); } - if (dns_rdataset_isassociated(fevent->rdataset)) { - dns_rdataset_disassociate(fevent->rdataset); + if (dns_rdataset_isassociated(resp->rdataset)) { + dns_rdataset_disassociate(resp->rdataset); } - INSIST(fevent->sigrdataset == NULL); + INSIST(resp->sigrdataset == NULL); - isc_mem_put(res->mctx, fevent->rdataset, sizeof(*fevent->rdataset)); - - isc_event_free(&event); + isc_mem_put(res->mctx, resp->rdataset, sizeof(*resp->rdataset)); + isc_mem_putanddetach(&resp->mctx, resp, sizeof(*resp)); dns_resolver_destroyfetch(&fetch); } @@ -10344,8 +10294,9 @@ dns_resolver_prime(dns_resolver_t *res) { LOCK(&res->primelock); result = dns_resolver_createfetch( res, dns_rootname, dns_rdatatype_ns, NULL, NULL, NULL, - NULL, 0, DNS_FETCHOPT_NOFORWARD, 0, NULL, res->tasks[0], - prime_done, res, rdataset, NULL, &res->primefetch); + NULL, 0, DNS_FETCHOPT_NOFORWARD, 0, NULL, + isc_loop_main(res->loopmgr), prime_done, res, rdataset, + NULL, &res->primefetch); UNLOCK(&res->primelock); if (result != ISC_R_SUCCESS) { @@ -10613,10 +10564,9 @@ dns_resolver_createfetch(dns_resolver_t *res, const dns_name_t *name, dns_forwarders_t *forwarders, const isc_sockaddr_t *client, dns_messageid_t id, unsigned int options, unsigned int depth, - isc_counter_t *qc, isc_task_t *task, - isc_taskaction_t action, void *arg, - dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset, - dns_fetch_t **fetchp) { + isc_counter_t *qc, isc_loop_t *loop, isc_job_cb cb, + void *arg, dns_rdataset_t *rdataset, + dns_rdataset_t *sigrdataset, dns_fetch_t **fetchp) { dns_fetch_t *fetch = NULL; fetchctx_t *fctx = NULL; isc_result_t result = ISC_R_SUCCESS; @@ -10675,18 +10625,14 @@ dns_resolver_createfetch(dns_resolver_t *res, const dns_name_t *name, INSIST(!SHUTTINGDOWN(fctx)); - /* - * Is this a duplicate? - */ - if (client != NULL) { - dns_fetchevent_t *fevent; - for (fevent = ISC_LIST_HEAD(fctx->events); - fevent != NULL; - fevent = ISC_LIST_NEXT(fevent, ev_link)) + /* Is this a duplicate? */ + if (fctx != NULL && client != NULL) { + dns_fetchresponse_t *resp = NULL; + for (resp = ISC_LIST_HEAD(fctx->resps); resp != NULL; + resp = ISC_LIST_NEXT(resp, link)) { - if (fevent->client != NULL && - fevent->id == id && - isc_sockaddr_equal(fevent->client, client)) + if (resp->client != NULL && resp->id == id && + isc_sockaddr_equal(resp->client, client)) { result = DNS_R_DUPLICATE; goto unlock; @@ -10717,12 +10663,12 @@ dns_resolver_createfetch(dns_resolver_t *res, const dns_name_t *name, fctx->depth = depth; } - fctx_join(fctx, task, client, id, action, arg, rdataset, sigrdataset, + fctx_join(fctx, loop, client, id, cb, arg, rdataset, sigrdataset, fetch); if ((options & DNS_FETCHOPT_TRYSTALE_ONTIMEOUT) != 0) { - fctx_add_event(fctx, task, client, id, action, arg, NULL, NULL, - fetch, DNS_EVENT_TRYSTALE); + fctx_add_event(fctx, loop, client, id, cb, arg, NULL, NULL, + fetch, TRYSTALE); } if (new_fctx) { @@ -10752,8 +10698,8 @@ fail: void dns_resolver_cancelfetch(dns_fetch_t *fetch) { fetchctx_t *fctx = NULL; - dns_fetchevent_t *event_trystale = NULL; - dns_fetchevent_t *event_fetchdone = NULL; + dns_fetchresponse_t *trystale = NULL; + dns_fetchresponse_t *fetchdone = NULL; REQUIRE(DNS_FETCH_VALID(fetch)); fctx = fetch->private; @@ -10764,46 +10710,53 @@ dns_resolver_cancelfetch(dns_fetch_t *fetch) { LOCK(&fctx->lock); /* - * Find all the events associated with the provided 'fetch' (as opposed - * to those for other fetches that have joined the same fctx). The - * event(s) found are only sent and removed from the fctx->events list - * after this loop is finished (i.e. the fctx->events list is not + * Find completion events associated with this fetch (as opposed + * to those for other fetches that have joined the same fctx). + * The event(s) found are only sent and removed from the fctx->resps + * list after this loop is finished (i.e. the fctx->resps list is not * modified during iteration). */ - for (dns_fetchevent_t *event = ISC_LIST_HEAD(fctx->events); - event != NULL; event = ISC_LIST_NEXT(event, ev_link)) - { - /* - * Only process events associated with the provided 'fetch'. - */ - if (event->fetch != fetch) { - continue; - } + if (fctx->state != fetchstate_done) { + dns_fetchresponse_t *next = NULL; + for (dns_fetchresponse_t *resp = ISC_LIST_HEAD(fctx->resps); + resp != NULL; resp = next) + { + next = ISC_LIST_NEXT(resp, link); - /* - * Track various events associated with the provided 'fetch' in - * separate variables as they will need to be sent in a - * specific order. - */ - switch (event->ev_type) { - case DNS_EVENT_TRYSTALE: - INSIST(event_trystale == NULL); - event_trystale = event; - break; - case DNS_EVENT_FETCHDONE: - INSIST(event_fetchdone == NULL); - event_fetchdone = event; - break; - default: - UNREACHABLE(); - } + /* + * Only process events associated with the provided + * 'fetch'. + */ + if (resp->fetch != fetch) { + continue; + } - /* - * Break out of the loop once all possible types of events - * associated with the provided 'fetch' are found. - */ - if (event_trystale != NULL && event_fetchdone != NULL) { - break; + /* + * Track various events associated with the + * provided 'fetch' in separate variables as they + * will need to be sent in a specific order. + */ + switch (resp->type) { + case TRYSTALE: + INSIST(trystale == NULL); + trystale = resp; + break; + case FETCHDONE: + INSIST(fetchdone == NULL); + fetchdone = resp; + break; + default: + UNREACHABLE(); + } + + /* + * Break out of the loop once all possible types of + * events associated with the provided 'fetch' are + * found. + */ + if (trystale != NULL && fetchdone != NULL) { + break; + } } } @@ -10812,19 +10765,15 @@ dns_resolver_cancelfetch(dns_fetch_t *fetch) { * because the latter clears the "recursing" query attribute, which is * required by both events (handled by the same callback function). */ - if (event_trystale != NULL) { - isc_task_t *etask = event_trystale->ev_sender; - ISC_LIST_UNLINK(fctx->events, event_trystale, ev_link); - event_trystale->ev_sender = fctx; - event_trystale->result = ISC_R_CANCELED; - isc_task_sendanddetach(&etask, ISC_EVENT_PTR(&event_trystale)); + if (trystale != NULL) { + trystale->result = ISC_R_CANCELED; + ISC_LIST_UNLINK(fctx->resps, trystale, link); + isc_async_run(trystale->loop, trystale->cb, trystale); } - if (event_fetchdone != NULL) { - isc_task_t *etask = event_fetchdone->ev_sender; - ISC_LIST_UNLINK(fctx->events, event_fetchdone, ev_link); - event_fetchdone->ev_sender = fctx; - event_fetchdone->result = ISC_R_CANCELED; - isc_task_sendanddetach(&etask, ISC_EVENT_PTR(&event_fetchdone)); + if (fetchdone != NULL) { + fetchdone->result = ISC_R_CANCELED; + ISC_LIST_UNLINK(fctx->resps, fetchdone, link); + isc_async_run(fetchdone->loop, fetchdone->cb, fetchdone); } /* @@ -10857,10 +10806,14 @@ dns_resolver_destroyfetch(dns_fetch_t **fetchp) { * Sanity check: the caller should have gotten its event before * trying to destroy the fetch. */ - for (dns_fetchevent_t *event = ISC_LIST_HEAD(fctx->events); - event != NULL; event = ISC_LIST_NEXT(event, ev_link)) - { - RUNTIME_CHECK(event->fetch != fetch); + if (fctx->state != fetchstate_done) { + dns_fetchresponse_t *resp = NULL, *next = NULL; + for (resp = ISC_LIST_HEAD(fctx->resps); resp != NULL; + resp = next) + { + next = ISC_LIST_NEXT(resp, link); + RUNTIME_CHECK(resp->fetch != fetch); + } } UNLOCK(&fctx->lock); @@ -11522,7 +11475,8 @@ dns_resolver_setstats(dns_resolver_t *res, isc_stats_t *stats) { isc_stats_attach(stats, &res->stats); /* initialize the bucket "counter"; it's a static value */ - set_stats(res, dns_resstatscounter_buckets, res->ntasks); + set_stats(res, dns_resstatscounter_buckets, + isc_loopmgr_nloops(res->loopmgr)); } void diff --git a/lib/dns/validator.c b/lib/dns/validator.c index 69f5a69dbf..53b35c1e8d 100644 --- a/lib/dns/validator.c +++ b/lib/dns/validator.c @@ -20,7 +20,6 @@ #include #include #include -#include #include #include @@ -207,7 +206,7 @@ marksecure(dns_valstatus_t *vstat) { } /* - * Validator 'val' is finished; send the completion event to the task + * Validator 'val' is finished; send the completion event to the loop * that called dns_validator_create(), with result `result`. * * Caller must be holding the validator lock. @@ -367,34 +366,29 @@ trynsec3: * If not found, fail the validation process. */ static void -fetch_callback_dnskey(isc_task_t *task, isc_event_t *event) { - dns_fetchevent_t *devent; - dns_validator_t *val; - dns_rdataset_t *rdataset; - bool want_destroy; +fetch_callback_dnskey(void *arg) { + dns_fetchresponse_t *resp = (dns_fetchresponse_t *)arg; + dns_validator_t *val = resp->arg; + dns_rdataset_t *rdataset = &val->frdataset; + isc_result_t eresult = resp->result; isc_result_t result; - isc_result_t eresult; isc_result_t saved_result; - dns_fetch_t *fetch; + dns_fetch_t *fetch = NULL; + bool want_destroy; - UNUSED(task); - INSIST(event->ev_type == DNS_EVENT_FETCHDONE); - devent = (dns_fetchevent_t *)event; - val = devent->ev_arg; - rdataset = &val->frdataset; - eresult = devent->result; + INSIST(resp->type == FETCHDONE); /* Free resources which are not of interest. */ - if (devent->node != NULL) { - dns_db_detachnode(devent->db, &devent->node); + if (resp->node != NULL) { + dns_db_detachnode(resp->db, &resp->node); } - if (devent->db != NULL) { - dns_db_detach(&devent->db); + if (resp->db != NULL) { + dns_db_detach(&resp->db); } if (dns_rdataset_isassociated(&val->fsigrdataset)) { dns_rdataset_disassociate(&val->fsigrdataset); } - isc_event_free(&event); + isc_mem_putanddetach(&resp->mctx, resp, sizeof(*resp)); INSIST(val->vstat != NULL); @@ -467,21 +461,16 @@ fetch_callback_dnskey(isc_task_t *task, isc_event_t *event) { * walking a trust chain, or an insecurity proof. */ static void -fetch_callback_ds(isc_task_t *task, isc_event_t *event) { - dns_fetchevent_t *devent; - dns_validator_t *val; - dns_rdataset_t *rdataset; - bool want_destroy, trustchain; +fetch_callback_ds(void *arg) { + dns_fetchresponse_t *resp = (dns_fetchresponse_t *)arg; + dns_validator_t *val = resp->arg; + dns_rdataset_t *rdataset = &val->frdataset; + isc_result_t eresult = resp->result; isc_result_t result; - isc_result_t eresult; - dns_fetch_t *fetch; + dns_fetch_t *fetch = NULL; + bool want_destroy, trustchain; - UNUSED(task); - INSIST(event->ev_type == DNS_EVENT_FETCHDONE); - devent = (dns_fetchevent_t *)event; - val = devent->ev_arg; - rdataset = &val->frdataset; - eresult = devent->result; + INSIST(resp->type == FETCHDONE); /* * Set 'trustchain' to true if we're walking a chain of @@ -490,11 +479,11 @@ fetch_callback_ds(isc_task_t *task, isc_event_t *event) { trustchain = ((val->attributes & VALATTR_INSECURITY) == 0); /* Free resources which are not of interest. */ - if (devent->node != NULL) { - dns_db_detachnode(devent->db, &devent->node); + if (resp->node != NULL) { + dns_db_detachnode(resp->db, &resp->node); } - if (devent->db != NULL) { - dns_db_detach(&devent->db); + if (resp->db != NULL) { + dns_db_detach(&resp->db); } if (dns_rdataset_isassociated(&val->fsigrdataset)) { dns_rdataset_disassociate(&val->fsigrdataset); @@ -572,7 +561,7 @@ fetch_callback_ds(isc_task_t *task, isc_event_t *event) { } else if (eresult == DNS_R_SERVFAIL) { goto unexpected; } else if (eresult != DNS_R_CNAME && - isdelegation(devent->foundname, &val->frdataset, + isdelegation(resp->foundname, &val->frdataset, eresult)) { /* @@ -608,7 +597,7 @@ fetch_callback_ds(isc_task_t *task, isc_event_t *event) { } done: - isc_event_free(&event); + isc_mem_putanddetach(&resp->mctx, resp, sizeof(*resp)); want_destroy = exit_check(val); UNLOCK(&val->lock); @@ -996,7 +985,7 @@ check_deadlock(dns_validator_t *val, dns_name_t *name, dns_rdatatype_t type, */ static isc_result_t create_fetch(dns_validator_t *val, dns_name_t *name, dns_rdatatype_t type, - isc_taskaction_t callback, const char *caller) { + isc_job_cb callback, const char *caller) { unsigned int fopts = 0; disassociate_rdatasets(val); @@ -1018,7 +1007,7 @@ create_fetch(dns_validator_t *val, dns_name_t *name, dns_rdatatype_t type, validator_logcreate(val, name, type, caller, "fetch"); return (dns_resolver_createfetch( val->view->resolver, name, type, NULL, NULL, NULL, NULL, 0, - fopts, 0, NULL, val->task, callback, val, &val->frdataset, + fopts, 0, NULL, val->loop, callback, val, &val->frdataset, &val->fsigrdataset, &val->fetch)); } @@ -1049,8 +1038,8 @@ create_validator(dns_validator_t *val, dns_name_t *name, dns_rdatatype_t type, validator_logcreate(val, name, type, caller, "validator"); result = dns_validator_create(val->view, name, type, rdataset, sig, - NULL, vopts, val->task, val->loop, cb, - val, &val->subvalidator); + NULL, vopts, val->loop, cb, val, + &val->subvalidator); if (result == ISC_R_SUCCESS) { val->subvalidator->parent = val; val->subvalidator->depth = val->depth + 1; @@ -3074,8 +3063,8 @@ isc_result_t dns_validator_create(dns_view_t *view, dns_name_t *name, dns_rdatatype_t type, dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset, dns_message_t *message, unsigned int options, - isc_task_t *task, isc_loop_t *loop, isc_job_cb cb, - void *arg, dns_validator_t **validatorp) { + isc_loop_t *loop, isc_job_cb cb, void *arg, + dns_validator_t **validatorp) { isc_result_t result = ISC_R_FAILURE; dns_validator_t *val = NULL; dns_valstatus_t *vstat = NULL; @@ -3105,7 +3094,6 @@ dns_validator_create(dns_view_t *view, dns_name_t *name, dns_rdatatype_t type, .loop = loop, .cb = cb, .arg = arg }; - isc_task_attach(task, &val->task); dns_view_attach(view, &val->view); isc_mutex_init(&val->lock); @@ -3135,7 +3123,6 @@ dns_validator_create(dns_view_t *view, dns_name_t *name, dns_rdatatype_t type, cleanup: isc_mutex_destroy(&val->lock); - isc_task_detach(&val->task); isc_mem_putanddetach(&vstat->mctx, vstat, sizeof(*vstat)); dns_view_detach(&val->view); @@ -3206,7 +3193,6 @@ destroy(dns_validator_t *val) { } isc_mutex_destroy(&val->lock); dns_view_detach(&val->view); - isc_task_detach(&val->task); if (val->vstat->message != NULL) { dns_message_detach(&val->vstat->message); } diff --git a/lib/dns/view.c b/lib/dns/view.c index ed863b1bff..cc5315e96d 100644 --- a/lib/dns/view.c +++ b/lib/dns/view.c @@ -319,9 +319,6 @@ destroy(dns_view_t *view) { if (view->requestmgr != NULL) { dns_requestmgr_detach(&view->requestmgr); } - if (view->task != NULL) { - isc_task_detach(&view->task); - } if (view->hints != NULL) { dns_db_detach(&view->hints); } @@ -640,9 +637,8 @@ dns_view_createzonetable(dns_view_t *view) { isc_result_t dns_view_createresolver(dns_view_t *view, isc_loopmgr_t *loopmgr, - isc_taskmgr_t *taskmgr, unsigned int ndisp, - isc_nm_t *netmgr, unsigned int options, - isc_tlsctx_cache_t *tlsctx_cache, + unsigned int ndisp, isc_nm_t *netmgr, + unsigned int options, isc_tlsctx_cache_t *tlsctx_cache, dns_dispatchmgr_t *dispatchmgr, dns_dispatch_t *dispatchv4, dns_dispatch_t *dispatchv6) { @@ -653,23 +649,18 @@ dns_view_createresolver(dns_view_t *view, isc_loopmgr_t *loopmgr, REQUIRE(!view->frozen); REQUIRE(view->resolver == NULL); - result = isc_task_create(taskmgr, &view->task, 0); - if (result != ISC_R_SUCCESS) { - return (result); - } - isc_task_setname(view->task, "view", view); + view->loop = isc_loop_current(loopmgr); - result = dns_resolver_create(view, loopmgr, taskmgr, ndisp, netmgr, - options, tlsctx_cache, dispatchmgr, - dispatchv4, dispatchv6, &view->resolver); + result = dns_resolver_create(view, loopmgr, ndisp, netmgr, options, + tlsctx_cache, dispatchmgr, dispatchv4, + dispatchv6, &view->resolver); if (result != ISC_R_SUCCESS) { - isc_task_detach(&view->task); return (result); } isc_mem_create(&mctx); isc_mem_setname(mctx, "ADB"); - result = dns_adb_create(mctx, view, loopmgr, taskmgr, &view->adb); + result = dns_adb_create(mctx, view, loopmgr, &view->adb); isc_mem_detach(&mctx); if (result != ISC_R_SUCCESS) { goto cleanup_resolver; @@ -1691,14 +1682,12 @@ dns_view_freezezones(dns_view_t *view, bool value) { } isc_result_t -dns_view_initntatable(dns_view_t *view, isc_taskmgr_t *taskmgr, - isc_loopmgr_t *loopmgr) { +dns_view_initntatable(dns_view_t *view, isc_loopmgr_t *loopmgr) { REQUIRE(DNS_VIEW_VALID(view)); if (view->ntatable_priv != NULL) { dns_ntatable_detach(&view->ntatable_priv); } - return (dns_ntatable_create(view, taskmgr, loopmgr, - &view->ntatable_priv)); + return (dns_ntatable_create(view, loopmgr, &view->ntatable_priv)); } isc_result_t diff --git a/lib/dns/zone.c b/lib/dns/zone.c index 681becb8a5..860e784c89 100644 --- a/lib/dns/zone.c +++ b/lib/dns/zone.c @@ -9973,11 +9973,11 @@ revocable(dns_keyfetch_t *kfetch, dns_rdata_keydata_t *keydata) { * local trust anchors according to RFC5011. */ static void -keyfetch_done(isc_task_t *task, isc_event_t *event) { +keyfetch_done(void *arg) { + dns_fetchresponse_t *resp = (dns_fetchresponse_t *)arg; isc_result_t result, eresult; - dns_fetchevent_t *devent; - dns_keyfetch_t *kfetch; - dns_zone_t *zone; + dns_keyfetch_t *kfetch = NULL; + dns_zone_t *zone = NULL; isc_mem_t *mctx = NULL; dns_keytable_t *secroots = NULL; dns_dbversion_t *ver = NULL; @@ -10004,11 +10004,12 @@ keyfetch_done(isc_task_t *task, isc_event_t *event) { dns_rdataset_t *dnskeys = NULL, *dnskeysigs = NULL; dns_rdataset_t *keydataset = NULL, dsset; - UNUSED(task); - INSIST(event != NULL && event->ev_type == DNS_EVENT_FETCHDONE); - INSIST(event->ev_arg != NULL); + INSIST(resp != NULL && resp->type == FETCHDONE); + + kfetch = resp->arg; + + INSIST(kfetch != NULL); - kfetch = event->ev_arg; zone = kfetch->zone; mctx = kfetch->mctx; keyname = dns_fixedname_name(&kfetch->name); @@ -10016,17 +10017,16 @@ keyfetch_done(isc_task_t *task, isc_event_t *event) { dnskeysigs = &kfetch->dnskeysigset; keydataset = &kfetch->keydataset; - devent = (dns_fetchevent_t *)event; - eresult = devent->result; + eresult = resp->result; /* Free resources which are not of interest */ - if (devent->node != NULL) { - dns_db_detachnode(devent->db, &devent->node); + if (resp->node != NULL) { + dns_db_detachnode(resp->db, &resp->node); } - if (devent->db != NULL) { - dns_db_detach(&devent->db); + if (resp->db != NULL) { + dns_db_detach(&resp->db); } - isc_event_free(&event); + dns_resolver_destroyfetch(&kfetch->fetch); LOCK_ZONE(zone); @@ -10621,6 +10621,7 @@ cleanup: dns_name_free(keyname, mctx); isc_mem_putanddetach(&kfetch->mctx, kfetch, sizeof(dns_keyfetch_t)); + isc_mem_putanddetach(&resp->mctx, resp, sizeof(*resp)); if (secroots != NULL) { dns_keytable_detach(&secroots); @@ -10710,15 +10711,13 @@ do_keyfetch(void *arg) { */ result = dns_resolver_createfetch( resolver, kname, dns_rdatatype_dnskey, NULL, NULL, NULL, NULL, - 0, options, 0, NULL, zone->task, keyfetch_done, kfetch, + 0, options, 0, NULL, zone->loop, keyfetch_done, kfetch, &kfetch->dnskeyset, &kfetch->dnskeysigset, &kfetch->fetch); dns_resolver_detach(&resolver); - if (result != ISC_R_SUCCESS) { - goto retry; + if (result == ISC_R_SUCCESS) { + return; } - - return; retry: retry_keyfetch(kfetch, kname); } diff --git a/lib/ns/include/ns/hooks.h b/lib/ns/include/ns/hooks.h index 7ee00e09b3..b50327219e 100644 --- a/lib/ns/include/ns/hooks.h +++ b/lib/ns/include/ns/hooks.h @@ -436,7 +436,7 @@ struct ns_hookasync { /* * isc_event to be sent on the completion of a hook-initiated asyncronous - * process, similar to dns_fetchevent_t. + * process, similar to dns_fetchresponse_t. */ typedef struct ns_hook_resume { ns_hookasync_t *ctx; /* asynchronous processing context */ diff --git a/lib/ns/include/ns/query.h b/lib/ns/include/ns/query.h index 7bbe4ba5ed..abb18fbd99 100644 --- a/lib/ns/include/ns/query.h +++ b/lib/ns/include/ns/query.h @@ -220,7 +220,7 @@ struct query_ctx { ns_client_t *client; /* client object */ bool detach_client; /* client needs detaching */ - dns_fetchevent_t *event; /* recursion event */ + dns_fetchresponse_t *fresp; /* recursion response */ dns_db_t *db; /* zone or cache database */ dns_dbversion_t *version; /* DB version */ diff --git a/lib/ns/query.c b/lib/ns/query.c index 22f1a3db6c..13c7a33534 100644 --- a/lib/ns/query.c +++ b/lib/ns/query.c @@ -394,8 +394,8 @@ static void query_trace(query_ctx_t *qctx); static void -qctx_init(ns_client_t *client, dns_fetchevent_t **eventp, dns_rdatatype_t qtype, - query_ctx_t *qctx); +qctx_init(ns_client_t *client, dns_fetchresponse_t **respp, + dns_rdatatype_t qtype, query_ctx_t *qctx); static isc_result_t qctx_prepare_buffers(query_ctx_t *qctx, isc_buffer_t *buffer); @@ -413,7 +413,7 @@ static isc_result_t query_lookup(query_ctx_t *qctx); static void -fetch_callback(isc_task_t *task, isc_event_t *event); +fetch_callback(void *arg); static void recparam_update(ns_query_recparam_t *param, dns_rdatatype_t qtype, @@ -2460,38 +2460,29 @@ fixfname(ns_client_t *client, dns_name_t **fname, isc_buffer_t **dbuf, } static void -free_devent(ns_client_t *client, isc_event_t **eventp, - dns_fetchevent_t **deventp) { - dns_fetchevent_t *devent = *deventp; +free_fresp(ns_client_t *client, dns_fetchresponse_t **frespp) { + dns_fetchresponse_t *fresp = *frespp; - REQUIRE((void *)(*eventp) == (void *)(*deventp)); + CTRACE(ISC_LOG_DEBUG(3), "free_fresp"); - CTRACE(ISC_LOG_DEBUG(3), "free_devent"); - - if (devent->fetch != NULL) { - dns_resolver_destroyfetch(&devent->fetch); + if (fresp->fetch != NULL) { + dns_resolver_destroyfetch(&fresp->fetch); } - if (devent->node != NULL) { - dns_db_detachnode(devent->db, &devent->node); + if (fresp->node != NULL) { + dns_db_detachnode(fresp->db, &fresp->node); } - if (devent->db != NULL) { - dns_db_detach(&devent->db); + if (fresp->db != NULL) { + dns_db_detach(&fresp->db); } - if (devent->rdataset != NULL) { - ns_client_putrdataset(client, &devent->rdataset); + if (fresp->rdataset != NULL) { + ns_client_putrdataset(client, &fresp->rdataset); } - if (devent->sigrdataset != NULL) { - ns_client_putrdataset(client, &devent->sigrdataset); + if (fresp->sigrdataset != NULL) { + ns_client_putrdataset(client, &fresp->sigrdataset); } - /* - * If the two pointers are the same then leave the setting of - * (*deventp) to NULL to isc_event_free. - */ - if ((void *)eventp != (void *)deventp) { - (*deventp) = NULL; - } - isc_event_free(eventp); + *frespp = NULL; + isc_mem_putanddetach(&fresp->mctx, fresp, sizeof(*fresp)); } static isc_result_t @@ -2630,30 +2621,25 @@ stale_refresh_aftermath(ns_client_t *client, isc_result_t result) { } static void -cleanup_after_fetch(isc_task_t *task, isc_event_t *event, const char *ctracestr, +cleanup_after_fetch(dns_fetchresponse_t *resp, const char *ctracestr, ns_query_rectype_t recursion_type) { - dns_fetchevent_t *devent = (dns_fetchevent_t *)event; - isc_nmhandle_t **handlep; - dns_fetch_t **fetchp; - ns_client_t *client; + ns_client_t *client = resp->arg; + isc_nmhandle_t **handlep = NULL; + dns_fetch_t **fetchp = NULL; isc_result_t result; - UNUSED(task); - - REQUIRE(event->ev_type == DNS_EVENT_FETCHDONE); - client = devent->ev_arg; + REQUIRE(resp->type == FETCHDONE); REQUIRE(NS_CLIENT_VALID(client)); - REQUIRE(task == client->manager->task); CTRACE(ISC_LOG_DEBUG(3), ctracestr); handlep = &client->query.recursions[recursion_type].handle; fetchp = &client->query.recursions[recursion_type].fetch; - result = devent->result; + result = resp->result; LOCK(&client->query.fetchlock); if (*fetchp != NULL) { - INSIST(devent->fetch == *fetchp); + INSIST(resp->fetch == *fetchp); *fetchp = NULL; } UNLOCK(&client->query.fetchlock); @@ -2664,24 +2650,23 @@ cleanup_after_fetch(isc_task_t *task, isc_event_t *event, const char *ctracestr, } recursionquotatype_detach(client, recursion_type); - free_devent(client, &event, &devent); + free_fresp(client, &resp); isc_nmhandle_detach(handlep); } static void -prefetch_done(isc_task_t *task, isc_event_t *event) { - cleanup_after_fetch(task, event, "prefetch_done", RECTYPE_PREFETCH); +prefetch_done(void *arg) { + cleanup_after_fetch(arg, "prefetch_done", RECTYPE_PREFETCH); } static void -rpzfetch_done(isc_task_t *task, isc_event_t *event) { - cleanup_after_fetch(task, event, "rpzfetch_done", RECTYPE_RPZ); +rpzfetch_done(void *arg) { + cleanup_after_fetch(arg, "rpzfetch_done", RECTYPE_RPZ); } static void -stale_refresh_done(isc_task_t *task, isc_event_t *event) { - cleanup_after_fetch(task, event, "stale_refresh_done", - RECTYPE_STALE_REFRESH); +stale_refresh_done(void *arg) { + cleanup_after_fetch(arg, "stale_refresh_done", RECTYPE_STALE_REFRESH); } /* @@ -2698,7 +2683,7 @@ fetch_and_forget(ns_client_t *client, dns_name_t *qname, dns_rdatatype_t qtype, dns_rdataset_t *tmprdataset; isc_sockaddr_t *peeraddr; unsigned int options; - isc_taskaction_t action; + isc_job_cb cb; isc_nmhandle_t **handlep; dns_fetch_t **fetchp; isc_result_t result; @@ -2719,15 +2704,15 @@ fetch_and_forget(ns_client_t *client, dns_name_t *qname, dns_rdatatype_t qtype, switch (recursion_type) { case RECTYPE_PREFETCH: options = client->query.fetchoptions | DNS_FETCHOPT_PREFETCH; - action = prefetch_done; + cb = prefetch_done; break; case RECTYPE_RPZ: options = client->query.fetchoptions; - action = rpzfetch_done; + cb = rpzfetch_done; break; case RECTYPE_STALE_REFRESH: options = client->query.fetchoptions; - action = stale_refresh_done; + cb = stale_refresh_done; break; default: UNREACHABLE(); @@ -2737,11 +2722,10 @@ fetch_and_forget(ns_client_t *client, dns_name_t *qname, dns_rdatatype_t qtype, fetchp = &client->query.recursions[recursion_type].fetch; isc_nmhandle_attach(client->handle, handlep); - result = dns_resolver_createfetch(client->view->resolver, qname, qtype, - NULL, NULL, NULL, peeraddr, - client->message->id, options, 0, NULL, - client->manager->task, action, client, - tmprdataset, NULL, fetchp); + result = dns_resolver_createfetch( + client->view->resolver, qname, qtype, NULL, NULL, NULL, + peeraddr, client->message->id, options, 0, NULL, + client->manager->loop, cb, client, tmprdataset, NULL, fetchp); if (result != ISC_R_SUCCESS) { ns_client_putrdataset(client, &tmprdataset); isc_nmhandle_detach(handlep); @@ -5335,8 +5319,8 @@ nxrrset: * when leaving the scope or freeing the qctx. */ static void -qctx_init(ns_client_t *client, dns_fetchevent_t **eventp, dns_rdatatype_t qtype, - query_ctx_t *qctx) { +qctx_init(ns_client_t *client, dns_fetchresponse_t **frespp, + dns_rdatatype_t qtype, query_ctx_t *qctx) { REQUIRE(qctx != NULL); REQUIRE(client != NULL); @@ -5349,11 +5333,11 @@ qctx_init(ns_client_t *client, dns_fetchevent_t **eventp, dns_rdatatype_t qtype, CCTRACE(ISC_LOG_DEBUG(3), "qctx_init"); - if (eventp != NULL) { - qctx->event = *eventp; - *eventp = NULL; + if (frespp != NULL) { + qctx->fresp = *frespp; + *frespp = NULL; } else { - qctx->event = NULL; + qctx->fresp = NULL; } qctx->qtype = qctx->type = qtype; qctx->result = ISC_R_SUCCESS; @@ -5424,9 +5408,8 @@ qctx_freedata(query_ctx_t *qctx) { dns_db_detach(&qctx->zdb); } - if (qctx->event != NULL && !qctx->client->nodetach) { - free_devent(qctx->client, ISC_EVENT_PTR(&qctx->event), - &qctx->event); + if (qctx->fresp != NULL && !qctx->client->nodetach) { + free_fresp(qctx->client, &qctx->fresp); } } @@ -5465,7 +5448,7 @@ qctx_save(query_ctx_t *src, query_ctx_t *tgt) { INITANDSAVE(tgt->rdataset, src->rdataset); INITANDSAVE(tgt->sigrdataset, src->sigrdataset); INITANDSAVE(tgt->noqname, src->noqname); - INITANDSAVE(tgt->event, src->event); + INITANDSAVE(tgt->fresp, src->fresp); INITANDSAVE(tgt->db, src->db); INITANDSAVE(tgt->version, src->version); INITANDSAVE(tgt->node, src->node); @@ -5797,7 +5780,7 @@ ns__query_start(query_ctx_t *qctx) { * Attach to the database which will be used to prepare the answer. * Update query statistics. */ - if (qctx->event == NULL && qctx->client->query.restarts == 0) { + if (qctx->fresp == NULL && qctx->client->query.restarts == 0) { if (qctx->is_zone) { if (qctx->zone != NULL) { /* @@ -6236,10 +6219,10 @@ query_lookup_stale(ns_client_t *client) { * call query_resume() to continue the ongoing work. */ static void -fetch_callback(isc_task_t *task, isc_event_t *event) { - dns_fetchevent_t *devent = (dns_fetchevent_t *)event; +fetch_callback(void *arg) { + dns_fetchresponse_t *resp = (dns_fetchresponse_t *)arg; + ns_client_t *client = resp->arg; dns_fetch_t *fetch = NULL; - ns_client_t *client = NULL; bool fetch_canceled = false; bool fetch_answered = false; isc_logcategory_t *logcategory = NS_LOGCATEGORY_QUERY_ERRORS; @@ -6247,24 +6230,16 @@ fetch_callback(isc_task_t *task, isc_event_t *event) { int errorloglevel; query_ctx_t qctx; - UNUSED(task); - - REQUIRE(event->ev_type == DNS_EVENT_FETCHDONE || - event->ev_type == DNS_EVENT_TRYSTALE); - - client = devent->ev_arg; - REQUIRE(NS_CLIENT_VALID(client)); - REQUIRE(task == client->manager->task); REQUIRE(RECURSING(client)); CTRACE(ISC_LOG_DEBUG(3), "fetch_callback"); - if (event->ev_type == DNS_EVENT_TRYSTALE) { - if (devent->result != ISC_R_CANCELED) { + if (resp->type == TRYSTALE) { + if (resp->result != ISC_R_CANCELED) { query_lookup_stale(client); } - isc_event_free(ISC_EVENT_PTR(&event)); + isc_mem_putanddetach(&resp->mctx, resp, sizeof(*resp)); return; } /* @@ -6279,7 +6254,7 @@ fetch_callback(isc_task_t *task, isc_event_t *event) { client->nodetach = false; LOCK(&client->query.fetchlock); - INSIST(FETCH_RECTYPE_NORMAL(client) == devent->fetch || + INSIST(FETCH_RECTYPE_NORMAL(client) == resp->fetch || FETCH_RECTYPE_NORMAL(client) == NULL); if (QUERY_STALEPENDING(&client->query)) { /* @@ -6293,7 +6268,7 @@ fetch_callback(isc_task_t *task, isc_event_t *event) { /* * This is the fetch we've been waiting for. */ - INSIST(FETCH_RECTYPE_NORMAL(client) == devent->fetch); + INSIST(FETCH_RECTYPE_NORMAL(client) == resp->fetch); FETCH_RECTYPE_NORMAL(client) = NULL; /* @@ -6309,7 +6284,7 @@ fetch_callback(isc_task_t *task, isc_event_t *event) { } UNLOCK(&client->query.fetchlock); - SAVE(fetch, devent->fetch); + SAVE(fetch, resp->fetch); /* * We're done recursing, detach from quota and unlink from @@ -6332,9 +6307,9 @@ fetch_callback(isc_task_t *task, isc_event_t *event) { /* * Initialize a new qctx and use it to either resume from * recursion or clean up after cancelation. Transfer - * ownership of devent to the new qctx in the process. + * ownership of resp to the new qctx in the process. */ - qctx_init(client, &devent, 0, &qctx); + qctx_init(client, &resp, 0, &qctx); if (fetch_canceled || fetch_answered) { /* @@ -6545,7 +6520,7 @@ ns_query_recurse(ns_client_t *client, dns_rdatatype_t qtype, dns_name_t *qname, result = dns_resolver_createfetch( client->view->resolver, qname, qtype, qdomain, nameservers, NULL, peeraddr, client->message->id, client->query.fetchoptions, - 0, NULL, client->manager->task, fetch_callback, client, + 0, NULL, client->manager->loop, fetch_callback, client, rdataset, sigrdataset, &FETCH_RECTYPE_NORMAL(client)); if (result != ISC_R_SUCCESS) { isc_nmhandle_detach(&HANDLE_RECTYPE_NORMAL(client)); @@ -6626,13 +6601,13 @@ query_resume(query_ctx_t *qctx) { RESTORE(qctx->sigrdataset, qctx->rpz_st->q.sigrdataset); qctx->qtype = qctx->rpz_st->q.qtype; - if (qctx->event->node != NULL) { - dns_db_detachnode(qctx->event->db, &qctx->event->node); + if (qctx->fresp->node != NULL) { + dns_db_detachnode(qctx->fresp->db, &qctx->fresp->node); } - SAVE(qctx->rpz_st->r.db, qctx->event->db); - qctx->rpz_st->r.r_type = qctx->event->qtype; - SAVE(qctx->rpz_st->r.r_rdataset, qctx->event->rdataset); - ns_client_putrdataset(qctx->client, &qctx->event->sigrdataset); + SAVE(qctx->rpz_st->r.db, qctx->fresp->db); + qctx->rpz_st->r.r_type = qctx->fresp->qtype; + SAVE(qctx->rpz_st->r.r_rdataset, qctx->fresp->rdataset); + ns_client_putrdataset(qctx->client, &qctx->fresp->sigrdataset); } else if (REDIRECT(qctx->client)) { /* * Restore saved state. @@ -6662,23 +6637,23 @@ query_resume(query_ctx_t *qctx) { /* * Free resources used while recursing. */ - ns_client_putrdataset(qctx->client, &qctx->event->rdataset); - ns_client_putrdataset(qctx->client, &qctx->event->sigrdataset); - if (qctx->event->node != NULL) { - dns_db_detachnode(qctx->event->db, &qctx->event->node); + ns_client_putrdataset(qctx->client, &qctx->fresp->rdataset); + ns_client_putrdataset(qctx->client, &qctx->fresp->sigrdataset); + if (qctx->fresp->node != NULL) { + dns_db_detachnode(qctx->fresp->db, &qctx->fresp->node); } - if (qctx->event->db != NULL) { - dns_db_detach(&qctx->event->db); + if (qctx->fresp->db != NULL) { + dns_db_detach(&qctx->fresp->db); } } else { CCTRACE(ISC_LOG_DEBUG(3), "resume from normal recursion"); qctx->authoritative = false; - qctx->qtype = qctx->event->qtype; - SAVE(qctx->db, qctx->event->db); - SAVE(qctx->node, qctx->event->node); - SAVE(qctx->rdataset, qctx->event->rdataset); - SAVE(qctx->sigrdataset, qctx->event->sigrdataset); + qctx->qtype = qctx->fresp->qtype; + SAVE(qctx->db, qctx->fresp->db); + SAVE(qctx->node, qctx->fresp->node); + SAVE(qctx->rdataset, qctx->fresp->rdataset); + SAVE(qctx->sigrdataset, qctx->fresp->sigrdataset); } INSIST(qctx->rdataset != NULL); @@ -6734,7 +6709,7 @@ query_resume(query_ctx_t *qctx) { } else if (REDIRECT(qctx->client)) { tname = qctx->client->query.redirect.fname; } else { - tname = qctx->event->foundname; + tname = qctx->fresp->foundname; } dns_name_copy(tname, qctx->fname); @@ -6742,14 +6717,13 @@ query_resume(query_ctx_t *qctx) { if (qctx->rpz_st != NULL && (qctx->rpz_st->state & DNS_RPZ_RECURSING) != 0) { - qctx->rpz_st->r.r_result = qctx->event->result; + qctx->rpz_st->r.r_result = qctx->fresp->result; result = qctx->rpz_st->q.result; - free_devent(qctx->client, ISC_EVENT_PTR(&qctx->event), - &qctx->event); + free_fresp(qctx->client, &qctx->fresp); } else if (REDIRECT(qctx->client)) { result = qctx->client->query.redirect.result; } else { - result = qctx->event->result; + result = qctx->fresp->result; } qctx->resuming = true; diff --git a/tests/dns/keytable_test.c b/tests/dns/keytable_test.c index 656bb118bb..baeaadbf7d 100644 --- a/tests/dns/keytable_test.c +++ b/tests/dns/keytable_test.c @@ -45,14 +45,12 @@ static int setup_test(void **state) { setup_loopmgr(state); - setup_taskmgr(state); return (0); } static int teardown_test(void **state) { - teardown_taskmgr(state); teardown_loopmgr(state); return (0); @@ -178,7 +176,7 @@ create_tables(void) { ISC_R_SUCCESS); assert_int_equal(dns_keytable_create(mctx, &keytable), ISC_R_SUCCESS); - assert_int_equal(dns_ntatable_create(view, taskmgr, loopmgr, &ntatable), + assert_int_equal(dns_ntatable_create(view, loopmgr, &ntatable), ISC_R_SUCCESS); /* Add a normal key */ @@ -611,15 +609,12 @@ ISC_LOOP_TEST_IMPL(nta) { result = dns_test_makeview("view", false, &myview); assert_int_equal(result, ISC_R_SUCCESS); - result = isc_task_create(taskmgr, &myview->task, 0); - assert_int_equal(result, ISC_R_SUCCESS); - result = dns_view_initsecroots(myview, mctx); assert_int_equal(result, ISC_R_SUCCESS); result = dns_view_getsecroots(myview, &keytable); assert_int_equal(result, ISC_R_SUCCESS); - result = dns_view_initntatable(myview, taskmgr, loopmgr); + result = dns_view_initntatable(myview, loopmgr); assert_int_equal(result, ISC_R_SUCCESS); result = dns_view_getntatable(myview, &ntatable); assert_int_equal(result, ISC_R_SUCCESS); diff --git a/tests/dns/resolver_test.c b/tests/dns/resolver_test.c index f65e2f986a..99da02df55 100644 --- a/tests/dns/resolver_test.c +++ b/tests/dns/resolver_test.c @@ -75,9 +75,8 @@ mkres(dns_resolver_t **resolverp) { isc_result_t result; isc_tlsctx_cache_create(mctx, &tlsctx_cache); - result = dns_resolver_create(view, loopmgr, taskmgr, 1, netmgr, 0, - tlsctx_cache, dispatchmgr, dispatch, NULL, - resolverp); + result = dns_resolver_create(view, loopmgr, 1, netmgr, 0, tlsctx_cache, + dispatchmgr, dispatch, NULL, resolverp); assert_int_equal(result, ISC_R_SUCCESS); }