remove ADB whenshutdown events

weakly attaching and detaching the view when creating or destroying
the ADB obviates the need for a whenshutdown callback event to do
the detaching.  remove the dns_adb_whenshutdown() mechanism, since
it is no longer needed.

diff --git a/lib/dns/adb.c b/lib/dns/adb.c
index 52ebf9bdc8e97d242522c516a064b29c06f83bd8..b41994f7103523aa59938def5f9d1d912badf487 100644 (file)
--- a/lib/dns/adb.c
+++ b/lib/dns/adb.c
@@ -117,10 +117,7 @@ struct dns_adb {
 
        isc_stats_t *stats;
 
-       isc_event_t cevent;
-       bool cevent_out;
        atomic_bool exiting;
-       isc_eventlist_t whenshutdown;
 
        uint32_t quota;
        uint32_t atr_freq;
@@ -1237,7 +1234,9 @@ clean_finds_at_name(dns_adbname_t *name, isc_eventtype_t evtype,
                        ev->ev_destroy = event_freefind;
                        ev->ev_destroy_arg = find;
 
-                       DP(DEF_LEVEL, "sending event %p to task %p for find %p",
+                       DP(DEF_LEVEL,
+                          "cfan: sending event %p "
+                          "to task %p for find %p",
                           ev, task, find);
 
                        isc_task_sendanddetach(&task, (isc_event_t **)&ev);
@@ -2045,8 +2044,7 @@ destroy(dns_adb_t *adb) {
 
        adb->magic = 0;
 
-       isc_task_detach(&adb->task);
-
+       RWLOCK(&adb->names_lock, isc_rwlocktype_write);
        isc_ht_iter_create(adb->namebuckets, &it);
        for (result = isc_ht_iter_first(it); result == ISC_R_SUCCESS;
             result = isc_ht_iter_delcurrent_next(it))
@@ -2058,7 +2056,10 @@ destroy(dns_adb_t *adb) {
        }
        isc_ht_iter_destroy(&it);
        isc_ht_destroy(&adb->namebuckets);
+       RWUNLOCK(&adb->names_lock, isc_rwlocktype_write);
+       isc_rwlock_destroy(&adb->names_lock);
 
+       RWLOCK(&adb->entries_lock, isc_rwlocktype_write);
        isc_ht_iter_create(adb->entrybuckets, &it);
        for (result = isc_ht_iter_first(it); result == ISC_R_SUCCESS;
             result = isc_ht_iter_delcurrent_next(it))
@@ -2070,12 +2071,14 @@ destroy(dns_adb_t *adb) {
        }
        isc_ht_iter_destroy(&it);
        isc_ht_destroy(&adb->entrybuckets);
-
-       isc_rwlock_destroy(&adb->names_lock);
+       RWUNLOCK(&adb->entries_lock, isc_rwlocktype_write);
        isc_rwlock_destroy(&adb->entries_lock);
+
        isc_mutex_destroy(&adb->lock);
 
+       isc_task_detach(&adb->task);
        isc_stats_detach(&adb->stats);
+       dns_view_weakdetach(&adb->view);
        isc_mem_putanddetach(&adb->mctx, adb, sizeof(dns_adb_t));
 }
 
@@ -2096,7 +2099,6 @@ dns_adb_create(isc_mem_t *mem, dns_view_t *view, isc_taskmgr_t *taskmgr,
 
        adb = isc_mem_get(mem, sizeof(dns_adb_t));
        *adb = (dns_adb_t){
-               .view = view,
                .taskmgr = taskmgr,
        };
 
@@ -2105,11 +2107,7 @@ dns_adb_create(isc_mem_t *mem, dns_view_t *view, isc_taskmgr_t *taskmgr,
         * that must be NULL for the error return to work properly.
         */
        isc_refcount_init(&adb->references, 1);
-       ISC_EVENT_INIT(&adb->cevent, sizeof(adb->cevent), 0, NULL, 0, NULL,
-                      NULL, NULL, NULL, NULL);
-       ISC_LIST_INIT(adb->whenshutdown);
-       atomic_init(&adb->exiting, false);
-
+       dns_view_weakattach(view, &adb->view);
        isc_mem_attach(mem, &adb->mctx);
 
        isc_ht_init(&adb->namebuckets, adb->mctx, 1, ISC_HT_CASE_INSENSITIVE);
@@ -2158,6 +2156,7 @@ free_lock:
        isc_rwlock_destroy(&adb->names_lock);
        isc_ht_destroy(&adb->namebuckets);
 
+       dns_view_weakdetach(&adb->view);
        isc_mem_putanddetach(&adb->mctx, adb, sizeof(dns_adb_t));
 
        return (result);
@@ -2211,39 +2210,8 @@ dns__adb_detach(dns_adb_t **adbp, const char *func, const char *file,
        }
 }
 
-void
-dns_adb_whenshutdown(dns_adb_t *adb, isc_task_t *task, isc_event_t **eventp) {
-       isc_event_t *event = NULL;
-
-       /*
-        * Send '*eventp' to 'task' when 'adb' has shutdown.
-        */
-
-       REQUIRE(DNS_ADB_VALID(adb));
-       REQUIRE(eventp != NULL);
-
-       event = *eventp;
-       *eventp = NULL;
-
-       if (atomic_load(&adb->exiting)) {
-               /*
-                * We're already shutdown.  Send the event.
-                */
-               event->ev_sender = adb;
-               isc_task_send(task, &event);
-       } else {
-               LOCK(&adb->lock);
-               isc_task_attach(task, &(isc_task_t *){ NULL });
-               event->ev_sender = task;
-               ISC_LIST_APPEND(adb->whenshutdown, event, ev_link);
-               UNLOCK(&adb->lock);
-       }
-}
-
 void
 dns_adb_shutdown(dns_adb_t *adb) {
-       isc_event_t *event = NULL;
-
        if (!atomic_compare_exchange_strong(&adb->exiting, &(bool){ false },
                                            true)) {
                return;
@@ -2255,17 +2223,6 @@ dns_adb_shutdown(dns_adb_t *adb) {
 
        shutdown_names(adb);
        shutdown_entries(adb);
-
-       LOCK(&adb->lock);
-       for (event = ISC_LIST_HEAD(adb->whenshutdown); event != NULL;
-            event = ISC_LIST_HEAD(adb->whenshutdown))
-       {
-               isc_task_t *task = event->ev_sender;
-               event->ev_sender = adb;
-               ISC_LIST_UNLINK(adb->whenshutdown, event, ev_link);
-               isc_task_sendanddetach(&task, &event);
-       }
-       UNLOCK(&adb->lock);
 }
 
 /*
@@ -3175,7 +3132,7 @@ fetch_callback(isc_task_t *task, isc_event_t *ev) {
        name = ev->ev_arg;
 
        REQUIRE(DNS_ADBNAME_VALID(name));
-       adb = name->adb;
+       dns_adb_attach(name->adb, &adb);
 
        REQUIRE(DNS_ADB_VALID(adb));
 
@@ -3199,9 +3156,6 @@ fetch_callback(isc_task_t *task, isc_event_t *ev) {
 
        INSIST(address_type != 0 && fetch != NULL);
 
-       dns_resolver_destroyfetch(&fetch->fetch);
-       dev->fetch = NULL;
-
        ev_status = DNS_EVENT_ADBNOMOREADDRESSES;
 
        /*
@@ -3219,11 +3173,8 @@ fetch_callback(isc_task_t *task, isc_event_t *ev) {
         * potentially good data.
         */
        if (NAME_DEAD(name)) {
-               free_adbfetch(adb, &fetch);
-               isc_event_free(&ev);
-               expire_name(&name, DNS_EVENT_ADBCANCELED);
-               UNLOCK(&nbucket->lock);
-               return;
+               ev_status = DNS_EVENT_ADBCANCELED;
+               goto out;
        }
 
        isc_stdtime_get(&now);
@@ -3327,12 +3278,16 @@ check_result:
        }
 
 out:
+       dns_resolver_destroyfetch(&fetch->fetch);
        free_adbfetch(adb, &fetch);
        isc_event_free(&ev);
-
-       clean_finds_at_name(name, ev_status, address_type);
-
+       if (ev_status == DNS_EVENT_ADBCANCELED) {
+               expire_name(&name, ev_status);
+       } else {
+               clean_finds_at_name(name, ev_status, address_type);
+       }
        UNLOCK(&nbucket->lock);
+       dns_adb_detach(&adb);
 }
 
 static isc_result_t

diff --git a/lib/dns/include/dns/adb.h b/lib/dns/include/dns/adb.h
index 2163a2ce3f908673e5ca8c82f978ecba3b9aa5d2..643dfe7588a85a9aec86a95e23cc55f958d008e8 100644 (file)
--- a/lib/dns/include/dns/adb.h
+++ b/lib/dns/include/dns/adb.h
@@ -308,25 +308,6 @@ dns__adb_detach(dns_adb_t **adb, const char *func, const char *file,
  *     dns_adb_create().
  */
 
-void
-dns_adb_whenshutdown(dns_adb_t *adb, isc_task_t *task, isc_event_t **eventp);
-/*%
- * Send '*eventp' to 'task' when 'adb' has shutdown.
- *
- * Requires:
- *
- *\li  '*adb' is a valid dns_adb_t.
- *
- *\li  eventp != NULL && *eventp is a valid event.
- *
- * Ensures:
- *
- *\li  *eventp == NULL
- *
- *\li  The event's sender field is set to the value of adb when the event
- *     is sent.
- */
-
 void
 dns_adb_shutdown(dns_adb_t *adb);
 /*%<

diff --git a/lib/dns/include/dns/events.h b/lib/dns/include/dns/events.h
index b2ad2e83efbf07a3fde3335cad2938f674b36ad9..58ce66df8ff130f1f7290f623605ef9f4d8642bc 100644 (file)
--- a/lib/dns/include/dns/events.h
+++ b/lib/dns/include/dns/events.h
@@ -20,10 +20,10 @@
  * Registry of DNS event numbers.
  */
 
-#define DNS_EVENT_FETCHCONTROL      (ISC_EVENTCLASS_DNS + 0)
-#define DNS_EVENT_FETCHDONE         (ISC_EVENTCLASS_DNS + 1)
-#define DNS_EVENT_VIEWRESSHUTDOWN    (ISC_EVENTCLASS_DNS + 2)
-#define DNS_EVENT_VIEWADBSHUTDOWN    (ISC_EVENTCLASS_DNS + 3)
+#define DNS_EVENT_FETCHCONTROL   (ISC_EVENTCLASS_DNS + 0)
+#define DNS_EVENT_FETCHDONE      (ISC_EVENTCLASS_DNS + 1)
+#define DNS_EVENT_VIEWRESSHUTDOWN (ISC_EVENTCLASS_DNS + 2)
+/* #define DNS_EVENT_VIEWADBSHUTDOWN    (ISC_EVENTCLASS_DNS + 3) */
 #define DNS_EVENT_UPDATE            (ISC_EVENTCLASS_DNS + 4)
 #define DNS_EVENT_UPDATEDONE        (ISC_EVENTCLASS_DNS + 5)
 #define DNS_EVENT_DISPATCH          (ISC_EVENTCLASS_DNS + 6)

diff --git a/lib/dns/include/dns/view.h b/lib/dns/include/dns/view.h
index d590dfeaa3cbf1654de6cdbe47e651ddfd5b3526..9918e2c2bea8a8b0f3f04a4e1f279d914b26940d 100644 (file)
--- a/lib/dns/include/dns/view.h
+++ b/lib/dns/include/dns/view.h
@@ -105,7 +105,6 @@ struct dns_view {
        bool        frozen;
        isc_task_t *task;
        isc_event_t resevent;
-       isc_event_t adbevent;
        isc_event_t reqevent;
        bool        cacheshared;
 

diff --git a/lib/dns/view.c b/lib/dns/view.c
index 13f55142b575438f51494fe3b9d6f0c8572a2469..8f2f4fbed2f0344744b79d25c1bfedf65f381d32 100644 (file)
--- a/lib/dns/view.c
+++ b/lib/dns/view.c
@@ -78,8 +78,6 @@
 static void
 resolver_shutdown(isc_task_t *task, isc_event_t *event);
 static void
-adb_shutdown(isc_task_t *task, isc_event_t *event);
-static void
 req_shutdown(isc_task_t *task, isc_event_t *event);
 
 isc_result_t
@@ -133,9 +131,6 @@ dns_view_create(isc_mem_t *mctx, dns_rdataclass_t rdclass, const char *name,
        ISC_EVENT_INIT(&view->resevent, sizeof(view->resevent), 0, NULL,
                       DNS_EVENT_VIEWRESSHUTDOWN, resolver_shutdown, view, NULL,
                       NULL, NULL);
-       ISC_EVENT_INIT(&view->adbevent, sizeof(view->adbevent), 0, NULL,
-                      DNS_EVENT_VIEWADBSHUTDOWN, adb_shutdown, view, NULL,
-                      NULL, NULL);
        ISC_EVENT_INIT(&view->reqevent, sizeof(view->reqevent), 0, NULL,
                       DNS_EVENT_VIEWREQSHUTDOWN, req_shutdown, view, NULL,
                       NULL, NULL);
@@ -525,6 +520,7 @@ dns_view_detach(dns_view_t **viewp) {
                }
                if (view->adb != NULL) {
                        dns_adb_shutdown(view->adb);
+                       dns_adb_detach(&view->adb);
                }
                if (view->requestmgr != NULL) {
                        dns_requestmgr_shutdown(view->requestmgr);
@@ -635,21 +631,6 @@ resolver_shutdown(isc_task_t *task, isc_event_t *event) {
        dns_view_weakdetach(&view);
 }
 
-static void
-adb_shutdown(isc_task_t *task, isc_event_t *event) {
-       dns_view_t *view = event->ev_arg;
-
-       REQUIRE(event->ev_type == DNS_EVENT_VIEWADBSHUTDOWN);
-       REQUIRE(DNS_VIEW_VALID(view));
-       REQUIRE(view->task == task);
-
-       UNUSED(task);
-
-       isc_event_free(&event);
-
-       dns_view_weakdetach(&view);
-}
-
 static void
 req_shutdown(isc_task_t *task, isc_event_t *event) {
        dns_view_t *view = event->ev_arg;
@@ -702,22 +683,19 @@ dns_view_createresolver(dns_view_t *view, isc_taskmgr_t *taskmgr,
                isc_task_detach(&view->task);
                return (result);
        }
+
+       dns_view_weakattach(view, &(dns_view_t *){ NULL });
        event = &view->resevent;
        dns_resolver_whenshutdown(view->resolver, view->task, &event);
-       isc_refcount_increment(&view->weakrefs);
 
        isc_mem_create(&mctx);
        isc_mem_setname(mctx, "ADB");
-
        result = dns_adb_create(mctx, view, taskmgr, &view->adb);
        isc_mem_detach(&mctx);
        if (result != ISC_R_SUCCESS) {
                dns_resolver_shutdown(view->resolver);
                return (result);
        }
-       event = &view->adbevent;
-       dns_adb_whenshutdown(view->adb, view->task, &event);
-       isc_refcount_increment(&view->weakrefs);
 
        result = dns_requestmgr_create(
                view->mctx, dns_resolver_taskmgr(view->resolver),
@@ -725,12 +703,14 @@ dns_view_createresolver(dns_view_t *view, isc_taskmgr_t *taskmgr,
                dispatchv6, &view->requestmgr);
        if (result != ISC_R_SUCCESS) {
                dns_adb_shutdown(view->adb);
+               dns_adb_detach(&view->adb);
                dns_resolver_shutdown(view->resolver);
                return (result);
        }
+
+       dns_view_weakattach(view, &(dns_view_t *){ NULL });
        event = &view->reqevent;
        dns_requestmgr_whenshutdown(view->requestmgr, view->task, &event);
-       isc_refcount_increment(&view->weakrefs);
 
        return (ISC_R_SUCCESS);
 }