Destroy netmgr before destroying taskmgr

With taskmgr running on top of netmgr, the ordering of how the tasks and
netmgr shutdown interacts was wrong as previously isc_taskmgr_destroy()
was waiting until all tasks were properly shutdown and detached.  This
responsibility was moved to netmgr, so we now need to do the following:

  1. shutdown all the tasks - this schedules all shutdown events onto
     the netmgr queue

  2. shutdown the netmgr - this also makes sure all the tasks and
     events are properly executed

  3. Shutdown the taskmgr - this now waits for all the tasks to finish
     running before returning

  4. Shutdown the netmgr - this call waits for all the netmgr netievents
     to finish before returning

This solves the race when the taskmgr object would be destroyed before
all the tasks were finished running in the netmgr loops.

diff --git a/bin/tests/test_client.c b/bin/tests/test_client.c
index 7c9f10e2c6100be22416962af5417708c23a0f61..6337406298130c8e84d72e1696b6cdd9a472c805 100644 (file)
--- a/bin/tests/test_client.c
+++ b/bin/tests/test_client.c
@@ -465,8 +465,6 @@ run(void) {
        }
 
        waitforsignal();
-
-       isc_nm_closedown(netmgr);
 }
 
 int

diff --git a/lib/dns/tests/dnstest.c b/lib/dns/tests/dnstest.c
index 6a247b6b05f4b3460eff7438b8d0c46efafd4021..c14eed36e85c5b72851385b44ceb3029abfcd31a 100644 (file)
--- a/lib/dns/tests/dnstest.c
+++ b/lib/dns/tests/dnstest.c
@@ -96,7 +96,10 @@ cleanup_managers(void) {
                isc_task_shutdown(maintask);
                isc_task_destroy(&maintask);
        }
-       isc_managers_destroy(&netmgr, &taskmgr, &timermgr, &socketmgr);
+       isc_managers_destroy(netmgr == NULL ? NULL : &netmgr,
+                            taskmgr == NULL ? NULL : &taskmgr,
+                            timermgr == NULL ? NULL : &timermgr,
+                            socketmgr == NULL ? NULL : &socketmgr);
        if (app_running) {
                isc_app_finish();
        }

diff --git a/lib/isc/include/isc/netmgr.h b/lib/isc/include/isc/netmgr.h
index e0a171902624cd579e17a1d91697c36ed49cfaf8..7ce897786b1e18a6e41f6eec11c24654fc52927e 100644 (file)
--- a/lib/isc/include/isc/netmgr.h
+++ b/lib/isc/include/isc/netmgr.h
@@ -79,15 +79,6 @@ isc_nm_detach(isc_nm_t **mgr0);
  * for all other references to be gone.
  */
 
-void
-isc_nm_closedown(isc_nm_t *mgr);
-/*%<
- * Close down all active connections, freeing associated resources;
- * prevent new connections from being established. This can optionally
- * be called prior to shutting down the netmgr, to stop all processing
- * before shutting down the task manager.
- */
-
 /* Return thread ID of current thread, or ISC_NETMGR_TID_UNKNOWN */
 int
 isc_nm_tid(void);

