From 6a005bc6e8f629d80dd6e36cd391ada7c916097f Mon Sep 17 00:00:00 2001 From: Evan Hunt Date: Tue, 5 Mar 2024 14:28:43 -0800 Subject: [PATCH] rename dns_rbtdb to dns_qpdb this commit renames all variables and macros with the string "rbtdb" or "RBDTB" to "qpdb" or "QPDB". --- lib/dns/db.c | 2 +- lib/dns/include/dns/types.h | 2 + lib/dns/qp-cachedb.c | 458 +++--- lib/dns/qp-zonedb.c | 509 +++--- lib/dns/qpdb.c | 1894 +++++++++++------------ lib/dns/qpdb_p.h | 217 ++- lib/dns/rbtdb.c | 6 +- lib/dns/rbtdb_p.h | 2 +- tests/dns/Makefile.am | 2 +- tests/dns/{rbtdb_test.c => qpdb_test.c} | 26 +- 10 files changed, 1545 insertions(+), 1573 deletions(-) rename tests/dns/{rbtdb_test.c => qpdb_test.c} (95%) diff --git a/lib/dns/db.c b/lib/dns/db.c index 691b9cb259..f974e3c7da 100644 --- a/lib/dns/db.c +++ b/lib/dns/db.c @@ -78,7 +78,7 @@ initialize(void) { rbtimp = (dns_dbimplementation_t){ .name = "rbt", - .create = dns__rbtdb_create, + .create = dns__qpdb_create, .link = ISC_LINK_INITIALIZER, }; diff --git a/lib/dns/include/dns/types.h b/lib/dns/include/dns/types.h index 6f72afd635..c09aba40ed 100644 --- a/lib/dns/include/dns/types.h +++ b/lib/dns/include/dns/types.h @@ -130,6 +130,8 @@ typedef struct dns_slabheader_proof dns_slabheader_proof_t; typedef struct dns_rbt dns_rbt_t; typedef struct dns_rbtdb dns_rbtdb_t; typedef struct dns_rbtdb_version dns_rbtdb_version_t; +typedef struct dns_qpdb dns_qpdb_t; +typedef struct dns_qpdb_version dns_qpdb_version_t; typedef struct dns_rbtnode dns_rbtnode_t; typedef ISC_LIST(dns_rbtnode_t) dns_rbtnodelist_t; typedef uint16_t dns_rcode_t; diff --git a/lib/dns/qp-cachedb.c b/lib/dns/qp-cachedb.c index f612aa1c22..a351df0f99 100644 --- a/lib/dns/qp-cachedb.c +++ b/lib/dns/qp-cachedb.c @@ -77,14 +77,14 @@ * Updating LRU requires write locking, so we don't do it every time the * record is touched - only after some time passes. */ -#ifndef DNS_RBTDB_LIMITLRUUPDATE -#define DNS_RBTDB_LIMITLRUUPDATE 1 +#ifndef DNS_QPDB_LIMITLRUUPDATE +#define DNS_QPDB_LIMITLRUUPDATE 1 #endif /*% Time after which we update LRU for glue records, 5 minutes */ -#define DNS_RBTDB_LRUUPDATE_GLUE 300 +#define DNS_QPDB_LRUUPDATE_GLUE 300 /*% Time after which we update LRU for all other records, 10 minutes */ -#define DNS_RBTDB_LRUUPDATE_REGULAR 600 +#define DNS_QPDB_LRUUPDATE_REGULAR 600 #define EXISTS(header) \ ((atomic_load_acquire(&(header)->attributes) & \ @@ -111,13 +111,13 @@ ((atomic_load_acquire(&(header)->attributes) & \ DNS_SLABHEADERATTR_STATCOUNT) != 0) -#define STALE_TTL(header, rbtdb) \ - (NXDOMAIN(header) ? 0 : rbtdb->common.serve_stale_ttl) +#define STALE_TTL(header, qpdb) \ + (NXDOMAIN(header) ? 0 : qpdb->common.serve_stale_ttl) #define ACTIVE(header, now) \ (((header)->ttl > (now)) || ((header)->ttl == (now) && ZEROTTL(header))) -#define KEEPSTALE(rbtdb) ((rbtdb)->common.serve_stale_ttl > 0) +#define KEEPSTALE(qpdb) ((qpdb)->common.serve_stale_ttl > 0) /*% * Routines for LRU-based cache management. @@ -129,7 +129,7 @@ * expected to return true for almost all cases. When used with threads, * however, this may cause a non-negligible performance penalty because a * writer lock will have to be acquired before updating the list. - * If DNS_RBTDB_LIMITLRUUPDATE is defined to be non 0 at compilation time, this + * If DNS_QPDB_LIMITLRUUPDATE is defined to be non 0 at compilation time, this * function returns true if the entry has not been updated for some period of * time. We differentiate the NS or glue address case and the others since * experiments have shown that the former tends to be accessed relatively @@ -148,29 +148,29 @@ need_headerupdate(dns_slabheader_t *header, isc_stdtime_t now) { return (false); } -#if DNS_RBTDB_LIMITLRUUPDATE +#if DNS_QPDB_LIMITLRUUPDATE if (header->type == dns_rdatatype_ns || (header->trust == dns_trust_glue && (header->type == dns_rdatatype_a || header->type == dns_rdatatype_aaaa))) { /* - * Glue records are updated if at least DNS_RBTDB_LRUUPDATE_GLUE + * Glue records are updated if at least DNS_QPDB_LRUUPDATE_GLUE * seconds have passed since the previous update time. */ - return (header->last_used + DNS_RBTDB_LRUUPDATE_GLUE <= now); + return (header->last_used + DNS_QPDB_LRUUPDATE_GLUE <= now); } /* - * Other records are updated if DNS_RBTDB_LRUUPDATE_REGULAR seconds + * Other records are updated if DNS_QPDB_LRUUPDATE_REGULAR seconds * have passed. */ - return (header->last_used + DNS_RBTDB_LRUUPDATE_REGULAR <= now); + return (header->last_used + DNS_QPDB_LRUUPDATE_REGULAR <= now); #else UNUSED(now); return (true); -#endif /* if DNS_RBTDB_LIMITLRUUPDATE */ +#endif /* if DNS_QPDB_LIMITLRUUPDATE */ } /*% @@ -182,16 +182,16 @@ need_headerupdate(dns_slabheader_t *header, isc_stdtime_t now) { * Note that the we do NOT touch the heap here, as the TTL has not changed. */ static void -update_header(dns_rbtdb_t *rbtdb, dns_slabheader_t *header, isc_stdtime_t now) { - INSIST(IS_CACHE(rbtdb)); +update_header(dns_qpdb_t *qpdb, dns_slabheader_t *header, isc_stdtime_t now) { + INSIST(IS_CACHE(qpdb)); /* To be checked: can we really assume this? XXXMLG */ INSIST(ISC_LINK_LINKED(header, link)); - ISC_LIST_UNLINK(rbtdb->lru[RBTDB_HEADERNODE(header)->locknum], header, + ISC_LIST_UNLINK(qpdb->lru[QPDB_HEADERNODE(header)->locknum], header, link); header->last_used = now; - ISC_LIST_PREPEND(rbtdb->lru[RBTDB_HEADERNODE(header)->locknum], header, + ISC_LIST_PREPEND(qpdb->lru[QPDB_HEADERNODE(header)->locknum], header, link); } @@ -222,16 +222,16 @@ update_header(dns_rbtdb_t *rbtdb, dns_slabheader_t *header, isc_stdtime_t now) { */ static void -update_cachestats(dns_rbtdb_t *rbtdb, isc_result_t result) { - INSIST(IS_CACHE(rbtdb)); +update_cachestats(dns_qpdb_t *qpdb, isc_result_t result) { + INSIST(IS_CACHE(qpdb)); - if (rbtdb->cachestats == NULL) { + if (qpdb->cachestats == NULL) { return; } switch (result) { case DNS_R_COVERINGNSEC: - isc_stats_increment(rbtdb->cachestats, + isc_stats_increment(qpdb->cachestats, dns_cachestatscounter_coveringnsec); FALLTHROUGH; case ISC_R_SUCCESS: @@ -240,11 +240,11 @@ update_cachestats(dns_rbtdb_t *rbtdb, isc_result_t result) { case DNS_R_DELEGATION: case DNS_R_NCACHENXDOMAIN: case DNS_R_NCACHENXRRSET: - isc_stats_increment(rbtdb->cachestats, + isc_stats_increment(qpdb->cachestats, dns_cachestatscounter_hits); break; default: - isc_stats_increment(rbtdb->cachestats, + isc_stats_increment(qpdb->cachestats, dns_cachestatscounter_misses); } } @@ -261,7 +261,7 @@ clean_stale_headers(dns_slabheader_t *top) { } static isc_result_t -setup_delegation(rbtdb_search_t *search, dns_dbnode_t **nodep, +setup_delegation(qpdb_search_t *search, dns_dbnode_t **nodep, dns_name_t *foundname, dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset DNS__DB_FLARG) { dns_name_t *zcname = NULL; @@ -301,19 +301,18 @@ setup_delegation(rbtdb_search_t *search, dns_dbnode_t **nodep, } if (rdataset != NULL) { isc_rwlocktype_t nlocktype = isc_rwlocktype_none; - NODE_RDLOCK(&(search->rbtdb->node_locks[node->locknum].lock), + NODE_RDLOCK(&(search->qpdb->node_locks[node->locknum].lock), &nlocktype); - dns__rbtdb_bindrdataset(search->rbtdb, node, - search->zonecut_header, search->now, - isc_rwlocktype_read, - rdataset DNS__DB_FLARG_PASS); + dns__qpdb_bindrdataset( + search->qpdb, node, search->zonecut_header, search->now, + isc_rwlocktype_read, rdataset DNS__DB_FLARG_PASS); if (sigrdataset != NULL && search->zonecut_sigheader != NULL) { - dns__rbtdb_bindrdataset( - search->rbtdb, node, search->zonecut_sigheader, - search->now, isc_rwlocktype_read, - sigrdataset DNS__DB_FLARG_PASS); + dns__qpdb_bindrdataset(search->qpdb, node, + search->zonecut_sigheader, + search->now, isc_rwlocktype_read, + sigrdataset DNS__DB_FLARG_PASS); } - NODE_UNLOCK(&(search->rbtdb->node_locks[node->locknum].lock), + NODE_UNLOCK(&(search->qpdb->node_locks[node->locknum].lock), &nlocktype); } @@ -326,10 +325,9 @@ setup_delegation(rbtdb_search_t *search, dns_dbnode_t **nodep, static bool check_stale_header(dns_rbtnode_t *node, dns_slabheader_t *header, isc_rwlocktype_t *nlocktypep, isc_rwlock_t *lock, - rbtdb_search_t *search, dns_slabheader_t **header_prev) { + qpdb_search_t *search, dns_slabheader_t **header_prev) { if (!ACTIVE(header, search->now)) { - dns_ttl_t stale = header->ttl + - STALE_TTL(header, search->rbtdb); + dns_ttl_t stale = header->ttl + STALE_TTL(header, search->qpdb); /* * If this data is in the stale window keep it and if * DNS_DBFIND_STALEOK is not set we tell the caller to @@ -338,10 +336,10 @@ check_stale_header(dns_rbtnode_t *node, dns_slabheader_t *header, */ DNS_SLABHEADER_CLRATTR(header, DNS_SLABHEADERATTR_STALE_WINDOW); - if (!ZEROTTL(header) && KEEPSTALE(search->rbtdb) && + if (!ZEROTTL(header) && KEEPSTALE(search->qpdb) && stale > search->now) { - dns__rbtdb_mark(header, DNS_SLABHEADERATTR_STALE); + dns__qpdb_mark(header, DNS_SLABHEADERATTR_STALE); *header_prev = header; /* * If DNS_DBFIND_STALESTART is set then it means we @@ -358,7 +356,7 @@ check_stale_header(dns_rbtnode_t *node, dns_slabheader_t *header, search->now < (atomic_load_acquire( &header->last_refresh_fail_ts) + - search->rbtdb->serve_stale_refresh)) + search->qpdb->serve_stale_refresh)) { /* * If we are within interval between last @@ -388,7 +386,7 @@ check_stale_header(dns_rbtnode_t *node, dns_slabheader_t *header, * it as ancient, and the node as dirty, so it will get * cleaned up later. */ - if ((header->ttl < search->now - RBTDB_VIRTUAL) && + if ((header->ttl < search->now - QPDB_VIRTUAL) && (*nlocktypep == isc_rwlocktype_write || NODE_TRYUPGRADE(lock, nlocktypep) == ISC_R_SUCCESS)) { @@ -405,7 +403,7 @@ check_stale_header(dns_rbtnode_t *node, dns_slabheader_t *header, /* * header->down can be non-NULL if the * refcount has just decremented to 0 - * but dns__rbtdb_decref() has not + * but dns__qpdb_decref() has not * performed clean_cache_node(), in * which case we need to purge the stale * headers first. @@ -418,9 +416,9 @@ check_stale_header(dns_rbtnode_t *node, dns_slabheader_t *header, } dns_slabheader_destroy(&header); } else { - dns__rbtdb_mark(header, - DNS_SLABHEADERATTR_ANCIENT); - RBTDB_HEADERNODE(header)->dirty = 1; + dns__qpdb_mark(header, + DNS_SLABHEADERATTR_ANCIENT); + QPDB_HEADERNODE(header)->dirty = 1; *header_prev = header; } } else { @@ -434,7 +432,7 @@ check_stale_header(dns_rbtnode_t *node, dns_slabheader_t *header, static isc_result_t cache_zonecut_callback(dns_rbtnode_t *node, dns_name_t *name, void *arg DNS__DB_FLARG) { - rbtdb_search_t *search = arg; + qpdb_search_t *search = arg; dns_slabheader_t *header = NULL; dns_slabheader_t *header_prev = NULL, *header_next = NULL; dns_slabheader_t *dname_header = NULL, *sigdname_header = NULL; @@ -449,7 +447,7 @@ cache_zonecut_callback(dns_rbtnode_t *node, dns_name_t *name, */ UNUSED(name); - lock = &(search->rbtdb->node_locks[node->locknum].lock); + lock = &(search->qpdb->node_locks[node->locknum].lock); NODE_RDLOCK(lock, &nlocktype); /* @@ -484,8 +482,8 @@ cache_zonecut_callback(dns_rbtnode_t *node, dns_name_t *name, * We increment the reference count on node to ensure that * search->zonecut_header will still be valid later. */ - dns__rbtdb_newref(search->rbtdb, node, - nlocktype DNS__DB_FLARG_PASS); + dns__qpdb_newref(search->qpdb, node, + nlocktype DNS__DB_FLARG_PASS); search->zonecut = node; search->zonecut_header = dname_header; search->zonecut_sigheader = sigdname_header; @@ -501,28 +499,28 @@ cache_zonecut_callback(dns_rbtnode_t *node, dns_name_t *name, } static isc_result_t -find_deepest_zonecut(rbtdb_search_t *search, dns_rbtnode_t *node, +find_deepest_zonecut(qpdb_search_t *search, dns_rbtnode_t *node, dns_dbnode_t **nodep, dns_name_t *foundname, dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset DNS__DB_FLARG) { unsigned int i; isc_result_t result = ISC_R_NOTFOUND; dns_name_t name; - dns_rbtdb_t *rbtdb = NULL; + dns_qpdb_t *qpdb = NULL; bool done; /* * Caller must be holding the tree lock. */ - rbtdb = search->rbtdb; + qpdb = search->qpdb; i = search->chain.level_matches; done = false; do { dns_slabheader_t *header = NULL; dns_slabheader_t *header_prev = NULL, *header_next = NULL; dns_slabheader_t *found = NULL, *foundsig = NULL; - isc_rwlock_t *lock = &rbtdb->node_locks[node->locknum].lock; + isc_rwlock_t *lock = &qpdb->node_locks[node->locknum].lock; isc_rwlocktype_t nlocktype = isc_rwlocktype_none; NODE_RDLOCK(lock, &nlocktype); @@ -592,16 +590,16 @@ find_deepest_zonecut(rbtdb_search_t *search, dns_rbtnode_t *node, } result = DNS_R_DELEGATION; if (nodep != NULL) { - dns__rbtdb_newref(search->rbtdb, node, - nlocktype DNS__DB_FLARG_PASS); + dns__qpdb_newref(search->qpdb, node, + nlocktype DNS__DB_FLARG_PASS); *nodep = node; } - dns__rbtdb_bindrdataset(search->rbtdb, node, found, - search->now, nlocktype, - rdataset DNS__DB_FLARG_PASS); + dns__qpdb_bindrdataset(search->qpdb, node, found, + search->now, nlocktype, + rdataset DNS__DB_FLARG_PASS); if (foundsig != NULL) { - dns__rbtdb_bindrdataset( - search->rbtdb, node, foundsig, + dns__qpdb_bindrdataset( + search->qpdb, node, foundsig, search->now, nlocktype, sigrdataset DNS__DB_FLARG_PASS); } @@ -614,13 +612,13 @@ find_deepest_zonecut(rbtdb_search_t *search, dns_rbtnode_t *node, POST(nlocktype); } if (need_headerupdate(found, search->now)) { - update_header(search->rbtdb, found, + update_header(search->qpdb, found, search->now); } if (foundsig != NULL && need_headerupdate(foundsig, search->now)) { - update_header(search->rbtdb, foundsig, + update_header(search->qpdb, foundsig, search->now); } } @@ -648,7 +646,7 @@ find_deepest_zonecut(rbtdb_search_t *search, dns_rbtnode_t *node, * Otherwise, return ISC_R_NOTFOUND. */ static isc_result_t -find_coveringnsec(rbtdb_search_t *search, const dns_name_t *name, +find_coveringnsec(qpdb_search_t *search, const dns_name_t *name, dns_dbnode_t **nodep, isc_stdtime_t now, dns_name_t *foundname, dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset DNS__DB_FLARG) { @@ -670,7 +668,7 @@ find_coveringnsec(rbtdb_search_t *search, const dns_name_t *name, */ dns_rbtnodechain_init(&chain); target = dns_fixedname_initname(&ftarget); - result = dns_rbt_findnode(search->rbtdb->nsec, name, target, &node, + result = dns_rbt_findnode(search->qpdb->nsec, name, target, &node, &chain, DNS_RBTFIND_EMPTYDATA, NULL, NULL); if (result != DNS_R_PARTIALMATCH) { dns_rbtnodechain_reset(&chain); @@ -703,13 +701,13 @@ find_coveringnsec(rbtdb_search_t *search, const dns_name_t *name, * Lookup the predecessor in the main tree. */ node = NULL; - result = dns_rbt_findnode(search->rbtdb->tree, target, fname, &node, + result = dns_rbt_findnode(search->qpdb->tree, target, fname, &node, NULL, DNS_RBTFIND_EMPTYDATA, NULL, NULL); if (result != ISC_R_SUCCESS) { return (ISC_R_NOTFOUND); } - lock = &(search->rbtdb->node_locks[node->locknum].lock); + lock = &(search->qpdb->node_locks[node->locknum].lock); NODE_RDLOCK(lock, &nlocktype); for (header = node->data; header != NULL; header = header_next) { header_next = header->next; @@ -737,15 +735,15 @@ find_coveringnsec(rbtdb_search_t *search, const dns_name_t *name, header_prev = header; } if (found != NULL) { - dns__rbtdb_bindrdataset(search->rbtdb, node, found, now, - nlocktype, rdataset DNS__DB_FLARG_PASS); + dns__qpdb_bindrdataset(search->qpdb, node, found, now, + nlocktype, rdataset DNS__DB_FLARG_PASS); if (foundsig != NULL) { - dns__rbtdb_bindrdataset(search->rbtdb, node, foundsig, - now, nlocktype, - sigrdataset DNS__DB_FLARG_PASS); + dns__qpdb_bindrdataset(search->qpdb, node, foundsig, + now, nlocktype, + sigrdataset DNS__DB_FLARG_PASS); } - dns__rbtdb_newref(search->rbtdb, node, - nlocktype DNS__DB_FLARG_PASS); + dns__qpdb_newref(search->qpdb, node, + nlocktype DNS__DB_FLARG_PASS); dns_name_copy(fname, foundname); @@ -766,7 +764,7 @@ cache_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, dns_rdataset_t *sigrdataset DNS__DB_FLARG) { dns_rbtnode_t *node = NULL; isc_result_t result; - rbtdb_search_t search; + qpdb_search_t search; bool cname_ok = true; bool found_noqname = false; bool all_negative = true; @@ -784,15 +782,15 @@ cache_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, UNUSED(version); - REQUIRE(VALID_RBTDB((dns_rbtdb_t *)db)); + REQUIRE(VALID_QPDB((dns_qpdb_t *)db)); REQUIRE(version == NULL); if (now == 0) { now = isc_stdtime_now(); } - search = (rbtdb_search_t){ - .rbtdb = (dns_rbtdb_t *)db, + search = (qpdb_search_t){ + .qpdb = (dns_qpdb_t *)db, .serial = 1, .options = options, .now = now, @@ -800,14 +798,14 @@ cache_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, dns_fixedname_init(&search.zonecut_name); dns_rbtnodechain_init(&search.chain); - TREE_RDLOCK(&search.rbtdb->tree_lock, &tlocktype); + TREE_RDLOCK(&search.qpdb->tree_lock, &tlocktype); /* * Search down from the root of the tree. If, while going down, we * encounter a callback node, cache_zonecut_callback() will search the * rdatasets at the zone cut for a DNAME rdataset. */ - result = dns_rbt_findnode(search.rbtdb->tree, name, foundname, &node, + result = dns_rbt_findnode(search.qpdb->tree, name, foundname, &node, &search.chain, DNS_RBTFIND_EMPTYDATA, cache_zonecut_callback, &search); @@ -858,7 +856,7 @@ cache_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, * We now go looking for rdata... */ - lock = &(search.rbtdb->node_locks[node->locknum].lock); + lock = &(search.qpdb->node_locks[node->locknum].lock); NODE_RDLOCK(lock, &nlocktype); /* @@ -1010,19 +1008,19 @@ cache_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, nsecheader != NULL) { if (nodep != NULL) { - dns__rbtdb_newref(search.rbtdb, node, - nlocktype DNS__DB_FLARG_PASS); + dns__qpdb_newref(search.qpdb, node, + nlocktype DNS__DB_FLARG_PASS); *nodep = node; } - dns__rbtdb_bindrdataset(search.rbtdb, node, nsecheader, - search.now, nlocktype, - rdataset DNS__DB_FLARG_PASS); + dns__qpdb_bindrdataset(search.qpdb, node, nsecheader, + search.now, nlocktype, + rdataset DNS__DB_FLARG_PASS); if (need_headerupdate(nsecheader, search.now)) { update = nsecheader; } if (nsecsig != NULL) { - dns__rbtdb_bindrdataset( - search.rbtdb, node, nsecsig, search.now, + dns__qpdb_bindrdataset( + search.qpdb, node, nsecsig, search.now, nlocktype, sigrdataset DNS__DB_FLARG_PASS); if (need_headerupdate(nsecsig, search.now)) { @@ -1055,19 +1053,19 @@ cache_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, */ if (nsheader != NULL) { if (nodep != NULL) { - dns__rbtdb_newref(search.rbtdb, node, - nlocktype DNS__DB_FLARG_PASS); + dns__qpdb_newref(search.qpdb, node, + nlocktype DNS__DB_FLARG_PASS); *nodep = node; } - dns__rbtdb_bindrdataset(search.rbtdb, node, nsheader, - search.now, nlocktype, - rdataset DNS__DB_FLARG_PASS); + dns__qpdb_bindrdataset(search.qpdb, node, nsheader, + search.now, nlocktype, + rdataset DNS__DB_FLARG_PASS); if (need_headerupdate(nsheader, search.now)) { update = nsheader; } if (nssig != NULL) { - dns__rbtdb_bindrdataset( - search.rbtdb, node, nssig, search.now, + dns__qpdb_bindrdataset( + search.qpdb, node, nssig, search.now, nlocktype, sigrdataset DNS__DB_FLARG_PASS); if (need_headerupdate(nssig, search.now)) { @@ -1090,8 +1088,8 @@ cache_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, */ if (nodep != NULL) { - dns__rbtdb_newref(search.rbtdb, node, - nlocktype DNS__DB_FLARG_PASS); + dns__qpdb_newref(search.qpdb, node, + nlocktype DNS__DB_FLARG_PASS); *nodep = node; } @@ -1123,15 +1121,15 @@ cache_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, if (type != dns_rdatatype_any || result == DNS_R_NCACHENXDOMAIN || result == DNS_R_NCACHENXRRSET) { - dns__rbtdb_bindrdataset(search.rbtdb, node, found, search.now, - nlocktype, rdataset DNS__DB_FLARG_PASS); + dns__qpdb_bindrdataset(search.qpdb, node, found, search.now, + nlocktype, rdataset DNS__DB_FLARG_PASS); if (need_headerupdate(found, search.now)) { update = found; } if (!NEGATIVE(found) && foundsig != NULL) { - dns__rbtdb_bindrdataset(search.rbtdb, node, foundsig, - search.now, nlocktype, - sigrdataset DNS__DB_FLARG_PASS); + dns__qpdb_bindrdataset(search.qpdb, node, foundsig, + search.now, nlocktype, + sigrdataset DNS__DB_FLARG_PASS); if (need_headerupdate(foundsig, search.now)) { updatesig = foundsig; } @@ -1146,16 +1144,16 @@ node_exit: POST(nlocktype); } if (update != NULL && need_headerupdate(update, search.now)) { - update_header(search.rbtdb, update, search.now); + update_header(search.qpdb, update, search.now); } if (updatesig != NULL && need_headerupdate(updatesig, search.now)) { - update_header(search.rbtdb, updatesig, search.now); + update_header(search.qpdb, updatesig, search.now); } NODE_UNLOCK(lock, &nlocktype); tree_exit: - TREE_UNLOCK(&search.rbtdb->tree_lock, &tlocktype); + TREE_UNLOCK(&search.qpdb->tree_lock, &tlocktype); /* * If we found a zonecut but aren't going to use it, we have to @@ -1164,18 +1162,18 @@ tree_exit: if (search.need_cleanup) { node = search.zonecut; INSIST(node != NULL); - lock = &(search.rbtdb->node_locks[node->locknum].lock); + lock = &(search.qpdb->node_locks[node->locknum].lock); NODE_RDLOCK(lock, &nlocktype); - dns__rbtdb_decref(search.rbtdb, node, 0, &nlocktype, &tlocktype, - true, false DNS__DB_FLARG_PASS); + dns__qpdb_decref(search.qpdb, node, 0, &nlocktype, &tlocktype, + true, false DNS__DB_FLARG_PASS); NODE_UNLOCK(lock, &nlocktype); INSIST(tlocktype == isc_rwlocktype_none); } dns_rbtnodechain_reset(&search.chain); - update_cachestats(search.rbtdb, result); + update_cachestats(search.qpdb, result); return (result); } @@ -1188,7 +1186,7 @@ cache_findzonecut(dns_db_t *db, const dns_name_t *name, unsigned int options, dns_rbtnode_t *node = NULL; isc_rwlock_t *lock = NULL; isc_result_t result; - rbtdb_search_t search; + qpdb_search_t search; dns_slabheader_t *header = NULL; dns_slabheader_t *header_prev = NULL, *header_next = NULL; dns_slabheader_t *found = NULL, *foundsig = NULL; @@ -1197,14 +1195,14 @@ cache_findzonecut(dns_db_t *db, const dns_name_t *name, unsigned int options, isc_rwlocktype_t nlocktype = isc_rwlocktype_none; bool dcnull = (dcname == NULL); - REQUIRE(VALID_RBTDB((dns_rbtdb_t *)db)); + REQUIRE(VALID_QPDB((dns_qpdb_t *)db)); if (now == 0) { now = isc_stdtime_now(); } - search = (rbtdb_search_t){ - .rbtdb = (dns_rbtdb_t *)db, + search = (qpdb_search_t){ + .qpdb = (dns_qpdb_t *)db, .serial = 1, .options = options, .now = now, @@ -1220,12 +1218,12 @@ cache_findzonecut(dns_db_t *db, const dns_name_t *name, unsigned int options, rbtoptions |= DNS_RBTFIND_NOEXACT; } - TREE_RDLOCK(&search.rbtdb->tree_lock, &tlocktype); + TREE_RDLOCK(&search.qpdb->tree_lock, &tlocktype); /* * Search down from the root of the tree. */ - result = dns_rbt_findnode(search.rbtdb->tree, name, dcname, &node, + result = dns_rbt_findnode(search.qpdb->tree, name, dcname, &node, &search.chain, rbtoptions, NULL, &search); if (result == DNS_R_PARTIALMATCH) { @@ -1243,7 +1241,7 @@ cache_findzonecut(dns_db_t *db, const dns_name_t *name, unsigned int options, * We now go looking for an NS rdataset at the node. */ - lock = &(search.rbtdb->node_locks[node->locknum].lock); + lock = &(search.qpdb->node_locks[node->locknum].lock); NODE_RDLOCK(lock, &nlocktype); for (header = node->data; header != NULL; header = header_next) { @@ -1306,17 +1304,17 @@ cache_findzonecut(dns_db_t *db, const dns_name_t *name, unsigned int options, } if (nodep != NULL) { - dns__rbtdb_newref(search.rbtdb, node, - nlocktype DNS__DB_FLARG_PASS); + dns__qpdb_newref(search.qpdb, node, + nlocktype DNS__DB_FLARG_PASS); *nodep = node; } - dns__rbtdb_bindrdataset(search.rbtdb, node, found, search.now, - nlocktype, rdataset DNS__DB_FLARG_PASS); + dns__qpdb_bindrdataset(search.qpdb, node, found, search.now, nlocktype, + rdataset DNS__DB_FLARG_PASS); if (foundsig != NULL) { - dns__rbtdb_bindrdataset(search.rbtdb, node, foundsig, - search.now, nlocktype, - sigrdataset DNS__DB_FLARG_PASS); + dns__qpdb_bindrdataset(search.qpdb, node, foundsig, search.now, + nlocktype, + sigrdataset DNS__DB_FLARG_PASS); } if (need_headerupdate(found, search.now) || @@ -1327,18 +1325,18 @@ cache_findzonecut(dns_db_t *db, const dns_name_t *name, unsigned int options, POST(nlocktype); } if (need_headerupdate(found, search.now)) { - update_header(search.rbtdb, found, search.now); + update_header(search.qpdb, found, search.now); } if (foundsig != NULL && need_headerupdate(foundsig, search.now)) { - update_header(search.rbtdb, foundsig, search.now); + update_header(search.qpdb, foundsig, search.now); } } NODE_UNLOCK(lock, &nlocktype); tree_exit: - TREE_UNLOCK(&search.rbtdb->tree_lock, &tlocktype); + TREE_UNLOCK(&search.qpdb->tree_lock, &tlocktype); INSIST(!search.need_cleanup); @@ -1356,7 +1354,7 @@ cache_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, dns_rdatatype_t type, dns_rdatatype_t covers, isc_stdtime_t now, dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset DNS__DB_FLARG) { - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; + dns_qpdb_t *qpdb = (dns_qpdb_t *)db; dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node; dns_slabheader_t *header = NULL, *header_next = NULL; dns_slabheader_t *found = NULL, *foundsig = NULL; @@ -1365,7 +1363,7 @@ cache_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, isc_rwlock_t *lock = NULL; isc_rwlocktype_t nlocktype = isc_rwlocktype_none; - REQUIRE(VALID_RBTDB(rbtdb)); + REQUIRE(VALID_QPDB(qpdb)); REQUIRE(type != dns_rdatatype_any); UNUSED(version); @@ -1376,7 +1374,7 @@ cache_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, now = isc_stdtime_now(); } - lock = &rbtdb->node_locks[rbtnode->locknum].lock; + lock = &qpdb->node_locks[rbtnode->locknum].lock; NODE_RDLOCK(lock, &nlocktype); matchtype = DNS_TYPEPAIR_VALUE(type, covers); @@ -1390,8 +1388,8 @@ cache_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, for (header = rbtnode->data; header != NULL; header = header_next) { header_next = header->next; if (!ACTIVE(header, now)) { - if ((header->ttl + STALE_TTL(header, rbtdb) < - now - RBTDB_VIRTUAL) && + if ((header->ttl + STALE_TTL(header, qpdb) < + now - QPDB_VIRTUAL) && (nlocktype == isc_rwlocktype_write || NODE_TRYUPGRADE(lock, &nlocktype) == ISC_R_SUCCESS)) @@ -1406,9 +1404,9 @@ cache_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, * non-zero. This is so because 'node' is an * argument to the function. */ - dns__rbtdb_mark(header, - DNS_SLABHEADERATTR_ANCIENT); - RBTDB_HEADERNODE(header)->dirty = 1; + dns__qpdb_mark(header, + DNS_SLABHEADERATTR_ANCIENT); + QPDB_HEADERNODE(header)->dirty = 1; } } else if (EXISTS(header) && !ANCIENT(header)) { if (header->type == matchtype) { @@ -1423,12 +1421,12 @@ cache_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, } } if (found != NULL) { - dns__rbtdb_bindrdataset(rbtdb, rbtnode, found, now, nlocktype, - rdataset DNS__DB_FLARG_PASS); + dns__qpdb_bindrdataset(qpdb, rbtnode, found, now, nlocktype, + rdataset DNS__DB_FLARG_PASS); if (!NEGATIVE(found) && foundsig != NULL) { - dns__rbtdb_bindrdataset(rbtdb, rbtnode, foundsig, now, - nlocktype, - sigrdataset DNS__DB_FLARG_PASS); + dns__qpdb_bindrdataset(qpdb, rbtnode, foundsig, now, + nlocktype, + sigrdataset DNS__DB_FLARG_PASS); } } @@ -1449,129 +1447,129 @@ cache_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, } } - update_cachestats(rbtdb, result); + update_cachestats(qpdb, result); return (result); } static size_t hashsize(dns_db_t *db) { - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; + dns_qpdb_t *qpdb = (dns_qpdb_t *)db; size_t size; isc_rwlocktype_t tlocktype = isc_rwlocktype_none; - REQUIRE(VALID_RBTDB(rbtdb)); + REQUIRE(VALID_QPDB(qpdb)); - TREE_RDLOCK(&rbtdb->tree_lock, &tlocktype); - size = dns_rbt_hashsize(rbtdb->tree); - TREE_UNLOCK(&rbtdb->tree_lock, &tlocktype); + TREE_RDLOCK(&qpdb->tree_lock, &tlocktype); + size = dns_rbt_hashsize(qpdb->tree); + TREE_UNLOCK(&qpdb->tree_lock, &tlocktype); return (size); } static isc_result_t setcachestats(dns_db_t *db, isc_stats_t *stats) { - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; + dns_qpdb_t *qpdb = (dns_qpdb_t *)db; - REQUIRE(VALID_RBTDB(rbtdb)); - REQUIRE(IS_CACHE(rbtdb)); /* current restriction */ + REQUIRE(VALID_QPDB(qpdb)); + REQUIRE(IS_CACHE(qpdb)); /* current restriction */ REQUIRE(stats != NULL); - isc_stats_attach(stats, &rbtdb->cachestats); + isc_stats_attach(stats, &qpdb->cachestats); return (ISC_R_SUCCESS); } static dns_stats_t * getrrsetstats(dns_db_t *db) { - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; + dns_qpdb_t *qpdb = (dns_qpdb_t *)db; - REQUIRE(VALID_RBTDB(rbtdb)); - REQUIRE(IS_CACHE(rbtdb)); /* current restriction */ + REQUIRE(VALID_QPDB(qpdb)); + REQUIRE(IS_CACHE(qpdb)); /* current restriction */ - return (rbtdb->rrsetstats); + return (qpdb->rrsetstats); } static isc_result_t setservestalettl(dns_db_t *db, dns_ttl_t ttl) { - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; + dns_qpdb_t *qpdb = (dns_qpdb_t *)db; - REQUIRE(VALID_RBTDB(rbtdb)); - REQUIRE(IS_CACHE(rbtdb)); + REQUIRE(VALID_QPDB(qpdb)); + REQUIRE(IS_CACHE(qpdb)); /* currently no bounds checking. 0 means disable. */ - rbtdb->common.serve_stale_ttl = ttl; + qpdb->common.serve_stale_ttl = ttl; return (ISC_R_SUCCESS); } static isc_result_t getservestalettl(dns_db_t *db, dns_ttl_t *ttl) { - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; + dns_qpdb_t *qpdb = (dns_qpdb_t *)db; - REQUIRE(VALID_RBTDB(rbtdb)); - REQUIRE(IS_CACHE(rbtdb)); + REQUIRE(VALID_QPDB(qpdb)); + REQUIRE(IS_CACHE(qpdb)); - *ttl = rbtdb->common.serve_stale_ttl; + *ttl = qpdb->common.serve_stale_ttl; return (ISC_R_SUCCESS); } static isc_result_t setservestalerefresh(dns_db_t *db, uint32_t interval) { - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; + dns_qpdb_t *qpdb = (dns_qpdb_t *)db; - REQUIRE(VALID_RBTDB(rbtdb)); - REQUIRE(IS_CACHE(rbtdb)); + REQUIRE(VALID_QPDB(qpdb)); + REQUIRE(IS_CACHE(qpdb)); /* currently no bounds checking. 0 means disable. */ - rbtdb->serve_stale_refresh = interval; + qpdb->serve_stale_refresh = interval; return (ISC_R_SUCCESS); } static isc_result_t getservestalerefresh(dns_db_t *db, uint32_t *interval) { - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; + dns_qpdb_t *qpdb = (dns_qpdb_t *)db; - REQUIRE(VALID_RBTDB(rbtdb)); - REQUIRE(IS_CACHE(rbtdb)); + REQUIRE(VALID_QPDB(qpdb)); + REQUIRE(IS_CACHE(qpdb)); - *interval = rbtdb->serve_stale_refresh; + *interval = qpdb->serve_stale_refresh; return (ISC_R_SUCCESS); } static void expiredata(dns_db_t *db, dns_dbnode_t *node, void *data) { - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; + dns_qpdb_t *qpdb = (dns_qpdb_t *)db; dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node; dns_slabheader_t *header = data; isc_rwlocktype_t nlocktype = isc_rwlocktype_none; isc_rwlocktype_t tlocktype = isc_rwlocktype_none; - NODE_WRLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype); - dns__cacherbt_expireheader(header, &tlocktype, - dns_expire_flush DNS__DB_FLARG_PASS); - NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype); + NODE_WRLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype); + dns__qpcache_expireheader(header, &tlocktype, + dns_expire_flush DNS__DB_FLARG_PASS); + NODE_UNLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype); INSIST(tlocktype == isc_rwlocktype_none); } -dns_dbmethods_t dns__rbtdb_cachemethods = { - .destroy = dns__rbtdb_destroy, - .currentversion = dns__rbtdb_currentversion, - .newversion = dns__rbtdb_newversion, - .attachversion = dns__rbtdb_attachversion, - .closeversion = dns__rbtdb_closeversion, - .findnode = dns__rbtdb_findnode, +dns_dbmethods_t dns__qpdb_cachemethods = { + .destroy = dns__qpdb_destroy, + .currentversion = dns__qpdb_currentversion, + .newversion = dns__qpdb_newversion, + .attachversion = dns__qpdb_attachversion, + .closeversion = dns__qpdb_closeversion, + .findnode = dns__qpdb_findnode, .find = cache_find, .findzonecut = cache_findzonecut, - .attachnode = dns__rbtdb_attachnode, - .detachnode = dns__rbtdb_detachnode, - .createiterator = dns__rbtdb_createiterator, + .attachnode = dns__qpdb_attachnode, + .detachnode = dns__qpdb_detachnode, + .createiterator = dns__qpdb_createiterator, .findrdataset = cache_findrdataset, - .allrdatasets = dns__rbtdb_allrdatasets, - .addrdataset = dns__rbtdb_addrdataset, - .subtractrdataset = dns__rbtdb_subtractrdataset, - .deleterdataset = dns__rbtdb_deleterdataset, - .nodecount = dns__rbtdb_nodecount, - .setloop = dns__rbtdb_setloop, - .getoriginnode = dns__rbtdb_getoriginnode, + .allrdatasets = dns__qpdb_allrdatasets, + .addrdataset = dns__qpdb_addrdataset, + .subtractrdataset = dns__qpdb_subtractrdataset, + .deleterdataset = dns__qpdb_deleterdataset, + .nodecount = dns__qpdb_nodecount, + .setloop = dns__qpdb_setloop, + .getoriginnode = dns__qpdb_getoriginnode, .getrrsetstats = getrrsetstats, .setcachestats = setcachestats, .hashsize = hashsize, @@ -1579,49 +1577,48 @@ dns_dbmethods_t dns__rbtdb_cachemethods = { .getservestalettl = getservestalettl, .setservestalerefresh = setservestalerefresh, .getservestalerefresh = getservestalerefresh, - .locknode = dns__rbtdb_locknode, - .unlocknode = dns__rbtdb_unlocknode, + .locknode = dns__qpdb_locknode, + .unlocknode = dns__qpdb_unlocknode, .expiredata = expiredata, - .deletedata = dns__rbtdb_deletedata, + .deletedata = dns__qpdb_deletedata, }; /* * Caller must hold the node (write) lock. */ void -dns__cacherbt_expireheader(dns_slabheader_t *header, - isc_rwlocktype_t *tlocktypep, - dns_expire_t reason DNS__DB_FLARG) { - dns__rbtdb_setttl(header, 0); - dns__rbtdb_mark(header, DNS_SLABHEADERATTR_ANCIENT); - RBTDB_HEADERNODE(header)->dirty = 1; +dns__qpcache_expireheader(dns_slabheader_t *header, + isc_rwlocktype_t *tlocktypep, + dns_expire_t reason DNS__DB_FLARG) { + dns__qpdb_setttl(header, 0); + dns__qpdb_mark(header, DNS_SLABHEADERATTR_ANCIENT); + QPDB_HEADERNODE(header)->dirty = 1; - if (isc_refcount_current(&RBTDB_HEADERNODE(header)->references) == 0) { + if (isc_refcount_current(&QPDB_HEADERNODE(header)->references) == 0) { isc_rwlocktype_t nlocktype = isc_rwlocktype_write; - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)header->db; + dns_qpdb_t *qpdb = (dns_qpdb_t *)header->db; /* * If no one else is using the node, we can clean it up now. * We first need to gain a new reference to the node to meet a - * requirement of dns__rbtdb_decref(). + * requirement of dns__qpdb_decref(). */ - dns__rbtdb_newref(rbtdb, RBTDB_HEADERNODE(header), - nlocktype DNS__DB_FLARG_PASS); - dns__rbtdb_decref(rbtdb, RBTDB_HEADERNODE(header), 0, - &nlocktype, tlocktypep, true, - false DNS__DB_FLARG_PASS); + dns__qpdb_newref(qpdb, QPDB_HEADERNODE(header), + nlocktype DNS__DB_FLARG_PASS); + dns__qpdb_decref(qpdb, QPDB_HEADERNODE(header), 0, &nlocktype, + tlocktypep, true, false DNS__DB_FLARG_PASS); - if (rbtdb->cachestats == NULL) { + if (qpdb->cachestats == NULL) { return; } switch (reason) { case dns_expire_ttl: - isc_stats_increment(rbtdb->cachestats, + isc_stats_increment(qpdb->cachestats, dns_cachestatscounter_deletettl); break; case dns_expire_lru: - isc_stats_increment(rbtdb->cachestats, + isc_stats_increment(qpdb->cachestats, dns_cachestatscounter_deletelru); break; default: @@ -1641,16 +1638,16 @@ rdataset_size(dns_slabheader_t *header) { } static size_t -expire_lru_headers(dns_rbtdb_t *rbtdb, unsigned int locknum, +expire_lru_headers(dns_qpdb_t *qpdb, unsigned int locknum, isc_rwlocktype_t *tlocktypep, size_t purgesize DNS__DB_FLARG) { dns_slabheader_t *header = NULL; size_t purged = 0; - for (header = ISC_LIST_TAIL(rbtdb->lru[locknum]); - header != NULL && header->last_used <= rbtdb->last_used && + for (header = ISC_LIST_TAIL(qpdb->lru[locknum]); + header != NULL && header->last_used <= qpdb->last_used && purged <= purgesize; - header = ISC_LIST_TAIL(rbtdb->lru[locknum])) + header = ISC_LIST_TAIL(qpdb->lru[locknum])) { size_t header_size = rdataset_size(header); @@ -1661,9 +1658,9 @@ expire_lru_headers(dns_rbtdb_t *rbtdb, unsigned int locknum, * referenced any more (so unlinking is safe) since the * TTL will be reset to 0. */ - ISC_LIST_UNLINK(rbtdb->lru[locknum], header, link); - dns__cacherbt_expireheader(header, tlocktypep, - dns_expire_lru DNS__DB_FLARG_PASS); + ISC_LIST_UNLINK(qpdb->lru[locknum], header, link); + dns__qpcache_expireheader(header, tlocktypep, + dns_expire_lru DNS__DB_FLARG_PASS); purged += header_size; } @@ -1681,14 +1678,13 @@ expire_lru_headers(dns_rbtdb_t *rbtdb, unsigned int locknum, * A write lock on the tree must be held. */ void -dns__cacherbt_overmem(dns_rbtdb_t *rbtdb, dns_slabheader_t *newheader, - isc_rwlocktype_t *tlocktypep DNS__DB_FLARG) { - uint32_t locknum_start = rbtdb->lru_sweep++ % rbtdb->node_lock_count; +dns__qpcache_overmem(dns_qpdb_t *qpdb, dns_slabheader_t *newheader, + isc_rwlocktype_t *tlocktypep DNS__DB_FLARG) { + uint32_t locknum_start = qpdb->lru_sweep++ % qpdb->node_lock_count; uint32_t locknum = locknum_start; /* Size of added data, possible node and possible ENT node. */ - size_t purgesize = - rdataset_size(newheader) + - 2 * dns__rbtnode_getsize(RBTDB_HEADERNODE(newheader)); + size_t purgesize = rdataset_size(newheader) + + 2 * dns__rbtnode_getsize(QPDB_HEADERNODE(newheader)); size_t purged = 0; isc_stdtime_t min_last_used = 0; size_t max_passes = 8; @@ -1696,9 +1692,9 @@ dns__cacherbt_overmem(dns_rbtdb_t *rbtdb, dns_slabheader_t *newheader, again: do { isc_rwlocktype_t nlocktype = isc_rwlocktype_none; - NODE_WRLOCK(&rbtdb->node_locks[locknum].lock, &nlocktype); + NODE_WRLOCK(&qpdb->node_locks[locknum].lock, &nlocktype); - purged += expire_lru_headers(rbtdb, locknum, tlocktypep, + purged += expire_lru_headers(qpdb, locknum, tlocktypep, purgesize - purged DNS__DB_FLARG_PASS); @@ -1706,23 +1702,23 @@ again: * Work out the oldest remaining last_used values of the list * tails as we walk across the array of lru lists. */ - dns_slabheader_t *header = ISC_LIST_TAIL(rbtdb->lru[locknum]); + dns_slabheader_t *header = ISC_LIST_TAIL(qpdb->lru[locknum]); if (header != NULL && (min_last_used == 0 || header->last_used < min_last_used)) { min_last_used = header->last_used; } - NODE_UNLOCK(&rbtdb->node_locks[locknum].lock, &nlocktype); - locknum = (locknum + 1) % rbtdb->node_lock_count; + NODE_UNLOCK(&qpdb->node_locks[locknum].lock, &nlocktype); + locknum = (locknum + 1) % qpdb->node_lock_count; } while (locknum != locknum_start && purged <= purgesize); /* - * Update rbtdb->last_used if we have walked all the list tails and have + * Update qpdb->last_used if we have walked all the list tails and have * not freed the required amount of memory. */ if (purged < purgesize) { if (min_last_used != 0) { - rbtdb->last_used = min_last_used; + qpdb->last_used = min_last_used; if (max_passes-- > 0) { goto again; } diff --git a/lib/dns/qp-zonedb.c b/lib/dns/qp-zonedb.c index 6ebc44f56a..63476caf47 100644 --- a/lib/dns/qp-zonedb.c +++ b/lib/dns/qp-zonedb.c @@ -88,24 +88,24 @@ ((atomic_load_acquire(&(header)->attributes) & \ DNS_SLABHEADERATTR_ANCIENT) != 0) -#define RBTDB_ATTR_LOADED 0x01 -#define RBTDB_ATTR_LOADING 0x02 +#define QPDB_ATTR_LOADED 0x01 +#define QPDB_ATTR_LOADING 0x02 static isc_result_t findnsec3node(dns_db_t *db, const dns_name_t *name, bool create, dns_dbnode_t **nodep DNS__DB_FLARG) { - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; + dns_qpdb_t *qpdb = (dns_qpdb_t *)db; - REQUIRE(VALID_RBTDB(rbtdb)); + REQUIRE(VALID_QPDB(qpdb)); - return (dns__rbtdb_findnodeintree(rbtdb, rbtdb->nsec3, name, create, - nodep DNS__DB_FLARG_PASS)); + return (dns__qpdb_findnodeintree(qpdb, qpdb->nsec3, name, create, + nodep DNS__DB_FLARG_PASS)); } static isc_result_t zone_zonecut_callback(dns_rbtnode_t *node, dns_name_t *name, void *arg DNS__DB_FLARG) { - rbtdb_search_t *search = arg; + qpdb_search_t *search = arg; dns_slabheader_t *header = NULL, *header_next = NULL; dns_slabheader_t *dname_header = NULL, *sigdname_header = NULL; dns_slabheader_t *ns_header = NULL; @@ -123,9 +123,9 @@ zone_zonecut_callback(dns_rbtnode_t *node, dns_name_t *name, return (result); } - onode = search->rbtdb->origin_node; + onode = search->qpdb->origin_node; - NODE_RDLOCK(&(search->rbtdb->node_locks[node->locknum].lock), + NODE_RDLOCK(&(search->qpdb->node_locks[node->locknum].lock), &nlocktype); /* @@ -161,7 +161,7 @@ zone_zonecut_callback(dns_rbtnode_t *node, dns_name_t *name, { sigdname_header = header; } else if (node != onode || - IS_STUB(search->rbtdb)) + IS_STUB(search->qpdb)) { /* * We've found an NS rdataset that @@ -180,7 +180,7 @@ zone_zonecut_callback(dns_rbtnode_t *node, dns_name_t *name, /* * Did we find anything? */ - if (!IS_STUB(search->rbtdb) && ns_header != NULL) { + if (!IS_STUB(search->qpdb) && ns_header != NULL) { /* * Note that NS has precedence over DNAME if both exist * in a zone. Otherwise DNAME take precedence over NS. @@ -200,8 +200,8 @@ zone_zonecut_callback(dns_rbtnode_t *node, dns_name_t *name, * We increment the reference count on node to ensure that * search->zonecut_header will still be valid later. */ - dns__rbtdb_newref(search->rbtdb, node, - isc_rwlocktype_read DNS__DB_FLARG_PASS); + dns__qpdb_newref(search->qpdb, node, + isc_rwlocktype_read DNS__DB_FLARG_PASS); search->zonecut = node; search->zonecut_header = found; search->need_cleanup = true; @@ -245,14 +245,14 @@ zone_zonecut_callback(dns_rbtnode_t *node, dns_name_t *name, } } - NODE_UNLOCK(&(search->rbtdb->node_locks[node->locknum].lock), + NODE_UNLOCK(&(search->qpdb->node_locks[node->locknum].lock), &nlocktype); return (result); } static isc_result_t -setup_delegation(rbtdb_search_t *search, dns_dbnode_t **nodep, +setup_delegation(qpdb_search_t *search, dns_dbnode_t **nodep, dns_name_t *foundname, dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset DNS__DB_FLARG) { dns_name_t *zcname = NULL; @@ -292,19 +292,18 @@ setup_delegation(rbtdb_search_t *search, dns_dbnode_t **nodep, } if (rdataset != NULL) { isc_rwlocktype_t nlocktype = isc_rwlocktype_none; - NODE_RDLOCK(&(search->rbtdb->node_locks[node->locknum].lock), + NODE_RDLOCK(&(search->qpdb->node_locks[node->locknum].lock), &nlocktype); - dns__rbtdb_bindrdataset(search->rbtdb, node, - search->zonecut_header, search->now, - isc_rwlocktype_read, - rdataset DNS__DB_FLARG_PASS); + dns__qpdb_bindrdataset( + search->qpdb, node, search->zonecut_header, search->now, + isc_rwlocktype_read, rdataset DNS__DB_FLARG_PASS); if (sigrdataset != NULL && search->zonecut_sigheader != NULL) { - dns__rbtdb_bindrdataset( - search->rbtdb, node, search->zonecut_sigheader, - search->now, isc_rwlocktype_read, - sigrdataset DNS__DB_FLARG_PASS); + dns__qpdb_bindrdataset(search->qpdb, node, + search->zonecut_sigheader, + search->now, isc_rwlocktype_read, + sigrdataset DNS__DB_FLARG_PASS); } - NODE_UNLOCK(&(search->rbtdb->node_locks[node->locknum].lock), + NODE_UNLOCK(&(search->qpdb->node_locks[node->locknum].lock), &nlocktype); } @@ -323,17 +322,17 @@ typedef enum { FORWARD, BACK } direction_t; * Return true if we found a predecessor or successor. */ static bool -step(rbtdb_search_t *search, dns_rbtnodechain_t *chain, direction_t direction, +step(qpdb_search_t *search, dns_rbtnodechain_t *chain, direction_t direction, dns_name_t *nextname) { dns_fixedname_t forigin; dns_name_t *origin = NULL; dns_name_t prefix; - dns_rbtdb_t *rbtdb = NULL; + dns_qpdb_t *qpdb = NULL; dns_rbtnode_t *node = NULL; isc_result_t result = ISC_R_SUCCESS; dns_slabheader_t *header = NULL; - rbtdb = search->rbtdb; + qpdb = search->qpdb; dns_name_init(&prefix, NULL); origin = dns_fixedname_initname(&forigin); @@ -346,7 +345,7 @@ step(rbtdb_search_t *search, dns_rbtnodechain_t *chain, direction_t direction, if (result != ISC_R_SUCCESS) { break; } - NODE_RDLOCK(&(rbtdb->node_locks[node->locknum].lock), + NODE_RDLOCK(&(qpdb->node_locks[node->locknum].lock), &nlocktype); for (header = node->data; header != NULL; header = header->next) { @@ -356,7 +355,7 @@ step(rbtdb_search_t *search, dns_rbtnodechain_t *chain, direction_t direction, break; } } - NODE_UNLOCK(&(rbtdb->node_locks[node->locknum].lock), + NODE_UNLOCK(&(qpdb->node_locks[node->locknum].lock), &nlocktype); if (header != NULL) { break; @@ -383,7 +382,7 @@ step(rbtdb_search_t *search, dns_rbtnodechain_t *chain, direction_t direction, * of the database. */ static bool -activeempty(rbtdb_search_t *search, dns_rbtnodechain_t *chain, +activeempty(qpdb_search_t *search, dns_rbtnodechain_t *chain, const dns_name_t *current) { isc_result_t result; dns_fixedname_t fnext; @@ -398,7 +397,7 @@ activeempty(rbtdb_search_t *search, dns_rbtnodechain_t *chain, } static bool -wildcard_blocked(rbtdb_search_t *search, const dns_name_t *qname, +wildcard_blocked(qpdb_search_t *search, const dns_name_t *qname, dns_name_t *wname) { isc_result_t result; dns_fixedname_t fnext; @@ -470,7 +469,7 @@ wildcard_blocked(rbtdb_search_t *search, const dns_name_t *qname, } static isc_result_t -find_wildcard(rbtdb_search_t *search, dns_rbtnode_t **nodep, +find_wildcard(qpdb_search_t *search, dns_rbtnode_t **nodep, const dns_name_t *qname) { unsigned int i, j; dns_rbtnode_t *node = NULL, *level_node = NULL, *wnode = NULL; @@ -479,7 +478,7 @@ find_wildcard(rbtdb_search_t *search, dns_rbtnode_t **nodep, dns_name_t name; dns_name_t *wname = NULL; dns_fixedname_t fwname; - dns_rbtdb_t *rbtdb = NULL; + dns_qpdb_t *qpdb = NULL; bool done, wild, active; dns_rbtnodechain_t wchain; @@ -498,12 +497,12 @@ find_wildcard(rbtdb_search_t *search, dns_rbtnode_t **nodep, * continue the search. */ - rbtdb = search->rbtdb; + qpdb = search->qpdb; i = search->chain.level_matches; done = false; node = *nodep; do { - isc_rwlock_t *lock = &rbtdb->node_locks[node->locknum].lock; + isc_rwlock_t *lock = &qpdb->node_locks[node->locknum].lock; isc_rwlocktype_t nlocktype = isc_rwlocktype_none; NODE_RDLOCK(lock, &nlocktype); @@ -561,7 +560,7 @@ find_wildcard(rbtdb_search_t *search, dns_rbtnode_t **nodep, wnode = NULL; dns_rbtnodechain_init(&wchain); result = dns_rbt_findnode( - rbtdb->tree, wname, NULL, &wnode, &wchain, + qpdb->tree, wname, NULL, &wnode, &wchain, DNS_RBTFIND_EMPTYDATA, NULL, NULL); if (result == ISC_R_SUCCESS) { /* @@ -569,7 +568,7 @@ find_wildcard(rbtdb_search_t *search, dns_rbtnode_t **nodep, * is active in the search's version, we're * done. */ - lock = &rbtdb->node_locks[wnode->locknum].lock; + lock = &qpdb->node_locks[wnode->locknum].lock; NODE_RDLOCK(lock, &nlocktype); for (header = wnode->data; header != NULL; header = header->next) @@ -631,7 +630,7 @@ find_wildcard(rbtdb_search_t *search, dns_rbtnode_t **nodep, } static bool -matchparams(dns_slabheader_t *header, rbtdb_search_t *search) { +matchparams(dns_slabheader_t *header, qpdb_search_t *search) { dns_rdata_t rdata = DNS_RDATA_INIT; dns_rdata_nsec3_t nsec3; unsigned char *raw = NULL; @@ -650,7 +649,7 @@ matchparams(dns_slabheader_t *header, rbtdb_search_t *search) { raw += DNS_RDATASET_ORDER + DNS_RDATASET_LENGTH; region.base = raw; region.length = rdlen; - dns_rdata_fromregion(&rdata, search->rbtdb->common.rdclass, + dns_rdata_fromregion(&rdata, search->qpdb->common.rdclass, dns_rdatatype_nsec3, ®ion); raw += rdlen; result = dns_rdata_tostruct(&rdata, &nsec3, NULL); @@ -672,7 +671,7 @@ matchparams(dns_slabheader_t *header, rbtdb_search_t *search) { * Find node of the NSEC/NSEC3 record that is 'name'. */ static isc_result_t -previous_closest_nsec(dns_rdatatype_t type, rbtdb_search_t *search, +previous_closest_nsec(dns_rdatatype_t type, qpdb_search_t *search, dns_name_t *name, dns_name_t *origin, dns_rbtnode_t **nodep, dns_rbtnodechain_t *nsecchain, bool *firstp) { @@ -711,7 +710,7 @@ previous_closest_nsec(dns_rdatatype_t type, rbtdb_search_t *search, } nsecnode = NULL; result = dns_rbt_findnode( - search->rbtdb->nsec, target, NULL, &nsecnode, + search->qpdb->nsec, target, NULL, &nsecnode, nsecchain, DNS_RBTFIND_EMPTYDATA, NULL, NULL); if (result == ISC_R_SUCCESS) { /* @@ -761,7 +760,7 @@ previous_closest_nsec(dns_rdatatype_t type, rbtdb_search_t *search, } *nodep = NULL; - result = dns_rbt_findnode(search->rbtdb->tree, target, NULL, + result = dns_rbt_findnode(search->qpdb->tree, target, NULL, nodep, &search->chain, DNS_RBTFIND_EMPTYDATA, NULL, NULL); if (result == ISC_R_SUCCESS) { @@ -789,7 +788,7 @@ previous_closest_nsec(dns_rdatatype_t type, rbtdb_search_t *search, * current NSEC3PARAM record are considered. */ static isc_result_t -find_closest_nsec(rbtdb_search_t *search, dns_dbnode_t **nodep, +find_closest_nsec(qpdb_search_t *search, dns_dbnode_t **nodep, dns_name_t *foundname, dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset, dns_qp_t *tree, bool secure DNS__DB_FLARG) { @@ -806,7 +805,7 @@ find_closest_nsec(rbtdb_search_t *search, dns_dbnode_t **nodep, bool first = true; bool need_sig = secure; - if (tree == search->rbtdb->nsec3) { + if (tree == search->qpdb->nsec3) { type = dns_rdatatype_nsec3; sigtype = DNS_SIGTYPE(dns_rdatatype_nsec3); wraps = true; @@ -832,7 +831,7 @@ again: do { dns_slabheader_t *found = NULL, *foundsig = NULL; isc_rwlocktype_t nlocktype = isc_rwlocktype_none; - NODE_RDLOCK(&(search->rbtdb->node_locks[node->locknum].lock), + NODE_RDLOCK(&(search->qpdb->node_locks[node->locknum].lock), &nlocktype); empty_node = true; for (header = node->data; header != NULL; header = header_next) @@ -903,20 +902,20 @@ again: foundname, NULL); if (result == ISC_R_SUCCESS) { if (nodep != NULL) { - dns__rbtdb_newref( - search->rbtdb, node, + dns__qpdb_newref( + search->qpdb, node, isc_rwlocktype_read DNS__DB_FLARG_PASS); *nodep = node; } - dns__rbtdb_bindrdataset( - search->rbtdb, node, found, + dns__qpdb_bindrdataset( + search->qpdb, node, found, search->now, isc_rwlocktype_read, rdataset DNS__DB_FLARG_PASS); if (foundsig != NULL) { - dns__rbtdb_bindrdataset( - search->rbtdb, node, + dns__qpdb_bindrdataset( + search->qpdb, node, foundsig, search->now, isc_rwlocktype_read, sigrdataset @@ -952,7 +951,7 @@ again: origin, &prevnode, &nsecchain, &first); } - NODE_UNLOCK(&(search->rbtdb->node_locks[node->locknum].lock), + NODE_UNLOCK(&(search->qpdb->node_locks[node->locknum].lock), &nlocktype); node = prevnode; prevnode = NULL; @@ -991,7 +990,7 @@ zone_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, dns_rdataset_t *sigrdataset DNS__DB_FLARG) { dns_rbtnode_t *node = NULL; isc_result_t result; - rbtdb_search_t search; + qpdb_search_t search; bool cname_ok = true; bool close_version = false; bool maybe_zonecut = false; @@ -1008,37 +1007,37 @@ zone_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, isc_rwlocktype_t nlocktype = isc_rwlocktype_none; isc_rwlocktype_t tlocktype = isc_rwlocktype_none; - REQUIRE(VALID_RBTDB((dns_rbtdb_t *)db)); + REQUIRE(VALID_QPDB((dns_qpdb_t *)db)); INSIST(version == NULL || - ((dns_rbtdb_version_t *)version)->rbtdb == (dns_rbtdb_t *)db); + ((dns_qpdb_version_t *)version)->qpdb == (dns_qpdb_t *)db); /* * If the caller didn't supply a version, attach to the current * version. */ if (version == NULL) { - dns__rbtdb_currentversion(db, &version); + dns__qpdb_currentversion(db, &version); close_version = true; } - search = (rbtdb_search_t){ - .rbtdb = (dns_rbtdb_t *)db, + search = (qpdb_search_t){ + .qpdb = (dns_qpdb_t *)db, .rbtversion = version, - .serial = ((dns_rbtdb_version_t *)version)->serial, + .serial = ((dns_qpdb_version_t *)version)->serial, .options = options, }; dns_fixedname_init(&search.zonecut_name); dns_rbtnodechain_init(&search.chain); - TREE_RDLOCK(&search.rbtdb->tree_lock, &tlocktype); + TREE_RDLOCK(&search.qpdb->tree_lock, &tlocktype); /* * Search down from the root of the tree. If, while going down, we * encounter a callback node, zone_zonecut_callback() will search the * rdatasets at the zone cut for active DNAME or NS rdatasets. */ - tree = (options & DNS_DBFIND_FORCENSEC3) != 0 ? search.rbtdb->nsec3 - : search.rbtdb->tree; + tree = (options & DNS_DBFIND_FORCENSEC3) != 0 ? search.qpdb->nsec3 + : search.qpdb->tree; result = dns_rbt_findnode(tree, name, foundname, &node, &search.chain, DNS_RBTFIND_EMPTYDATA, zone_zonecut_callback, &search); @@ -1126,10 +1125,9 @@ found: * Stub zones don't have anything "above" the delegation so * we always return a referral. */ - if (node->find_callback && - ((node != search.rbtdb->origin_node && - !dns_rdatatype_atparent(type)) || - IS_STUB(search.rbtdb))) + if (node->find_callback && ((node != search.qpdb->origin_node && + !dns_rdatatype_atparent(type)) || + IS_STUB(search.qpdb))) { maybe_zonecut = true; } @@ -1150,7 +1148,7 @@ found: * We now go looking for rdata... */ - lock = &search.rbtdb->node_locks[node->locknum].lock; + lock = &search.qpdb->node_locks[node->locknum].lock; NODE_RDLOCK(lock, &nlocktype); found = NULL; @@ -1196,8 +1194,8 @@ found: * ensure that search->zonecut_header will * still be valid later. */ - dns__rbtdb_newref(search.rbtdb, node, - nlocktype DNS__DB_FLARG_PASS); + dns__qpdb_newref(search.qpdb, node, + nlocktype DNS__DB_FLARG_PASS); search.zonecut = node; search.zonecut_header = header; search.zonecut_sigheader = NULL; @@ -1365,7 +1363,7 @@ found: NODE_UNLOCK(lock, &nlocktype); result = find_closest_nsec( &search, nodep, foundname, rdataset, - sigrdataset, search.rbtdb->tree, + sigrdataset, search.qpdb->tree, search.rbtversion->secure DNS__DB_FLARG_PASS); if (result == ISC_R_SUCCESS) { result = DNS_R_EMPTYWILD; @@ -1373,19 +1371,19 @@ found: goto tree_exit; } if (nodep != NULL) { - dns__rbtdb_newref(search.rbtdb, node, - nlocktype DNS__DB_FLARG_PASS); + dns__qpdb_newref(search.qpdb, node, + nlocktype DNS__DB_FLARG_PASS); *nodep = node; } if ((search.rbtversion->secure && !search.rbtversion->havensec3)) { - dns__rbtdb_bindrdataset(search.rbtdb, node, nsecheader, - 0, nlocktype, - rdataset DNS__DB_FLARG_PASS); + dns__qpdb_bindrdataset(search.qpdb, node, nsecheader, 0, + nlocktype, + rdataset DNS__DB_FLARG_PASS); if (nsecsig != NULL) { - dns__rbtdb_bindrdataset( - search.rbtdb, node, nsecsig, 0, + dns__qpdb_bindrdataset( + search.qpdb, node, nsecsig, 0, nlocktype, sigrdataset DNS__DB_FLARG_PASS); } @@ -1444,8 +1442,8 @@ found: if (nodep != NULL) { if (!at_zonecut) { - dns__rbtdb_newref(search.rbtdb, node, - nlocktype DNS__DB_FLARG_PASS); + dns__qpdb_newref(search.qpdb, node, + nlocktype DNS__DB_FLARG_PASS); } else { search.need_cleanup = false; } @@ -1453,12 +1451,12 @@ found: } if (type != dns_rdatatype_any) { - dns__rbtdb_bindrdataset(search.rbtdb, node, found, 0, nlocktype, - rdataset DNS__DB_FLARG_PASS); + dns__qpdb_bindrdataset(search.qpdb, node, found, 0, nlocktype, + rdataset DNS__DB_FLARG_PASS); if (foundsig != NULL) { - dns__rbtdb_bindrdataset(search.rbtdb, node, foundsig, 0, - nlocktype, - sigrdataset DNS__DB_FLARG_PASS); + dns__qpdb_bindrdataset(search.qpdb, node, foundsig, 0, + nlocktype, + sigrdataset DNS__DB_FLARG_PASS); } } @@ -1470,7 +1468,7 @@ node_exit: NODE_UNLOCK(lock, &nlocktype); tree_exit: - TREE_UNLOCK(&search.rbtdb->tree_lock, &tlocktype); + TREE_UNLOCK(&search.qpdb->tree_lock, &tlocktype); /* * If we found a zonecut but aren't going to use it, we have to @@ -1479,17 +1477,17 @@ tree_exit: if (search.need_cleanup) { node = search.zonecut; INSIST(node != NULL); - lock = &(search.rbtdb->node_locks[node->locknum].lock); + lock = &(search.qpdb->node_locks[node->locknum].lock); NODE_RDLOCK(lock, &nlocktype); - dns__rbtdb_decref(search.rbtdb, node, 0, &nlocktype, &tlocktype, - true, false DNS__DB_FLARG_PASS); + dns__qpdb_decref(search.qpdb, node, 0, &nlocktype, &tlocktype, + true, false DNS__DB_FLARG_PASS); NODE_UNLOCK(lock, &nlocktype); INSIST(tlocktype == isc_rwlocktype_none); } if (close_version) { - dns__rbtdb_closeversion(db, &version, false DNS__DB_FLARG_PASS); + dns__qpdb_closeversion(db, &version, false DNS__DB_FLARG_PASS); } dns_rbtnodechain_reset(&search.chain); @@ -1502,29 +1500,29 @@ zone_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, dns_rdatatype_t type, dns_rdatatype_t covers, isc_stdtime_t now, dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset DNS__DB_FLARG) { - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; + dns_qpdb_t *qpdb = (dns_qpdb_t *)db; dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node; dns_slabheader_t *header = NULL, *header_next = NULL; dns_slabheader_t *found = NULL, *foundsig = NULL; uint32_t serial; - dns_rbtdb_version_t *rbtversion = version; + dns_qpdb_version_t *rbtversion = version; bool close_version = false; dns_typepair_t matchtype, sigmatchtype; isc_rwlocktype_t nlocktype = isc_rwlocktype_none; - REQUIRE(VALID_RBTDB(rbtdb)); + REQUIRE(VALID_QPDB(qpdb)); REQUIRE(type != dns_rdatatype_any); - INSIST(rbtversion == NULL || rbtversion->rbtdb == rbtdb); + INSIST(rbtversion == NULL || rbtversion->qpdb == qpdb); if (rbtversion == NULL) { - dns__rbtdb_currentversion( + dns__qpdb_currentversion( db, (dns_dbversion_t **)(void *)(&rbtversion)); close_version = true; } serial = rbtversion->serial; now = 0; - NODE_RDLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype); + NODE_RDLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype); matchtype = DNS_TYPEPAIR_VALUE(type, covers); if (covers == 0) { @@ -1568,20 +1566,20 @@ zone_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, } } if (found != NULL) { - dns__rbtdb_bindrdataset(rbtdb, rbtnode, found, now, - isc_rwlocktype_read, - rdataset DNS__DB_FLARG_PASS); + dns__qpdb_bindrdataset(qpdb, rbtnode, found, now, + isc_rwlocktype_read, + rdataset DNS__DB_FLARG_PASS); if (foundsig != NULL) { - dns__rbtdb_bindrdataset(rbtdb, rbtnode, foundsig, now, - isc_rwlocktype_read, - sigrdataset DNS__DB_FLARG_PASS); + dns__qpdb_bindrdataset(qpdb, rbtnode, foundsig, now, + isc_rwlocktype_read, + sigrdataset DNS__DB_FLARG_PASS); } } - NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype); + NODE_UNLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype); if (close_version) { - dns__rbtdb_closeversion( + dns__qpdb_closeversion( db, (dns_dbversion_t **)(void *)(&rbtversion), false DNS__DB_FLARG_PASS); } @@ -1594,10 +1592,10 @@ zone_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, } static bool -delegating_type(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, dns_typepair_t type) { +delegating_type(dns_qpdb_t *qpdb, dns_rbtnode_t *node, dns_typepair_t type) { if (type == dns_rdatatype_dname || (type == dns_rdatatype_ns && - (node != rbtdb->origin_node || IS_STUB(rbtdb)))) + (node != qpdb->origin_node || IS_STUB(qpdb)))) { return (true); } @@ -1608,12 +1606,12 @@ delegating_type(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, dns_typepair_t type) { * load a non-NSEC3 node in the main tree and optionally to the auxiliary NSEC */ static isc_result_t -loadnode(dns_rbtdb_t *rbtdb, const dns_name_t *name, dns_rbtnode_t **nodep, +loadnode(dns_qpdb_t *qpdb, const dns_name_t *name, dns_rbtnode_t **nodep, bool hasnsec) { isc_result_t noderesult, nsecresult, tmpresult; dns_rbtnode_t *nsecnode = NULL, *node = NULL; - noderesult = dns_rbt_addnode(rbtdb->tree, name, &node); + noderesult = dns_rbt_addnode(qpdb->tree, name, &node); if (!hasnsec) { goto done; } @@ -1637,7 +1635,7 @@ loadnode(dns_rbtdb_t *rbtdb, const dns_name_t *name, dns_rbtnode_t **nodep, * Add nodes to the auxiliary tree after corresponding nodes have * been added to the main tree. */ - nsecresult = dns_rbt_addnode(rbtdb->nsec, name, &nsecnode); + nsecresult = dns_rbt_addnode(qpdb->nsec, name, &nsecnode); if (nsecresult == ISC_R_SUCCESS) { nsecnode->nsec = DNS_DB_NSEC_NSEC; node->nsec = DNS_DB_NSEC_HAS_NSEC; @@ -1658,7 +1656,7 @@ loadnode(dns_rbtdb_t *rbtdb, const dns_name_t *name, dns_rbtnode_t **nodep, /* * Remove the node we just added above. */ - tmpresult = dns_rbt_deletenode(rbtdb->tree, node, false); + tmpresult = dns_rbt_deletenode(qpdb->tree, node, false); if (tmpresult != ISC_R_SUCCESS) { isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_CACHE, ISC_LOG_WARNING, @@ -1686,21 +1684,21 @@ done: static isc_result_t loading_addrdataset(void *arg, const dns_name_t *name, dns_rdataset_t *rdataset DNS__DB_FLARG) { - rbtdb_load_t *loadctx = arg; - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)loadctx->db; + qpdb_load_t *loadctx = arg; + dns_qpdb_t *qpdb = (dns_qpdb_t *)loadctx->db; dns_rbtnode_t *node = NULL; isc_result_t result; isc_region_t region; dns_slabheader_t *newheader = NULL; isc_rwlocktype_t nlocktype = isc_rwlocktype_none; - REQUIRE(rdataset->rdclass == rbtdb->common.rdclass); + REQUIRE(rdataset->rdclass == qpdb->common.rdclass); /* * SOA records are only allowed at top of zone. */ if (rdataset->type == dns_rdatatype_soa && - !dns_name_equal(name, &rbtdb->common.origin)) + !dns_name_equal(name, &qpdb->common.origin)) { return (DNS_R_NOTZONETOP); } @@ -1708,7 +1706,7 @@ loading_addrdataset(void *arg, const dns_name_t *name, if (rdataset->type != dns_rdatatype_nsec3 && rdataset->covers != dns_rdatatype_nsec3) { - dns__zonerbt_addwildcards(rbtdb, name, false); + dns__qpzone_addwildcards(qpdb, name, false); } if (dns_name_iswildcard(name)) { @@ -1724,7 +1722,7 @@ loading_addrdataset(void *arg, const dns_name_t *name, if (rdataset->type == dns_rdatatype_nsec3) { return (DNS_R_INVALIDNSEC3); } - result = dns__zonerbt_wildcardmagic(rbtdb, name, false); + result = dns__qpzone_wildcardmagic(qpdb, name, false); if (result != ISC_R_SUCCESS) { return (result); } @@ -1733,23 +1731,23 @@ loading_addrdataset(void *arg, const dns_name_t *name, if (rdataset->type == dns_rdatatype_nsec3 || rdataset->covers == dns_rdatatype_nsec3) { - result = dns_rbt_addnode(rbtdb->nsec3, name, &node); + result = dns_rbt_addnode(qpdb->nsec3, name, &node); if (result == ISC_R_SUCCESS) { node->nsec = DNS_DB_NSEC_NSEC3; } } else if (rdataset->type == dns_rdatatype_nsec) { - result = loadnode(rbtdb, name, &node, true); + result = loadnode(qpdb, name, &node, true); } else { - result = loadnode(rbtdb, name, &node, false); + result = loadnode(qpdb, name, &node, false); } if (result != ISC_R_SUCCESS && result != ISC_R_EXISTS) { return (result); } if (result == ISC_R_SUCCESS) { - node->locknum = node->hashval % rbtdb->node_lock_count; + node->locknum = node->hashval % qpdb->node_lock_count; } - result = dns_rdataslab_fromrdataset(rdataset, rbtdb->common.mctx, + result = dns_rdataslab_fromrdataset(rdataset, qpdb->common.mctx, ®ion, sizeof(dns_slabheader_t)); if (result != ISC_R_SUCCESS) { return (result); @@ -1764,7 +1762,7 @@ loading_addrdataset(void *arg, const dns_name_t *name, .count = 1, }; - dns_slabheader_reset(newheader, (dns_db_t *)rbtdb, node); + dns_slabheader_reset(newheader, (dns_db_t *)qpdb, node); dns_slabheader_setownercase(newheader, name); if ((rdataset->attributes & DNS_RDATASETATTR_RESIGN) != 0) { @@ -1775,14 +1773,14 @@ loading_addrdataset(void *arg, const dns_name_t *name, newheader->resign_lsb = rdataset->resign & 0x1; } - NODE_WRLOCK(&rbtdb->node_locks[node->locknum].lock, &nlocktype); - result = dns__rbtdb_add(rbtdb, node, name, rbtdb->current_version, - newheader, DNS_DBADD_MERGE, true, NULL, - 0 DNS__DB_FLARG_PASS); - NODE_UNLOCK(&rbtdb->node_locks[node->locknum].lock, &nlocktype); + NODE_WRLOCK(&qpdb->node_locks[node->locknum].lock, &nlocktype); + result = dns__qpdb_add(qpdb, node, name, qpdb->current_version, + newheader, DNS_DBADD_MERGE, true, NULL, + 0 DNS__DB_FLARG_PASS); + NODE_UNLOCK(&qpdb->node_locks[node->locknum].lock, &nlocktype); if (result == ISC_R_SUCCESS && - delegating_type(rbtdb, node, rdataset->type)) + delegating_type(qpdb, node, rdataset->type)) { node->find_callback = 1; } else if (result == DNS_R_UNCHANGED) { @@ -1794,24 +1792,24 @@ loading_addrdataset(void *arg, const dns_name_t *name, static isc_result_t beginload(dns_db_t *db, dns_rdatacallbacks_t *callbacks) { - rbtdb_load_t *loadctx = NULL; - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; + qpdb_load_t *loadctx = NULL; + dns_qpdb_t *qpdb = (dns_qpdb_t *)db; REQUIRE(DNS_CALLBACK_VALID(callbacks)); - REQUIRE(VALID_RBTDB(rbtdb)); + REQUIRE(VALID_QPDB(qpdb)); - loadctx = isc_mem_get(rbtdb->common.mctx, sizeof(*loadctx)); + loadctx = isc_mem_get(qpdb->common.mctx, sizeof(*loadctx)); loadctx->db = db; loadctx->now = 0; - RWLOCK(&rbtdb->lock, isc_rwlocktype_write); + RWLOCK(&qpdb->lock, isc_rwlocktype_write); - REQUIRE((rbtdb->attributes & - (RBTDB_ATTR_LOADED | RBTDB_ATTR_LOADING)) == 0); - rbtdb->attributes |= RBTDB_ATTR_LOADING; + REQUIRE((qpdb->attributes & (QPDB_ATTR_LOADED | QPDB_ATTR_LOADING)) == + 0); + qpdb->attributes |= QPDB_ATTR_LOADING; - RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write); + RWUNLOCK(&qpdb->lock, isc_rwlocktype_write); callbacks->add = loading_addrdataset; callbacks->add_private = loadctx; @@ -1821,53 +1819,53 @@ beginload(dns_db_t *db, dns_rdatacallbacks_t *callbacks) { static isc_result_t endload(dns_db_t *db, dns_rdatacallbacks_t *callbacks) { - rbtdb_load_t *loadctx = NULL; - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; + qpdb_load_t *loadctx = NULL; + dns_qpdb_t *qpdb = (dns_qpdb_t *)db; - REQUIRE(VALID_RBTDB(rbtdb)); + REQUIRE(VALID_QPDB(qpdb)); REQUIRE(DNS_CALLBACK_VALID(callbacks)); loadctx = callbacks->add_private; REQUIRE(loadctx != NULL); REQUIRE(loadctx->db == db); - RWLOCK(&rbtdb->lock, isc_rwlocktype_write); + RWLOCK(&qpdb->lock, isc_rwlocktype_write); - REQUIRE((rbtdb->attributes & RBTDB_ATTR_LOADING) != 0); - REQUIRE((rbtdb->attributes & RBTDB_ATTR_LOADED) == 0); + REQUIRE((qpdb->attributes & QPDB_ATTR_LOADING) != 0); + REQUIRE((qpdb->attributes & QPDB_ATTR_LOADED) == 0); - rbtdb->attributes &= ~RBTDB_ATTR_LOADING; - rbtdb->attributes |= RBTDB_ATTR_LOADED; + qpdb->attributes &= ~QPDB_ATTR_LOADING; + qpdb->attributes |= QPDB_ATTR_LOADED; /* * If there's a KEY rdataset at the zone origin containing a * zone key, we consider the zone secure. */ - if (rbtdb->origin_node != NULL) { - dns_dbversion_t *version = rbtdb->current_version; - RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write); - dns__rbtdb_setsecure(db, version, rbtdb->origin_node); + if (qpdb->origin_node != NULL) { + dns_dbversion_t *version = qpdb->current_version; + RWUNLOCK(&qpdb->lock, isc_rwlocktype_write); + dns__qpdb_setsecure(db, version, qpdb->origin_node); } else { - RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write); + RWUNLOCK(&qpdb->lock, isc_rwlocktype_write); } callbacks->add = NULL; callbacks->add_private = NULL; - isc_mem_put(rbtdb->common.mctx, loadctx, sizeof(*loadctx)); + isc_mem_put(qpdb->common.mctx, loadctx, sizeof(*loadctx)); return (ISC_R_SUCCESS); } static bool issecure(dns_db_t *db) { - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; + dns_qpdb_t *qpdb = (dns_qpdb_t *)db; bool secure; - REQUIRE(VALID_RBTDB(rbtdb)); + REQUIRE(VALID_QPDB(qpdb)); - RWLOCK(&rbtdb->lock, isc_rwlocktype_read); - secure = rbtdb->current_version->secure; - RWUNLOCK(&rbtdb->lock, isc_rwlocktype_read); + RWLOCK(&qpdb->lock, isc_rwlocktype_read); + secure = qpdb->current_version->secure; + RWUNLOCK(&qpdb->lock, isc_rwlocktype_read); return (secure); } @@ -1876,16 +1874,16 @@ static isc_result_t getnsec3parameters(dns_db_t *db, dns_dbversion_t *version, dns_hash_t *hash, uint8_t *flags, uint16_t *iterations, unsigned char *salt, size_t *salt_length) { - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; + dns_qpdb_t *qpdb = (dns_qpdb_t *)db; isc_result_t result = ISC_R_NOTFOUND; - dns_rbtdb_version_t *rbtversion = version; + dns_qpdb_version_t *rbtversion = version; - REQUIRE(VALID_RBTDB(rbtdb)); - INSIST(rbtversion == NULL || rbtversion->rbtdb == rbtdb); + REQUIRE(VALID_QPDB(qpdb)); + INSIST(rbtversion == NULL || rbtversion->qpdb == qpdb); - RWLOCK(&rbtdb->lock, isc_rwlocktype_read); + RWLOCK(&qpdb->lock, isc_rwlocktype_read); if (rbtversion == NULL) { - rbtversion = rbtdb->current_version; + rbtversion = qpdb->current_version; } if (rbtversion->havensec3) { @@ -1908,7 +1906,7 @@ getnsec3parameters(dns_db_t *db, dns_dbversion_t *version, dns_hash_t *hash, } result = ISC_R_SUCCESS; } - RWUNLOCK(&rbtdb->lock, isc_rwlocktype_read); + RWUNLOCK(&qpdb->lock, isc_rwlocktype_read); return (result); } @@ -1916,16 +1914,16 @@ getnsec3parameters(dns_db_t *db, dns_dbversion_t *version, dns_hash_t *hash, static isc_result_t getsize(dns_db_t *db, dns_dbversion_t *version, uint64_t *records, uint64_t *xfrsize) { - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; + dns_qpdb_t *qpdb = (dns_qpdb_t *)db; isc_result_t result = ISC_R_SUCCESS; - dns_rbtdb_version_t *rbtversion = version; + dns_qpdb_version_t *rbtversion = version; - REQUIRE(VALID_RBTDB(rbtdb)); - INSIST(rbtversion == NULL || rbtversion->rbtdb == rbtdb); + REQUIRE(VALID_QPDB(qpdb)); + INSIST(rbtversion == NULL || rbtversion->qpdb == qpdb); - RWLOCK(&rbtdb->lock, isc_rwlocktype_read); + RWLOCK(&qpdb->lock, isc_rwlocktype_read); if (rbtversion == NULL) { - rbtversion = rbtdb->current_version; + rbtversion = qpdb->current_version; } RWLOCK(&rbtversion->rwlock, isc_rwlocktype_read); @@ -1933,25 +1931,25 @@ getsize(dns_db_t *db, dns_dbversion_t *version, uint64_t *records, SET_IF_NOT_NULL(xfrsize, rbtversion->xfrsize); RWUNLOCK(&rbtversion->rwlock, isc_rwlocktype_read); - RWUNLOCK(&rbtdb->lock, isc_rwlocktype_read); + RWUNLOCK(&qpdb->lock, isc_rwlocktype_read); return (result); } static isc_result_t setsigningtime(dns_db_t *db, dns_rdataset_t *rdataset, isc_stdtime_t resign) { - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; + dns_qpdb_t *qpdb = (dns_qpdb_t *)db; dns_slabheader_t *header, oldheader; isc_rwlocktype_t nlocktype = isc_rwlocktype_none; - REQUIRE(VALID_RBTDB(rbtdb)); - REQUIRE(!IS_CACHE(rbtdb)); + REQUIRE(VALID_QPDB(qpdb)); + REQUIRE(!IS_CACHE(qpdb)); REQUIRE(rdataset != NULL); REQUIRE(rdataset->methods == &dns_rdataslab_rdatasetmethods); header = dns_slabheader_fromrdataset(rdataset); - NODE_WRLOCK(&rbtdb->node_locks[RBTDB_HEADERNODE(header)->locknum].lock, + NODE_WRLOCK(&qpdb->node_locks[QPDB_HEADERNODE(header)->locknum].lock, &nlocktype); oldheader = *header; @@ -1970,25 +1968,25 @@ setsigningtime(dns_db_t *db, dns_rdataset_t *rdataset, isc_stdtime_t resign) { INSIST(RESIGN(header)); if (resign == 0) { isc_heap_delete( - rbtdb->heaps[RBTDB_HEADERNODE(header)->locknum], + qpdb->heaps[QPDB_HEADERNODE(header)->locknum], header->heap_index); header->heap_index = 0; header->heap = NULL; - } else if (rbtdb->sooner(header, &oldheader)) { + } else if (qpdb->sooner(header, &oldheader)) { isc_heap_increased( - rbtdb->heaps[RBTDB_HEADERNODE(header)->locknum], + qpdb->heaps[QPDB_HEADERNODE(header)->locknum], header->heap_index); - } else if (rbtdb->sooner(&oldheader, header)) { + } else if (qpdb->sooner(&oldheader, header)) { isc_heap_decreased( - rbtdb->heaps[RBTDB_HEADERNODE(header)->locknum], + qpdb->heaps[QPDB_HEADERNODE(header)->locknum], header->heap_index); } } else if (resign != 0) { DNS_SLABHEADER_SETATTR(header, DNS_SLABHEADERATTR_RESIGN); - dns__zonerbt_resigninsert( - rbtdb, RBTDB_HEADERNODE(header)->locknum, header); + dns__qpzone_resigninsert(qpdb, QPDB_HEADERNODE(header)->locknum, + header); } - NODE_UNLOCK(&rbtdb->node_locks[RBTDB_HEADERNODE(header)->locknum].lock, + NODE_UNLOCK(&qpdb->node_locks[QPDB_HEADERNODE(header)->locknum].lock, &nlocktype); return (ISC_R_SUCCESS); } @@ -1996,7 +1994,7 @@ setsigningtime(dns_db_t *db, dns_rdataset_t *rdataset, isc_stdtime_t resign) { static isc_result_t getsigningtime(dns_db_t *db, dns_rdataset_t *rdataset, dns_name_t *foundname DNS__DB_FLARG) { - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; + dns_qpdb_t *qpdb = (dns_qpdb_t *)db; dns_slabheader_t *header = NULL, *this = NULL; unsigned int i; isc_result_t result = ISC_R_NOTFOUND; @@ -2004,22 +2002,22 @@ getsigningtime(dns_db_t *db, dns_rdataset_t *rdataset, isc_rwlocktype_t tlocktype = isc_rwlocktype_none; isc_rwlocktype_t nlocktype = isc_rwlocktype_none; - REQUIRE(VALID_RBTDB(rbtdb)); + REQUIRE(VALID_QPDB(qpdb)); - TREE_RDLOCK(&rbtdb->tree_lock, &tlocktype); + TREE_RDLOCK(&qpdb->tree_lock, &tlocktype); - for (i = 0; i < rbtdb->node_lock_count; i++) { - NODE_RDLOCK(&rbtdb->node_locks[i].lock, &nlocktype); + for (i = 0; i < qpdb->node_lock_count; i++) { + NODE_RDLOCK(&qpdb->node_locks[i].lock, &nlocktype); /* * Find for the earliest signing time among all of the * heaps, each of which is covered by a different bucket * lock. */ - this = isc_heap_element(rbtdb->heaps[i], 1); + this = isc_heap_element(qpdb->heaps[i], 1); if (this == NULL) { /* Nothing found; unlock and try the next heap. */ - NODE_UNLOCK(&rbtdb->node_locks[i].lock, &nlocktype); + NODE_UNLOCK(&qpdb->node_locks[i].lock, &nlocktype); continue; } @@ -2032,12 +2030,12 @@ getsigningtime(dns_db_t *db, dns_rdataset_t *rdataset, header = this; locknum = i; nlocktype = isc_rwlocktype_none; - } else if (rbtdb->sooner(this, header)) { + } else if (qpdb->sooner(this, header)) { /* * Found an earlier signing time; release the * previous bucket lock and retain this one instead. */ - NODE_UNLOCK(&rbtdb->node_locks[locknum].lock, + NODE_UNLOCK(&qpdb->node_locks[locknum].lock, &nlocktype); header = this; locknum = i; @@ -2046,7 +2044,7 @@ getsigningtime(dns_db_t *db, dns_rdataset_t *rdataset, * Earliest signing time in this heap isn't * an improvement; unlock and try the next heap. */ - NODE_UNLOCK(&rbtdb->node_locks[i].lock, &nlocktype); + NODE_UNLOCK(&qpdb->node_locks[i].lock, &nlocktype); } } @@ -2056,34 +2054,34 @@ getsigningtime(dns_db_t *db, dns_rdataset_t *rdataset, * Found something; pass back the answer and unlock * the bucket. */ - dns__rbtdb_bindrdataset(rbtdb, RBTDB_HEADERNODE(header), header, - 0, isc_rwlocktype_read, - rdataset DNS__DB_FLARG_PASS); + dns__qpdb_bindrdataset(qpdb, QPDB_HEADERNODE(header), header, 0, + isc_rwlocktype_read, + rdataset DNS__DB_FLARG_PASS); if (foundname != NULL) { - dns_rbt_fullnamefromnode(RBTDB_HEADERNODE(header), + dns_rbt_fullnamefromnode(QPDB_HEADERNODE(header), foundname); } - NODE_UNLOCK(&rbtdb->node_locks[locknum].lock, &nlocktype); + NODE_UNLOCK(&qpdb->node_locks[locknum].lock, &nlocktype); result = ISC_R_SUCCESS; } - TREE_UNLOCK(&rbtdb->tree_lock, &tlocktype); + TREE_UNLOCK(&qpdb->tree_lock, &tlocktype); return (result); } static isc_result_t setgluecachestats(dns_db_t *db, isc_stats_t *stats) { - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; + dns_qpdb_t *qpdb = (dns_qpdb_t *)db; - REQUIRE(VALID_RBTDB(rbtdb)); - REQUIRE(!IS_CACHE(rbtdb) && !IS_STUB(rbtdb)); + REQUIRE(VALID_QPDB(qpdb)); + REQUIRE(!IS_CACHE(qpdb) && !IS_STUB(qpdb)); REQUIRE(stats != NULL); - isc_stats_attach(stats, &rbtdb->gluecachestats); + isc_stats_attach(stats, &qpdb->gluecachestats); return (ISC_R_SUCCESS); } @@ -2307,11 +2305,11 @@ addglue_to_message(dns_glue_t *ge, dns_message_t *msg) { } static dns_glue_t * -newglue(dns_rbtdb_t *rbtdb, dns_rbtdb_version_t *rbtversion, - dns_rbtnode_t *node, dns_rdataset_t *rdataset) { +newglue(dns_qpdb_t *qpdb, dns_qpdb_version_t *rbtversion, dns_rbtnode_t *node, + dns_rdataset_t *rdataset) { dns_fixedname_t nodename; dns_glue_additionaldata_ctx_t ctx = { - .db = (dns_db_t *)rbtdb, + .db = (dns_db_t *)qpdb, .version = (dns_dbversion_t *)rbtversion, .nodename = dns_fixedname_initname(&nodename), }; @@ -2322,7 +2320,7 @@ newglue(dns_rbtdb_t *rbtdb, dns_rbtdb_version_t *rbtversion, * determining which NS records in the delegation are * in-bailiwick). */ - dns__rbtdb_nodefullname((dns_db_t *)rbtdb, node, ctx.nodename); + dns__qpdb_nodefullname((dns_db_t *)qpdb, node, ctx.nodename); (void)dns_rdataset_additionaldata(rdataset, dns_rootname, glue_nsdname_cb, &ctx); @@ -2333,29 +2331,29 @@ newglue(dns_rbtdb_t *rbtdb, dns_rbtdb_version_t *rbtversion, static isc_result_t addglue(dns_db_t *db, dns_dbversion_t *version, dns_rdataset_t *rdataset, dns_message_t *msg) { - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; - dns_rbtdb_version_t *rbtversion = version; + dns_qpdb_t *qpdb = (dns_qpdb_t *)db; + dns_qpdb_version_t *rbtversion = version; dns_rbtnode_t *node = (dns_rbtnode_t *)rdataset->slab.node; dns_slabheader_t *header = dns_slabheader_fromrdataset(rdataset); REQUIRE(rdataset->type == dns_rdatatype_ns); - REQUIRE(rbtdb == (dns_rbtdb_t *)rdataset->slab.db); - REQUIRE(rbtdb == rbtversion->rbtdb); - REQUIRE(!IS_CACHE(rbtdb) && !IS_STUB(rbtdb)); + REQUIRE(qpdb == (dns_qpdb_t *)rdataset->slab.db); + REQUIRE(qpdb == rbtversion->qpdb); + REQUIRE(!IS_CACHE(qpdb) && !IS_STUB(qpdb)); rcu_read_lock(); dns_glue_t *glue = rcu_dereference(header->glue_list); if (glue == NULL) { /* No cached glue was found in the table. Get new glue. */ - glue = newglue(rbtdb, rbtversion, node, rdataset); + glue = newglue(qpdb, rbtversion, node, rdataset); /* Cache the glue or (void *)-1 if no glue was found. */ dns_glue_t *old_glue = rcu_cmpxchg_pointer( &header->glue_list, NULL, (glue) ? glue : (void *)-1); if (old_glue != NULL) { /* Somebody else was faster */ - dns__rbtdb_freeglue(glue); + dns__qpdb_freeglue(glue); glue = old_glue; } else if (glue != NULL) { cds_wfs_push(&rbtversion->glue_stack, @@ -2365,9 +2363,9 @@ addglue(dns_db_t *db, dns_dbversion_t *version, dns_rdataset_t *rdataset, /* We have a cached result. Add it to the message and return. */ - if (rbtdb->gluecachestats != NULL) { + if (qpdb->gluecachestats != NULL) { isc_stats_increment( - rbtdb->gluecachestats, + qpdb->gluecachestats, (glue == (void *)-1) ? dns_gluecachestatscounter_hits_absent : dns_gluecachestatscounter_hits_present); @@ -2386,64 +2384,64 @@ addglue(dns_db_t *db, dns_dbversion_t *version, dns_rdataset_t *rdataset, return (ISC_R_SUCCESS); } -dns_dbmethods_t dns__rbtdb_zonemethods = { - .destroy = dns__rbtdb_destroy, +dns_dbmethods_t dns__qpdb_zonemethods = { + .destroy = dns__qpdb_destroy, .beginload = beginload, .endload = endload, - .currentversion = dns__rbtdb_currentversion, - .newversion = dns__rbtdb_newversion, - .attachversion = dns__rbtdb_attachversion, - .closeversion = dns__rbtdb_closeversion, - .findnode = dns__rbtdb_findnode, + .currentversion = dns__qpdb_currentversion, + .newversion = dns__qpdb_newversion, + .attachversion = dns__qpdb_attachversion, + .closeversion = dns__qpdb_closeversion, + .findnode = dns__qpdb_findnode, .find = zone_find, - .attachnode = dns__rbtdb_attachnode, - .detachnode = dns__rbtdb_detachnode, - .createiterator = dns__rbtdb_createiterator, + .attachnode = dns__qpdb_attachnode, + .detachnode = dns__qpdb_detachnode, + .createiterator = dns__qpdb_createiterator, .findrdataset = zone_findrdataset, - .allrdatasets = dns__rbtdb_allrdatasets, - .addrdataset = dns__rbtdb_addrdataset, - .subtractrdataset = dns__rbtdb_subtractrdataset, - .deleterdataset = dns__rbtdb_deleterdataset, + .allrdatasets = dns__qpdb_allrdatasets, + .addrdataset = dns__qpdb_addrdataset, + .subtractrdataset = dns__qpdb_subtractrdataset, + .deleterdataset = dns__qpdb_deleterdataset, .issecure = issecure, - .nodecount = dns__rbtdb_nodecount, - .setloop = dns__rbtdb_setloop, - .getoriginnode = dns__rbtdb_getoriginnode, + .nodecount = dns__qpdb_nodecount, + .setloop = dns__qpdb_setloop, + .getoriginnode = dns__qpdb_getoriginnode, .getnsec3parameters = getnsec3parameters, .findnsec3node = findnsec3node, .setsigningtime = setsigningtime, .getsigningtime = getsigningtime, .getsize = getsize, .setgluecachestats = setgluecachestats, - .locknode = dns__rbtdb_locknode, - .unlocknode = dns__rbtdb_unlocknode, + .locknode = dns__qpdb_locknode, + .unlocknode = dns__qpdb_unlocknode, .addglue = addglue, - .deletedata = dns__rbtdb_deletedata, + .deletedata = dns__qpdb_deletedata, }; void -dns__zonerbt_resigninsert(dns_rbtdb_t *rbtdb, int idx, - dns_slabheader_t *newheader) { - INSIST(!IS_CACHE(rbtdb)); +dns__qpzone_resigninsert(dns_qpdb_t *qpdb, int idx, + dns_slabheader_t *newheader) { + INSIST(!IS_CACHE(qpdb)); INSIST(newheader->heap_index == 0); INSIST(!ISC_LINK_LINKED(newheader, link)); - isc_heap_insert(rbtdb->heaps[idx], newheader); - newheader->heap = rbtdb->heaps[idx]; + isc_heap_insert(qpdb->heaps[idx], newheader); + newheader->heap = qpdb->heaps[idx]; } void -dns__zonerbt_resigndelete(dns_rbtdb_t *rbtdb, dns_rbtdb_version_t *version, - dns_slabheader_t *header DNS__DB_FLARG) { +dns__qpzone_resigndelete(dns_qpdb_t *qpdb, dns_qpdb_version_t *version, + dns_slabheader_t *header DNS__DB_FLARG) { /* * Remove the old header from the heap */ if (header != NULL && header->heap_index != 0) { - isc_heap_delete(rbtdb->heaps[RBTDB_HEADERNODE(header)->locknum], + isc_heap_delete(qpdb->heaps[QPDB_HEADERNODE(header)->locknum], header->heap_index); header->heap_index = 0; if (version != NULL) { - dns__rbtdb_newref( - rbtdb, RBTDB_HEADERNODE(header), + dns__qpdb_newref( + qpdb, QPDB_HEADERNODE(header), isc_rwlocktype_write DNS__DB_FLARG_PASS); ISC_LIST_APPEND(version->resigned_list, header, link); } @@ -2451,8 +2449,7 @@ dns__zonerbt_resigndelete(dns_rbtdb_t *rbtdb, dns_rbtdb_version_t *version, } isc_result_t -dns__zonerbt_wildcardmagic(dns_rbtdb_t *rbtdb, const dns_name_t *name, - bool lock) { +dns__qpzone_wildcardmagic(dns_qpdb_t *qpdb, const dns_name_t *name, bool lock) { isc_result_t result; dns_name_t foundname; dns_offsets_t offsets; @@ -2465,7 +2462,7 @@ dns__zonerbt_wildcardmagic(dns_rbtdb_t *rbtdb, const dns_name_t *name, INSIST(n >= 2); n--; dns_name_getlabelsequence(name, 1, n, &foundname); - result = dns_rbt_addnode(rbtdb->tree, &foundname, &node); + result = dns_rbt_addnode(qpdb->tree, &foundname, &node); if (result != ISC_R_SUCCESS && result != ISC_R_EXISTS) { return (result); } @@ -2474,18 +2471,17 @@ dns__zonerbt_wildcardmagic(dns_rbtdb_t *rbtdb, const dns_name_t *name, } node->find_callback = 1; if (lock) { - NODE_WRLOCK(&rbtdb->node_locks[node->locknum].lock, &nlocktype); + NODE_WRLOCK(&qpdb->node_locks[node->locknum].lock, &nlocktype); } node->wild = 1; if (lock) { - NODE_UNLOCK(&rbtdb->node_locks[node->locknum].lock, &nlocktype); + NODE_UNLOCK(&qpdb->node_locks[node->locknum].lock, &nlocktype); } return (ISC_R_SUCCESS); } isc_result_t -dns__zonerbt_addwildcards(dns_rbtdb_t *rbtdb, const dns_name_t *name, - bool lock) { +dns__qpzone_addwildcards(dns_qpdb_t *qpdb, const dns_name_t *name, bool lock) { isc_result_t result; dns_name_t foundname; dns_offsets_t offsets; @@ -2493,19 +2489,18 @@ dns__zonerbt_addwildcards(dns_rbtdb_t *rbtdb, const dns_name_t *name, dns_name_init(&foundname, offsets); n = dns_name_countlabels(name); - l = dns_name_countlabels(&rbtdb->common.origin); + l = dns_name_countlabels(&qpdb->common.origin); i = l + 1; while (i < n) { dns_rbtnode_t *node = NULL; dns_name_getlabelsequence(name, n - i, i, &foundname); if (dns_name_iswildcard(&foundname)) { - result = dns__zonerbt_wildcardmagic(rbtdb, &foundname, - lock); + result = dns__qpzone_wildcardmagic(qpdb, &foundname, + lock); if (result != ISC_R_SUCCESS) { return (result); } - result = dns_rbt_addnode(rbtdb->tree, &foundname, - &node); + result = dns_rbt_addnode(qpdb->tree, &foundname, &node); if (result != ISC_R_SUCCESS && result != ISC_R_EXISTS) { return (result); } diff --git a/lib/dns/qpdb.c b/lib/dns/qpdb.c index e10024316e..96ce0341e1 100644 --- a/lib/dns/qpdb.c +++ b/lib/dns/qpdb.c @@ -115,8 +115,8 @@ ((atomic_load_acquire(&(header)->attributes) & \ DNS_SLABHEADERATTR_STATCOUNT) != 0) -#define STALE_TTL(header, rbtdb) \ - (NXDOMAIN(header) ? 0 : rbtdb->common.serve_stale_ttl) +#define STALE_TTL(header, qpdb) \ + (NXDOMAIN(header) ? 0 : qpdb->common.serve_stale_ttl) #define ACTIVE(header, now) \ (((header)->ttl > (now)) || ((header)->ttl == (now) && ZEROTTL(header))) @@ -129,11 +129,11 @@ #define STALEOK(rbtiterator) \ (((rbtiterator)->common.options & DNS_DB_STALEOK) != 0) -#define KEEPSTALE(rbtdb) ((rbtdb)->common.serve_stale_ttl > 0) +#define KEEPSTALE(qpdb) ((qpdb)->common.serve_stale_ttl > 0) -#define RBTDBITER_NSEC3_ORIGIN_NODE(rbtdb, iterator) \ +#define QPDBITER_NSEC3_ORIGIN_NODE(qpdb, iterator) \ ((iterator)->current == &(iterator)->nsec3chain && \ - (iterator)->node == (rbtdb)->nsec3_origin_node) + (iterator)->node == (qpdb)->nsec3_origin_node) /*% * Number of buckets for cache DB entries (locks, LRU lists, TTL heaps). @@ -142,18 +142,18 @@ * LRU purge algorithm won't work well (entries tend to be purged prematurely). * The default value should work well for most environments, but this can * also be configurable at compilation time via the - * DNS_RBTDB_CACHE_NODE_LOCK_COUNT variable. This value must be larger than - * 1 due to the assumption of dns__cacherbt_overmem(). + * DNS_QPDB_CACHE_NODE_LOCK_COUNT variable. This value must be larger than + * 1 due to the assumption of dns__qpcache_overmem(). */ -#ifdef DNS_RBTDB_CACHE_NODE_LOCK_COUNT -#if DNS_RBTDB_CACHE_NODE_LOCK_COUNT <= 1 -#error "DNS_RBTDB_CACHE_NODE_LOCK_COUNT must be larger than 1" -#else /* if DNS_RBTDB_CACHE_NODE_LOCK_COUNT <= 1 */ -#define DEFAULT_CACHE_NODE_LOCK_COUNT DNS_RBTDB_CACHE_NODE_LOCK_COUNT -#endif /* if DNS_RBTDB_CACHE_NODE_LOCK_COUNT <= 1 */ -#else /* ifdef DNS_RBTDB_CACHE_NODE_LOCK_COUNT */ +#ifdef DNS_QPDB_CACHE_NODE_LOCK_COUNT +#if DNS_QPDB_CACHE_NODE_LOCK_COUNT <= 1 +#error "DNS_QPDB_CACHE_NODE_LOCK_COUNT must be larger than 1" +#else /* if DNS_QPDB_CACHE_NODE_LOCK_COUNT <= 1 */ +#define DEFAULT_CACHE_NODE_LOCK_COUNT DNS_QPDB_CACHE_NODE_LOCK_COUNT +#endif /* if DNS_QPDB_CACHE_NODE_LOCK_COUNT <= 1 */ +#else /* ifdef DNS_QPDB_CACHE_NODE_LOCK_COUNT */ #define DEFAULT_CACHE_NODE_LOCK_COUNT 17 -#endif /* DNS_RBTDB_CACHE_NODE_LOCK_COUNT */ +#endif /* DNS_QPDB_CACHE_NODE_LOCK_COUNT */ /* * This defines the number of headers that we try to expire each time the @@ -161,7 +161,7 @@ * TTL-based header expiration doesn't take too long, but it should be large * enough, so we expire enough headers if their TTL is clustered. */ -#define DNS_RBTDB_EXPIRE_TTL_COUNT 10 +#define DNS_QPDB_EXPIRE_TTL_COUNT 10 /* QP methods */ static void @@ -210,7 +210,7 @@ qp_triename(void *uctx, char *buf, size_t size) { static void prune_tree(void *arg); static void -free_gluetable(dns_rbtdb_version_t *version); +free_gluetable(dns_qpdb_version_t *version); static void rdatasetiter_destroy(dns_rdatasetiter_t **iteratorp DNS__DB_FLARG); @@ -227,10 +227,10 @@ static dns_rdatasetitermethods_t rdatasetiter_methods = { rdatasetiter_current }; -typedef struct rbtdb_rdatasetiter { +typedef struct qpdb_rdatasetiter { dns_rdatasetiter_t common; dns_slabheader_t *current; -} rbtdb_rdatasetiter_t; +} qpdb_rdatasetiter_t; /* * Note that these iterators, unless created with either DNS_DB_NSEC3ONLY or @@ -271,7 +271,7 @@ static dns_dbiteratormethods_t dbiterator_methods = { /* * If 'paused' is true, then the tree lock is not being held. */ -typedef struct rbtdb_dbiterator { +typedef struct qpdb_dbiterator { dns_dbiterator_t common; bool paused; bool new_origin; @@ -284,12 +284,12 @@ typedef struct rbtdb_dbiterator { dns_rbtnodechain_t *current; dns_rbtnode_t *node; enum { full, nonsec3, nsec3only } nsec3mode; -} rbtdb_dbiterator_t; +} qpdb_dbiterator_t; static void -free_rbtdb(dns_rbtdb_t *rbtdb, bool log); +free_qpdb(dns_qpdb_t *qpdb, bool log); static void -setnsec3parameters(dns_db_t *db, dns_rbtdb_version_t *version); +setnsec3parameters(dns_db_t *db, dns_qpdb_version_t *version); /*% * 'init_count' is used to initialize 'newheader->count' which inturn @@ -366,7 +366,7 @@ update_rrsetstats(dns_stats_t *stats, const dns_typepair_t htype, } void -dns__rbtdb_setttl(dns_slabheader_t *header, dns_ttl_t newttl) { +dns__qpdb_setttl(dns_slabheader_t *header, dns_ttl_t newttl) { dns_ttl_t oldttl = header->ttl; header->ttl = newttl; @@ -456,50 +456,50 @@ set_index(void *what, unsigned int idx) { } static void -free_rbtdb(dns_rbtdb_t *rbtdb, bool log) { +free_qpdb(dns_qpdb_t *qpdb, bool log) { unsigned int i; char buf[DNS_NAME_FORMATSIZE]; dns_qp_t **treep = NULL; - REQUIRE(rbtdb->current_version != NULL || EMPTY(rbtdb->open_versions)); - REQUIRE(rbtdb->future_version == NULL); + REQUIRE(qpdb->current_version != NULL || EMPTY(qpdb->open_versions)); + REQUIRE(qpdb->future_version == NULL); - if (rbtdb->current_version != NULL) { - isc_refcount_decrementz(&rbtdb->current_version->references); + if (qpdb->current_version != NULL) { + isc_refcount_decrementz(&qpdb->current_version->references); - isc_refcount_destroy(&rbtdb->current_version->references); - UNLINK(rbtdb->open_versions, rbtdb->current_version, link); - cds_wfs_destroy(&rbtdb->current_version->glue_stack); - isc_rwlock_destroy(&rbtdb->current_version->rwlock); - isc_mem_put(rbtdb->common.mctx, rbtdb->current_version, - sizeof(*rbtdb->current_version)); + isc_refcount_destroy(&qpdb->current_version->references); + UNLINK(qpdb->open_versions, qpdb->current_version, link); + cds_wfs_destroy(&qpdb->current_version->glue_stack); + isc_rwlock_destroy(&qpdb->current_version->rwlock); + isc_mem_put(qpdb->common.mctx, qpdb->current_version, + sizeof(*qpdb->current_version)); } /* * We assume the number of remaining dead nodes is reasonably small; * the overhead of unlinking all nodes here should be negligible. */ - for (i = 0; i < rbtdb->node_lock_count; i++) { + for (i = 0; i < qpdb->node_lock_count; i++) { dns_rbtnode_t *node = NULL; - node = ISC_LIST_HEAD(rbtdb->deadnodes[i]); + node = ISC_LIST_HEAD(qpdb->deadnodes[i]); while (node != NULL) { - ISC_LIST_UNLINK(rbtdb->deadnodes[i], node, deadlink); - node = ISC_LIST_HEAD(rbtdb->deadnodes[i]); + ISC_LIST_UNLINK(qpdb->deadnodes[i], node, deadlink); + node = ISC_LIST_HEAD(qpdb->deadnodes[i]); } } - rbtdb->quantum = (rbtdb->loop != NULL) ? 100 : 0; + qpdb->quantum = (qpdb->loop != NULL) ? 100 : 0; for (;;) { /* * pick the next tree to (start to) destroy */ - treep = &rbtdb->tree; + treep = &qpdb->tree; if (*treep == NULL) { - treep = &rbtdb->nsec; + treep = &qpdb->nsec; if (*treep == NULL) { - treep = &rbtdb->nsec3; + treep = &qpdb->nsec3; /* * we're finished after clear cutting */ @@ -514,100 +514,99 @@ free_rbtdb(dns_rbtdb_t *rbtdb, bool log) { } if (log) { - if (dns_name_dynamic(&rbtdb->common.origin)) { - dns_name_format(&rbtdb->common.origin, buf, - sizeof(buf)); + if (dns_name_dynamic(&qpdb->common.origin)) { + dns_name_format(&qpdb->common.origin, buf, sizeof(buf)); } else { strlcpy(buf, "", sizeof(buf)); } isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_CACHE, ISC_LOG_DEBUG(1), - "done free_rbtdb(%s)", buf); + "done free_qpdb(%s)", buf); } - if (dns_name_dynamic(&rbtdb->common.origin)) { - dns_name_free(&rbtdb->common.origin, rbtdb->common.mctx); + if (dns_name_dynamic(&qpdb->common.origin)) { + dns_name_free(&qpdb->common.origin, qpdb->common.mctx); } - for (i = 0; i < rbtdb->node_lock_count; i++) { - isc_refcount_destroy(&rbtdb->node_locks[i].references); - NODE_DESTROYLOCK(&rbtdb->node_locks[i].lock); + for (i = 0; i < qpdb->node_lock_count; i++) { + isc_refcount_destroy(&qpdb->node_locks[i].references); + NODE_DESTROYLOCK(&qpdb->node_locks[i].lock); } /* * Clean up LRU / re-signing order lists. */ - if (rbtdb->lru != NULL) { - for (i = 0; i < rbtdb->node_lock_count; i++) { - INSIST(ISC_LIST_EMPTY(rbtdb->lru[i])); + if (qpdb->lru != NULL) { + for (i = 0; i < qpdb->node_lock_count; i++) { + INSIST(ISC_LIST_EMPTY(qpdb->lru[i])); } - isc_mem_cput(rbtdb->common.mctx, rbtdb->lru, - rbtdb->node_lock_count, + isc_mem_cput(qpdb->common.mctx, qpdb->lru, + qpdb->node_lock_count, sizeof(dns_slabheaderlist_t)); } /* * Clean up dead node buckets. */ - if (rbtdb->deadnodes != NULL) { - for (i = 0; i < rbtdb->node_lock_count; i++) { - INSIST(ISC_LIST_EMPTY(rbtdb->deadnodes[i])); + if (qpdb->deadnodes != NULL) { + for (i = 0; i < qpdb->node_lock_count; i++) { + INSIST(ISC_LIST_EMPTY(qpdb->deadnodes[i])); } - isc_mem_cput(rbtdb->common.mctx, rbtdb->deadnodes, - rbtdb->node_lock_count, sizeof(dns_rbtnodelist_t)); + isc_mem_cput(qpdb->common.mctx, qpdb->deadnodes, + qpdb->node_lock_count, sizeof(dns_rbtnodelist_t)); } /* * Clean up heap objects. */ - if (rbtdb->heaps != NULL) { - for (i = 0; i < rbtdb->node_lock_count; i++) { - isc_heap_destroy(&rbtdb->heaps[i]); + if (qpdb->heaps != NULL) { + for (i = 0; i < qpdb->node_lock_count; i++) { + isc_heap_destroy(&qpdb->heaps[i]); } - isc_mem_cput(rbtdb->hmctx, rbtdb->heaps, rbtdb->node_lock_count, + isc_mem_cput(qpdb->hmctx, qpdb->heaps, qpdb->node_lock_count, sizeof(isc_heap_t *)); } - if (rbtdb->rrsetstats != NULL) { - dns_stats_detach(&rbtdb->rrsetstats); + if (qpdb->rrsetstats != NULL) { + dns_stats_detach(&qpdb->rrsetstats); } - if (rbtdb->cachestats != NULL) { - isc_stats_detach(&rbtdb->cachestats); + if (qpdb->cachestats != NULL) { + isc_stats_detach(&qpdb->cachestats); } - if (rbtdb->gluecachestats != NULL) { - isc_stats_detach(&rbtdb->gluecachestats); + if (qpdb->gluecachestats != NULL) { + isc_stats_detach(&qpdb->gluecachestats); } - isc_mem_cput(rbtdb->common.mctx, rbtdb->node_locks, - rbtdb->node_lock_count, sizeof(db_nodelock_t)); - TREE_DESTROYLOCK(&rbtdb->tree_lock); - isc_refcount_destroy(&rbtdb->common.references); - if (rbtdb->loop != NULL) { - isc_loop_detach(&rbtdb->loop); + isc_mem_cput(qpdb->common.mctx, qpdb->node_locks, qpdb->node_lock_count, + sizeof(db_nodelock_t)); + TREE_DESTROYLOCK(&qpdb->tree_lock); + isc_refcount_destroy(&qpdb->common.references); + if (qpdb->loop != NULL) { + isc_loop_detach(&qpdb->loop); } - isc_rwlock_destroy(&rbtdb->lock); - rbtdb->common.magic = 0; - rbtdb->common.impmagic = 0; - isc_mem_detach(&rbtdb->hmctx); + isc_rwlock_destroy(&qpdb->lock); + qpdb->common.magic = 0; + qpdb->common.impmagic = 0; + isc_mem_detach(&qpdb->hmctx); - if (rbtdb->common.update_listeners != NULL) { - INSIST(!cds_lfht_destroy(rbtdb->common.update_listeners, NULL)); + if (qpdb->common.update_listeners != NULL) { + INSIST(!cds_lfht_destroy(qpdb->common.update_listeners, NULL)); } - isc_mem_putanddetach(&rbtdb->common.mctx, rbtdb, sizeof(*rbtdb)); + isc_mem_putanddetach(&qpdb->common.mctx, qpdb, sizeof(*qpdb)); } void -dns__rbtdb_destroy(dns_db_t *arg) { - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)arg; +dns__qpdb_destroy(dns_db_t *arg) { + dns_qpdb_t *qpdb = (dns_qpdb_t *)arg; bool want_free = false; unsigned int i; unsigned int inactive = 0; /* XXX check for open versions here */ - if (rbtdb->soanode != NULL) { - dns_db_detachnode((dns_db_t *)rbtdb, &rbtdb->soanode); + if (qpdb->soanode != NULL) { + dns_db_detachnode((dns_db_t *)qpdb, &qpdb->soanode); } - if (rbtdb->nsnode != NULL) { - dns_db_detachnode((dns_db_t *)rbtdb, &rbtdb->nsnode); + if (qpdb->nsnode != NULL) { + dns_db_detachnode((dns_db_t *)qpdb, &qpdb->nsnode); } /* @@ -615,68 +614,68 @@ dns__rbtdb_destroy(dns_db_t *arg) { * so the nodes are dereferenced before we check the active * node count below. */ - if (rbtdb->current_version != NULL) { - free_gluetable(rbtdb->current_version); + if (qpdb->current_version != NULL) { + free_gluetable(qpdb->current_version); } /* * Even though there are no external direct references, there still * may be nodes in use. */ - for (i = 0; i < rbtdb->node_lock_count; i++) { + for (i = 0; i < qpdb->node_lock_count; i++) { isc_rwlocktype_t nodelock = isc_rwlocktype_none; - NODE_WRLOCK(&rbtdb->node_locks[i].lock, &nodelock); - rbtdb->node_locks[i].exiting = true; - if (isc_refcount_current(&rbtdb->node_locks[i].references) == 0) + NODE_WRLOCK(&qpdb->node_locks[i].lock, &nodelock); + qpdb->node_locks[i].exiting = true; + if (isc_refcount_current(&qpdb->node_locks[i].references) == 0) { inactive++; } - NODE_UNLOCK(&rbtdb->node_locks[i].lock, &nodelock); + NODE_UNLOCK(&qpdb->node_locks[i].lock, &nodelock); } if (inactive != 0) { - RWLOCK(&rbtdb->lock, isc_rwlocktype_write); - rbtdb->active -= inactive; - if (rbtdb->active == 0) { + RWLOCK(&qpdb->lock, isc_rwlocktype_write); + qpdb->active -= inactive; + if (qpdb->active == 0) { want_free = true; } - RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write); + RWUNLOCK(&qpdb->lock, isc_rwlocktype_write); if (want_free) { char buf[DNS_NAME_FORMATSIZE]; - if (dns_name_dynamic(&rbtdb->common.origin)) { - dns_name_format(&rbtdb->common.origin, buf, + if (dns_name_dynamic(&qpdb->common.origin)) { + dns_name_format(&qpdb->common.origin, buf, sizeof(buf)); } else { strlcpy(buf, "", sizeof(buf)); } isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_CACHE, ISC_LOG_DEBUG(1), - "calling free_rbtdb(%s)", buf); - free_rbtdb(rbtdb, true); + "calling free_qpdb(%s)", buf); + free_qpdb(qpdb, true); } } } void -dns__rbtdb_currentversion(dns_db_t *db, dns_dbversion_t **versionp) { - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; - dns_rbtdb_version_t *version = NULL; +dns__qpdb_currentversion(dns_db_t *db, dns_dbversion_t **versionp) { + dns_qpdb_t *qpdb = (dns_qpdb_t *)db; + dns_qpdb_version_t *version = NULL; - REQUIRE(VALID_RBTDB(rbtdb)); + REQUIRE(VALID_QPDB(qpdb)); - RWLOCK(&rbtdb->lock, isc_rwlocktype_read); - version = rbtdb->current_version; + RWLOCK(&qpdb->lock, isc_rwlocktype_read); + version = qpdb->current_version; isc_refcount_increment(&version->references); - RWUNLOCK(&rbtdb->lock, isc_rwlocktype_read); + RWUNLOCK(&qpdb->lock, isc_rwlocktype_read); *versionp = (dns_dbversion_t *)version; } -static dns_rbtdb_version_t * +static dns_qpdb_version_t * allocate_version(isc_mem_t *mctx, uint32_t serial, unsigned int references, bool writer) { - dns_rbtdb_version_t *version = isc_mem_get(mctx, sizeof(*version)); - *version = (dns_rbtdb_version_t){ + dns_qpdb_version_t *version = isc_mem_get(mctx, sizeof(*version)); + *version = (dns_qpdb_version_t){ .serial = serial, .writer = writer, .changed_list = ISC_LIST_INITIALIZER, @@ -692,28 +691,28 @@ allocate_version(isc_mem_t *mctx, uint32_t serial, unsigned int references, } isc_result_t -dns__rbtdb_newversion(dns_db_t *db, dns_dbversion_t **versionp) { - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; - dns_rbtdb_version_t *version = NULL; +dns__qpdb_newversion(dns_db_t *db, dns_dbversion_t **versionp) { + dns_qpdb_t *qpdb = (dns_qpdb_t *)db; + dns_qpdb_version_t *version = NULL; - REQUIRE(VALID_RBTDB(rbtdb)); + REQUIRE(VALID_QPDB(qpdb)); REQUIRE(versionp != NULL && *versionp == NULL); - REQUIRE(rbtdb->future_version == NULL); + REQUIRE(qpdb->future_version == NULL); - RWLOCK(&rbtdb->lock, isc_rwlocktype_write); - RUNTIME_CHECK(rbtdb->next_serial != 0); /* XXX Error? */ - version = allocate_version(rbtdb->common.mctx, rbtdb->next_serial, 1, + RWLOCK(&qpdb->lock, isc_rwlocktype_write); + RUNTIME_CHECK(qpdb->next_serial != 0); /* XXX Error? */ + version = allocate_version(qpdb->common.mctx, qpdb->next_serial, 1, true); - version->rbtdb = rbtdb; + version->qpdb = qpdb; version->commit_ok = true; - version->secure = rbtdb->current_version->secure; - version->havensec3 = rbtdb->current_version->havensec3; + version->secure = qpdb->current_version->secure; + version->havensec3 = qpdb->current_version->havensec3; if (version->havensec3) { - version->flags = rbtdb->current_version->flags; - version->iterations = rbtdb->current_version->iterations; - version->hash = rbtdb->current_version->hash; - version->salt_length = rbtdb->current_version->salt_length; - memmove(version->salt, rbtdb->current_version->salt, + version->flags = qpdb->current_version->flags; + version->iterations = qpdb->current_version->iterations; + version->hash = qpdb->current_version->hash; + version->salt_length = qpdb->current_version->salt_length; + memmove(version->salt, qpdb->current_version->salt, version->salt_length); } else { version->flags = 0; @@ -723,13 +722,13 @@ dns__rbtdb_newversion(dns_db_t *db, dns_dbversion_t **versionp) { memset(version->salt, 0, sizeof(version->salt)); } isc_rwlock_init(&version->rwlock); - RWLOCK(&rbtdb->current_version->rwlock, isc_rwlocktype_read); - version->records = rbtdb->current_version->records; - version->xfrsize = rbtdb->current_version->xfrsize; - RWUNLOCK(&rbtdb->current_version->rwlock, isc_rwlocktype_read); - rbtdb->next_serial++; - rbtdb->future_version = version; - RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write); + RWLOCK(&qpdb->current_version->rwlock, isc_rwlocktype_read); + version->records = qpdb->current_version->records; + version->xfrsize = qpdb->current_version->xfrsize; + RWUNLOCK(&qpdb->current_version->rwlock, isc_rwlocktype_read); + qpdb->next_serial++; + qpdb->future_version = version; + RWUNLOCK(&qpdb->lock, isc_rwlocktype_write); *versionp = version; @@ -737,33 +736,33 @@ dns__rbtdb_newversion(dns_db_t *db, dns_dbversion_t **versionp) { } void -dns__rbtdb_attachversion(dns_db_t *db, dns_dbversion_t *source, - dns_dbversion_t **targetp) { - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; - dns_rbtdb_version_t *rbtversion = source; +dns__qpdb_attachversion(dns_db_t *db, dns_dbversion_t *source, + dns_dbversion_t **targetp) { + dns_qpdb_t *qpdb = (dns_qpdb_t *)db; + dns_qpdb_version_t *rbtversion = source; - REQUIRE(VALID_RBTDB(rbtdb)); - INSIST(rbtversion != NULL && rbtversion->rbtdb == rbtdb); + REQUIRE(VALID_QPDB(qpdb)); + INSIST(rbtversion != NULL && rbtversion->qpdb == qpdb); isc_refcount_increment(&rbtversion->references); *targetp = rbtversion; } -static rbtdb_changed_t * +static qpdb_changed_t * add_changed(dns_slabheader_t *header, - dns_rbtdb_version_t *version DNS__DB_FLARG) { - rbtdb_changed_t *changed = NULL; - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)header->db; + dns_qpdb_version_t *version DNS__DB_FLARG) { + qpdb_changed_t *changed = NULL; + dns_qpdb_t *qpdb = (dns_qpdb_t *)header->db; /* * Caller must be holding the node lock if its reference must be * protected by the lock. */ - changed = isc_mem_get(rbtdb->common.mctx, sizeof(*changed)); + changed = isc_mem_get(qpdb->common.mctx, sizeof(*changed)); - RWLOCK(&rbtdb->lock, isc_rwlocktype_write); + RWLOCK(&qpdb->lock, isc_rwlocktype_write); REQUIRE(version->writer); @@ -784,7 +783,7 @@ add_changed(dns_slabheader_t *header, version->commit_ok = false; } - RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write); + RWUNLOCK(&qpdb->lock, isc_rwlocktype_write); return (changed); } @@ -825,7 +824,7 @@ rollback_node(dns_rbtnode_t *node, uint32_t serial) { } void -dns__rbtdb_mark(dns_slabheader_t *header, uint_least16_t flag) { +dns__qpdb_mark(dns_slabheader_t *header, uint_least16_t flag) { uint_least16_t attributes = atomic_load_acquire(&header->attributes); uint_least16_t newattributes = 0; dns_stats_t *stats = NULL; @@ -854,9 +853,9 @@ dns__rbtdb_mark(dns_slabheader_t *header, uint_least16_t flag) { static void mark_ancient(dns_slabheader_t *header) { - dns__rbtdb_setttl(header, 0); - dns__rbtdb_mark(header, DNS_SLABHEADERATTR_ANCIENT); - RBTDB_HEADERNODE(header)->dirty = 1; + dns__qpdb_setttl(header, 0); + dns__qpdb_mark(header, DNS_SLABHEADERATTR_ANCIENT); + QPDB_HEADERNODE(header)->dirty = 1; } static void @@ -871,7 +870,7 @@ clean_stale_headers(dns_slabheader_t *top) { } static void -clean_cache_node(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node) { +clean_cache_node(dns_qpdb_t *qpdb, dns_rbtnode_t *node) { dns_slabheader_t *current = NULL, *top_prev = NULL, *top_next = NULL; /* @@ -886,7 +885,7 @@ clean_cache_node(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node) { * we are not keeping stale, we can clean it up. */ if (NONEXISTENT(current) || ANCIENT(current) || - (STALE(current) && !KEEPSTALE(rbtdb))) + (STALE(current) && !KEEPSTALE(qpdb))) { if (top_prev != NULL) { top_prev->next = current->next; @@ -1037,7 +1036,7 @@ clean_zone_node(dns_rbtnode_t *node, uint32_t least_serial) { * tree_lock(write) must be held. */ static void -delete_node(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node) { +delete_node(dns_qpdb_t *qpdb, dns_rbtnode_t *node) { dns_rbtnode_t *nsecnode = NULL; dns_fixedname_t fname; dns_name_t *name = NULL; @@ -1057,7 +1056,7 @@ delete_node(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node) { switch (node->nsec) { case DNS_DB_NSEC_NORMAL: - result = dns_rbt_deletenode(rbtdb->tree, node, false); + result = dns_rbt_deletenode(qpdb->tree, node, false); break; case DNS_DB_NSEC_HAS_NSEC: /* @@ -1071,7 +1070,7 @@ delete_node(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node) { * tree before deleting from the main tree. */ nsecnode = NULL; - result = dns_rbt_findnode(rbtdb->nsec, name, NULL, &nsecnode, + result = dns_rbt_findnode(qpdb->nsec, name, NULL, &nsecnode, NULL, DNS_RBTFIND_EMPTYDATA, NULL, NULL); if (result != ISC_R_SUCCESS) { @@ -1081,7 +1080,7 @@ delete_node(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node) { "dns_rbt_findnode(nsec): %s", isc_result_totext(result)); } else { - result = dns_rbt_deletenode(rbtdb->nsec, nsecnode, + result = dns_rbt_deletenode(qpdb->nsec, nsecnode, false); if (result != ISC_R_SUCCESS) { isc_log_write( @@ -1092,13 +1091,13 @@ delete_node(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node) { isc_result_totext(result)); } } - result = dns_rbt_deletenode(rbtdb->tree, node, false); + result = dns_rbt_deletenode(qpdb->tree, node, false); break; case DNS_DB_NSEC_NSEC: - result = dns_rbt_deletenode(rbtdb->nsec, node, false); + result = dns_rbt_deletenode(qpdb->nsec, node, false); break; case DNS_DB_NSEC_NSEC3: - result = dns_rbt_deletenode(rbtdb->nsec3, node, false); + result = dns_rbt_deletenode(qpdb->nsec3, node, false); break; } if (result != ISC_R_SUCCESS) { @@ -1114,15 +1113,14 @@ delete_node(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node) { * Caller must be holding the node lock. */ void -dns__rbtdb_newref(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, - isc_rwlocktype_t nlocktype DNS__DB_FLARG) { +dns__qpdb_newref(dns_qpdb_t *qpdb, dns_rbtnode_t *node, + isc_rwlocktype_t nlocktype DNS__DB_FLARG) { uint_fast32_t refs; if (nlocktype == isc_rwlocktype_write && ISC_LINK_LINKED(node, deadlink)) { - ISC_LIST_UNLINK(rbtdb->deadnodes[node->locknum], node, - deadlink); + ISC_LIST_UNLINK(qpdb->deadnodes[node->locknum], node, deadlink); } refs = isc_refcount_increment0(&node->references); @@ -1136,13 +1134,13 @@ dns__rbtdb_newref(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, if (refs == 0) { /* this is the first reference to the node */ refs = isc_refcount_increment0( - &rbtdb->node_locks[node->locknum].references); + &qpdb->node_locks[node->locknum].references); #if DNS_DB_NODETRACE fprintf(stderr, "incr:nodelock:%s:%s:%u:%p:%p->references = " "%" PRIuFAST32 "\n", func, file, line, node, - &rbtdb->node_locks[node->locknum], refs + 1); + &qpdb->node_locks[node->locknum], refs + 1); #else UNUSED(refs); #endif @@ -1159,15 +1157,15 @@ is_leaf(dns_rbtnode_t *node) { } static void -send_to_prune_tree(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, +send_to_prune_tree(dns_qpdb_t *qpdb, dns_rbtnode_t *node, isc_rwlocktype_t nlocktype DNS__DB_FLARG) { - prune_t *prune = isc_mem_get(rbtdb->common.mctx, sizeof(*prune)); - *prune = (prune_t){ .node = node }; + qpdb_prune_t *prune = isc_mem_get(qpdb->common.mctx, sizeof(*prune)); + *prune = (qpdb_prune_t){ .node = node }; - dns_db_attach((dns_db_t *)rbtdb, &prune->db); - dns__rbtdb_newref(rbtdb, node, nlocktype DNS__DB_FLARG_PASS); + dns_db_attach((dns_db_t *)qpdb, &prune->db); + dns__qpdb_newref(qpdb, node, nlocktype DNS__DB_FLARG_PASS); - isc_async_run(rbtdb->loop, prune_tree, prune); + isc_async_run(qpdb->loop, prune_tree, prune); } /*% @@ -1179,13 +1177,13 @@ send_to_prune_tree(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, * The caller must hold a tree write lock and bucketnum'th node (write) lock. */ static void -cleanup_dead_nodes(dns_rbtdb_t *rbtdb, int bucketnum DNS__DB_FLARG) { +cleanup_dead_nodes(dns_qpdb_t *qpdb, int bucketnum DNS__DB_FLARG) { dns_rbtnode_t *node = NULL; int count = 10; /* XXXJT: should be adjustable */ - node = ISC_LIST_HEAD(rbtdb->deadnodes[bucketnum]); + node = ISC_LIST_HEAD(qpdb->deadnodes[bucketnum]); while (node != NULL && count > 0) { - ISC_LIST_UNLINK(rbtdb->deadnodes[bucketnum], node, deadlink); + ISC_LIST_UNLINK(qpdb->deadnodes[bucketnum], node, deadlink); /* * We might have reactivated this node without a tree write @@ -1195,30 +1193,30 @@ cleanup_dead_nodes(dns_rbtdb_t *rbtdb, int bucketnum DNS__DB_FLARG) { if (isc_refcount_current(&node->references) != 0 || node->data != NULL) { - node = ISC_LIST_HEAD(rbtdb->deadnodes[bucketnum]); + node = ISC_LIST_HEAD(qpdb->deadnodes[bucketnum]); count--; continue; } - if (is_leaf(node) && rbtdb->loop != NULL) { + if (is_leaf(node) && qpdb->loop != NULL) { send_to_prune_tree( - rbtdb, node, + qpdb, node, isc_rwlocktype_write DNS__DB_FLARG_PASS); } else if (node->down == NULL && node->data == NULL) { /* * Not a interior node and not needing to be * reactivated. */ - delete_node(rbtdb, node); + delete_node(qpdb, node); } else if (node->data == NULL) { /* * A interior node without data. Leave linked to * to be cleaned up when node->down becomes NULL. */ - ISC_LIST_APPEND(rbtdb->deadnodes[bucketnum], node, + ISC_LIST_APPEND(qpdb->deadnodes[bucketnum], node, deadlink); } - node = ISC_LIST_HEAD(rbtdb->deadnodes[bucketnum]); + node = ISC_LIST_HEAD(qpdb->deadnodes[bucketnum]); count--; } } @@ -1234,10 +1232,10 @@ cleanup_dead_nodes(dns_rbtdb_t *rbtdb, int bucketnum DNS__DB_FLARG) { * have been added to the list). */ static void -reactivate_node(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, +reactivate_node(dns_qpdb_t *qpdb, dns_rbtnode_t *node, isc_rwlocktype_t tlocktype DNS__DB_FLARG) { isc_rwlocktype_t nlocktype = isc_rwlocktype_none; - isc_rwlock_t *nodelock = &rbtdb->node_locks[node->locknum].lock; + isc_rwlock_t *nodelock = &qpdb->node_locks[node->locknum].lock; bool maybe_cleanup = false; POST(nlocktype); @@ -1248,7 +1246,7 @@ reactivate_node(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, * Check if we can possibly cleanup the dead node. If so, upgrade * the node lock below to perform the cleanup. */ - if (!ISC_LIST_EMPTY(rbtdb->deadnodes[node->locknum]) && + if (!ISC_LIST_EMPTY(qpdb->deadnodes[node->locknum]) && tlocktype == isc_rwlocktype_write) { maybe_cleanup = true; @@ -1261,16 +1259,16 @@ reactivate_node(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, NODE_FORCEUPGRADE(nodelock, &nlocktype); POST(nlocktype); if (ISC_LINK_LINKED(node, deadlink)) { - ISC_LIST_UNLINK(rbtdb->deadnodes[node->locknum], node, + ISC_LIST_UNLINK(qpdb->deadnodes[node->locknum], node, deadlink); } if (maybe_cleanup) { - cleanup_dead_nodes(rbtdb, + cleanup_dead_nodes(qpdb, node->locknum DNS__DB_FILELINE); } } - dns__rbtdb_newref(rbtdb, node, nlocktype DNS__DB_FLARG_PASS); + dns__qpdb_newref(qpdb, node, nlocktype DNS__DB_FLARG_PASS); NODE_UNLOCK(nodelock, &nlocktype); } @@ -1290,10 +1288,9 @@ reactivate_node(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, * will be immediately freed. */ bool -dns__rbtdb_decref(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, - uint32_t least_serial, isc_rwlocktype_t *nlocktypep, - isc_rwlocktype_t *tlocktypep, bool tryupgrade, - bool pruning DNS__DB_FLARG) { +dns__qpdb_decref(dns_qpdb_t *qpdb, dns_rbtnode_t *node, uint32_t least_serial, + isc_rwlocktype_t *nlocktypep, isc_rwlocktype_t *tlocktypep, + bool tryupgrade, bool pruning DNS__DB_FLARG) { isc_result_t result; bool locked = *tlocktypep != isc_rwlocktype_none; bool write_locked = false; @@ -1304,14 +1301,14 @@ dns__rbtdb_decref(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, REQUIRE(*nlocktypep != isc_rwlocktype_none); - nodelock = &rbtdb->node_locks[bucket]; + nodelock = &qpdb->node_locks[bucket]; #define KEEP_NODE(n, r, l) \ ((n)->data != NULL || ((l) && (n)->down != NULL) || \ (n) == (r)->origin_node || (n) == (r)->nsec3_origin_node) /* Handle easy and typical case first. */ - if (!node->dirty && KEEP_NODE(node, rbtdb, locked)) { + if (!node->dirty && KEEP_NODE(node, qpdb, locked)) { refs = isc_refcount_decrement(&node->references); #if DNS_DB_NODETRACE fprintf(stderr, @@ -1353,17 +1350,17 @@ dns__rbtdb_decref(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, } if (node->dirty) { - if (IS_CACHE(rbtdb)) { - clean_cache_node(rbtdb, node); + if (IS_CACHE(qpdb)) { + clean_cache_node(qpdb, node); } else { if (least_serial == 0) { /* * Caller doesn't know the least serial. * Get it. */ - RWLOCK(&rbtdb->lock, isc_rwlocktype_read); - least_serial = rbtdb->least_serial; - RWUNLOCK(&rbtdb->lock, isc_rwlocktype_read); + RWLOCK(&qpdb->lock, isc_rwlocktype_read); + least_serial = qpdb->least_serial; + RWUNLOCK(&qpdb->lock, isc_rwlocktype_read); } clean_zone_node(node, least_serial); } @@ -1385,13 +1382,13 @@ dns__rbtdb_decref(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, break; case isc_rwlocktype_read: if (tryupgrade) { - result = TREE_TRYUPGRADE(&rbtdb->tree_lock, tlocktypep); + result = TREE_TRYUPGRADE(&qpdb->tree_lock, tlocktypep); } else { result = ISC_R_LOCKBUSY; } break; case isc_rwlocktype_none: - result = TREE_TRYWRLOCK(&rbtdb->tree_lock, tlocktypep); + result = TREE_TRYWRLOCK(&qpdb->tree_lock, tlocktypep); break; default: UNREACHABLE(); @@ -1410,7 +1407,7 @@ dns__rbtdb_decref(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, UNUSED(refs); #endif - if (KEEP_NODE(node, rbtdb, (locked || write_locked))) { + if (KEEP_NODE(node, qpdb, (locked || write_locked))) { goto restore_locks; } @@ -1429,24 +1426,24 @@ dns__rbtdb_decref(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, * cleaning. We need to check whether we're deleting the node * as a result of pruning to avoid infinite dispatching. * Note: pruning happens only when a loop has been set for the - * rbtdb. If the user of the rbtdb chooses not to set a loop, + * qpdb. If the user of the qpdb chooses not to set a loop, * it's their responsibility to purge stale leaves (e.g. by * periodic walk-through). */ - if (!pruning && is_leaf(node) && rbtdb->loop != NULL) { - send_to_prune_tree(rbtdb, node, + if (!pruning && is_leaf(node) && qpdb->loop != NULL) { + send_to_prune_tree(qpdb, node, *nlocktypep DNS__DB_FLARG_PASS); no_reference = false; } else { /* We can now delete the node. */ - delete_node(rbtdb, node); + delete_node(qpdb, node); } } else { INSIST(node->data == NULL); if (!ISC_LINK_LINKED(node, deadlink)) { - ISC_LIST_APPEND(rbtdb->deadnodes[bucket], node, + ISC_LIST_APPEND(qpdb->deadnodes[bucket], node, deadlink); } } @@ -1456,7 +1453,7 @@ restore_locks: * Relock a read lock, or unlock the write lock if no lock was held. */ if (!locked && write_locked) { - TREE_UNLOCK(&rbtdb->tree_lock, tlocktypep); + TREE_UNLOCK(&qpdb->tree_lock, tlocktypep); } return (no_reference); @@ -1470,54 +1467,54 @@ restore_locks: */ static void prune_tree(void *arg) { - prune_t *prune = (prune_t *)arg; - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)prune->db; + qpdb_prune_t *prune = (qpdb_prune_t *)arg; + dns_qpdb_t *qpdb = (dns_qpdb_t *)prune->db; dns_rbtnode_t *node = prune->node; dns_rbtnode_t *parent = NULL; unsigned int locknum = node->locknum; isc_rwlocktype_t tlocktype = isc_rwlocktype_none; isc_rwlocktype_t nlocktype = isc_rwlocktype_none; - isc_mem_put(rbtdb->common.mctx, prune, sizeof(*prune)); + isc_mem_put(qpdb->common.mctx, prune, sizeof(*prune)); - TREE_WRLOCK(&rbtdb->tree_lock, &tlocktype); + TREE_WRLOCK(&qpdb->tree_lock, &tlocktype); parent = node->parent; - NODE_WRLOCK(&rbtdb->node_locks[locknum].lock, &nlocktype); - dns__rbtdb_decref(rbtdb, node, 0, &nlocktype, &tlocktype, true, - true DNS__DB_FILELINE); - NODE_UNLOCK(&rbtdb->node_locks[locknum].lock, &nlocktype); + NODE_WRLOCK(&qpdb->node_locks[locknum].lock, &nlocktype); + dns__qpdb_decref(qpdb, node, 0, &nlocktype, &tlocktype, true, + true DNS__DB_FILELINE); + NODE_UNLOCK(&qpdb->node_locks[locknum].lock, &nlocktype); if (parent != NULL && is_leaf(parent)) { - NODE_WRLOCK(&rbtdb->node_locks[parent->locknum].lock, + NODE_WRLOCK(&qpdb->node_locks[parent->locknum].lock, &nlocktype); - send_to_prune_tree(rbtdb, parent, nlocktype); - NODE_UNLOCK(&rbtdb->node_locks[parent->locknum].lock, + send_to_prune_tree(qpdb, parent, nlocktype); + NODE_UNLOCK(&qpdb->node_locks[parent->locknum].lock, &nlocktype); } - TREE_UNLOCK(&rbtdb->tree_lock, &tlocktype); + TREE_UNLOCK(&qpdb->tree_lock, &tlocktype); - dns_db_detach((dns_db_t **)&rbtdb); + dns_db_detach((dns_db_t **)&qpdb); } static void -make_least_version(dns_rbtdb_t *rbtdb, dns_rbtdb_version_t *version, - rbtdb_changedlist_t *cleanup_list) { +make_least_version(dns_qpdb_t *qpdb, dns_qpdb_version_t *version, + qpdb_changedlist_t *cleanup_list) { /* * Caller must be holding the database lock. */ - rbtdb->least_serial = version->serial; + qpdb->least_serial = version->serial; *cleanup_list = version->changed_list; ISC_LIST_INIT(version->changed_list); } static void -cleanup_nondirty(dns_rbtdb_version_t *version, - rbtdb_changedlist_t *cleanup_list) { - rbtdb_changed_t *changed = NULL, *next_changed = NULL; +cleanup_nondirty(dns_qpdb_version_t *version, + qpdb_changedlist_t *cleanup_list) { + qpdb_changed_t *changed = NULL, *next_changed = NULL; /* * If the changed record is dirty, then @@ -1545,8 +1542,8 @@ cleanup_nondirty(dns_rbtdb_version_t *version, } void -dns__rbtdb_setsecure(dns_db_t *db, dns_rbtdb_version_t *version, - dns_dbnode_t *origin) { +dns__qpdb_setsecure(dns_db_t *db, dns_qpdb_version_t *version, + dns_dbnode_t *origin) { dns_rdataset_t keyset; dns_rdataset_t nsecset, signsecset; bool haszonekey = false; @@ -1604,7 +1601,7 @@ dns__rbtdb_setsecure(dns_db_t *db, dns_rbtdb_version_t *version, * Cache the nsec3 parameters. */ static void -setnsec3parameters(dns_db_t *db, dns_rbtdb_version_t *version) { +setnsec3parameters(dns_db_t *db, dns_qpdb_version_t *version) { dns_rbtnode_t *node = NULL; dns_rdata_nsec3param_t nsec3param; dns_rdata_t rdata = DNS_RDATA_INIT; @@ -1613,14 +1610,14 @@ setnsec3parameters(dns_db_t *db, dns_rbtdb_version_t *version) { dns_slabheader_t *header = NULL, *header_next = NULL; unsigned char *raw; /* RDATASLAB */ unsigned int count, length; - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; + dns_qpdb_t *qpdb = (dns_qpdb_t *)db; isc_rwlocktype_t tlocktype = isc_rwlocktype_none; isc_rwlocktype_t nlocktype = isc_rwlocktype_none; - TREE_RDLOCK(&rbtdb->tree_lock, &tlocktype); + TREE_RDLOCK(&qpdb->tree_lock, &tlocktype); version->havensec3 = false; - node = rbtdb->origin_node; - NODE_RDLOCK(&(rbtdb->node_locks[node->locknum].lock), &nlocktype); + node = qpdb->origin_node; + NODE_RDLOCK(&(qpdb->node_locks[node->locknum].lock), &nlocktype); for (header = node->data; header != NULL; header = header_next) { header_next = header->next; do { @@ -1652,7 +1649,7 @@ setnsec3parameters(dns_db_t *db, dns_rbtdb_version_t *version) { region.length = length; raw += length; dns_rdata_fromregion( - &rdata, rbtdb->common.rdclass, + &rdata, qpdb->common.rdclass, dns_rdatatype_nsec3param, ®ion); result = dns_rdata_tostruct(&rdata, &nsec3param, NULL); @@ -1687,52 +1684,52 @@ setnsec3parameters(dns_db_t *db, dns_rbtdb_version_t *version) { } } unlock: - NODE_UNLOCK(&(rbtdb->node_locks[node->locknum].lock), &nlocktype); - TREE_UNLOCK(&rbtdb->tree_lock, &tlocktype); + NODE_UNLOCK(&(qpdb->node_locks[node->locknum].lock), &nlocktype); + TREE_UNLOCK(&qpdb->tree_lock, &tlocktype); } static void cleanup_dead_nodes_callback(void *arg) { - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)arg; + dns_qpdb_t *qpdb = (dns_qpdb_t *)arg; bool again = false; unsigned int locknum; isc_rwlocktype_t tlocktype = isc_rwlocktype_none; isc_rwlocktype_t nlocktype = isc_rwlocktype_none; - TREE_WRLOCK(&rbtdb->tree_lock, &tlocktype); - for (locknum = 0; locknum < rbtdb->node_lock_count; locknum++) { - NODE_WRLOCK(&rbtdb->node_locks[locknum].lock, &nlocktype); - cleanup_dead_nodes(rbtdb, locknum DNS__DB_FILELINE); - if (ISC_LIST_HEAD(rbtdb->deadnodes[locknum]) != NULL) { + TREE_WRLOCK(&qpdb->tree_lock, &tlocktype); + for (locknum = 0; locknum < qpdb->node_lock_count; locknum++) { + NODE_WRLOCK(&qpdb->node_locks[locknum].lock, &nlocktype); + cleanup_dead_nodes(qpdb, locknum DNS__DB_FILELINE); + if (ISC_LIST_HEAD(qpdb->deadnodes[locknum]) != NULL) { again = true; } - NODE_UNLOCK(&rbtdb->node_locks[locknum].lock, &nlocktype); + NODE_UNLOCK(&qpdb->node_locks[locknum].lock, &nlocktype); } - TREE_UNLOCK(&rbtdb->tree_lock, &tlocktype); + TREE_UNLOCK(&qpdb->tree_lock, &tlocktype); if (again) { - isc_async_run(rbtdb->loop, cleanup_dead_nodes_callback, rbtdb); + isc_async_run(qpdb->loop, cleanup_dead_nodes_callback, qpdb); } else { - dns_db_detach((dns_db_t **)&rbtdb); + dns_db_detach((dns_db_t **)&qpdb); } } void -dns__rbtdb_closeversion(dns_db_t *db, dns_dbversion_t **versionp, - bool commit DNS__DB_FLARG) { - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; - dns_rbtdb_version_t *version = NULL, *cleanup_version = NULL; - dns_rbtdb_version_t *least_greater = NULL; +dns__qpdb_closeversion(dns_db_t *db, dns_dbversion_t **versionp, + bool commit DNS__DB_FLARG) { + dns_qpdb_t *qpdb = (dns_qpdb_t *)db; + dns_qpdb_version_t *version = NULL, *cleanup_version = NULL; + dns_qpdb_version_t *least_greater = NULL; bool rollback = false; - rbtdb_changedlist_t cleanup_list; + qpdb_changedlist_t cleanup_list; dns_slabheaderlist_t resigned_list; - rbtdb_changed_t *changed = NULL, *next_changed = NULL; + qpdb_changed_t *changed = NULL, *next_changed = NULL; uint32_t serial, least_serial; dns_rbtnode_t *rbtnode = NULL; dns_slabheader_t *header = NULL; - REQUIRE(VALID_RBTDB(rbtdb)); - version = (dns_rbtdb_version_t *)*versionp; - INSIST(version->rbtdb == rbtdb); + REQUIRE(VALID_QPDB(qpdb)); + version = (dns_qpdb_version_t *)*versionp; + INSIST(version->qpdb == qpdb); ISC_LIST_INIT(cleanup_list); ISC_LIST_INIT(resigned_list); @@ -1740,9 +1737,9 @@ dns__rbtdb_closeversion(dns_db_t *db, dns_dbversion_t **versionp, if (isc_refcount_decrement(&version->references) > 1) { /* typical and easy case first */ if (commit) { - RWLOCK(&rbtdb->lock, isc_rwlocktype_read); + RWLOCK(&qpdb->lock, isc_rwlocktype_read); INSIST(!version->writer); - RWUNLOCK(&rbtdb->lock, isc_rwlocktype_read); + RWUNLOCK(&qpdb->lock, isc_rwlocktype_read); } goto end; } @@ -1751,43 +1748,42 @@ dns__rbtdb_closeversion(dns_db_t *db, dns_dbversion_t **versionp, * Update the zone's secure status in version before making * it the current version. */ - if (version->writer && commit && !IS_CACHE(rbtdb)) { - dns__rbtdb_setsecure(db, version, rbtdb->origin_node); + if (version->writer && commit && !IS_CACHE(qpdb)) { + dns__qpdb_setsecure(db, version, qpdb->origin_node); } - RWLOCK(&rbtdb->lock, isc_rwlocktype_write); + RWLOCK(&qpdb->lock, isc_rwlocktype_write); serial = version->serial; if (version->writer) { if (commit) { unsigned int cur_ref; - dns_rbtdb_version_t *cur_version = NULL; + dns_qpdb_version_t *cur_version = NULL; INSIST(version->commit_ok); - INSIST(version == rbtdb->future_version); + INSIST(version == qpdb->future_version); /* * The current version is going to be replaced. * Release the (likely last) reference to it from the * DB itself and unlink it from the open list. */ - cur_version = rbtdb->current_version; + cur_version = qpdb->current_version; cur_ref = isc_refcount_decrement( &cur_version->references); if (cur_ref == 1) { (void)isc_refcount_current( &cur_version->references); - if (cur_version->serial == rbtdb->least_serial) - { + if (cur_version->serial == qpdb->least_serial) { INSIST(EMPTY( cur_version->changed_list)); } - UNLINK(rbtdb->open_versions, cur_version, link); + UNLINK(qpdb->open_versions, cur_version, link); } - if (EMPTY(rbtdb->open_versions)) { + if (EMPTY(qpdb->open_versions)) { /* * We're going to become the least open * version. */ - make_least_version(rbtdb, version, + make_least_version(qpdb, version, &cleanup_list); } else { /* @@ -1819,9 +1815,9 @@ dns__rbtdb_closeversion(dns_db_t *db, dns_dbversion_t **versionp, * Become the current version. */ version->writer = false; - rbtdb->current_version = version; - rbtdb->current_serial = version->serial; - rbtdb->future_version = NULL; + qpdb->current_version = version; + qpdb->current_serial = version->serial; + qpdb->future_version = NULL; /* * Keep the current version in the open list, and @@ -1832,7 +1828,7 @@ dns__rbtdb_closeversion(dns_db_t *db, dns_dbversion_t **versionp, */ INSIST(isc_refcount_increment0(&version->references) == 0); - PREPEND(rbtdb->open_versions, rbtdb->current_version, + PREPEND(qpdb->open_versions, qpdb->current_version, link); resigned_list = version->resigned_list; ISC_LIST_INIT(version->resigned_list); @@ -1846,10 +1842,10 @@ dns__rbtdb_closeversion(dns_db_t *db, dns_dbversion_t **versionp, ISC_LIST_INIT(version->resigned_list); rollback = true; cleanup_version = version; - rbtdb->future_version = NULL; + qpdb->future_version = NULL; } } else { - if (version != rbtdb->current_version) { + if (version != qpdb->current_version) { /* * There are no external or internal references * to this version and it can be cleaned up. @@ -1862,19 +1858,19 @@ dns__rbtdb_closeversion(dns_db_t *db, dns_dbversion_t **versionp, */ least_greater = PREV(version, link); if (least_greater == NULL) { - least_greater = rbtdb->current_version; + least_greater = qpdb->current_version; } INSIST(version->serial < least_greater->serial); /* * Is this the least open version? */ - if (version->serial == rbtdb->least_serial) { + if (version->serial == qpdb->least_serial) { /* * Yes. Install the new least open * version. */ - make_least_version(rbtdb, least_greater, + make_least_version(qpdb, least_greater, &cleanup_list); } else { /* @@ -1884,13 +1880,13 @@ dns__rbtdb_closeversion(dns_db_t *db, dns_dbversion_t **versionp, APPENDLIST(least_greater->changed_list, version->changed_list, link); } - } else if (version->serial == rbtdb->least_serial) { + } else if (version->serial == qpdb->least_serial) { INSIST(EMPTY(version->changed_list)); } - UNLINK(rbtdb->open_versions, version, link); + UNLINK(qpdb->open_versions, version, link); } - least_serial = rbtdb->least_serial; - RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write); + least_serial = qpdb->least_serial; + RWUNLOCK(&qpdb->lock, isc_rwlocktype_write); if (cleanup_version != NULL) { isc_refcount_destroy(&cleanup_version->references); @@ -1898,7 +1894,7 @@ dns__rbtdb_closeversion(dns_db_t *db, dns_dbversion_t **versionp, free_gluetable(cleanup_version); cds_wfs_destroy(&cleanup_version->glue_stack); isc_rwlock_destroy(&cleanup_version->rwlock); - isc_mem_put(rbtdb->common.mctx, cleanup_version, + isc_mem_put(qpdb->common.mctx, cleanup_version, sizeof(*cleanup_version)); } @@ -1914,17 +1910,15 @@ dns__rbtdb_closeversion(dns_db_t *db, dns_dbversion_t **versionp, ISC_LIST_UNLINK(resigned_list, header, link); - lock = &rbtdb->node_locks[RBTDB_HEADERNODE(header)->locknum] - .lock; + lock = &qpdb->node_locks[QPDB_HEADERNODE(header)->locknum].lock; NODE_WRLOCK(lock, &nlocktype); if (rollback && !IGNORE(header)) { - dns__zonerbt_resigninsert( - rbtdb, RBTDB_HEADERNODE(header)->locknum, - header); + dns__qpzone_resigninsert( + qpdb, QPDB_HEADERNODE(header)->locknum, header); } - dns__rbtdb_decref(rbtdb, RBTDB_HEADERNODE(header), least_serial, - &nlocktype, &tlocktype, true, - false DNS__DB_FLARG_PASS); + dns__qpdb_decref(qpdb, QPDB_HEADERNODE(header), least_serial, + &nlocktype, &tlocktype, true, + false DNS__DB_FLARG_PASS); NODE_UNLOCK(lock, &nlocktype); INSIST(tlocktype == isc_rwlocktype_none); } @@ -1932,17 +1926,17 @@ dns__rbtdb_closeversion(dns_db_t *db, dns_dbversion_t **versionp, if (!EMPTY(cleanup_list)) { isc_rwlocktype_t tlocktype = isc_rwlocktype_none; - if (rbtdb->loop == NULL) { + if (qpdb->loop == NULL) { /* * We acquire a tree write lock here in order to make * sure that stale nodes will be removed in - * dns__rbtdb_decref(). If we didn't have the lock, + * dns__qpdb_decref(). If we didn't have the lock, * those nodes could miss the chance to be removed * until the server stops. The write lock is * expensive, but this should be rare enough * to justify the cost. */ - TREE_WRLOCK(&rbtdb->tree_lock, &tlocktype); + TREE_WRLOCK(&qpdb->tree_lock, &tlocktype); } for (changed = HEAD(cleanup_list); changed != NULL; @@ -1953,37 +1947,37 @@ dns__rbtdb_closeversion(dns_db_t *db, dns_dbversion_t **versionp, next_changed = NEXT(changed, link); rbtnode = changed->node; - lock = &rbtdb->node_locks[rbtnode->locknum].lock; + lock = &qpdb->node_locks[rbtnode->locknum].lock; NODE_WRLOCK(lock, &nlocktype); /* * This is a good opportunity to purge any dead nodes, * so use it. */ - if (rbtdb->loop == NULL) { + if (qpdb->loop == NULL) { cleanup_dead_nodes( - rbtdb, + qpdb, rbtnode->locknum DNS__DB_FLARG_PASS); } if (rollback) { rollback_node(rbtnode, serial); } - dns__rbtdb_decref(rbtdb, rbtnode, least_serial, - &nlocktype, &tlocktype, true, - false DNS__DB_FILELINE); + dns__qpdb_decref(qpdb, rbtnode, least_serial, + &nlocktype, &tlocktype, true, + false DNS__DB_FILELINE); NODE_UNLOCK(lock, &nlocktype); - isc_mem_put(rbtdb->common.mctx, changed, + isc_mem_put(qpdb->common.mctx, changed, sizeof(*changed)); } - if (rbtdb->loop != NULL) { - isc_refcount_increment(&rbtdb->common.references); - isc_async_run(rbtdb->loop, cleanup_dead_nodes_callback, - rbtdb); + if (qpdb->loop != NULL) { + isc_refcount_increment(&qpdb->common.references); + isc_async_run(qpdb->loop, cleanup_dead_nodes_callback, + qpdb); } else { - TREE_UNLOCK(&rbtdb->tree_lock, &tlocktype); + TREE_UNLOCK(&qpdb->tree_lock, &tlocktype); } INSIST(tlocktype == isc_rwlocktype_none); @@ -1994,18 +1988,18 @@ end: } isc_result_t -dns__rbtdb_findnodeintree(dns_rbtdb_t *rbtdb, dns_qp_t *tree, - const dns_name_t *name, bool create, - dns_dbnode_t **nodep DNS__DB_FLARG) { +dns__qpdb_findnodeintree(dns_qpdb_t *qpdb, dns_qp_t *tree, + const dns_name_t *name, bool create, + dns_dbnode_t **nodep DNS__DB_FLARG) { dns_rbtnode_t *node = NULL; dns_name_t nodename; isc_result_t result; isc_rwlocktype_t tlocktype = isc_rwlocktype_none; - INSIST(tree == rbtdb->tree || tree == rbtdb->nsec3); + INSIST(tree == qpdb->tree || tree == qpdb->nsec3); dns_name_init(&nodename, NULL); - TREE_RDLOCK(&rbtdb->tree_lock, &tlocktype); + TREE_RDLOCK(&qpdb->tree_lock, &tlocktype); result = dns_rbt_findnode(tree, name, NULL, &node, NULL, DNS_RBTFIND_EMPTYDATA, NULL, NULL); if (result != ISC_R_SUCCESS) { @@ -2018,24 +2012,24 @@ dns__rbtdb_findnodeintree(dns_rbtdb_t *rbtdb, dns_qp_t *tree, /* * Try to upgrade the lock and if that fails unlock then relock. */ - TREE_FORCEUPGRADE(&rbtdb->tree_lock, &tlocktype); + TREE_FORCEUPGRADE(&qpdb->tree_lock, &tlocktype); node = NULL; result = dns_rbt_addnode(tree, name, &node); if (result == ISC_R_SUCCESS) { dns_rbt_namefromnode(node, &nodename); - node->locknum = node->hashval % rbtdb->node_lock_count; - if (tree == rbtdb->tree) { - dns__zonerbt_addwildcards(rbtdb, name, true); + node->locknum = node->hashval % qpdb->node_lock_count; + if (tree == qpdb->tree) { + dns__qpzone_addwildcards(qpdb, name, true); if (dns_name_iswildcard(name)) { - result = dns__zonerbt_wildcardmagic( - rbtdb, name, true); + result = dns__qpzone_wildcardmagic( + qpdb, name, true); if (result != ISC_R_SUCCESS) { goto unlock; } } } - if (tree == rbtdb->nsec3) { + if (tree == qpdb->nsec3) { node->nsec = DNS_DB_NSEC_NSEC3; } } else if (result == ISC_R_EXISTS) { @@ -2045,35 +2039,35 @@ dns__rbtdb_findnodeintree(dns_rbtdb_t *rbtdb, dns_qp_t *tree, } } - if (tree == rbtdb->nsec3) { + if (tree == qpdb->nsec3) { INSIST(node->nsec == DNS_DB_NSEC_NSEC3); } - reactivate_node(rbtdb, node, tlocktype DNS__DB_FLARG_PASS); + reactivate_node(qpdb, node, tlocktype DNS__DB_FLARG_PASS); *nodep = (dns_dbnode_t *)node; unlock: - TREE_UNLOCK(&rbtdb->tree_lock, &tlocktype); + TREE_UNLOCK(&qpdb->tree_lock, &tlocktype); return (result); } isc_result_t -dns__rbtdb_findnode(dns_db_t *db, const dns_name_t *name, bool create, - dns_dbnode_t **nodep DNS__DB_FLARG) { - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; +dns__qpdb_findnode(dns_db_t *db, const dns_name_t *name, bool create, + dns_dbnode_t **nodep DNS__DB_FLARG) { + dns_qpdb_t *qpdb = (dns_qpdb_t *)db; - REQUIRE(VALID_RBTDB(rbtdb)); + REQUIRE(VALID_QPDB(qpdb)); - return (dns__rbtdb_findnodeintree(rbtdb, rbtdb->tree, name, create, - nodep DNS__DB_FLARG_PASS)); + return (dns__qpdb_findnodeintree(qpdb, qpdb->tree, name, create, + nodep DNS__DB_FLARG_PASS)); } void -dns__rbtdb_bindrdataset(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, - dns_slabheader_t *header, isc_stdtime_t now, - isc_rwlocktype_t locktype, - dns_rdataset_t *rdataset DNS__DB_FLARG) { +dns__qpdb_bindrdataset(dns_qpdb_t *qpdb, dns_rbtnode_t *node, + dns_slabheader_t *header, isc_stdtime_t now, + isc_rwlocktype_t locktype, + dns_rdataset_t *rdataset DNS__DB_FLARG) { bool stale = STALE(header); bool ancient = ANCIENT(header); @@ -2089,7 +2083,7 @@ dns__rbtdb_bindrdataset(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, return; } - dns__rbtdb_newref(rbtdb, node, locktype DNS__DB_FLARG_PASS); + dns__qpdb_newref(qpdb, node, locktype DNS__DB_FLARG_PASS); INSIST(rdataset->methods == NULL); /* We must be disassociated. */ @@ -2097,7 +2091,7 @@ dns__rbtdb_bindrdataset(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, * Mark header stale or ancient if the RRset is no longer active. */ if (!ACTIVE(header, now)) { - dns_ttl_t stale_ttl = header->ttl + STALE_TTL(header, rbtdb); + dns_ttl_t stale_ttl = header->ttl + STALE_TTL(header, qpdb); /* * If this data is in the stale window keep it and if * DNS_DBFIND_STALEOK is not set we tell the caller to @@ -2105,7 +2099,7 @@ dns__rbtdb_bindrdataset(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, * (these records should not be cached anyway). */ - if (KEEPSTALE(rbtdb) && stale_ttl > now) { + if (KEEPSTALE(qpdb) && stale_ttl > now) { stale = true; } else { /* @@ -2117,7 +2111,7 @@ dns__rbtdb_bindrdataset(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, } rdataset->methods = &dns_rdataslab_rdatasetmethods; - rdataset->rdclass = rbtdb->common.rdclass; + rdataset->rdclass = qpdb->common.rdclass; rdataset->type = DNS_TYPEPAIR_TYPE(header->type); rdataset->covers = DNS_TYPEPAIR_COVERS(header->type); rdataset->ttl = header->ttl - now; @@ -2137,7 +2131,7 @@ dns__rbtdb_bindrdataset(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, } if (stale && !ancient) { - dns_ttl_t stale_ttl = header->ttl + STALE_TTL(header, rbtdb); + dns_ttl_t stale_ttl = header->ttl + STALE_TTL(header, qpdb); if (stale_ttl > now) { rdataset->ttl = stale_ttl - now; } else { @@ -2147,14 +2141,14 @@ dns__rbtdb_bindrdataset(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, rdataset->attributes |= DNS_RDATASETATTR_STALE_WINDOW; } rdataset->attributes |= DNS_RDATASETATTR_STALE; - } else if (IS_CACHE(rbtdb) && !ACTIVE(header, now)) { + } else if (IS_CACHE(qpdb) && !ACTIVE(header, now)) { rdataset->attributes |= DNS_RDATASETATTR_ANCIENT; rdataset->ttl = header->ttl; } rdataset->count = atomic_fetch_add_relaxed(&header->count, 1); - rdataset->slab.db = (dns_db_t *)rbtdb; + rdataset->slab.db = (dns_db_t *)qpdb; rdataset->slab.node = (dns_dbnode_t *)node; rdataset->slab.raw = dns_slabheader_raw(header); rdataset->slab.iter_pos = NULL; @@ -2184,9 +2178,9 @@ dns__rbtdb_bindrdataset(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, } void -dns__rbtdb_attachnode(dns_db_t *db, dns_dbnode_t *source, - dns_dbnode_t **targetp DNS__DB_FLARG) { - REQUIRE(VALID_RBTDB((dns_rbtdb_t *)db)); +dns__qpdb_attachnode(dns_db_t *db, dns_dbnode_t *source, + dns_dbnode_t **targetp DNS__DB_FLARG) { + REQUIRE(VALID_QPDB((dns_qpdb_t *)db)); REQUIRE(targetp != NULL && *targetp == NULL); dns_rbtnode_t *node = (dns_rbtnode_t *)source; @@ -2203,8 +2197,8 @@ dns__rbtdb_attachnode(dns_db_t *db, dns_dbnode_t *source, } void -dns__rbtdb_detachnode(dns_db_t *db, dns_dbnode_t **targetp DNS__DB_FLARG) { - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; +dns__qpdb_detachnode(dns_db_t *db, dns_dbnode_t **targetp DNS__DB_FLARG) { + dns_qpdb_t *qpdb = (dns_qpdb_t *)db; dns_rbtnode_t *node = NULL; bool want_free = false; bool inactive = false; @@ -2212,16 +2206,16 @@ dns__rbtdb_detachnode(dns_db_t *db, dns_dbnode_t **targetp DNS__DB_FLARG) { isc_rwlocktype_t nlocktype = isc_rwlocktype_none; isc_rwlocktype_t tlocktype = isc_rwlocktype_none; - REQUIRE(VALID_RBTDB(rbtdb)); + REQUIRE(VALID_QPDB(qpdb)); REQUIRE(targetp != NULL && *targetp != NULL); node = (dns_rbtnode_t *)(*targetp); - nodelock = &rbtdb->node_locks[node->locknum]; + nodelock = &qpdb->node_locks[node->locknum]; NODE_RDLOCK(&nodelock->lock, &nlocktype); - if (dns__rbtdb_decref(rbtdb, node, 0, &nlocktype, &tlocktype, true, - false DNS__DB_FLARG_PASS)) + if (dns__qpdb_decref(qpdb, node, 0, &nlocktype, &tlocktype, true, + false DNS__DB_FLARG_PASS)) { if (isc_refcount_current(&nodelock->references) == 0 && nodelock->exiting) @@ -2236,94 +2230,94 @@ dns__rbtdb_detachnode(dns_db_t *db, dns_dbnode_t **targetp DNS__DB_FLARG) { *targetp = NULL; if (inactive) { - RWLOCK(&rbtdb->lock, isc_rwlocktype_write); - rbtdb->active--; - if (rbtdb->active == 0) { + RWLOCK(&qpdb->lock, isc_rwlocktype_write); + qpdb->active--; + if (qpdb->active == 0) { want_free = true; } - RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write); + RWUNLOCK(&qpdb->lock, isc_rwlocktype_write); if (want_free) { char buf[DNS_NAME_FORMATSIZE]; - if (dns_name_dynamic(&rbtdb->common.origin)) { - dns_name_format(&rbtdb->common.origin, buf, + if (dns_name_dynamic(&qpdb->common.origin)) { + dns_name_format(&qpdb->common.origin, buf, sizeof(buf)); } else { strlcpy(buf, "", sizeof(buf)); } isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_CACHE, ISC_LOG_DEBUG(1), - "calling free_rbtdb(%s)", buf); - free_rbtdb(rbtdb, true); + "calling free_qpdb(%s)", buf); + free_qpdb(qpdb, true); } } } isc_result_t -dns__rbtdb_createiterator(dns_db_t *db, unsigned int options, - dns_dbiterator_t **iteratorp) { - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; - rbtdb_dbiterator_t *rbtdbiter = NULL; +dns__qpdb_createiterator(dns_db_t *db, unsigned int options, + dns_dbiterator_t **iteratorp) { + dns_qpdb_t *qpdb = (dns_qpdb_t *)db; + qpdb_dbiterator_t *qpdbiter = NULL; - REQUIRE(VALID_RBTDB(rbtdb)); + REQUIRE(VALID_QPDB(qpdb)); REQUIRE((options & (DNS_DB_NSEC3ONLY | DNS_DB_NONSEC3)) != (DNS_DB_NSEC3ONLY | DNS_DB_NONSEC3)); - rbtdbiter = isc_mem_get(rbtdb->common.mctx, sizeof(*rbtdbiter)); + qpdbiter = isc_mem_get(qpdb->common.mctx, sizeof(*qpdbiter)); - rbtdbiter->common.methods = &dbiterator_methods; - rbtdbiter->common.db = NULL; - dns_db_attach(db, &rbtdbiter->common.db); - rbtdbiter->common.relative_names = ((options & DNS_DB_RELATIVENAMES) != - 0); - rbtdbiter->common.magic = DNS_DBITERATOR_MAGIC; - rbtdbiter->paused = true; - rbtdbiter->tree_locked = isc_rwlocktype_none; - rbtdbiter->result = ISC_R_SUCCESS; - dns_fixedname_init(&rbtdbiter->name); - dns_fixedname_init(&rbtdbiter->origin); - rbtdbiter->node = NULL; + qpdbiter->common.methods = &dbiterator_methods; + qpdbiter->common.db = NULL; + dns_db_attach(db, &qpdbiter->common.db); + qpdbiter->common.relative_names = ((options & DNS_DB_RELATIVENAMES) != + 0); + qpdbiter->common.magic = DNS_DBITERATOR_MAGIC; + qpdbiter->paused = true; + qpdbiter->tree_locked = isc_rwlocktype_none; + qpdbiter->result = ISC_R_SUCCESS; + dns_fixedname_init(&qpdbiter->name); + dns_fixedname_init(&qpdbiter->origin); + qpdbiter->node = NULL; if ((options & DNS_DB_NSEC3ONLY) != 0) { - rbtdbiter->nsec3mode = nsec3only; + qpdbiter->nsec3mode = nsec3only; } else if ((options & DNS_DB_NONSEC3) != 0) { - rbtdbiter->nsec3mode = nonsec3; + qpdbiter->nsec3mode = nonsec3; } else { - rbtdbiter->nsec3mode = full; + qpdbiter->nsec3mode = full; } - dns_rbtnodechain_init(&rbtdbiter->chain); - dns_rbtnodechain_init(&rbtdbiter->nsec3chain); - if (rbtdbiter->nsec3mode == nsec3only) { - rbtdbiter->current = &rbtdbiter->nsec3chain; + dns_rbtnodechain_init(&qpdbiter->chain); + dns_rbtnodechain_init(&qpdbiter->nsec3chain); + if (qpdbiter->nsec3mode == nsec3only) { + qpdbiter->current = &qpdbiter->nsec3chain; } else { - rbtdbiter->current = &rbtdbiter->chain; + qpdbiter->current = &qpdbiter->chain; } - *iteratorp = (dns_dbiterator_t *)rbtdbiter; + *iteratorp = (dns_dbiterator_t *)qpdbiter; return (ISC_R_SUCCESS); } isc_result_t -dns__rbtdb_allrdatasets(dns_db_t *db, dns_dbnode_t *node, - dns_dbversion_t *version, unsigned int options, - isc_stdtime_t now, - dns_rdatasetiter_t **iteratorp DNS__DB_FLARG) { - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; +dns__qpdb_allrdatasets(dns_db_t *db, dns_dbnode_t *node, + dns_dbversion_t *version, unsigned int options, + isc_stdtime_t now, + dns_rdatasetiter_t **iteratorp DNS__DB_FLARG) { + dns_qpdb_t *qpdb = (dns_qpdb_t *)db; dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node; - dns_rbtdb_version_t *rbtversion = version; - rbtdb_rdatasetiter_t *iterator = NULL; + dns_qpdb_version_t *rbtversion = version; + qpdb_rdatasetiter_t *iterator = NULL; uint_fast32_t refs; - REQUIRE(VALID_RBTDB(rbtdb)); + REQUIRE(VALID_QPDB(qpdb)); - iterator = isc_mem_get(rbtdb->common.mctx, sizeof(*iterator)); + iterator = isc_mem_get(qpdb->common.mctx, sizeof(*iterator)); if ((db->attributes & DNS_DBATTR_CACHE) == 0) { now = 0; if (rbtversion == NULL) { - dns__rbtdb_currentversion( + dns__qpdb_currentversion( db, (dns_dbversion_t **)(void *)(&rbtversion)); } else { - INSIST(rbtversion->rbtdb == rbtdb); + INSIST(rbtversion->qpdb == qpdb); (void)isc_refcount_increment(&rbtversion->references); } @@ -2456,7 +2450,7 @@ recordsize(dns_slabheader_t *header, unsigned int namelen) { } static void -update_recordsandxfrsize(bool add, dns_rbtdb_version_t *rbtversion, +update_recordsandxfrsize(bool add, dns_qpdb_version_t *rbtversion, dns_slabheader_t *header, unsigned int namelen) { unsigned char *hdr = (unsigned char *)header; size_t hdrsize = sizeof(*header); @@ -2473,11 +2467,11 @@ update_recordsandxfrsize(bool add, dns_rbtdb_version_t *rbtversion, } isc_result_t -dns__rbtdb_add(dns_rbtdb_t *rbtdb, dns_rbtnode_t *rbtnode, - const dns_name_t *nodename, dns_rbtdb_version_t *rbtversion, - dns_slabheader_t *newheader, unsigned int options, bool loading, - dns_rdataset_t *addedrdataset, isc_stdtime_t now DNS__DB_FLARG) { - rbtdb_changed_t *changed = NULL; +dns__qpdb_add(dns_qpdb_t *qpdb, dns_rbtnode_t *rbtnode, + const dns_name_t *nodename, dns_qpdb_version_t *rbtversion, + dns_slabheader_t *newheader, unsigned int options, bool loading, + dns_rdataset_t *addedrdataset, isc_stdtime_t now DNS__DB_FLARG) { + qpdb_changed_t *changed = NULL; dns_slabheader_t *topheader = NULL, *topheader_prev = NULL; dns_slabheader_t *header = NULL, *sigheader = NULL; dns_slabheader_t *prioheader = NULL; @@ -2589,8 +2583,8 @@ dns__rbtdb_add(dns_rbtdb_t *rbtdb, dns_rbtnode_t *rbtnode, */ dns_slabheader_destroy(&newheader); if (addedrdataset != NULL) { - dns__rbtdb_bindrdataset( - rbtdb, rbtnode, + dns__qpdb_bindrdataset( + qpdb, rbtnode, topheader, now, isc_rwlocktype_write, addedrdataset @@ -2657,8 +2651,8 @@ find_header: { dns_slabheader_destroy(&newheader); if (addedrdataset != NULL) { - dns__rbtdb_bindrdataset( - rbtdb, rbtnode, header, now, + dns__qpdb_bindrdataset( + qpdb, rbtnode, header, now, isc_rwlocktype_write, addedrdataset DNS__DB_FLARG_PASS); } @@ -2701,8 +2695,7 @@ find_header: (unsigned char *)header, (unsigned char *)newheader, (unsigned int)(sizeof(*newheader)), - rbtdb->common.mctx, - rbtdb->common.rdclass, + qpdb->common.mctx, qpdb->common.rdclass, (dns_rdatatype_t)header->type, flags, &merged); } @@ -2718,7 +2711,7 @@ find_header: dns_slabheader_destroy(&newheader); newheader = (dns_slabheader_t *)merged; dns_slabheader_reset(newheader, - (dns_db_t *)rbtdb, + (dns_db_t *)qpdb, (dns_dbnode_t *)rbtnode); dns_slabheader_copycase(newheader, header); if (loading && RESIGN(newheader) && @@ -2742,13 +2735,13 @@ find_header: * special to be done w.r.t stale data; it gets replaced * normally further down. */ - if (IS_CACHE(rbtdb) && ACTIVE(header, now) && + if (IS_CACHE(qpdb) && ACTIVE(header, now) && header->type == dns_rdatatype_ns && !header_nx && !newheader_nx && header->trust >= newheader->trust && dns_rdataslab_equalx((unsigned char *)header, (unsigned char *)newheader, (unsigned int)(sizeof(*newheader)), - rbtdb->common.rdclass, + qpdb->common.rdclass, (dns_rdatatype_t)header->type)) { /* @@ -2756,17 +2749,17 @@ find_header: * older one. */ if (header->ttl > newheader->ttl) { - dns__rbtdb_setttl(header, newheader->ttl); + dns__qpdb_setttl(header, newheader->ttl); } if (header->last_used != now) { ISC_LIST_UNLINK( - rbtdb->lru[RBTDB_HEADERNODE(header) - ->locknum], + qpdb->lru[QPDB_HEADERNODE(header) + ->locknum], header, link); header->last_used = now; ISC_LIST_PREPEND( - rbtdb->lru[RBTDB_HEADERNODE(header) - ->locknum], + qpdb->lru[QPDB_HEADERNODE(header) + ->locknum], header, link); } if (header->noqname == NULL && @@ -2783,8 +2776,8 @@ find_header: } dns_slabheader_destroy(&newheader); if (addedrdataset != NULL) { - dns__rbtdb_bindrdataset( - rbtdb, rbtnode, header, now, + dns__qpdb_bindrdataset( + qpdb, rbtnode, header, now, isc_rwlocktype_write, addedrdataset DNS__DB_FLARG_PASS); } @@ -2796,7 +2789,7 @@ find_header: * to be no more than the current NS RRset's TTL. This * ensures the delegations that are withdrawn are honoured. */ - if (IS_CACHE(rbtdb) && ACTIVE(header, now) && + if (IS_CACHE(qpdb) && ACTIVE(header, now) && header->type == dns_rdatatype_ns && !header_nx && !newheader_nx && header->trust <= newheader->trust) { @@ -2804,7 +2797,7 @@ find_header: newheader->ttl = header->ttl; } } - if (IS_CACHE(rbtdb) && ACTIVE(header, now) && + if (IS_CACHE(qpdb) && ACTIVE(header, now) && (options & DNS_DBADD_PREFETCH) == 0 && (header->type == dns_rdatatype_a || header->type == dns_rdatatype_aaaa || @@ -2821,17 +2814,17 @@ find_header: * older one. */ if (header->ttl > newheader->ttl) { - dns__rbtdb_setttl(header, newheader->ttl); + dns__qpdb_setttl(header, newheader->ttl); } if (header->last_used != now) { ISC_LIST_UNLINK( - rbtdb->lru[RBTDB_HEADERNODE(header) - ->locknum], + qpdb->lru[QPDB_HEADERNODE(header) + ->locknum], header, link); header->last_used = now; ISC_LIST_PREPEND( - rbtdb->lru[RBTDB_HEADERNODE(header) - ->locknum], + qpdb->lru[QPDB_HEADERNODE(header) + ->locknum], header, link); } if (header->noqname == NULL && @@ -2848,8 +2841,8 @@ find_header: } dns_slabheader_destroy(&newheader); if (addedrdataset != NULL) { - dns__rbtdb_bindrdataset( - rbtdb, rbtnode, header, now, + dns__qpdb_bindrdataset( + qpdb, rbtnode, header, now, isc_rwlocktype_write, addedrdataset DNS__DB_FLARG_PASS); } @@ -2859,23 +2852,22 @@ find_header: rbtversion->serial >= topheader->serial); if (loading) { newheader->down = NULL; - idx = RBTDB_HEADERNODE(newheader)->locknum; - if (IS_CACHE(rbtdb)) { + idx = QPDB_HEADERNODE(newheader)->locknum; + if (IS_CACHE(qpdb)) { if (ZEROTTL(newheader)) { - newheader->last_used = - rbtdb->last_used + 1; - ISC_LIST_APPEND(rbtdb->lru[idx], + newheader->last_used = qpdb->last_used + + 1; + ISC_LIST_APPEND(qpdb->lru[idx], newheader, link); } else { - ISC_LIST_PREPEND(rbtdb->lru[idx], + ISC_LIST_PREPEND(qpdb->lru[idx], newheader, link); } - INSIST(rbtdb->heaps != NULL); - isc_heap_insert(rbtdb->heaps[idx], newheader); - newheader->heap = rbtdb->heaps[idx]; + INSIST(qpdb->heaps != NULL); + isc_heap_insert(qpdb->heaps[idx], newheader); + newheader->heap = qpdb->heaps[idx]; } else if (RESIGN(newheader)) { - dns__zonerbt_resigninsert(rbtdb, idx, - newheader); + dns__qpzone_resigninsert(qpdb, idx, newheader); /* * Don't call resigndelete, we don't need * to reverse the delete. The free_slabheader @@ -2902,25 +2894,24 @@ find_header: } dns_slabheader_destroy(&header); } else { - idx = RBTDB_HEADERNODE(newheader)->locknum; - if (IS_CACHE(rbtdb)) { - INSIST(rbtdb->heaps != NULL); - isc_heap_insert(rbtdb->heaps[idx], newheader); - newheader->heap = rbtdb->heaps[idx]; + idx = QPDB_HEADERNODE(newheader)->locknum; + if (IS_CACHE(qpdb)) { + INSIST(qpdb->heaps != NULL); + isc_heap_insert(qpdb->heaps[idx], newheader); + newheader->heap = qpdb->heaps[idx]; if (ZEROTTL(newheader)) { - newheader->last_used = - rbtdb->last_used + 1; - ISC_LIST_APPEND(rbtdb->lru[idx], + newheader->last_used = qpdb->last_used + + 1; + ISC_LIST_APPEND(qpdb->lru[idx], newheader, link); } else { - ISC_LIST_PREPEND(rbtdb->lru[idx], + ISC_LIST_PREPEND(qpdb->lru[idx], newheader, link); } } else if (RESIGN(newheader)) { - dns__zonerbt_resigninsert(rbtdb, idx, - newheader); - dns__zonerbt_resigndelete( - rbtdb, rbtversion, + dns__qpzone_resigninsert(qpdb, idx, newheader); + dns__qpzone_resigndelete( + qpdb, rbtversion, header DNS__DB_FLARG_PASS); } if (topheader_prev != NULL) { @@ -2961,21 +2952,21 @@ find_header: return (DNS_R_UNCHANGED); } - idx = RBTDB_HEADERNODE(newheader)->locknum; - if (IS_CACHE(rbtdb)) { - isc_heap_insert(rbtdb->heaps[idx], newheader); - newheader->heap = rbtdb->heaps[idx]; + idx = QPDB_HEADERNODE(newheader)->locknum; + if (IS_CACHE(qpdb)) { + isc_heap_insert(qpdb->heaps[idx], newheader); + newheader->heap = qpdb->heaps[idx]; if (ZEROTTL(newheader)) { - ISC_LIST_APPEND(rbtdb->lru[idx], newheader, + ISC_LIST_APPEND(qpdb->lru[idx], newheader, link); } else { - ISC_LIST_PREPEND(rbtdb->lru[idx], newheader, + ISC_LIST_PREPEND(qpdb->lru[idx], newheader, link); } } else if (RESIGN(newheader)) { - dns__zonerbt_resigninsert(rbtdb, idx, newheader); - dns__zonerbt_resigndelete(rbtdb, rbtversion, - header DNS__DB_FLARG_PASS); + dns__qpzone_resigninsert(qpdb, idx, newheader); + dns__qpzone_resigndelete(qpdb, rbtversion, + header DNS__DB_FLARG_PASS); } if (topheader != NULL) { @@ -3039,17 +3030,17 @@ find_header: } if (addedrdataset != NULL) { - dns__rbtdb_bindrdataset(rbtdb, rbtnode, newheader, now, - isc_rwlocktype_write, - addedrdataset DNS__DB_FLARG_PASS); + dns__qpdb_bindrdataset(qpdb, rbtnode, newheader, now, + isc_rwlocktype_write, + addedrdataset DNS__DB_FLARG_PASS); } return (ISC_R_SUCCESS); } static bool -delegating_type(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, dns_typepair_t type) { - if (IS_CACHE(rbtdb)) { +delegating_type(dns_qpdb_t *qpdb, dns_rbtnode_t *node, dns_typepair_t type) { + if (IS_CACHE(qpdb)) { if (type == dns_rdatatype_dname) { return (true); } else { @@ -3057,7 +3048,7 @@ delegating_type(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, dns_typepair_t type) { } } else if (type == dns_rdatatype_dname || (type == dns_rdatatype_ns && - (node != rbtdb->origin_node || IS_STUB(rbtdb)))) + (node != qpdb->origin_node || IS_STUB(qpdb)))) { return (true); } @@ -3142,18 +3133,18 @@ cleanup: } static void -expire_ttl_headers(dns_rbtdb_t *rbtdb, unsigned int locknum, +expire_ttl_headers(dns_qpdb_t *qpdb, unsigned int locknum, isc_rwlocktype_t *tlocktypep, isc_stdtime_t now, bool cache_is_overmem DNS__DB_FLARG); isc_result_t -dns__rbtdb_addrdataset(dns_db_t *db, dns_dbnode_t *node, - dns_dbversion_t *version, isc_stdtime_t now, - dns_rdataset_t *rdataset, unsigned int options, - dns_rdataset_t *addedrdataset DNS__DB_FLARG) { - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; +dns__qpdb_addrdataset(dns_db_t *db, dns_dbnode_t *node, + dns_dbversion_t *version, isc_stdtime_t now, + dns_rdataset_t *rdataset, unsigned int options, + dns_rdataset_t *addedrdataset DNS__DB_FLARG) { + dns_qpdb_t *qpdb = (dns_qpdb_t *)db; dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node; - dns_rbtdb_version_t *rbtversion = version; + dns_qpdb_version_t *rbtversion = version; isc_region_t region; dns_slabheader_t *newheader = NULL; isc_result_t result; @@ -3165,26 +3156,26 @@ dns__rbtdb_addrdataset(dns_db_t *db, dns_dbnode_t *node, dns_fixedname_t fixed; dns_name_t *name = NULL; - REQUIRE(VALID_RBTDB(rbtdb)); - INSIST(rbtversion == NULL || rbtversion->rbtdb == rbtdb); + REQUIRE(VALID_QPDB(qpdb)); + INSIST(rbtversion == NULL || rbtversion->qpdb == qpdb); - if (!IS_CACHE(rbtdb)) { + if (!IS_CACHE(qpdb)) { /* * SOA records are only allowed at top of zone. */ if (rdataset->type == dns_rdatatype_soa && - node != rbtdb->origin_node) + node != qpdb->origin_node) { return (DNS_R_NOTZONETOP); } - TREE_RDLOCK(&rbtdb->tree_lock, &tlocktype); + TREE_RDLOCK(&qpdb->tree_lock, &tlocktype); REQUIRE(((rbtnode->nsec == DNS_DB_NSEC_NSEC3 && (rdataset->type == dns_rdatatype_nsec3 || rdataset->covers == dns_rdatatype_nsec3)) || (rbtnode->nsec != DNS_DB_NSEC_NSEC3 && rdataset->type != dns_rdatatype_nsec3 && rdataset->covers != dns_rdatatype_nsec3))); - TREE_UNLOCK(&rbtdb->tree_lock, &tlocktype); + TREE_UNLOCK(&qpdb->tree_lock, &tlocktype); } if (rbtversion == NULL) { @@ -3195,14 +3186,14 @@ dns__rbtdb_addrdataset(dns_db_t *db, dns_dbnode_t *node, now = 0; } - result = dns_rdataslab_fromrdataset(rdataset, rbtdb->common.mctx, + result = dns_rdataslab_fromrdataset(rdataset, qpdb->common.mctx, ®ion, sizeof(dns_slabheader_t)); if (result != ISC_R_SUCCESS) { return (result); } name = dns_fixedname_initname(&fixed); - dns__rbtdb_nodefullname(db, node, name); + dns__qpdb_nodefullname(db, node, name); dns_rdataset_getownercase(rdataset, name); newheader = (dns_slabheader_t *)region.base; @@ -3214,7 +3205,7 @@ dns__rbtdb_addrdataset(dns_db_t *db, dns_dbnode_t *node, }; dns_slabheader_reset(newheader, db, node); - dns__rbtdb_setttl(newheader, rdataset->ttl + now); + dns__qpdb_setttl(newheader, rdataset->ttl + now); if (rdataset->ttl == 0U) { DNS_SLABHEADER_SETATTR(newheader, DNS_SLABHEADERATTR_ZEROTTL); } @@ -3252,7 +3243,7 @@ dns__rbtdb_addrdataset(dns_db_t *db, dns_dbnode_t *node, DNS_SLABHEADERATTR_OPTOUT); } if ((rdataset->attributes & DNS_RDATASETATTR_NOQNAME) != 0) { - result = addnoqname(rbtdb->common.mctx, newheader, + result = addnoqname(qpdb->common.mctx, newheader, rdataset); if (result != ISC_R_SUCCESS) { dns_slabheader_destroy(&newheader); @@ -3260,7 +3251,7 @@ dns__rbtdb_addrdataset(dns_db_t *db, dns_dbnode_t *node, } } if ((rdataset->attributes & DNS_RDATASETATTR_CLOSEST) != 0) { - result = addclosest(rbtdb->common.mctx, newheader, + result = addclosest(qpdb->common.mctx, newheader, rdataset); if (result != ISC_R_SUCCESS) { dns_slabheader_destroy(&newheader); @@ -3274,7 +3265,7 @@ dns__rbtdb_addrdataset(dns_db_t *db, dns_dbnode_t *node, * just DNAME for the cache), then we need to set the callback bit * on the node. */ - if (delegating_type(rbtdb, rbtnode, rdataset->type)) { + if (delegating_type(qpdb, rbtnode, rdataset->type)) { delegating = true; } else { delegating = false; @@ -3283,7 +3274,7 @@ dns__rbtdb_addrdataset(dns_db_t *db, dns_dbnode_t *node, /* * Add to the auxiliary NSEC tree if we're adding an NSEC record. */ - TREE_RDLOCK(&rbtdb->tree_lock, &tlocktype); + TREE_RDLOCK(&qpdb->tree_lock, &tlocktype); if (rbtnode->nsec != DNS_DB_NSEC_HAS_NSEC && rdataset->type == dns_rdatatype_nsec) { @@ -3291,7 +3282,7 @@ dns__rbtdb_addrdataset(dns_db_t *db, dns_dbnode_t *node, } else { newnsec = false; } - TREE_UNLOCK(&rbtdb->tree_lock, &tlocktype); + TREE_UNLOCK(&qpdb->tree_lock, &tlocktype); /* * If we're adding a delegation type, adding to the auxiliary NSEC @@ -3300,34 +3291,34 @@ dns__rbtdb_addrdataset(dns_db_t *db, dns_dbnode_t *node, * not necessarily have to be acquired but it will help purge * ancient entries more effectively. */ - if (IS_CACHE(rbtdb) && isc_mem_isovermem(rbtdb->common.mctx)) { + if (IS_CACHE(qpdb) && isc_mem_isovermem(qpdb->common.mctx)) { cache_is_overmem = true; } if (delegating || newnsec || cache_is_overmem) { - TREE_WRLOCK(&rbtdb->tree_lock, &tlocktype); + TREE_WRLOCK(&qpdb->tree_lock, &tlocktype); } if (cache_is_overmem) { - dns__cacherbt_overmem(rbtdb, newheader, - &tlocktype DNS__DB_FLARG_PASS); + dns__qpcache_overmem(qpdb, newheader, + &tlocktype DNS__DB_FLARG_PASS); } - NODE_WRLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype); + NODE_WRLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype); - if (rbtdb->rrsetstats != NULL) { + if (qpdb->rrsetstats != NULL) { DNS_SLABHEADER_SETATTR(newheader, DNS_SLABHEADERATTR_STATCOUNT); - update_rrsetstats(rbtdb->rrsetstats, newheader->type, + update_rrsetstats(qpdb->rrsetstats, newheader->type, atomic_load_acquire(&newheader->attributes), true); } - if (IS_CACHE(rbtdb)) { + if (IS_CACHE(qpdb)) { if (tlocktype == isc_rwlocktype_write) { - cleanup_dead_nodes(rbtdb, + cleanup_dead_nodes(qpdb, rbtnode->locknum DNS__DB_FLARG_PASS); } - expire_ttl_headers(rbtdb, rbtnode->locknum, &tlocktype, now, + expire_ttl_headers(qpdb, rbtnode->locknum, &tlocktype, now, cache_is_overmem DNS__DB_FLARG_PASS); /* @@ -3338,7 +3329,7 @@ dns__rbtdb_addrdataset(dns_db_t *db, dns_dbnode_t *node, if (tlocktype == isc_rwlocktype_write && !delegating && !newnsec) { - TREE_UNLOCK(&rbtdb->tree_lock, &tlocktype); + TREE_UNLOCK(&qpdb->tree_lock, &tlocktype); } } @@ -3346,7 +3337,7 @@ dns__rbtdb_addrdataset(dns_db_t *db, dns_dbnode_t *node, if (newnsec) { dns_rbtnode_t *nsecnode = NULL; - result = dns_rbt_addnode(rbtdb->nsec, name, &nsecnode); + result = dns_rbt_addnode(qpdb->nsec, name, &nsecnode); if (result == ISC_R_SUCCESS) { nsecnode->nsec = DNS_DB_NSEC_NSEC; rbtnode->nsec = DNS_DB_NSEC_HAS_NSEC; @@ -3357,40 +3348,40 @@ dns__rbtdb_addrdataset(dns_db_t *db, dns_dbnode_t *node, } if (result == ISC_R_SUCCESS) { - result = dns__rbtdb_add(rbtdb, rbtnode, name, rbtversion, - newheader, options, false, - addedrdataset, now DNS__DB_FLARG_PASS); + result = dns__qpdb_add(qpdb, rbtnode, name, rbtversion, + newheader, options, false, addedrdataset, + now DNS__DB_FLARG_PASS); } if (result == ISC_R_SUCCESS && delegating) { rbtnode->find_callback = 1; } - NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype); + NODE_UNLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype); if (tlocktype != isc_rwlocktype_none) { - TREE_UNLOCK(&rbtdb->tree_lock, &tlocktype); + TREE_UNLOCK(&qpdb->tree_lock, &tlocktype); } INSIST(tlocktype == isc_rwlocktype_none); /* * Update the zone's secure status. If version is non-NULL - * this is deferred until dns__rbtdb_closeversion() is called. + * this is deferred until dns__qpdb_closeversion() is called. */ - if (result == ISC_R_SUCCESS && version == NULL && !IS_CACHE(rbtdb)) { - dns__rbtdb_setsecure(db, version, rbtdb->origin_node); + if (result == ISC_R_SUCCESS && version == NULL && !IS_CACHE(qpdb)) { + dns__qpdb_setsecure(db, version, qpdb->origin_node); } return (result); } isc_result_t -dns__rbtdb_subtractrdataset(dns_db_t *db, dns_dbnode_t *node, - dns_dbversion_t *version, dns_rdataset_t *rdataset, - unsigned int options, - dns_rdataset_t *newrdataset DNS__DB_FLARG) { - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; +dns__qpdb_subtractrdataset(dns_db_t *db, dns_dbnode_t *node, + dns_dbversion_t *version, dns_rdataset_t *rdataset, + unsigned int options, + dns_rdataset_t *newrdataset DNS__DB_FLARG) { + dns_qpdb_t *qpdb = (dns_qpdb_t *)db; dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node; - dns_rbtdb_version_t *rbtversion = version; + dns_qpdb_version_t *rbtversion = version; dns_fixedname_t fname; dns_name_t *nodename = dns_fixedname_initname(&fname); dns_slabheader_t *topheader = NULL, *topheader_prev = NULL; @@ -3398,27 +3389,27 @@ dns__rbtdb_subtractrdataset(dns_db_t *db, dns_dbnode_t *node, unsigned char *subresult = NULL; isc_region_t region; isc_result_t result; - rbtdb_changed_t *changed = NULL; + qpdb_changed_t *changed = NULL; isc_rwlocktype_t tlocktype = isc_rwlocktype_none; isc_rwlocktype_t nlocktype = isc_rwlocktype_none; - REQUIRE(VALID_RBTDB(rbtdb)); - REQUIRE(rbtversion != NULL && rbtversion->rbtdb == rbtdb); + REQUIRE(VALID_QPDB(qpdb)); + REQUIRE(rbtversion != NULL && rbtversion->qpdb == qpdb); - if (!IS_CACHE(rbtdb)) { - TREE_RDLOCK(&rbtdb->tree_lock, &tlocktype); + if (!IS_CACHE(qpdb)) { + TREE_RDLOCK(&qpdb->tree_lock, &tlocktype); REQUIRE(((rbtnode->nsec == DNS_DB_NSEC_NSEC3 && (rdataset->type == dns_rdatatype_nsec3 || rdataset->covers == dns_rdatatype_nsec3)) || (rbtnode->nsec != DNS_DB_NSEC_NSEC3 && rdataset->type != dns_rdatatype_nsec3 && rdataset->covers != dns_rdatatype_nsec3))); - TREE_UNLOCK(&rbtdb->tree_lock, &tlocktype); + TREE_UNLOCK(&qpdb->tree_lock, &tlocktype); } - dns__rbtdb_nodefullname(db, node, nodename); + dns__qpdb_nodefullname(db, node, nodename); - result = dns_rdataslab_fromrdataset(rdataset, rbtdb->common.mctx, + result = dns_rdataslab_fromrdataset(rdataset, qpdb->common.mctx, ®ion, sizeof(dns_slabheader_t)); if (result != ISC_R_SUCCESS) { return (result); @@ -3426,7 +3417,7 @@ dns__rbtdb_subtractrdataset(dns_db_t *db, dns_dbnode_t *node, newheader = (dns_slabheader_t *)region.base; dns_slabheader_reset(newheader, db, node); - dns__rbtdb_setttl(newheader, rdataset->ttl); + dns__qpdb_setttl(newheader, rdataset->ttl); newheader->type = DNS_TYPEPAIR_VALUE(rdataset->type, rdataset->covers); atomic_init(&newheader->attributes, 0); newheader->serial = rbtversion->serial; @@ -3437,7 +3428,7 @@ dns__rbtdb_subtractrdataset(dns_db_t *db, dns_dbnode_t *node, atomic_fetch_add_relaxed(&init_count, 1)); newheader->last_used = 0; newheader->node = rbtnode; - newheader->db = (dns_db_t *)rbtdb; + newheader->db = (dns_db_t *)qpdb; if ((rdataset->attributes & DNS_RDATASETATTR_RESIGN) != 0) { DNS_SLABHEADER_SETATTR(newheader, DNS_SLABHEADERATTR_RESIGN); newheader->resign = @@ -3449,12 +3440,12 @@ dns__rbtdb_subtractrdataset(dns_db_t *db, dns_dbnode_t *node, newheader->resign_lsb = 0; } - NODE_WRLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype); + NODE_WRLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype); changed = add_changed(newheader, rbtversion DNS__DB_FLARG_PASS); if (changed == NULL) { dns_slabheader_destroy(&newheader); - NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, + NODE_UNLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype); return (ISC_R_NOMEMORY); } @@ -3491,7 +3482,7 @@ dns__rbtdb_subtractrdataset(dns_db_t *db, dns_dbnode_t *node, (unsigned char *)header, (unsigned char *)newheader, (unsigned int)(sizeof(*newheader)), - rbtdb->common.mctx, rbtdb->common.rdclass, + qpdb->common.mctx, qpdb->common.rdclass, (dns_rdatatype_t)header->type, flags, &subresult); } @@ -3505,8 +3496,8 @@ dns__rbtdb_subtractrdataset(dns_db_t *db, dns_dbnode_t *node, newheader, DNS_SLABHEADERATTR_RESIGN); newheader->resign = header->resign; newheader->resign_lsb = header->resign_lsb; - dns__zonerbt_resigninsert( - rbtdb, rbtnode->locknum, newheader); + dns__qpzone_resigninsert(qpdb, rbtnode->locknum, + newheader); } /* * We have to set the serial since the rdataslab @@ -3527,9 +3518,9 @@ dns__rbtdb_subtractrdataset(dns_db_t *db, dns_dbnode_t *node, * add a nonexistent header instead. */ dns_slabheader_destroy(&newheader); - newheader = dns_slabheader_new((dns_db_t *)rbtdb, + newheader = dns_slabheader_new((dns_db_t *)qpdb, (dns_dbnode_t *)rbtnode); - dns__rbtdb_setttl(newheader, 0); + dns__qpdb_setttl(newheader, 0); newheader->type = topheader->type; atomic_init(&newheader->attributes, DNS_SLABHEADERATTR_NONEXISTENT); @@ -3556,8 +3547,8 @@ dns__rbtdb_subtractrdataset(dns_db_t *db, dns_dbnode_t *node, topheader->next = newheader; rbtnode->dirty = 1; changed->dirty = true; - dns__zonerbt_resigndelete(rbtdb, rbtversion, - header DNS__DB_FLARG_PASS); + dns__qpzone_resigndelete(qpdb, rbtversion, + header DNS__DB_FLARG_PASS); } else { /* * The rdataset doesn't exist, so we don't need to do anything @@ -3572,51 +3563,51 @@ dns__rbtdb_subtractrdataset(dns_db_t *db, dns_dbnode_t *node, } if (result == ISC_R_SUCCESS && newrdataset != NULL) { - dns__rbtdb_bindrdataset(rbtdb, rbtnode, newheader, 0, - isc_rwlocktype_write, - newrdataset DNS__DB_FLARG_PASS); + dns__qpdb_bindrdataset(qpdb, rbtnode, newheader, 0, + isc_rwlocktype_write, + newrdataset DNS__DB_FLARG_PASS); } if (result == DNS_R_NXRRSET && newrdataset != NULL && (options & DNS_DBSUB_WANTOLD) != 0) { - dns__rbtdb_bindrdataset(rbtdb, rbtnode, header, 0, - isc_rwlocktype_write, - newrdataset DNS__DB_FLARG_PASS); + dns__qpdb_bindrdataset(qpdb, rbtnode, header, 0, + isc_rwlocktype_write, + newrdataset DNS__DB_FLARG_PASS); } unlock: - NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype); + NODE_UNLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype); /* * Update the zone's secure status. If version is non-NULL - * this is deferred until dns__rbtdb_closeversion() is called. + * this is deferred until dns__qpdb_closeversion() is called. */ - if (result == ISC_R_SUCCESS && version == NULL && !IS_CACHE(rbtdb)) { - RWLOCK(&rbtdb->lock, isc_rwlocktype_read); - version = rbtdb->current_version; - RWUNLOCK(&rbtdb->lock, isc_rwlocktype_read); - dns__rbtdb_setsecure(db, version, rbtdb->origin_node); + if (result == ISC_R_SUCCESS && version == NULL && !IS_CACHE(qpdb)) { + RWLOCK(&qpdb->lock, isc_rwlocktype_read); + version = qpdb->current_version; + RWUNLOCK(&qpdb->lock, isc_rwlocktype_read); + dns__qpdb_setsecure(db, version, qpdb->origin_node); } return (result); } isc_result_t -dns__rbtdb_deleterdataset(dns_db_t *db, dns_dbnode_t *node, - dns_dbversion_t *version, dns_rdatatype_t type, - dns_rdatatype_t covers DNS__DB_FLARG) { - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; +dns__qpdb_deleterdataset(dns_db_t *db, dns_dbnode_t *node, + dns_dbversion_t *version, dns_rdatatype_t type, + dns_rdatatype_t covers DNS__DB_FLARG) { + dns_qpdb_t *qpdb = (dns_qpdb_t *)db; dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node; - dns_rbtdb_version_t *rbtversion = version; + dns_qpdb_version_t *rbtversion = version; dns_fixedname_t fname; dns_name_t *nodename = dns_fixedname_initname(&fname); isc_result_t result; dns_slabheader_t *newheader = NULL; isc_rwlocktype_t nlocktype = isc_rwlocktype_none; - REQUIRE(VALID_RBTDB(rbtdb)); - INSIST(rbtversion == NULL || rbtversion->rbtdb == rbtdb); + REQUIRE(VALID_QPDB(qpdb)); + INSIST(rbtversion == NULL || rbtversion->qpdb == qpdb); if (type == dns_rdatatype_any) { return (ISC_R_NOTIMPLEMENTED); @@ -3627,94 +3618,94 @@ dns__rbtdb_deleterdataset(dns_db_t *db, dns_dbnode_t *node, newheader = dns_slabheader_new(db, node); newheader->type = DNS_TYPEPAIR_VALUE(type, covers); - dns__rbtdb_setttl(newheader, 0); + dns__qpdb_setttl(newheader, 0); atomic_init(&newheader->attributes, DNS_SLABHEADERATTR_NONEXISTENT); if (rbtversion != NULL) { newheader->serial = rbtversion->serial; } - dns__rbtdb_nodefullname(db, node, nodename); + dns__qpdb_nodefullname(db, node, nodename); - NODE_WRLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype); - result = dns__rbtdb_add(rbtdb, rbtnode, nodename, rbtversion, newheader, - DNS_DBADD_FORCE, false, NULL, - 0 DNS__DB_FLARG_PASS); - NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype); + NODE_WRLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype); + result = dns__qpdb_add(qpdb, rbtnode, nodename, rbtversion, newheader, + DNS_DBADD_FORCE, false, NULL, + 0 DNS__DB_FLARG_PASS); + NODE_UNLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype); /* * Update the zone's secure status. If version is non-NULL - * this is deferred until dns__rbtdb_closeversion() is called. + * this is deferred until dns__qpdb_closeversion() is called. */ - if (result == ISC_R_SUCCESS && version == NULL && !IS_CACHE(rbtdb)) { - RWLOCK(&rbtdb->lock, isc_rwlocktype_read); - version = rbtdb->current_version; - RWUNLOCK(&rbtdb->lock, isc_rwlocktype_read); - dns__rbtdb_setsecure(db, version, rbtdb->origin_node); + if (result == ISC_R_SUCCESS && version == NULL && !IS_CACHE(qpdb)) { + RWLOCK(&qpdb->lock, isc_rwlocktype_read); + version = qpdb->current_version; + RWUNLOCK(&qpdb->lock, isc_rwlocktype_read); + dns__qpdb_setsecure(db, version, qpdb->origin_node); } return (result); } unsigned int -dns__rbtdb_nodecount(dns_db_t *db, dns_dbtree_t tree) { - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; +dns__qpdb_nodecount(dns_db_t *db, dns_dbtree_t tree) { + dns_qpdb_t *qpdb = (dns_qpdb_t *)db; unsigned int count; isc_rwlocktype_t tlocktype = isc_rwlocktype_none; - REQUIRE(VALID_RBTDB(rbtdb)); + REQUIRE(VALID_QPDB(qpdb)); - TREE_RDLOCK(&rbtdb->tree_lock, &tlocktype); + TREE_RDLOCK(&qpdb->tree_lock, &tlocktype); switch (tree) { case dns_dbtree_main: - count = dns_rbt_nodecount(rbtdb->tree); + count = dns_rbt_nodecount(qpdb->tree); break; case dns_dbtree_nsec: - count = dns_rbt_nodecount(rbtdb->nsec); + count = dns_rbt_nodecount(qpdb->nsec); break; case dns_dbtree_nsec3: - count = dns_rbt_nodecount(rbtdb->nsec3); + count = dns_rbt_nodecount(qpdb->nsec3); break; default: UNREACHABLE(); } - TREE_UNLOCK(&rbtdb->tree_lock, &tlocktype); + TREE_UNLOCK(&qpdb->tree_lock, &tlocktype); return (count); } void -dns__rbtdb_setloop(dns_db_t *db, isc_loop_t *loop) { - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; +dns__qpdb_setloop(dns_db_t *db, isc_loop_t *loop) { + dns_qpdb_t *qpdb = (dns_qpdb_t *)db; - REQUIRE(VALID_RBTDB(rbtdb)); + REQUIRE(VALID_QPDB(qpdb)); - RWLOCK(&rbtdb->lock, isc_rwlocktype_write); - if (rbtdb->loop != NULL) { - isc_loop_detach(&rbtdb->loop); + RWLOCK(&qpdb->lock, isc_rwlocktype_write); + if (qpdb->loop != NULL) { + isc_loop_detach(&qpdb->loop); } if (loop != NULL) { - isc_loop_attach(loop, &rbtdb->loop); + isc_loop_attach(loop, &qpdb->loop); } - RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write); + RWUNLOCK(&qpdb->lock, isc_rwlocktype_write); } isc_result_t -dns__rbtdb_getoriginnode(dns_db_t *db, dns_dbnode_t **nodep DNS__DB_FLARG) { - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; +dns__qpdb_getoriginnode(dns_db_t *db, dns_dbnode_t **nodep DNS__DB_FLARG) { + dns_qpdb_t *qpdb = (dns_qpdb_t *)db; dns_rbtnode_t *onode = NULL; isc_result_t result = ISC_R_SUCCESS; - REQUIRE(VALID_RBTDB(rbtdb)); + REQUIRE(VALID_QPDB(qpdb)); REQUIRE(nodep != NULL && *nodep == NULL); /* Note that the access to origin_node doesn't require a DB lock */ - onode = (dns_rbtnode_t *)rbtdb->origin_node; + onode = (dns_rbtnode_t *)qpdb->origin_node; if (onode != NULL) { - dns__rbtdb_newref(rbtdb, onode, - isc_rwlocktype_none DNS__DB_FLARG_PASS); - *nodep = rbtdb->origin_node; + dns__qpdb_newref(qpdb, onode, + isc_rwlocktype_none DNS__DB_FLARG_PASS); + *nodep = qpdb->origin_node; } else { - INSIST(IS_CACHE(rbtdb)); + INSIST(IS_CACHE(qpdb)); result = ISC_R_NOTFOUND; } @@ -3722,50 +3713,50 @@ dns__rbtdb_getoriginnode(dns_db_t *db, dns_dbnode_t **nodep DNS__DB_FLARG) { } void -dns__rbtdb_locknode(dns_db_t *db, dns_dbnode_t *node, isc_rwlocktype_t type) { - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; +dns__qpdb_locknode(dns_db_t *db, dns_dbnode_t *node, isc_rwlocktype_t type) { + dns_qpdb_t *qpdb = (dns_qpdb_t *)db; dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node; - RWLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, type); + RWLOCK(&qpdb->node_locks[rbtnode->locknum].lock, type); } void -dns__rbtdb_unlocknode(dns_db_t *db, dns_dbnode_t *node, isc_rwlocktype_t type) { - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; +dns__qpdb_unlocknode(dns_db_t *db, dns_dbnode_t *node, isc_rwlocktype_t type) { + dns_qpdb_t *qpdb = (dns_qpdb_t *)db; dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node; - RWUNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, type); + RWUNLOCK(&qpdb->node_locks[rbtnode->locknum].lock, type); } isc_result_t -dns__rbtdb_nodefullname(dns_db_t *db, dns_dbnode_t *node, dns_name_t *name) { - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; +dns__qpdb_nodefullname(dns_db_t *db, dns_dbnode_t *node, dns_name_t *name) { + dns_qpdb_t *qpdb = (dns_qpdb_t *)db; dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node; isc_result_t result; isc_rwlocktype_t tlocktype = isc_rwlocktype_none; - REQUIRE(VALID_RBTDB(rbtdb)); + REQUIRE(VALID_QPDB(qpdb)); REQUIRE(node != NULL); REQUIRE(name != NULL); - TREE_RDLOCK(&rbtdb->tree_lock, &tlocktype); + TREE_RDLOCK(&qpdb->tree_lock, &tlocktype); result = dns_rbt_fullnamefromnode(rbtnode, name); - TREE_UNLOCK(&rbtdb->tree_lock, &tlocktype); + TREE_UNLOCK(&qpdb->tree_lock, &tlocktype); return (result); } isc_result_t -dns__rbtdb_create(isc_mem_t *mctx, const dns_name_t *origin, dns_dbtype_t type, - dns_rdataclass_t rdclass, unsigned int argc, char *argv[], - void *driverarg ISC_ATTR_UNUSED, dns_db_t **dbp) { - dns_rbtdb_t *rbtdb = NULL; +dns__qpdb_create(isc_mem_t *mctx, const dns_name_t *origin, dns_dbtype_t type, + dns_rdataclass_t rdclass, unsigned int argc, char *argv[], + void *driverarg ISC_ATTR_UNUSED, dns_db_t **dbp) { + dns_qpdb_t *qpdb = NULL; isc_result_t result; int i; isc_mem_t *hmctx = mctx; - rbtdb = isc_mem_get(mctx, sizeof(*rbtdb)); - *rbtdb = (dns_rbtdb_t){ + qpdb = isc_mem_get(mctx, sizeof(*qpdb)); + *qpdb = (dns_qpdb_t){ .common.origin = DNS_NAME_INITEMPTY, .common.rdclass = rdclass, .current_serial = 1, @@ -3774,7 +3765,7 @@ dns__rbtdb_create(isc_mem_t *mctx, const dns_name_t *origin, dns_dbtype_t type, .open_versions = ISC_LIST_INITIALIZER, }; - isc_refcount_init(&rbtdb->common.references, 1); + isc_refcount_init(&qpdb->common.references, 1); /* * If argv[0] exists, it points to a memory context to use for heap @@ -3784,17 +3775,17 @@ dns__rbtdb_create(isc_mem_t *mctx, const dns_name_t *origin, dns_dbtype_t type, } if (type == dns_dbtype_cache) { - rbtdb->common.methods = &dns__rbtdb_cachemethods; - rbtdb->common.attributes |= DNS_DBATTR_CACHE; + qpdb->common.methods = &dns__qpdb_cachemethods; + qpdb->common.attributes |= DNS_DBATTR_CACHE; } else if (type == dns_dbtype_stub) { - rbtdb->common.methods = &dns__rbtdb_zonemethods; - rbtdb->common.attributes |= DNS_DBATTR_STUB; + qpdb->common.methods = &dns__qpdb_zonemethods; + qpdb->common.attributes |= DNS_DBATTR_STUB; } else { - rbtdb->common.methods = &dns__rbtdb_zonemethods; + qpdb->common.methods = &dns__qpdb_zonemethods; } - isc_rwlock_init(&rbtdb->lock); - TREE_INITLOCK(&rbtdb->tree_lock); + isc_rwlock_init(&qpdb->lock); + TREE_INITLOCK(&qpdb->tree_lock); /* * Initialize node_lock_count in a generic way to support future @@ -3802,62 +3793,62 @@ dns__rbtdb_create(isc_mem_t *mctx, const dns_name_t *origin, dns_dbtype_t type, * Note that when specified for a cache DB it must be larger than 1 * as commented with the definition of DEFAULT_CACHE_NODE_LOCK_COUNT. */ - if (rbtdb->node_lock_count == 0) { - if (IS_CACHE(rbtdb)) { - rbtdb->node_lock_count = DEFAULT_CACHE_NODE_LOCK_COUNT; + if (qpdb->node_lock_count == 0) { + if (IS_CACHE(qpdb)) { + qpdb->node_lock_count = DEFAULT_CACHE_NODE_LOCK_COUNT; } else { - rbtdb->node_lock_count = DEFAULT_NODE_LOCK_COUNT; + qpdb->node_lock_count = DEFAULT_NODE_LOCK_COUNT; } - } else if (rbtdb->node_lock_count < 2 && IS_CACHE(rbtdb)) { + } else if (qpdb->node_lock_count < 2 && IS_CACHE(qpdb)) { result = ISC_R_RANGE; goto cleanup_tree_lock; } - INSIST(rbtdb->node_lock_count < (1 << DNS_RBT_LOCKLENGTH)); - rbtdb->node_locks = isc_mem_get(mctx, rbtdb->node_lock_count * - sizeof(db_nodelock_t)); + INSIST(qpdb->node_lock_count < (1 << DNS_RBT_LOCKLENGTH)); + qpdb->node_locks = isc_mem_get(mctx, qpdb->node_lock_count * + sizeof(db_nodelock_t)); - rbtdb->common.update_listeners = cds_lfht_new(16, 16, 0, 0, NULL); + qpdb->common.update_listeners = cds_lfht_new(16, 16, 0, 0, NULL); - if (IS_CACHE(rbtdb)) { - dns_rdatasetstats_create(mctx, &rbtdb->rrsetstats); - rbtdb->lru = isc_mem_get(mctx, - rbtdb->node_lock_count * - sizeof(dns_slabheaderlist_t)); - for (i = 0; i < (int)rbtdb->node_lock_count; i++) { - ISC_LIST_INIT(rbtdb->lru[i]); + if (IS_CACHE(qpdb)) { + dns_rdatasetstats_create(mctx, &qpdb->rrsetstats); + qpdb->lru = isc_mem_get(mctx, + qpdb->node_lock_count * + sizeof(dns_slabheaderlist_t)); + for (i = 0; i < (int)qpdb->node_lock_count; i++) { + ISC_LIST_INIT(qpdb->lru[i]); } } /* * Create the heaps. */ - rbtdb->heaps = isc_mem_get(hmctx, rbtdb->node_lock_count * - sizeof(isc_heap_t *)); - for (i = 0; i < (int)rbtdb->node_lock_count; i++) { - rbtdb->heaps[i] = NULL; + qpdb->heaps = isc_mem_get(hmctx, + qpdb->node_lock_count * sizeof(isc_heap_t *)); + for (i = 0; i < (int)qpdb->node_lock_count; i++) { + qpdb->heaps[i] = NULL; } - rbtdb->sooner = IS_CACHE(rbtdb) ? ttl_sooner : resign_sooner; - for (i = 0; i < (int)rbtdb->node_lock_count; i++) { - isc_heap_create(hmctx, rbtdb->sooner, set_index, 0, - &rbtdb->heaps[i]); + qpdb->sooner = IS_CACHE(qpdb) ? ttl_sooner : resign_sooner; + for (i = 0; i < (int)qpdb->node_lock_count; i++) { + isc_heap_create(hmctx, qpdb->sooner, set_index, 0, + &qpdb->heaps[i]); } /* * Create deadnode lists. */ - rbtdb->deadnodes = isc_mem_get(mctx, rbtdb->node_lock_count * - sizeof(dns_rbtnodelist_t)); - for (i = 0; i < (int)rbtdb->node_lock_count; i++) { - ISC_LIST_INIT(rbtdb->deadnodes[i]); + qpdb->deadnodes = isc_mem_get(mctx, qpdb->node_lock_count * + sizeof(dns_rbtnodelist_t)); + for (i = 0; i < (int)qpdb->node_lock_count; i++) { + ISC_LIST_INIT(qpdb->deadnodes[i]); } - rbtdb->active = rbtdb->node_lock_count; + qpdb->active = qpdb->node_lock_count; - for (i = 0; i < (int)(rbtdb->node_lock_count); i++) { - NODE_INITLOCK(&rbtdb->node_locks[i].lock); - isc_refcount_init(&rbtdb->node_locks[i].references, 0); - rbtdb->node_locks[i].exiting = false; + for (i = 0; i < (int)(qpdb->node_lock_count); i++) { + NODE_INITLOCK(&qpdb->node_locks[i].lock); + isc_refcount_init(&qpdb->node_locks[i].references, 0); + qpdb->node_locks[i].exiting = false; } /* @@ -3865,31 +3856,31 @@ dns__rbtdb_create(isc_mem_t *mctx, const dns_name_t *origin, dns_dbtype_t type, * are references to it, and attaching to the mctx ensures that our * mctx won't disappear out from under us. */ - isc_mem_attach(mctx, &rbtdb->common.mctx); - isc_mem_attach(hmctx, &rbtdb->hmctx); + isc_mem_attach(mctx, &qpdb->common.mctx); + isc_mem_attach(hmctx, &qpdb->hmctx); /* * Make a copy of the origin name. */ - result = dns_name_dupwithoffsets(origin, mctx, &rbtdb->common.origin); + result = dns_name_dupwithoffsets(origin, mctx, &qpdb->common.origin); if (result != ISC_R_SUCCESS) { - free_rbtdb(rbtdb, false); + free_qpdb(qpdb, false); return (result); } /* * Make the qp tries. */ - dns_qp_create(mctx, &qpmethods, rbtdb, &rbtdb->tree); - dns_qp_create(mctx, &qpmethods, rbtdb, &rbtdb->nsec); - dns_qp_create(mctx, &qpmethods, rbtdb, &rbtdb->nsec3); + dns_qp_create(mctx, &qpmethods, qpdb, &qpdb->tree); + dns_qp_create(mctx, &qpmethods, qpdb, &qpdb->nsec); + dns_qp_create(mctx, &qpmethods, qpdb, &qpdb->nsec3); /* * In order to set the node callback bit correctly in zone databases, * we need to know if the node has the origin name of the zone. * In loading_addrdataset() we could simply compare the new name * to the origin name, but this is expensive. Also, we don't know the - * node name in dns__rbtdb_addrdataset(), so we need another way of + * node name in dns__qpdb_addrdataset(), so we need another way of * knowing the zone's top. * * We now explicitly create a node for the zone's origin, and then @@ -3897,57 +3888,57 @@ dns__rbtdb_create(isc_mem_t *mctx, const dns_name_t *origin, dns_dbtype_t type, * the top-of-zone node can never be deleted, nor can its address * change. */ - if (!IS_CACHE(rbtdb)) { - result = dns_rbt_addnode(rbtdb->tree, &rbtdb->common.origin, - &rbtdb->origin_node); + if (!IS_CACHE(qpdb)) { + result = dns_rbt_addnode(qpdb->tree, &qpdb->common.origin, + &qpdb->origin_node); if (result != ISC_R_SUCCESS) { INSIST(result != ISC_R_EXISTS); - free_rbtdb(rbtdb, false); + free_qpdb(qpdb, false); return (result); } - INSIST(rbtdb->origin_node != NULL); - rbtdb->origin_node->nsec = DNS_DB_NSEC_NORMAL; + INSIST(qpdb->origin_node != NULL); + qpdb->origin_node->nsec = DNS_DB_NSEC_NORMAL; /* * Add an apex node to the NSEC3 tree so that NSEC3 searches * return partial matches when there is only a single NSEC3 * record in the tree. */ - result = dns_rbt_addnode(rbtdb->nsec3, &rbtdb->common.origin, - &rbtdb->nsec3_origin_node); + result = dns_rbt_addnode(qpdb->nsec3, &qpdb->common.origin, + &qpdb->nsec3_origin_node); if (result != ISC_R_SUCCESS) { INSIST(result != ISC_R_EXISTS); - free_rbtdb(rbtdb, false); + free_qpdb(qpdb, false); return (result); } INSIST(result == ISC_R_SUCCESS); - INSIST(rbtdb->nsec3_origin_node != NULL); - rbtdb->nsec3_origin_node->nsec = DNS_DB_NSEC_NSEC3; + INSIST(qpdb->nsec3_origin_node != NULL); + qpdb->nsec3_origin_node->nsec = DNS_DB_NSEC_NSEC3; } /* * Version Initialization. */ - rbtdb->current_version = allocate_version(mctx, 1, 1, false); - rbtdb->current_version->rbtdb = rbtdb; - isc_rwlock_init(&rbtdb->current_version->rwlock); + qpdb->current_version = allocate_version(mctx, 1, 1, false); + qpdb->current_version->qpdb = qpdb; + isc_rwlock_init(&qpdb->current_version->rwlock); /* * Keep the current version in the open list so that list operation * won't happen in normal lookup operations. */ - PREPEND(rbtdb->open_versions, rbtdb->current_version, link); + PREPEND(qpdb->open_versions, qpdb->current_version, link); - rbtdb->common.magic = DNS_DB_MAGIC; - rbtdb->common.impmagic = RBTDB_MAGIC; + qpdb->common.magic = DNS_DB_MAGIC; + qpdb->common.impmagic = QPDB_MAGIC; - *dbp = (dns_db_t *)rbtdb; + *dbp = (dns_db_t *)qpdb; return (ISC_R_SUCCESS); cleanup_tree_lock: - TREE_DESTROYLOCK(&rbtdb->tree_lock); - isc_rwlock_destroy(&rbtdb->lock); - isc_mem_put(mctx, rbtdb, sizeof(*rbtdb)); + TREE_DESTROYLOCK(&qpdb->tree_lock); + isc_rwlock_destroy(&qpdb->lock); + isc_mem_put(mctx, qpdb, sizeof(*qpdb)); return (result); } @@ -3957,14 +3948,14 @@ cleanup_tree_lock: static void rdatasetiter_destroy(dns_rdatasetiter_t **iteratorp DNS__DB_FLARG) { - rbtdb_rdatasetiter_t *rbtiterator = NULL; + qpdb_rdatasetiter_t *rbtiterator = NULL; - rbtiterator = (rbtdb_rdatasetiter_t *)(*iteratorp); + rbtiterator = (qpdb_rdatasetiter_t *)(*iteratorp); if (rbtiterator->common.version != NULL) { - dns__rbtdb_closeversion(rbtiterator->common.db, - &rbtiterator->common.version, - false DNS__DB_FLARG_PASS); + dns__qpdb_closeversion(rbtiterator->common.db, + &rbtiterator->common.version, + false DNS__DB_FLARG_PASS); } dns__db_detachnode(rbtiterator->common.db, &rbtiterator->common.node DNS__DB_FLARG_PASS); @@ -3975,9 +3966,9 @@ rdatasetiter_destroy(dns_rdatasetiter_t **iteratorp DNS__DB_FLARG) { } static bool -iterator_active(dns_rbtdb_t *rbtdb, rbtdb_rdatasetiter_t *rbtiterator, +iterator_active(dns_qpdb_t *qpdb, qpdb_rdatasetiter_t *rbtiterator, dns_slabheader_t *header) { - dns_ttl_t stale_ttl = header->ttl + STALE_TTL(header, rbtdb); + dns_ttl_t stale_ttl = header->ttl + STALE_TTL(header, qpdb); /* * Is this a "this rdataset doesn't exist" record? @@ -3989,7 +3980,7 @@ iterator_active(dns_rbtdb_t *rbtdb, rbtdb_rdatasetiter_t *rbtiterator, /* * If this is a zone or this header still active then return it. */ - if (!IS_CACHE(rbtdb) || ACTIVE(header, rbtiterator->common.now)) { + if (!IS_CACHE(qpdb) || ACTIVE(header, rbtiterator->common.now)) { return (true); } @@ -4005,15 +3996,15 @@ iterator_active(dns_rbtdb_t *rbtdb, rbtdb_rdatasetiter_t *rbtiterator, static isc_result_t rdatasetiter_first(dns_rdatasetiter_t *iterator DNS__DB_FLARG) { - rbtdb_rdatasetiter_t *rbtiterator = (rbtdb_rdatasetiter_t *)iterator; - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)(rbtiterator->common.db); + qpdb_rdatasetiter_t *rbtiterator = (qpdb_rdatasetiter_t *)iterator; + dns_qpdb_t *qpdb = (dns_qpdb_t *)(rbtiterator->common.db); dns_rbtnode_t *rbtnode = rbtiterator->common.node; - dns_rbtdb_version_t *rbtversion = rbtiterator->common.version; + dns_qpdb_version_t *rbtversion = rbtiterator->common.version; dns_slabheader_t *header = NULL, *top_next = NULL; - uint32_t serial = IS_CACHE(rbtdb) ? 1 : rbtversion->serial; + uint32_t serial = IS_CACHE(qpdb) ? 1 : rbtversion->serial; isc_rwlocktype_t nlocktype = isc_rwlocktype_none; - NODE_RDLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype); + NODE_RDLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype); for (header = rbtnode->data; header != NULL; header = top_next) { top_next = header->next; @@ -4025,8 +4016,7 @@ rdatasetiter_first(dns_rdatasetiter_t *iterator DNS__DB_FLARG) { header = header->down; } else if (header->serial <= serial && !IGNORE(header)) { - if (!iterator_active(rbtdb, rbtiterator, - header)) + if (!iterator_active(qpdb, rbtiterator, header)) { header = NULL; } @@ -4040,7 +4030,7 @@ rdatasetiter_first(dns_rdatasetiter_t *iterator DNS__DB_FLARG) { } } - NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype); + NODE_UNLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype); rbtiterator->current = header; @@ -4053,12 +4043,12 @@ rdatasetiter_first(dns_rdatasetiter_t *iterator DNS__DB_FLARG) { static isc_result_t rdatasetiter_next(dns_rdatasetiter_t *iterator DNS__DB_FLARG) { - rbtdb_rdatasetiter_t *rbtiterator = (rbtdb_rdatasetiter_t *)iterator; - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)(rbtiterator->common.db); + qpdb_rdatasetiter_t *rbtiterator = (qpdb_rdatasetiter_t *)iterator; + dns_qpdb_t *qpdb = (dns_qpdb_t *)(rbtiterator->common.db); dns_rbtnode_t *rbtnode = rbtiterator->common.node; - dns_rbtdb_version_t *rbtversion = rbtiterator->common.version; + dns_qpdb_version_t *rbtversion = rbtiterator->common.version; dns_slabheader_t *header = NULL, *top_next = NULL; - uint32_t serial = IS_CACHE(rbtdb) ? 1 : rbtversion->serial; + uint32_t serial = IS_CACHE(qpdb) ? 1 : rbtversion->serial; dns_typepair_t type, negtype; dns_rdatatype_t rdtype, covers; isc_rwlocktype_t nlocktype = isc_rwlocktype_none; @@ -4069,7 +4059,7 @@ rdatasetiter_next(dns_rdatasetiter_t *iterator DNS__DB_FLARG) { return (ISC_R_NOMORE); } - NODE_RDLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype); + NODE_RDLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype); type = header->type; rdtype = DNS_TYPEPAIR_TYPE(header->type); @@ -4109,8 +4099,7 @@ rdatasetiter_next(dns_rdatasetiter_t *iterator DNS__DB_FLARG) { header = header->down; } else if (header->serial <= serial && !IGNORE(header)) { - if (!iterator_active(rbtdb, rbtiterator, - header)) + if (!iterator_active(qpdb, rbtiterator, header)) { header = NULL; } @@ -4133,7 +4122,7 @@ rdatasetiter_next(dns_rdatasetiter_t *iterator DNS__DB_FLARG) { } } - NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype); + NODE_UNLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype); rbtiterator->current = header; @@ -4147,8 +4136,8 @@ rdatasetiter_next(dns_rdatasetiter_t *iterator DNS__DB_FLARG) { static void rdatasetiter_current(dns_rdatasetiter_t *iterator, dns_rdataset_t *rdataset DNS__DB_FLARG) { - rbtdb_rdatasetiter_t *rbtiterator = (rbtdb_rdatasetiter_t *)iterator; - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)(rbtiterator->common.db); + qpdb_rdatasetiter_t *rbtiterator = (qpdb_rdatasetiter_t *)iterator; + dns_qpdb_t *qpdb = (dns_qpdb_t *)(rbtiterator->common.db); dns_rbtnode_t *rbtnode = rbtiterator->common.node; dns_slabheader_t *header = NULL; isc_rwlocktype_t nlocktype = isc_rwlocktype_none; @@ -4156,13 +4145,13 @@ rdatasetiter_current(dns_rdatasetiter_t *iterator, header = rbtiterator->current; REQUIRE(header != NULL); - NODE_RDLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype); + NODE_RDLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype); - dns__rbtdb_bindrdataset(rbtdb, rbtnode, header, rbtiterator->common.now, - isc_rwlocktype_read, - rdataset DNS__DB_FLARG_PASS); + dns__qpdb_bindrdataset(qpdb, rbtnode, header, rbtiterator->common.now, + isc_rwlocktype_read, + rdataset DNS__DB_FLARG_PASS); - NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype); + NODE_UNLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype); } /* @@ -4170,25 +4159,25 @@ rdatasetiter_current(dns_rdatasetiter_t *iterator, */ static void -reference_iter_node(rbtdb_dbiterator_t *rbtdbiter DNS__DB_FLARG) { - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)rbtdbiter->common.db; - dns_rbtnode_t *node = rbtdbiter->node; +reference_iter_node(qpdb_dbiterator_t *qpdbiter DNS__DB_FLARG) { + dns_qpdb_t *qpdb = (dns_qpdb_t *)qpdbiter->common.db; + dns_rbtnode_t *node = qpdbiter->node; if (node == NULL) { return; } - INSIST(rbtdbiter->tree_locked != isc_rwlocktype_none); - reactivate_node(rbtdb, node, rbtdbiter->tree_locked DNS__DB_FLARG_PASS); + INSIST(qpdbiter->tree_locked != isc_rwlocktype_none); + reactivate_node(qpdb, node, qpdbiter->tree_locked DNS__DB_FLARG_PASS); } static void -dereference_iter_node(rbtdb_dbiterator_t *rbtdbiter DNS__DB_FLARG) { - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)rbtdbiter->common.db; - dns_rbtnode_t *node = rbtdbiter->node; +dereference_iter_node(qpdb_dbiterator_t *qpdbiter DNS__DB_FLARG) { + dns_qpdb_t *qpdb = (dns_qpdb_t *)qpdbiter->common.db; + dns_rbtnode_t *node = qpdbiter->node; isc_rwlock_t *lock = NULL; isc_rwlocktype_t nlocktype = isc_rwlocktype_none; - isc_rwlocktype_t tlocktype = rbtdbiter->tree_locked; + isc_rwlocktype_t tlocktype = qpdbiter->tree_locked; if (node == NULL) { return; @@ -4196,48 +4185,48 @@ dereference_iter_node(rbtdb_dbiterator_t *rbtdbiter DNS__DB_FLARG) { REQUIRE(tlocktype != isc_rwlocktype_write); - lock = &rbtdb->node_locks[node->locknum].lock; + lock = &qpdb->node_locks[node->locknum].lock; NODE_RDLOCK(lock, &nlocktype); - dns__rbtdb_decref(rbtdb, node, 0, &nlocktype, &rbtdbiter->tree_locked, - false, false DNS__DB_FLARG_PASS); + dns__qpdb_decref(qpdb, node, 0, &nlocktype, &qpdbiter->tree_locked, + false, false DNS__DB_FLARG_PASS); NODE_UNLOCK(lock, &nlocktype); - INSIST(rbtdbiter->tree_locked == tlocktype); + INSIST(qpdbiter->tree_locked == tlocktype); - rbtdbiter->node = NULL; + qpdbiter->node = NULL; } static void -resume_iteration(rbtdb_dbiterator_t *rbtdbiter) { - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)rbtdbiter->common.db; +resume_iteration(qpdb_dbiterator_t *qpdbiter) { + dns_qpdb_t *qpdb = (dns_qpdb_t *)qpdbiter->common.db; - REQUIRE(rbtdbiter->paused); - REQUIRE(rbtdbiter->tree_locked == isc_rwlocktype_none); + REQUIRE(qpdbiter->paused); + REQUIRE(qpdbiter->tree_locked == isc_rwlocktype_none); - TREE_RDLOCK(&rbtdb->tree_lock, &rbtdbiter->tree_locked); + TREE_RDLOCK(&qpdb->tree_lock, &qpdbiter->tree_locked); - rbtdbiter->paused = false; + qpdbiter->paused = false; } static void dbiterator_destroy(dns_dbiterator_t **iteratorp DNS__DB_FLARG) { - rbtdb_dbiterator_t *rbtdbiter = (rbtdb_dbiterator_t *)(*iteratorp); - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)rbtdbiter->common.db; + qpdb_dbiterator_t *qpdbiter = (qpdb_dbiterator_t *)(*iteratorp); + dns_qpdb_t *qpdb = (dns_qpdb_t *)qpdbiter->common.db; dns_db_t *db = NULL; - if (rbtdbiter->tree_locked == isc_rwlocktype_read) { - TREE_UNLOCK(&rbtdb->tree_lock, &rbtdbiter->tree_locked); + if (qpdbiter->tree_locked == isc_rwlocktype_read) { + TREE_UNLOCK(&qpdb->tree_lock, &qpdbiter->tree_locked); } - INSIST(rbtdbiter->tree_locked == isc_rwlocktype_none); + INSIST(qpdbiter->tree_locked == isc_rwlocktype_none); - dereference_iter_node(rbtdbiter DNS__DB_FLARG_PASS); + dereference_iter_node(qpdbiter DNS__DB_FLARG_PASS); - dns_db_attach(rbtdbiter->common.db, &db); - dns_db_detach(&rbtdbiter->common.db); + dns_db_attach(qpdbiter->common.db, &db); + dns_db_detach(&qpdbiter->common.db); - dns_rbtnodechain_reset(&rbtdbiter->chain); - dns_rbtnodechain_reset(&rbtdbiter->nsec3chain); - isc_mem_put(db->mctx, rbtdbiter, sizeof(*rbtdbiter)); + dns_rbtnodechain_reset(&qpdbiter->chain); + dns_rbtnodechain_reset(&qpdbiter->nsec3chain); + isc_mem_put(db->mctx, qpdbiter, sizeof(*qpdbiter)); dns_db_detach(&db); *iteratorp = NULL; @@ -4246,48 +4235,48 @@ dbiterator_destroy(dns_dbiterator_t **iteratorp DNS__DB_FLARG) { static isc_result_t dbiterator_first(dns_dbiterator_t *iterator DNS__DB_FLARG) { isc_result_t result; - rbtdb_dbiterator_t *rbtdbiter = (rbtdb_dbiterator_t *)iterator; - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)iterator->db; + qpdb_dbiterator_t *qpdbiter = (qpdb_dbiterator_t *)iterator; + dns_qpdb_t *qpdb = (dns_qpdb_t *)iterator->db; dns_name_t *name = NULL, *origin = NULL; - if (rbtdbiter->result != ISC_R_SUCCESS && - rbtdbiter->result != ISC_R_NOTFOUND && - rbtdbiter->result != DNS_R_PARTIALMATCH && - rbtdbiter->result != ISC_R_NOMORE) + if (qpdbiter->result != ISC_R_SUCCESS && + qpdbiter->result != ISC_R_NOTFOUND && + qpdbiter->result != DNS_R_PARTIALMATCH && + qpdbiter->result != ISC_R_NOMORE) { - return (rbtdbiter->result); + return (qpdbiter->result); } - if (rbtdbiter->paused) { - resume_iteration(rbtdbiter); + if (qpdbiter->paused) { + resume_iteration(qpdbiter); } - dereference_iter_node(rbtdbiter DNS__DB_FLARG_PASS); + dereference_iter_node(qpdbiter DNS__DB_FLARG_PASS); - name = dns_fixedname_name(&rbtdbiter->name); - origin = dns_fixedname_name(&rbtdbiter->origin); - dns_rbtnodechain_reset(&rbtdbiter->chain); - dns_rbtnodechain_reset(&rbtdbiter->nsec3chain); + name = dns_fixedname_name(&qpdbiter->name); + origin = dns_fixedname_name(&qpdbiter->origin); + dns_rbtnodechain_reset(&qpdbiter->chain); + dns_rbtnodechain_reset(&qpdbiter->nsec3chain); - switch (rbtdbiter->nsec3mode) { + switch (qpdbiter->nsec3mode) { case nsec3only: - rbtdbiter->current = &rbtdbiter->nsec3chain; - result = dns_rbtnodechain_first(rbtdbiter->current, - rbtdb->nsec3, name, origin); + qpdbiter->current = &qpdbiter->nsec3chain; + result = dns_rbtnodechain_first(qpdbiter->current, qpdb->nsec3, + name, origin); break; case nonsec3: - rbtdbiter->current = &rbtdbiter->chain; - result = dns_rbtnodechain_first(rbtdbiter->current, rbtdb->tree, + qpdbiter->current = &qpdbiter->chain; + result = dns_rbtnodechain_first(qpdbiter->current, qpdb->tree, name, origin); break; case full: - rbtdbiter->current = &rbtdbiter->chain; - result = dns_rbtnodechain_first(rbtdbiter->current, rbtdb->tree, + qpdbiter->current = &qpdbiter->chain; + result = dns_rbtnodechain_first(qpdbiter->current, qpdb->tree, name, origin); if (result == ISC_R_NOTFOUND) { - rbtdbiter->current = &rbtdbiter->nsec3chain; + qpdbiter->current = &qpdbiter->nsec3chain; result = dns_rbtnodechain_first( - rbtdbiter->current, rbtdb->nsec3, name, origin); + qpdbiter->current, qpdb->nsec3, name, origin); } break; default: @@ -4295,35 +4284,35 @@ dbiterator_first(dns_dbiterator_t *iterator DNS__DB_FLARG) { } if (result == ISC_R_SUCCESS || result == DNS_R_NEWORIGIN) { - result = dns_rbtnodechain_current(rbtdbiter->current, NULL, - NULL, &rbtdbiter->node); + result = dns_rbtnodechain_current(qpdbiter->current, NULL, NULL, + &qpdbiter->node); /* If we're in the NSEC3 tree, skip the origin */ - if (RBTDBITER_NSEC3_ORIGIN_NODE(rbtdb, rbtdbiter)) { - rbtdbiter->node = NULL; - result = dns_rbtnodechain_next(rbtdbiter->current, name, + if (QPDBITER_NSEC3_ORIGIN_NODE(qpdb, qpdbiter)) { + qpdbiter->node = NULL; + result = dns_rbtnodechain_next(qpdbiter->current, name, origin); if (result == ISC_R_SUCCESS || result == DNS_R_NEWORIGIN) { result = dns_rbtnodechain_current( - rbtdbiter->current, NULL, NULL, - &rbtdbiter->node); + qpdbiter->current, NULL, NULL, + &qpdbiter->node); } } if (result == ISC_R_SUCCESS) { - rbtdbiter->new_origin = true; - reference_iter_node(rbtdbiter DNS__DB_FLARG_PASS); + qpdbiter->new_origin = true; + reference_iter_node(qpdbiter DNS__DB_FLARG_PASS); } } else { INSIST(result == ISC_R_NOTFOUND); result = ISC_R_NOMORE; /* The tree is empty. */ } - rbtdbiter->result = result; + qpdbiter->result = result; if (result != ISC_R_SUCCESS) { - ENSURE(!rbtdbiter->paused); + ENSURE(!qpdbiter->paused); } return (result); @@ -4332,48 +4321,48 @@ dbiterator_first(dns_dbiterator_t *iterator DNS__DB_FLARG) { static isc_result_t dbiterator_last(dns_dbiterator_t *iterator DNS__DB_FLARG) { isc_result_t result; - rbtdb_dbiterator_t *rbtdbiter = (rbtdb_dbiterator_t *)iterator; - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)iterator->db; + qpdb_dbiterator_t *qpdbiter = (qpdb_dbiterator_t *)iterator; + dns_qpdb_t *qpdb = (dns_qpdb_t *)iterator->db; dns_name_t *name = NULL, *origin = NULL; - if (rbtdbiter->result != ISC_R_SUCCESS && - rbtdbiter->result != ISC_R_NOTFOUND && - rbtdbiter->result != DNS_R_PARTIALMATCH && - rbtdbiter->result != ISC_R_NOMORE) + if (qpdbiter->result != ISC_R_SUCCESS && + qpdbiter->result != ISC_R_NOTFOUND && + qpdbiter->result != DNS_R_PARTIALMATCH && + qpdbiter->result != ISC_R_NOMORE) { - return (rbtdbiter->result); + return (qpdbiter->result); } - if (rbtdbiter->paused) { - resume_iteration(rbtdbiter); + if (qpdbiter->paused) { + resume_iteration(qpdbiter); } - dereference_iter_node(rbtdbiter DNS__DB_FLARG_PASS); + dereference_iter_node(qpdbiter DNS__DB_FLARG_PASS); - name = dns_fixedname_name(&rbtdbiter->name); - origin = dns_fixedname_name(&rbtdbiter->origin); - dns_rbtnodechain_reset(&rbtdbiter->chain); - dns_rbtnodechain_reset(&rbtdbiter->nsec3chain); + name = dns_fixedname_name(&qpdbiter->name); + origin = dns_fixedname_name(&qpdbiter->origin); + dns_rbtnodechain_reset(&qpdbiter->chain); + dns_rbtnodechain_reset(&qpdbiter->nsec3chain); - switch (rbtdbiter->nsec3mode) { + switch (qpdbiter->nsec3mode) { case nsec3only: - rbtdbiter->current = &rbtdbiter->nsec3chain; - result = dns_rbtnodechain_last(rbtdbiter->current, rbtdb->nsec3, + qpdbiter->current = &qpdbiter->nsec3chain; + result = dns_rbtnodechain_last(qpdbiter->current, qpdb->nsec3, name, origin); break; case nonsec3: - rbtdbiter->current = &rbtdbiter->chain; - result = dns_rbtnodechain_last(rbtdbiter->current, rbtdb->tree, + qpdbiter->current = &qpdbiter->chain; + result = dns_rbtnodechain_last(qpdbiter->current, qpdb->tree, name, origin); break; case full: - rbtdbiter->current = &rbtdbiter->nsec3chain; - result = dns_rbtnodechain_last(rbtdbiter->current, rbtdb->nsec3, + qpdbiter->current = &qpdbiter->nsec3chain; + result = dns_rbtnodechain_last(qpdbiter->current, qpdb->nsec3, name, origin); if (result == ISC_R_NOTFOUND) { - rbtdbiter->current = &rbtdbiter->chain; + qpdbiter->current = &qpdbiter->chain; result = dns_rbtnodechain_last( - rbtdbiter->current, rbtdb->tree, name, origin); + qpdbiter->current, qpdb->tree, name, origin); } break; default: @@ -4381,29 +4370,29 @@ dbiterator_last(dns_dbiterator_t *iterator DNS__DB_FLARG) { } if (result == ISC_R_SUCCESS || result == DNS_R_NEWORIGIN) { - result = dns_rbtnodechain_current(rbtdbiter->current, NULL, - NULL, &rbtdbiter->node); - if (RBTDBITER_NSEC3_ORIGIN_NODE(rbtdb, rbtdbiter)) { + result = dns_rbtnodechain_current(qpdbiter->current, NULL, NULL, + &qpdbiter->node); + if (QPDBITER_NSEC3_ORIGIN_NODE(qpdb, qpdbiter)) { /* * NSEC3 tree only has an origin node. */ - rbtdbiter->node = NULL; - switch (rbtdbiter->nsec3mode) { + qpdbiter->node = NULL; + switch (qpdbiter->nsec3mode) { case nsec3only: result = ISC_R_NOMORE; break; case nonsec3: case full: - rbtdbiter->current = &rbtdbiter->chain; + qpdbiter->current = &qpdbiter->chain; result = dns_rbtnodechain_last( - rbtdbiter->current, rbtdb->tree, name, + qpdbiter->current, qpdb->tree, name, origin); if (result == ISC_R_SUCCESS || result == DNS_R_NEWORIGIN) { result = dns_rbtnodechain_current( - rbtdbiter->current, NULL, NULL, - &rbtdbiter->node); + qpdbiter->current, NULL, NULL, + &qpdbiter->node); } break; default: @@ -4411,15 +4400,15 @@ dbiterator_last(dns_dbiterator_t *iterator DNS__DB_FLARG) { } } if (result == ISC_R_SUCCESS) { - rbtdbiter->new_origin = true; - reference_iter_node(rbtdbiter DNS__DB_FLARG_PASS); + qpdbiter->new_origin = true; + reference_iter_node(qpdbiter DNS__DB_FLARG_PASS); } } else { INSIST(result == ISC_R_NOTFOUND); result = ISC_R_NOMORE; /* The tree is empty. */ } - rbtdbiter->result = result; + qpdbiter->result = result; return (result); } @@ -4428,59 +4417,59 @@ static isc_result_t dbiterator_seek(dns_dbiterator_t *iterator, const dns_name_t *name DNS__DB_FLARG) { isc_result_t result, tresult; - rbtdb_dbiterator_t *rbtdbiter = (rbtdb_dbiterator_t *)iterator; - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)iterator->db; + qpdb_dbiterator_t *qpdbiter = (qpdb_dbiterator_t *)iterator; + dns_qpdb_t *qpdb = (dns_qpdb_t *)iterator->db; dns_name_t *iname = NULL, *origin = NULL; - if (rbtdbiter->result != ISC_R_SUCCESS && - rbtdbiter->result != ISC_R_NOTFOUND && - rbtdbiter->result != DNS_R_PARTIALMATCH && - rbtdbiter->result != ISC_R_NOMORE) + if (qpdbiter->result != ISC_R_SUCCESS && + qpdbiter->result != ISC_R_NOTFOUND && + qpdbiter->result != DNS_R_PARTIALMATCH && + qpdbiter->result != ISC_R_NOMORE) { - return (rbtdbiter->result); + return (qpdbiter->result); } - if (rbtdbiter->paused) { - resume_iteration(rbtdbiter); + if (qpdbiter->paused) { + resume_iteration(qpdbiter); } - dereference_iter_node(rbtdbiter DNS__DB_FLARG_PASS); + dereference_iter_node(qpdbiter DNS__DB_FLARG_PASS); - iname = dns_fixedname_name(&rbtdbiter->name); - origin = dns_fixedname_name(&rbtdbiter->origin); - dns_rbtnodechain_reset(&rbtdbiter->chain); - dns_rbtnodechain_reset(&rbtdbiter->nsec3chain); + iname = dns_fixedname_name(&qpdbiter->name); + origin = dns_fixedname_name(&qpdbiter->origin); + dns_rbtnodechain_reset(&qpdbiter->chain); + dns_rbtnodechain_reset(&qpdbiter->nsec3chain); - switch (rbtdbiter->nsec3mode) { + switch (qpdbiter->nsec3mode) { case nsec3only: - rbtdbiter->current = &rbtdbiter->nsec3chain; - result = dns_rbt_findnode(rbtdb->nsec3, name, NULL, - &rbtdbiter->node, rbtdbiter->current, + qpdbiter->current = &qpdbiter->nsec3chain; + result = dns_rbt_findnode(qpdb->nsec3, name, NULL, + &qpdbiter->node, qpdbiter->current, DNS_RBTFIND_EMPTYDATA, NULL, NULL); break; case nonsec3: - rbtdbiter->current = &rbtdbiter->chain; - result = dns_rbt_findnode(rbtdb->tree, name, NULL, - &rbtdbiter->node, rbtdbiter->current, + qpdbiter->current = &qpdbiter->chain; + result = dns_rbt_findnode(qpdb->tree, name, NULL, + &qpdbiter->node, qpdbiter->current, DNS_RBTFIND_EMPTYDATA, NULL, NULL); break; case full: /* * Stay on main chain if not found on either chain. */ - rbtdbiter->current = &rbtdbiter->chain; - result = dns_rbt_findnode(rbtdb->tree, name, NULL, - &rbtdbiter->node, rbtdbiter->current, + qpdbiter->current = &qpdbiter->chain; + result = dns_rbt_findnode(qpdb->tree, name, NULL, + &qpdbiter->node, qpdbiter->current, DNS_RBTFIND_EMPTYDATA, NULL, NULL); if (result == DNS_R_PARTIALMATCH) { dns_rbtnode_t *node = NULL; - tresult = dns_rbt_findnode( - rbtdb->nsec3, name, NULL, &node, - &rbtdbiter->nsec3chain, DNS_RBTFIND_EMPTYDATA, - NULL, NULL); + tresult = dns_rbt_findnode(qpdb->nsec3, name, NULL, + &node, &qpdbiter->nsec3chain, + DNS_RBTFIND_EMPTYDATA, NULL, + NULL); if (tresult == ISC_R_SUCCESS) { - rbtdbiter->node = node; - rbtdbiter->current = &rbtdbiter->nsec3chain; + qpdbiter->node = node; + qpdbiter->current = &qpdbiter->nsec3chain; result = tresult; } } @@ -4490,21 +4479,21 @@ dbiterator_seek(dns_dbiterator_t *iterator, } if (result == ISC_R_SUCCESS || result == DNS_R_PARTIALMATCH) { - tresult = dns_rbtnodechain_current(rbtdbiter->current, iname, + tresult = dns_rbtnodechain_current(qpdbiter->current, iname, origin, NULL); if (tresult == ISC_R_SUCCESS) { - rbtdbiter->new_origin = true; - reference_iter_node(rbtdbiter DNS__DB_FLARG_PASS); + qpdbiter->new_origin = true; + reference_iter_node(qpdbiter DNS__DB_FLARG_PASS); } else { result = tresult; - rbtdbiter->node = NULL; + qpdbiter->node = NULL; } } else { - rbtdbiter->node = NULL; + qpdbiter->node = NULL; } - rbtdbiter->result = (result == DNS_R_PARTIALMATCH) ? ISC_R_SUCCESS - : result; + qpdbiter->result = (result == DNS_R_PARTIALMATCH) ? ISC_R_SUCCESS + : result; return (result); } @@ -4512,47 +4501,47 @@ dbiterator_seek(dns_dbiterator_t *iterator, static isc_result_t dbiterator_prev(dns_dbiterator_t *iterator DNS__DB_FLARG) { isc_result_t result; - rbtdb_dbiterator_t *rbtdbiter = (rbtdb_dbiterator_t *)iterator; + qpdb_dbiterator_t *qpdbiter = (qpdb_dbiterator_t *)iterator; dns_name_t *name = NULL, *origin = NULL; - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)iterator->db; + dns_qpdb_t *qpdb = (dns_qpdb_t *)iterator->db; - REQUIRE(rbtdbiter->node != NULL); + REQUIRE(qpdbiter->node != NULL); - if (rbtdbiter->result != ISC_R_SUCCESS) { - return (rbtdbiter->result); + if (qpdbiter->result != ISC_R_SUCCESS) { + return (qpdbiter->result); } - if (rbtdbiter->paused) { - resume_iteration(rbtdbiter); + if (qpdbiter->paused) { + resume_iteration(qpdbiter); } - dereference_iter_node(rbtdbiter DNS__DB_FLARG_PASS); + dereference_iter_node(qpdbiter DNS__DB_FLARG_PASS); - name = dns_fixedname_name(&rbtdbiter->name); - origin = dns_fixedname_name(&rbtdbiter->origin); - result = dns_rbtnodechain_prev(rbtdbiter->current, name, origin); - if (rbtdbiter->current == &rbtdbiter->nsec3chain && + name = dns_fixedname_name(&qpdbiter->name); + origin = dns_fixedname_name(&qpdbiter->origin); + result = dns_rbtnodechain_prev(qpdbiter->current, name, origin); + if (qpdbiter->current == &qpdbiter->nsec3chain && (result == ISC_R_SUCCESS || result == DNS_R_NEWORIGIN)) { /* * If we're in the NSEC3 tree, it's empty or we've * reached the origin, then we're done with it. */ - result = dns_rbtnodechain_current(rbtdbiter->current, NULL, - NULL, &rbtdbiter->node); + result = dns_rbtnodechain_current(qpdbiter->current, NULL, NULL, + &qpdbiter->node); if (result == ISC_R_NOTFOUND || - RBTDBITER_NSEC3_ORIGIN_NODE(rbtdb, rbtdbiter)) + QPDBITER_NSEC3_ORIGIN_NODE(qpdb, qpdbiter)) { - rbtdbiter->node = NULL; + qpdbiter->node = NULL; result = ISC_R_NOMORE; } } - if (result == ISC_R_NOMORE && rbtdbiter->nsec3mode != nsec3only && - &rbtdbiter->nsec3chain == rbtdbiter->current) + if (result == ISC_R_NOMORE && qpdbiter->nsec3mode != nsec3only && + &qpdbiter->nsec3chain == qpdbiter->current) { - rbtdbiter->current = &rbtdbiter->chain; - dns_rbtnodechain_reset(rbtdbiter->current); - result = dns_rbtnodechain_last(rbtdbiter->current, rbtdb->tree, + qpdbiter->current = &qpdbiter->chain; + dns_rbtnodechain_reset(qpdbiter->current); + result = dns_rbtnodechain_last(qpdbiter->current, qpdb->tree, name, origin); if (result == ISC_R_NOTFOUND) { result = ISC_R_NOMORE; @@ -4560,16 +4549,16 @@ dbiterator_prev(dns_dbiterator_t *iterator DNS__DB_FLARG) { } if (result == DNS_R_NEWORIGIN || result == ISC_R_SUCCESS) { - rbtdbiter->new_origin = (result == DNS_R_NEWORIGIN); - result = dns_rbtnodechain_current(rbtdbiter->current, NULL, - NULL, &rbtdbiter->node); + qpdbiter->new_origin = (result == DNS_R_NEWORIGIN); + result = dns_rbtnodechain_current(qpdbiter->current, NULL, NULL, + &qpdbiter->node); } if (result == ISC_R_SUCCESS) { - reference_iter_node(rbtdbiter DNS__DB_FLARG_PASS); + reference_iter_node(qpdbiter DNS__DB_FLARG_PASS); } - rbtdbiter->result = result; + qpdbiter->result = result; return (result); } @@ -4577,63 +4566,63 @@ dbiterator_prev(dns_dbiterator_t *iterator DNS__DB_FLARG) { static isc_result_t dbiterator_next(dns_dbiterator_t *iterator DNS__DB_FLARG) { isc_result_t result; - rbtdb_dbiterator_t *rbtdbiter = (rbtdb_dbiterator_t *)iterator; + qpdb_dbiterator_t *qpdbiter = (qpdb_dbiterator_t *)iterator; dns_name_t *name = NULL, *origin = NULL; - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)iterator->db; + dns_qpdb_t *qpdb = (dns_qpdb_t *)iterator->db; - REQUIRE(rbtdbiter->node != NULL); + REQUIRE(qpdbiter->node != NULL); - if (rbtdbiter->result != ISC_R_SUCCESS) { - return (rbtdbiter->result); + if (qpdbiter->result != ISC_R_SUCCESS) { + return (qpdbiter->result); } - if (rbtdbiter->paused) { - resume_iteration(rbtdbiter); + if (qpdbiter->paused) { + resume_iteration(qpdbiter); } - name = dns_fixedname_name(&rbtdbiter->name); - origin = dns_fixedname_name(&rbtdbiter->origin); - result = dns_rbtnodechain_next(rbtdbiter->current, name, origin); - if (result == ISC_R_NOMORE && rbtdbiter->nsec3mode != nonsec3 && - &rbtdbiter->chain == rbtdbiter->current) + name = dns_fixedname_name(&qpdbiter->name); + origin = dns_fixedname_name(&qpdbiter->origin); + result = dns_rbtnodechain_next(qpdbiter->current, name, origin); + if (result == ISC_R_NOMORE && qpdbiter->nsec3mode != nonsec3 && + &qpdbiter->chain == qpdbiter->current) { - rbtdbiter->current = &rbtdbiter->nsec3chain; - dns_rbtnodechain_reset(rbtdbiter->current); - result = dns_rbtnodechain_first(rbtdbiter->current, - rbtdb->nsec3, name, origin); + qpdbiter->current = &qpdbiter->nsec3chain; + dns_rbtnodechain_reset(qpdbiter->current); + result = dns_rbtnodechain_first(qpdbiter->current, qpdb->nsec3, + name, origin); if (result == ISC_R_NOTFOUND) { result = ISC_R_NOMORE; } } - dereference_iter_node(rbtdbiter DNS__DB_FLARG_PASS); + dereference_iter_node(qpdbiter DNS__DB_FLARG_PASS); if (result == DNS_R_NEWORIGIN || result == ISC_R_SUCCESS) { /* * If we've just started the NSEC3 tree, * skip over the origin. */ - rbtdbiter->new_origin = (result == DNS_R_NEWORIGIN); - result = dns_rbtnodechain_current(rbtdbiter->current, NULL, - NULL, &rbtdbiter->node); - if (RBTDBITER_NSEC3_ORIGIN_NODE(rbtdb, rbtdbiter)) { - rbtdbiter->node = NULL; - result = dns_rbtnodechain_next(rbtdbiter->current, name, + qpdbiter->new_origin = (result == DNS_R_NEWORIGIN); + result = dns_rbtnodechain_current(qpdbiter->current, NULL, NULL, + &qpdbiter->node); + if (QPDBITER_NSEC3_ORIGIN_NODE(qpdb, qpdbiter)) { + qpdbiter->node = NULL; + result = dns_rbtnodechain_next(qpdbiter->current, name, origin); if (result == ISC_R_SUCCESS || result == DNS_R_NEWORIGIN) { result = dns_rbtnodechain_current( - rbtdbiter->current, NULL, NULL, - &rbtdbiter->node); + qpdbiter->current, NULL, NULL, + &qpdbiter->node); } } } if (result == ISC_R_SUCCESS) { - reference_iter_node(rbtdbiter DNS__DB_FLARG_PASS); + reference_iter_node(qpdbiter DNS__DB_FLARG_PASS); } - rbtdbiter->result = result; + qpdbiter->result = result; return (result); } @@ -4641,76 +4630,76 @@ dbiterator_next(dns_dbiterator_t *iterator DNS__DB_FLARG) { static isc_result_t dbiterator_current(dns_dbiterator_t *iterator, dns_dbnode_t **nodep, dns_name_t *name DNS__DB_FLARG) { - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)iterator->db; - rbtdb_dbiterator_t *rbtdbiter = (rbtdb_dbiterator_t *)iterator; - dns_rbtnode_t *node = rbtdbiter->node; + dns_qpdb_t *qpdb = (dns_qpdb_t *)iterator->db; + qpdb_dbiterator_t *qpdbiter = (qpdb_dbiterator_t *)iterator; + dns_rbtnode_t *node = qpdbiter->node; isc_result_t result; - dns_name_t *nodename = dns_fixedname_name(&rbtdbiter->name); - dns_name_t *origin = dns_fixedname_name(&rbtdbiter->origin); + dns_name_t *nodename = dns_fixedname_name(&qpdbiter->name); + dns_name_t *origin = dns_fixedname_name(&qpdbiter->origin); - REQUIRE(rbtdbiter->result == ISC_R_SUCCESS); - REQUIRE(rbtdbiter->node != NULL); + REQUIRE(qpdbiter->result == ISC_R_SUCCESS); + REQUIRE(qpdbiter->node != NULL); - if (rbtdbiter->paused) { - resume_iteration(rbtdbiter); + if (qpdbiter->paused) { + resume_iteration(qpdbiter); } if (name != NULL) { - if (rbtdbiter->common.relative_names) { + if (qpdbiter->common.relative_names) { origin = NULL; } result = dns_name_concatenate(nodename, origin, name, NULL); if (result != ISC_R_SUCCESS) { return (result); } - if (rbtdbiter->common.relative_names && rbtdbiter->new_origin) { + if (qpdbiter->common.relative_names && qpdbiter->new_origin) { result = DNS_R_NEWORIGIN; } } else { result = ISC_R_SUCCESS; } - dns__rbtdb_newref(rbtdb, node, isc_rwlocktype_none DNS__DB_FLARG_PASS); + dns__qpdb_newref(qpdb, node, isc_rwlocktype_none DNS__DB_FLARG_PASS); - *nodep = rbtdbiter->node; + *nodep = qpdbiter->node; return (result); } static isc_result_t dbiterator_pause(dns_dbiterator_t *iterator) { - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)iterator->db; - rbtdb_dbiterator_t *rbtdbiter = (rbtdb_dbiterator_t *)iterator; + dns_qpdb_t *qpdb = (dns_qpdb_t *)iterator->db; + qpdb_dbiterator_t *qpdbiter = (qpdb_dbiterator_t *)iterator; - if (rbtdbiter->result != ISC_R_SUCCESS && - rbtdbiter->result != ISC_R_NOTFOUND && - rbtdbiter->result != DNS_R_PARTIALMATCH && - rbtdbiter->result != ISC_R_NOMORE) + if (qpdbiter->result != ISC_R_SUCCESS && + qpdbiter->result != ISC_R_NOTFOUND && + qpdbiter->result != DNS_R_PARTIALMATCH && + qpdbiter->result != ISC_R_NOMORE) { - return (rbtdbiter->result); + return (qpdbiter->result); } - if (rbtdbiter->paused) { + if (qpdbiter->paused) { return (ISC_R_SUCCESS); } - rbtdbiter->paused = true; + qpdbiter->paused = true; - if (rbtdbiter->tree_locked == isc_rwlocktype_read) { - TREE_UNLOCK(&rbtdb->tree_lock, &rbtdbiter->tree_locked); + if (qpdbiter->tree_locked == isc_rwlocktype_read) { + TREE_UNLOCK(&qpdb->tree_lock, &qpdbiter->tree_locked); } - INSIST(rbtdbiter->tree_locked == isc_rwlocktype_none); + INSIST(qpdbiter->tree_locked == isc_rwlocktype_none); return (ISC_R_SUCCESS); } static isc_result_t dbiterator_origin(dns_dbiterator_t *iterator, dns_name_t *name) { - rbtdb_dbiterator_t *rbtdbiter = (rbtdb_dbiterator_t *)iterator; - dns_name_t *origin = dns_fixedname_name(&rbtdbiter->origin); + qpdb_dbiterator_t *qpdbiter = (qpdb_dbiterator_t *)iterator; + dns_name_t *origin = dns_fixedname_name(&qpdbiter->origin); - if (rbtdbiter->result != ISC_R_SUCCESS) { - return (rbtdbiter->result); + if (qpdbiter->result != ISC_R_SUCCESS) { + return (qpdbiter->result); } dns_name_copy(origin, name); @@ -4718,7 +4707,7 @@ dbiterator_origin(dns_dbiterator_t *iterator, dns_name_t *name) { } void -dns__rbtdb_freeglue(dns_glue_t *glue_list) { +dns__qpdb_freeglue(dns_glue_t *glue_list) { if (glue_list == (void *)-1) { return; } @@ -4756,11 +4745,11 @@ static void free_gluelist_rcu(struct rcu_head *rcu_head) { dns_glue_t *glue = caa_container_of(rcu_head, dns_glue_t, rcu_head); - dns__rbtdb_freeglue(glue); + dns__qpdb_freeglue(glue); } static void -free_gluetable(dns_rbtdb_version_t *rbtversion) { +free_gluetable(dns_qpdb_version_t *rbtversion) { struct cds_wfs_head *head = __cds_wfs_pop_all(&rbtversion->glue_stack); struct cds_wfs_node *node = NULL, *next = NULL; @@ -4776,24 +4765,24 @@ free_gluetable(dns_rbtdb_version_t *rbtversion) { } void -dns__rbtdb_deletedata(dns_db_t *db ISC_ATTR_UNUSED, - dns_dbnode_t *node ISC_ATTR_UNUSED, void *data) { +dns__qpdb_deletedata(dns_db_t *db ISC_ATTR_UNUSED, + dns_dbnode_t *node ISC_ATTR_UNUSED, void *data) { dns_slabheader_t *header = data; - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)header->db; + dns_qpdb_t *qpdb = (dns_qpdb_t *)header->db; if (header->heap != NULL && header->heap_index != 0) { isc_heap_delete(header->heap, header->heap_index); } - if (IS_CACHE(rbtdb)) { - update_rrsetstats(rbtdb->rrsetstats, header->type, + if (IS_CACHE(qpdb)) { + update_rrsetstats(qpdb->rrsetstats, header->type, atomic_load_acquire(&header->attributes), false); if (ISC_LINK_LINKED(header, link)) { - int idx = RBTDB_HEADERNODE(header)->locknum; - INSIST(IS_CACHE(rbtdb)); - ISC_LIST_UNLINK(rbtdb->lru[idx], header, link); + int idx = QPDB_HEADERNODE(header)->locknum; + INSIST(IS_CACHE(qpdb)); + ISC_LIST_UNLINK(qpdb->lru[idx], header, link); } if (header->noqname != NULL) { @@ -4804,7 +4793,7 @@ dns__rbtdb_deletedata(dns_db_t *db ISC_ATTR_UNUSED, } } else { if (header->glue_list) { - dns__rbtdb_freeglue(header->glue_list); + dns__qpdb_freeglue(header->glue_list); } } } @@ -4813,12 +4802,12 @@ dns__rbtdb_deletedata(dns_db_t *db ISC_ATTR_UNUSED, * Caller must be holding the node write lock. */ static void -expire_ttl_headers(dns_rbtdb_t *rbtdb, unsigned int locknum, +expire_ttl_headers(dns_qpdb_t *qpdb, unsigned int locknum, isc_rwlocktype_t *tlocktypep, isc_stdtime_t now, bool cache_is_overmem DNS__DB_FLARG) { - isc_heap_t *heap = rbtdb->heaps[locknum]; + isc_heap_t *heap = qpdb->heaps[locknum]; - for (size_t i = 0; i < DNS_RBTDB_EXPIRE_TTL_COUNT; i++) { + for (size_t i = 0; i < DNS_QPDB_EXPIRE_TTL_COUNT; i++) { dns_slabheader_t *header = isc_heap_element(heap, 1); if (header == NULL) { @@ -4830,10 +4819,10 @@ expire_ttl_headers(dns_rbtdb_t *rbtdb, unsigned int locknum, if (!cache_is_overmem) { /* Only account for stale TTL if cache is not overmem */ - ttl += STALE_TTL(header, rbtdb); + ttl += STALE_TTL(header, qpdb); } - if (ttl >= now - RBTDB_VIRTUAL) { + if (ttl >= now - QPDB_VIRTUAL) { /* * The header at the top of this TTL heap is not yet * eligible for expiry, so none of the other headers on @@ -4843,26 +4832,25 @@ expire_ttl_headers(dns_rbtdb_t *rbtdb, unsigned int locknum, return; } - dns__cacherbt_expireheader(header, tlocktypep, - dns_expire_ttl DNS__DB_FLARG_PASS); + dns__qpcache_expireheader(header, tlocktypep, + dns_expire_ttl DNS__DB_FLARG_PASS); } } dns_qpdata_t * -dns_qpdata_create(dns_rbtdb_t *rbtdb, const dns_name_t *name) { - dns_qpdata_t *newdata = isc_mem_get(rbtdb->common.mctx, +dns_qpdata_create(dns_qpdb_t *qpdb, const dns_name_t *name) { + dns_qpdata_t *newdata = isc_mem_get(qpdb->common.mctx, sizeof(*newdata)); *newdata = (dns_qpdata_t){ .references = ISC_REFCOUNT_INITIALIZER(1), }; newdata->hashval = dns_name_hash(name); - newdata->locknum = newdata->hashval % rbtdb->node_lock_count; + newdata->locknum = newdata->hashval % qpdb->node_lock_count; newdata->name = dns_fixedname_initname(&newdata->fn); dns_name_copy(name, newdata->name); - isc_mem_attach(rbtdb->common.mctx, &newdata->mctx); + isc_mem_attach(qpdb->common.mctx, &newdata->mctx); ISC_LINK_INIT(newdata, deadlink); - ISC_LINK_INIT(newdata, prunelink); #ifdef DNS_DB_NODETRACE fprintf(stderr, "dns_qpdata_create:%s:%s:%d:%p->references = 1\n", diff --git a/lib/dns/qpdb_p.h b/lib/dns/qpdb_p.h index 92964ecbec..e28f29bcb6 100644 --- a/lib/dns/qpdb_p.h +++ b/lib/dns/qpdb_p.h @@ -26,17 +26,17 @@ * Note that "impmagic" is not the first four bytes of the struct, so * ISC_MAGIC_VALID cannot be used. */ -#define RBTDB_MAGIC ISC_MAGIC('R', 'B', 'D', '4') -#define VALID_RBTDB(rbtdb) \ - ((rbtdb) != NULL && (rbtdb)->common.impmagic == RBTDB_MAGIC) +#define QPDB_MAGIC ISC_MAGIC('Q', 'P', 'D', '4') +#define VALID_QPDB(qpdb) \ + ((qpdb) != NULL && (qpdb)->common.impmagic == QPDB_MAGIC) -#define RBTDB_HEADERNODE(h) ((dns_rbtnode_t *)((h)->node)) +#define QPDB_HEADERNODE(h) ((dns_rbtnode_t *)((h)->node)) /* * Allow clients with a virtual time of up to 5 minutes in the past to see * records that would have otherwise have expired. */ -#define RBTDB_VIRTUAL 300 +#define QPDB_VIRTUAL 300 /***** ***** Module Info @@ -44,7 +44,7 @@ /*! \file * \brief - * DNS RBTDB Implementation (that actually uses qp tries) + * DNS QPDB Implementation (minimally adapted from RBTDB) */ ISC_LANG_BEGINDECLS @@ -108,13 +108,7 @@ struct dns_qpdata { * have no data any longer, but we cannot unlink at that exact moment * because we did not or could not obtain a write lock on the tree. */ - ISC_LINK(dns_rbtdbnode_t) deadlink; - - /*% - * This linked list is used to store nodes from which tree pruning can - * be started. - */ - ISC_LINK(dns_rbtdbnode_t) prunelink; + ISC_LINK(dns_qpdbnode_t) deadlink; /*@{*/ /*! @@ -144,18 +138,18 @@ struct dns_qpdata { /*@}*/ }; -typedef struct rbtdb_changed { +typedef struct qpdb_changed { dns_rbtnode_t *node; bool dirty; - ISC_LINK(struct rbtdb_changed) link; -} rbtdb_changed_t; + ISC_LINK(struct qpdb_changed) link; +} qpdb_changed_t; -typedef ISC_LIST(rbtdb_changed_t) rbtdb_changedlist_t; +typedef ISC_LIST(qpdb_changed_t) qpdb_changedlist_t; -struct dns_rbtdb_version { +struct dns_qpdb_version { /* Not locked */ uint32_t serial; - dns_rbtdb_t *rbtdb; + dns_qpdb_t *qpdb; /* * Protected in the refcount routines. * XXXJT: should we change the lock policy based on the refcount @@ -165,9 +159,9 @@ struct dns_rbtdb_version { /* Locked by database lock. */ bool writer; bool commit_ok; - rbtdb_changedlist_t changed_list; + qpdb_changedlist_t changed_list; dns_slabheaderlist_t resigned_list; - ISC_LINK(dns_rbtdb_version_t) link; + ISC_LINK(dns_qpdb_version_t) link; bool secure; bool havensec3; /* NSEC3 parameters */ @@ -187,9 +181,9 @@ struct dns_rbtdb_version { struct cds_wfs_stack glue_stack; }; -typedef ISC_LIST(dns_rbtdb_version_t) rbtdb_versionlist_t; +typedef ISC_LIST(dns_qpdb_version_t) qpdb_versionlist_t; -struct dns_rbtdb { +struct dns_qpdb { /* Unlocked. */ dns_db_t common; /* Locks the data in this struct */ @@ -210,9 +204,9 @@ struct dns_rbtdb { uint32_t current_serial; uint32_t least_serial; uint32_t next_serial; - dns_rbtdb_version_t *current_version; - dns_rbtdb_version_t *future_version; - rbtdb_versionlist_t open_versions; + dns_qpdb_version_t *current_version; + dns_qpdb_version_t *future_version; + qpdb_versionlist_t open_versions; isc_loop_t *loop; dns_dbnode_t *soanode; dns_dbnode_t *nsnode; @@ -271,8 +265,8 @@ struct dns_rbtdb { * Search Context */ typedef struct { - dns_rbtdb_t *rbtdb; - dns_rbtdb_version_t *rbtversion; + dns_qpdb_t *qpdb; + dns_qpdb_version_t *rbtversion; uint32_t serial; unsigned int options; dns_rbtnodechain_t chain; @@ -284,7 +278,7 @@ typedef struct { dns_slabheader_t *zonecut_sigheader; dns_fixedname_t zonecut_name; isc_stdtime_t now; -} rbtdb_search_t; +} qpdb_search_t; /*% * Load Context @@ -292,7 +286,7 @@ typedef struct { typedef struct { dns_db_t *db; isc_stdtime_t now; -} rbtdb_load_t; +} qpdb_load_t; /*% * Prune context @@ -300,10 +294,10 @@ typedef struct { typedef struct { dns_db_t *db; dns_rbtnode_t *node; -} prune_t; +} qpdb_prune_t; -extern dns_dbmethods_t dns__rbtdb_zonemethods; -extern dns_dbmethods_t dns__rbtdb_cachemethods; +extern dns_dbmethods_t dns__qpdb_zonemethods; +extern dns_dbmethods_t dns__qpdb_cachemethods; /* * Common DB implementation methods shared by both cache and zone RBT @@ -311,9 +305,9 @@ extern dns_dbmethods_t dns__rbtdb_cachemethods; */ isc_result_t -dns__rbtdb_create(isc_mem_t *mctx, const dns_name_t *base, dns_dbtype_t type, - dns_rdataclass_t rdclass, unsigned int argc, char *argv[], - void *driverarg, dns_db_t **dbp); +dns__qpdb_create(isc_mem_t *mctx, const dns_name_t *base, dns_dbtype_t type, + dns_rdataclass_t rdclass, unsigned int argc, char *argv[], + void *driverarg, dns_db_t **dbp); /*%< * Create a new database of type "rbt". Called via dns_db_create(); * see documentation for that function for more details. @@ -328,22 +322,22 @@ dns__rbtdb_create(isc_mem_t *mctx, const dns_name_t *base, dns_dbtype_t type, */ void -dns__rbtdb_destroy(dns_db_t *arg); +dns__qpdb_destroy(dns_db_t *arg); /*%< * Implement dns_db_destroy() for RBT databases, see documentation * for that function for more details. */ void -dns__rbtdb_currentversion(dns_db_t *db, dns_dbversion_t **versionp); +dns__qpdb_currentversion(dns_db_t *db, dns_dbversion_t **versionp); isc_result_t -dns__rbtdb_newversion(dns_db_t *db, dns_dbversion_t **versionp); +dns__qpdb_newversion(dns_db_t *db, dns_dbversion_t **versionp); void -dns__rbtdb_attachversion(dns_db_t *db, dns_dbversion_t *source, - dns_dbversion_t **targetp); +dns__qpdb_attachversion(dns_db_t *db, dns_dbversion_t *source, + dns_dbversion_t **targetp); void -dns__rbtdb_closeversion(dns_db_t *db, dns_dbversion_t **versionp, - bool commit DNS__DB_FLARG); +dns__qpdb_closeversion(dns_db_t *db, dns_dbversion_t **versionp, + bool commit DNS__DB_FLARG); /*%< * Implement the dns_db_currentversion(), _newversion(), * _attachversion() and _closeversion() methods for RBT databases; @@ -351,58 +345,58 @@ dns__rbtdb_closeversion(dns_db_t *db, dns_dbversion_t **versionp, */ isc_result_t -dns__rbtdb_findnode(dns_db_t *db, const dns_name_t *name, bool create, - dns_dbnode_t **nodep DNS__DB_FLARG); +dns__qpdb_findnode(dns_db_t *db, const dns_name_t *name, bool create, + dns_dbnode_t **nodep DNS__DB_FLARG); isc_result_t -dns__rbtdb_findnodeintree(dns_rbtdb_t *rbtdb, dns_qp_t *tree, - const dns_name_t *name, bool create, - dns_dbnode_t **nodep DNS__DB_FLARG); +dns__qpdb_findnodeintree(dns_qpdb_t *qpdb, dns_qp_t *tree, + const dns_name_t *name, bool create, + dns_dbnode_t **nodep DNS__DB_FLARG); /*%< * Implement the dns_db_findnode() and _findnodeintree() methods for * RBT databases; see documentation of those functions for more details. */ void -dns__rbtdb_attachnode(dns_db_t *db, dns_dbnode_t *source, - dns_dbnode_t **targetp DNS__DB_FLARG); +dns__qpdb_attachnode(dns_db_t *db, dns_dbnode_t *source, + dns_dbnode_t **targetp DNS__DB_FLARG); void -dns__rbtdb_detachnode(dns_db_t *db, dns_dbnode_t **targetp DNS__DB_FLARG); +dns__qpdb_detachnode(dns_db_t *db, dns_dbnode_t **targetp DNS__DB_FLARG); /*%< * Implement the dns_db_attachnode() and _detachnode() methods for * RBT databases; see documentation of those functions for more details. */ isc_result_t -dns__rbtdb_createiterator(dns_db_t *db, unsigned int options, - dns_dbiterator_t **iteratorp); +dns__qpdb_createiterator(dns_db_t *db, unsigned int options, + dns_dbiterator_t **iteratorp); /*%< * Implement dns_db_createiterator() for RBT databases; see documentation of * that function for more details. */ isc_result_t -dns__rbtdb_allrdatasets(dns_db_t *db, dns_dbnode_t *node, - dns_dbversion_t *version, unsigned int options, - isc_stdtime_t now, - dns_rdatasetiter_t **iteratorp DNS__DB_FLARG); +dns__qpdb_allrdatasets(dns_db_t *db, dns_dbnode_t *node, + dns_dbversion_t *version, unsigned int options, + isc_stdtime_t now, + dns_rdatasetiter_t **iteratorp DNS__DB_FLARG); /*%< * Implement dns_db_allrdatasets() for RBT databases; see documentation of * that function for more details. */ isc_result_t -dns__rbtdb_addrdataset(dns_db_t *db, dns_dbnode_t *node, - dns_dbversion_t *version, isc_stdtime_t now, - dns_rdataset_t *rdataset, unsigned int options, - dns_rdataset_t *addedrdataset DNS__DB_FLARG); +dns__qpdb_addrdataset(dns_db_t *db, dns_dbnode_t *node, + dns_dbversion_t *version, isc_stdtime_t now, + dns_rdataset_t *rdataset, unsigned int options, + dns_rdataset_t *addedrdataset DNS__DB_FLARG); isc_result_t -dns__rbtdb_subtractrdataset(dns_db_t *db, dns_dbnode_t *node, - dns_dbversion_t *version, dns_rdataset_t *rdataset, - unsigned int options, - dns_rdataset_t *newrdataset DNS__DB_FLARG); +dns__qpdb_subtractrdataset(dns_db_t *db, dns_dbnode_t *node, + dns_dbversion_t *version, dns_rdataset_t *rdataset, + unsigned int options, + dns_rdataset_t *newrdataset DNS__DB_FLARG); isc_result_t -dns__rbtdb_deleterdataset(dns_db_t *db, dns_dbnode_t *node, - dns_dbversion_t *version, dns_rdatatype_t type, - dns_rdatatype_t covers DNS__DB_FLARG); +dns__qpdb_deleterdataset(dns_db_t *db, dns_dbnode_t *node, + dns_dbversion_t *version, dns_rdatatype_t type, + dns_rdatatype_t covers DNS__DB_FLARG); /*%< * Implement the dns_db_addrdataset(), _subtractrdataset() and * _deleterdataset() methods for RBT databases; see documentation of @@ -410,38 +404,38 @@ dns__rbtdb_deleterdataset(dns_db_t *db, dns_dbnode_t *node, */ unsigned int -dns__rbtdb_nodecount(dns_db_t *db, dns_dbtree_t tree); +dns__qpdb_nodecount(dns_db_t *db, dns_dbtree_t tree); /*%< * Implement dns_db_nodecount() for RBT databases; see documentation of * that function for more details. */ void -dns__rbtdb_setloop(dns_db_t *db, isc_loop_t *loop); +dns__qpdb_setloop(dns_db_t *db, isc_loop_t *loop); /*%< * Implement dns_db_setloop() for RBT databases; see documentation of * that function for more details. */ isc_result_t -dns__rbtdb_getoriginnode(dns_db_t *db, dns_dbnode_t **nodep DNS__DB_FLARG); +dns__qpdb_getoriginnode(dns_db_t *db, dns_dbnode_t **nodep DNS__DB_FLARG); /*%< * Implement dns_db_getoriginnode() for RBT databases; see documentation of * that function for more details. */ void -dns__rbtdb_deletedata(dns_db_t *db ISC_ATTR_UNUSED, - dns_dbnode_t *node ISC_ATTR_UNUSED, void *data); +dns__qpdb_deletedata(dns_db_t *db ISC_ATTR_UNUSED, + dns_dbnode_t *node ISC_ATTR_UNUSED, void *data); /*%< * Implement dns_db_deletedata() for RBT databases; see documentation of * that function for more details. */ void -dns__rbtdb_locknode(dns_db_t *db, dns_dbnode_t *node, isc_rwlocktype_t type); +dns__qpdb_locknode(dns_db_t *db, dns_dbnode_t *node, isc_rwlocktype_t type); void -dns__rbtdb_unlocknode(dns_db_t *db, dns_dbnode_t *node, isc_rwlocktype_t type); +dns__qpdb_unlocknode(dns_db_t *db, dns_dbnode_t *node, isc_rwlocktype_t type); /*%< * Implement the dns_db_locknode() and _unlocknode() methods for * RBT databases; see documentation of those functions for more details. @@ -449,24 +443,24 @@ dns__rbtdb_unlocknode(dns_db_t *db, dns_dbnode_t *node, isc_rwlocktype_t type); /*% * Functions used for the RBT implementation which are defined and - * used in rbtdb.c but may also be called from rbt-zonedb.c or + * used in qpdb.c but may also be called from rbt-zonedb.c or * rbt-cachedb.c: */ void -dns__rbtdb_bindrdataset(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, - dns_slabheader_t *header, isc_stdtime_t now, - isc_rwlocktype_t locktype, - dns_rdataset_t *rdataset DNS__DB_FLARG); +dns__qpdb_bindrdataset(dns_qpdb_t *qpdb, dns_rbtnode_t *node, + dns_slabheader_t *header, isc_stdtime_t now, + isc_rwlocktype_t locktype, + dns_rdataset_t *rdataset DNS__DB_FLARG); isc_result_t -dns__rbtdb_nodefullname(dns_db_t *db, dns_dbnode_t *node, dns_name_t *name); +dns__qpdb_nodefullname(dns_db_t *db, dns_dbnode_t *node, dns_name_t *name); void -dns__rbtdb_freeglue(dns_glue_t *glue_list); +dns__qpdb_freeglue(dns_glue_t *glue_list); void -dns__rbtdb_newref(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, - isc_rwlocktype_t locktype DNS__DB_FLARG); +dns__qpdb_newref(dns_qpdb_t *qpdb, dns_rbtnode_t *node, + isc_rwlocktype_t locktype DNS__DB_FLARG); /*%< * Increment the reference counter to a node in an RBT database. * If the caller holds a node lock then its lock type is specified @@ -476,10 +470,9 @@ dns__rbtdb_newref(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, */ bool -dns__rbtdb_decref(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, - uint32_t least_serial, isc_rwlocktype_t *nlocktypep, - isc_rwlocktype_t *tlocktypep, bool tryupgrade, - bool pruning DNS__DB_FLARG); +dns__qpdb_decref(dns_qpdb_t *qpdb, dns_rbtnode_t *node, uint32_t least_serial, + isc_rwlocktype_t *nlocktypep, isc_rwlocktype_t *tlocktypep, + bool tryupgrade, bool pruning DNS__DB_FLARG); /*%< * Decrement the reference counter to a node in an RBT database. * 'nlocktypep' and 'tlocktypep' are pointers to the current status @@ -490,18 +483,18 @@ dns__rbtdb_decref(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, */ isc_result_t -dns__rbtdb_add(dns_rbtdb_t *rbtdb, dns_rbtnode_t *rbtnode, - const dns_name_t *nodename, dns_rbtdb_version_t *rbtversion, - dns_slabheader_t *newheader, unsigned int options, bool loading, - dns_rdataset_t *addedrdataset, isc_stdtime_t now DNS__DB_FLARG); +dns__qpdb_add(dns_qpdb_t *qpdb, dns_rbtnode_t *rbtnode, + const dns_name_t *nodename, dns_qpdb_version_t *rbtversion, + dns_slabheader_t *newheader, unsigned int options, bool loading, + dns_rdataset_t *addedrdataset, isc_stdtime_t now DNS__DB_FLARG); /*%< * Add a slab header 'newheader' to a node in an RBT database. * The caller must have the node write-locked. */ void -dns__rbtdb_setsecure(dns_db_t *db, dns_rbtdb_version_t *version, - dns_dbnode_t *origin); +dns__qpdb_setsecure(dns_db_t *db, dns_qpdb_version_t *version, + dns_dbnode_t *origin); /*%< * Update the secure status for an RBT database version 'version'. * The version will be marked secure if it is fully signed and @@ -509,7 +502,7 @@ dns__rbtdb_setsecure(dns_db_t *db, dns_rbtdb_version_t *version, */ void -dns__rbtdb_mark(dns_slabheader_t *header, uint_least16_t flag); +dns__qpdb_mark(dns_slabheader_t *header, uint_least16_t flag); /*%< * Set attribute 'flag' in a slab header 'header' - for example, * DNS_SLABHEADERATTR_STALE or DNS_SLABHEADERATTR_ANCIENT - and, @@ -517,31 +510,30 @@ dns__rbtdb_mark(dns_slabheader_t *header, uint_least16_t flag); */ void -dns__rbtdb_setttl(dns_slabheader_t *header, dns_ttl_t newttl); +dns__qpdb_setttl(dns_slabheader_t *header, dns_ttl_t newttl); /*%< * Set the TTL in a slab header 'header'. In a cache database, * also update the TTL heap accordingly. */ /* - * Functions specific to zone databases that are also called from rbtdb.c. + * Functions specific to zone databases that are also called from qpdb.c. */ void -dns__zonerbt_resigninsert(dns_rbtdb_t *rbtdb, int idx, - dns_slabheader_t *newheader); +dns__qpzone_resigninsert(dns_qpdb_t *qpdb, int idx, + dns_slabheader_t *newheader); void -dns__zonerbt_resigndelete(dns_rbtdb_t *rbtdb, dns_rbtdb_version_t *version, - dns_slabheader_t *header DNS__DB_FLARG); +dns__qpzone_resigndelete(dns_qpdb_t *qpdb, dns_qpdb_version_t *version, + dns_slabheader_t *header DNS__DB_FLARG); /*%< * Insert/delete a node from the zone database's resigning heap. */ isc_result_t -dns__zonerbt_wildcardmagic(dns_rbtdb_t *rbtdb, const dns_name_t *name, - bool lock); +dns__qpzone_wildcardmagic(dns_qpdb_t *qpdb, const dns_name_t *name, bool lock); /*%< * Add the necessary magic for the wildcard name 'name' - * to be found in 'rbtdb'. + * to be found in 'qpdb'. * * In order for wildcard matching to work correctly in * zone_find(), we must ensure that a node for the wildcarding @@ -555,29 +547,28 @@ dns__zonerbt_wildcardmagic(dns_rbtdb_t *rbtdb, const dns_name_t *name, * The tree must be write-locked. */ isc_result_t -dns__zonerbt_addwildcards(dns_rbtdb_t *rbtdb, const dns_name_t *name, - bool lock); +dns__qpzone_addwildcards(dns_qpdb_t *qpdb, const dns_name_t *name, bool lock); /*%< * If 'name' is or contains a wildcard name, create a node for it in the * database. The tree must be write-locked. */ /* - * Cache-specific functions that are called from rbtdb.c + * Cache-specific functions that are called from qpdb.c */ void -dns__cacherbt_expireheader(dns_slabheader_t *header, - isc_rwlocktype_t *tlocktypep, - dns_expire_t reason DNS__DB_FLARG); +dns__qpcache_expireheader(dns_slabheader_t *header, + isc_rwlocktype_t *tlocktypep, + dns_expire_t reason DNS__DB_FLARG); void -dns__cacherbt_overmem(dns_rbtdb_t *rbtdb, dns_slabheader_t *newheader, - isc_rwlocktype_t *tlocktypep DNS__DB_FLARG); +dns__qpcache_overmem(dns_qpdb_t *qpdb, dns_slabheader_t *newheader, + isc_rwlocktype_t *tlocktypep DNS__DB_FLARG); /* * Create a new qpdata node. */ dns_qpdata_t * -dns_qpdata_create(dns_rbtdb_t *rbtdb, const dns_name_t *name); +dns_qpdata_create(dns_qpdb_t *qpdb, const dns_name_t *name); /* * Destroy a qpdata node. diff --git a/lib/dns/rbtdb.c b/lib/dns/rbtdb.c index 5be2ae23e7..76c69afdfb 100644 --- a/lib/dns/rbtdb.c +++ b/lib/dns/rbtdb.c @@ -1192,8 +1192,8 @@ is_leaf(dns_rbtnode_t *node) { static void send_to_prune_tree(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, isc_rwlocktype_t nlocktype DNS__DB_FLARG) { - prune_t *prune = isc_mem_get(rbtdb->common.mctx, sizeof(*prune)); - *prune = (prune_t){ .node = node }; + rbtdb_prune_t *prune = isc_mem_get(rbtdb->common.mctx, sizeof(*prune)); + *prune = (rbtdb_prune_t){ .node = node }; dns_db_attach((dns_db_t *)rbtdb, &prune->db); dns__rbtdb_newref(rbtdb, node, nlocktype DNS__DB_FLARG_PASS); @@ -1501,7 +1501,7 @@ restore_locks: */ static void prune_tree(void *arg) { - prune_t *prune = (prune_t *)arg; + rbtdb_prune_t *prune = (rbtdb_prune_t *)arg; dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)prune->db; dns_rbtnode_t *node = prune->node; dns_rbtnode_t *parent = NULL; diff --git a/lib/dns/rbtdb_p.h b/lib/dns/rbtdb_p.h index 401bccc00e..46da32691a 100644 --- a/lib/dns/rbtdb_p.h +++ b/lib/dns/rbtdb_p.h @@ -204,7 +204,7 @@ typedef struct { typedef struct { dns_db_t *db; dns_rbtnode_t *node; -} prune_t; +} rbtdb_prune_t; extern dns_dbmethods_t dns__rbtdb_zonemethods; extern dns_dbmethods_t dns__rbtdb_cachemethods; diff --git a/tests/dns/Makefile.am b/tests/dns/Makefile.am index 005a97860b..ae89c40077 100644 --- a/tests/dns/Makefile.am +++ b/tests/dns/Makefile.am @@ -35,8 +35,8 @@ check_PROGRAMS = \ private_test \ qp_test \ qpmulti_test \ + qpdb_test \ rbt_test \ - rbtdb_test \ rdata_test \ rdataset_test \ rdatasetstats_test \ diff --git a/tests/dns/rbtdb_test.c b/tests/dns/qpdb_test.c similarity index 95% rename from tests/dns/rbtdb_test.c rename to tests/dns/qpdb_test.c index c6db261f59..0696289e45 100644 --- a/tests/dns/rbtdb_test.c +++ b/tests/dns/qpdb_test.c @@ -36,7 +36,7 @@ #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wshadow" #undef CHECK -#include "rbtdb.c" +#include "qpdb.c" #pragma GCC diagnostic pop #undef CHECK @@ -97,20 +97,20 @@ static bool ownercase_test_one(const char *str1, const char *str2) { isc_result_t result; db_nodelock_t node_locks[1]; - dns_rbtdb_t rbtdb = { - .common.methods = &dns__rbtdb_zonemethods, + dns_qpdb_t qpdb = { + .common.methods = &dns__qpdb_zonemethods, .common.mctx = mctx, .node_locks = node_locks, }; dns_rbtnode_t rbtnode = { .locknum = 0 }; dns_slabheader_t header = { .node = &rbtnode, - .db = (dns_db_t *)&rbtdb, + .db = (dns_db_t *)&qpdb, }; unsigned char *raw = (unsigned char *)(&header) + sizeof(header); dns_rdataset_t rdataset = { .magic = DNS_RDATASET_MAGIC, - .slab = { .db = (dns_db_t *)&rbtdb, + .slab = { .db = (dns_db_t *)&qpdb, .node = &rbtnode, .raw = raw }, .methods = &dns_rdataslab_rdatasetmethods, @@ -122,7 +122,7 @@ ownercase_test_one(const char *str1, const char *str2) { memset(node_locks, 0, sizeof(node_locks)); /* Minimal initialization of the mock objects */ - NODE_INITLOCK(&rbtdb.node_locks[0].lock); + NODE_INITLOCK(&qpdb.node_locks[0].lock); isc_buffer_constinit(&b, str1, strlen(str1)); isc_buffer_add(&b, strlen(str1)); @@ -142,7 +142,7 @@ ownercase_test_one(const char *str1, const char *str2) { /* Retrieve the case to name2 */ dns_rdataset_getownercase(&rdataset, name2); - NODE_DESTROYLOCK(&rbtdb.node_locks[0].lock); + NODE_DESTROYLOCK(&qpdb.node_locks[0].lock); return (dns_name_caseequal(name1, name2)); } @@ -164,20 +164,20 @@ ISC_RUN_TEST_IMPL(ownercase) { ISC_RUN_TEST_IMPL(setownercase) { isc_result_t result; db_nodelock_t node_locks[1]; - dns_rbtdb_t rbtdb = { - .common.methods = &dns__rbtdb_zonemethods, + dns_qpdb_t qpdb = { + .common.methods = &dns__qpdb_zonemethods, .common.mctx = mctx, .node_locks = node_locks, }; dns_rbtnode_t rbtnode = { .locknum = 0 }; dns_slabheader_t header = { .node = &rbtnode, - .db = (dns_db_t *)&rbtdb, + .db = (dns_db_t *)&qpdb, }; unsigned char *raw = (unsigned char *)(&header) + sizeof(header); dns_rdataset_t rdataset = { .magic = DNS_RDATASET_MAGIC, - .slab = { .db = (dns_db_t *)&rbtdb, + .slab = { .db = (dns_db_t *)&qpdb, .node = &rbtnode, .raw = raw }, .methods = &dns_rdataslab_rdatasetmethods, @@ -193,7 +193,7 @@ ISC_RUN_TEST_IMPL(setownercase) { /* Minimal initialization of the mock objects */ memset(node_locks, 0, sizeof(node_locks)); - NODE_INITLOCK(&rbtdb.node_locks[0].lock); + NODE_INITLOCK(&qpdb.node_locks[0].lock); isc_buffer_constinit(&b, str1, strlen(str1)); isc_buffer_add(&b, strlen(str1)); @@ -210,7 +210,7 @@ ISC_RUN_TEST_IMPL(setownercase) { /* Retrieve the case to name2 */ dns_rdataset_getownercase(&rdataset, name2); - NODE_DESTROYLOCK(&rbtdb.node_locks[0].lock); + NODE_DESTROYLOCK(&qpdb.node_locks[0].lock); assert_true(dns_name_caseequal(name1, name2)); }