Replace the linked list of TCP dispatches with hash table

Reusing TCP connections with dns_dispatch_gettcp() used linear linked
list to lookup existing outgoing TCP connections that could be reused.
Replace the linked list with per-loop cds_lfht hashtable to speedup the
lookups.  We use cds_lfht because it allows non-unique node insertion
that we need to check for dispatches in different connection states.

diff --git a/bin/delv/delv.c b/bin/delv/delv.c
index 26adc81266d7ae067beaeb4b3d54d86253a16913..3a95d3f93d0a05f777c9c656bedc97f3fb5bb1ae 100644 (file)
--- a/bin/delv/delv.c
+++ b/bin/delv/delv.c
@@ -2142,7 +2142,7 @@ run_server(void *arg) {
 
        ns_server_create(mctx, matchview, &sctx);
 
-       CHECK(dns_dispatchmgr_create(mctx, netmgr, &dispatchmgr));
+       CHECK(dns_dispatchmgr_create(mctx, loopmgr, netmgr, &dispatchmgr));
        isc_sockaddr_any(&any);
        CHECK(dns_dispatch_createudp(dispatchmgr, &any, &dispatch));
        CHECK(ns_interfacemgr_create(mctx, sctx, loopmgr, netmgr, dispatchmgr,

diff --git a/bin/named/server.c b/bin/named/server.c
index bd3ca9bb0e88c96c94c529afdbddf1358e98cf17..2831951ac8cc0ee9cfc1b74b37454880fa8047d3 100644 (file)
--- a/bin/named/server.c
+++ b/bin/named/server.c
@@ -1312,8 +1312,8 @@ get_view_querysource_dispatch(const cfg_obj_t **maps, int af,
                isc_sockaddr_format(&sa, buf, sizeof(buf));
                isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
                              NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
-                             "could not get query source dispatcher (%s)",
-                             buf);
+                             "could not get query source dispatcher (%s): %s",
+                             buf, isc_result_totext(result));
                return (result);
        }
 
@@ -9897,8 +9897,8 @@ run_server(void *arg) {
        dns_zonemgr_create(named_g_mctx, named_g_loopmgr, named_g_netmgr,
                           &server->zonemgr);
 
-       CHECKFATAL(dns_dispatchmgr_create(named_g_mctx, named_g_netmgr,
-                                         &named_g_dispatchmgr),
+       CHECKFATAL(dns_dispatchmgr_create(named_g_mctx, named_g_loopmgr,
+                                         named_g_netmgr, &named_g_dispatchmgr),
                   "creating dispatch manager");
 
        dns_dispatchmgr_setstats(named_g_dispatchmgr, server->resolverstats);

diff --git a/bin/nsupdate/nsupdate.c b/bin/nsupdate/nsupdate.c
index 5746933935708da53dfee16b6d9c0b127e193796..fc42badc64365ba2ac1c4a7b9011dbd3ed0d888d 100644 (file)
--- a/bin/nsupdate/nsupdate.c
+++ b/bin/nsupdate/nsupdate.c
@@ -919,7 +919,7 @@ setup_system(void *arg ISC_ATTR_UNUSED) {
 
        irs_resconf_destroy(&resconf);
 
-       result = dns_dispatchmgr_create(gmctx, netmgr, &dispatchmgr);
+       result = dns_dispatchmgr_create(gmctx, loopmgr, netmgr, &dispatchmgr);
        check_result(result, "dns_dispatchmgr_create");
 
        result = dst_lib_init(gmctx, NULL);

diff --git a/bin/tests/system/pipelined/pipequeries.c b/bin/tests/system/pipelined/pipequeries.c
index bfe0c1b84aa598bbd16a956c106d23717a4019db..ceb26dac848a59f93de8451b4c659e78d798efdc 100644 (file)
--- a/bin/tests/system/pipelined/pipequeries.c
+++ b/bin/tests/system/pipelined/pipequeries.c
@@ -275,7 +275,7 @@ main(int argc, char *argv[]) {
 
        RUNCHECK(dst_lib_init(mctx, NULL));
 
-       RUNCHECK(dns_dispatchmgr_create(mctx, netmgr, &dispatchmgr));
+       RUNCHECK(dns_dispatchmgr_create(mctx, loopmgr, netmgr, &dispatchmgr));
 
        RUNCHECK(dns_dispatch_createudp(
                dispatchmgr, have_src ? &srcaddr : &bind_any, &dispatchv4));

diff --git a/bin/tools/mdig.c b/bin/tools/mdig.c
index 6b2facf09b0c8ac0fa6596befa84103b0abed97f..4de30ab65f6c1eb5c26e6338c43483297a558ab4 100644 (file)
--- a/bin/tools/mdig.c
+++ b/bin/tools/mdig.c
@@ -2085,7 +2085,7 @@ teardown(void *arg ISC_ATTR_UNUSED) {
 
 static void
 setup(void *arg ISC_ATTR_UNUSED) {
-       RUNCHECK(dns_dispatchmgr_create(mctx, netmgr, &dispatchmgr));
+       RUNCHECK(dns_dispatchmgr_create(mctx, loopmgr, netmgr, &dispatchmgr));
 
        set_source_ports(dispatchmgr);
 

diff --git a/lib/dns/client.c b/lib/dns/client.c
index a8100f7ab6fa8e48728154ce15095ff73b6d7fdd..486cda4af7d57264f7040cff912d587749a04985 100644 (file)
--- a/lib/dns/client.c
+++ b/lib/dns/client.c
@@ -252,7 +252,8 @@ dns_client_create(isc_mem_t *mctx, isc_loopmgr_t *loopmgr, isc_nm_t *nm,
                .nm = nm,
        };
 
-       result = dns_dispatchmgr_create(mctx, nm, &client->dispatchmgr);
+       result = dns_dispatchmgr_create(mctx, loopmgr, nm,
+                                       &client->dispatchmgr);
        if (result != ISC_R_SUCCESS) {
                goto cleanup_client;
        }

diff --git a/lib/dns/dispatch.c b/lib/dns/dispatch.c
index 38b6577ed762b30480b99f0c8bc4ba194648d65e..08076668682a038a752fc88252507e9bdb456b47 100644 (file)
--- a/lib/dns/dispatch.c
+++ b/lib/dns/dispatch.c
@@ -55,9 +55,9 @@ struct dns_dispatchmgr {
        isc_stats_t *stats;
        isc_nm_t *nm;
 
-       /* Locked by "lock". */
-       isc_mutex_t lock;
-       ISC_LIST(dns_dispatch_t) list;
+       uint32_t nloops;
+
+       struct cds_lfht **tcps;
 
        struct cds_lfht *qids;
 
@@ -109,15 +109,13 @@ struct dns_dispatch {
        /* Unlocked. */
        unsigned int magic; /*%< magic */
        uint32_t tid;
+       isc_mem_t *mctx;
        dns_dispatchmgr_t *mgr; /*%< dispatch manager */
        isc_nmhandle_t *handle; /*%< netmgr handle for TCP connection */
        isc_sockaddr_t local;   /*%< local address */
        in_port_t localport;    /*%< local UDP port */
        isc_sockaddr_t peer;    /*%< peer address (TCP) */
 
-       /*% Locked by mgr->lock. */
-       ISC_LINK(dns_dispatch_t) link;
-
        isc_socktype_t socktype;
        dns_dispatchstate_t state;
        isc_refcount_t references;
@@ -130,6 +128,9 @@ struct dns_dispatch {
        uint_fast32_t requests; /*%< how many requests we have */
 
        unsigned int timedout;
+
+       struct cds_lfht_node ht_node;
+       struct rcu_head rcu_head;
 };
 
 #define RESPONSE_MAGIC   ISC_MAGIC('D', 'r', 's', 'p')
@@ -339,7 +340,6 @@ dispentry_log(dns_dispentry_t *resp, int level, const char *fmt, ...) {
 
 /*%
  * Choose a random port number for a dispatch entry.
- * The caller must hold the disp->lock
  */
 static isc_result_t
 setup_socket(dns_dispatch_t *disp, dns_dispentry_t *resp,
@@ -957,7 +957,7 @@ setavailports(dns_dispatchmgr_t *mgr, isc_portset_t *v4portset,
  */
 
 isc_result_t
-dns_dispatchmgr_create(isc_mem_t *mctx, isc_nm_t *nm,
+dns_dispatchmgr_create(isc_mem_t *mctx, isc_loopmgr_t *loopmgr, isc_nm_t *nm,
                       dns_dispatchmgr_t **mgrp) {
        dns_dispatchmgr_t *mgr = NULL;
        isc_portset_t *v4portset = NULL;
@@ -967,7 +967,10 @@ dns_dispatchmgr_create(isc_mem_t *mctx, isc_nm_t *nm,
        REQUIRE(mgrp != NULL && *mgrp == NULL);
 
        mgr = isc_mem_get(mctx, sizeof(dns_dispatchmgr_t));
-       *mgr = (dns_dispatchmgr_t){ .magic = 0 };
+       *mgr = (dns_dispatchmgr_t){
+               .magic = 0,
+               .nloops = isc_loopmgr_nloops(loopmgr),
+       };
 
 #if DNS_DISPATCH_TRACE
        fprintf(stderr, "dns_dispatchmgr__init:%s:%s:%d:%p->references = 1\n",
@@ -978,9 +981,12 @@ dns_dispatchmgr_create(isc_mem_t *mctx, isc_nm_t *nm,
        isc_mem_attach(mctx, &mgr->mctx);
        isc_nm_attach(nm, &mgr->nm);
 
-       isc_mutex_init(&mgr->lock);
-
-       ISC_LIST_INIT(mgr->list);
+       mgr->tcps = isc_mem_cget(mgr->mctx, mgr->nloops, sizeof(mgr->tcps[0]));
+       for (size_t i = 0; i < mgr->nloops; i++) {
+               mgr->tcps[i] = cds_lfht_new(
+                       2, 2, 0, CDS_LFHT_AUTO_RESIZE | CDS_LFHT_ACCOUNTING,
+                       NULL);
+       }
 
        create_default_portset(mgr->mctx, AF_INET, &v4portset);
        create_default_portset(mgr->mctx, AF_INET6, &v6portset);
@@ -1035,10 +1041,14 @@ dispatchmgr_destroy(dns_dispatchmgr_t *mgr) {
        isc_refcount_destroy(&mgr->references);
 
        mgr->magic = 0;
-       isc_mutex_destroy(&mgr->lock);
 
        RUNTIME_CHECK(!cds_lfht_destroy(mgr->qids, NULL));
 
+       for (size_t i = 0; i < mgr->nloops; i++) {
+               RUNTIME_CHECK(!cds_lfht_destroy(mgr->tcps[i], NULL));
+       }
+       isc_mem_cput(mgr->mctx, mgr->tcps, mgr->nloops, sizeof(mgr->tcps[0]));
+
        if (mgr->blackhole != NULL) {
                dns_acl_detach(&mgr->blackhole);
        }
@@ -1064,7 +1074,6 @@ dispatchmgr_destroy(dns_dispatchmgr_t *mgr) {
 void
 dns_dispatchmgr_setstats(dns_dispatchmgr_t *mgr, isc_stats_t *stats) {
        REQUIRE(VALID_DISPATCHMGR(mgr));
-       REQUIRE(ISC_LIST_EMPTY(mgr->list));
        REQUIRE(mgr->stats == NULL);
 
        isc_stats_attach(stats, &mgr->stats);
@@ -1089,13 +1098,14 @@ dispatch_allocate(dns_dispatchmgr_t *mgr, isc_socktype_t type, uint32_t tid,
        disp = isc_mem_get(mgr->mctx, sizeof(*disp));
        *disp = (dns_dispatch_t){
                .socktype = type,
-               .link = ISC_LINK_INITIALIZER,
                .active = ISC_LIST_INITIALIZER,
                .pending = ISC_LIST_INITIALIZER,
                .tid = tid,
                .magic = DISPATCH_MAGIC,
        };
 
+       isc_mem_attach(mgr->mctx, &disp->mctx);
+
        dns_dispatchmgr_attach(mgr, &disp->mgr);
 #if DNS_DISPATCH_TRACE
        fprintf(stderr, "dns_dispatch__init:%s:%s:%d:%p->references = 1\n",
@@ -1106,17 +1116,50 @@ dispatch_allocate(dns_dispatchmgr_t *mgr, isc_socktype_t type, uint32_t tid,
        *dispp = disp;
 }
 
+struct dispatch_key {
+       const isc_sockaddr_t *local;
+       const isc_sockaddr_t *peer;
+};
+
+static uint32_t
+dispatch_hash(struct dispatch_key *key) {
+       uint32_t hashval = isc_sockaddr_hash(key->peer, false);
+       if (key->local) {
+               hashval ^= isc_sockaddr_hash(key->local, true);
+       }
+
+       return (hashval);
+}
+
+static int
+dispatch_match(struct cds_lfht_node *node, const void *key0) {
+       dns_dispatch_t *disp = caa_container_of(node, dns_dispatch_t, ht_node);
+       const struct dispatch_key *key = key0;
+       isc_sockaddr_t local;
+       isc_sockaddr_t peer;
+
+       if (disp->handle != NULL) {
+               local = isc_nmhandle_localaddr(disp->handle);
+               peer = isc_nmhandle_peeraddr(disp->handle);
+       } else {
+               local = disp->local;
+               peer = disp->peer;
+       }
+
+       return (isc_sockaddr_equal(&peer, key->peer) &&
+               (key->local == NULL || isc_sockaddr_equal(&local, key->local)));
+}
+
 isc_result_t
 dns_dispatch_createtcp(dns_dispatchmgr_t *mgr, const isc_sockaddr_t *localaddr,
                       const isc_sockaddr_t *destaddr, dns_dispatch_t **dispp) {
        dns_dispatch_t *disp = NULL;
+       uint32_t tid = isc_tid();
 
        REQUIRE(VALID_DISPATCHMGR(mgr));
        REQUIRE(destaddr != NULL);
 
-       LOCK(&mgr->lock);
-
-       dispatch_allocate(mgr, isc_socktype_tcp, isc_tid(), &disp);
+       dispatch_allocate(mgr, isc_socktype_tcp, tid, &disp);
 
        disp->peer = *destaddr;
 
@@ -1132,10 +1175,14 @@ dns_dispatch_createtcp(dns_dispatchmgr_t *mgr, const isc_sockaddr_t *localaddr,
        /*
         * Append it to the dispatcher list.
         */
+       struct dispatch_key key = {
+               .local = &disp->local,
+               .peer = &disp->peer,
+       };
 
-       /* FIXME: There should be a lookup hashtable here */
-       ISC_LIST_APPEND(mgr->list, disp, link);
-       UNLOCK(&mgr->lock);
+       rcu_read_lock();
+       cds_lfht_add(mgr->tcps[tid], dispatch_hash(&key), &disp->ht_node);
+       rcu_read_unlock();
 
        if (isc_log_wouldlog(dns_lctx, 90)) {
                char addrbuf[ISC_SOCKADDR_FORMATSIZE];
@@ -1159,46 +1206,25 @@ dns_dispatch_gettcp(dns_dispatchmgr_t *mgr, const isc_sockaddr_t *destaddr,
        dns_dispatch_t *disp_connected = NULL;
        dns_dispatch_t *disp_fallback = NULL;
        isc_result_t result = ISC_R_NOTFOUND;
+       uint32_t tid = isc_tid();
 
        REQUIRE(VALID_DISPATCHMGR(mgr));
        REQUIRE(destaddr != NULL);
        REQUIRE(dispp != NULL && *dispp == NULL);
 
-       LOCK(&mgr->lock);
-
-       for (dns_dispatch_t *disp = ISC_LIST_HEAD(mgr->list); disp != NULL;
-            disp = ISC_LIST_NEXT(disp, link))
-       {
-               isc_sockaddr_t sockname;
-               isc_sockaddr_t peeraddr;
-
-               if (disp->tid != isc_tid()) {
-                       continue;
-               }
-
-               REQUIRE(disp->tid == isc_tid());
-
-               if (disp->handle != NULL) {
-                       sockname = isc_nmhandle_localaddr(disp->handle);
-                       peeraddr = isc_nmhandle_peeraddr(disp->handle);
-               } else {
-                       sockname = disp->local;
-                       peeraddr = disp->peer;
-               }
+       struct dispatch_key key = {
+               .local = localaddr,
+               .peer = destaddr,
+       };
 
-               /*
-                * The conditions match:
-                * 1. socktype is TCP
-                * 2. destination address is same
-                * 3. local address is either NULL or same
-                */
-               if (disp->socktype != isc_socktype_tcp ||
-                   !isc_sockaddr_equal(destaddr, &peeraddr) ||
-                   (localaddr != NULL &&
-                    !isc_sockaddr_eqaddr(localaddr, &sockname)))
-               {
-                       continue;
-               }
+       rcu_read_lock();
+       struct cds_lfht_iter iter;
+       dns_dispatch_t *disp = NULL;
+       cds_lfht_for_each_entry_duplicate(mgr->tcps[tid], dispatch_hash(&key),
+                                         dispatch_match, &key, &iter, disp,
+                                         ht_node) {
+               INSIST(disp->tid == isc_tid());
+               INSIST(disp->socktype == isc_socktype_tcp);
 
                switch (disp->state) {
                case DNS_DISPATCHSTATE_NONE:
@@ -1233,6 +1259,7 @@ dns_dispatch_gettcp(dns_dispatchmgr_t *mgr, const isc_sockaddr_t *destaddr,
                        break;
                }
        }
+       rcu_read_unlock();
 
        if (disp_connected != NULL) {
                /* We found connected dispatch */
@@ -1252,8 +1279,6 @@ dns_dispatch_gettcp(dns_dispatchmgr_t *mgr, const isc_sockaddr_t *destaddr,
                result = ISC_R_SUCCESS;
        }
 
-       UNLOCK(&mgr->lock);
-
        return (result);
 }
 
@@ -1267,12 +1292,10 @@ dns_dispatch_createudp(dns_dispatchmgr_t *mgr, const isc_sockaddr_t *localaddr,
        REQUIRE(localaddr != NULL);
        REQUIRE(dispp != NULL && *dispp == NULL);
 
-       LOCK(&mgr->lock);
        result = dispatch_createudp(mgr, localaddr, isc_tid(), &disp);
        if (result == ISC_R_SUCCESS) {
                *dispp = disp;
        }
-       UNLOCK(&mgr->lock);
 
        return (result);
 }
@@ -1321,25 +1344,30 @@ dispatch_createudp(dns_dispatchmgr_t *mgr, const isc_sockaddr_t *localaddr,
        return (result);
 }
 
+static void
+dispatch_destroy_rcu(struct rcu_head *rcu_head) {
+       dns_dispatch_t *disp = caa_container_of(rcu_head, dns_dispatch_t,
+                                               rcu_head);
+
+       isc_mem_putanddetach(&disp->mctx, disp, sizeof(*disp));
+}
+
 static void
 dispatch_destroy(dns_dispatch_t *disp) {
        dns_dispatchmgr_t *mgr = disp->mgr;
+       uint32_t tid = isc_tid();
 
        isc_refcount_destroy(&disp->references);
        disp->magic = 0;
 
-       LOCK(&mgr->lock);
-       if (ISC_LINK_LINKED(disp, link)) {
-               ISC_LIST_UNLINK(disp->mgr->list, disp, link);
+       if (disp->socktype == isc_socktype_tcp) {
+               (void)cds_lfht_del(mgr->tcps[tid], &disp->ht_node);
        }
-       UNLOCK(&mgr->lock);
 
        INSIST(disp->requests == 0);
        INSIST(ISC_LIST_EMPTY(disp->pending));
        INSIST(ISC_LIST_EMPTY(disp->active));
 
-       INSIST(!ISC_LINK_LINKED(disp, link));
-
        dispatch_log(disp, LVL(90), "destroying dispatch %p", disp);
 
        if (disp->handle) {
@@ -1347,14 +1375,9 @@ dispatch_destroy(dns_dispatch_t *disp) {
                             disp->handle, &disp->handle);
                isc_nmhandle_detach(&disp->handle);
        }
+       dns_dispatchmgr_detach(&disp->mgr);
 
-       isc_mem_put(mgr->mctx, disp, sizeof(*disp));
-
-       /*
-        * Because dispatch uses mgr->mctx, we must detach after freeing
-        * dispatch, not before.
-        */
-       dns_dispatchmgr_detach(&mgr);
+       call_rcu(&disp->rcu_head, dispatch_destroy_rcu);
 }
 
 #if DNS_DISPATCH_TRACE
@@ -1394,7 +1417,7 @@ dns_dispatch_add(dns_dispatch_t *disp, isc_loop_t *loop, unsigned int options,
 
        localport = isc_sockaddr_getport(&disp->local);
 
-       resp = isc_mem_get(disp->mgr->mctx, sizeof(*resp));
+       resp = isc_mem_get(disp->mctx, sizeof(*resp));
        *resp = (dns_dispentry_t){
                .port = localport,
                .timeout = timeout,
@@ -1419,7 +1442,7 @@ dns_dispatch_add(dns_dispatch_t *disp, isc_loop_t *loop, unsigned int options,
        if (disp->socktype == isc_socktype_udp) {
                result = setup_socket(disp, resp, dest, &localport);
                if (result != ISC_R_SUCCESS) {
-                       isc_mem_put(disp->mgr->mctx, resp, sizeof(*resp));
+                       isc_mem_put(disp->mctx, resp, sizeof(*resp));
                        inc_stats(disp->mgr, dns_resstatscounter_dispsockfail);
                        return (result);
                }
@@ -1456,11 +1479,11 @@ dns_dispatch_add(dns_dispatch_t *disp, isc_loop_t *loop, unsigned int options,
        } while (i++ < QID_MAX_TRIES);
 fail:
        if (result != ISC_R_SUCCESS) {
-               isc_mem_put(disp->mgr->mctx, resp, sizeof(*resp));
+               isc_mem_put(disp->mctx, resp, sizeof(*resp));
                return (ISC_R_NOMORE);
        }
 
-       isc_mem_attach(disp->mgr->mctx, &resp->mctx);
+       isc_mem_attach(disp->mctx, &resp->mctx);
 
        if (transport != NULL) {
                dns_transport_attach(transport, &resp->transport);
@@ -1907,7 +1930,7 @@ tcp_dispatch_connect(dns_dispatch_t *disp, dns_dispentry_t *resp) {
 
                result = dns_transport_get_tlsctx(
                        resp->transport, &resp->peer, resp->tlsctx_cache,
-                       resp->disp->mgr->mctx, &tlsctx, &sess_cache);
+                       resp->mctx, &tlsctx, &sess_cache);
 
                if (result != ISC_R_SUCCESS) {
                        return (result);
@@ -2184,7 +2207,6 @@ dns_dispatchset_create(isc_mem_t *mctx, dns_dispatch_t *source,
        dset->dispatches[0] = NULL;
        dns_dispatch_attach(source, &dset->dispatches[0]); /* DISPATCH004 */
 
-       LOCK(&mgr->lock);
        for (i = 1; i < dset->ndisp; i++) {
                result = dispatch_createudp(mgr, &source->local, i,
                                            &dset->dispatches[i]);
@@ -2193,14 +2215,11 @@ dns_dispatchset_create(isc_mem_t *mctx, dns_dispatch_t *source,
                }
        }
 
-       UNLOCK(&mgr->lock);
        *dsetp = dset;
 
        return (ISC_R_SUCCESS);
 
 fail:
-       UNLOCK(&mgr->lock);
-
        for (size_t j = 0; j < i; j++) {
                dns_dispatch_detach(&(dset->dispatches[j])); /* DISPATCH004 */
        }

diff --git a/lib/dns/include/dns/dispatch.h b/lib/dns/include/dns/dispatch.h
index 0813224f8b96fc11f8a02510824542cb7bc10e2b..0e302f288e727f5d0abb5c61a07ceac99843f6ef 100644 (file)
--- a/lib/dns/include/dns/dispatch.h
+++ b/lib/dns/include/dns/dispatch.h
@@ -77,7 +77,8 @@ struct dns_dispatchset {
 #define DNS_DISPATCHOPT_FIXEDID 0x00000001U
 
 isc_result_t
-dns_dispatchmgr_create(isc_mem_t *mctx, isc_nm_t *nm, dns_dispatchmgr_t **mgrp);
+dns_dispatchmgr_create(isc_mem_t *mctx, isc_loopmgr_t *loopmgr, isc_nm_t *nm,
+                      dns_dispatchmgr_t **mgrp);
 /*%<
  * Creates a new dispatchmgr object, and sets the available ports
  * to the default range (1024-65535).

diff --git a/tests/dns/dispatch_test.c b/tests/dns/dispatch_test.c
index 150ad405ac644815dd8b428ec4cae8e018be35ce..bce2565d82b798116d79a02e5603926ddcb5b4fc 100644 (file)
--- a/tests/dns/dispatch_test.c
+++ b/tests/dns/dispatch_test.c
@@ -245,7 +245,8 @@ ISC_LOOP_TEST_IMPL(dispatchset_create) {
 
        UNUSED(arg);
 
-       result = dns_dispatchmgr_create(mctx, connect_nm, &dispatchmgr);
+       result = dns_dispatchmgr_create(mctx, loopmgr, connect_nm,
+                                       &dispatchmgr);
        assert_int_equal(result, ISC_R_SUCCESS);
 
        result = make_dispatchset(1, &dset);
@@ -270,7 +271,8 @@ ISC_LOOP_TEST_IMPL(dispatchset_get) {
 
        UNUSED(arg);
 
-       result = dns_dispatchmgr_create(mctx, connect_nm, &dispatchmgr);
+       result = dns_dispatchmgr_create(mctx, loopmgr, connect_nm,
+                                       &dispatchmgr);
        assert_int_equal(result, ISC_R_SUCCESS);
 
        result = make_dispatchset(1, &dset);
@@ -463,7 +465,8 @@ ISC_LOOP_TEST_IMPL(dispatch_timeout_tcp_connect) {
        testdata.region.base = testdata.message;
        testdata.region.length = sizeof(testdata.message);
 
-       result = dns_dispatchmgr_create(mctx, connect_nm, &dispatchmgr);
+       result = dns_dispatchmgr_create(mctx, loopmgr, connect_nm,
+                                       &dispatchmgr);
        assert_int_equal(result, ISC_R_SUCCESS);
 
        result = dns_dispatch_createtcp(dispatchmgr, &tcp_connect_addr,
@@ -508,7 +511,8 @@ ISC_LOOP_TEST_IMPL(dispatch_timeout_tcp_response) {
        isc_loop_teardown(isc_loop_main(loopmgr), stop_listening, sock);
 
        /* Client */
-       result = dns_dispatchmgr_create(mctx, connect_nm, &dispatchmgr);
+       result = dns_dispatchmgr_create(mctx, loopmgr, connect_nm,
+                                       &dispatchmgr);
        assert_int_equal(result, ISC_R_SUCCESS);
 
        result = dns_dispatch_createtcp(dispatchmgr, &tcp_connect_addr,
@@ -542,7 +546,8 @@ ISC_LOOP_TEST_IMPL(dispatch_tcp_response) {
        testdata.region.base = testdata.message;
        testdata.region.length = sizeof(testdata.message);
 
-       result = dns_dispatchmgr_create(mctx, connect_nm, &dispatchmgr);
+       result = dns_dispatchmgr_create(mctx, loopmgr, connect_nm,
+                                       &dispatchmgr);
        assert_int_equal(result, ISC_R_SUCCESS);
 
        result = dns_dispatch_createtcp(dispatchmgr, &tcp_connect_addr,
@@ -579,7 +584,8 @@ ISC_LOOP_TEST_IMPL(dispatch_tls_response) {
        testdata.region.base = testdata.message;
        testdata.region.length = sizeof(testdata.message);
 
-       result = dns_dispatchmgr_create(mctx, connect_nm, &dispatchmgr);
+       result = dns_dispatchmgr_create(mctx, loopmgr, connect_nm,
+                                       &dispatchmgr);
        assert_int_equal(result, ISC_R_SUCCESS);
 
        result = dns_dispatch_createtcp(dispatchmgr, &tls_connect_addr,
@@ -606,7 +612,8 @@ ISC_LOOP_TEST_IMPL(dispatch_timeout_udp_response) {
        uint16_t id;
 
        /* Server */
-       result = dns_dispatchmgr_create(mctx, connect_nm, &dispatchmgr);
+       result = dns_dispatchmgr_create(mctx, loopmgr, connect_nm,
+                                       &dispatchmgr);
        assert_int_equal(result, ISC_R_SUCCESS);
 
        result = isc_nm_listenudp(netmgr, ISC_NM_LISTEN_ONE, &udp_server_addr,
@@ -648,7 +655,8 @@ ISC_LOOP_TEST_IMPL(dispatch_getnext) {
        testdata.region.base = testdata.message;
        testdata.region.length = sizeof(testdata.message);
 
-       result = dns_dispatchmgr_create(mctx, connect_nm, &dispatchmgr);
+       result = dns_dispatchmgr_create(mctx, loopmgr, connect_nm,
+                                       &dispatchmgr);
        assert_int_equal(result, ISC_R_SUCCESS);
 
        result = dns_dispatch_createudp(dispatchmgr, &udp_connect_addr,

diff --git a/tests/libtest/dns.c b/tests/libtest/dns.c
index d50c012caf1c9adcf26b2b5eb558ab14338c6027..73fb630807951e6dc478cb90cc5483b393834fec 100644 (file)
--- a/tests/libtest/dns.c
+++ b/tests/libtest/dns.c
@@ -68,7 +68,8 @@ dns_test_makeview(const char *name, bool with_dispatchmgr, bool with_cache,
        dns_dispatchmgr_t *dispatchmgr = NULL;
 
        if (with_dispatchmgr) {
-               result = dns_dispatchmgr_create(mctx, netmgr, &dispatchmgr);
+               result = dns_dispatchmgr_create(mctx, loopmgr, netmgr,
+                                               &dispatchmgr);
                if (result != ISC_R_SUCCESS) {
                        return (result);
                }

diff --git a/tests/libtest/ns.c b/tests/libtest/ns.c
index 19b2f676991a0534e6f8c4b89ab8c2151efc5d15..4c49474ccc266d8b4253e1607ccdf495d9f81f5c 100644 (file)
--- a/tests/libtest/ns.c
+++ b/tests/libtest/ns.c
@@ -85,7 +85,7 @@ setup_server(void **state) {
 
        ns_server_create(mctx, matchview, &sctx);
 
-       result = dns_dispatchmgr_create(mctx, netmgr, &dispatchmgr);
+       result = dns_dispatchmgr_create(mctx, loopmgr, netmgr, &dispatchmgr);
        if (result != ISC_R_SUCCESS) {
                goto cleanup;
        }