Remove local locking macros as they are always RWLOCK now

diff --git a/lib/dns/rbtdb.c b/lib/dns/rbtdb.c
index 670f5df9f213341024ec31d9af224609e88d21dd..880cadaacfe11d52f10fcb769642d40c2c45b56a 100644 (file)
--- a/lib/dns/rbtdb.c
+++ b/lib/dns/rbtdb.c
@@ -135,11 +135,6 @@ typedef isc_uint32_t                    rbtdb_rdatatype_t;
 #define RBTDB_RDATATYPE_NCACHEANY \
                RBTDB_RDATATYPE_VALUE(0, dns_rdatatype_any)
 
-#define RBTDB_INITLOCK(l)       isc_rwlock_init((l), 0, 0)
-#define RBTDB_DESTROYLOCK(l)    isc_rwlock_destroy(l)
-#define RBTDB_LOCK(l, t)        RWLOCK((l), (t))
-#define RBTDB_UNLOCK(l, t)      RWUNLOCK((l), (t))
-
 /*
  * Since node locking is sensitive to both performance and memory footprint,
  * we need some trick here.  If we have both high-performance rwlock and
@@ -1104,7 +1099,7 @@ free_rbtdb(dns_rbtdb_t *rbtdb, isc_boolean_t log, isc_event_t *event) {
        if (rbtdb->task != NULL)
                isc_task_detach(&rbtdb->task);
 
-       RBTDB_DESTROYLOCK(&rbtdb->lock);
+       isc_rwlock_destroy(&rbtdb->lock);
        rbtdb->common.magic = 0;
        rbtdb->common.impmagic = 0;
        isc_mem_detach(&rbtdb->hmctx);
@@ -1163,12 +1158,12 @@ maybe_free_rbtdb(dns_rbtdb_t *rbtdb) {
        }
 
        if (inactive != 0) {
-               RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_write);
+               RWLOCK(&rbtdb->lock, isc_rwlocktype_write);
                rbtdb->active -= inactive;
                if (rbtdb->active == 0) {
                        want_free = ISC_TRUE;
                }
-               RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_write);
+               RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write);
                if (want_free) {
                        char buf[DNS_NAME_FORMATSIZE];
                        if (dns_name_dynamic(&rbtdb->common.origin)) {
@@ -1208,10 +1203,10 @@ currentversion(dns_db_t *db, dns_dbversion_t **versionp) {
 
        REQUIRE(VALID_RBTDB(rbtdb));
 
-       RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_read);
+       RWLOCK(&rbtdb->lock, isc_rwlocktype_read);
        version = rbtdb->current_version;
        isc_refcount_increment(&version->references, &refs);
-       RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_read);
+       RWUNLOCK(&rbtdb->lock, isc_rwlocktype_read);
 
        *versionp = (dns_dbversion_t *)version;
 }
@@ -1274,7 +1269,7 @@ newversion(dns_db_t *db, dns_dbversion_t **versionp) {
        REQUIRE(versionp != NULL && *versionp == NULL);
        REQUIRE(rbtdb->future_version == NULL);
 
-       RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_write);
+       RWLOCK(&rbtdb->lock, isc_rwlocktype_write);
        RUNTIME_CHECK(rbtdb->next_serial != 0);         /* XXX Error? */
        version = allocate_version(rbtdb->common.mctx, rbtdb->next_serial, 1,
                                   ISC_TRUE);
@@ -1319,7 +1314,7 @@ newversion(dns_db_t *db, dns_dbversion_t **versionp) {
                }
        } else
                result = ISC_R_NOMEMORY;
-       RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_write);
+       RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write);
 
        if (version == NULL)
                return (result);
@@ -1360,7 +1355,7 @@ add_changed(dns_rbtdb_t *rbtdb, rbtdb_version_t *version,
 
        changed = isc_mem_get(rbtdb->common.mctx, sizeof(*changed));
 
-       RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_write);
+       RWLOCK(&rbtdb->lock, isc_rwlocktype_write);
 
        REQUIRE(version->writer);
 