diff --git a/lib/isc/managers.c b/lib/isc/managers.c
index 8a17fd1e05f4b193a5494f386cac5db601b2e0ab..f86d4c8485ffd6deba5c10fdf804f9ccb134f971 100644 (file)
--- a/lib/isc/managers.c
+++ b/lib/isc/managers.c
@@ -42,6 +42,7 @@ isc_managers_create(isc_mem_t *mctx, size_t workers, size_t quantum,
 
        REQUIRE(taskmgrp == NULL || *taskmgrp == NULL);
        if (taskmgrp != NULL) {
+               INSIST(netmgr != NULL);
                result = isc__taskmgr_create(mctx, quantum, netmgr, &taskmgr);
                if (result != ISC_R_SUCCESS) {
                        UNEXPECTED_ERROR(__FILE__, __LINE__,
@@ -87,23 +88,57 @@ fail:
 void
 isc_managers_destroy(isc_nm_t **netmgrp, isc_taskmgr_t **taskmgrp,
                     isc_timermgr_t **timermgrp, isc_socketmgr_t **socketmgrp) {
-       if (netmgrp != NULL && *netmgrp != NULL) {
-               isc_nm_closedown(*netmgrp);
+       /*
+        * If we have a taskmgr to clean up, then we must also have a netmgr.
+        */
+       REQUIRE(taskmgrp != NULL || netmgrp == NULL);
+
+       /*
+        * The sequence of operations here is important:
+        *
+        * 1. Initiate shutdown of the taskmgr, sending shutdown events to
+        * all tasks that are not already shutting down.
+        */
+       if (taskmgrp != NULL) {
+               INSIST(*taskmgrp != NULL);
+               isc__taskmgr_shutdown(*taskmgrp);
+       }
+
+       /*
+        * 2. Initiate shutdown of the network manager, freeing clients
+        * and other resources and preventing new connections, but do
+        * not stop processing of existing events.
+        */
+       if (netmgrp != NULL) {
+               INSIST(*netmgrp != NULL);
+               isc__netmgr_shutdown(*netmgrp);
        }
 
-       if (taskmgrp != NULL && *taskmgrp != NULL) {
+       /*
+        * 3. Finish destruction of the task manager when all tasks
+        * have completed.
+        */
+       if (taskmgrp != NULL) {
                isc__taskmgr_destroy(taskmgrp);
        }
 
-       if (netmgrp != NULL && *netmgrp != NULL) {
+       /*
+        * 4. Finish destruction of the netmgr, and wait until all
+        * references have been released.
+        */
+       if (netmgrp != NULL) {
                isc__netmgr_destroy(netmgrp);
        }
 
-       if (timermgrp != NULL && *timermgrp != NULL) {
+       /*
+        * 5. Clean up the remaining managers.
+        */
+       if (timermgrp != NULL) {
+               INSIST(*timermgrp != NULL);
                isc__timermgr_destroy(timermgrp);
        }
-
-       if (socketmgrp != NULL && *socketmgrp != NULL) {
+       if (socketmgrp != NULL) {
+               INSIST(*socketmgrp != NULL);
                isc__socketmgr_destroy(socketmgrp);
        }
 }

diff --git a/lib/isc/netmgr/netmgr.c b/lib/isc/netmgr/netmgr.c
index 7acaca8791a1ec490178081828e4d8b1948075a5..85a1f1714aa475f697b62e569762a18c20e46f6f 100644 (file)
--- a/lib/isc/netmgr/netmgr.c
+++ b/lib/isc/netmgr/netmgr.c
@@ -474,7 +474,7 @@ isc_nm_detach(isc_nm_t **mgr0) {
 }
 
 void
-isc_nm_closedown(isc_nm_t *mgr) {
+isc__netmgr_shutdown(isc_nm_t *mgr) {
        REQUIRE(VALID_NM(mgr));
 
        atomic_store(&mgr->closing, true);
@@ -497,7 +497,7 @@ isc__netmgr_destroy(isc_nm_t **netmgrp) {
        /*
         * Close active connections.
         */
-       isc_nm_closedown(mgr);
+       isc__netmgr_shutdown(mgr);
 
        /*
         * Wait for the manager to be dereferenced elsewhere.

diff --git a/lib/isc/netmgr_p.h b/lib/isc/netmgr_p.h
index ce934d51c94c3d46ebf6f07c2ae447dfb127d3d9..8f33c84160745b8fd3574bd56bf81ebf78e8239b 100644 (file)
--- a/lib/isc/netmgr_p.h
+++ b/lib/isc/netmgr_p.h
@@ -24,6 +24,13 @@ isc__netmgr_create(isc_mem_t *mctx, uint32_t workers, isc_nm_t **netgmrp);
 void
 isc__netmgr_destroy(isc_nm_t **netmgrp);
 /*%<
- * Destroy is working the same way as isc_nm_detach, but it actively waits
- * for all other references to be gone.
+ * Similar to isc_nm_detach(), but actively waits for all other references
+ * to be gone before returning.
+ */
+
+void
+isc__netmgr_shutdown(isc_nm_t *mgr);
+/*%<
+ * Shut down all active connections, freeing associated resources;
+ * prevent new connections from being established.
  */

diff --git a/lib/isc/task.c b/lib/isc/task.c
index 2c987875b3e8f222b0de719a9b6ecffaabaaf4a6..49112f22e766efbfc038fd71e95c91589dde4c4a 100644 (file)
--- a/lib/isc/task.c
+++ b/lib/isc/task.c
@@ -1008,19 +1008,12 @@ isc__taskmgr_create(isc_mem_t *mctx, unsigned int default_quantum, isc_nm_t *nm,
 }
 
 void
-isc__taskmgr_destroy(isc_taskmgr_t **managerp) {
-       isc_taskmgr_t *manager;
+isc__taskmgr_shutdown(isc_taskmgr_t *manager) {
        isc_task_t *task;
 
-       /*
-        * Destroy '*managerp'.
-        */
-
-       REQUIRE(managerp != NULL);
-       manager = *managerp;
        REQUIRE(VALID_MANAGER(manager));
 
-       XTHREADTRACE("isc_taskmgr_destroy");
+       XTHREADTRACE(e "isc_taskmgr_shutdown");
        /*
         * Only one non-worker thread may ever call this routine.
         * If a worker thread wants to initiate shutdown of the
@@ -1070,10 +1063,19 @@ isc__taskmgr_destroy(isc_taskmgr_t **managerp) {
        }
 
        UNLOCK(&manager->lock);
+}
 
-       isc_taskmgr_detach(manager);
+void
+isc__taskmgr_destroy(isc_taskmgr_t **managerp) {
+       REQUIRE(managerp != NULL && VALID_MANAGER(*managerp));
 
+       isc_taskmgr_t *manager = *managerp;
        *managerp = NULL;
+
+       XTHREADTRACE("isc_taskmgr_destroy");
+
+       REQUIRE(isc_refcount_decrement(&manager->references) == 1);
+       manager_free(manager);
 }
 
 void

diff --git a/lib/isc/task_p.h b/lib/isc/task_p.h
index fbf3eb1c56bf82c0f717a991efb1b46f56d3278d..4dda7d63ba24ce256e7edfb3d45a10ebc62a91b3 100644 (file)
--- a/lib/isc/task_p.h
+++ b/lib/isc/task_p.h
@@ -77,6 +77,24 @@ isc__taskmgr_destroy(isc_taskmgr_t **managerp);
  *
  *\li  '*managerp' is a valid task manager.
  *
+ *\li   'isc__taskmgr_shutdown()' and isc__netmgr_shutdown() have been
+ *     called.
+ */
+
+void
+isc__taskmgr_shutdown(isc_taskmgr_t *manager);
+/*%>
+ * Shutdown 'manager'.
+ *
+ * Notes:
+ *
+ *\li  Calling isc__taskmgr_shutdown() will shut down all tasks managed by
+ *     *managerp that haven't already been shut down.
+ *
+ * Requires:
+ *
+ *\li   'manager' is a valid task manager.
+ *
  *\li  isc_taskmgr_destroy() has not be called previously on '*managerp'.
  *
  * Ensures:

diff --git a/lib/isc/tests/doh_test.c b/lib/isc/tests/doh_test.c
index a04a000a6857fa97edd867ee90fb058e82130f80..1fa9d51fd31e937c6b306a16d38a3ca6cabb7843 100644 (file)
--- a/lib/isc/tests/doh_test.c
+++ b/lib/isc/tests/doh_test.c
@@ -499,7 +499,7 @@ doh_noop(void **state) {
                                              .length = send_msg.len },
                             noop_read_cb, NULL, atomic_load(&use_TLS), 30000);
 
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
 
        assert_int_equal(0, atomic_load(&csends));
        assert_int_equal(0, atomic_load(&creads));
@@ -546,7 +546,7 @@ doh_noresponse(void **state) {
        isc_nm_stoplistening(listen_sock);
        isc_nmsocket_close(&listen_sock);
        assert_null(listen_sock);
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
 }
 
 static void
@@ -667,7 +667,7 @@ doh_timeout_recovery(void **state) {
        isc_nm_stoplistening(listen_sock);
        isc_nmsocket_close(&listen_sock);
        assert_null(listen_sock);
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
 }
 
 static void
@@ -793,7 +793,7 @@ doh_recv_one(void **state) {
        isc_nm_stoplistening(listen_sock);
        isc_nmsocket_close(&listen_sock);
        assert_null(listen_sock);
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
 
        X(csends);
        X(creads);
@@ -914,7 +914,7 @@ doh_recv_two(void **state) {
        isc_nm_stoplistening(listen_sock);
        isc_nmsocket_close(&listen_sock);
        assert_null(listen_sock);
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
 
        X(csends);
        X(creads);
@@ -980,7 +980,7 @@ doh_recv_send(void **state) {
                isc_thread_join(threads[i], NULL);
        }
 
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
        isc_nm_stoplistening(listen_sock);
        isc_nmsocket_close(&listen_sock);
        assert_null(listen_sock);
@@ -1051,7 +1051,7 @@ doh_recv_half_send(void **state) {
                isc_thread_yield();
        }
 
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
 
        for (size_t i = 0; i < nthreads; i++) {
                isc_thread_join(threads[i], NULL);
@@ -1135,7 +1135,7 @@ doh_half_recv_send(void **state) {
                isc_thread_join(threads[i], NULL);
        }
 
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
 
        X(csends);
        X(creads);
@@ -1203,7 +1203,7 @@ doh_half_recv_half_send(void **state) {
                isc_thread_yield();
        }
 
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
        isc_nm_stoplistening(listen_sock);
        isc_nmsocket_close(&listen_sock);
        assert_null(listen_sock);

diff --git a/lib/isc/tests/isctest.c b/lib/isc/tests/isctest.c
index bf3521025195d3af6ca26d8108682d49d0a06515..89ef18c5c7278c71f995044894ede8361ed0bdb8 100644 (file)
--- a/lib/isc/tests/isctest.c
+++ b/lib/isc/tests/isctest.c
@@ -59,7 +59,10 @@ cleanup_managers(void) {
                isc_task_shutdown(maintask);
                isc_task_destroy(&maintask);
        }
-       isc_managers_destroy(&netmgr, &taskmgr, &timermgr, &socketmgr);
+       isc_managers_destroy(netmgr == NULL ? NULL : &netmgr,
+                            taskmgr == NULL ? NULL : &taskmgr,
+                            timermgr == NULL ? NULL : &timermgr,
+                            socketmgr == NULL ? NULL : &socketmgr);
 }
 
 static isc_result_t

diff --git a/lib/isc/tests/netmgr_test.c b/lib/isc/tests/netmgr_test.c
index 661133a92d04dfcac4590728c5d7fe06e814b6bb..2a1516bffc3b29ccf3dd677b79abf5ba09f03e3d 100644 (file)
--- a/lib/isc/tests/netmgr_test.c
+++ b/lib/isc/tests/netmgr_test.c
@@ -678,7 +678,7 @@ mock_udpconnect_uv_udp_open(void **state __attribute__((unused))) {
        isc_nm_udpconnect(connect_nm, (isc_nmiface_t *)&udp_connect_addr,
                          (isc_nmiface_t *)&udp_listen_addr, connect_connect_cb,
                          NULL, T_CONNECT, 0);
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
 
        RESET_RETURN;
 }
@@ -692,7 +692,7 @@ mock_udpconnect_uv_udp_bind(void **state __attribute__((unused))) {
        isc_nm_udpconnect(connect_nm, (isc_nmiface_t *)&udp_connect_addr,
                          (isc_nmiface_t *)&udp_listen_addr, connect_connect_cb,
                          NULL, T_CONNECT, 0);
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
 
        RESET_RETURN;
 }
@@ -707,7 +707,7 @@ mock_udpconnect_uv_udp_connect(void **state __attribute__((unused))) {
        isc_nm_udpconnect(connect_nm, (isc_nmiface_t *)&udp_connect_addr,
                          (isc_nmiface_t *)&udp_listen_addr, connect_connect_cb,
                          NULL, T_CONNECT, 0);
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
 
        RESET_RETURN;
 }
@@ -722,7 +722,7 @@ mock_udpconnect_uv_recv_buffer_size(void **state __attribute__((unused))) {
        isc_nm_udpconnect(connect_nm, (isc_nmiface_t *)&udp_connect_addr,
                          (isc_nmiface_t *)&udp_listen_addr, connect_connect_cb,
                          NULL, T_CONNECT, 0);
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
 
        RESET_RETURN;
 }
@@ -736,7 +736,7 @@ mock_udpconnect_uv_send_buffer_size(void **state __attribute__((unused))) {
        isc_nm_udpconnect(connect_nm, (isc_nmiface_t *)&udp_connect_addr,
                          (isc_nmiface_t *)&udp_listen_addr, connect_connect_cb,
                          NULL, T_CONNECT, 0);
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
 
        RESET_RETURN;
 }
@@ -759,7 +759,7 @@ udp_noop(void **state __attribute__((unused))) {
        isc_nm_udpconnect(connect_nm, (isc_nmiface_t *)&udp_connect_addr,
                          (isc_nmiface_t *)&udp_listen_addr, connect_connect_cb,
                          NULL, T_CONNECT, 0);
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
 
        atomic_assert_int_eq(cconnects, 0);
        atomic_assert_int_eq(csends, 0);
@@ -788,7 +788,7 @@ udp_noresponse(void **state __attribute__((unused))) {
        isc_nm_stoplistening(listen_sock);
        isc_nmsocket_close(&listen_sock);
        assert_null(listen_sock);
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
 
        X(cconnects);
        X(csends);
@@ -861,7 +861,7 @@ udp_timeout_recovery(void **state __attribute__((unused))) {
        isc_nm_stoplistening(listen_sock);
        isc_nmsocket_close(&listen_sock);
        assert_null(listen_sock);
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
 }
 
 static void
@@ -890,7 +890,7 @@ udp_recv_one(void **state __attribute__((unused))) {
        isc_nm_stoplistening(listen_sock);
        isc_nmsocket_close(&listen_sock);
        assert_null(listen_sock);
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
 
        X(cconnects);
        X(csends);
@@ -938,7 +938,7 @@ udp_recv_two(void **state __attribute__((unused))) {
        isc_nm_stoplistening(listen_sock);
        isc_nmsocket_close(&listen_sock);
        assert_null(listen_sock);
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
 
        X(cconnects);
        X(csends);
@@ -981,7 +981,7 @@ udp_recv_send(void **state __attribute__((unused))) {
                isc_thread_join(threads[i], NULL);
        }
 
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
        isc_nm_stoplistening(listen_sock);
        isc_nmsocket_close(&listen_sock);
        assert_null(listen_sock);
@@ -1021,7 +1021,7 @@ udp_recv_half_send(void **state __attribute__((unused))) {
        WAIT_FOR_GE(ssends, esends / 2);
        WAIT_FOR_GE(creads, esends / 2);
 
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
 
        DONE();
        for (size_t i = 0; i < workers; i++) {
@@ -1074,7 +1074,7 @@ udp_half_recv_send(void **state __attribute__((unused))) {
        /* Try to send a little while longer */
        isc_test_nap((esends / 2) * 10000);
 
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
 
        DONE();
        for (size_t i = 0; i < workers; i++) {
@@ -1116,7 +1116,7 @@ udp_half_recv_half_send(void **state __attribute__((unused))) {
        WAIT_FOR_GE(ssends, esends / 2);
        WAIT_FOR_GE(creads, esends / 2);
 
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
        isc_nm_stoplistening(listen_sock);
        isc_nmsocket_close(&listen_sock);
        assert_null(listen_sock);
@@ -1219,7 +1219,7 @@ stream_noop(void **state __attribute__((unused))) {
        connect_readcb = NULL;
        isc_refcount_increment0(&active_cconnects);
        stream_connect(connect_connect_cb, NULL, T_CONNECT, 0);
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
 
        atomic_assert_int_eq(cconnects, 0);
        atomic_assert_int_eq(csends, 0);
@@ -1245,7 +1245,7 @@ stream_noresponse(void **state __attribute__((unused))) {
        isc_nm_stoplistening(listen_sock);
        isc_nmsocket_close(&listen_sock);
        assert_null(listen_sock);
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
 
        X(cconnects);
        X(csends);
@@ -1295,7 +1295,7 @@ stream_timeout_recovery(void **state __attribute__((unused))) {
        isc_nm_stoplistening(listen_sock);
        isc_nmsocket_close(&listen_sock);
        assert_null(listen_sock);
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
 }
 
 static void
@@ -1323,7 +1323,7 @@ stream_recv_one(void **state __attribute__((unused))) {
        isc_nm_stoplistening(listen_sock);
        isc_nmsocket_close(&listen_sock);
        assert_null(listen_sock);
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
 
        X(cconnects);
        X(csends);
@@ -1368,7 +1368,7 @@ stream_recv_two(void **state __attribute__((unused))) {
        isc_nm_stoplistening(listen_sock);
        isc_nmsocket_close(&listen_sock);
        assert_null(listen_sock);
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
 
        X(cconnects);
        X(csends);
@@ -1417,7 +1417,7 @@ stream_recv_send(void **state __attribute__((unused))) {
                isc_thread_join(threads[i], NULL);
        }
 
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
        isc_nm_stoplistening(listen_sock);
        isc_nmsocket_close(&listen_sock);
        assert_null(listen_sock);
@@ -1463,7 +1463,7 @@ stream_recv_half_send(void **state __attribute__((unused))) {
        WAIT_FOR_GE(ssends, esends / 2);
        WAIT_FOR_GE(creads, esends / 2);
 
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
 
        DONE();
        for (size_t i = 0; i < workers; i++) {
@@ -1522,7 +1522,7 @@ stream_half_recv_send(void **state __attribute__((unused))) {
        /* Try to send a little while longer */
        isc_test_nap((esends / 2) * 10000);
 
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
 
        DONE();
        for (size_t i = 0; i < workers; i++) {
@@ -1570,7 +1570,7 @@ stream_half_recv_half_send(void **state __attribute__((unused))) {
        WAIT_FOR_GE(ssends, esends / 2);
        WAIT_FOR_GE(creads, esends / 2);
 
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
        isc_nm_stoplistening(listen_sock);
        isc_nmsocket_close(&listen_sock);
        assert_null(listen_sock);
@@ -1768,7 +1768,7 @@ tcpdns_noop(void **state __attribute__((unused))) {
        isc_nm_tcpdnsconnect(connect_nm, (isc_nmiface_t *)&tcp_connect_addr,
                             (isc_nmiface_t *)&tcp_listen_addr,
                             connect_connect_cb, NULL, T_CONNECT, 0);
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
 
        atomic_assert_int_eq(cconnects, 0);
        atomic_assert_int_eq(csends, 0);
@@ -1802,7 +1802,7 @@ tcpdns_noresponse(void **state __attribute__((unused))) {
        isc_nm_stoplistening(listen_sock);
        isc_nmsocket_close(&listen_sock);
        assert_null(listen_sock);
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
 
        X(cconnects);
        X(csends);
@@ -1857,7 +1857,7 @@ tcpdns_timeout_recovery(void **state __attribute__((unused))) {
        isc_nm_stoplistening(listen_sock);
        isc_nmsocket_close(&listen_sock);
        assert_null(listen_sock);
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
 }
 
 static void
@@ -1887,7 +1887,7 @@ tcpdns_recv_one(void **state __attribute__((unused))) {
        isc_nm_stoplistening(listen_sock);
        isc_nmsocket_close(&listen_sock);
        assert_null(listen_sock);
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
 
        X(cconnects);
        X(csends);
@@ -1937,7 +1937,7 @@ tcpdns_recv_two(void **state __attribute__((unused))) {
        isc_nm_stoplistening(listen_sock);
        isc_nmsocket_close(&listen_sock);
        assert_null(listen_sock);
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
 
        X(cconnects);
        X(csends);
@@ -1981,7 +1981,7 @@ tcpdns_recv_send(void **state __attribute__((unused))) {
                isc_thread_join(threads[i], NULL);
        }
 
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
        isc_nm_stoplistening(listen_sock);
        isc_nmsocket_close(&listen_sock);
        assert_null(listen_sock);
@@ -2022,7 +2022,7 @@ tcpdns_recv_half_send(void **state __attribute__((unused))) {
        WAIT_FOR_GE(ssends, esends / 2);
        WAIT_FOR_GE(creads, esends / 2);
 
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
 
        DONE();
        for (size_t i = 0; i < workers; i++) {
@@ -2076,7 +2076,7 @@ tcpdns_half_recv_send(void **state __attribute__((unused))) {
        /* Try to send a little while longer */
        isc_test_nap((esends / 2) * 10000);
 
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
 
        DONE();
        for (size_t i = 0; i < workers; i++) {
@@ -2119,7 +2119,7 @@ tcpdns_half_recv_half_send(void **state __attribute__((unused))) {
        WAIT_FOR_GE(ssends, esends / 2);
        WAIT_FOR_GE(creads, esends / 2);
 
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
        isc_nm_stoplistening(listen_sock);
        isc_nmsocket_close(&listen_sock);
        assert_null(listen_sock);
@@ -2356,7 +2356,7 @@ tlsdns_noop(void **state __attribute__((unused))) {
                             connect_connect_cb, NULL, T_CONNECT, 0,
                             tcp_connect_tlsctx);
 
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
 
        atomic_assert_int_eq(cconnects, 0);
        atomic_assert_int_eq(csends, 0);
@@ -2392,7 +2392,7 @@ tlsdns_noresponse(void **state __attribute__((unused))) {
        isc_nm_stoplistening(listen_sock);
        isc_nmsocket_close(&listen_sock);
        assert_null(listen_sock);
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
 
        X(cconnects);
        X(csends);
@@ -2453,7 +2453,7 @@ tlsdns_timeout_recovery(void **state __attribute__((unused))) {
        isc_nm_stoplistening(listen_sock);
        isc_nmsocket_close(&listen_sock);
        assert_null(listen_sock);
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
 }
 
 static void
@@ -2485,7 +2485,7 @@ tlsdns_recv_one(void **state __attribute__((unused))) {
        isc_nm_stoplistening(listen_sock);
        isc_nmsocket_close(&listen_sock);
        assert_null(listen_sock);
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
 
        X(cconnects);
        X(csends);
@@ -2538,7 +2538,7 @@ tlsdns_recv_two(void **state __attribute__((unused))) {
        isc_nm_stoplistening(listen_sock);
        isc_nmsocket_close(&listen_sock);
        assert_null(listen_sock);
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
 
        X(cconnects);
        X(csends);
@@ -2583,7 +2583,7 @@ tlsdns_recv_send(void **state __attribute__((unused))) {
                isc_thread_join(threads[i], NULL);
        }
 
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
        isc_nm_stoplistening(listen_sock);
        isc_nmsocket_close(&listen_sock);
        assert_null(listen_sock);
@@ -2625,7 +2625,7 @@ tlsdns_recv_half_send(void **state __attribute__((unused))) {
        WAIT_FOR_GE(ssends, esends / 2);
        WAIT_FOR_GE(creads, esends / 2);
 
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
 
        DONE();
        for (size_t i = 0; i < workers; i++) {
@@ -2680,7 +2680,7 @@ tlsdns_half_recv_send(void **state __attribute__((unused))) {
        /* Try to send a little while longer */
        isc_test_nap((esends / 2) * 10000);
 
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
 
        DONE();
        for (size_t i = 0; i < workers; i++) {
@@ -2724,7 +2724,7 @@ tlsdns_half_recv_half_send(void **state __attribute__((unused))) {
        WAIT_FOR_GE(ssends, esends / 2);
        WAIT_FOR_GE(creads, esends / 2);
 
-       isc_nm_closedown(connect_nm);
+       isc__netmgr_shutdown(connect_nm);
        isc_nm_stoplistening(listen_sock);
        isc_nmsocket_close(&listen_sock);
        assert_null(listen_sock);

diff --git a/lib/isc/win32/libisc.def.in b/lib/isc/win32/libisc.def.in
index d5ae24177cad3a8ec819cbbbf456989e62b68b31..3c4dd02f7165f0d34797f0e8bdffd32c8ccc843a 100644 (file)
--- a/lib/isc/win32/libisc.def.in
+++ b/lib/isc/win32/libisc.def.in
@@ -451,7 +451,6 @@ isc_nmhandle_peeraddr
 isc_nmhandle_setdata
 isc_nmhandle_settimeout
 isc_nm_cancelread
-isc_nm_closedown
 isc_nm_detach
 isc_nm_http_endpoint
 isc_nm_httpconnect

diff --git a/lib/ns/client.c b/lib/ns/client.c
index 16e14be4c9fed1a6a72047cce56877403473b142..bc0afe1a19bb2146e6ce406bc152460aa795cd89 100644 (file)
--- a/lib/ns/client.c
+++ b/lib/ns/client.c
@@ -1629,15 +1629,13 @@ ns__client_put_cb(void *client0) {
 void
 ns__client_request(isc_nmhandle_t *handle, isc_result_t eresult,
                   isc_region_t *region, void *arg) {
-       ns_client_t *client;
-       ns_clientmgr_t *mgr;
-       ns_interface_t *ifp;
+       ns_client_t *client = NULL;
        isc_result_t result;
        isc_result_t sigresult = ISC_R_SUCCESS;
-       isc_buffer_t *buffer;
+       isc_buffer_t *buffer = NULL;
        isc_buffer_t tbuffer;
-       dns_rdataset_t *opt;
-       const dns_name_t *signame;
+       dns_rdataset_t *opt = NULL;
+       const dns_name_t *signame = NULL;
        bool ra; /* Recursion available. */
        isc_netaddr_t netaddr;
        int match;
@@ -1645,29 +1643,24 @@ ns__client_request(isc_nmhandle_t *handle, isc_result_t eresult,
        unsigned int flags;
        bool notimp;
        size_t reqsize;
-       dns_aclenv_t *env;
+       dns_aclenv_t *env = NULL;
 #ifdef HAVE_DNSTAP
        dns_dtmsgtype_t dtmsgtype;
 #endif /* ifdef HAVE_DNSTAP */
-       ifp = (ns_interface_t *)arg;
 
        if (eresult != ISC_R_SUCCESS) {
                return;
        }
 
-       mgr = ifp->clientmgr;
-       if (mgr == NULL) {
-               /* The interface was shut down in the meantime, just bail */
-               return;
-       }
-
-       REQUIRE(VALID_MANAGER(mgr));
-
        client = isc_nmhandle_getdata(handle);
        if (client == NULL) {
+               ns_interface_t *ifp = (ns_interface_t *)arg;
+
+               INSIST(VALID_MANAGER(ifp->clientmgr));
+
                client = isc_nmhandle_getextra(handle);
 
-               result = ns__client_setup(client, mgr, true);
+               result = ns__client_setup(client, ifp->clientmgr, true);
                if (result != ISC_R_SUCCESS) {
                        return;
                }

diff --git a/lib/ns/tests/nstest.c b/lib/ns/tests/nstest.c
index 67f0792bdcd7722af6906ed18292864bb4acc5f8..b291335afa63dc53c7193c4eb2542f5ad8b95a34 100644 (file)
--- a/lib/ns/tests/nstest.c
+++ b/lib/ns/tests/nstest.c
@@ -199,7 +199,10 @@ cleanup_managers(void) {
                ns_interfacemgr_detach(&interfacemgr);
        }
 
-       isc_managers_destroy(&netmgr, &taskmgr, &timermgr, &socketmgr);
+       isc_managers_destroy(netmgr == NULL ? NULL : &netmgr,
+                            taskmgr == NULL ? NULL : &taskmgr,
+                            timermgr == NULL ? NULL : &timermgr,
+                            socketmgr == NULL ? NULL : &socketmgr);
 
        if (app_running) {
                isc_app_finish();