upstream/bind9
1
0
Fork 0
mirror of https://github.com/isc-projects/bind9.git synced 2026-05-28 04:34:54 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Replace dns_rbtnode_t with dns_qpdata_t

Browse source 
This for now has almost the same structure contents except for
dns_qpdata_t has 'fn' and 'name' to store the domain name.
This commit is contained in:
Matthijs Mekking 2024-01-16 12:09:52 +01:00
parent cc3a40dafa
commit fe97aa59b9
6 changed files with 185 additions and 185 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

11
lib/dns/include/dns/types.h
View file

@ -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;

41
lib/dns/qp-cachedb.c
View file

@ -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;

56
lib/dns/qp-zonedb.c
View file

@ -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,

222
lib/dns/qpdb.c
View file

@ -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);

36
lib/dns/qpdb_p.h
View file

@ -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);

4
tests/dns/qpdb_test.c
View file

@ -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,