@@ -1373,7 +1368,7 @@ add_changed(dns_rbtdb_t *rbtdb, rbtdb_version_t *version,
        } else
                version->commit_ok = ISC_FALSE;
 
-       RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_write);
+       RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write);
 
        return (changed);
 }
@@ -2061,9 +2056,9 @@ decrement_reference(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node,
                                 * Caller doesn't know the least serial.
                                 * Get it.
                                 */
-                               RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_read);
+                               RWLOCK(&rbtdb->lock, isc_rwlocktype_read);
                                least_serial = rbtdb->least_serial;
-                               RBTDB_UNLOCK(&rbtdb->lock,
+                               RWUNLOCK(&rbtdb->lock,
                                             isc_rwlocktype_read);
                        }
                        clean_zone_node(rbtdb, node, least_serial);
@@ -2496,9 +2491,9 @@ closeversion(dns_db_t *db, dns_dbversion_t **versionp, isc_boolean_t commit) {
        isc_refcount_decrement(&version->references, &refs);
        if (refs > 0) {         /* typical and easy case first */
                if (commit) {
-                       RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_read);
+                       RWLOCK(&rbtdb->lock, isc_rwlocktype_read);
                        INSIST(!version->writer);
-                       RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_read);
+                       RWUNLOCK(&rbtdb->lock, isc_rwlocktype_read);
                }
                goto end;
        }
@@ -2510,7 +2505,7 @@ closeversion(dns_db_t *db, dns_dbversion_t **versionp, isc_boolean_t commit) {
        if (version->writer && commit && !IS_CACHE(rbtdb))
                iszonesecure(db, version, rbtdb->origin_node);
 
-       RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_write);
+       RWLOCK(&rbtdb->lock, isc_rwlocktype_write);
        serial = version->serial;
        if (version->writer) {
                if (commit) {
@@ -2643,7 +2638,7 @@ closeversion(dns_db_t *db, dns_dbversion_t **versionp, isc_boolean_t commit) {
                UNLINK(rbtdb->open_versions, version, link);
        }
        least_serial = rbtdb->least_serial;
-       RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_write);
+       RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write);
 
        if (cleanup_version != NULL) {
                INSIST(EMPTY(cleanup_version->changed_list));
@@ -5327,11 +5322,11 @@ detachnode(dns_db_t *db, dns_dbnode_t **targetp) {
        *targetp = NULL;
 
        if (inactive) {
-               RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_write);
+               RWLOCK(&rbtdb->lock, isc_rwlocktype_write);
                rbtdb->active--;
                if (rbtdb->active == 0)
                        want_free = ISC_TRUE;
-               RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_write);
+               RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write);
                if (want_free) {
                        char buf[DNS_NAME_FORMATSIZE];
                        if (dns_name_dynamic(&rbtdb->common.origin))
@@ -7402,13 +7397,13 @@ beginload(dns_db_t *db, dns_rdatacallbacks_t *callbacks) {
        else
                loadctx->now = 0;
 
-       RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_write);
+       RWLOCK(&rbtdb->lock, isc_rwlocktype_write);
 
        REQUIRE((rbtdb->attributes & (RBTDB_ATTR_LOADED|RBTDB_ATTR_LOADING))
                == 0);
        rbtdb->attributes |= RBTDB_ATTR_LOADING;
 
-       RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_write);
+       RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write);
 
        callbacks->add = loading_addrdataset;
        callbacks->add_private = loadctx;
@@ -7429,7 +7424,7 @@ endload(dns_db_t *db, dns_rdatacallbacks_t *callbacks) {
        REQUIRE(loadctx != NULL);
        REQUIRE(loadctx->rbtdb == rbtdb);
 
-       RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_write);
+       RWLOCK(&rbtdb->lock, isc_rwlocktype_write);
 
        REQUIRE((rbtdb->attributes & RBTDB_ATTR_LOADING) != 0);
        REQUIRE((rbtdb->attributes & RBTDB_ATTR_LOADED) == 0);
