diff --git a/lib/dns/include/dns/types.h b/lib/dns/include/dns/types.h index c09aba40ed..b938d13752 100644 --- a/lib/dns/include/dns/types.h +++ b/lib/dns/include/dns/types.h @@ -149,11 +149,12 @@ typedef struct dns_requestmgr dns_requestmgr_t; typedef struct dns_resolver dns_resolver_t; typedef struct dns_rpsdb dns_rpsdb_t; typedef struct dns_qpdata dns_qpdata_t; -typedef struct dns_qpnode dns_qpnode_t; -typedef uint8_t dns_secalg_t; -typedef uint8_t dns_secproto_t; -typedef struct dns_signature dns_signature_t; -typedef struct dns_slabheader dns_slabheader_t; +typedef ISC_LIST(dns_qpdata_t) dns_qpdatalist_t; +typedef struct dns_qpnode dns_qpnode_t; +typedef uint8_t dns_secalg_t; +typedef uint8_t dns_secproto_t; +typedef struct dns_signature dns_signature_t; +typedef struct dns_slabheader dns_slabheader_t; typedef ISC_LIST(dns_slabheader_t) dns_slabheaderlist_t; typedef struct dns_sortlist_arg dns_sortlist_arg_t; typedef struct dns_ssurule dns_ssurule_t; diff --git a/lib/dns/qp-cachedb.c b/lib/dns/qp-cachedb.c index b063ad7a2a..4f522399ca 100644 --- a/lib/dns/qp-cachedb.c +++ b/lib/dns/qp-cachedb.c @@ -266,7 +266,7 @@ setup_delegation(qpdb_search_t *search, dns_dbnode_t **nodep, dns_rdataset_t *sigrdataset DNS__DB_FLARG) { dns_name_t *zcname = NULL; dns_typepair_t type; - dns_rbtnode_t *node = NULL; + dns_qpdata_t *node = NULL; REQUIRE(search != NULL); REQUIRE(search->zonecut != NULL); @@ -323,7 +323,7 @@ setup_delegation(qpdb_search_t *search, dns_dbnode_t **nodep, } static bool -check_stale_header(dns_rbtnode_t *node, dns_slabheader_t *header, +check_stale_header(dns_qpdata_t *node, dns_slabheader_t *header, isc_rwlocktype_t *nlocktypep, isc_rwlock_t *lock, qpdb_search_t *search, dns_slabheader_t **header_prev) { if (!ACTIVE(header, search->now)) { @@ -430,7 +430,7 @@ check_stale_header(dns_rbtnode_t *node, dns_slabheader_t *header, } static isc_result_t -check_zonecut(dns_rbtnode_t *node, void *arg DNS__DB_FLARG) { +check_zonecut(dns_qpdata_t *node, void *arg DNS__DB_FLARG) { qpdb_search_t *search = arg; dns_slabheader_t *header = NULL; dns_slabheader_t *header_prev = NULL, *header_next = NULL; @@ -493,7 +493,7 @@ check_zonecut(dns_rbtnode_t *node, void *arg DNS__DB_FLARG) { } static isc_result_t -find_deepest_zonecut(qpdb_search_t *search, dns_rbtnode_t *node, +find_deepest_zonecut(qpdb_search_t *search, dns_qpdata_t *node, dns_dbnode_t **nodep, dns_name_t *foundname, dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset DNS__DB_FLARG) { @@ -620,7 +620,7 @@ find_coveringnsec(qpdb_search_t *search, const dns_name_t *name, dns_rdataset_t *sigrdataset DNS__DB_FLARG) { dns_fixedname_t fpredecessor, fixed; dns_name_t *predecessor = NULL, *fname = NULL; - dns_rbtnode_t *node = NULL; + dns_qpdata_t *node = NULL; dns_qpiter_t iter; isc_result_t result; isc_rwlocktype_t nlocktype = isc_rwlocktype_none; @@ -717,7 +717,7 @@ cache_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, dns_dbnode_t **nodep, dns_name_t *foundname, dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset DNS__DB_FLARG) { - dns_rbtnode_t *node = NULL; + dns_qpdata_t *node = NULL; isc_result_t result; qpdb_search_t search; bool cname_ok = true; @@ -774,7 +774,7 @@ cache_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, for (unsigned int i = 0; i < len; i++) { isc_result_t zcresult; - dns_rbtnode_t *encloser = NULL; + dns_qpdata_t *encloser = NULL; dns_qpchain_node(&search.chain, i, NULL, (void **)&encloser, NULL); @@ -1163,7 +1163,7 @@ cache_findzonecut(dns_db_t *db, const dns_name_t *name, unsigned int options, dns_name_t *foundname, dns_name_t *dcname, dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset DNS__DB_FLARG) { - dns_rbtnode_t *node = NULL; + dns_qpdata_t *node = NULL; isc_rwlock_t *lock = NULL; isc_result_t result; qpdb_search_t search; @@ -1339,7 +1339,7 @@ cache_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, isc_stdtime_t now, dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset DNS__DB_FLARG) { dns_qpdb_t *qpdb = (dns_qpdb_t *)db; - dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node; + dns_qpdata_t *qpnode = (dns_qpdata_t *)node; dns_slabheader_t *header = NULL, *header_next = NULL; dns_slabheader_t *found = NULL, *foundsig = NULL; dns_typepair_t matchtype, sigmatchtype, negtype; @@ -1358,7 +1358,7 @@ cache_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, now = isc_stdtime_now(); } - lock = &qpdb->node_locks[rbtnode->locknum].lock; + lock = &qpdb->node_locks[qpnode->locknum].lock; NODE_RDLOCK(lock, &nlocktype); matchtype = DNS_TYPEPAIR_VALUE(type, covers); @@ -1369,7 +1369,7 @@ cache_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, sigmatchtype = 0; } - for (header = rbtnode->data; header != NULL; header = header_next) { + for (header = qpnode->data; header != NULL; header = header_next) { header_next = header->next; if (!ACTIVE(header, now)) { if ((header->ttl + STALE_TTL(header, qpdb) < @@ -1382,9 +1382,9 @@ cache_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, * We update the node's status only when we * can get write access. * - * We don't check if refcurrent(rbtnode) == 0 + * We don't check if refcurrent(qpnode) == 0 * and try to free like we do in cache_find(), - * because refcurrent(rbtnode) must be + * because refcurrent(qpnode) must be * non-zero. This is so because 'node' is an * argument to the function. */ @@ -1405,10 +1405,10 @@ cache_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, } } if (found != NULL) { - dns__qpdb_bindrdataset(qpdb, rbtnode, found, now, nlocktype, + dns__qpdb_bindrdataset(qpdb, qpnode, found, now, nlocktype, rdataset DNS__DB_FLARG_PASS); if (!NEGATIVE(found) && foundsig != NULL) { - dns__qpdb_bindrdataset(qpdb, rbtnode, foundsig, now, + dns__qpdb_bindrdataset(qpdb, qpnode, foundsig, now, nlocktype, sigrdataset DNS__DB_FLARG_PASS); } @@ -1522,15 +1522,15 @@ getservestalerefresh(dns_db_t *db, uint32_t *interval) { static void expiredata(dns_db_t *db, dns_dbnode_t *node, void *data) { dns_qpdb_t *qpdb = (dns_qpdb_t *)db; - dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node; + dns_qpdata_t *qpnode = (dns_qpdata_t *)node; dns_slabheader_t *header = data; isc_rwlocktype_t nlocktype = isc_rwlocktype_none; isc_rwlocktype_t tlocktype = isc_rwlocktype_none; - NODE_WRLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype); + NODE_WRLOCK(&qpdb->node_locks[qpnode->locknum].lock, &nlocktype); dns__qpcache_expireheader(header, &tlocktype, - dns_expire_flush DNS__DB_FLARG_PASS); - NODE_UNLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype); + dns_expire_flush DNS__DB_FILELINE); + NODE_UNLOCK(&qpdb->node_locks[qpnode->locknum].lock, &nlocktype); INSIST(tlocktype == isc_rwlocktype_none); } @@ -1667,8 +1667,7 @@ dns__qpcache_overmem(dns_qpdb_t *qpdb, dns_slabheader_t *newheader, 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(QPDB_HEADERNODE(newheader)); + size_t purgesize = rdataset_size(newheader) + 2 * sizeof(dns_qpdata_t); size_t purged = 0; isc_stdtime_t min_last_used = 0; size_t max_passes = 8; diff --git a/lib/dns/qp-zonedb.c b/lib/dns/qp-zonedb.c index 57fcaa5765..f5a14a33ef 100644 --- a/lib/dns/qp-zonedb.c +++ b/lib/dns/qp-zonedb.c @@ -103,14 +103,14 @@ findnsec3node(dns_db_t *db, const dns_name_t *name, bool create, } static isc_result_t -check_zonecut(dns_rbtnode_t *node, void *arg DNS__DB_FLARG) { +check_zonecut(dns_qpdata_t *node, void *arg DNS__DB_FLARG) { 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; dns_slabheader_t *found = NULL; isc_result_t result = DNS_R_CONTINUE; - dns_rbtnode_t *onode = NULL; + dns_qpdata_t *onode = NULL; isc_rwlocktype_t nlocktype = isc_rwlocktype_none; /* @@ -256,7 +256,7 @@ setup_delegation(qpdb_search_t *search, dns_dbnode_t **nodep, dns_rdataset_t *sigrdataset DNS__DB_FLARG) { dns_name_t *zcname = NULL; dns_typepair_t type; - dns_rbtnode_t *node = NULL; + dns_qpdata_t *node = NULL; REQUIRE(search != NULL); REQUIRE(search->zonecut != NULL); @@ -326,7 +326,7 @@ step(qpdb_search_t *search, dns_qpiter_t *iter, direction_t direction, dns_fixedname_t fnodename; dns_name_t *nodename = dns_fixedname_initname(&fnodename); dns_qpdb_t *qpdb = NULL; - dns_rbtnode_t *node = NULL; + dns_qpdata_t *node = NULL; isc_result_t result = ISC_R_SUCCESS; dns_slabheader_t *header = NULL; @@ -464,7 +464,7 @@ wildcard_blocked(qpdb_search_t *search, const dns_name_t *qname, } static isc_result_t -find_wildcard(qpdb_search_t *search, dns_rbtnode_t **nodep, +find_wildcard(qpdb_search_t *search, dns_qpdata_t **nodep, const dns_name_t *qname) { dns_slabheader_t *header = NULL; isc_result_t result = ISC_R_NOTFOUND; @@ -488,7 +488,7 @@ find_wildcard(qpdb_search_t *search, dns_rbtnode_t **nodep, qpdb = search->qpdb; for (int i = dns_qpchain_length(&search->chain) - 1; i >= 0; i--) { - dns_rbtnode_t *node = NULL; + dns_qpdata_t *node = NULL; isc_rwlock_t *lock = NULL; isc_rwlocktype_t nlocktype = isc_rwlocktype_none; @@ -516,7 +516,7 @@ find_wildcard(qpdb_search_t *search, dns_rbtnode_t **nodep, NODE_UNLOCK(lock, &nlocktype); if (wild) { - dns_rbtnode_t *wnode = NULL; + dns_qpdata_t *wnode = NULL; dns_fixedname_t fwname; dns_name_t *wname = NULL; dns_qpiter_t witer; @@ -638,11 +638,11 @@ matchparams(dns_slabheader_t *header, qpdb_search_t *search) { static isc_result_t previous_closest_nsec(dns_rdatatype_t type, qpdb_search_t *search, dns_name_t *name, dns_name_t *origin, - dns_rbtnode_t **nodep, dns_qpiter_t *nseciter, + dns_qpdata_t **nodep, dns_qpiter_t *nseciter, bool *firstp) { dns_fixedname_t ftarget; dns_name_t *target = NULL; - dns_rbtnode_t *nsecnode = NULL; + dns_qpdata_t *nsecnode = NULL; isc_result_t result; REQUIRE(nodep != NULL && *nodep == NULL); @@ -741,7 +741,7 @@ 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) { - dns_rbtnode_t *node = NULL, *prevnode = NULL; + dns_qpdata_t *node = NULL, *prevnode = NULL; dns_slabheader_t *header = NULL, *header_next = NULL; dns_qpiter_t nseciter; bool empty_node; @@ -933,7 +933,7 @@ zone_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, isc_stdtime_t now ISC_ATTR_UNUSED, dns_dbnode_t **nodep, dns_name_t *foundname, dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset DNS__DB_FLARG) { - dns_rbtnode_t *node = NULL; + dns_qpdata_t *node = NULL; isc_result_t result; qpdb_search_t search; bool cname_ok = true; @@ -997,7 +997,7 @@ zone_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, for (unsigned int i = 0; i < len; i++) { isc_result_t zcresult; - dns_rbtnode_t *encloser = NULL; + dns_qpdata_t *encloser = NULL; dns_qpchain_node(&search.chain, i, NULL, (void **)&encloser, NULL); @@ -1471,7 +1471,7 @@ zone_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, isc_stdtime_t now, dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset DNS__DB_FLARG) { dns_qpdb_t *qpdb = (dns_qpdb_t *)db; - dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node; + dns_qpdata_t *qpnode = (dns_qpdata_t *)node; dns_slabheader_t *header = NULL, *header_next = NULL; dns_slabheader_t *found = NULL, *foundsig = NULL; uint32_t serial; @@ -1492,7 +1492,7 @@ zone_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, serial = rbtversion->serial; now = 0; - NODE_RDLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype); + NODE_RDLOCK(&qpdb->node_locks[qpnode->locknum].lock, &nlocktype); matchtype = DNS_TYPEPAIR_VALUE(type, covers); if (covers == 0) { @@ -1501,7 +1501,7 @@ zone_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, sigmatchtype = 0; } - for (header = rbtnode->data; header != NULL; header = header_next) { + for (header = qpnode->data; header != NULL; header = header_next) { header_next = header->next; do { if (header->serial <= serial && !IGNORE(header)) { @@ -1536,17 +1536,17 @@ zone_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, } } if (found != NULL) { - dns__qpdb_bindrdataset(qpdb, rbtnode, found, now, + dns__qpdb_bindrdataset(qpdb, qpnode, found, now, isc_rwlocktype_read, rdataset DNS__DB_FLARG_PASS); if (foundsig != NULL) { - dns__qpdb_bindrdataset(qpdb, rbtnode, foundsig, now, + dns__qpdb_bindrdataset(qpdb, qpnode, foundsig, now, isc_rwlocktype_read, sigrdataset DNS__DB_FLARG_PASS); } } - NODE_UNLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype); + NODE_UNLOCK(&qpdb->node_locks[qpnode->locknum].lock, &nlocktype); if (close_version) { dns__qpdb_closeversion( @@ -1562,7 +1562,7 @@ zone_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, } static bool -delegating_type(dns_qpdb_t *qpdb, dns_rbtnode_t *node, dns_typepair_t type) { +delegating_type(dns_qpdb_t *qpdb, dns_qpdata_t *node, dns_typepair_t type) { if (type == dns_rdatatype_dname || (type == dns_rdatatype_ns && (node != qpdb->origin_node || IS_STUB(qpdb)))) @@ -1576,10 +1576,10 @@ delegating_type(dns_qpdb_t *qpdb, 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_qpdb_t *qpdb, const dns_name_t *name, dns_rbtnode_t **nodep, +loadnode(dns_qpdb_t *qpdb, const dns_name_t *name, dns_qpdata_t **nodep, bool hasnsec) { isc_result_t noderesult, nsecresult; - dns_rbtnode_t *nsecnode = NULL, *node = NULL; + dns_qpdata_t *nsecnode = NULL, *node = NULL; noderesult = dns_qp_getname(qpdb->tree, name, (void **)&node, NULL); if (noderesult != ISC_R_SUCCESS) { @@ -1643,7 +1643,7 @@ loading_addrdataset(void *arg, const dns_name_t *name, dns_rdataset_t *rdataset DNS__DB_FLARG) { qpdb_load_t *loadctx = arg; dns_qpdb_t *qpdb = (dns_qpdb_t *)loadctx->db; - dns_rbtnode_t *node = NULL; + dns_qpdata_t *node = NULL; isc_result_t result; isc_region_t region; dns_slabheader_t *newheader = NULL; @@ -2066,11 +2066,11 @@ glue_nsdname_cb(void *arg, const dns_name_t *name, dns_rdatatype_t qtype, dns_fixedname_t fixedname_a; dns_name_t *name_a = NULL; dns_rdataset_t rdataset_a, sigrdataset_a; - dns_rbtnode_t *node_a = NULL; + dns_qpdata_t *node_a = NULL; dns_fixedname_t fixedname_aaaa; dns_name_t *name_aaaa = NULL; dns_rdataset_t rdataset_aaaa, sigrdataset_aaaa; - dns_rbtnode_t *node_aaaa = NULL; + dns_qpdata_t *node_aaaa = NULL; dns_glue_t *glue = NULL; UNUSED(unused); @@ -2266,7 +2266,7 @@ addglue_to_message(dns_glue_t *ge, dns_message_t *msg) { } static dns_glue_t * -newglue(dns_qpdb_t *qpdb, dns_qpdb_version_t *rbtversion, dns_rbtnode_t *node, +newglue(dns_qpdb_t *qpdb, dns_qpdb_version_t *rbtversion, dns_qpdata_t *node, dns_rdataset_t *rdataset) { dns_fixedname_t nodename; dns_glue_additionaldata_ctx_t ctx = { @@ -2294,7 +2294,7 @@ addglue(dns_db_t *db, dns_dbversion_t *version, dns_rdataset_t *rdataset, dns_message_t *msg) { 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_qpdata_t *node = (dns_qpdata_t *)rdataset->slab.node; dns_slabheader_t *header = dns_slabheader_fromrdataset(rdataset); REQUIRE(rdataset->type == dns_rdatatype_ns); @@ -2415,7 +2415,7 @@ dns__qpzone_wildcardmagic(dns_qpdb_t *qpdb, const dns_name_t *name, bool lock) { dns_name_t foundname; dns_offsets_t offsets; unsigned int n; - dns_rbtnode_t *node = NULL; + dns_qpdata_t *node = NULL; isc_rwlocktype_t nlocktype = isc_rwlocktype_none; dns_name_init(&foundname, offsets); @@ -2457,7 +2457,7 @@ dns__qpzone_addwildcards(dns_qpdb_t *qpdb, const dns_name_t *name, bool lock) { l = dns_name_countlabels(&qpdb->common.origin); i = l + 1; while (i < n) { - dns_rbtnode_t *node = NULL; + dns_qpdata_t *node = NULL; dns_name_getlabelsequence(name, n - i, i, &foundname); if (dns_name_iswildcard(&foundname)) { result = dns__qpzone_wildcardmagic(qpdb, &foundname, diff --git a/lib/dns/qpdb.c b/lib/dns/qpdb.c index b95e9804bd..903356a3c4 100644 --- a/lib/dns/qpdb.c +++ b/lib/dns/qpdb.c @@ -282,7 +282,7 @@ typedef struct qpdb_dbiterator { dns_qpiter_t iter; dns_qpiter_t nsec3iter; dns_qpiter_t *current; - dns_rbtnode_t *node; + dns_qpdata_t *node; enum { full, nonsec3, nsec3only } nsec3mode; } qpdb_dbiterator_t; @@ -480,7 +480,7 @@ free_qpdb(dns_qpdb_t *qpdb, bool log) { * the overhead of unlinking all nodes here should be negligible. */ for (i = 0; i < qpdb->node_lock_count; i++) { - dns_rbtnode_t *node = NULL; + dns_qpdata_t *node = NULL; node = ISC_LIST_HEAD(qpdb->deadnodes[i]); while (node != NULL) { @@ -550,7 +550,7 @@ free_qpdb(dns_qpdb_t *qpdb, bool log) { INSIST(ISC_LIST_EMPTY(qpdb->deadnodes[i])); } isc_mem_cput(qpdb->common.mctx, qpdb->deadnodes, - qpdb->node_lock_count, sizeof(dns_rbtnodelist_t)); + qpdb->node_lock_count, sizeof(dns_qpdatalist_t)); } /* * Clean up heap objects. @@ -767,7 +767,7 @@ add_changed(dns_slabheader_t *header, REQUIRE(version->writer); if (changed != NULL) { - dns_rbtnode_t *node = (dns_rbtnode_t *)header->node; + dns_qpdata_t *node = (dns_qpdata_t *)header->node; uint_fast32_t refs = isc_refcount_increment(&node->references); #if DNS_DB_NODETRACE fprintf(stderr, @@ -789,7 +789,7 @@ add_changed(dns_slabheader_t *header, } static void -rollback_node(dns_rbtnode_t *node, uint32_t serial) { +rollback_node(dns_qpdata_t *node, uint32_t serial) { dns_slabheader_t *header = NULL, *dcurrent = NULL; bool make_dirty = false; @@ -870,7 +870,7 @@ clean_stale_headers(dns_slabheader_t *top) { } static void -clean_cache_node(dns_qpdb_t *qpdb, dns_rbtnode_t *node) { +clean_cache_node(dns_qpdb_t *qpdb, dns_qpdata_t *node) { dns_slabheader_t *current = NULL, *top_prev = NULL, *top_next = NULL; /* @@ -901,7 +901,7 @@ clean_cache_node(dns_qpdb_t *qpdb, dns_rbtnode_t *node) { } static void -clean_zone_node(dns_rbtnode_t *node, uint32_t least_serial) { +clean_zone_node(dns_qpdata_t *node, uint32_t least_serial) { dns_slabheader_t *current = NULL, *dcurrent = NULL; dns_slabheader_t *down_next = NULL, *dparent = NULL; dns_slabheader_t *top_prev = NULL, *top_next = NULL; @@ -1036,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_qpdb_t *qpdb, dns_rbtnode_t *node) { +delete_node(dns_qpdb_t *qpdb, dns_qpdata_t *node) { isc_result_t result = ISC_R_UNEXPECTED; INSIST(!ISC_LINK_LINKED(node, deadlink)); @@ -1088,7 +1088,7 @@ delete_node(dns_qpdb_t *qpdb, dns_rbtnode_t *node) { * Caller must be holding the node lock. */ void -dns__qpdb_newref(dns_qpdb_t *qpdb, dns_rbtnode_t *node, +dns__qpdb_newref(dns_qpdb_t *qpdb, dns_qpdata_t *node, isc_rwlocktype_t nlocktype DNS__DB_FLARG) { uint_fast32_t refs; @@ -1126,13 +1126,13 @@ dns__qpdb_newref(dns_qpdb_t *qpdb, dns_rbtnode_t *node, * The tree lock must be held for the result to be valid. */ static bool -is_leaf(dns_rbtnode_t *node) { +is_leaf(dns_qpdata_t *node) { return (node->parent != NULL && node->parent->down == node && node->left == NULL && node->right == NULL); } static void -send_to_prune_tree(dns_qpdb_t *qpdb, dns_rbtnode_t *node, +send_to_prune_tree(dns_qpdb_t *qpdb, dns_qpdata_t *node, isc_rwlocktype_t nlocktype DNS__DB_FLARG) { qpdb_prune_t *prune = isc_mem_get(qpdb->common.mctx, sizeof(*prune)); *prune = (qpdb_prune_t){ .node = node }; @@ -1153,7 +1153,7 @@ send_to_prune_tree(dns_qpdb_t *qpdb, dns_rbtnode_t *node, */ static void cleanup_dead_nodes(dns_qpdb_t *qpdb, int bucketnum DNS__DB_FLARG) { - dns_rbtnode_t *node = NULL; + dns_qpdata_t *node = NULL; int count = 10; /* XXXJT: should be adjustable */ node = ISC_LIST_HEAD(qpdb->deadnodes[bucketnum]); @@ -1207,7 +1207,7 @@ cleanup_dead_nodes(dns_qpdb_t *qpdb, int bucketnum DNS__DB_FLARG) { * have been added to the list). */ static void -reactivate_node(dns_qpdb_t *qpdb, dns_rbtnode_t *node, +reactivate_node(dns_qpdb_t *qpdb, dns_qpdata_t *node, isc_rwlocktype_t tlocktype DNS__DB_FLARG) { isc_rwlocktype_t nlocktype = isc_rwlocktype_none; isc_rwlock_t *nodelock = &qpdb->node_locks[node->locknum].lock; @@ -1263,7 +1263,7 @@ reactivate_node(dns_qpdb_t *qpdb, dns_rbtnode_t *node, * will be immediately freed. */ bool -dns__qpdb_decref(dns_qpdb_t *qpdb, dns_rbtnode_t *node, uint32_t least_serial, +dns__qpdb_decref(dns_qpdb_t *qpdb, dns_qpdata_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; @@ -1444,8 +1444,8 @@ static void prune_tree(void *arg) { 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; + dns_qpdata_t *node = prune->node; + dns_qpdata_t *parent = NULL; unsigned int locknum = node->locknum; isc_rwlocktype_t tlocktype = isc_rwlocktype_none; isc_rwlocktype_t nlocktype = isc_rwlocktype_none; @@ -1577,7 +1577,7 @@ dns__qpdb_setsecure(dns_db_t *db, dns_qpdb_version_t *version, */ static void setnsec3parameters(dns_db_t *db, dns_qpdb_version_t *version) { - dns_rbtnode_t *node = NULL; + dns_qpdata_t *node = NULL; dns_rdata_nsec3param_t nsec3param; dns_rdata_t rdata = DNS_RDATA_INIT; isc_region_t region; @@ -1699,7 +1699,7 @@ dns__qpdb_closeversion(dns_db_t *db, dns_dbversion_t **versionp, dns_slabheaderlist_t resigned_list; qpdb_changed_t *changed = NULL, *next_changed = NULL; uint32_t serial, least_serial; - dns_rbtnode_t *rbtnode = NULL; + dns_qpdata_t *qpnode = NULL; dns_slabheader_t *header = NULL; REQUIRE(VALID_QPDB(qpdb)); @@ -1921,8 +1921,8 @@ dns__qpdb_closeversion(dns_db_t *db, dns_dbversion_t **versionp, isc_rwlocktype_t nlocktype = isc_rwlocktype_none; next_changed = NEXT(changed, link); - rbtnode = changed->node; - lock = &qpdb->node_locks[rbtnode->locknum].lock; + qpnode = changed->node; + lock = &qpdb->node_locks[qpnode->locknum].lock; NODE_WRLOCK(lock, &nlocktype); /* @@ -1932,14 +1932,14 @@ dns__qpdb_closeversion(dns_db_t *db, dns_dbversion_t **versionp, if (qpdb->loop == NULL) { cleanup_dead_nodes( qpdb, - rbtnode->locknum DNS__DB_FLARG_PASS); + qpnode->locknum DNS__DB_FLARG_PASS); } if (rollback) { - rollback_node(rbtnode, serial); + rollback_node(qpnode, serial); } - dns__qpdb_decref(qpdb, rbtnode, least_serial, - &nlocktype, &tlocktype, true, + dns__qpdb_decref(qpdb, qpnode, least_serial, &nlocktype, + &tlocktype, true, false DNS__DB_FILELINE); NODE_UNLOCK(lock, &nlocktype); @@ -1966,7 +1966,7 @@ isc_result_t 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_qpdata_t *node = NULL; dns_name_t nodename; isc_result_t result; isc_rwlocktype_t tlocktype = isc_rwlocktype_none; @@ -2033,7 +2033,7 @@ dns__qpdb_findnode(dns_db_t *db, const dns_name_t *name, bool create, } void -dns__qpdb_bindrdataset(dns_qpdb_t *qpdb, dns_rbtnode_t *node, +dns__qpdb_bindrdataset(dns_qpdb_t *qpdb, dns_qpdata_t *node, dns_slabheader_t *header, isc_stdtime_t now, isc_rwlocktype_t locktype, dns_rdataset_t *rdataset DNS__DB_FLARG) { @@ -2152,7 +2152,7 @@ dns__qpdb_attachnode(dns_db_t *db, dns_dbnode_t *source, REQUIRE(VALID_QPDB((dns_qpdb_t *)db)); REQUIRE(targetp != NULL && *targetp == NULL); - dns_rbtnode_t *node = (dns_rbtnode_t *)source; + dns_qpdata_t *node = (dns_qpdata_t *)source; uint_fast32_t refs = isc_refcount_increment(&node->references); #if DNS_DB_NODETRACE @@ -2168,7 +2168,7 @@ dns__qpdb_attachnode(dns_db_t *db, dns_dbnode_t *source, void 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; + dns_qpdata_t *node = NULL; bool want_free = false; bool inactive = false; db_nodelock_t *nodelock = NULL; @@ -2178,7 +2178,7 @@ dns__qpdb_detachnode(dns_db_t *db, dns_dbnode_t **targetp DNS__DB_FLARG) { REQUIRE(VALID_QPDB(qpdb)); REQUIRE(targetp != NULL && *targetp != NULL); - node = (dns_rbtnode_t *)(*targetp); + node = (dns_qpdata_t *)(*targetp); nodelock = &qpdb->node_locks[node->locknum]; NODE_RDLOCK(&nodelock->lock, &nlocktype); @@ -2271,7 +2271,7 @@ dns__qpdb_allrdatasets(dns_db_t *db, dns_dbnode_t *node, 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_qpdata_t *qpnode = (dns_qpdata_t *)node; dns_qpdb_version_t *rbtversion = version; qpdb_rdatasetiter_t *iterator = NULL; uint_fast32_t refs; @@ -2305,7 +2305,7 @@ dns__qpdb_allrdatasets(dns_db_t *db, dns_dbnode_t *node, iterator->common.options = options; iterator->common.now = now; - refs = isc_refcount_increment(&rbtnode->references); + refs = isc_refcount_increment(&qpnode->references); #if DNS_DB_NODETRACE fprintf(stderr, "incr:node:%s:%s:%u:%p->references = %" PRIuFAST32 "\n", func, file, line, node, refs + 1); @@ -2321,7 +2321,7 @@ dns__qpdb_allrdatasets(dns_db_t *db, dns_dbnode_t *node, } static bool -cname_and_other_data(dns_rbtnode_t *node, uint32_t serial) { +cname_and_other_data(dns_qpdata_t *node, uint32_t serial) { dns_slabheader_t *header = NULL, *header_next = NULL; bool cname = false, other_data = false; dns_rdatatype_t rdtype; @@ -2436,7 +2436,7 @@ update_recordsandxfrsize(bool add, dns_qpdb_version_t *rbtversion, } isc_result_t -dns__qpdb_add(dns_qpdb_t *qpdb, dns_rbtnode_t *rbtnode, +dns__qpdb_add(dns_qpdb_t *qpdb, dns_qpdata_t *qpnode, 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) { @@ -2499,7 +2499,7 @@ dns__qpdb_add(dns_qpdb_t *qpdb, dns_rbtnode_t *rbtnode, * only rdataset that can be found at this * node is the negative cache entry. */ - for (topheader = rbtnode->data; + for (topheader = qpnode->data; topheader != NULL; topheader = topheader->next) { @@ -2511,7 +2511,7 @@ dns__qpdb_add(dns_qpdb_t *qpdb, dns_rbtnode_t *rbtnode, * Otherwise look for any RRSIGs of the given * type so they can be marked ancient later. */ - for (topheader = rbtnode->data; topheader != NULL; + for (topheader = qpnode->data; topheader != NULL; topheader = topheader->next) { if (topheader->type == sigtype) { @@ -2528,7 +2528,7 @@ dns__qpdb_add(dns_qpdb_t *qpdb, dns_rbtnode_t *rbtnode, * check for an extant non-ancient NODATA ncache * entry which covers the same type as the RRSIG. */ - for (topheader = rbtnode->data; topheader != NULL; + for (topheader = qpnode->data; topheader != NULL; topheader = topheader->next) { if ((topheader->type == RDATATYPE_NCACHEANY) || @@ -2553,8 +2553,8 @@ dns__qpdb_add(dns_qpdb_t *qpdb, dns_rbtnode_t *rbtnode, dns_slabheader_destroy(&newheader); if (addedrdataset != NULL) { dns__qpdb_bindrdataset( - qpdb, rbtnode, - topheader, now, + qpdb, qpnode, topheader, + now, isc_rwlocktype_write, addedrdataset DNS__DB_FLARG_PASS); @@ -2573,7 +2573,7 @@ dns__qpdb_add(dns_qpdb_t *qpdb, dns_rbtnode_t *rbtnode, } } - for (topheader = rbtnode->data; topheader != NULL; + for (topheader = qpnode->data; topheader != NULL; topheader = topheader->next) { if (prio_type(topheader->type)) { @@ -2621,7 +2621,7 @@ find_header: dns_slabheader_destroy(&newheader); if (addedrdataset != NULL) { dns__qpdb_bindrdataset( - qpdb, rbtnode, header, now, + qpdb, qpnode, header, now, isc_rwlocktype_write, addedrdataset DNS__DB_FLARG_PASS); } @@ -2681,7 +2681,7 @@ find_header: newheader = (dns_slabheader_t *)merged; dns_slabheader_reset(newheader, (dns_db_t *)qpdb, - (dns_dbnode_t *)rbtnode); + (dns_dbnode_t *)qpnode); dns_slabheader_copycase(newheader, header); if (loading && RESIGN(newheader) && RESIGN(header) && @@ -2746,7 +2746,7 @@ find_header: dns_slabheader_destroy(&newheader); if (addedrdataset != NULL) { dns__qpdb_bindrdataset( - qpdb, rbtnode, header, now, + qpdb, qpnode, header, now, isc_rwlocktype_write, addedrdataset DNS__DB_FLARG_PASS); } @@ -2811,7 +2811,7 @@ find_header: dns_slabheader_destroy(&newheader); if (addedrdataset != NULL) { dns__qpdb_bindrdataset( - qpdb, rbtnode, header, now, + qpdb, qpnode, header, now, isc_rwlocktype_write, addedrdataset DNS__DB_FLARG_PASS); } @@ -2853,7 +2853,7 @@ find_header: if (topheader_prev != NULL) { topheader_prev->next = newheader; } else { - rbtnode->data = newheader; + qpnode->data = newheader; } newheader->next = topheader->next; if (rbtversion != NULL && !header_nx) { @@ -2886,12 +2886,12 @@ find_header: if (topheader_prev != NULL) { topheader_prev->next = newheader; } else { - rbtnode->data = newheader; + qpnode->data = newheader; } newheader->next = topheader->next; newheader->down = topheader; topheader->next = newheader; - rbtnode->dirty = 1; + qpnode->dirty = 1; if (changed != NULL) { changed->dirty = true; } @@ -2953,12 +2953,12 @@ find_header: if (topheader_prev != NULL) { topheader_prev->next = newheader; } else { - rbtnode->data = newheader; + qpnode->data = newheader; } newheader->next = topheader->next; newheader->down = topheader; topheader->next = newheader; - rbtnode->dirty = 1; + qpnode->dirty = 1; if (changed != NULL) { changed->dirty = true; } @@ -2970,16 +2970,16 @@ find_header: if (prio_type(newheader->type)) { /* This is a priority type, prepend it */ - newheader->next = rbtnode->data; - rbtnode->data = newheader; + newheader->next = qpnode->data; + qpnode->data = newheader; } else if (prioheader != NULL) { /* Append after the priority headers */ newheader->next = prioheader->next; prioheader->next = newheader; } else { /* There were no priority headers */ - newheader->next = rbtnode->data; - rbtnode->data = newheader; + newheader->next = qpnode->data; + qpnode->data = newheader; } } } @@ -2993,13 +2993,13 @@ find_header: * Check if the node now contains CNAME and other data. */ if (rbtversion != NULL && - cname_and_other_data(rbtnode, rbtversion->serial)) + cname_and_other_data(qpnode, rbtversion->serial)) { return (DNS_R_CNAMEANDOTHER); } if (addedrdataset != NULL) { - dns__qpdb_bindrdataset(qpdb, rbtnode, newheader, now, + dns__qpdb_bindrdataset(qpdb, qpnode, newheader, now, isc_rwlocktype_write, addedrdataset DNS__DB_FLARG_PASS); } @@ -3008,7 +3008,7 @@ find_header: } static bool -delegating_type(dns_qpdb_t *qpdb, dns_rbtnode_t *node, dns_typepair_t type) { +delegating_type(dns_qpdb_t *qpdb, dns_qpdata_t *node, dns_typepair_t type) { if (IS_CACHE(qpdb)) { if (type == dns_rdatatype_dname) { return (true); @@ -3112,7 +3112,7 @@ dns__qpdb_addrdataset(dns_db_t *db, dns_dbnode_t *node, 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_qpdata_t *qpnode = (dns_qpdata_t *)node; dns_qpdb_version_t *rbtversion = version; isc_region_t region; dns_slabheader_t *newheader = NULL; @@ -3138,10 +3138,10 @@ dns__qpdb_addrdataset(dns_db_t *db, dns_dbnode_t *node, return (DNS_R_NOTZONETOP); } TREE_RDLOCK(&qpdb->tree_lock, &tlocktype); - REQUIRE(((rbtnode->nsec == DNS_DB_NSEC_NSEC3 && + REQUIRE(((qpnode->nsec == DNS_DB_NSEC_NSEC3 && (rdataset->type == dns_rdatatype_nsec3 || rdataset->covers == dns_rdatatype_nsec3)) || - (rbtnode->nsec != DNS_DB_NSEC_NSEC3 && + (qpnode->nsec != DNS_DB_NSEC_NSEC3 && rdataset->type != dns_rdatatype_nsec3 && rdataset->covers != dns_rdatatype_nsec3))); TREE_UNLOCK(&qpdb->tree_lock, &tlocktype); @@ -3170,7 +3170,7 @@ dns__qpdb_addrdataset(dns_db_t *db, dns_dbnode_t *node, .type = DNS_TYPEPAIR_VALUE(rdataset->type, rdataset->covers), .trust = rdataset->trust, .last_used = now, - .node = rbtnode, + .node = qpnode, }; dns_slabheader_reset(newheader, db, node); @@ -3234,7 +3234,7 @@ dns__qpdb_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(qpdb, rbtnode, rdataset->type)) { + if (delegating_type(qpdb, qpnode, rdataset->type)) { delegating = true; } else { delegating = false; @@ -3244,7 +3244,7 @@ dns__qpdb_addrdataset(dns_db_t *db, dns_dbnode_t *node, * Add to the auxiliary NSEC tree if we're adding an NSEC record. */ TREE_RDLOCK(&qpdb->tree_lock, &tlocktype); - if (rbtnode->nsec != DNS_DB_NSEC_HAS_NSEC && + if (qpnode->nsec != DNS_DB_NSEC_HAS_NSEC && rdataset->type == dns_rdatatype_nsec) { newnsec = true; @@ -3272,7 +3272,7 @@ dns__qpdb_addrdataset(dns_db_t *db, dns_dbnode_t *node, &tlocktype DNS__DB_FLARG_PASS); } - NODE_WRLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype); + NODE_WRLOCK(&qpdb->node_locks[qpnode->locknum].lock, &nlocktype); if (qpdb->rrsetstats != NULL) { DNS_SLABHEADER_SETATTR(newheader, DNS_SLABHEADERATTR_STATCOUNT); @@ -3284,10 +3284,10 @@ dns__qpdb_addrdataset(dns_db_t *db, dns_dbnode_t *node, if (IS_CACHE(qpdb)) { if (tlocktype == isc_rwlocktype_write) { cleanup_dead_nodes(qpdb, - rbtnode->locknum DNS__DB_FLARG_PASS); + qpnode->locknum DNS__DB_FLARG_PASS); } - expire_ttl_headers(qpdb, rbtnode->locknum, &tlocktype, now, + expire_ttl_headers(qpdb, qpnode->locknum, &tlocktype, now, cache_is_overmem DNS__DB_FLARG_PASS); /* @@ -3304,7 +3304,7 @@ dns__qpdb_addrdataset(dns_db_t *db, dns_dbnode_t *node, result = ISC_R_SUCCESS; if (newnsec) { - dns_rbtnode_t *nsecnode = NULL; + dns_qpdata_t *nsecnode = NULL; result = dns_qp_getname(qpdb->nsec, name, (void **)&nsecnode, NULL); @@ -3317,19 +3317,19 @@ dns__qpdb_addrdataset(dns_db_t *db, dns_dbnode_t *node, result = dns_qp_insert(qpdb->nsec, nsecnode, 0); INSIST(result == ISC_R_SUCCESS); } - rbtnode->nsec = DNS_DB_NSEC_HAS_NSEC; + qpnode->nsec = DNS_DB_NSEC_HAS_NSEC; } if (result == ISC_R_SUCCESS) { - result = dns__qpdb_add(qpdb, rbtnode, name, rbtversion, + result = dns__qpdb_add(qpdb, qpnode, name, rbtversion, newheader, options, false, addedrdataset, now DNS__DB_FLARG_PASS); } if (result == ISC_R_SUCCESS && delegating) { - rbtnode->find_callback = 1; + qpnode->find_callback = 1; } - NODE_UNLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype); + NODE_UNLOCK(&qpdb->node_locks[qpnode->locknum].lock, &nlocktype); if (tlocktype != isc_rwlocktype_none) { TREE_UNLOCK(&qpdb->tree_lock, &tlocktype); @@ -3353,7 +3353,7 @@ dns__qpdb_subtractrdataset(dns_db_t *db, dns_dbnode_t *node, 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_qpdata_t *qpnode = (dns_qpdata_t *)node; dns_qpdb_version_t *rbtversion = version; dns_fixedname_t fname; dns_name_t *nodename = dns_fixedname_initname(&fname); @@ -3371,10 +3371,10 @@ dns__qpdb_subtractrdataset(dns_db_t *db, dns_dbnode_t *node, if (!IS_CACHE(qpdb)) { TREE_RDLOCK(&qpdb->tree_lock, &tlocktype); - REQUIRE(((rbtnode->nsec == DNS_DB_NSEC_NSEC3 && + REQUIRE(((qpnode->nsec == DNS_DB_NSEC_NSEC3 && (rdataset->type == dns_rdatatype_nsec3 || rdataset->covers == dns_rdatatype_nsec3)) || - (rbtnode->nsec != DNS_DB_NSEC_NSEC3 && + (qpnode->nsec != DNS_DB_NSEC_NSEC3 && rdataset->type != dns_rdatatype_nsec3 && rdataset->covers != dns_rdatatype_nsec3))); TREE_UNLOCK(&qpdb->tree_lock, &tlocktype); @@ -3400,7 +3400,7 @@ dns__qpdb_subtractrdataset(dns_db_t *db, dns_dbnode_t *node, atomic_init(&newheader->count, atomic_fetch_add_relaxed(&init_count, 1)); newheader->last_used = 0; - newheader->node = rbtnode; + newheader->node = qpnode; newheader->db = (dns_db_t *)qpdb; if ((rdataset->attributes & DNS_RDATASETATTR_RESIGN) != 0) { DNS_SLABHEADER_SETATTR(newheader, DNS_SLABHEADERATTR_RESIGN); @@ -3413,17 +3413,17 @@ dns__qpdb_subtractrdataset(dns_db_t *db, dns_dbnode_t *node, newheader->resign_lsb = 0; } - NODE_WRLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype); + NODE_WRLOCK(&qpdb->node_locks[qpnode->locknum].lock, &nlocktype); changed = add_changed(newheader, rbtversion DNS__DB_FLARG_PASS); if (changed == NULL) { dns_slabheader_destroy(&newheader); - NODE_UNLOCK(&qpdb->node_locks[rbtnode->locknum].lock, + NODE_UNLOCK(&qpdb->node_locks[qpnode->locknum].lock, &nlocktype); return (ISC_R_NOMEMORY); } - for (topheader = rbtnode->data; topheader != NULL; + for (topheader = qpnode->data; topheader != NULL; topheader = topheader->next) { if (topheader->type == newheader->type) { @@ -3469,7 +3469,7 @@ dns__qpdb_subtractrdataset(dns_db_t *db, dns_dbnode_t *node, newheader, DNS_SLABHEADERATTR_RESIGN); newheader->resign = header->resign; newheader->resign_lsb = header->resign_lsb; - dns__qpzone_resigninsert(qpdb, rbtnode->locknum, + dns__qpzone_resigninsert(qpdb, qpnode->locknum, newheader); } /* @@ -3492,7 +3492,7 @@ dns__qpdb_subtractrdataset(dns_db_t *db, dns_dbnode_t *node, */ dns_slabheader_destroy(&newheader); newheader = dns_slabheader_new((dns_db_t *)qpdb, - (dns_dbnode_t *)rbtnode); + (dns_dbnode_t *)qpnode); dns__qpdb_setttl(newheader, 0); newheader->type = topheader->type; atomic_init(&newheader->attributes, @@ -3513,12 +3513,12 @@ dns__qpdb_subtractrdataset(dns_db_t *db, dns_dbnode_t *node, if (topheader_prev != NULL) { topheader_prev->next = newheader; } else { - rbtnode->data = newheader; + qpnode->data = newheader; } newheader->next = topheader->next; newheader->down = topheader; topheader->next = newheader; - rbtnode->dirty = 1; + qpnode->dirty = 1; changed->dirty = true; dns__qpzone_resigndelete(qpdb, rbtversion, header DNS__DB_FLARG_PASS); @@ -3536,7 +3536,7 @@ dns__qpdb_subtractrdataset(dns_db_t *db, dns_dbnode_t *node, } if (result == ISC_R_SUCCESS && newrdataset != NULL) { - dns__qpdb_bindrdataset(qpdb, rbtnode, newheader, 0, + dns__qpdb_bindrdataset(qpdb, qpnode, newheader, 0, isc_rwlocktype_write, newrdataset DNS__DB_FLARG_PASS); } @@ -3544,13 +3544,13 @@ dns__qpdb_subtractrdataset(dns_db_t *db, dns_dbnode_t *node, if (result == DNS_R_NXRRSET && newrdataset != NULL && (options & DNS_DBSUB_WANTOLD) != 0) { - dns__qpdb_bindrdataset(qpdb, rbtnode, header, 0, + dns__qpdb_bindrdataset(qpdb, qpnode, header, 0, isc_rwlocktype_write, newrdataset DNS__DB_FLARG_PASS); } unlock: - NODE_UNLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype); + NODE_UNLOCK(&qpdb->node_locks[qpnode->locknum].lock, &nlocktype); /* * Update the zone's secure status. If version is non-NULL @@ -3571,7 +3571,7 @@ 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_qpdata_t *qpnode = (dns_qpdata_t *)node; dns_qpdb_version_t *rbtversion = version; dns_fixedname_t fname; dns_name_t *nodename = dns_fixedname_initname(&fname); @@ -3599,11 +3599,11 @@ dns__qpdb_deleterdataset(dns_db_t *db, dns_dbnode_t *node, dns__qpdb_nodefullname(db, node, nodename); - NODE_WRLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype); - result = dns__qpdb_add(qpdb, rbtnode, nodename, rbtversion, newheader, + NODE_WRLOCK(&qpdb->node_locks[qpnode->locknum].lock, &nlocktype); + result = dns__qpdb_add(qpdb, qpnode, nodename, rbtversion, newheader, DNS_DBADD_FORCE, false, NULL, 0 DNS__DB_FLARG_PASS); - NODE_UNLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype); + NODE_UNLOCK(&qpdb->node_locks[qpnode->locknum].lock, &nlocktype); /* * Update the zone's secure status. If version is non-NULL @@ -3665,14 +3665,14 @@ dns__qpdb_setloop(dns_db_t *db, isc_loop_t *loop) { isc_result_t 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; + dns_qpdata_t *onode = NULL; isc_result_t result = ISC_R_SUCCESS; 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 *)qpdb->origin_node; + onode = (dns_qpdata_t *)qpdb->origin_node; if (onode != NULL) { dns__qpdb_newref(qpdb, onode, isc_rwlocktype_none DNS__DB_FLARG_PASS); @@ -3688,23 +3688,23 @@ dns__qpdb_getoriginnode(dns_db_t *db, dns_dbnode_t **nodep DNS__DB_FLARG) { void 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; + dns_qpdata_t *qpnode = (dns_qpdata_t *)node; - RWLOCK(&qpdb->node_locks[rbtnode->locknum].lock, type); + RWLOCK(&qpdb->node_locks[qpnode->locknum].lock, type); } void 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; + dns_qpdata_t *qpnode = (dns_qpdata_t *)node; - RWUNLOCK(&qpdb->node_locks[rbtnode->locknum].lock, type); + RWUNLOCK(&qpdb->node_locks[qpnode->locknum].lock, type); } isc_result_t 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; + dns_qpdata_t *qpnode = (dns_qpdata_t *)node; isc_rwlocktype_t tlocktype = isc_rwlocktype_none; REQUIRE(VALID_QPDB(qpdb)); @@ -3712,7 +3712,7 @@ dns__qpdb_nodefullname(dns_db_t *db, dns_dbnode_t *node, dns_name_t *name) { REQUIRE(name != NULL); TREE_RDLOCK(&qpdb->tree_lock, &tlocktype); - dns_name_copy(rbtnode->name, name); + dns_name_copy(qpnode->name, name); TREE_UNLOCK(&qpdb->tree_lock, &tlocktype); return (ISC_R_SUCCESS); @@ -3810,7 +3810,7 @@ dns__qpdb_create(isc_mem_t *mctx, const dns_name_t *origin, dns_dbtype_t type, * Create deadnode lists. */ qpdb->deadnodes = isc_mem_get(mctx, qpdb->node_lock_count * - sizeof(dns_rbtnodelist_t)); + sizeof(dns_qpdatalist_t)); for (i = 0; i < (int)qpdb->node_lock_count; i++) { ISC_LIST_INIT(qpdb->deadnodes[i]); } @@ -3964,15 +3964,15 @@ static isc_result_t rdatasetiter_first(dns_rdatasetiter_t *iterator DNS__DB_FLARG) { 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_qpdata_t *qpnode = rbtiterator->common.node; dns_qpdb_version_t *rbtversion = rbtiterator->common.version; dns_slabheader_t *header = NULL, *top_next = NULL; uint32_t serial = IS_CACHE(qpdb) ? 1 : rbtversion->serial; isc_rwlocktype_t nlocktype = isc_rwlocktype_none; - NODE_RDLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype); + NODE_RDLOCK(&qpdb->node_locks[qpnode->locknum].lock, &nlocktype); - for (header = rbtnode->data; header != NULL; header = top_next) { + for (header = qpnode->data; header != NULL; header = top_next) { top_next = header->next; do { if (EXPIREDOK(rbtiterator)) { @@ -3996,7 +3996,7 @@ rdatasetiter_first(dns_rdatasetiter_t *iterator DNS__DB_FLARG) { } } - NODE_UNLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype); + NODE_UNLOCK(&qpdb->node_locks[qpnode->locknum].lock, &nlocktype); rbtiterator->current = header; @@ -4011,7 +4011,7 @@ static isc_result_t rdatasetiter_next(dns_rdatasetiter_t *iterator DNS__DB_FLARG) { 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_qpdata_t *qpnode = rbtiterator->common.node; dns_qpdb_version_t *rbtversion = rbtiterator->common.version; dns_slabheader_t *header = NULL, *top_next = NULL; uint32_t serial = IS_CACHE(qpdb) ? 1 : rbtversion->serial; @@ -4025,7 +4025,7 @@ rdatasetiter_next(dns_rdatasetiter_t *iterator DNS__DB_FLARG) { return (ISC_R_NOMORE); } - NODE_RDLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype); + NODE_RDLOCK(&qpdb->node_locks[qpnode->locknum].lock, &nlocktype); type = header->type; rdtype = DNS_TYPEPAIR_TYPE(header->type); @@ -4088,7 +4088,7 @@ rdatasetiter_next(dns_rdatasetiter_t *iterator DNS__DB_FLARG) { } } - NODE_UNLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype); + NODE_UNLOCK(&qpdb->node_locks[qpnode->locknum].lock, &nlocktype); rbtiterator->current = header; @@ -4104,20 +4104,20 @@ rdatasetiter_current(dns_rdatasetiter_t *iterator, dns_rdataset_t *rdataset DNS__DB_FLARG) { 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_qpdata_t *qpnode = rbtiterator->common.node; dns_slabheader_t *header = NULL; isc_rwlocktype_t nlocktype = isc_rwlocktype_none; header = rbtiterator->current; REQUIRE(header != NULL); - NODE_RDLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype); + NODE_RDLOCK(&qpdb->node_locks[qpnode->locknum].lock, &nlocktype); - dns__qpdb_bindrdataset(qpdb, rbtnode, header, rbtiterator->common.now, + dns__qpdb_bindrdataset(qpdb, qpnode, header, rbtiterator->common.now, isc_rwlocktype_read, rdataset DNS__DB_FLARG_PASS); - NODE_UNLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype); + NODE_UNLOCK(&qpdb->node_locks[qpnode->locknum].lock, &nlocktype); } /* @@ -4127,7 +4127,7 @@ rdatasetiter_current(dns_rdatasetiter_t *iterator, static void 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; + dns_qpdata_t *node = qpdbiter->node; if (node == NULL) { return; @@ -4140,7 +4140,7 @@ reference_iter_node(qpdb_dbiterator_t *qpdbiter DNS__DB_FLARG) { static void 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; + dns_qpdata_t *node = qpdbiter->node; isc_rwlock_t *lock = NULL; isc_rwlocktype_t nlocktype = isc_rwlocktype_none; isc_rwlocktype_t tlocktype = qpdbiter->tree_locked; @@ -4394,7 +4394,7 @@ dbiterator_seek(dns_dbiterator_t *iterator, qpdbiter->current, NULL, (void **)&qpdbiter->node, NULL); if (result == DNS_R_PARTIALMATCH) { - dns_rbtnode_t *node = NULL; + dns_qpdata_t *node = NULL; tresult = dns_qp_lookup(qpdb->nsec3, name, NULL, &qpdbiter->nsec3iter, NULL, (void **)&node, NULL); @@ -4544,7 +4544,7 @@ dbiterator_current(dns_dbiterator_t *iterator, dns_dbnode_t **nodep, dns_name_t *name DNS__DB_FLARG) { dns_qpdb_t *qpdb = (dns_qpdb_t *)iterator->db; qpdb_dbiterator_t *qpdbiter = (qpdb_dbiterator_t *)iterator; - dns_rbtnode_t *node = qpdbiter->node; + dns_qpdata_t *node = qpdbiter->node; isc_result_t result = ISC_R_SUCCESS; REQUIRE(qpdbiter->result == ISC_R_SUCCESS); diff --git a/lib/dns/qpdb_p.h b/lib/dns/qpdb_p.h index 4d87dd440a..ab0d589f24 100644 --- a/lib/dns/qpdb_p.h +++ b/lib/dns/qpdb_p.h @@ -30,7 +30,7 @@ #define VALID_QPDB(qpdb) \ ((qpdb) != NULL && (qpdb)->common.impmagic == QPDB_MAGIC) -#define QPDB_HEADERNODE(h) ((dns_rbtnode_t *)((h)->node)) +#define QPDB_HEADERNODE(h) ((dns_qpdata_t *)((h)->node)) /* * Allow clients with a virtual time of up to 5 minutes in the past to see @@ -91,13 +91,13 @@ struct dns_qpdata { * be reached from a child that was found by a hash lookup. */ unsigned int hashval; - dns_rbtnode_t *uppernode; - dns_rbtnode_t *hashnext; + dns_qpdata_t *uppernode; + dns_qpdata_t *hashnext; - dns_rbtnode_t *parent; - dns_rbtnode_t *left; - dns_rbtnode_t *right; - dns_rbtnode_t *down; + dns_qpdata_t *parent; + dns_qpdata_t *left; + dns_qpdata_t *right; + dns_qpdata_t *down; dns_fixedname_t fn; dns_name_t *name; @@ -108,7 +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_qpdbnode_t) deadlink; + ISC_LINK(dns_qpdata_t) deadlink; /*@{*/ /*! @@ -139,7 +139,7 @@ struct dns_qpdata { }; typedef struct qpdb_changed { - dns_rbtnode_t *node; + dns_qpdata_t *node; bool dirty; ISC_LINK(struct qpdb_changed) link; } qpdb_changed_t; @@ -193,8 +193,8 @@ struct dns_qpdb { /* Locks for individual tree nodes */ unsigned int node_lock_count; db_nodelock_t *node_locks; - dns_rbtnode_t *origin_node; - dns_rbtnode_t *nsec3_origin_node; + dns_qpdata_t *origin_node; + dns_qpdata_t *nsec3_origin_node; dns_stats_t *rrsetstats; /* cache DB only */ isc_stats_t *cachestats; /* cache DB only */ isc_stats_t *gluecachestats; /* zone DB only */ @@ -240,7 +240,7 @@ struct dns_qpdb { * Temporary storage for stale cache nodes and dynamically deleted * nodes that await being cleaned up. */ - dns_rbtnodelist_t *deadnodes; + dns_qpdatalist_t *deadnodes; /* * Heaps. These are used for TTL based expiry in a cache, @@ -274,7 +274,7 @@ typedef struct { bool copy_name; bool need_cleanup; bool wild; - dns_rbtnode_t *zonecut; + dns_qpdata_t *zonecut; dns_slabheader_t *zonecut_header; dns_slabheader_t *zonecut_sigheader; dns_fixedname_t zonecut_name; @@ -294,7 +294,7 @@ typedef struct { */ typedef struct { dns_db_t *db; - dns_rbtnode_t *node; + dns_qpdata_t *node; } qpdb_prune_t; extern dns_dbmethods_t dns__qpdb_zonemethods; @@ -448,7 +448,7 @@ dns__qpdb_unlocknode(dns_db_t *db, dns_dbnode_t *node, isc_rwlocktype_t type); * rbt-cachedb.c: */ void -dns__qpdb_bindrdataset(dns_qpdb_t *qpdb, dns_rbtnode_t *node, +dns__qpdb_bindrdataset(dns_qpdb_t *qpdb, dns_qpdata_t *node, dns_slabheader_t *header, isc_stdtime_t now, isc_rwlocktype_t locktype, dns_rdataset_t *rdataset DNS__DB_FLARG); @@ -460,7 +460,7 @@ void dns__qpdb_freeglue(dns_glue_t *glue_list); void -dns__qpdb_newref(dns_qpdb_t *qpdb, dns_rbtnode_t *node, +dns__qpdb_newref(dns_qpdb_t *qpdb, dns_qpdata_t *node, isc_rwlocktype_t locktype DNS__DB_FLARG); /*%< * Increment the reference counter to a node in an RBT database. @@ -471,7 +471,7 @@ dns__qpdb_newref(dns_qpdb_t *qpdb, dns_rbtnode_t *node, */ bool -dns__qpdb_decref(dns_qpdb_t *qpdb, dns_rbtnode_t *node, uint32_t least_serial, +dns__qpdb_decref(dns_qpdb_t *qpdb, dns_qpdata_t *node, uint32_t least_serial, isc_rwlocktype_t *nlocktypep, isc_rwlocktype_t *tlocktypep, bool tryupgrade, bool pruning DNS__DB_FLARG); /*%< @@ -484,7 +484,7 @@ dns__qpdb_decref(dns_qpdb_t *qpdb, dns_rbtnode_t *node, uint32_t least_serial, */ isc_result_t -dns__qpdb_add(dns_qpdb_t *qpdb, dns_rbtnode_t *rbtnode, +dns__qpdb_add(dns_qpdb_t *qpdb, dns_qpdata_t *qpnode, 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); diff --git a/tests/dns/qpdb_test.c b/tests/dns/qpdb_test.c index 2ced0f16df..d02c3d0c96 100644 --- a/tests/dns/qpdb_test.c +++ b/tests/dns/qpdb_test.c @@ -102,7 +102,7 @@ ownercase_test_one(const char *str1, const char *str2) { .common.mctx = mctx, .node_locks = node_locks, }; - dns_rbtnode_t rbtnode = { .locknum = 0 }; + dns_qpdata_t rbtnode = { .locknum = 0 }; dns_slabheader_t header = { .node = &rbtnode, .db = (dns_db_t *)&qpdb, @@ -169,7 +169,7 @@ ISC_RUN_TEST_IMPL(setownercase) { .common.mctx = mctx, .node_locks = node_locks, }; - dns_rbtnode_t rbtnode = { .locknum = 0 }; + dns_qpdata_t rbtnode = { .locknum = 0 }; dns_slabheader_t header = { .node = &rbtnode, .db = (dns_db_t *)&qpdb,