@@ -7437,7 +7432,7 @@ endload(dns_db_t *db, dns_rdatacallbacks_t *callbacks) {
        rbtdb->attributes &= ~RBTDB_ATTR_LOADING;
        rbtdb->attributes |= RBTDB_ATTR_LOADED;
 
-       RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_write);
+       RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write);
 
        /*
         * If there's a KEY rdataset at the zone origin containing a
@@ -7773,12 +7768,12 @@ settask(dns_db_t *db, isc_task_t *task) {
 
        REQUIRE(VALID_RBTDB(rbtdb));
 
-       RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_write);
+       RWLOCK(&rbtdb->lock, isc_rwlocktype_write);
        if (rbtdb->task != NULL)
                isc_task_detach(&rbtdb->task);
        if (task != NULL)
                isc_task_attach(task, &rbtdb->task);
-       RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_write);
+       RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write);
 }
 
 static isc_boolean_t
@@ -8237,7 +8232,7 @@ dns_rbtdb_create(isc_mem_t *mctx, const dns_name_t *origin, dns_dbtype_t type,
 
        ISC_LIST_INIT(rbtdb->common.update_listeners);
 
-       result = RBTDB_INITLOCK(&rbtdb->lock);
+       result = isc_rwlock_init(&rbtdb->lock, 0, 0);
        if (result != ISC_R_SUCCESS)
                goto cleanup_rbtdb;
 
@@ -8538,7 +8533,7 @@ dns_rbtdb_create(isc_mem_t *mctx, const dns_name_t *origin, dns_dbtype_t type,
        isc_rwlock_destroy(&rbtdb->tree_lock);
 
  cleanup_lock:
-       RBTDB_DESTROYLOCK(&rbtdb->lock);
+       isc_rwlock_destroy(&rbtdb->lock);
 
  cleanup_rbtdb:
        isc_mem_put(mctx, rbtdb,  sizeof(*rbtdb));

diff --git a/lib/dns/zone.c b/lib/dns/zone.c
index a14a4a05897fb0590273bbc73fb52d3d5c6252af..03ece190a291b93da326489c6408e5b5988eae41 100644 (file)
--- a/lib/dns/zone.c
+++ b/lib/dns/zone.c
@@ -174,11 +174,6 @@ typedef struct dns_include dns_include_t;
        do { result = isc_mutex_trylock(&(z)->lock); } while (0)
 #endif
 
-#define ZONEDB_INITLOCK(l)     isc_rwlock_init((l), 0, 0)
-#define ZONEDB_DESTROYLOCK(l)  isc_rwlock_destroy(l)
-#define ZONEDB_LOCK(l, t)      RWLOCK((l), (t))
-#define ZONEDB_UNLOCK(l, t)    RWUNLOCK((l), (t))
-
 struct dns_zone {
        /* Unlocked */
        unsigned int            magic;
@@ -891,7 +886,7 @@ dns_zone_create(dns_zone_t **zonep, isc_mem_t *mctx) {
                goto free_zone;
        }
 
-       result = ZONEDB_INITLOCK(&zone->dblock);
+       result = isc_rwlock_init(&zone->dblock, 0, 0);
        if (result != ISC_R_SUCCESS) {
                goto free_mutex;
        }
@@ -1077,7 +1072,7 @@ dns_zone_create(dns_zone_t **zonep, isc_mem_t *mctx) {
        isc_refcount_destroy(&zone->erefs);
 
  free_dblock:
-       ZONEDB_DESTROYLOCK(&zone->dblock);
+       isc_rwlock_destroy(&zone->dblock);
 
  free_mutex:
        DESTROYLOCK(&zone->lock);
@@ -1238,7 +1233,7 @@ zone_free(dns_zone_t *zone) {
        }
 
        /* last stuff */
-       ZONEDB_DESTROYLOCK(&zone->dblock);
+       isc_rwlock_destroy(&zone->dblock);
        DESTROYLOCK(&zone->lock);
        isc_refcount_destroy(&zone->erefs);
        zone->magic = 0;
@@ -1330,7 +1325,7 @@ dns_zone_getserial(dns_zone_t *zone, isc_uint32_t *serialp) {
        REQUIRE(serialp != NULL);
 
        LOCK_ZONE(zone);
-       ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+       RWLOCK(&zone->dblock, isc_rwlocktype_read);
        if (zone->db != NULL) {
                result = zone_get_from_db(zone, zone->db, NULL, &soacount,
                                          serialp, NULL, NULL, NULL, NULL,
@@ -1339,7 +1334,7 @@ dns_zone_getserial(dns_zone_t *zone, isc_uint32_t *serialp) {
                        result = ISC_R_FAILURE;
        } else
                result = DNS_R_NOTLOADED;
-       ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+       RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
        UNLOCK_ZONE(zone);
 
        return (result);
@@ -1994,7 +1989,7 @@ zone_load(dns_zone_t *zone, unsigned int flags, isc_boolean_t locked) {
                        goto cleanup;
                }
 
-               ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_write);
+               RWLOCK(&zone->dblock, isc_rwlocktype_write);
                /* ask SDLZ driver if the zone is supported */
                findzone = dlzdb->implementation->methods->findzone;
                result = (*findzone)(dlzdb->implementation->driverarg,
@@ -2008,7 +2003,7 @@ zone_load(dns_zone_t *zone, unsigned int flags, isc_boolean_t locked) {
                        dns_db_detach(&db);
                        result = ISC_R_SUCCESS;
                }
-               ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_write);
+               RWUNLOCK(&zone->dblock, isc_rwlocktype_write);
 
                if (result == ISC_R_SUCCESS) {
                        if (dlzdb->configure_callback == NULL)
@@ -2369,7 +2364,7 @@ zone_gotwritehandle(isc_task_t *task, isc_event_t *event) {
 
        LOCK_ZONE(zone);
        INSIST(zone != zone->raw);
-       ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+       RWLOCK(&zone->dblock, isc_rwlocktype_read);
        if (zone->db != NULL) {
                const dns_master_style_t *output_style;
 
@@ -2391,7 +2386,7 @@ zone_gotwritehandle(isc_task_t *task, isc_event_t *event) {
                dns_db_closeversion(zone->db, &version, ISC_FALSE);
        } else
                result = ISC_R_CANCELED;
-       ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+       RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
        UNLOCK_ZONE(zone);
        if (result != DNS_R_CONTINUE)
                goto fail;
@@ -3196,10 +3191,10 @@ resume_signingwithkey(dns_zone_t *zone) {
        isc_result_t result;
        dns_db_t *db = NULL;
 
-       ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+       RWLOCK(&zone->dblock, isc_rwlocktype_read);
        if (zone->db != NULL)
                dns_db_attach(zone->db, &db);
-       ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+       RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
        if (db == NULL)
                goto cleanup;
 
@@ -3269,10 +3264,10 @@ zone_addnsec3chain(dns_zone_t *zone, dns_rdata_nsec3param_t *nsec3param) {
        char flags[sizeof("INITIAL|REMOVE|CREATE|NONSEC|OPTOUT")];
        dns_db_t *db = NULL;
 
-       ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+       RWLOCK(&zone->dblock, isc_rwlocktype_read);
        if (zone->db != NULL)
                dns_db_attach(zone->db, &db);
-       ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+       RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
 
        if (db == NULL) {
                result = ISC_R_SUCCESS;
@@ -3448,10 +3443,10 @@ resume_addnsec3chain(dns_zone_t *zone) {
        if (zone->privatetype == 0)
                return;
 
-       ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+       RWLOCK(&zone->dblock, isc_rwlocktype_read);
        if (zone->db != NULL)
                dns_db_attach(zone->db, &db);
-       ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+       RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
        if (db == NULL)
                goto cleanup;
 
@@ -3547,10 +3542,10 @@ set_resigntime(dns_zone_t *zone) {
        dns_rdataset_init(&rdataset);
        dns_fixedname_init(&fixed);
 
-       ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+       RWLOCK(&zone->dblock, isc_rwlocktype_read);
        if (zone->db != NULL)
                dns_db_attach(zone->db, &db);
-       ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+       RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
        if (db == NULL) {
                isc_time_settoepoch(&zone->resigntime);
                return;
@@ -4724,15 +4719,15 @@ zone_postload(dns_zone_t *zone, dns_db_t *db, isc_time_t loadtime,
            DNS_ZONEKEY_OPTION(zone, DNS_ZONEKEY_MAINTAIN))
                zone->refreshkeytime = now;
 
-       ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_write);
+       RWLOCK(&zone->dblock, isc_rwlocktype_write);
        if (zone->db != NULL) {
                result = zone_replacedb(zone, db, ISC_FALSE);
-               ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_write);
+               RWUNLOCK(&zone->dblock, isc_rwlocktype_write);
                if (result != ISC_R_SUCCESS)
                        goto cleanup;
        } else {
                zone_attachdb(zone, db);
-               ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_write);
+               RWUNLOCK(&zone->dblock, isc_rwlocktype_write);
                DNS_ZONE_SETFLAG(zone,
                                 DNS_ZONEFLG_LOADED|
                                 DNS_ZONEFLG_NEEDSTARTUPNOTIFY);
@@ -5908,12 +5903,12 @@ dns_zone_getdb(dns_zone_t *zone, dns_db_t **dpb) {
 
        REQUIRE(DNS_ZONE_VALID(zone));
 
-       ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+       RWLOCK(&zone->dblock, isc_rwlocktype_read);
        if (zone->db == NULL)
                result = DNS_R_NOTLOADED;
        else
                dns_db_attach(zone->db, dpb);
-       ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+       RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
 
        return (result);
 }
@@ -5923,10 +5918,10 @@ dns_zone_setdb(dns_zone_t *zone, dns_db_t *db) {
        REQUIRE(DNS_ZONE_VALID(zone));
        REQUIRE(zone->type == dns_zone_staticstub);
 
-       ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_write);
+       RWLOCK(&zone->dblock, isc_rwlocktype_write);
        REQUIRE(zone->db == NULL);
        dns_db_attach(db, &zone->db);
-       ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_write);
+       RWUNLOCK(&zone->dblock, isc_rwlocktype_write);
 }
 
 /*
@@ -6422,9 +6417,9 @@ zone_resigninc(dns_zone_t *zone) {
                goto failure;
        }
 
-       ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+       RWLOCK(&zone->dblock, isc_rwlocktype_read);
        dns_db_attach(zone->db, &db);
-       ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+       RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
 
        result = dns_db_newversion(db, &version);
        if (result != ISC_R_SUCCESS) {
@@ -7426,7 +7421,7 @@ zone_nsec3chain(dns_zone_t *zone) {
                goto failure;
        }
 
-       ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+       RWLOCK(&zone->dblock, isc_rwlocktype_read);
        /*
         * This function is called when zone timer fires, after the latter gets
         * set by zone_addnsec3chain().  If the action triggering the call to
@@ -7439,7 +7434,7 @@ zone_nsec3chain(dns_zone_t *zone) {
        if (zone->db != NULL) {
                dns_db_attach(zone->db, &db);
        }
-       ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+       RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
        if (db == NULL) {
                return;
        }
@@ -7516,12 +7511,12 @@ zone_nsec3chain(dns_zone_t *zone) {
                LOCK_ZONE(zone);
                nextnsec3chain = ISC_LIST_NEXT(nsec3chain, link);
 
-               ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+               RWLOCK(&zone->dblock, isc_rwlocktype_read);
                if (nsec3chain->done || nsec3chain->db != zone->db) {
                        ISC_LIST_UNLINK(zone->nsec3chain, nsec3chain, link);
                        ISC_LIST_APPEND(cleanup, nsec3chain, link);
                }
-               ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+               RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
                UNLOCK_ZONE(zone);
                if (ISC_LIST_TAIL(cleanup) == nsec3chain)
                        goto next_addchain;
@@ -8317,10 +8312,10 @@ zone_sign(dns_zone_t *zone) {
                goto failure;
        }
 
-       ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+       RWLOCK(&zone->dblock, isc_rwlocktype_read);
        if (zone->db != NULL)
                dns_db_attach(zone->db, &db);
-       ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+       RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
        if (db == NULL) {
                result = ISC_R_FAILURE;
                goto failure;
@@ -8379,7 +8374,7 @@ zone_sign(dns_zone_t *zone) {
        while (signing != NULL && nodes-- > 0 && signatures > 0) {
                nextsigning = ISC_LIST_NEXT(signing, link);
 
-               ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+               RWLOCK(&zone->dblock, isc_rwlocktype_read);
                if (signing->done || signing->db != zone->db) {
                        /*
                         * The zone has been reloaded.  We will have
@@ -8388,10 +8383,10 @@ zone_sign(dns_zone_t *zone) {
                         */
                        ISC_LIST_UNLINK(zone->signing, signing, link);
                        ISC_LIST_APPEND(cleanup, signing, link);
-                       ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+                       RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
                        goto next_signing;
                }
-               ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+               RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
 
                if (signing->db != db)
                        goto next_signing;
@@ -9661,9 +9656,9 @@ zone_refreshkeys(dns_zone_t *zone) {
                return;
        }
 
-       ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+       RWLOCK(&zone->dblock, isc_rwlocktype_read);
        dns_db_attach(zone->db, &db);
-       ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+       RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
 
        dns_diff_init(zone->mctx, &diff);
 
@@ -10028,7 +10023,7 @@ dns_zone_markdirty(dns_zone_t *zone) {
                                goto again;
                        }
 
-                       ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+                       RWLOCK(&zone->dblock, isc_rwlocktype_read);
                        if (zone->db != NULL) {
                                result = zone_get_from_db(zone, zone->db, NULL,
                                                          &soacount, &serial,
@@ -10036,7 +10031,7 @@ dns_zone_markdirty(dns_zone_t *zone) {
                                                          NULL, NULL);
                        } else
                                result = DNS_R_NOTLOADED;
-                       ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+                       RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
                        if (result == ISC_R_SUCCESS && soacount > 0U)
                                zone_send_secureserial(zone, serial);
                }
@@ -10305,7 +10300,7 @@ dump_done(void *arg, isc_result_t result) {
                        isc_uint32_t sserial;
                        isc_result_t mresult;
 
-                       ZONEDB_LOCK(&secure->dblock, isc_rwlocktype_read);
+                       RWLOCK(&secure->dblock, isc_rwlocktype_read);
                        if (secure->db != NULL) {
                                mresult = dns_db_getsoaserial(zone->secure->db,
                                                              NULL, &sserial);
@@ -10313,7 +10308,7 @@ dump_done(void *arg, isc_result_t result) {
                                    isc_serial_lt(sserial, serial))
                                        serial = sserial;
                        }
-                       ZONEDB_UNLOCK(&secure->dblock, isc_rwlocktype_read);
+                       RWUNLOCK(&secure->dblock, isc_rwlocktype_read);
                }
                if (tresult == ISC_R_SUCCESS && zone->xfr == NULL) {
                        dns_db_t *zdb = NULL;
@@ -10377,10 +10372,10 @@ zone_dump(dns_zone_t *zone, isc_boolean_t compact) {
        ENTER;
 
  redo:
-       ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+       RWLOCK(&zone->dblock, isc_rwlocktype_read);
        if (zone->db != NULL)
                dns_db_attach(zone->db, &db);
-       ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+       RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
        LOCK_ZONE(zone);
        if (zone->masterfile != NULL) {
                masterfile = isc_mem_strdup(zone->mctx, zone->masterfile);
@@ -10470,10 +10465,10 @@ dumptostream(dns_zone_t *zone, FILE *fd, const dns_master_style_t *style,
 
        REQUIRE(DNS_ZONE_VALID(zone));
 
-       ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+       RWLOCK(&zone->dblock, isc_rwlocktype_read);
        if (zone->db != NULL)
                dns_db_attach(zone->db, &db);
-       ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+       RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
        if (db == NULL)
                return (DNS_R_NOTLOADED);
 
@@ -10565,9 +10560,9 @@ zone_unload(dns_zone_t *zone) {
                if (zone->dctx != NULL)
                        dns_dumpctx_cancel(zone->dctx);
        }
-       ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_write);
+       RWLOCK(&zone->dblock, isc_rwlocktype_write);
        zone_detachdb(zone);
-       ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_write);
+       RWUNLOCK(&zone->dblock, isc_rwlocktype_write);
        DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_LOADED);
        DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_NEEDDUMP);
 }
@@ -11119,10 +11114,10 @@ zone_notify(dns_zone_t *zone, isc_time_t *now) {
        /*
         * Get SOA RRset.
         */
-       ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+       RWLOCK(&zone->dblock, isc_rwlocktype_read);
        if (zone->db != NULL)
                dns_db_attach(zone->db, &zonedb);
-       ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+       RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
        if (zonedb == NULL)
                return;
        dns_db_currentversion(zonedb, &version);
@@ -11522,7 +11517,7 @@ stub_callback(isc_task_t *task, isc_event_t *event) {
         * Tidy up.
         */
        dns_db_closeversion(stub->db, &stub->version, ISC_TRUE);
-       ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_write);
+       RWLOCK(&zone->dblock, isc_rwlocktype_write);
        if (zone->db == NULL)
                zone_attachdb(zone, stub->db);
        result = zone_get_from_db(zone, zone->db, NULL, &soacount, NULL,
@@ -11535,7 +11530,7 @@ stub_callback(isc_task_t *task, isc_event_t *event) {
                                     DNS_MAX_EXPIRE);
                DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_HAVETIMERS);
        }
-       ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_write);
+       RWUNLOCK(&zone->dblock, isc_rwlocktype_write);
        dns_db_detach(&stub->db);
 
        dns_message_destroy(&msg);
@@ -12469,12 +12464,12 @@ ns_query(dns_zone_t *zone, dns_rdataset_t *soardataset, dns_stub_t *stub) {
                 * new one and attach it to the zone once we have the NS
                 * RRset and glue.
                 */
-               ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+               RWLOCK(&zone->dblock, isc_rwlocktype_read);
                if (zone->db != NULL) {
                        dns_db_attach(zone->db, &stub->db);
-                       ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+                       RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
                } else {
-                       ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+                       RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
 
                        INSIST(zone->db_argc >= 1);
                        result = dns_db_create(zone->mctx, zone->db_argv[0],
@@ -13009,10 +13004,10 @@ notify_createmessage(dns_zone_t *zone, unsigned int flags,
        if (result != ISC_R_SUCCESS)
                goto soa_cleanup;
 
-       ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+       RWLOCK(&zone->dblock, isc_rwlocktype_read);
        INSIST(zone->db != NULL); /* XXXJT: is this assumption correct? */
        dns_db_attach(zone->db, &zonedb);
-       ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+       RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
 
        dns_name_init(tempname, NULL);
        dns_name_clone(&zone->origin, tempname);
@@ -13808,10 +13803,10 @@ dns_zone_settask(dns_zone_t *zone, isc_task_t *task) {
        if (zone->task != NULL)
                isc_task_detach(&zone->task);
        isc_task_attach(task, &zone->task);
-       ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+       RWLOCK(&zone->dblock, isc_rwlocktype_read);
        if (zone->db != NULL)
                dns_db_settask(zone->db, zone->task);
-       ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+       RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
        UNLOCK_ZONE(zone);
 }
 
@@ -14143,12 +14138,12 @@ receive_secure_serial(isc_task_t *task, isc_event_t *event) {
                 * zone->db may be NULL, if the load from disk failed.
                 */
                result = ISC_R_SUCCESS;
-               ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+               RWLOCK(&zone->dblock, isc_rwlocktype_read);
                if (zone->db != NULL)
                        dns_db_attach(zone->db, &zone->rss_db);
                else
                        result = ISC_R_FAILURE;
-               ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+               RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
 
                if (result == ISC_R_SUCCESS && zone->raw != NULL)
                        dns_zone_attach(zone->raw, &zone->rss_raw);
@@ -14648,7 +14643,7 @@ receive_secure_db(isc_task_t *task, isc_event_t *event) {
        }
 
        TIME_NOW(&loadtime);
-       ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+       RWLOCK(&zone->dblock, isc_rwlocktype_read);
        if (zone->db != NULL) {
                result = dns_db_getsoaserial(zone->db, NULL, &oldserial);
                if (result == ISC_R_SUCCESS)
@@ -14660,11 +14655,11 @@ receive_secure_db(isc_task_t *task, isc_event_t *event) {
                 */
                result = save_nsec3param(zone, &nsec3list);
                if (result != ISC_R_SUCCESS) {
-                       ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+                       RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
                        goto failure;
                }
        }
-       ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+       RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
 
        result = dns_db_create(zone->mctx, zone->db_argv[0],
                               &zone->origin, dns_dbtype_zone, zone->rdclass,
@@ -14826,9 +14821,9 @@ dns_zone_replacedb(dns_zone_t *zone, dns_db_t *db, isc_boolean_t dump) {
                        goto again;
                }
        }
-       ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_write);
+       RWLOCK(&zone->dblock, isc_rwlocktype_write);
        result = zone_replacedb(zone, db, dump);
-       ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_write);
+       RWUNLOCK(&zone->dblock, isc_rwlocktype_write);
        if (secure != NULL)
                UNLOCK_ZONE(secure);
        UNLOCK_ZONE(zone);
@@ -15070,9 +15065,9 @@ zone_xfrdone(dns_zone_t *zone, isc_result_t result) {
                /*
                 * Has the zone expired underneath us?
                 */
-               ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+               RWLOCK(&zone->dblock, isc_rwlocktype_read);
                if (zone->db == NULL) {
-                       ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+                       RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
                        goto same_master;
                }
 
@@ -15086,7 +15081,7 @@ zone_xfrdone(dns_zone_t *zone, isc_result_t result) {
                result = zone_get_from_db(zone, zone->db, &nscount,
                                          &soacount, &serial, &refresh,
                                          &retry, &expire, &minimum, NULL);
-               ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+               RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
                if (result == ISC_R_SUCCESS) {
                        if (soacount != 1)
                                dns_zone_log(zone, ISC_LOG_ERROR,
@@ -15501,9 +15496,9 @@ got_transfer_quota(isc_task_t *task, isc_event_t *event) {
        /*
         * Decide whether we should request IXFR or AXFR.
         */
-       ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+       RWLOCK(&zone->dblock, isc_rwlocktype_read);
        loaded = ISC_TF(zone->db != NULL);
-       ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+       RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
 
        if (!loaded) {
                dns_zone_log(zone, ISC_LOG_DEBUG(1),
@@ -17323,10 +17318,10 @@ zone_signwithkey(dns_zone_t *zone, dns_secalg_t algorithm, isc_uint16_t keyid,
 
        TIME_NOW(&now);
 
-       ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+       RWLOCK(&zone->dblock, isc_rwlocktype_read);
        if (zone->db != NULL)
                dns_db_attach(zone->db, &db);
-       ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+       RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
 
        if (db == NULL) {
                result = ISC_R_NOTFOUND;
@@ -18532,10 +18527,10 @@ keydone(isc_task_t *task, isc_event_t *event) {
        dns_rdataset_init(&rdataset);
        dns_diff_init(zone->mctx, &diff);
 
-       ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+       RWLOCK(&zone->dblock, isc_rwlocktype_read);
        if (zone->db != NULL)
                dns_db_attach(zone->db, &db);
-       ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+       RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
        if (db == NULL)
                goto failure;
 
@@ -18737,17 +18732,17 @@ setnsec3param(isc_task_t *task, isc_event_t *event) {
        dns_rdataset_init(&nrdataset);
        dns_diff_init(zone->mctx, &diff);
 
-       ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+       RWLOCK(&zone->dblock, isc_rwlocktype_read);
        if (zone->db != NULL)
                dns_db_attach(zone->db, &db);
-       ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+       RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
        if (db == NULL)
                goto failure;
 
        dns_db_currentversion(db, &oldver);
        result = dns_db_newversion(db, &newver);
        if (result != ISC_R_SUCCESS) {
-               ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+               RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
                dns_zone_log(zone, ISC_LOG_ERROR,
                             "setnsec3param:dns_db_newversion -> %s",
                             dns_result_totext(result));
@@ -19090,10 +19085,10 @@ setserial(isc_task_t *task, isc_event_t *event) {
 
        dns_diff_init(zone->mctx, &diff);
 
-       ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+       RWLOCK(&zone->dblock, isc_rwlocktype_read);
        if (zone->db != NULL)
                dns_db_attach(zone->db, &db);
-       ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+       RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
        if (db == NULL)
                goto failure;