From: Ondřej Surý Date: Thu, 5 Jan 2023 08:12:35 +0000 (+0100) Subject: Implement dns_db node tracing X-Git-Tag: v9.19.11~12^2 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=cd632ad31d0cb9f75254688977f78e301b92ceaf;p=thirdparty%2Fbind9.git Implement dns_db node tracing This implements node reference tracing that passes all the internal layers from dns_db API (and friends) to increment_reference() and decrement_reference(). It can be enabled by #defining DNS_DB_NODETRACE in header. The output then looks like this: incr:node:check_address_records:rootns.c:409:0x7f67f5a55a40->references = 1 decr:node:check_address_records:rootns.c:449:0x7f67f5a55a40->references = 0 incr:nodelock:check_address_records:rootns.c:409:0x7f67f5a55a40:0x7f68304d7040->references = 1 decr:nodelock:check_address_records:rootns.c:449:0x7f67f5a55a40:0x7f68304d7040->references = 0 There's associated python script to find the missing detach located at: https://gitlab.isc.org/isc-projects/bind9/-/snippets/1038 --- diff --git a/bin/named/builtin.c b/bin/named/builtin.c index 331cfd3f509..b0767a1e52f 100644 --- a/bin/named/builtin.c +++ b/bin/named/builtin.c @@ -80,13 +80,15 @@ typedef struct bdb_rdatasetiter { static isc_result_t findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, dns_rdatatype_t type, dns_rdatatype_t covers, isc_stdtime_t now, - dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset); + dns_rdataset_t *rdataset, + dns_rdataset_t *sigrdataset DNS__DB_FLARG); static void -attachnode(dns_db_t *db, dns_dbnode_t *source, dns_dbnode_t **targetp); +attachnode(dns_db_t *db, dns_dbnode_t *source, + dns_dbnode_t **targetp DNS__DB_FLARG); static void -detachnode(dns_db_t *db, dns_dbnode_t **nodep); +detachnode(dns_db_t *db, dns_dbnode_t **nodep DNS__DB_FLARG); /* * Helper functions to convert text to wire forma. @@ -605,23 +607,24 @@ ipv4reverse_lookup(bdbnode_t *node) { * the implementation can be the same as dns_rdatalist.. */ static void -disassociate(dns_rdataset_t *rdataset) { +disassociate(dns_rdataset_t *rdataset DNS__DB_FLARG) { dns_dbnode_t *node = rdataset->private5; bdbnode_t *bdbnode = (bdbnode_t *)node; dns_db_t *db = (dns_db_t *)bdbnode->bdb; - detachnode(db, &node); - dns_rdatalist_disassociate(rdataset); + detachnode(db, &node DNS__DB_FLARG_PASS); + dns_rdatalist_disassociate(rdataset DNS__DB_FLARG_PASS); } static void -rdataset_clone(dns_rdataset_t *source, dns_rdataset_t *target) { +rdataset_clone(dns_rdataset_t *source, dns_rdataset_t *target DNS__DB_FLARG) { dns_dbnode_t *node = source->private5; bdbnode_t *bdbnode = (bdbnode_t *)node; dns_db_t *db = (dns_db_t *)bdbnode->bdb; - dns_rdatalist_clone(source, target); - attachnode(db, node, (dns_dbnode_t **)&target->private5); + dns_rdatalist_clone(source, target DNS__DB_FLARG_PASS); + attachnode(db, node, + (dns_dbnode_t **)&target->private5 DNS__DB_FLARG_PASS); } static dns_rdatasetmethods_t bdb_rdataset_methods = { @@ -649,16 +652,17 @@ new_rdataset(dns_rdatalist_t *rdatalist, dns_db_t *db, dns_dbnode_t *node, */ static void -rdatasetiter_destroy(dns_rdatasetiter_t **iteratorp) { +rdatasetiter_destroy(dns_rdatasetiter_t **iteratorp DNS__DB_FLARG) { bdb_rdatasetiter_t *bdbiterator = (bdb_rdatasetiter_t *)(*iteratorp); - detachnode(bdbiterator->common.db, &bdbiterator->common.node); + detachnode(bdbiterator->common.db, + &bdbiterator->common.node DNS__DB_FLARG_PASS); isc_mem_put(bdbiterator->common.db->mctx, bdbiterator, sizeof(bdb_rdatasetiter_t)); *iteratorp = NULL; } static isc_result_t -rdatasetiter_first(dns_rdatasetiter_t *iterator) { +rdatasetiter_first(dns_rdatasetiter_t *iterator DNS__DB_FLARG) { bdb_rdatasetiter_t *bdbiterator = (bdb_rdatasetiter_t *)iterator; bdbnode_t *bdbnode = (bdbnode_t *)iterator->node; @@ -670,7 +674,7 @@ rdatasetiter_first(dns_rdatasetiter_t *iterator) { } static isc_result_t -rdatasetiter_next(dns_rdatasetiter_t *iterator) { +rdatasetiter_next(dns_rdatasetiter_t *iterator DNS__DB_FLARG) { bdb_rdatasetiter_t *bdbiterator = (bdb_rdatasetiter_t *)iterator; bdbiterator->current = ISC_LIST_NEXT(bdbiterator->current, link); @@ -682,7 +686,8 @@ rdatasetiter_next(dns_rdatasetiter_t *iterator) { } static void -rdatasetiter_current(dns_rdatasetiter_t *iterator, dns_rdataset_t *rdataset) { +rdatasetiter_current(dns_rdatasetiter_t *iterator, + dns_rdataset_t *rdataset DNS__DB_FLARG) { bdb_rdatasetiter_t *bdbiterator = (bdb_rdatasetiter_t *)iterator; new_rdataset(bdbiterator->current, iterator->db, iterator->node, @@ -748,7 +753,8 @@ attachversion(dns_db_t *db, dns_dbversion_t *source, } static void -closeversion(dns_db_t *db, dns_dbversion_t **versionp, bool commit) { +closeversion(dns_db_t *db, dns_dbversion_t **versionp, + bool commit DNS__DB_FLARG) { bdb_t *bdb = (bdb_t *)db; REQUIRE(VALID_BDB(bdb)); @@ -820,7 +826,7 @@ destroynode(bdbnode_t *node) { } static isc_result_t -getoriginnode(dns_db_t *db, dns_dbnode_t **nodep) { +getoriginnode(dns_db_t *db, dns_dbnode_t **nodep DNS__DB_FLARG) { bdb_t *bdb = (bdb_t *)db; bdbnode_t *node = NULL; isc_result_t result; @@ -856,7 +862,7 @@ getoriginnode(dns_db_t *db, dns_dbnode_t **nodep) { static isc_result_t findnode(dns_db_t *db, const dns_name_t *name, bool create, - dns_dbnode_t **nodep) { + dns_dbnode_t **nodep DNS__DB_FLARG) { bdb_t *bdb = (bdb_t *)db; bdbnode_t *node = NULL; isc_result_t result; @@ -904,7 +910,7 @@ static isc_result_t find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, dns_rdatatype_t type, unsigned int options, isc_stdtime_t now, dns_dbnode_t **nodep, dns_name_t *foundname, dns_rdataset_t *rdataset, - dns_rdataset_t *sigrdataset) { + dns_rdataset_t *sigrdataset DNS__DB_FLARG) { bdb_t *bdb = (bdb_t *)db; isc_result_t result; dns_dbnode_t *node = NULL; @@ -939,7 +945,7 @@ find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, * Look up the next label. */ dns_name_getlabelsequence(name, nlabels - i, i, xname); - result = findnode(db, xname, false, &node); + result = findnode(db, xname, false, &node DNS__DB_FLARG_PASS); if (result == ISC_R_NOTFOUND) { /* * No data at zone apex? @@ -966,9 +972,9 @@ find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, * the qname. */ if (i < nlabels) { - result = findrdataset(db, node, version, - dns_rdatatype_dname, 0, now, - rdataset, sigrdataset); + result = findrdataset( + db, node, version, dns_rdatatype_dname, 0, now, + rdataset, sigrdataset DNS__DB_FLARG_PASS); if (result == ISC_R_SUCCESS) { result = DNS_R_DNAME; break; @@ -980,9 +986,9 @@ find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, * origin or glue is ok. */ if (i != olabels && (options & DNS_DBFIND_GLUEOK) == 0) { - result = findrdataset(db, node, version, - dns_rdatatype_ns, 0, now, - rdataset, sigrdataset); + result = findrdataset( + db, node, version, dns_rdatatype_ns, 0, now, + rdataset, sigrdataset DNS__DB_FLARG_PASS); if (result == ISC_R_SUCCESS) { if (i == nlabels && type == dns_rdatatype_any) { result = DNS_R_ZONECUT; @@ -1024,7 +1030,7 @@ find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, * Look for the qtype. */ result = findrdataset(db, node, version, type, 0, now, rdataset, - sigrdataset); + sigrdataset DNS__DB_FLARG_PASS); if (result == ISC_R_SUCCESS) { break; } @@ -1033,9 +1039,9 @@ find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, * Look for a CNAME. */ if (type != dns_rdatatype_cname) { - result = findrdataset(db, node, version, - dns_rdatatype_cname, 0, now, - rdataset, sigrdataset); + result = findrdataset( + db, node, version, dns_rdatatype_cname, 0, now, + rdataset, sigrdataset DNS__DB_FLARG_PASS); if (result == ISC_R_SUCCESS) { result = DNS_R_CNAME; break; @@ -1057,14 +1063,15 @@ find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, if (nodep != NULL) { *nodep = node; } else if (node != NULL) { - detachnode(db, &node); + detachnode(db, &node DNS__DB_FLARG_PASS); } return (result); } static void -attachnode(dns_db_t *db, dns_dbnode_t *source, dns_dbnode_t **targetp) { +attachnode(dns_db_t *db, dns_dbnode_t *source, + dns_dbnode_t **targetp DNS__DB_FLARG) { bdb_t *bdb = (bdb_t *)db; bdbnode_t *node = (bdbnode_t *)source; @@ -1076,7 +1083,7 @@ attachnode(dns_db_t *db, dns_dbnode_t *source, dns_dbnode_t **targetp) { } static void -detachnode(dns_db_t *db, dns_dbnode_t **nodep) { +detachnode(dns_db_t *db, dns_dbnode_t **nodep DNS__DB_FLARG) { bdb_t *bdb = (bdb_t *)db; bdbnode_t *node = NULL; @@ -1094,7 +1101,8 @@ detachnode(dns_db_t *db, dns_dbnode_t **nodep) { static isc_result_t findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, dns_rdatatype_t type, dns_rdatatype_t covers, isc_stdtime_t now, - dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset) { + dns_rdataset_t *rdataset, + dns_rdataset_t *sigrdataset DNS__DB_FLARG) { bdbnode_t *bdbnode = (bdbnode_t *)node; dns_rdatalist_t *list = NULL; @@ -1128,7 +1136,7 @@ findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, static isc_result_t allrdatasets(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, unsigned int options, isc_stdtime_t now, - dns_rdatasetiter_t **iteratorp) { + dns_rdatasetiter_t **iteratorp DNS__DB_FLARG) { bdb_rdatasetiter_t *iterator = NULL; REQUIRE(version == NULL || version == &dummy); @@ -1143,7 +1151,7 @@ allrdatasets(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, .common.magic = DNS_RDATASETITER_MAGIC, }; - attachnode(db, node, &iterator->common.node); + attachnode(db, node, &iterator->common.node DNS__DB_FLARG_PASS); *iteratorp = (dns_rdatasetiter_t *)iterator; diff --git a/bin/tests/system/dyndb/driver/db.c b/bin/tests/system/dyndb/driver/db.c index a7123821000..33b6f890fa3 100644 --- a/bin/tests/system/dyndb/driver/db.c +++ b/bin/tests/system/dyndb/driver/db.c @@ -132,66 +132,72 @@ attachversion(dns_db_t *db, dns_dbversion_t *source, } static void -closeversion(dns_db_t *db, dns_dbversion_t **versionp, bool commit) { +closeversion(dns_db_t *db, dns_dbversion_t **versionp, + bool commit DNS__DB_FLARG) { sampledb_t *sampledb = (sampledb_t *)db; REQUIRE(VALID_SAMPLEDB(sampledb)); - dns_db_closeversion(sampledb->rbtdb, versionp, commit); + dns__db_closeversion(sampledb->rbtdb, versionp, + commit DNS__DB_FLARG_PASS); } static isc_result_t findnode(dns_db_t *db, const dns_name_t *name, bool create, - dns_dbnode_t **nodep) { + dns_dbnode_t **nodep DNS__DB_FLARG) { sampledb_t *sampledb = (sampledb_t *)db; REQUIRE(VALID_SAMPLEDB(sampledb)); - return (dns_db_findnode(sampledb->rbtdb, name, create, nodep)); + return (dns__db_findnode(sampledb->rbtdb, name, create, + nodep DNS__DB_FLARG_PASS)); } static isc_result_t find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, dns_rdatatype_t type, unsigned int options, isc_stdtime_t now, dns_dbnode_t **nodep, dns_name_t *foundname, dns_rdataset_t *rdataset, - dns_rdataset_t *sigrdataset) { + dns_rdataset_t *sigrdataset DNS__DB_FLARG) { sampledb_t *sampledb = (sampledb_t *)db; REQUIRE(VALID_SAMPLEDB(sampledb)); - return (dns_db_find(sampledb->rbtdb, name, version, type, options, now, - nodep, foundname, rdataset, sigrdataset)); + return (dns__db_find(sampledb->rbtdb, name, version, type, options, now, + nodep, foundname, rdataset, + sigrdataset DNS__DB_FLARG_PASS)); } static isc_result_t findzonecut(dns_db_t *db, const dns_name_t *name, unsigned int options, isc_stdtime_t now, dns_dbnode_t **nodep, dns_name_t *foundname, dns_name_t *dcname, dns_rdataset_t *rdataset, - dns_rdataset_t *sigrdataset) { + dns_rdataset_t *sigrdataset DNS__DB_FLARG) { sampledb_t *sampledb = (sampledb_t *)db; REQUIRE(VALID_SAMPLEDB(sampledb)); - return (dns_db_findzonecut(sampledb->rbtdb, name, options, now, nodep, - foundname, dcname, rdataset, sigrdataset)); + return (dns__db_findzonecut(sampledb->rbtdb, name, options, now, nodep, + foundname, dcname, rdataset, + sigrdataset DNS__DB_FLARG_PASS)); } static void -attachnode(dns_db_t *db, dns_dbnode_t *source, dns_dbnode_t **targetp) { +attachnode(dns_db_t *db, dns_dbnode_t *source, + dns_dbnode_t **targetp DNS__DB_FLARG) { sampledb_t *sampledb = (sampledb_t *)db; REQUIRE(VALID_SAMPLEDB(sampledb)); - dns_db_attachnode(sampledb->rbtdb, source, targetp); + dns__db_attachnode(sampledb->rbtdb, source, targetp DNS__DB_FLARG_PASS); } static void -detachnode(dns_db_t *db, dns_dbnode_t **targetp) { +detachnode(dns_db_t *db, dns_dbnode_t **targetp DNS__DB_FLARG) { sampledb_t *sampledb = (sampledb_t *)db; REQUIRE(VALID_SAMPLEDB(sampledb)); - dns_db_detachnode(sampledb->rbtdb, targetp); + dns__db_detachnode(sampledb->rbtdb, targetp DNS__DB_FLARG_PASS); } static isc_result_t @@ -225,31 +231,33 @@ createiterator(dns_db_t *db, unsigned int options, static isc_result_t findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, dns_rdatatype_t type, dns_rdatatype_t covers, isc_stdtime_t now, - dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset) { + dns_rdataset_t *rdataset, + dns_rdataset_t *sigrdataset DNS__DB_FLARG) { sampledb_t *sampledb = (sampledb_t *)db; REQUIRE(VALID_SAMPLEDB(sampledb)); - return (dns_db_findrdataset(sampledb->rbtdb, node, version, type, - covers, now, rdataset, sigrdataset)); + return (dns__db_findrdataset(sampledb->rbtdb, node, version, type, + covers, now, rdataset, + sigrdataset DNS__DB_FLARG_PASS)); } static isc_result_t allrdatasets(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, unsigned int options, isc_stdtime_t now, - dns_rdatasetiter_t **iteratorp) { + dns_rdatasetiter_t **iteratorp DNS__DB_FLARG) { sampledb_t *sampledb = (sampledb_t *)db; REQUIRE(VALID_SAMPLEDB(sampledb)); - return (dns_db_allrdatasets(sampledb->rbtdb, node, version, options, - now, iteratorp)); + return (dns__db_allrdatasets(sampledb->rbtdb, node, version, options, + now, iteratorp DNS__DB_FLARG_PASS)); } static isc_result_t addrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, isc_stdtime_t now, dns_rdataset_t *rdataset, unsigned int options, - dns_rdataset_t *addedrdataset) { + dns_rdataset_t *addedrdataset DNS__DB_FLARG) { sampledb_t *sampledb = (sampledb_t *)db; isc_result_t result; dns_fixedname_t name; @@ -257,8 +265,8 @@ addrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, REQUIRE(VALID_SAMPLEDB(sampledb)); dns_fixedname_init(&name); - CHECK(dns_db_addrdataset(sampledb->rbtdb, node, version, now, rdataset, - options, addedrdataset)); + CHECK(dns__db_addrdataset(sampledb->rbtdb, node, version, now, rdataset, + options, addedrdataset DNS__DB_FLARG_PASS)); if (rdataset->type == dns_rdatatype_a || rdataset->type == dns_rdatatype_aaaa) { @@ -274,7 +282,7 @@ cleanup: static isc_result_t subtractrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, dns_rdataset_t *rdataset, unsigned int options, - dns_rdataset_t *newrdataset) { + dns_rdataset_t *newrdataset DNS__DB_FLARG) { sampledb_t *sampledb = (sampledb_t *)db; isc_result_t result; dns_fixedname_t name; @@ -282,8 +290,9 @@ subtractrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, REQUIRE(VALID_SAMPLEDB(sampledb)); dns_fixedname_init(&name); - result = dns_db_subtractrdataset(sampledb->rbtdb, node, version, - rdataset, options, newrdataset); + result = dns__db_subtractrdataset(sampledb->rbtdb, node, version, + rdataset, options, + newrdataset DNS__DB_FLARG_PASS); if (result != ISC_R_SUCCESS && result != DNS_R_NXRRSET) { goto cleanup; } @@ -306,13 +315,13 @@ cleanup: */ static isc_result_t deleterdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, - dns_rdatatype_t type, dns_rdatatype_t covers) { + dns_rdatatype_t type, dns_rdatatype_t covers DNS__DB_FLARG) { sampledb_t *sampledb = (sampledb_t *)db; REQUIRE(VALID_SAMPLEDB(sampledb)); - return (dns_db_deleterdataset(sampledb->rbtdb, node, version, type, - covers)); + return (dns__db_deleterdataset(sampledb->rbtdb, node, version, type, + covers DNS__DB_FLARG_PASS)); } static bool @@ -352,12 +361,13 @@ setloop(dns_db_t *db, isc_loop_t *loop) { } static isc_result_t -getoriginnode(dns_db_t *db, dns_dbnode_t **nodep) { +getoriginnode(dns_db_t *db, dns_dbnode_t **nodep DNS__DB_FLARG) { sampledb_t *sampledb = (sampledb_t *)db; REQUIRE(VALID_SAMPLEDB(sampledb)); - return (dns_db_getoriginnode(sampledb->rbtdb, nodep)); + return (dns__db_getoriginnode(sampledb->rbtdb, + nodep DNS__DB_FLARG_PASS)); } static void @@ -383,12 +393,13 @@ getnsec3parameters(dns_db_t *db, dns_dbversion_t *version, dns_hash_t *hash, static isc_result_t findnsec3node(dns_db_t *db, const dns_name_t *name, bool create, - dns_dbnode_t **nodep) { + dns_dbnode_t **nodep DNS__DB_FLARG) { sampledb_t *sampledb = (sampledb_t *)db; REQUIRE(VALID_SAMPLEDB(sampledb)); - return (dns_db_findnsec3node(sampledb->rbtdb, name, create, nodep)); + return (dns__db_findnsec3node(sampledb->rbtdb, name, create, + nodep DNS__DB_FLARG_PASS)); } static isc_result_t @@ -401,21 +412,24 @@ setsigningtime(dns_db_t *db, dns_rdataset_t *rdataset, isc_stdtime_t resign) { } static isc_result_t -getsigningtime(dns_db_t *db, dns_rdataset_t *rdataset, dns_name_t *name) { +getsigningtime(dns_db_t *db, dns_rdataset_t *rdataset, + dns_name_t *name DNS__DB_FLARG) { sampledb_t *sampledb = (sampledb_t *)db; REQUIRE(VALID_SAMPLEDB(sampledb)); - return (dns_db_getsigningtime(sampledb->rbtdb, rdataset, name)); + return (dns__db_getsigningtime(sampledb->rbtdb, rdataset, + name DNS__DB_FLARG_PASS)); } static void -resigned(dns_db_t *db, dns_rdataset_t *rdataset, dns_dbversion_t *version) { +resigned(dns_db_t *db, dns_rdataset_t *rdataset, + dns_dbversion_t *version DNS__DB_FLARG) { sampledb_t *sampledb = (sampledb_t *)db; REQUIRE(VALID_SAMPLEDB(sampledb)); - dns_db_resigned(sampledb->rbtdb, rdataset, version); + dns__db_resigned(sampledb->rbtdb, rdataset, version DNS__DB_FLARG_PASS); } static bool @@ -439,13 +453,13 @@ getrrsetstats(dns_db_t *db) { static isc_result_t findnodeext(dns_db_t *db, const dns_name_t *name, bool create, dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo, - dns_dbnode_t **nodep) { + dns_dbnode_t **nodep DNS__DB_FLARG) { sampledb_t *sampledb = (sampledb_t *)db; REQUIRE(VALID_SAMPLEDB(sampledb)); - return (dns_db_findnodeext(sampledb->rbtdb, name, create, methods, - clientinfo, nodep)); + return (dns__db_findnodeext(sampledb->rbtdb, name, create, methods, + clientinfo, nodep DNS__DB_FLARG_PASS)); } static isc_result_t @@ -453,14 +467,14 @@ findext(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, dns_rdatatype_t type, unsigned int options, isc_stdtime_t now, dns_dbnode_t **nodep, dns_name_t *foundname, dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo, - dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset) { + dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset DNS__DB_FLARG) { sampledb_t *sampledb = (sampledb_t *)db; REQUIRE(VALID_SAMPLEDB(sampledb)); - return (dns_db_findext(sampledb->rbtdb, name, version, type, options, - now, nodep, foundname, methods, clientinfo, - rdataset, sigrdataset)); + return (dns__db_findext(sampledb->rbtdb, name, version, type, options, + now, nodep, foundname, methods, clientinfo, + rdataset, sigrdataset DNS__DB_FLARG_PASS)); } static isc_result_t diff --git a/lib/dns/Makefile.am b/lib/dns/Makefile.am index aa88ad1962d..d5a64707f6c 100644 --- a/lib/dns/Makefile.am +++ b/lib/dns/Makefile.am @@ -126,6 +126,7 @@ libdns_la_HEADERS = \ include/dns/time.h \ include/dns/transport.h \ include/dns/tkey.h \ + include/dns/trace.h \ include/dns/tsig.h \ include/dns/ttl.h \ include/dns/types.h \ diff --git a/lib/dns/db.c b/lib/dns/db.c index de2e26a9e67..29beaa3184b 100644 --- a/lib/dns/db.c +++ b/lib/dns/db.c @@ -26,6 +26,7 @@ #include #include #include +#include #include #include @@ -411,7 +412,8 @@ dns_db_attachversion(dns_db_t *db, dns_dbversion_t *source, } void -dns_db_closeversion(dns_db_t *db, dns_dbversion_t **versionp, bool commit) { +dns__db_closeversion(dns_db_t *db, dns_dbversion_t **versionp, + bool commit DNS__DB_FLARG) { dns_dbonupdatelistener_t *listener; /* @@ -422,7 +424,7 @@ dns_db_closeversion(dns_db_t *db, dns_dbversion_t **versionp, bool commit) { REQUIRE((db->attributes & DNS_DBATTR_CACHE) == 0); REQUIRE(versionp != NULL && *versionp != NULL); - (db->methods->closeversion)(db, versionp, commit); + (db->methods->closeversion)(db, versionp, commit DNS__DB_FLARG_PASS); if (commit) { for (listener = ISC_LIST_HEAD(db->update_listeners); @@ -440,8 +442,8 @@ dns_db_closeversion(dns_db_t *db, dns_dbversion_t **versionp, bool commit) { ***/ isc_result_t -dns_db_findnode(dns_db_t *db, const dns_name_t *name, bool create, - dns_dbnode_t **nodep) { +dns__db_findnode(dns_db_t *db, const dns_name_t *name, bool create, + dns_dbnode_t **nodep DNS__DB_FLARG) { /* * Find the node with name 'name'. */ @@ -450,17 +452,19 @@ dns_db_findnode(dns_db_t *db, const dns_name_t *name, bool create, REQUIRE(nodep != NULL && *nodep == NULL); if (db->methods->findnode != NULL) { - return ((db->methods->findnode)(db, name, create, nodep)); + return ((db->methods->findnode)(db, name, create, + nodep DNS__DB_FLARG_PASS)); } else { return ((db->methods->findnodeext)(db, name, create, NULL, NULL, - nodep)); + nodep DNS__DB_FLARG_PASS)); } } isc_result_t -dns_db_findnodeext(dns_db_t *db, const dns_name_t *name, bool create, - dns_clientinfomethods_t *methods, - dns_clientinfo_t *clientinfo, dns_dbnode_t **nodep) { +dns__db_findnodeext(dns_db_t *db, const dns_name_t *name, bool create, + dns_clientinfomethods_t *methods, + dns_clientinfo_t *clientinfo, + dns_dbnode_t **nodep DNS__DB_FLARG) { /* * Find the node with name 'name', passing 'arg' to the database * implementation. @@ -471,15 +475,17 @@ dns_db_findnodeext(dns_db_t *db, const dns_name_t *name, bool create, if (db->methods->findnodeext != NULL) { return ((db->methods->findnodeext)(db, name, create, methods, - clientinfo, nodep)); + clientinfo, + nodep DNS__DB_FLARG_PASS)); } else { - return ((db->methods->findnode)(db, name, create, nodep)); + return ((db->methods->findnode)(db, name, create, + nodep DNS__DB_FLARG_PASS)); } } isc_result_t -dns_db_findnsec3node(dns_db_t *db, const dns_name_t *name, bool create, - dns_dbnode_t **nodep) { +dns__db_findnsec3node(dns_db_t *db, const dns_name_t *name, bool create, + dns_dbnode_t **nodep DNS__DB_FLARG) { /* * Find the node with name 'name'. */ @@ -487,14 +493,16 @@ dns_db_findnsec3node(dns_db_t *db, const dns_name_t *name, bool create, REQUIRE(DNS_DB_VALID(db)); REQUIRE(nodep != NULL && *nodep == NULL); - return ((db->methods->findnsec3node)(db, name, create, nodep)); + return ((db->methods->findnsec3node)(db, name, create, + nodep DNS__DB_FLARG_PASS)); } isc_result_t -dns_db_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, - dns_rdatatype_t type, unsigned int options, isc_stdtime_t now, - dns_dbnode_t **nodep, dns_name_t *foundname, - dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset) { +dns__db_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, + dns_rdatatype_t type, unsigned int options, isc_stdtime_t now, + dns_dbnode_t **nodep, dns_name_t *foundname, + dns_rdataset_t *rdataset, + dns_rdataset_t *sigrdataset DNS__DB_FLARG) { /* * Find the best match for 'name' and 'type' in version 'version' * of 'db'. @@ -513,20 +521,21 @@ dns_db_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, if (db->methods->find != NULL) { return ((db->methods->find)(db, name, version, type, options, now, nodep, foundname, rdataset, - sigrdataset)); + sigrdataset DNS__DB_FLARG_PASS)); } else { - return ((db->methods->findext)(db, name, version, type, options, - now, nodep, foundname, NULL, - NULL, rdataset, sigrdataset)); + return ((db->methods->findext)( + db, name, version, type, options, now, nodep, foundname, + NULL, NULL, rdataset, sigrdataset DNS__DB_FLARG_PASS)); } } isc_result_t -dns_db_findext(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, - dns_rdatatype_t type, unsigned int options, isc_stdtime_t now, - dns_dbnode_t **nodep, dns_name_t *foundname, - dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo, - dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset) { +dns__db_findext(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, + dns_rdatatype_t type, unsigned int options, isc_stdtime_t now, + dns_dbnode_t **nodep, dns_name_t *foundname, + dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo, + dns_rdataset_t *rdataset, + dns_rdataset_t *sigrdataset DNS__DB_FLARG) { /* * Find the best match for 'name' and 'type' in version 'version' * of 'db', passing in 'arg'. @@ -543,21 +552,23 @@ dns_db_findext(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, !dns_rdataset_isassociated(sigrdataset))); if (db->methods->findext != NULL) { - return ((db->methods->findext)( - db, name, version, type, options, now, nodep, foundname, - methods, clientinfo, rdataset, sigrdataset)); + return ((db->methods->findext)(db, name, version, type, options, + now, nodep, foundname, methods, + clientinfo, rdataset, + sigrdataset DNS__DB_FLARG_PASS)); } else { return ((db->methods->find)(db, name, version, type, options, now, nodep, foundname, rdataset, - sigrdataset)); + sigrdataset DNS__DB_FLARG_PASS)); } } isc_result_t -dns_db_findzonecut(dns_db_t *db, const dns_name_t *name, unsigned int options, - isc_stdtime_t now, dns_dbnode_t **nodep, - dns_name_t *foundname, dns_name_t *dcname, - dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset) { +dns__db_findzonecut(dns_db_t *db, const dns_name_t *name, unsigned int options, + isc_stdtime_t now, dns_dbnode_t **nodep, + dns_name_t *foundname, dns_name_t *dcname, + dns_rdataset_t *rdataset, + dns_rdataset_t *sigrdataset DNS__DB_FLARG) { /* * Find the deepest known zonecut which encloses 'name' in 'db'. * foundname is the zonecut, dcname is the deepest name we have @@ -573,15 +584,16 @@ dns_db_findzonecut(dns_db_t *db, const dns_name_t *name, unsigned int options, !dns_rdataset_isassociated(sigrdataset))); if (db->methods->findzonecut != NULL) { - return ((db->methods->findzonecut)(db, name, options, now, - nodep, foundname, dcname, - rdataset, sigrdataset)); + return ((db->methods->findzonecut)( + db, name, options, now, nodep, foundname, dcname, + rdataset, sigrdataset DNS__DB_FLARG_PASS)); } return (ISC_R_NOTIMPLEMENTED); } void -dns_db_attachnode(dns_db_t *db, dns_dbnode_t *source, dns_dbnode_t **targetp) { +dns__db_attachnode(dns_db_t *db, dns_dbnode_t *source, + dns_dbnode_t **targetp DNS__DB_FLARG) { /* * Attach *targetp to source. */ @@ -590,11 +602,11 @@ dns_db_attachnode(dns_db_t *db, dns_dbnode_t *source, dns_dbnode_t **targetp) { REQUIRE(source != NULL); REQUIRE(targetp != NULL && *targetp == NULL); - (db->methods->attachnode)(db, source, targetp); + (db->methods->attachnode)(db, source, targetp DNS__DB_FLARG_PASS); } void -dns_db_detachnode(dns_db_t *db, dns_dbnode_t **nodep) { +dns__db_detachnode(dns_db_t *db, dns_dbnode_t **nodep DNS__DB_FLARG) { /* * Detach *nodep from its node. */ @@ -602,7 +614,7 @@ dns_db_detachnode(dns_db_t *db, dns_dbnode_t **nodep) { REQUIRE(DNS_DB_VALID(db)); REQUIRE(nodep != NULL && *nodep != NULL); - (db->methods->detachnode)(db, nodep); + (db->methods->detachnode)(db, nodep DNS__DB_FLARG_PASS); ENSURE(*nodep == NULL); } @@ -687,10 +699,10 @@ dns_db_createiterator(dns_db_t *db, unsigned int flags, ***/ isc_result_t -dns_db_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, - dns_rdatatype_t type, dns_rdatatype_t covers, - isc_stdtime_t now, dns_rdataset_t *rdataset, - dns_rdataset_t *sigrdataset) { +dns__db_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, + dns_rdatatype_t type, dns_rdatatype_t covers, + isc_stdtime_t now, dns_rdataset_t *rdataset, + dns_rdataset_t *sigrdataset DNS__DB_FLARG) { REQUIRE(DNS_DB_VALID(db)); REQUIRE(node != NULL); REQUIRE(DNS_RDATASET_VALID(rdataset)); @@ -702,13 +714,14 @@ dns_db_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, !dns_rdataset_isassociated(sigrdataset))); return ((db->methods->findrdataset)(db, node, version, type, covers, - now, rdataset, sigrdataset)); + now, rdataset, + sigrdataset DNS__DB_FLARG_PASS)); } isc_result_t -dns_db_allrdatasets(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, - unsigned int options, isc_stdtime_t now, - dns_rdatasetiter_t **iteratorp) { +dns__db_allrdatasets(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, + unsigned int options, isc_stdtime_t now, + dns_rdatasetiter_t **iteratorp DNS__DB_FLARG) { /* * Make '*iteratorp' an rdataset iteratator for all rdatasets at * 'node' in version 'version' of 'db'. @@ -718,13 +731,14 @@ dns_db_allrdatasets(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, REQUIRE(iteratorp != NULL && *iteratorp == NULL); return ((db->methods->allrdatasets)(db, node, version, options, now, - iteratorp)); + iteratorp DNS__DB_FLARG_PASS)); } isc_result_t -dns_db_addrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, - isc_stdtime_t now, dns_rdataset_t *rdataset, - unsigned int options, dns_rdataset_t *addedrdataset) { +dns__db_addrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, + isc_stdtime_t now, dns_rdataset_t *rdataset, + unsigned int options, + dns_rdataset_t *addedrdataset DNS__DB_FLARG) { /* * Add 'rdataset' to 'node' in version 'version' of 'db'. */ @@ -744,17 +758,18 @@ dns_db_addrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, !dns_rdataset_isassociated(addedrdataset))); if (db->methods->addrdataset != NULL) { - return ((db->methods->addrdataset)(db, node, version, now, - rdataset, options, - addedrdataset)); + return ((db->methods->addrdataset)( + db, node, version, now, rdataset, options, + addedrdataset DNS__DB_FLARG_PASS)); } return (ISC_R_NOTIMPLEMENTED); } isc_result_t -dns_db_subtractrdataset(dns_db_t *db, dns_dbnode_t *node, - dns_dbversion_t *version, dns_rdataset_t *rdataset, - unsigned int options, dns_rdataset_t *newrdataset) { +dns__db_subtractrdataset(dns_db_t *db, dns_dbnode_t *node, + dns_dbversion_t *version, dns_rdataset_t *rdataset, + unsigned int options, + dns_rdataset_t *newrdataset DNS__DB_FLARG) { /* * Remove any rdata in 'rdataset' from 'node' in version 'version' of * 'db'. @@ -772,15 +787,16 @@ dns_db_subtractrdataset(dns_db_t *db, dns_dbnode_t *node, if (db->methods->subtractrdataset != NULL) { return ((db->methods->subtractrdataset)( - db, node, version, rdataset, options, newrdataset)); + db, node, version, rdataset, options, + newrdataset DNS__DB_FLARG_PASS)); } return (ISC_R_NOTIMPLEMENTED); } isc_result_t -dns_db_deleterdataset(dns_db_t *db, dns_dbnode_t *node, - dns_dbversion_t *version, dns_rdatatype_t type, - dns_rdatatype_t covers) { +dns__db_deleterdataset(dns_db_t *db, dns_dbnode_t *node, + dns_dbversion_t *version, dns_rdatatype_t type, + dns_rdatatype_t covers DNS__DB_FLARG) { /* * Make it so that no rdataset of type 'type' exists at 'node' in * version version 'version' of 'db'. @@ -792,8 +808,8 @@ dns_db_deleterdataset(dns_db_t *db, dns_dbnode_t *node, ((db->attributes & DNS_DBATTR_CACHE) != 0 && version == NULL)); if (db->methods->deleterdataset != NULL) { - return ((db->methods->deleterdataset)(db, node, version, type, - covers)); + return ((db->methods->deleterdataset)( + db, node, version, type, covers DNS__DB_FLARG_PASS)); } return (ISC_R_NOTIMPLEMENTED); } @@ -933,13 +949,14 @@ dns_db_unregister(dns_dbimplementation_t **dbimp) { } isc_result_t -dns_db_getoriginnode(dns_db_t *db, dns_dbnode_t **nodep) { +dns__db_getoriginnode(dns_db_t *db, dns_dbnode_t **nodep DNS__DB_FLARG) { REQUIRE(DNS_DB_VALID(db)); REQUIRE(dns_db_iszone(db)); REQUIRE(nodep != NULL && *nodep == NULL); if (db->methods->getoriginnode != NULL) { - return ((db->methods->getoriginnode)(db, nodep)); + return ((db->methods->getoriginnode)(db, + nodep DNS__DB_FLARG_PASS)); } return (ISC_R_NOTFOUND); @@ -1007,19 +1024,21 @@ dns_db_setsigningtime(dns_db_t *db, dns_rdataset_t *rdataset, } isc_result_t -dns_db_getsigningtime(dns_db_t *db, dns_rdataset_t *rdataset, - dns_name_t *name) { +dns__db_getsigningtime(dns_db_t *db, dns_rdataset_t *rdataset, + dns_name_t *name DNS__DB_FLARG) { if (db->methods->getsigningtime != NULL) { - return ((db->methods->getsigningtime)(db, rdataset, name)); + return ((db->methods->getsigningtime)(db, rdataset, + name DNS__DB_FLARG_PASS)); } return (ISC_R_NOTFOUND); } void -dns_db_resigned(dns_db_t *db, dns_rdataset_t *rdataset, - dns_dbversion_t *version) { +dns__db_resigned(dns_db_t *db, dns_rdataset_t *rdataset, + dns_dbversion_t *version DNS__DB_FLARG) { if (db->methods->resigned != NULL) { - (db->methods->resigned)(db, rdataset, version); + (db->methods->resigned)(db, rdataset, + version DNS__DB_FLARG_PASS); } } diff --git a/lib/dns/dbiterator.c b/lib/dns/dbiterator.c index 2bb7e933389..eaa8eba2290 100644 --- a/lib/dns/dbiterator.c +++ b/lib/dns/dbiterator.c @@ -21,7 +21,7 @@ #include void -dns_dbiterator_destroy(dns_dbiterator_t **iteratorp) { +dns__dbiterator_destroy(dns_dbiterator_t **iteratorp DNS__DB_FLARG) { /* * Destroy '*iteratorp'. */ @@ -29,69 +29,70 @@ dns_dbiterator_destroy(dns_dbiterator_t **iteratorp) { REQUIRE(iteratorp != NULL); REQUIRE(DNS_DBITERATOR_VALID(*iteratorp)); - (*iteratorp)->methods->destroy(iteratorp); + (*iteratorp)->methods->destroy(iteratorp DNS__DB_FLARG_PASS); ENSURE(*iteratorp == NULL); } isc_result_t -dns_dbiterator_first(dns_dbiterator_t *iterator) { +dns__dbiterator_first(dns_dbiterator_t *iterator DNS__DB_FLARG) { /* * Move the node cursor to the first node in the database (if any). */ REQUIRE(DNS_DBITERATOR_VALID(iterator)); - return (iterator->methods->first(iterator)); + return (iterator->methods->first(iterator DNS__DB_FLARG_PASS)); } isc_result_t -dns_dbiterator_last(dns_dbiterator_t *iterator) { +dns__dbiterator_last(dns_dbiterator_t *iterator DNS__DB_FLARG) { /* * Move the node cursor to the first node in the database (if any). */ REQUIRE(DNS_DBITERATOR_VALID(iterator)); - return (iterator->methods->last(iterator)); + return (iterator->methods->last(iterator DNS__DB_FLARG_PASS)); } isc_result_t -dns_dbiterator_seek(dns_dbiterator_t *iterator, const dns_name_t *name) { +dns__dbiterator_seek(dns_dbiterator_t *iterator, + const dns_name_t *name DNS__DB_FLARG) { /* * Move the node cursor to the node with name 'name'. */ REQUIRE(DNS_DBITERATOR_VALID(iterator)); - return (iterator->methods->seek(iterator, name)); + return (iterator->methods->seek(iterator, name DNS__DB_FLARG_PASS)); } isc_result_t -dns_dbiterator_prev(dns_dbiterator_t *iterator) { +dns__dbiterator_prev(dns_dbiterator_t *iterator DNS__DB_FLARG) { /* * Move the node cursor to the previous node in the database (if any). */ REQUIRE(DNS_DBITERATOR_VALID(iterator)); - return (iterator->methods->prev(iterator)); + return (iterator->methods->prev(iterator DNS__DB_FLARG_PASS)); } isc_result_t -dns_dbiterator_next(dns_dbiterator_t *iterator) { +dns__dbiterator_next(dns_dbiterator_t *iterator DNS__DB_FLARG) { /* * Move the node cursor to the next node in the database (if any). */ REQUIRE(DNS_DBITERATOR_VALID(iterator)); - return (iterator->methods->next(iterator)); + return (iterator->methods->next(iterator DNS__DB_FLARG_PASS)); } isc_result_t -dns_dbiterator_current(dns_dbiterator_t *iterator, dns_dbnode_t **nodep, - dns_name_t *name) { +dns__dbiterator_current(dns_dbiterator_t *iterator, dns_dbnode_t **nodep, + dns_name_t *name DNS__DB_FLARG) { /* * Return the current node. */ @@ -100,7 +101,8 @@ dns_dbiterator_current(dns_dbiterator_t *iterator, dns_dbnode_t **nodep, REQUIRE(nodep != NULL && *nodep == NULL); REQUIRE(name == NULL || dns_name_hasbuffer(name)); - return (iterator->methods->current(iterator, nodep, name)); + return (iterator->methods->current(iterator, nodep, + name DNS__DB_FLARG_PASS)); } isc_result_t diff --git a/lib/dns/diff.c b/lib/dns/diff.c index fc8bbb06908..8f900ab26a9 100644 --- a/lib/dns/diff.c +++ b/lib/dns/diff.c @@ -517,7 +517,8 @@ dns_diff_load(dns_diff_t *diff, dns_addrdatasetfunc_t addfunc, rds.trust = dns_trust_ultimate; INSIST(op == DNS_DIFFOP_ADD); - result = (*addfunc)(add_private, name, &rds); + result = (*addfunc)(add_private, name, + &rds DNS__DB_FILELINE); if (result == DNS_R_UNCHANGED) { isc_log_write(DIFF_COMMON_LOGARGS, ISC_LOG_WARNING, diff --git a/lib/dns/include/dns/db.h b/lib/dns/include/dns/db.h index de41b122127..ccb562cd417 100644 --- a/lib/dns/include/dns/db.h +++ b/lib/dns/include/dns/db.h @@ -89,24 +89,25 @@ typedef struct dns_dbmethods { void (*attachversion)(dns_db_t *db, dns_dbversion_t *source, dns_dbversion_t **targetp); void (*closeversion)(dns_db_t *db, dns_dbversion_t **versionp, - bool commit); + bool commit DNS__DB_FLARG); isc_result_t (*findnode)(dns_db_t *db, const dns_name_t *name, - bool create, dns_dbnode_t **nodep); + bool create, + dns_dbnode_t **nodep DNS__DB_FLARG); isc_result_t (*find)(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, dns_rdatatype_t type, unsigned int options, isc_stdtime_t now, dns_dbnode_t **nodep, dns_name_t *foundname, - dns_rdataset_t *rdataset, - dns_rdataset_t *sigrdataset); + dns_rdataset_t *rdataset, + dns_rdataset_t *sigrdataset DNS__DB_FLARG); isc_result_t (*findzonecut)(dns_db_t *db, const dns_name_t *name, unsigned int options, isc_stdtime_t now, dns_dbnode_t **nodep, dns_name_t *foundname, - dns_name_t *dcname, - dns_rdataset_t *rdataset, - dns_rdataset_t *sigrdataset); + dns_name_t *dcname, + dns_rdataset_t *rdataset, + dns_rdataset_t *sigrdataset DNS__DB_FLARG); void (*attachnode)(dns_db_t *db, dns_dbnode_t *source, - dns_dbnode_t **targetp); - void (*detachnode)(dns_db_t *db, dns_dbnode_t **targetp); + dns_dbnode_t **targetp DNS__DB_FLARG); + void (*detachnode)(dns_db_t *db, dns_dbnode_t **targetp DNS__DB_FLARG); isc_result_t (*expirenode)(dns_db_t *db, dns_dbnode_t *node, isc_stdtime_t now); void (*printnode)(dns_db_t *db, dns_dbnode_t *node, FILE *out); @@ -116,32 +117,32 @@ typedef struct dns_dbmethods { dns_dbversion_t *version, dns_rdatatype_t type, dns_rdatatype_t covers, isc_stdtime_t now, - dns_rdataset_t *rdataset, - dns_rdataset_t *sigrdataset); - isc_result_t (*allrdatasets)(dns_db_t *db, dns_dbnode_t *node, - dns_dbversion_t *version, - unsigned int options, isc_stdtime_t now, - dns_rdatasetiter_t **iteratorp); + dns_rdataset_t *rdataset, + dns_rdataset_t *sigrdataset DNS__DB_FLARG); + isc_result_t (*allrdatasets)( + dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, + unsigned int options, isc_stdtime_t now, + dns_rdatasetiter_t **iteratorp DNS__DB_FLARG); isc_result_t (*addrdataset)(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, isc_stdtime_t now, dns_rdataset_t *rdataset, unsigned int options, - dns_rdataset_t *addedrdataset); - isc_result_t (*subtractrdataset)(dns_db_t *db, dns_dbnode_t *node, - dns_dbversion_t *version, - dns_rdataset_t *rdataset, - unsigned int options, - dns_rdataset_t *newrdataset); + dns_rdataset_t *addedrdataset DNS__DB_FLARG); + isc_result_t (*subtractrdataset)( + dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, + dns_rdataset_t *rdataset, unsigned int options, + dns_rdataset_t *newrdataset DNS__DB_FLARG); isc_result_t (*deleterdataset)(dns_db_t *db, dns_dbnode_t *node, - dns_dbversion_t *version, - dns_rdatatype_t type, - dns_rdatatype_t covers); + dns_dbversion_t *version, + dns_rdatatype_t type, + dns_rdatatype_t covers DNS__DB_FLARG); bool (*issecure)(dns_db_t *db); unsigned int (*nodecount)(dns_db_t *db, dns_dbtree_t); bool (*ispersistent)(dns_db_t *db); void (*overmem)(dns_db_t *db, bool overmem); void (*setloop)(dns_db_t *db, isc_loop_t *); - isc_result_t (*getoriginnode)(dns_db_t *db, dns_dbnode_t **nodep); + isc_result_t (*getoriginnode)(dns_db_t *db, + dns_dbnode_t **nodep DNS__DB_FLARG); void (*transfernode)(dns_db_t *db, dns_dbnode_t **sourcep, dns_dbnode_t **targetp); isc_result_t (*getnsec3parameters)(dns_db_t *db, @@ -151,28 +152,29 @@ typedef struct dns_dbmethods { unsigned char *salt, size_t *salt_len); isc_result_t (*findnsec3node)(dns_db_t *db, const dns_name_t *name, - bool create, dns_dbnode_t **nodep); + bool create, + dns_dbnode_t **nodep DNS__DB_FLARG); isc_result_t (*setsigningtime)(dns_db_t *db, dns_rdataset_t *rdataset, isc_stdtime_t resign); isc_result_t (*getsigningtime)(dns_db_t *db, dns_rdataset_t *rdataset, - dns_name_t *name); + dns_name_t *name DNS__DB_FLARG); void (*resigned)(dns_db_t *db, dns_rdataset_t *rdataset, - dns_dbversion_t *version); + dns_dbversion_t *version DNS__DB_FLARG); bool (*isdnssec)(dns_db_t *db); dns_stats_t *(*getrrsetstats)(dns_db_t *db); isc_result_t (*findnodeext)(dns_db_t *db, const dns_name_t *name, bool create, dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo, - dns_dbnode_t **nodep); + dns_dbnode_t **nodep DNS__DB_FLARG); isc_result_t (*findext)(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, dns_rdatatype_t type, unsigned int options, isc_stdtime_t now, dns_dbnode_t **nodep, dns_name_t *foundname, - dns_clientinfomethods_t *methods, - dns_clientinfo_t *clientinfo, - dns_rdataset_t *rdataset, - dns_rdataset_t *sigrdataset); + dns_clientinfomethods_t *methods, + dns_clientinfo_t *clientinfo, + dns_rdataset_t *rdataset, + dns_rdataset_t *sigrdataset DNS__DB_FLARG); isc_result_t (*setcachestats)(dns_db_t *db, isc_stats_t *stats); size_t (*hashsize)(dns_db_t *db); isc_result_t (*nodefullname)(dns_db_t *db, dns_dbnode_t *node, @@ -633,8 +635,11 @@ dns_db_attachversion(dns_db_t *db, dns_dbversion_t *source, * \li '*targetp' is attached to source. */ +#define dns_db_closeversion(db, versionp, commit) \ + dns__db_closeversion(db, versionp, commit DNS__DB_FILELINE) void -dns_db_closeversion(dns_db_t *db, dns_dbversion_t **versionp, bool commit); +dns__db_closeversion(dns_db_t *db, dns_dbversion_t **versionp, + bool commit DNS__DB_FLARG); /*%< * Close version '*versionp'. * @@ -667,14 +672,20 @@ dns_db_closeversion(dns_db_t *db, dns_dbversion_t **versionp, bool commit); *** Node Methods ***/ +#define dns_db_findnode(db, name, create, nodep) \ + dns__db_findnode(db, name, create, nodep DNS__DB_FILELINE) isc_result_t -dns_db_findnode(dns_db_t *db, const dns_name_t *name, bool create, - dns_dbnode_t **nodep); +dns__db_findnode(dns_db_t *db, const dns_name_t *name, bool create, + dns_dbnode_t **nodep DNS__DB_FLARG); +#define dns_db_findnodeext(db, name, create, methods, clientinfo, nodep) \ + dns__db_findnodeext(db, name, create, methods, clientinfo, \ + nodep DNS__DB_FILELINE) isc_result_t -dns_db_findnodeext(dns_db_t *db, const dns_name_t *name, bool create, - dns_clientinfomethods_t *methods, - dns_clientinfo_t *clientinfo, dns_dbnode_t **nodep); +dns__db_findnodeext(dns_db_t *db, const dns_name_t *name, bool create, + dns_clientinfomethods_t *methods, + dns_clientinfo_t *clientinfo, + dns_dbnode_t **nodep DNS__DB_FLARG); /*%< * Find the node with name 'name'. * @@ -714,18 +725,29 @@ dns_db_findnodeext(dns_db_t *db, const dns_name_t *name, bool create, * implementation used. */ +#define dns_db_find(db, name, version, type, options, now, nodep, foundname, \ + rdataset, sigrdataset) \ + dns__db_find(db, name, version, type, options, now, nodep, foundname, \ + rdataset, sigrdataset DNS__DB_FILELINE) isc_result_t -dns_db_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, - dns_rdatatype_t type, unsigned int options, isc_stdtime_t now, - dns_dbnode_t **nodep, dns_name_t *foundname, - dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset); - +dns__db_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, + dns_rdatatype_t type, unsigned int options, isc_stdtime_t now, + dns_dbnode_t **nodep, dns_name_t *foundname, + dns_rdataset_t *rdataset, + dns_rdataset_t *sigrdataset DNS__DB_FLARG); + +#define dns_db_findext(db, name, version, type, options, now, nodep, \ + foundname, methods, clientinfo, rdataset, sigrdataset) \ + dns__db_findext(db, name, version, type, options, now, nodep, \ + foundname, methods, clientinfo, rdataset, \ + sigrdataset DNS__DB_FILELINE) isc_result_t -dns_db_findext(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, - dns_rdatatype_t type, unsigned int options, isc_stdtime_t now, - dns_dbnode_t **nodep, dns_name_t *foundname, - dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo, - dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset); +dns__db_findext(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, + dns_rdatatype_t type, unsigned int options, isc_stdtime_t now, + dns_dbnode_t **nodep, dns_name_t *foundname, + dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo, + dns_rdataset_t *rdataset, + dns_rdataset_t *sigrdataset DNS__DB_FLARG); /*%< * Find the best match for 'name' and 'type' in version 'version' of 'db'. * @@ -910,11 +932,16 @@ dns_db_findext(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, * errors. */ +#define dns_db_findzonecut(db, name, options, now, nodep, foundname, dcname, \ + rdataset, sigrdataset) \ + dns__db_findzonecut(db, name, options, now, nodep, foundname, dcname, \ + rdataset, sigrdataset DNS__DB_FILELINE) isc_result_t -dns_db_findzonecut(dns_db_t *db, const dns_name_t *name, unsigned int options, - isc_stdtime_t now, dns_dbnode_t **nodep, - dns_name_t *foundname, dns_name_t *dcname, - dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset); +dns__db_findzonecut(dns_db_t *db, const dns_name_t *name, unsigned int options, + isc_stdtime_t now, dns_dbnode_t **nodep, + dns_name_t *foundname, dns_name_t *dcname, + dns_rdataset_t *rdataset, + dns_rdataset_t *sigrdataset DNS__DB_FLARG); /*%< * Find the deepest known zonecut which encloses 'name' in 'db'. * @@ -960,8 +987,11 @@ dns_db_findzonecut(dns_db_t *db, const dns_name_t *name, unsigned int options, * errors. */ +#define dns_db_attachnode(db, source, targetp) \ + dns__db_attachnode(db, source, targetp DNS__DB_FILELINE) void -dns_db_attachnode(dns_db_t *db, dns_dbnode_t *source, dns_dbnode_t **targetp); +dns__db_attachnode(dns_db_t *db, dns_dbnode_t *source, + dns_dbnode_t **targetp DNS__DB_FLARG); /*%< * Attach *targetp to source. * @@ -978,8 +1008,10 @@ dns_db_attachnode(dns_db_t *db, dns_dbnode_t *source, dns_dbnode_t **targetp); * \li *targetp is attached to source. */ +#define dns_db_detachnode(db, nodep) \ + dns__db_detachnode(db, nodep DNS__DB_FILELINE) void -dns_db_detachnode(dns_db_t *db, dns_dbnode_t **nodep); +dns__db_detachnode(dns_db_t *db, dns_dbnode_t **nodep DNS__DB_FLARG); /*%< * Detach *nodep from its node. * @@ -1085,11 +1117,15 @@ dns_db_createiterator(dns_db_t *db, unsigned int options, * XXXRTH Should we check for glue and pending data in dns_db_findrdataset()? */ +#define dns_db_findrdataset(db, node, version, type, covers, now, rdataset, \ + sigrdataset) \ + dns__db_findrdataset(db, node, version, type, covers, now, rdataset, \ + sigrdataset DNS__DB_FILELINE) isc_result_t -dns_db_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, - dns_rdatatype_t type, dns_rdatatype_t covers, - isc_stdtime_t now, dns_rdataset_t *rdataset, - dns_rdataset_t *sigrdataset); +dns__db_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, + dns_rdatatype_t type, dns_rdatatype_t covers, + isc_stdtime_t now, dns_rdataset_t *rdataset, + dns_rdataset_t *sigrdataset DNS__DB_FLARG); /*%< * Search for an rdataset of type 'type' at 'node' that are in version @@ -1135,10 +1171,13 @@ dns_db_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, * implementation used. */ +#define dns_db_allrdatasets(db, node, version, options, now, iteratorp) \ + dns__db_allrdatasets(db, node, version, options, now, \ + iteratorp DNS__DB_FILELINE) isc_result_t -dns_db_allrdatasets(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, - unsigned int options, isc_stdtime_t now, - dns_rdatasetiter_t **iteratorp); +dns__db_allrdatasets(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, + unsigned int options, isc_stdtime_t now, + dns_rdatasetiter_t **iteratorp DNS__DB_FLARG); /*%< * Make '*iteratorp' an rdataset iterator for all rdatasets at 'node' in * version 'version' of 'db'. @@ -1180,10 +1219,15 @@ dns_db_allrdatasets(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, * implementation used. */ +#define dns_db_addrdataset(db, node, version, now, rdataset, options, \ + addedrdataset) \ + dns__db_addrdataset(db, node, version, now, rdataset, options, \ + addedrdataset DNS__DB_FILELINE) isc_result_t -dns_db_addrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, - isc_stdtime_t now, dns_rdataset_t *rdataset, - unsigned int options, dns_rdataset_t *addedrdataset); +dns__db_addrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, + isc_stdtime_t now, dns_rdataset_t *rdataset, + unsigned int options, + dns_rdataset_t *addedrdataset DNS__DB_FLARG); /*%< * Add 'rdataset' to 'node' in version 'version' of 'db'. * @@ -1238,10 +1282,15 @@ dns_db_addrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, * implementation used. */ +#define dns_db_subtractrdataset(db, node, version, rdataset, options, \ + newrdataset) \ + dns__db_subtractrdataset(db, node, version, rdataset, options, \ + newrdataset DNS__DB_FILELINE) isc_result_t -dns_db_subtractrdataset(dns_db_t *db, dns_dbnode_t *node, - dns_dbversion_t *version, dns_rdataset_t *rdataset, - unsigned int options, dns_rdataset_t *newrdataset); +dns__db_subtractrdataset(dns_db_t *db, dns_dbnode_t *node, + dns_dbversion_t *version, dns_rdataset_t *rdataset, + unsigned int options, + dns_rdataset_t *newrdataset DNS__DB_FLARG); /*%< * Remove any rdata in 'rdataset' from 'node' in version 'version' of * 'db'. @@ -1283,10 +1332,12 @@ dns_db_subtractrdataset(dns_db_t *db, dns_dbnode_t *node, * implementation used. */ +#define dns_db_deleterdataset(db, node, version, type, covers) \ + dns__db_deleterdataset(db, node, version, type, covers DNS__DB_FILELINE) isc_result_t -dns_db_deleterdataset(dns_db_t *db, dns_dbnode_t *node, - dns_dbversion_t *version, dns_rdatatype_t type, - dns_rdatatype_t covers); +dns__db_deleterdataset(dns_db_t *db, dns_dbnode_t *node, + dns_dbversion_t *version, dns_rdatatype_t type, + dns_rdatatype_t covers DNS__DB_FLARG); /*%< * Make it so that no rdataset of type 'type' exists at 'node' in version * version 'version' of 'db'. @@ -1436,8 +1487,10 @@ dns_db_unregister(dns_dbimplementation_t **dbimp); * \li Any memory allocated in *dbimp will be freed. */ +#define dns_db_getoriginnode(db, nodep) \ + dns__db_getoriginnode(db, nodep DNS__DB_FILELINE) isc_result_t -dns_db_getoriginnode(dns_db_t *db, dns_dbnode_t **nodep); +dns__db_getoriginnode(dns_db_t *db, dns_dbnode_t **nodep DNS__DB_FLARG); /*%< * Get the origin DB node corresponding to the DB's zone. This function * should typically succeed unless the underlying DB implementation doesn't @@ -1495,9 +1548,11 @@ dns_db_getsize(dns_db_t *db, dns_dbversion_t *version, uint64_t *records, * \li #ISC_R_NOTIMPLEMENTED */ +#define dns_db_findnsec3node(db, name, create, nodep) \ + dns__db_findnsec3node(db, name, create, nodep DNS__DB_FILELINE) isc_result_t -dns_db_findnsec3node(dns_db_t *db, const dns_name_t *name, bool create, - dns_dbnode_t **nodep); +dns__db_findnsec3node(dns_db_t *db, const dns_name_t *name, bool create, + dns_dbnode_t **nodep DNS__DB_FLARG); /*%< * Find the NSEC3 node with name 'name'. * @@ -1545,8 +1600,11 @@ dns_db_setsigningtime(dns_db_t *db, dns_rdataset_t *rdataset, * \li #ISC_R_NOTIMPLEMENTED - Not supported by this DB implementation. */ +#define dns_db_getsigningtime(db, rdataset, name) \ + dns__db_getsigningtime(db, rdataset, name DNS__DB_FILELINE) isc_result_t -dns_db_getsigningtime(dns_db_t *db, dns_rdataset_t *rdataset, dns_name_t *name); +dns__db_getsigningtime(dns_db_t *db, dns_rdataset_t *rdataset, + dns_name_t *name DNS__DB_FLARG); /*%< * Return the rdataset with the earliest signing time in the zone. * Note: the rdataset is version agnostic. @@ -1561,9 +1619,11 @@ dns_db_getsigningtime(dns_db_t *db, dns_rdataset_t *rdataset, dns_name_t *name); * \li #ISC_R_NOTFOUND - No dataset exists. */ +#define dns_db_resigned(db, rdataset, version) \ + dns__db_resigned(db, rdataset, version DNS__DB_FILELINE) void -dns_db_resigned(dns_db_t *db, dns_rdataset_t *rdataset, - dns_dbversion_t *version); +dns__db_resigned(dns_db_t *db, dns_rdataset_t *rdataset, + dns_dbversion_t *version DNS__DB_FLARG); /*%< * Mark 'rdataset' as not being available to be returned by * dns_db_getsigningtime(). If the changes associated with 'version' diff --git a/lib/dns/include/dns/dbiterator.h b/lib/dns/include/dns/dbiterator.h index 8d6147d2d9c..e03636a7e70 100644 --- a/lib/dns/include/dns/dbiterator.h +++ b/lib/dns/include/dns/dbiterator.h @@ -68,15 +68,16 @@ ISC_LANG_BEGINDECLS *****/ typedef struct dns_dbiteratormethods { - void (*destroy)(dns_dbiterator_t **iteratorp); - isc_result_t (*first)(dns_dbiterator_t *iterator); - isc_result_t (*last)(dns_dbiterator_t *iterator); - isc_result_t (*seek)(dns_dbiterator_t *iterator, - const dns_name_t *name); - isc_result_t (*prev)(dns_dbiterator_t *iterator); - isc_result_t (*next)(dns_dbiterator_t *iterator); + void (*destroy)(dns_dbiterator_t **iteratorp DNS__DB_FLARG); + isc_result_t (*first)(dns_dbiterator_t *iterator DNS__DB_FLARG); + isc_result_t (*last)(dns_dbiterator_t *iterator DNS__DB_FLARG); + isc_result_t (*seek)(dns_dbiterator_t *iterator, + const dns_name_t *name DNS__DB_FLARG); + isc_result_t (*prev)(dns_dbiterator_t *iterator DNS__DB_FLARG); + isc_result_t (*next)(dns_dbiterator_t *iterator DNS__DB_FLARG); isc_result_t (*current)(dns_dbiterator_t *iterator, - dns_dbnode_t **nodep, dns_name_t *name); + dns_dbnode_t **nodep, + dns_name_t *name DNS__DB_FLARG); isc_result_t (*pause)(dns_dbiterator_t *iterator); isc_result_t (*origin)(dns_dbiterator_t *iterator, dns_name_t *name); } dns_dbiteratormethods_t; @@ -101,8 +102,10 @@ struct dns_dbiterator { bool relative_names; }; +#define dns_dbiterator_destroy(iteratorp) \ + dns__dbiterator_destroy(iteratorp DNS__DB_FILELINE) void -dns_dbiterator_destroy(dns_dbiterator_t **iteratorp); +dns__dbiterator_destroy(dns_dbiterator_t **iteratorp DNS__DB_FLARG); /*%< * Destroy '*iteratorp'. * @@ -117,8 +120,10 @@ dns_dbiterator_destroy(dns_dbiterator_t **iteratorp); *\li *iteratorp == NULL. */ +#define dns_dbiterator_first(iterator) \ + dns__dbiterator_first(iterator DNS__DB_FILELINE) isc_result_t -dns_dbiterator_first(dns_dbiterator_t *iterator); +dns__dbiterator_first(dns_dbiterator_t *iterator DNS__DB_FLARG); /*%< * Move the node cursor to the first node in the database (if any). * @@ -132,8 +137,10 @@ dns_dbiterator_first(dns_dbiterator_t *iterator); *\li Other results are possible, depending on the DB implementation. */ +#define dns_dbiterator_last(iterator) \ + dns__dbiterator_last(iterator DNS__DB_FILELINE) isc_result_t -dns_dbiterator_last(dns_dbiterator_t *iterator); +dns__dbiterator_last(dns_dbiterator_t *iterator DNS__DB_FLARG); /*%< * Move the node cursor to the last node in the database (if any). * @@ -147,8 +154,11 @@ dns_dbiterator_last(dns_dbiterator_t *iterator); *\li Other results are possible, depending on the DB implementation. */ +#define dns_dbiterator_seek(iterator, name) \ + dns__dbiterator_seek(iterator, name DNS__DB_FILELINE) isc_result_t -dns_dbiterator_seek(dns_dbiterator_t *iterator, const dns_name_t *name); +dns__dbiterator_seek(dns_dbiterator_t *iterator, + const dns_name_t *name DNS__DB_FLARG); /*%< * Move the node cursor to the node with name 'name'. * @@ -166,8 +176,10 @@ dns_dbiterator_seek(dns_dbiterator_t *iterator, const dns_name_t *name); *\li Other results are possible, depending on the DB implementation. */ +#define dns_dbiterator_prev(iterator) \ + dns__dbiterator_prev(iterator DNS__DB_FILELINE) isc_result_t -dns_dbiterator_prev(dns_dbiterator_t *iterator); +dns__dbiterator_prev(dns_dbiterator_t *iterator DNS__DB_FLARG); /*%< * Move the node cursor to the previous node in the database (if any). * @@ -182,8 +194,10 @@ dns_dbiterator_prev(dns_dbiterator_t *iterator); *\li Other results are possible, depending on the DB implementation. */ +#define dns_dbiterator_next(iterator) \ + dns__dbiterator_next(iterator DNS__DB_FILELINE) isc_result_t -dns_dbiterator_next(dns_dbiterator_t *iterator); +dns__dbiterator_next(dns_dbiterator_t *iterator DNS__DB_FLARG); /*%< * Move the node cursor to the next node in the database (if any). * @@ -198,9 +212,11 @@ dns_dbiterator_next(dns_dbiterator_t *iterator); *\li Other results are possible, depending on the DB implementation. */ +#define dns_dbiterator_current(iterator, nodep, name) \ + dns__dbiterator_current(iterator, nodep, name DNS__DB_FILELINE) isc_result_t -dns_dbiterator_current(dns_dbiterator_t *iterator, dns_dbnode_t **nodep, - dns_name_t *name); +dns__dbiterator_current(dns_dbiterator_t *iterator, dns_dbnode_t **nodep, + dns_name_t *name DNS__DB_FLARG); /*%< * Return the current node. * diff --git a/lib/dns/include/dns/rbt.h b/lib/dns/include/dns/rbt.h index bf5b23eb67c..dcc458b5b2c 100644 --- a/lib/dns/include/dns/rbt.h +++ b/lib/dns/include/dns/rbt.h @@ -147,9 +147,9 @@ struct dns_rbtnode { /*@}*/ }; -typedef isc_result_t (*dns_rbtfindcallback_t)(dns_rbtnode_t *node, - dns_name_t *name, - void *callback_arg); +typedef isc_result_t (*dns_rbtfindcallback_t)(dns_rbtnode_t *node, + dns_name_t *name, + void *callback_arg DNS__DB_FLARG); typedef isc_result_t (*dns_rbtdatawriter_t)(FILE *file, unsigned char *data, void *arg, uint64_t *crc); @@ -360,9 +360,11 @@ dns_rbt_addnode(dns_rbt_t *rbt, const dns_name_t *name, dns_rbtnode_t **nodep); *\li #ISC_R_NOMEMORY Resource Limit: Out of Memory */ +#define dns_rbt_findname(rbt, name, options, foundname, data) \ + dns__rbt_findname(rbt, name, options, foundname, data DNS__DB_FILELINE) isc_result_t -dns_rbt_findname(dns_rbt_t *rbt, const dns_name_t *name, unsigned int options, - dns_name_t *foundname, void **data); +dns__rbt_findname(dns_rbt_t *rbt, const dns_name_t *name, unsigned int options, + dns_name_t *foundname, void **data DNS__DB_FLARG); /*%< * Get the data pointer associated with 'name'. * @@ -399,11 +401,16 @@ dns_rbt_findname(dns_rbt_t *rbt, const dns_name_t *name, unsigned int options, *\li #ISC_R_NOSPACE Concatenating nodes to form foundname failed */ +#define dns_rbt_findnode(rbt, name, foundname, node, chain, options, callback, \ + callback_arg) \ + dns__rbt_findnode(rbt, name, foundname, node, chain, options, \ + callback, callback_arg DNS__DB_FILELINE) + isc_result_t -dns_rbt_findnode(dns_rbt_t *rbt, const dns_name_t *name, dns_name_t *foundname, - dns_rbtnode_t **node, dns_rbtnodechain_t *chain, - unsigned int options, dns_rbtfindcallback_t callback, - void *callback_arg); +dns__rbt_findnode(dns_rbt_t *rbt, const dns_name_t *name, dns_name_t *foundname, + dns_rbtnode_t **node, dns_rbtnodechain_t *chain, + unsigned int options, dns_rbtfindcallback_t callback, + void *callback_arg DNS__DB_FLARG); /*%< * Find the node for 'name'. * @@ -504,8 +511,11 @@ dns_rbt_findnode(dns_rbt_t *rbt, const dns_name_t *name, dns_name_t *foundname, *\li #ISC_R_NOSPACE Concatenating nodes to form foundname failed */ +#define dns_rbt_deletename(rbt, name, recurse) \ + dns__rbt_deletename(rbt, name, recurse DNS__DB_FILELINE) isc_result_t -dns_rbt_deletename(dns_rbt_t *rbt, const dns_name_t *name, bool recurse); +dns__rbt_deletename(dns_rbt_t *rbt, const dns_name_t *name, + bool recurse DNS__DB_FLARG); /*%< * Delete 'name' from the tree of trees. * diff --git a/lib/dns/include/dns/rdatalist.h b/lib/dns/include/dns/rdatalist.h index 602c0696be3..6e564b635ee 100644 --- a/lib/dns/include/dns/rdatalist.h +++ b/lib/dns/include/dns/rdatalist.h @@ -112,7 +112,7 @@ dns_rdatalist_fromrdataset(dns_rdataset_t *rdataset, */ void -dns_rdatalist_disassociate(dns_rdataset_t *rdatasetp); +dns_rdatalist_disassociate(dns_rdataset_t *rdatasetp DNS__DB_FLARG); isc_result_t dns_rdatalist_first(dns_rdataset_t *rdataset); @@ -124,7 +124,8 @@ void dns_rdatalist_current(dns_rdataset_t *rdataset, dns_rdata_t *rdata); void -dns_rdatalist_clone(dns_rdataset_t *source, dns_rdataset_t *target); +dns_rdatalist_clone(dns_rdataset_t *source, + dns_rdataset_t *target DNS__DB_FLARG); unsigned int dns_rdatalist_count(dns_rdataset_t *rdataset); @@ -134,14 +135,16 @@ dns_rdatalist_addnoqname(dns_rdataset_t *rdataset, const dns_name_t *name); isc_result_t dns_rdatalist_getnoqname(dns_rdataset_t *rdataset, dns_name_t *name, - dns_rdataset_t *neg, dns_rdataset_t *negsig); + dns_rdataset_t *neg, + dns_rdataset_t *negsig DNS__DB_FLARG); isc_result_t dns_rdatalist_addclosest(dns_rdataset_t *rdataset, const dns_name_t *name); isc_result_t dns_rdatalist_getclosest(dns_rdataset_t *rdataset, dns_name_t *name, - dns_rdataset_t *neg, dns_rdataset_t *negsig); + dns_rdataset_t *neg, + dns_rdataset_t *negsig DNS__DB_FLARG); void dns_rdatalist_setownercase(dns_rdataset_t *rdataset, const dns_name_t *name); diff --git a/lib/dns/include/dns/rdataset.h b/lib/dns/include/dns/rdataset.h index 566ea44cf93..c1994d3cf83 100644 --- a/lib/dns/include/dns/rdataset.h +++ b/lib/dns/include/dns/rdataset.h @@ -63,22 +63,25 @@ typedef enum { } dns_rdatasetadditional_t; typedef struct dns_rdatasetmethods { - void (*disassociate)(dns_rdataset_t *rdataset); + void (*disassociate)(dns_rdataset_t *rdataset DNS__DB_FLARG); isc_result_t (*first)(dns_rdataset_t *rdataset); isc_result_t (*next)(dns_rdataset_t *rdataset); void (*current)(dns_rdataset_t *rdataset, dns_rdata_t *rdata); - void (*clone)(dns_rdataset_t *source, dns_rdataset_t *target); + void (*clone)(dns_rdataset_t *source, + dns_rdataset_t *target DNS__DB_FLARG); unsigned int (*count)(dns_rdataset_t *rdataset); isc_result_t (*addnoqname)(dns_rdataset_t *rdataset, const dns_name_t *name); isc_result_t (*getnoqname)(dns_rdataset_t *rdataset, dns_name_t *name, - dns_rdataset_t *neg, dns_rdataset_t *negsig); + dns_rdataset_t *neg, + dns_rdataset_t *negsig DNS__DB_FLARG); isc_result_t (*addclosest)(dns_rdataset_t *rdataset, const dns_name_t *name); isc_result_t (*getclosest)(dns_rdataset_t *rdataset, dns_name_t *name, - dns_rdataset_t *neg, dns_rdataset_t *negsig); + dns_rdataset_t *neg, + dns_rdataset_t *negsig DNS__DB_FLARG); void (*settrust)(dns_rdataset_t *rdataset, dns_trust_t trust); - void (*expire)(dns_rdataset_t *rdataset); + void (*expire)(dns_rdataset_t *rdataset DNS__DB_FLARG); void (*clearprefetch)(dns_rdataset_t *rdataset); void (*setownercase)(dns_rdataset_t *rdataset, const dns_name_t *name); void (*getownercase)(const dns_rdataset_t *rdataset, dns_name_t *name); @@ -233,8 +236,10 @@ dns_rdataset_invalidate(dns_rdataset_t *rdataset); * without initializing it will cause an assertion failure. */ +#define dns_rdataset_disassociate(rdataset) \ + dns__rdataset_disassociate(rdataset DNS__DB_FILELINE) void -dns_rdataset_disassociate(dns_rdataset_t *rdataset); +dns__rdataset_disassociate(dns_rdataset_t *rdataset DNS__DB_FLARG); /*%< * Disassociate 'rdataset' from its rdata, allowing it to be reused. * @@ -279,8 +284,11 @@ dns_rdataset_makequestion(dns_rdataset_t *rdataset, dns_rdataclass_t rdclass, *\li 'rdataset' is a valid, associated, question rdataset. */ +#define dns_rdataset_clone(source, target) \ + dns__rdataset_clone(source, target DNS__DB_FILELINE) void -dns_rdataset_clone(dns_rdataset_t *source, dns_rdataset_t *target); +dns__rdataset_clone(dns_rdataset_t *source, + dns_rdataset_t *target DNS__DB_FLARG); /*%< * Make 'target' refer to the same rdataset as 'source'. * @@ -480,9 +488,12 @@ dns_rdataset_additionaldata(dns_rdataset_t *rdataset, *\li Any error that dns_rdata_additionaldata() can return. */ +#define dns_rdataset_getnoqname(rdataset, name, neg, negsig) \ + dns__rdataset_getnoqname(rdataset, name, neg, negsig DNS__DB_FILELINE) isc_result_t -dns_rdataset_getnoqname(dns_rdataset_t *rdataset, dns_name_t *name, - dns_rdataset_t *neg, dns_rdataset_t *negsig); +dns__rdataset_getnoqname(dns_rdataset_t *rdataset, dns_name_t *name, + dns_rdataset_t *neg, + dns_rdataset_t *negsig DNS__DB_FLARG); /*%< * Return the noqname proof for this record. * @@ -506,9 +517,12 @@ dns_rdataset_addnoqname(dns_rdataset_t *rdataset, dns_name_t *name); * rdatasets. */ +#define dns_rdataset_getclosest(rdataset, name, nsec, nsecsig) \ + dns__rdataset_getclosest(rdataset, name, nsec, nsecsig DNS__DB_FILELINE) isc_result_t -dns_rdataset_getclosest(dns_rdataset_t *rdataset, dns_name_t *name, - dns_rdataset_t *nsec, dns_rdataset_t *nsecsig); +dns__rdataset_getclosest(dns_rdataset_t *rdataset, dns_name_t *name, + dns_rdataset_t *nsec, + dns_rdataset_t *nsecsig DNS__DB_FLARG); /*%< * Return the closest encloser for this record. * @@ -538,8 +552,10 @@ dns_rdataset_settrust(dns_rdataset_t *rdataset, dns_trust_t trust); * The local trust level of 'rdataset' is also set. */ +#define dns_rdataset_expire(rdataset) \ + dns__rdataset_expire(rdataset DNS__DB_FILELINE) void -dns_rdataset_expire(dns_rdataset_t *rdataset); +dns__rdataset_expire(dns_rdataset_t *rdataset DNS__DB_FLARG); /*%< * Mark the rdataset to be expired in the backing database. */ diff --git a/lib/dns/include/dns/rdatasetiter.h b/lib/dns/include/dns/rdatasetiter.h index 8611d9900c2..4689d333c3c 100644 --- a/lib/dns/include/dns/rdatasetiter.h +++ b/lib/dns/include/dns/rdatasetiter.h @@ -67,10 +67,11 @@ ISC_LANG_BEGINDECLS *****/ typedef struct dns_rdatasetitermethods { - void (*destroy)(dns_rdatasetiter_t **iteratorp); - isc_result_t (*first)(dns_rdatasetiter_t *iterator); - isc_result_t (*next)(dns_rdatasetiter_t *iterator); - void (*current)(dns_rdatasetiter_t *iterator, dns_rdataset_t *rdataset); + void (*destroy)(dns_rdatasetiter_t **iteratorp DNS__DB_FLARG); + isc_result_t (*first)(dns_rdatasetiter_t *iterator DNS__DB_FLARG); + isc_result_t (*next)(dns_rdatasetiter_t *iterator DNS__DB_FLARG); + void (*current)(dns_rdatasetiter_t *iterator, + dns_rdataset_t *rdataset DNS__DB_FLARG); } dns_rdatasetitermethods_t; #define DNS_RDATASETITER_MAGIC ISC_MAGIC('D', 'N', 'S', 'i') @@ -96,8 +97,10 @@ struct dns_rdatasetiter { unsigned int options; }; +#define dns_rdatasetiter_destroy(iteratorp) \ + dns__rdatasetiter_destroy(iteratorp DNS__DB_FILELINE) void -dns_rdatasetiter_destroy(dns_rdatasetiter_t **iteratorp); +dns__rdatasetiter_destroy(dns_rdatasetiter_t **iteratorp DNS__DB_FLARG); /*%< * Destroy '*iteratorp'. * @@ -112,8 +115,10 @@ dns_rdatasetiter_destroy(dns_rdatasetiter_t **iteratorp); *\li *iteratorp == NULL. */ +#define dns_rdatasetiter_first(iterator) \ + dns__rdatasetiter_first(iterator DNS__DB_FILELINE) isc_result_t -dns_rdatasetiter_first(dns_rdatasetiter_t *iterator); +dns__rdatasetiter_first(dns_rdatasetiter_t *iterator DNS__DB_FLARG); /*%< * Move the rdataset cursor to the first rdataset at the node (if any). * @@ -127,8 +132,10 @@ dns_rdatasetiter_first(dns_rdatasetiter_t *iterator); *\li Other results are possible, depending on the DB implementation. */ +#define dns_rdatasetiter_next(iterator) \ + dns__rdatasetiter_next(iterator DNS__DB_FILELINE) isc_result_t -dns_rdatasetiter_next(dns_rdatasetiter_t *iterator); +dns__rdatasetiter_next(dns_rdatasetiter_t *iterator DNS__DB_FLARG); /*%< * Move the rdataset cursor to the next rdataset at the node (if any). * @@ -143,9 +150,11 @@ dns_rdatasetiter_next(dns_rdatasetiter_t *iterator); *\li Other results are possible, depending on the DB implementation. */ +#define dns_rdatasetiter_current(iterator, rdataset) \ + dns__rdatasetiter_current(iterator, rdataset DNS__DB_FILELINE) void -dns_rdatasetiter_current(dns_rdatasetiter_t *iterator, - dns_rdataset_t *rdataset); +dns__rdatasetiter_current(dns_rdatasetiter_t *iterator, + dns_rdataset_t *rdataset DNS__DB_FLARG); /*%< * Return the current rdataset. * diff --git a/lib/dns/include/dns/trace.h b/lib/dns/include/dns/trace.h new file mode 100644 index 00000000000..f1a0b680c6a --- /dev/null +++ b/lib/dns/include/dns/trace.h @@ -0,0 +1,33 @@ +/* + * Copyright (C) Internet Systems Consortium, Inc. ("ISC") + * + * SPDX-License-Identifier: MPL-2.0 + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, you can obtain one at https://mozilla.org/MPL/2.0/. + * + * See the COPYRIGHT file distributed with this work for additional + * information regarding copyright ownership. + */ + +#pragma once + +#undef DNS_DB_NODETRACE + +#if DNS_DB_NODETRACE + +#define DNS__DB_FILELINE , __func__, __FILE__, __LINE__ +#define DNS__DB_FLARG_PASS , func, file, line +#define DNS__DB_FLARG \ + , const char *func __attribute__((__unused__)), \ + const char *file __attribute__((__unused__)), \ + unsigned int line __attribute__((__unused__)) + +#else /* DNS_DB_NODETRACE */ + +#define DNS__DB_FILELINE +#define DNS__DB_FLARG +#define DNS__DB_FLARG_PASS + +#endif /* DNS_DB_NODETRACE */ diff --git a/lib/dns/include/dns/types.h b/lib/dns/include/dns/types.h index ce3e52bb732..13c65c69202 100644 --- a/lib/dns/include/dns/types.h +++ b/lib/dns/include/dns/types.h @@ -28,6 +28,8 @@ #include +#include + typedef struct dns_acl dns_acl_t; typedef struct dns_aclelement dns_aclelement_t; typedef struct dns_aclenv dns_aclenv_t; @@ -401,12 +403,13 @@ typedef void (*dns_loaddonefunc_t)(void *, isc_result_t); typedef void (*dns_rawdatafunc_t)(dns_zone_t *, dns_masterrawheader_t *); -typedef isc_result_t (*dns_addrdatasetfunc_t)(void *, const dns_name_t *, - dns_rdataset_t *); +typedef isc_result_t (*dns_addrdatasetfunc_t)(void *arg, const dns_name_t *name, + dns_rdataset_t *rdataset + DNS__DB_FLARG); -typedef isc_result_t (*dns_additionaldatafunc_t)(void *, const dns_name_t *, - dns_rdatatype_t, - dns_rdataset_t *); +typedef isc_result_t (*dns_additionaldatafunc_t)( + void *arg, const dns_name_t *name, dns_rdatatype_t type, + dns_rdataset_t *rdataset DNS__DB_FLARG); typedef isc_result_t (*dns_digestfunc_t)(void *, isc_region_t *); diff --git a/lib/dns/keytable.c b/lib/dns/keytable.c index 40748a59f0d..589ce1190fb 100644 --- a/lib/dns/keytable.c +++ b/lib/dns/keytable.c @@ -63,7 +63,7 @@ new_keynode(dns_rdata_ds_t *ds, dns_keytable_t *keytable, bool managed, bool initial); static void -keynode_disassociate(dns_rdataset_t *rdataset); +keynode_disassociate(dns_rdataset_t *rdataset DNS__DB_FLARG); static isc_result_t keynode_first(dns_rdataset_t *rdataset); static isc_result_t @@ -71,7 +71,7 @@ keynode_next(dns_rdataset_t *rdataset); static void keynode_current(dns_rdataset_t *rdataset, dns_rdata_t *rdata); static void -keynode_clone(dns_rdataset_t *source, dns_rdataset_t *target); +keynode_clone(dns_rdataset_t *source, dns_rdataset_t *target DNS__DB_FLARG); static dns_rdatasetmethods_t methods = { .disassociate = keynode_disassociate, @@ -805,7 +805,8 @@ dns_keynode_dsset(dns_keynode_t *keynode, dns_rdataset_t *rdataset) { RWLOCK(&keynode->rwlock, isc_rwlocktype_read); if (keynode->dslist != NULL) { if (rdataset != NULL) { - keynode_clone(&keynode->dsset, rdataset); + keynode_clone(&keynode->dsset, + rdataset DNS__DB_FILELINE); } result = true; } else { @@ -851,7 +852,7 @@ dns_keynode_trust(dns_keynode_t *keynode) { } static void -keynode_disassociate(dns_rdataset_t *rdataset) { +keynode_disassociate(dns_rdataset_t *rdataset DNS__DB_FLARG) { dns_keynode_t *keynode; REQUIRE(rdataset != NULL); @@ -922,7 +923,7 @@ keynode_current(dns_rdataset_t *rdataset, dns_rdata_t *rdata) { } static void -keynode_clone(dns_rdataset_t *source, dns_rdataset_t *target) { +keynode_clone(dns_rdataset_t *source, dns_rdataset_t *target DNS__DB_FLARG) { dns_keynode_t *keynode; REQUIRE(source != NULL); diff --git a/lib/dns/master.c b/lib/dns/master.c index 6df8fc298d9..6b7f2b5fc8d 100644 --- a/lib/dns/master.c +++ b/lib/dns/master.c @@ -2919,7 +2919,7 @@ commit(dns_rdatacallbacks_t *callbacks, dns_loadctx_t *lctx, dataset.resign = resign_fromlist(this, lctx); } result = ((*callbacks->add)(callbacks->add_private, owner, - &dataset)); + &dataset DNS__DB_FILELINE)); if (result == ISC_R_NOMEMORY) { (*error)(callbacks, "dns_master_load: %s", isc_result_totext(result)); diff --git a/lib/dns/ncache.c b/lib/dns/ncache.c index 52740a75d0f..162309b2259 100644 --- a/lib/dns/ncache.c +++ b/lib/dns/ncache.c @@ -30,15 +30,15 @@ #define DNS_NCACHE_RDATA 100U /* - * The format of an ncache rdata is a sequence of zero or more records of - * the following format: + * The format of an ncache rdata is a sequence of zero or more records + * of the following format: * * owner name * type * trust * rdata count - * rdata length These two occur 'rdata count' - * rdata times. + * rdata length These two occur 'rdata + * rdata count' times. * */ @@ -417,7 +417,7 @@ rollback: } static void -rdataset_disassociate(dns_rdataset_t *rdataset) { +rdataset_disassociate(dns_rdataset_t *rdataset DNS__DB_FLARG) { UNUSED(rdataset); } @@ -478,7 +478,7 @@ rdataset_current(dns_rdataset_t *rdataset, dns_rdata_t *rdata) { } static void -rdataset_clone(dns_rdataset_t *source, dns_rdataset_t *target) { +rdataset_clone(dns_rdataset_t *source, dns_rdataset_t *target DNS__DB_FLARG) { *target = *source; /* diff --git a/lib/dns/rbt.c b/lib/dns/rbt.c index b875229e059..a8f40dadb33 100644 --- a/lib/dns/rbt.c +++ b/lib/dns/rbt.c @@ -741,10 +741,10 @@ dns_rbt_addname(dns_rbt_t *rbt, const dns_name_t *name, void *data) { * Find the node for "name" in the tree of trees. */ isc_result_t -dns_rbt_findnode(dns_rbt_t *rbt, const dns_name_t *name, dns_name_t *foundname, - dns_rbtnode_t **node, dns_rbtnodechain_t *chain, - unsigned int options, dns_rbtfindcallback_t callback, - void *callback_arg) { +dns__rbt_findnode(dns_rbt_t *rbt, const dns_name_t *name, dns_name_t *foundname, + dns_rbtnode_t **node, dns_rbtnodechain_t *chain, + unsigned int options, dns_rbtfindcallback_t callback, + void *callback_arg DNS__DB_FLARG) { dns_rbtnode_t *current, *last_compared; dns_rbtnodechain_t localchain; dns_name_t *search_name, current_name, *callback_name; @@ -1004,9 +1004,11 @@ dns_rbt_findnode(dns_rbt_t *rbt, const dns_name_t *name, dns_name_t *foundname, return (result); } - result = (callback)(current, - callback_name, - callback_arg); + result = + (callback)(current, + callback_name, + callback_arg + DNS__DB_FLARG_PASS); if (result != DNS_R_CONTINUE) { saved_result = result; /* @@ -1270,15 +1272,15 @@ dns_rbt_findnode(dns_rbt_t *rbt, const dns_name_t *name, dns_name_t *foundname, * Get the data pointer associated with 'name'. */ isc_result_t -dns_rbt_findname(dns_rbt_t *rbt, const dns_name_t *name, unsigned int options, - dns_name_t *foundname, void **data) { +dns__rbt_findname(dns_rbt_t *rbt, const dns_name_t *name, unsigned int options, + dns_name_t *foundname, void **data DNS__DB_FLARG) { dns_rbtnode_t *node = NULL; isc_result_t result; REQUIRE(data != NULL && *data == NULL); - result = dns_rbt_findnode(rbt, name, foundname, &node, NULL, options, - NULL, NULL); + result = dns__rbt_findnode(rbt, name, foundname, &node, NULL, options, + NULL, NULL DNS__DB_FLARG_PASS); if (node != NULL && WANTEMPTYDATA_OR_DATA(options, node)) { *data = node->data; @@ -1293,7 +1295,8 @@ dns_rbt_findname(dns_rbt_t *rbt, const dns_name_t *name, unsigned int options, * Delete a name from the tree of trees. */ isc_result_t -dns_rbt_deletename(dns_rbt_t *rbt, const dns_name_t *name, bool recurse) { +dns__rbt_deletename(dns_rbt_t *rbt, const dns_name_t *name, + bool recurse DNS__DB_FLARG) { dns_rbtnode_t *node = NULL; isc_result_t result; @@ -1314,8 +1317,9 @@ dns_rbt_deletename(dns_rbt_t *rbt, const dns_name_t *name, bool recurse) { * ->dirty, ->locknum and ->references are ignored; they are * solely the province of rbtdb.c. */ - result = dns_rbt_findnode(rbt, name, NULL, &node, NULL, - DNS_RBTFIND_NOOPTIONS, NULL, NULL); + result = dns__rbt_findnode(rbt, name, NULL, &node, NULL, + DNS_RBTFIND_NOOPTIONS, NULL, + NULL DNS__DB_FLARG_PASS); if (result == ISC_R_SUCCESS) { if (node->data != NULL) { diff --git a/lib/dns/rbtdb.c b/lib/dns/rbtdb.c index 48267693b60..8ed1bff3a8c 100644 --- a/lib/dns/rbtdb.c +++ b/lib/dns/rbtdb.c @@ -599,7 +599,7 @@ typedef struct { static void delete_callback(void *data, void *arg); static void -rdataset_disassociate(dns_rdataset_t *rdataset); +rdataset_disassociate(dns_rdataset_t *rdataset DNS__DB_FLARG); static isc_result_t rdataset_first(dns_rdataset_t *rdataset); static isc_result_t @@ -607,15 +607,15 @@ rdataset_next(dns_rdataset_t *rdataset); static void rdataset_current(dns_rdataset_t *rdataset, dns_rdata_t *rdata); static void -rdataset_clone(dns_rdataset_t *source, dns_rdataset_t *target); +rdataset_clone(dns_rdataset_t *source, dns_rdataset_t *target DNS__DB_FLARG); static unsigned int rdataset_count(dns_rdataset_t *rdataset); static isc_result_t rdataset_getnoqname(dns_rdataset_t *rdataset, dns_name_t *name, - dns_rdataset_t *neg, dns_rdataset_t *negsig); + dns_rdataset_t *neg, dns_rdataset_t *negsig DNS__DB_FLARG); static isc_result_t rdataset_getclosest(dns_rdataset_t *rdataset, dns_name_t *name, - dns_rdataset_t *neg, dns_rdataset_t *negsig); + dns_rdataset_t *neg, dns_rdataset_t *negsig DNS__DB_FLARG); static bool need_headerupdate(rdatasetheader_t *header, isc_stdtime_t now); static void @@ -623,21 +623,21 @@ update_header(dns_rbtdb_t *rbtdb, rdatasetheader_t *header, isc_stdtime_t now); static void expire_header(dns_rbtdb_t *rbtdb, rdatasetheader_t *header, isc_rwlocktype_t *nlocktypep, isc_rwlocktype_t *tlocktypep, - expire_t reason); + expire_t reason DNS__DB_FLARG); static void overmem_purge(dns_rbtdb_t *rbtdb, unsigned int locknum_start, isc_stdtime_t now, - isc_rwlocktype_t *tlocktypep); + isc_rwlocktype_t *tlocktypep DNS__DB_FLARG); static void resign_insert(dns_rbtdb_t *rbtdb, int idx, rdatasetheader_t *newheader); static void resign_delete(dns_rbtdb_t *rbtdb, rbtdb_version_t *version, - rdatasetheader_t *header); + rdatasetheader_t *header DNS__DB_FLARG); static void prune_tree(void *arg); static void rdataset_settrust(dns_rdataset_t *rdataset, dns_trust_t trust); static void -rdataset_expire(dns_rdataset_t *rdataset); +rdataset_expire(dns_rdataset_t *rdataset DNS__DB_FLARG); static void rdataset_clearprefetch(dns_rdataset_t *rdataset); static void @@ -679,13 +679,14 @@ static dns_rdatasetmethods_t slab_methods = { }; static void -rdatasetiter_destroy(dns_rdatasetiter_t **iteratorp); +rdatasetiter_destroy(dns_rdatasetiter_t **iteratorp DNS__DB_FLARG); static isc_result_t -rdatasetiter_first(dns_rdatasetiter_t *iterator); +rdatasetiter_first(dns_rdatasetiter_t *iterator DNS__DB_FLARG); static isc_result_t -rdatasetiter_next(dns_rdatasetiter_t *iterator); +rdatasetiter_next(dns_rdatasetiter_t *iterator DNS__DB_FLARG); static void -rdatasetiter_current(dns_rdatasetiter_t *iterator, dns_rdataset_t *rdataset); +rdatasetiter_current(dns_rdatasetiter_t *iterator, + dns_rdataset_t *rdataset DNS__DB_FLARG); static dns_rdatasetitermethods_t rdatasetiter_methods = { rdatasetiter_destroy, rdatasetiter_first, rdatasetiter_next, @@ -707,20 +708,21 @@ typedef struct rbtdb_rdatasetiter { * being traversed at given time. */ static void -dbiterator_destroy(dns_dbiterator_t **iteratorp); +dbiterator_destroy(dns_dbiterator_t **iteratorp DNS__DB_FLARG); static isc_result_t -dbiterator_first(dns_dbiterator_t *iterator); +dbiterator_first(dns_dbiterator_t *iterator DNS__DB_FLARG); static isc_result_t -dbiterator_last(dns_dbiterator_t *iterator); +dbiterator_last(dns_dbiterator_t *iterator DNS__DB_FLARG); static isc_result_t -dbiterator_seek(dns_dbiterator_t *iterator, const dns_name_t *name); +dbiterator_seek(dns_dbiterator_t *iterator, + const dns_name_t *name DNS__DB_FLARG); static isc_result_t -dbiterator_prev(dns_dbiterator_t *iterator); +dbiterator_prev(dns_dbiterator_t *iterator DNS__DB_FLARG); static isc_result_t -dbiterator_next(dns_dbiterator_t *iterator); +dbiterator_next(dns_dbiterator_t *iterator DNS__DB_FLARG); static isc_result_t dbiterator_current(dns_dbiterator_t *iterator, dns_dbnode_t **nodep, - dns_name_t *name); + dns_name_t *name DNS__DB_FLARG); static isc_result_t dbiterator_pause(dns_dbiterator_t *iterator); static isc_result_t @@ -1343,7 +1345,8 @@ attachversion(dns_db_t *db, dns_dbversion_t *source, } static rbtdb_changed_t * -add_changed(dns_rbtdb_t *rbtdb, rbtdb_version_t *version, dns_rbtnode_t *node) { +add_changed(dns_rbtdb_t *rbtdb, rbtdb_version_t *version, + dns_rbtnode_t *node DNS__DB_FLARG) { rbtdb_changed_t *changed; /* @@ -1358,7 +1361,14 @@ add_changed(dns_rbtdb_t *rbtdb, rbtdb_version_t *version, dns_rbtnode_t *node) { REQUIRE(version->writer); if (changed != NULL) { - isc_refcount_increment(&node->references); + uint_fast32_t refs = isc_refcount_increment(&node->references); +#if DNS_DB_NODETRACE + fprintf(stderr, + "incr:node:%s:%s:%u:%p->references = %" PRIuFAST32 "\n", + func, file, line, node, refs + 1); +#else + UNUSED(refs); +#endif changed->node = node; changed->dirty = false; ISC_LIST_INITANDAPPEND(version->changed_list, changed, link); @@ -1825,16 +1835,36 @@ delete_node(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node) { */ static void new_reference(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, - isc_rwlocktype_t locktype) { + isc_rwlocktype_t locktype DNS__DB_FLARG) { + uint_fast32_t refs; + if (locktype == isc_rwlocktype_write && ISC_LINK_LINKED(node, deadlink)) { ISC_LIST_UNLINK(rbtdb->deadnodes[node->locknum], node, deadlink); } - if (isc_refcount_increment0(&node->references) == 0) { + + refs = isc_refcount_increment0(&node->references); +#if DNS_DB_NODETRACE + fprintf(stderr, "incr:node:%s:%s:%u:%p->references = %" PRIuFAST32 "\n", + func, file, line, node, refs + 1); +#else + UNUSED(refs); +#endif + + if (refs == 0) { /* this is the first reference to the node */ - isc_refcount_increment0( + refs = isc_refcount_increment0( &rbtdb->node_locks[node->locknum].references); +#if DNS_DB_NODETRACE + fprintf(stderr, + "incr:nodelock:%s:%s:%u:%p:%p->references = " + "%" PRIuFAST32 "\n", + func, file, line, node, + &rbtdb->node_locks[node->locknum], refs + 1); +#else + UNUSED(refs); +#endif } } @@ -1849,12 +1879,12 @@ is_leaf(dns_rbtnode_t *node) { static void send_to_prune_tree(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, - isc_rwlocktype_t locktype) { + isc_rwlocktype_t locktype DNS__DB_FLARG) { prune_t *prune = isc_mem_get(rbtdb->common.mctx, sizeof(*prune)); *prune = (prune_t){ .node = node }; dns_db_attach((dns_db_t *)rbtdb, &prune->db); - new_reference(rbtdb, node, locktype); + new_reference(rbtdb, node, locktype DNS__DB_FLARG_PASS); isc_async_run(rbtdb->loop, prune_tree, prune); } @@ -1868,7 +1898,7 @@ send_to_prune_tree(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, * The caller must hold a tree write lock and bucketnum'th node (write) lock. */ static void -cleanup_dead_nodes(dns_rbtdb_t *rbtdb, int bucketnum) { +cleanup_dead_nodes(dns_rbtdb_t *rbtdb, int bucketnum DNS__DB_FLARG) { dns_rbtnode_t *node; int count = 10; /* XXXJT: should be adjustable */ @@ -1890,7 +1920,9 @@ cleanup_dead_nodes(dns_rbtdb_t *rbtdb, int bucketnum) { } if (is_leaf(node) && rbtdb->loop != NULL) { - send_to_prune_tree(rbtdb, node, isc_rwlocktype_write); + send_to_prune_tree( + rbtdb, node, + isc_rwlocktype_write DNS__DB_FLARG_PASS); } else if (node->down == NULL && node->data == NULL) { /* * Not a interior node and not needing to be @@ -1922,7 +1954,7 @@ cleanup_dead_nodes(dns_rbtdb_t *rbtdb, int bucketnum) { */ static void reactivate_node(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, - isc_rwlocktype_t tlocktype) { + isc_rwlocktype_t tlocktype DNS__DB_FLARG) { isc_rwlocktype_t nlocktype = isc_rwlocktype_none; nodelock_t *nodelock = &rbtdb->node_locks[node->locknum].lock; bool maybe_cleanup = false; @@ -1952,11 +1984,12 @@ reactivate_node(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, deadlink); } if (maybe_cleanup) { - cleanup_dead_nodes(rbtdb, node->locknum); + cleanup_dead_nodes(rbtdb, + node->locknum DNS__DB_FILELINE); } } - new_reference(rbtdb, node, nlocktype); + new_reference(rbtdb, node, nlocktype DNS__DB_FLARG_PASS); NODE_UNLOCK(nodelock, &nlocktype); } @@ -1979,7 +2012,7 @@ static bool decrement_reference(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, rbtdb_serial_t least_serial, isc_rwlocktype_t *nlocktypep, isc_rwlocktype_t *tlocktypep, bool tryupgrade, - bool pruning) { + bool pruning DNS__DB_FLARG) { isc_result_t result; bool locked = *tlocktypep != isc_rwlocktype_none; bool write_locked = false; @@ -1998,9 +2031,24 @@ decrement_reference(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, /* Handle easy and typical case first. */ if (!node->dirty && KEEP_NODE(node, rbtdb, locked)) { - if (isc_refcount_decrement(&node->references) == 1) { + refs = isc_refcount_decrement(&node->references); +#if DNS_DB_NODETRACE + fprintf(stderr, + "decr:node:%s:%s:%u:%p->references = %" PRIuFAST32 "\n", + func, file, line, node, refs - 1); +#else + UNUSED(refs); +#endif + if (refs == 1) { refs = isc_refcount_decrement(&nodelock->references); - INSIST(refs > 0); +#if DNS_DB_NODETRACE + fprintf(stderr, + "decr:nodelock:%s:%s:%u:%p:%p->references = " + "%" PRIuFAST32 "\n", + func, file, line, node, nodelock, refs - 1); +#else + UNUSED(refs); +#endif return (true); } else { return (false); @@ -2012,7 +2060,14 @@ decrement_reference(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, NODE_FORCEUPGRADE(&nodelock->lock, nlocktypep); } - if (isc_refcount_decrement(&node->references) > 1) { + refs = isc_refcount_decrement(&node->references); +#if DNS_DB_NODETRACE + fprintf(stderr, "decr:node:%s:%s:%u:%p->references = %" PRIuFAST32 "\n", + func, file, line, node, refs - 1); +#else + UNUSED(refs); +#endif + if (refs > 1) { return (false); } @@ -2066,7 +2121,13 @@ decrement_reference(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, } refs = isc_refcount_decrement(&nodelock->references); - INSIST(refs > 0); +#if DNS_DB_NODETRACE + fprintf(stderr, + "decr:nodelock:%s:%s:%u:%p:%p->references = %" PRIuFAST32 "\n", + func, file, line, node, nodelock, refs - 1); +#else + UNUSED(refs); +#endif if (KEEP_NODE(node, rbtdb, (locked || write_locked))) { goto restore_locks; @@ -2096,7 +2157,9 @@ decrement_reference(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, * periodic walk-through). */ if (!pruning && is_leaf(node) && rbtdb->loop != NULL) { - send_to_prune_tree(rbtdb, node, isc_rwlocktype_write); + send_to_prune_tree( + rbtdb, node, + isc_rwlocktype_write DNS__DB_FLARG_PASS); no_reference = false; } else { delete_node(rbtdb, node); @@ -2145,7 +2208,7 @@ prune_tree(void *arg) { do { parent = node->parent; decrement_reference(rbtdb, node, 0, &nlocktype, &tlocktype, - true, true); + true, true DNS__DB_FILELINE); if (parent != NULL && parent->down == NULL) { /* @@ -2170,7 +2233,8 @@ prune_tree(void *arg) { ISC_LIST_UNLINK(rbtdb->deadnodes[locknum], parent, deadlink); } - new_reference(rbtdb, parent, nlocktype); + new_reference(rbtdb, parent, + nlocktype DNS__DB_FILELINE); } else { parent = NULL; } @@ -2381,7 +2445,7 @@ cleanup_dead_nodes_callback(void *arg) { TREE_WRLOCK(&rbtdb->tree_lock, &tlocktype); for (locknum = 0; locknum < rbtdb->node_lock_count; locknum++) { NODE_WRLOCK(&rbtdb->node_locks[locknum].lock, &nlocktype); - cleanup_dead_nodes(rbtdb, locknum); + cleanup_dead_nodes(rbtdb, locknum DNS__DB_FILELINE); if (ISC_LIST_HEAD(rbtdb->deadnodes[locknum]) != NULL) { again = true; } @@ -2398,7 +2462,8 @@ cleanup_dead_nodes_callback(void *arg) { } static void -closeversion(dns_db_t *db, dns_dbversion_t **versionp, bool commit) { +closeversion(dns_db_t *db, dns_dbversion_t **versionp, + bool commit DNS__DB_FLARG) { dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; rbtdb_version_t *version, *cleanup_version, *least_greater; bool rollback = false; @@ -2599,7 +2664,8 @@ closeversion(dns_db_t *db, dns_dbversion_t **versionp, bool commit) { resign_insert(rbtdb, header->node->locknum, header); } decrement_reference(rbtdb, header->node, least_serial, - &nlocktype, &tlocktype, true, false); + &nlocktype, &tlocktype, true, + false DNS__DB_FLARG_PASS); NODE_UNLOCK(lock, &nlocktype); INSIST(tlocktype == isc_rwlocktype_none); } @@ -2636,7 +2702,9 @@ closeversion(dns_db_t *db, dns_dbversion_t **versionp, bool commit) { * so use it. */ if (rbtdb->loop == NULL) { - cleanup_dead_nodes(rbtdb, rbtnode->locknum); + cleanup_dead_nodes( + rbtdb, + rbtnode->locknum DNS__DB_FLARG_PASS); } if (rollback) { @@ -2644,7 +2712,7 @@ closeversion(dns_db_t *db, dns_dbversion_t **versionp, bool commit) { } decrement_reference(rbtdb, rbtnode, least_serial, &nlocktype, &tlocktype, true, - false); + false DNS__DB_FILELINE); NODE_UNLOCK(lock, &nlocktype); @@ -2751,7 +2819,7 @@ add_empty_wildcards(dns_rbtdb_t *rbtdb, const dns_name_t *name, bool lock) { static isc_result_t findnodeintree(dns_rbtdb_t *rbtdb, dns_rbt_t *tree, const dns_name_t *name, - bool create, dns_dbnode_t **nodep) { + bool create, dns_dbnode_t **nodep DNS__DB_FLARG) { dns_rbtnode_t *node = NULL; dns_name_t nodename; isc_result_t result; @@ -2804,7 +2872,7 @@ findnodeintree(dns_rbtdb_t *rbtdb, dns_rbt_t *tree, const dns_name_t *name, INSIST(node->nsec == DNS_RBT_NSEC_NSEC3); } - reactivate_node(rbtdb, node, tlocktype); + reactivate_node(rbtdb, node, tlocktype DNS__DB_FLARG_PASS); *nodep = (dns_dbnode_t *)node; unlock: @@ -2815,26 +2883,29 @@ unlock: static isc_result_t findnode(dns_db_t *db, const dns_name_t *name, bool create, - dns_dbnode_t **nodep) { + dns_dbnode_t **nodep DNS__DB_FLARG) { dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; REQUIRE(VALID_RBTDB(rbtdb)); - return (findnodeintree(rbtdb, rbtdb->tree, name, create, nodep)); + return (findnodeintree(rbtdb, rbtdb->tree, name, create, + nodep DNS__DB_FLARG_PASS)); } static isc_result_t findnsec3node(dns_db_t *db, const dns_name_t *name, bool create, - dns_dbnode_t **nodep) { + dns_dbnode_t **nodep DNS__DB_FLARG) { dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; REQUIRE(VALID_RBTDB(rbtdb)); - return (findnodeintree(rbtdb, rbtdb->nsec3, name, create, nodep)); + return (findnodeintree(rbtdb, rbtdb->nsec3, name, create, + nodep DNS__DB_FLARG_PASS)); } static isc_result_t -zone_zonecut_callback(dns_rbtnode_t *node, dns_name_t *name, void *arg) { +zone_zonecut_callback(dns_rbtnode_t *node, dns_name_t *name, + void *arg DNS__DB_FLARG) { rbtdb_search_t *search = arg; rdatasetheader_t *header, *header_next; rdatasetheader_t *dname_header, *sigdname_header, *ns_header; @@ -2936,7 +3007,8 @@ zone_zonecut_callback(dns_rbtnode_t *node, dns_name_t *name, void *arg) { * We increment the reference count on node to ensure that * search->zonecut_rdataset will still be valid later. */ - new_reference(search->rbtdb, node, isc_rwlocktype_read); + new_reference(search->rbtdb, node, + isc_rwlocktype_read DNS__DB_FLARG_PASS); search->zonecut = node; search->zonecut_rdataset = found; search->need_cleanup = true; @@ -2989,7 +3061,7 @@ zone_zonecut_callback(dns_rbtnode_t *node, dns_name_t *name, void *arg) { static void bind_rdataset(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, rdatasetheader_t *header, isc_stdtime_t now, isc_rwlocktype_t locktype, - dns_rdataset_t *rdataset) { + dns_rdataset_t *rdataset DNS__DB_FLARG) { unsigned char *raw; /* RDATASLAB */ bool stale = STALE(header); bool ancient = ANCIENT(header); @@ -3006,7 +3078,7 @@ bind_rdataset(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, rdatasetheader_t *header, return; } - new_reference(rbtdb, node, locktype); + new_reference(rbtdb, node, locktype DNS__DB_FLARG_PASS); INSIST(rdataset->methods == NULL); /* We must be disassociated. */ @@ -3109,7 +3181,7 @@ bind_rdataset(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, rdatasetheader_t *header, static isc_result_t setup_delegation(rbtdb_search_t *search, dns_dbnode_t **nodep, dns_name_t *foundname, dns_rdataset_t *rdataset, - dns_rdataset_t *sigrdataset) { + dns_rdataset_t *sigrdataset DNS__DB_FLARG) { dns_name_t *zcname; rbtdb_rdatatype_t type; dns_rbtnode_t *node; @@ -3150,12 +3222,14 @@ setup_delegation(rbtdb_search_t *search, dns_dbnode_t **nodep, NODE_RDLOCK(&(search->rbtdb->node_locks[node->locknum].lock), &nlocktype); bind_rdataset(search->rbtdb, node, search->zonecut_rdataset, - search->now, isc_rwlocktype_read, rdataset); + search->now, isc_rwlocktype_read, + rdataset DNS__DB_FLARG_PASS); if (sigrdataset != NULL && search->zonecut_sigrdataset != NULL) { bind_rdataset(search->rbtdb, node, search->zonecut_sigrdataset, search->now, - isc_rwlocktype_read, sigrdataset); + isc_rwlocktype_read, + sigrdataset DNS__DB_FLARG_PASS); } NODE_UNLOCK(&(search->rbtdb->node_locks[node->locknum].lock), &nlocktype); @@ -3725,7 +3799,7 @@ static isc_result_t find_closest_nsec(rbtdb_search_t *search, dns_dbnode_t **nodep, dns_name_t *foundname, dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset, dns_rbt_t *tree, - dns_db_secure_t secure) { + dns_db_secure_t secure DNS__DB_FLARG) { dns_rbtnode_t *node, *prevnode; rdatasetheader_t *header, *header_next, *found, *foundsig; dns_rbtnodechain_t nsecchain; @@ -3839,19 +3913,22 @@ again: if (nodep != NULL) { new_reference( search->rbtdb, node, - isc_rwlocktype_read); + isc_rwlocktype_read + DNS__DB_FLARG_PASS); *nodep = node; } - bind_rdataset(search->rbtdb, node, - found, search->now, - isc_rwlocktype_read, - rdataset); + bind_rdataset( + search->rbtdb, node, found, + search->now, + isc_rwlocktype_read, + rdataset DNS__DB_FLARG_PASS); if (foundsig != NULL) { bind_rdataset( search->rbtdb, node, foundsig, search->now, isc_rwlocktype_read, - sigrdataset); + sigrdataset + DNS__DB_FLARG_PASS); } } } else if (found == NULL && foundsig == NULL) { @@ -3918,7 +3995,7 @@ static isc_result_t zone_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, dns_rdatatype_t type, unsigned int options, isc_stdtime_t now, dns_dbnode_t **nodep, dns_name_t *foundname, dns_rdataset_t *rdataset, - dns_rdataset_t *sigrdataset) { + dns_rdataset_t *sigrdataset DNS__DB_FLARG) { dns_rbtnode_t *node = NULL; isc_result_t result; rbtdb_search_t search; @@ -3989,8 +4066,9 @@ zone_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, if (result == DNS_R_PARTIALMATCH) { partial_match: if (search.zonecut != NULL) { - result = setup_delegation(&search, nodep, foundname, - rdataset, sigrdataset); + result = setup_delegation( + &search, nodep, foundname, rdataset, + sigrdataset DNS__DB_FLARG_PASS); goto tree_exit; } @@ -4030,9 +4108,10 @@ zone_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, (search.options & DNS_DBFIND_FORCENSEC) != 0 || (search.options & DNS_DBFIND_FORCENSEC3) != 0) { - result = find_closest_nsec(&search, nodep, foundname, - rdataset, sigrdataset, tree, - search.rbtversion->secure); + result = find_closest_nsec( + &search, nodep, foundname, rdataset, + sigrdataset, tree, + search.rbtversion->secure DNS__DB_FLARG_PASS); if (result == ISC_R_SUCCESS) { result = active ? DNS_R_EMPTYNAME : DNS_R_NXDOMAIN; @@ -4138,7 +4217,8 @@ found: * ensure that search->zonecut_rdataset will * still be valid later. */ - new_reference(search.rbtdb, node, nlocktype); + new_reference(search.rbtdb, node, + nlocktype DNS__DB_FLARG_PASS); search.zonecut = node; search.zonecut_rdataset = header; search.zonecut_sigrdataset = NULL; @@ -4279,8 +4359,9 @@ found: * Return the delegation. */ NODE_UNLOCK(lock, &nlocktype); - result = setup_delegation(&search, nodep, foundname, - rdataset, sigrdataset); + result = setup_delegation( + &search, nodep, foundname, rdataset, + sigrdataset DNS__DB_FLARG_PASS); goto tree_exit; } /* @@ -4301,10 +4382,10 @@ found: } NODE_UNLOCK(lock, &nlocktype); - result = find_closest_nsec(&search, nodep, foundname, - rdataset, sigrdataset, - search.rbtdb->tree, - search.rbtversion->secure); + result = find_closest_nsec( + &search, nodep, foundname, rdataset, + sigrdataset, search.rbtdb->tree, + search.rbtversion->secure DNS__DB_FLARG_PASS); if (result == ISC_R_SUCCESS) { result = DNS_R_EMPTYWILD; } @@ -4321,7 +4402,8 @@ found: goto node_exit; } if (nodep != NULL) { - new_reference(search.rbtdb, node, nlocktype); + new_reference(search.rbtdb, node, + nlocktype DNS__DB_FLARG_PASS); *nodep = node; } if ((search.rbtversion->secure == dns_db_secure && @@ -4329,10 +4411,11 @@ found: (search.options & DNS_DBFIND_FORCENSEC) != 0) { bind_rdataset(search.rbtdb, node, nsecheader, 0, - nlocktype, rdataset); + nlocktype, rdataset DNS__DB_FLARG_PASS); if (nsecsig != NULL) { bind_rdataset(search.rbtdb, node, nsecsig, 0, - nlocktype, sigrdataset); + nlocktype, + sigrdataset DNS__DB_FLARG_PASS); } } if (wild) { @@ -4392,8 +4475,9 @@ found: !valid_glue(&search, foundname, type, node)) { NODE_UNLOCK(lock, &nlocktype); - result = setup_delegation(&search, nodep, foundname, - rdataset, sigrdataset); + result = setup_delegation( + &search, nodep, foundname, rdataset, + sigrdataset DNS__DB_FLARG_PASS); goto tree_exit; } } else { @@ -4405,7 +4489,8 @@ found: if (nodep != NULL) { if (!at_zonecut) { - new_reference(search.rbtdb, node, nlocktype); + new_reference(search.rbtdb, node, + nlocktype DNS__DB_FLARG_PASS); } else { search.need_cleanup = false; } @@ -4414,10 +4499,11 @@ found: if (type != dns_rdatatype_any) { bind_rdataset(search.rbtdb, node, found, 0, nlocktype, - rdataset); + rdataset DNS__DB_FLARG_PASS); if (foundsig != NULL) { bind_rdataset(search.rbtdb, node, foundsig, 0, - nlocktype, sigrdataset); + nlocktype, + sigrdataset DNS__DB_FLARG_PASS); } } @@ -4442,13 +4528,13 @@ tree_exit: NODE_RDLOCK(lock, &nlocktype); decrement_reference(search.rbtdb, node, 0, &nlocktype, - &tlocktype, true, false); + &tlocktype, true, false DNS__DB_FLARG_PASS); NODE_UNLOCK(lock, &nlocktype); INSIST(tlocktype == isc_rwlocktype_none); } if (close_version) { - closeversion(db, &version, false); + closeversion(db, &version, false DNS__DB_FLARG_PASS); } dns_rbtnodechain_reset(&search.chain); @@ -4566,7 +4652,8 @@ check_stale_header(dns_rbtnode_t *node, rdatasetheader_t *header, } static isc_result_t -cache_zonecut_callback(dns_rbtnode_t *node, dns_name_t *name, void *arg) { +cache_zonecut_callback(dns_rbtnode_t *node, dns_name_t *name, + void *arg DNS__DB_FLARG) { rbtdb_search_t *search = arg; rdatasetheader_t *header, *header_prev, *header_next; rdatasetheader_t *dname_header, *sigdname_header; @@ -4621,7 +4708,8 @@ cache_zonecut_callback(dns_rbtnode_t *node, dns_name_t *name, void *arg) { * We increment the reference count on node to ensure that * search->zonecut_rdataset will still be valid later. */ - new_reference(search->rbtdb, node, nlocktype); + new_reference(search->rbtdb, node, + nlocktype DNS__DB_FLARG_PASS); search->zonecut = node; search->zonecut_rdataset = dname_header; search->zonecut_sigrdataset = sigdname_header; @@ -4639,7 +4727,8 @@ cache_zonecut_callback(dns_rbtnode_t *node, dns_name_t *name, void *arg) { static isc_result_t find_deepest_zonecut(rbtdb_search_t *search, dns_rbtnode_t *node, dns_dbnode_t **nodep, dns_name_t *foundname, - dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset) { + dns_rdataset_t *rdataset, + dns_rdataset_t *sigrdataset DNS__DB_FLARG) { unsigned int i; dns_rbtnode_t *level_node; rdatasetheader_t *header, *header_prev, *header_next; @@ -4730,15 +4819,16 @@ find_deepest_zonecut(rbtdb_search_t *search, dns_rbtnode_t *node, } result = DNS_R_DELEGATION; if (nodep != NULL) { - new_reference(search->rbtdb, node, nlocktype); + new_reference(search->rbtdb, node, + nlocktype DNS__DB_FLARG_PASS); *nodep = node; } bind_rdataset(search->rbtdb, node, found, search->now, - nlocktype, rdataset); + nlocktype, rdataset DNS__DB_FLARG_PASS); if (foundsig != NULL) { bind_rdataset(search->rbtdb, node, foundsig, search->now, nlocktype, - sigrdataset); + sigrdataset DNS__DB_FLARG_PASS); } if (need_headerupdate(found, search->now) || (foundsig != NULL && @@ -4786,7 +4876,7 @@ static isc_result_t find_coveringnsec(rbtdb_search_t *search, const dns_name_t *name, dns_dbnode_t **nodep, isc_stdtime_t now, dns_name_t *foundname, dns_rdataset_t *rdataset, - dns_rdataset_t *sigrdataset) { + dns_rdataset_t *sigrdataset DNS__DB_FLARG) { dns_fixedname_t fprefix, forigin, ftarget, fixed; dns_name_t *prefix = NULL, *origin = NULL; dns_name_t *target = NULL, *fname = NULL; @@ -4875,12 +4965,14 @@ find_coveringnsec(rbtdb_search_t *search, const dns_name_t *name, } if (found != NULL) { bind_rdataset(search->rbtdb, node, found, now, nlocktype, - rdataset); + rdataset DNS__DB_FLARG_PASS); if (foundsig != NULL) { bind_rdataset(search->rbtdb, node, foundsig, now, - nlocktype, sigrdataset); + nlocktype, + sigrdataset DNS__DB_FLARG_PASS); } - new_reference(search->rbtdb, node, nlocktype); + new_reference(search->rbtdb, node, + nlocktype DNS__DB_FLARG_PASS); dns_name_copy(fname, foundname); @@ -4897,7 +4989,8 @@ static isc_result_t cache_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, dns_rdatatype_t type, unsigned int options, isc_stdtime_t now, dns_dbnode_t **nodep, dns_name_t *foundname, - dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset) { + dns_rdataset_t *rdataset, + dns_rdataset_t *sigrdataset DNS__DB_FLARG) { dns_rbtnode_t *node = NULL; isc_result_t result; rbtdb_search_t search; @@ -4961,22 +5054,23 @@ cache_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, (search.zonecut_rdataset == NULL || search.zonecut_rdataset->type != dns_rdatatype_dname)) { - result = find_coveringnsec(&search, name, nodep, now, - foundname, rdataset, - sigrdataset); + result = find_coveringnsec( + &search, name, nodep, now, foundname, rdataset, + sigrdataset DNS__DB_FLARG_PASS); if (result == DNS_R_COVERINGNSEC) { goto tree_exit; } } if (search.zonecut != NULL) { - result = setup_delegation(&search, nodep, foundname, - rdataset, sigrdataset); + result = setup_delegation( + &search, nodep, foundname, rdataset, + sigrdataset DNS__DB_FLARG_PASS); goto tree_exit; } else { find_ns: - result = find_deepest_zonecut(&search, node, nodep, - foundname, rdataset, - sigrdataset); + result = find_deepest_zonecut( + &search, node, nodep, foundname, rdataset, + sigrdataset DNS__DB_FLARG_PASS); goto tree_exit; } } else if (result != ISC_R_SUCCESS) { @@ -5108,9 +5202,9 @@ cache_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, */ NODE_UNLOCK(lock, &nlocktype); if ((search.options & DNS_DBFIND_COVERINGNSEC) != 0) { - result = find_coveringnsec(&search, name, nodep, now, - foundname, rdataset, - sigrdataset); + result = find_coveringnsec( + &search, name, nodep, now, foundname, rdataset, + sigrdataset DNS__DB_FLARG_PASS); if (result == DNS_R_COVERINGNSEC) { goto tree_exit; } @@ -5136,18 +5230,20 @@ cache_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, nsecheader != NULL) { if (nodep != NULL) { - new_reference(search.rbtdb, node, nlocktype); + new_reference(search.rbtdb, node, + nlocktype DNS__DB_FLARG_PASS); *nodep = node; } bind_rdataset(search.rbtdb, node, nsecheader, - search.now, nlocktype, rdataset); + search.now, nlocktype, + rdataset DNS__DB_FLARG_PASS); if (need_headerupdate(nsecheader, search.now)) { update = nsecheader; } if (nsecsig != NULL) { bind_rdataset(search.rbtdb, node, nsecsig, search.now, nlocktype, - sigrdataset); + sigrdataset DNS__DB_FLARG_PASS); if (need_headerupdate(nsecsig, search.now)) { updatesig = nsecsig; } @@ -5163,9 +5259,9 @@ cache_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, (search.options & DNS_DBFIND_COVERINGNSEC) != 0) { NODE_UNLOCK(lock, &nlocktype); - result = find_coveringnsec(&search, name, nodep, now, - foundname, rdataset, - sigrdataset); + result = find_coveringnsec( + &search, name, nodep, now, foundname, rdataset, + sigrdataset DNS__DB_FLARG_PASS); if (result == DNS_R_COVERINGNSEC) { goto tree_exit; } @@ -5178,18 +5274,19 @@ cache_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, */ if (nsheader != NULL) { if (nodep != NULL) { - new_reference(search.rbtdb, node, nlocktype); + new_reference(search.rbtdb, node, + nlocktype DNS__DB_FLARG_PASS); *nodep = node; } bind_rdataset(search.rbtdb, node, nsheader, search.now, - nlocktype, rdataset); + nlocktype, rdataset DNS__DB_FLARG_PASS); if (need_headerupdate(nsheader, search.now)) { update = nsheader; } if (nssig != NULL) { bind_rdataset(search.rbtdb, node, nssig, search.now, nlocktype, - sigrdataset); + sigrdataset DNS__DB_FLARG_PASS); if (need_headerupdate(nssig, search.now)) { updatesig = nssig; } @@ -5210,7 +5307,7 @@ cache_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, */ if (nodep != NULL) { - new_reference(search.rbtdb, node, nlocktype); + new_reference(search.rbtdb, node, nlocktype DNS__DB_FLARG_PASS); *nodep = node; } @@ -5243,13 +5340,14 @@ cache_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, result == DNS_R_NCACHENXRRSET) { bind_rdataset(search.rbtdb, node, found, search.now, nlocktype, - rdataset); + rdataset DNS__DB_FLARG_PASS); if (need_headerupdate(found, search.now)) { update = found; } if (!NEGATIVE(found) && foundsig != NULL) { bind_rdataset(search.rbtdb, node, foundsig, search.now, - nlocktype, sigrdataset); + nlocktype, + sigrdataset DNS__DB_FLARG_PASS); if (need_headerupdate(foundsig, search.now)) { updatesig = foundsig; } @@ -5286,7 +5384,7 @@ tree_exit: NODE_RDLOCK(lock, &nlocktype); decrement_reference(search.rbtdb, node, 0, &nlocktype, - &tlocktype, true, false); + &tlocktype, true, false DNS__DB_FLARG_PASS); NODE_UNLOCK(lock, &nlocktype); INSIST(tlocktype == isc_rwlocktype_none); } @@ -5301,7 +5399,8 @@ static isc_result_t cache_findzonecut(dns_db_t *db, const dns_name_t *name, unsigned int options, isc_stdtime_t now, dns_dbnode_t **nodep, dns_name_t *foundname, dns_name_t *dcname, - dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset) { + dns_rdataset_t *rdataset, + dns_rdataset_t *sigrdataset DNS__DB_FLARG) { dns_rbtnode_t *node = NULL; nodelock_t *lock; isc_result_t result; @@ -5350,7 +5449,8 @@ cache_findzonecut(dns_db_t *db, const dns_name_t *name, unsigned int options, if (result == DNS_R_PARTIALMATCH) { result = find_deepest_zonecut(&search, node, nodep, foundname, - rdataset, sigrdataset); + rdataset, + sigrdataset DNS__DB_FLARG_PASS); goto tree_exit; } else if (result != ISC_R_SUCCESS) { goto tree_exit; @@ -5384,9 +5484,9 @@ cache_findzonecut(dns_db_t *db, const dns_name_t *name, unsigned int options, * zonecut from this node up and return that instead. */ NODE_UNLOCK(lock, &nlocktype); - result = find_deepest_zonecut(&search, node, nodep, - foundname, rdataset, - sigrdataset); + result = find_deepest_zonecut( + &search, node, nodep, foundname, rdataset, + sigrdataset DNS__DB_FLARG_PASS); dns_name_copy(foundname, dcname); goto tree_exit; } else if (EXISTS(header) && !ANCIENT(header)) { @@ -5420,20 +5520,21 @@ cache_findzonecut(dns_db_t *db, const dns_name_t *name, unsigned int options, */ NODE_UNLOCK(lock, &nlocktype); result = find_deepest_zonecut(&search, node, nodep, foundname, - rdataset, sigrdataset); + rdataset, + sigrdataset DNS__DB_FLARG_PASS); goto tree_exit; } if (nodep != NULL) { - new_reference(search.rbtdb, node, nlocktype); + new_reference(search.rbtdb, node, nlocktype DNS__DB_FLARG_PASS); *nodep = node; } bind_rdataset(search.rbtdb, node, found, search.now, nlocktype, - rdataset); + rdataset DNS__DB_FLARG_PASS); if (foundsig != NULL) { bind_rdataset(search.rbtdb, node, foundsig, search.now, - nlocktype, sigrdataset); + nlocktype, sigrdataset DNS__DB_FLARG_PASS); } if (need_headerupdate(found, search.now) || @@ -5469,20 +5570,26 @@ tree_exit: } static void -attachnode(dns_db_t *db, dns_dbnode_t *source, dns_dbnode_t **targetp) { - dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; - dns_rbtnode_t *node = (dns_rbtnode_t *)source; - - REQUIRE(VALID_RBTDB(rbtdb)); +attachnode(dns_db_t *db, dns_dbnode_t *source, + dns_dbnode_t **targetp DNS__DB_FLARG) { + REQUIRE(VALID_RBTDB((dns_rbtdb_t *)db)); REQUIRE(targetp != NULL && *targetp == NULL); - isc_refcount_increment(&node->references); + dns_rbtnode_t *node = (dns_rbtnode_t *)source; + uint_fast32_t refs = isc_refcount_increment(&node->references); + +#if DNS_DB_NODETRACE + fprintf(stderr, "incr:node:%s:%s:%u:%p->references = %" PRIuFAST32 "\n", + func, file, line, node, refs + 1); +#else + UNUSED(refs); +#endif *targetp = source; } static void -detachnode(dns_db_t *db, dns_dbnode_t **targetp) { +detachnode(dns_db_t *db, dns_dbnode_t **targetp DNS__DB_FLARG) { dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; dns_rbtnode_t *node; bool want_free = false; @@ -5500,7 +5607,7 @@ detachnode(dns_db_t *db, dns_dbnode_t **targetp) { NODE_RDLOCK(&nodelock->lock, &nlocktype); if (decrement_reference(rbtdb, node, 0, &nlocktype, &tlocktype, true, - false)) + false DNS__DB_FLARG_PASS)) { if (isc_refcount_current(&nodelock->references) == 0 && nodelock->exiting) @@ -5732,7 +5839,7 @@ static isc_result_t zone_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, dns_rdatatype_t type, dns_rdatatype_t covers, isc_stdtime_t now, dns_rdataset_t *rdataset, - dns_rdataset_t *sigrdataset) { + dns_rdataset_t *sigrdataset DNS__DB_FLARG) { dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node; rdatasetheader_t *header, *header_next, *found, *foundsig; @@ -5800,10 +5907,11 @@ zone_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, } if (found != NULL) { bind_rdataset(rbtdb, rbtnode, found, now, isc_rwlocktype_read, - rdataset); + rdataset DNS__DB_FLARG_PASS); if (foundsig != NULL) { bind_rdataset(rbtdb, rbtnode, foundsig, now, - isc_rwlocktype_read, sigrdataset); + isc_rwlocktype_read, + sigrdataset DNS__DB_FLARG_PASS); } } @@ -5811,7 +5919,7 @@ zone_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, if (close_version) { closeversion(db, (dns_dbversion_t **)(void *)(&rbtversion), - false); + false DNS__DB_FLARG_PASS); } if (found == NULL) { @@ -5825,7 +5933,7 @@ static isc_result_t cache_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, dns_rdatatype_t type, dns_rdatatype_t covers, isc_stdtime_t now, dns_rdataset_t *rdataset, - dns_rdataset_t *sigrdataset) { + dns_rdataset_t *sigrdataset DNS__DB_FLARG) { dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node; rdatasetheader_t *header, *header_next, *found, *foundsig; @@ -5894,10 +6002,11 @@ cache_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, } } if (found != NULL) { - bind_rdataset(rbtdb, rbtnode, found, now, nlocktype, rdataset); + bind_rdataset(rbtdb, rbtnode, found, now, nlocktype, + rdataset DNS__DB_FLARG_PASS); if (!NEGATIVE(found) && foundsig != NULL) { bind_rdataset(rbtdb, rbtnode, foundsig, now, nlocktype, - sigrdataset); + sigrdataset DNS__DB_FLARG_PASS); } } @@ -5926,11 +6035,12 @@ cache_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, static isc_result_t allrdatasets(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, unsigned int options, isc_stdtime_t now, - dns_rdatasetiter_t **iteratorp) { + dns_rdatasetiter_t **iteratorp DNS__DB_FLARG) { dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node; rbtdb_version_t *rbtversion = version; rbtdb_rdatasetiter_t *iterator; + uint_fast32_t refs; REQUIRE(VALID_RBTDB(rbtdb)); @@ -5961,7 +6071,13 @@ allrdatasets(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, iterator->common.options = options; iterator->common.now = now; - isc_refcount_increment(&rbtnode->references); + refs = isc_refcount_increment(&rbtnode->references); +#if DNS_DB_NODETRACE + fprintf(stderr, "incr:node:%s:%s:%u:%p->references = %" PRIuFAST32 "\n", + func, file, line, node, refs + 1); +#else + UNUSED(refs); +#endif iterator->current = NULL; @@ -6069,7 +6185,7 @@ resign_insert(dns_rbtdb_t *rbtdb, int idx, rdatasetheader_t *newheader) { */ static void resign_delete(dns_rbtdb_t *rbtdb, rbtdb_version_t *version, - rdatasetheader_t *header) { + rdatasetheader_t *header DNS__DB_FLARG) { /* * Remove the old header from the heap */ @@ -6079,7 +6195,7 @@ resign_delete(dns_rbtdb_t *rbtdb, rbtdb_version_t *version, header->heap_index = 0; if (version != NULL) { new_reference(rbtdb, header->node, - isc_rwlocktype_write); + isc_rwlocktype_write DNS__DB_FLARG_PASS); ISC_LIST_APPEND(version->resigned_list, header, link); } } @@ -6117,7 +6233,7 @@ static isc_result_t add32(dns_rbtdb_t *rbtdb, dns_rbtnode_t *rbtnode, const dns_name_t *nodename, rbtdb_version_t *rbtversion, rdatasetheader_t *newheader, unsigned int options, bool loading, dns_rdataset_t *addedrdataset, - isc_stdtime_t now) { + isc_stdtime_t now DNS__DB_FLARG) { rbtdb_changed_t *changed = NULL; rdatasetheader_t *topheader = NULL, *topheader_prev = NULL; rdatasetheader_t *header = NULL, *sigheader = NULL; @@ -6158,7 +6274,8 @@ add32(dns_rbtdb_t *rbtdb, dns_rbtnode_t *rbtnode, const dns_name_t *nodename, * being made to this node, because it's harmless and * simplifies the code. */ - changed = add_changed(rbtdb, rbtversion, rbtnode); + changed = add_changed(rbtdb, rbtversion, + rbtnode DNS__DB_FLARG_PASS); if (changed == NULL) { free_rdataset(rbtdb, rbtdb->common.mctx, newheader); return (ISC_R_NOMEMORY); @@ -6247,7 +6364,8 @@ add32(dns_rbtdb_t *rbtdb, dns_rbtnode_t *rbtnode, const dns_name_t *nodename, rbtdb, rbtnode, topheader, now, isc_rwlocktype_write, - addedrdataset); + addedrdataset + DNS__DB_FLARG_PASS); } return (DNS_R_UNCHANGED); } @@ -6310,7 +6428,7 @@ find_header: if (addedrdataset != NULL) { bind_rdataset(rbtdb, rbtnode, header, now, isc_rwlocktype_write, - addedrdataset); + addedrdataset DNS__DB_FLARG_PASS); } return (DNS_R_UNCHANGED); } @@ -6424,7 +6542,7 @@ find_header: if (addedrdataset != NULL) { bind_rdataset(rbtdb, rbtnode, header, now, isc_rwlocktype_write, - addedrdataset); + addedrdataset DNS__DB_FLARG_PASS); } return (ISC_R_SUCCESS); } @@ -6476,7 +6594,7 @@ find_header: if (addedrdataset != NULL) { bind_rdataset(rbtdb, rbtnode, header, now, isc_rwlocktype_write, - addedrdataset); + addedrdataset DNS__DB_FLARG_PASS); } return (ISC_R_SUCCESS); } @@ -6536,7 +6654,8 @@ find_header: } } else if (RESIGN(newheader)) { resign_insert(rbtdb, idx, newheader); - resign_delete(rbtdb, rbtversion, header); + resign_delete(rbtdb, rbtversion, + header DNS__DB_FLARG_PASS); } if (topheader_prev != NULL) { topheader_prev->next = newheader; @@ -6590,7 +6709,8 @@ find_header: } } else if (RESIGN(newheader)) { resign_insert(rbtdb, idx, newheader); - resign_delete(rbtdb, rbtversion, header); + resign_delete(rbtdb, rbtversion, + header DNS__DB_FLARG_PASS); } if (topheader != NULL) { @@ -6643,7 +6763,8 @@ find_header: if (addedrdataset != NULL) { bind_rdataset(rbtdb, rbtnode, newheader, now, - isc_rwlocktype_write, addedrdataset); + isc_rwlocktype_write, + addedrdataset DNS__DB_FLARG_PASS); } return (ISC_R_SUCCESS); @@ -6762,7 +6883,7 @@ static dns_dbmethods_t zone_methods; static isc_result_t addrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, isc_stdtime_t now, dns_rdataset_t *rdataset, unsigned int options, - dns_rdataset_t *addedrdataset) { + dns_rdataset_t *addedrdataset DNS__DB_FLARG) { dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node; rbtdb_version_t *rbtversion = version; @@ -6923,7 +7044,8 @@ addrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, } if (cache_is_overmem) { - overmem_purge(rbtdb, rbtnode->locknum, now, &tlocktype); + overmem_purge(rbtdb, rbtnode->locknum, now, + &tlocktype DNS__DB_FLARG_PASS); } NODE_WRLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype); @@ -6937,7 +7059,8 @@ addrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, if (IS_CACHE(rbtdb)) { if (tlocktype == isc_rwlocktype_write) { - cleanup_dead_nodes(rbtdb, rbtnode->locknum); + cleanup_dead_nodes(rbtdb, + rbtnode->locknum DNS__DB_FLARG_PASS); } header = isc_heap_element(rbtdb->heaps[rbtnode->locknum], 1); @@ -6946,7 +7069,7 @@ addrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, now - RBTDB_VIRTUAL) { expire_header(rbtdb, header, &nlocktype, &tlocktype, - expire_ttl); + expire_ttl DNS__DB_FLARG_PASS); } /* @@ -6978,7 +7101,8 @@ addrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, if (result == ISC_R_SUCCESS) { result = add32(rbtdb, rbtnode, name, rbtversion, newheader, - options, false, addedrdataset, now); + options, false, addedrdataset, + now DNS__DB_FLARG_PASS); } if (result == ISC_R_SUCCESS && delegating) { rbtnode->find_callback = 1; @@ -7005,7 +7129,7 @@ addrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, static isc_result_t subtractrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, dns_rdataset_t *rdataset, unsigned int options, - dns_rdataset_t *newrdataset) { + dns_rdataset_t *newrdataset DNS__DB_FLARG) { dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node; rbtdb_version_t *rbtversion = version; @@ -7067,7 +7191,7 @@ subtractrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, NODE_WRLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype); - changed = add_changed(rbtdb, rbtversion, rbtnode); + changed = add_changed(rbtdb, rbtversion, rbtnode DNS__DB_FLARG_PASS); if (changed == NULL) { free_rdataset(rbtdb, rbtdb->common.mctx, newheader); NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, @@ -7185,7 +7309,7 @@ subtractrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, topheader->next = newheader; rbtnode->dirty = 1; changed->dirty = true; - resign_delete(rbtdb, rbtversion, header); + resign_delete(rbtdb, rbtversion, header DNS__DB_FLARG_PASS); } else { /* * The rdataset doesn't exist, so we don't need to do anything @@ -7201,14 +7325,15 @@ subtractrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, if (result == ISC_R_SUCCESS && newrdataset != NULL) { bind_rdataset(rbtdb, rbtnode, newheader, 0, - isc_rwlocktype_write, newrdataset); + isc_rwlocktype_write, + newrdataset DNS__DB_FLARG_PASS); } if (result == DNS_R_NXRRSET && newrdataset != NULL && (options & DNS_DBSUB_WANTOLD) != 0) { bind_rdataset(rbtdb, rbtnode, header, 0, isc_rwlocktype_write, - newrdataset); + newrdataset DNS__DB_FLARG_PASS); } unlock: @@ -7230,7 +7355,7 @@ unlock: static isc_result_t deleterdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, - dns_rdatatype_t type, dns_rdatatype_t covers) { + dns_rdatatype_t type, dns_rdatatype_t covers DNS__DB_FLARG) { dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node; rbtdb_version_t *rbtversion = version; @@ -7274,7 +7399,7 @@ deleterdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, NODE_WRLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype); result = add32(rbtdb, rbtnode, nodename, rbtversion, newheader, - DNS_DBADD_FORCE, false, NULL, 0); + DNS_DBADD_FORCE, false, NULL, 0 DNS__DB_FLARG_PASS); NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype); /* @@ -7372,7 +7497,7 @@ done: static isc_result_t loading_addrdataset(void *arg, const dns_name_t *name, - dns_rdataset_t *rdataset) { + dns_rdataset_t *rdataset DNS__DB_FLARG) { rbtdb_load_t *loadctx = arg; dns_rbtdb_t *rbtdb = loadctx->rbtdb; dns_rbtnode_t *node; @@ -7472,7 +7597,7 @@ loading_addrdataset(void *arg, const dns_name_t *name, NODE_WRLOCK(&rbtdb->node_locks[node->locknum].lock, &nlocktype); result = add32(rbtdb, node, name, rbtdb->current_version, newheader, - DNS_DBADD_MERGE, true, NULL, 0); + DNS_DBADD_MERGE, true, NULL, 0 DNS__DB_FLARG_PASS); NODE_UNLOCK(&rbtdb->node_locks[node->locknum].lock, &nlocktype); if (result == ISC_R_SUCCESS && @@ -7688,7 +7813,7 @@ setloop(dns_db_t *db, isc_loop_t *loop) { } static isc_result_t -getoriginnode(dns_db_t *db, dns_dbnode_t **nodep) { +getoriginnode(dns_db_t *db, dns_dbnode_t **nodep DNS__DB_FLARG) { dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; dns_rbtnode_t *onode; isc_result_t result = ISC_R_SUCCESS; @@ -7699,7 +7824,8 @@ getoriginnode(dns_db_t *db, dns_dbnode_t **nodep) { /* Note that the access to origin_node doesn't require a DB lock */ onode = (dns_rbtnode_t *)rbtdb->origin_node; if (onode != NULL) { - new_reference(rbtdb, onode, isc_rwlocktype_none); + new_reference(rbtdb, onode, + isc_rwlocktype_none DNS__DB_FLARG_PASS); *nodep = rbtdb->origin_node; } else { INSIST(IS_CACHE(rbtdb)); @@ -7831,7 +7957,8 @@ setsigningtime(dns_db_t *db, dns_rdataset_t *rdataset, isc_stdtime_t resign) { } static isc_result_t -getsigningtime(dns_db_t *db, dns_rdataset_t *rdataset, dns_name_t *foundname) { +getsigningtime(dns_db_t *db, dns_rdataset_t *rdataset, + dns_name_t *foundname DNS__DB_FLARG) { dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; rdatasetheader_t *header = NULL, *this; unsigned int i; @@ -7893,7 +8020,7 @@ getsigningtime(dns_db_t *db, dns_rdataset_t *rdataset, dns_name_t *foundname) { * the bucket. */ bind_rdataset(rbtdb, header->node, header, 0, - isc_rwlocktype_read, rdataset); + isc_rwlocktype_read, rdataset DNS__DB_FLARG_PASS); if (foundname != NULL) { dns_rbt_fullnamefromnode(header->node, foundname); @@ -7910,7 +8037,8 @@ getsigningtime(dns_db_t *db, dns_rdataset_t *rdataset, dns_name_t *foundname) { } static void -resigned(dns_db_t *db, dns_rdataset_t *rdataset, dns_dbversion_t *version) { +resigned(dns_db_t *db, dns_rdataset_t *rdataset, + dns_dbversion_t *version DNS__DB_FLARG) { rbtdb_version_t *rbtversion = (rbtdb_version_t *)version; dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db; dns_rbtnode_t *node; @@ -7942,7 +8070,7 @@ resigned(dns_db_t *db, dns_rdataset_t *rdataset, dns_dbversion_t *version) { * Delete from heap and save to re-signed list so that it can * be restored if we backout of this change. */ - resign_delete(rbtdb, rbtversion, header); + resign_delete(rbtdb, rbtversion, header DNS__DB_FLARG_PASS); NODE_UNLOCK(&rbtdb->node_locks[node->locknum].lock, &nlocktype); TREE_UNLOCK(&rbtdb->tree_lock, &tlocktype); } @@ -8384,11 +8512,11 @@ cleanup_tree_lock: */ static void -rdataset_disassociate(dns_rdataset_t *rdataset) { +rdataset_disassociate(dns_rdataset_t *rdataset DNS__DB_FLARG) { dns_db_t *db = rdataset->private1; dns_dbnode_t *node = rdataset->private2; - detachnode(db, &node); + detachnode(db, &node DNS__DB_FLARG_PASS); } static isc_result_t @@ -8496,12 +8624,12 @@ rdataset_current(dns_rdataset_t *rdataset, dns_rdata_t *rdata) { } static void -rdataset_clone(dns_rdataset_t *source, dns_rdataset_t *target) { +rdataset_clone(dns_rdataset_t *source, dns_rdataset_t *target DNS__DB_FLARG) { dns_db_t *db = source->private1; dns_dbnode_t *node = source->private2; dns_dbnode_t *cloned_node = NULL; - attachnode(db, node, &cloned_node); + attachnode(db, node, &cloned_node DNS__DB_FLARG_PASS); INSIST(!ISC_LINK_LINKED(target, link)); *target = *source; ISC_LINK_INIT(target, link); @@ -8525,14 +8653,15 @@ rdataset_count(dns_rdataset_t *rdataset) { static isc_result_t rdataset_getnoqname(dns_rdataset_t *rdataset, dns_name_t *name, - dns_rdataset_t *nsec, dns_rdataset_t *nsecsig) { + dns_rdataset_t *nsec, + dns_rdataset_t *nsecsig DNS__DB_FLARG) { dns_db_t *db = rdataset->private1; dns_dbnode_t *node = rdataset->private2; dns_dbnode_t *cloned_node; const struct noqname *noqname = rdataset->private6; cloned_node = NULL; - attachnode(db, node, &cloned_node); + attachnode(db, node, &cloned_node DNS__DB_FLARG_PASS); nsec->methods = &slab_methods; nsec->rdclass = db->rdclass; nsec->type = noqname->type; @@ -8548,7 +8677,7 @@ rdataset_getnoqname(dns_rdataset_t *rdataset, dns_name_t *name, nsec->private7 = NULL; cloned_node = NULL; - attachnode(db, node, &cloned_node); + attachnode(db, node, &cloned_node DNS__DB_FLARG_PASS); nsecsig->methods = &slab_methods; nsecsig->rdclass = db->rdclass; nsecsig->type = dns_rdatatype_rrsig; @@ -8570,14 +8699,15 @@ rdataset_getnoqname(dns_rdataset_t *rdataset, dns_name_t *name, static isc_result_t rdataset_getclosest(dns_rdataset_t *rdataset, dns_name_t *name, - dns_rdataset_t *nsec, dns_rdataset_t *nsecsig) { + dns_rdataset_t *nsec, + dns_rdataset_t *nsecsig DNS__DB_FLARG) { dns_db_t *db = rdataset->private1; dns_dbnode_t *node = rdataset->private2; dns_dbnode_t *cloned_node; const struct noqname *closest = rdataset->private7; cloned_node = NULL; - attachnode(db, node, &cloned_node); + attachnode(db, node, &cloned_node DNS__DB_FLARG_PASS); nsec->methods = &slab_methods; nsec->rdclass = db->rdclass; nsec->type = closest->type; @@ -8593,7 +8723,7 @@ rdataset_getclosest(dns_rdataset_t *rdataset, dns_name_t *name, nsec->private7 = NULL; cloned_node = NULL; - attachnode(db, node, &cloned_node); + attachnode(db, node, &cloned_node DNS__DB_FLARG_PASS); nsecsig->methods = &slab_methods; nsecsig->rdclass = db->rdclass; nsecsig->type = dns_rdatatype_rrsig; @@ -8627,7 +8757,7 @@ rdataset_settrust(dns_rdataset_t *rdataset, dns_trust_t trust) { } static void -rdataset_expire(dns_rdataset_t *rdataset) { +rdataset_expire(dns_rdataset_t *rdataset DNS__DB_FLARG) { dns_rbtdb_t *rbtdb = rdataset->private1; dns_rbtnode_t *rbtnode = rdataset->private2; rdatasetheader_t *header = rdataset->private3; @@ -8636,7 +8766,8 @@ rdataset_expire(dns_rdataset_t *rdataset) { header--; NODE_WRLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype); - expire_header(rbtdb, header, &nlocktype, &tlocktype, expire_flush); + expire_header(rbtdb, header, &nlocktype, &tlocktype, + expire_flush DNS__DB_FLARG_PASS); NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype); INSIST(tlocktype == isc_rwlocktype_none); } @@ -8659,16 +8790,18 @@ rdataset_clearprefetch(dns_rdataset_t *rdataset) { */ static void -rdatasetiter_destroy(dns_rdatasetiter_t **iteratorp) { +rdatasetiter_destroy(dns_rdatasetiter_t **iteratorp DNS__DB_FLARG) { rbtdb_rdatasetiter_t *rbtiterator; rbtiterator = (rbtdb_rdatasetiter_t *)(*iteratorp); if (rbtiterator->common.version != NULL) { closeversion(rbtiterator->common.db, - &rbtiterator->common.version, false); + &rbtiterator->common.version, + false DNS__DB_FLARG_PASS); } - detachnode(rbtiterator->common.db, &rbtiterator->common.node); + detachnode(rbtiterator->common.db, + &rbtiterator->common.node DNS__DB_FLARG_PASS); isc_mem_put(rbtiterator->common.db->mctx, rbtiterator, sizeof(*rbtiterator)); @@ -8705,7 +8838,7 @@ iterator_active(dns_rbtdb_t *rbtdb, rbtdb_rdatasetiter_t *rbtiterator, } static isc_result_t -rdatasetiter_first(dns_rdatasetiter_t *iterator) { +rdatasetiter_first(dns_rdatasetiter_t *iterator DNS__DB_FLARG) { rbtdb_rdatasetiter_t *rbtiterator = (rbtdb_rdatasetiter_t *)iterator; dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)(rbtiterator->common.db); dns_rbtnode_t *rbtnode = rbtiterator->common.node; @@ -8753,7 +8886,7 @@ rdatasetiter_first(dns_rdatasetiter_t *iterator) { } static isc_result_t -rdatasetiter_next(dns_rdatasetiter_t *iterator) { +rdatasetiter_next(dns_rdatasetiter_t *iterator DNS__DB_FLARG) { rbtdb_rdatasetiter_t *rbtiterator = (rbtdb_rdatasetiter_t *)iterator; dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)(rbtiterator->common.db); dns_rbtnode_t *rbtnode = rbtiterator->common.node; @@ -8846,7 +8979,8 @@ rdatasetiter_next(dns_rdatasetiter_t *iterator) { } static void -rdatasetiter_current(dns_rdatasetiter_t *iterator, dns_rdataset_t *rdataset) { +rdatasetiter_current(dns_rdatasetiter_t *iterator, + dns_rdataset_t *rdataset DNS__DB_FLARG) { rbtdb_rdatasetiter_t *rbtiterator = (rbtdb_rdatasetiter_t *)iterator; dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)(rbtiterator->common.db); dns_rbtnode_t *rbtnode = rbtiterator->common.node; @@ -8859,7 +8993,7 @@ rdatasetiter_current(dns_rdatasetiter_t *iterator, dns_rdataset_t *rdataset) { NODE_RDLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype); bind_rdataset(rbtdb, rbtnode, header, rbtiterator->common.now, - isc_rwlocktype_read, rdataset); + isc_rwlocktype_read, rdataset DNS__DB_FLARG_PASS); NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype); } @@ -8869,7 +9003,7 @@ rdatasetiter_current(dns_rdatasetiter_t *iterator, dns_rdataset_t *rdataset) { */ static void -reference_iter_node(rbtdb_dbiterator_t *rbtdbiter) { +reference_iter_node(rbtdb_dbiterator_t *rbtdbiter DNS__DB_FLARG) { dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)rbtdbiter->common.db; dns_rbtnode_t *node = rbtdbiter->node; @@ -8878,11 +9012,11 @@ reference_iter_node(rbtdb_dbiterator_t *rbtdbiter) { } INSIST(rbtdbiter->tree_locked != isc_rwlocktype_none); - reactivate_node(rbtdb, node, rbtdbiter->tree_locked); + reactivate_node(rbtdb, node, rbtdbiter->tree_locked DNS__DB_FLARG_PASS); } static void -dereference_iter_node(rbtdb_dbiterator_t *rbtdbiter) { +dereference_iter_node(rbtdb_dbiterator_t *rbtdbiter DNS__DB_FLARG) { dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)rbtdbiter->common.db; dns_rbtnode_t *node = rbtdbiter->node; nodelock_t *lock; @@ -8898,7 +9032,7 @@ dereference_iter_node(rbtdb_dbiterator_t *rbtdbiter) { lock = &rbtdb->node_locks[node->locknum].lock; NODE_RDLOCK(lock, &nlocktype); decrement_reference(rbtdb, node, 0, &nlocktype, &rbtdbiter->tree_locked, - false, false); + false, false DNS__DB_FLARG_PASS); NODE_UNLOCK(lock, &nlocktype); INSIST(rbtdbiter->tree_locked == tlocktype); @@ -8919,7 +9053,7 @@ resume_iteration(rbtdb_dbiterator_t *rbtdbiter) { } static void -dbiterator_destroy(dns_dbiterator_t **iteratorp) { +dbiterator_destroy(dns_dbiterator_t **iteratorp DNS__DB_FLARG) { rbtdb_dbiterator_t *rbtdbiter = (rbtdb_dbiterator_t *)(*iteratorp); dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)rbtdbiter->common.db; dns_db_t *db = NULL; @@ -8929,7 +9063,7 @@ dbiterator_destroy(dns_dbiterator_t **iteratorp) { } INSIST(rbtdbiter->tree_locked == isc_rwlocktype_none); - dereference_iter_node(rbtdbiter); + dereference_iter_node(rbtdbiter DNS__DB_FLARG_PASS); dns_db_attach(rbtdbiter->common.db, &db); dns_db_detach(&rbtdbiter->common.db); @@ -8943,7 +9077,7 @@ dbiterator_destroy(dns_dbiterator_t **iteratorp) { } static isc_result_t -dbiterator_first(dns_dbiterator_t *iterator) { +dbiterator_first(dns_dbiterator_t *iterator DNS__DB_FLARG) { isc_result_t result; rbtdb_dbiterator_t *rbtdbiter = (rbtdb_dbiterator_t *)iterator; dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)iterator->db; @@ -8961,7 +9095,7 @@ dbiterator_first(dns_dbiterator_t *iterator) { resume_iteration(rbtdbiter); } - dereference_iter_node(rbtdbiter); + dereference_iter_node(rbtdbiter DNS__DB_FLARG_PASS); name = dns_fixedname_name(&rbtdbiter->name); origin = dns_fixedname_name(&rbtdbiter->origin); @@ -8987,7 +9121,7 @@ dbiterator_first(dns_dbiterator_t *iterator) { NULL, &rbtdbiter->node); if (result == ISC_R_SUCCESS) { rbtdbiter->new_origin = true; - reference_iter_node(rbtdbiter); + reference_iter_node(rbtdbiter DNS__DB_FLARG_PASS); } } else { INSIST(result == ISC_R_NOTFOUND); @@ -9004,7 +9138,7 @@ dbiterator_first(dns_dbiterator_t *iterator) { } static isc_result_t -dbiterator_last(dns_dbiterator_t *iterator) { +dbiterator_last(dns_dbiterator_t *iterator DNS__DB_FLARG) { isc_result_t result; rbtdb_dbiterator_t *rbtdbiter = (rbtdb_dbiterator_t *)iterator; dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)iterator->db; @@ -9022,7 +9156,7 @@ dbiterator_last(dns_dbiterator_t *iterator) { resume_iteration(rbtdbiter); } - dereference_iter_node(rbtdbiter); + dereference_iter_node(rbtdbiter DNS__DB_FLARG_PASS); name = dns_fixedname_name(&rbtdbiter->name); origin = dns_fixedname_name(&rbtdbiter->origin); @@ -9045,7 +9179,7 @@ dbiterator_last(dns_dbiterator_t *iterator) { NULL, &rbtdbiter->node); if (result == ISC_R_SUCCESS) { rbtdbiter->new_origin = true; - reference_iter_node(rbtdbiter); + reference_iter_node(rbtdbiter DNS__DB_FLARG_PASS); } } else { INSIST(result == ISC_R_NOTFOUND); @@ -9058,7 +9192,8 @@ dbiterator_last(dns_dbiterator_t *iterator) { } static isc_result_t -dbiterator_seek(dns_dbiterator_t *iterator, const dns_name_t *name) { +dbiterator_seek(dns_dbiterator_t *iterator, + const dns_name_t *name DNS__DB_FLARG) { isc_result_t result, tresult; rbtdb_dbiterator_t *rbtdbiter = (rbtdb_dbiterator_t *)iterator; dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)iterator->db; @@ -9076,7 +9211,7 @@ dbiterator_seek(dns_dbiterator_t *iterator, const dns_name_t *name) { resume_iteration(rbtdbiter); } - dereference_iter_node(rbtdbiter); + dereference_iter_node(rbtdbiter DNS__DB_FLARG_PASS); iname = dns_fixedname_name(&rbtdbiter->name); origin = dns_fixedname_name(&rbtdbiter->origin); @@ -9120,7 +9255,7 @@ dbiterator_seek(dns_dbiterator_t *iterator, const dns_name_t *name) { origin, NULL); if (tresult == ISC_R_SUCCESS) { rbtdbiter->new_origin = true; - reference_iter_node(rbtdbiter); + reference_iter_node(rbtdbiter DNS__DB_FLARG_PASS); } else { result = tresult; rbtdbiter->node = NULL; @@ -9136,7 +9271,7 @@ dbiterator_seek(dns_dbiterator_t *iterator, const dns_name_t *name) { } static isc_result_t -dbiterator_prev(dns_dbiterator_t *iterator) { +dbiterator_prev(dns_dbiterator_t *iterator DNS__DB_FLARG) { isc_result_t result; rbtdb_dbiterator_t *rbtdbiter = (rbtdb_dbiterator_t *)iterator; dns_name_t *name, *origin; @@ -9167,7 +9302,7 @@ dbiterator_prev(dns_dbiterator_t *iterator) { } } - dereference_iter_node(rbtdbiter); + dereference_iter_node(rbtdbiter DNS__DB_FLARG_PASS); if (result == DNS_R_NEWORIGIN || result == ISC_R_SUCCESS) { rbtdbiter->new_origin = (result == DNS_R_NEWORIGIN); @@ -9176,7 +9311,7 @@ dbiterator_prev(dns_dbiterator_t *iterator) { } if (result == ISC_R_SUCCESS) { - reference_iter_node(rbtdbiter); + reference_iter_node(rbtdbiter DNS__DB_FLARG_PASS); } rbtdbiter->result = result; @@ -9185,7 +9320,7 @@ dbiterator_prev(dns_dbiterator_t *iterator) { } static isc_result_t -dbiterator_next(dns_dbiterator_t *iterator) { +dbiterator_next(dns_dbiterator_t *iterator DNS__DB_FLARG) { isc_result_t result; rbtdb_dbiterator_t *rbtdbiter = (rbtdb_dbiterator_t *)iterator; dns_name_t *name, *origin; @@ -9216,7 +9351,7 @@ dbiterator_next(dns_dbiterator_t *iterator) { } } - dereference_iter_node(rbtdbiter); + dereference_iter_node(rbtdbiter DNS__DB_FLARG_PASS); if (result == DNS_R_NEWORIGIN || result == ISC_R_SUCCESS) { rbtdbiter->new_origin = (result == DNS_R_NEWORIGIN); @@ -9224,7 +9359,7 @@ dbiterator_next(dns_dbiterator_t *iterator) { NULL, &rbtdbiter->node); } if (result == ISC_R_SUCCESS) { - reference_iter_node(rbtdbiter); + reference_iter_node(rbtdbiter DNS__DB_FLARG_PASS); } rbtdbiter->result = result; @@ -9234,7 +9369,7 @@ dbiterator_next(dns_dbiterator_t *iterator) { static isc_result_t dbiterator_current(dns_dbiterator_t *iterator, dns_dbnode_t **nodep, - dns_name_t *name) { + dns_name_t *name DNS__DB_FLARG) { dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)iterator->db; rbtdb_dbiterator_t *rbtdbiter = (rbtdb_dbiterator_t *)iterator; dns_rbtnode_t *node = rbtdbiter->node; @@ -9264,7 +9399,7 @@ dbiterator_current(dns_dbiterator_t *iterator, dns_dbnode_t **nodep, result = ISC_R_SUCCESS; } - new_reference(rbtdb, node, isc_rwlocktype_none); + new_reference(rbtdb, node, isc_rwlocktype_none DNS__DB_FLARG_PASS); *nodep = rbtdbiter->node; @@ -9544,7 +9679,7 @@ maybe_rehash_gluetable(rbtdb_version_t *version) { static isc_result_t glue_nsdname_cb(void *arg, const dns_name_t *name, dns_rdatatype_t qtype, - dns_rdataset_t *unused) { + dns_rdataset_t *unused DNS__DB_FLARG) { rbtdb_glue_additionaldata_ctx_t *ctx; isc_result_t result; dns_fixedname_t fixedname_a; @@ -9578,7 +9713,7 @@ glue_nsdname_cb(void *arg, const dns_name_t *name, dns_rdatatype_t qtype, result = zone_find((dns_db_t *)ctx->rbtdb, name, ctx->rbtversion, dns_rdatatype_a, DNS_DBFIND_GLUEOK, 0, (dns_dbnode_t **)&node_a, name_a, &rdataset_a, - &sigrdataset_a); + &sigrdataset_a DNS__DB_FLARG_PASS); if (result == DNS_R_GLUE) { glue = isc_mem_get(ctx->rbtdb->common.mctx, sizeof(*glue)); @@ -9600,7 +9735,8 @@ glue_nsdname_cb(void *arg, const dns_name_t *name, dns_rdatatype_t qtype, result = zone_find((dns_db_t *)ctx->rbtdb, name, ctx->rbtversion, dns_rdatatype_aaaa, DNS_DBFIND_GLUEOK, 0, (dns_dbnode_t **)&node_aaaa, name_aaaa, - &rdataset_aaaa, &sigrdataset_aaaa); + &rdataset_aaaa, + &sigrdataset_aaaa DNS__DB_FLARG_PASS); if (result == DNS_R_GLUE) { if (glue == NULL) { glue = isc_mem_get(ctx->rbtdb->common.mctx, @@ -9652,24 +9788,26 @@ glue_nsdname_cb(void *arg, const dns_name_t *name, dns_rdatatype_t qtype, result = ISC_R_SUCCESS; if (dns_rdataset_isassociated(&rdataset_a)) { - rdataset_disassociate(&rdataset_a); + rdataset_disassociate(&rdataset_a DNS__DB_FLARG_PASS); } if (dns_rdataset_isassociated(&sigrdataset_a)) { - rdataset_disassociate(&sigrdataset_a); + rdataset_disassociate(&sigrdataset_a DNS__DB_FLARG_PASS); } if (dns_rdataset_isassociated(&rdataset_aaaa)) { - rdataset_disassociate(&rdataset_aaaa); + rdataset_disassociate(&rdataset_aaaa DNS__DB_FLARG_PASS); } if (dns_rdataset_isassociated(&sigrdataset_aaaa)) { - rdataset_disassociate(&sigrdataset_aaaa); + rdataset_disassociate(&sigrdataset_aaaa DNS__DB_FLARG_PASS); } if (node_a != NULL) { - detachnode((dns_db_t *)ctx->rbtdb, (dns_dbnode_t *)&node_a); + detachnode((dns_db_t *)ctx->rbtdb, + (dns_dbnode_t *)&node_a DNS__DB_FLARG_PASS); } if (node_aaaa != NULL) { - detachnode((dns_db_t *)ctx->rbtdb, (dns_dbnode_t *)&node_aaaa); + detachnode((dns_db_t *)ctx->rbtdb, + (dns_dbnode_t *)&node_aaaa DNS__DB_FLARG_PASS); } return (result); @@ -9996,7 +10134,7 @@ update_header(dns_rbtdb_t *rbtdb, rdatasetheader_t *header, isc_stdtime_t now) { */ static void overmem_purge(dns_rbtdb_t *rbtdb, unsigned int locknum_start, isc_stdtime_t now, - isc_rwlocktype_t *tlocktypep) { + isc_rwlocktype_t *tlocktypep DNS__DB_FLARG) { rdatasetheader_t *header, *header_prev; unsigned int locknum; int purgecount = 2; @@ -10011,7 +10149,7 @@ overmem_purge(dns_rbtdb_t *rbtdb, unsigned int locknum_start, isc_stdtime_t now, header = isc_heap_element(rbtdb->heaps[locknum], 1); if (header && header->rdh_ttl < now - RBTDB_VIRTUAL) { expire_header(rbtdb, header, &nlocktype, tlocktypep, - expire_ttl); + expire_ttl DNS__DB_FLARG_PASS); purgecount--; } @@ -10029,7 +10167,7 @@ overmem_purge(dns_rbtdb_t *rbtdb, unsigned int locknum_start, isc_stdtime_t now, ISC_LIST_UNLINK(rbtdb->rdatasets[locknum], header, link); expire_header(rbtdb, header, &nlocktype, tlocktypep, - expire_lru); + expire_lru DNS__DB_FLARG_PASS); purgecount--; } @@ -10040,7 +10178,7 @@ overmem_purge(dns_rbtdb_t *rbtdb, unsigned int locknum_start, isc_stdtime_t now, static void expire_header(dns_rbtdb_t *rbtdb, rdatasetheader_t *header, isc_rwlocktype_t *nlocktypep, isc_rwlocktype_t *tlocktypep, - expire_t reason) { + expire_t reason DNS__DB_FLARG) { set_ttl(rbtdb, header, 0); mark_header_ancient(rbtdb, header); @@ -10056,9 +10194,10 @@ expire_header(dns_rbtdb_t *rbtdb, rdatasetheader_t *header, * We first need to gain a new reference to the node to meet a * requirement of decrement_reference(). */ - new_reference(rbtdb, header->node, nlocktype); + new_reference(rbtdb, header->node, + nlocktype DNS__DB_FLARG_PASS); decrement_reference(rbtdb, header->node, 0, &nlocktype, - tlocktypep, true, false); + tlocktypep, true, false DNS__DB_FLARG_PASS); if (rbtdb->cachestats == NULL) { return; diff --git a/lib/dns/rdata.c b/lib/dns/rdata.c index 82f95c8ba1a..7ecc4a9a4d6 100644 --- a/lib/dns/rdata.c +++ b/lib/dns/rdata.c @@ -32,6 +32,7 @@ #include #include #include +#include #include #include #include diff --git a/lib/dns/rdata/generic/afsdb_18.c b/lib/dns/rdata/generic/afsdb_18.c index a2362f3b700..04b55f16b73 100644 --- a/lib/dns/rdata/generic/afsdb_18.c +++ b/lib/dns/rdata/generic/afsdb_18.c @@ -256,7 +256,7 @@ additionaldata_afsdb(ARGS_ADDLDATA) { isc_region_consume(®ion, 2); dns_name_fromregion(&name, ®ion); - return ((add)(arg, &name, dns_rdatatype_a, NULL)); + return ((add)(arg, &name, dns_rdatatype_a, NULL DNS__DB_FILELINE)); } static isc_result_t diff --git a/lib/dns/rdata/generic/lp_107.c b/lib/dns/rdata/generic/lp_107.c index b1889d71193..4fd8f367265 100644 --- a/lib/dns/rdata/generic/lp_107.c +++ b/lib/dns/rdata/generic/lp_107.c @@ -202,11 +202,11 @@ additionaldata_lp(ARGS_ADDLDATA) { isc_region_consume(®ion, 2); dns_name_fromregion(&name, ®ion); - result = (add)(arg, &name, dns_rdatatype_l32, NULL); + result = (add)(arg, &name, dns_rdatatype_l32, NULL DNS__DB_FILELINE); if (result != ISC_R_SUCCESS) { return (result); } - return ((add)(arg, &name, dns_rdatatype_l64, NULL)); + return ((add)(arg, &name, dns_rdatatype_l64, NULL DNS__DB_FILELINE)); } static isc_result_t diff --git a/lib/dns/rdata/generic/mb_7.c b/lib/dns/rdata/generic/mb_7.c index a44f37ba5fb..0903673b3dc 100644 --- a/lib/dns/rdata/generic/mb_7.c +++ b/lib/dns/rdata/generic/mb_7.c @@ -187,7 +187,7 @@ additionaldata_mb(ARGS_ADDLDATA) { dns_rdata_toregion(rdata, ®ion); dns_name_fromregion(&name, ®ion); - return ((add)(arg, &name, dns_rdatatype_a, NULL)); + return ((add)(arg, &name, dns_rdatatype_a, NULL DNS__DB_FILELINE)); } static isc_result_t diff --git a/lib/dns/rdata/generic/md_3.c b/lib/dns/rdata/generic/md_3.c index eca3d18f1f8..49188482460 100644 --- a/lib/dns/rdata/generic/md_3.c +++ b/lib/dns/rdata/generic/md_3.c @@ -188,7 +188,7 @@ additionaldata_md(ARGS_ADDLDATA) { dns_rdata_toregion(rdata, ®ion); dns_name_fromregion(&name, ®ion); - return ((add)(arg, &name, dns_rdatatype_a, NULL)); + return ((add)(arg, &name, dns_rdatatype_a, NULL DNS__DB_FILELINE)); } static isc_result_t diff --git a/lib/dns/rdata/generic/mf_4.c b/lib/dns/rdata/generic/mf_4.c index d354871f18c..602e8655961 100644 --- a/lib/dns/rdata/generic/mf_4.c +++ b/lib/dns/rdata/generic/mf_4.c @@ -187,7 +187,7 @@ additionaldata_mf(ARGS_ADDLDATA) { dns_rdata_toregion(rdata, ®ion); dns_name_fromregion(&name, ®ion); - return ((add)(arg, &name, dns_rdatatype_a, NULL)); + return ((add)(arg, &name, dns_rdatatype_a, NULL DNS__DB_FILELINE)); } static isc_result_t diff --git a/lib/dns/rdata/generic/mx_15.c b/lib/dns/rdata/generic/mx_15.c index e75828a23e4..1d822832f3f 100644 --- a/lib/dns/rdata/generic/mx_15.c +++ b/lib/dns/rdata/generic/mx_15.c @@ -286,7 +286,7 @@ additionaldata_mx(ARGS_ADDLDATA) { return (ISC_R_SUCCESS); } - result = (add)(arg, &name, dns_rdatatype_a, NULL); + result = (add)(arg, &name, dns_rdatatype_a, NULL DNS__DB_FILELINE); if (result != ISC_R_SUCCESS) { return (result); } @@ -299,7 +299,7 @@ additionaldata_mx(ARGS_ADDLDATA) { } return ((add)(arg, dns_fixedname_name(&fixed), dns_rdatatype_tlsa, - NULL)); + NULL DNS__DB_FILELINE)); } static isc_result_t diff --git a/lib/dns/rdata/generic/naptr_35.c b/lib/dns/rdata/generic/naptr_35.c index ae2a4f95952..0956d1d504d 100644 --- a/lib/dns/rdata/generic/naptr_35.c +++ b/lib/dns/rdata/generic/naptr_35.c @@ -621,7 +621,7 @@ additionaldata_naptr(ARGS_ADDLDATA) { dns_name_fromregion(&name, &sr); if (atype != 0) { - return ((add)(arg, &name, atype, NULL)); + return ((add)(arg, &name, atype, NULL DNS__DB_FILELINE)); } return (ISC_R_SUCCESS); diff --git a/lib/dns/rdata/generic/ns_2.c b/lib/dns/rdata/generic/ns_2.c index c7f12b19c1b..e80f4fe7a47 100644 --- a/lib/dns/rdata/generic/ns_2.c +++ b/lib/dns/rdata/generic/ns_2.c @@ -198,7 +198,7 @@ additionaldata_ns(ARGS_ADDLDATA) { dns_rdata_toregion(rdata, ®ion); dns_name_fromregion(&name, ®ion); - return ((add)(arg, &name, dns_rdatatype_a, NULL)); + return ((add)(arg, &name, dns_rdatatype_a, NULL DNS__DB_FILELINE)); } static isc_result_t diff --git a/lib/dns/rdata/generic/rt_21.c b/lib/dns/rdata/generic/rt_21.c index b6185bec85f..017aee54e78 100644 --- a/lib/dns/rdata/generic/rt_21.c +++ b/lib/dns/rdata/generic/rt_21.c @@ -250,15 +250,15 @@ additionaldata_rt(ARGS_ADDLDATA) { isc_region_consume(®ion, 2); dns_name_fromregion(&name, ®ion); - result = (add)(arg, &name, dns_rdatatype_x25, NULL); + result = (add)(arg, &name, dns_rdatatype_x25, NULL DNS__DB_FILELINE); if (result != ISC_R_SUCCESS) { return (result); } - result = (add)(arg, &name, dns_rdatatype_isdn, NULL); + result = (add)(arg, &name, dns_rdatatype_isdn, NULL DNS__DB_FILELINE); if (result != ISC_R_SUCCESS) { return (result); } - return ((add)(arg, &name, dns_rdatatype_a, NULL)); + return ((add)(arg, &name, dns_rdatatype_a, NULL DNS__DB_FILELINE)); } static isc_result_t diff --git a/lib/dns/rdata/in_1/kx_36.c b/lib/dns/rdata/in_1/kx_36.c index b244fcad2e1..7b13897e6de 100644 --- a/lib/dns/rdata/in_1/kx_36.c +++ b/lib/dns/rdata/in_1/kx_36.c @@ -237,7 +237,7 @@ additionaldata_in_kx(ARGS_ADDLDATA) { isc_region_consume(®ion, 2); dns_name_fromregion(&name, ®ion); - return ((add)(arg, &name, dns_rdatatype_a, NULL)); + return ((add)(arg, &name, dns_rdatatype_a, NULL DNS__DB_FILELINE)); } static isc_result_t diff --git a/lib/dns/rdata/in_1/srv_33.c b/lib/dns/rdata/in_1/srv_33.c index aab24e0ba10..2ebfc1db5b7 100644 --- a/lib/dns/rdata/in_1/srv_33.c +++ b/lib/dns/rdata/in_1/srv_33.c @@ -328,7 +328,7 @@ additionaldata_in_srv(ARGS_ADDLDATA) { return (ISC_R_SUCCESS); } - result = (add)(arg, &name, dns_rdatatype_a, NULL); + result = (add)(arg, &name, dns_rdatatype_a, NULL DNS__DB_FILELINE); if (result != ISC_R_SUCCESS) { return (result); } @@ -348,7 +348,7 @@ additionaldata_in_srv(ARGS_ADDLDATA) { } return ((add)(arg, dns_fixedname_name(&fixed), dns_rdatatype_tlsa, - NULL)); + NULL DNS__DB_FILELINE)); } static isc_result_t diff --git a/lib/dns/rdata/in_1/svcb_64.c b/lib/dns/rdata/in_1/svcb_64.c index 7009ca6384a..d88cfb7b503 100644 --- a/lib/dns/rdata/in_1/svcb_64.c +++ b/lib/dns/rdata/in_1/svcb_64.c @@ -1133,7 +1133,8 @@ generic_additionaldata_in_svcb(ARGS_ADDLDATA) { return (ISC_R_SUCCESS); } /* Only lookup address records */ - return ((add)(arg, owner, dns_rdatatype_a, NULL)); + return ((add)(arg, owner, dns_rdatatype_a, + NULL DNS__DB_FILELINE)); } /* @@ -1142,7 +1143,8 @@ generic_additionaldata_in_svcb(ARGS_ADDLDATA) { dns_rdataset_init(&rdataset); fname = dns_fixedname_initname(&fixed); do { - RETERR((add)(arg, &name, dns_rdatatype_cname, &rdataset)); + RETERR((add)(arg, &name, dns_rdatatype_cname, + &rdataset DNS__DB_FILELINE)); if (dns_rdataset_isassociated(&rdataset)) { isc_result_t result; result = dns_rdataset_first(&rdataset); @@ -1176,7 +1178,8 @@ generic_additionaldata_in_svcb(ARGS_ADDLDATA) { * Look up HTTPS/SVCB records when processing the alias form. */ if (alias) { - RETERR((add)(arg, &name, rdata->type, &rdataset)); + RETERR((add)(arg, &name, rdata->type, + &rdataset DNS__DB_FILELINE)); /* * Don't return A or AAAA if this is not the last element * in the HTTP / SVCB chain. @@ -1186,7 +1189,7 @@ generic_additionaldata_in_svcb(ARGS_ADDLDATA) { return (ISC_R_SUCCESS); } } - return ((add)(arg, &name, dns_rdatatype_a, NULL)); + return ((add)(arg, &name, dns_rdatatype_a, NULL DNS__DB_FILELINE)); } static isc_result_t diff --git a/lib/dns/rdatalist.c b/lib/dns/rdatalist.c index 1511279da8a..dee769d7cfc 100644 --- a/lib/dns/rdatalist.c +++ b/lib/dns/rdatalist.c @@ -94,7 +94,7 @@ dns_rdatalist_fromrdataset(dns_rdataset_t *rdataset, } void -dns_rdatalist_disassociate(dns_rdataset_t *rdataset) { +dns_rdatalist_disassociate(dns_rdataset_t *rdataset DNS__DB_FLARG) { UNUSED(rdataset); } @@ -145,7 +145,8 @@ dns_rdatalist_current(dns_rdataset_t *rdataset, dns_rdata_t *rdata) { } void -dns_rdatalist_clone(dns_rdataset_t *source, dns_rdataset_t *target) { +dns_rdatalist_clone(dns_rdataset_t *source, + dns_rdataset_t *target DNS__DB_FLARG) { REQUIRE(source != NULL); REQUIRE(target != NULL); @@ -233,7 +234,8 @@ dns_rdatalist_addnoqname(dns_rdataset_t *rdataset, const dns_name_t *name) { isc_result_t dns_rdatalist_getnoqname(dns_rdataset_t *rdataset, dns_name_t *name, - dns_rdataset_t *neg, dns_rdataset_t *negsig) { + dns_rdataset_t *neg, + dns_rdataset_t *negsig DNS__DB_FLARG) { dns_rdataclass_t rdclass; dns_rdataset_t *tneg = NULL; dns_rdataset_t *tnegsig = NULL; @@ -338,7 +340,8 @@ dns_rdatalist_addclosest(dns_rdataset_t *rdataset, const dns_name_t *name) { isc_result_t dns_rdatalist_getclosest(dns_rdataset_t *rdataset, dns_name_t *name, - dns_rdataset_t *neg, dns_rdataset_t *negsig) { + dns_rdataset_t *neg, + dns_rdataset_t *negsig DNS__DB_FLARG) { dns_rdataclass_t rdclass; dns_rdataset_t *tneg = NULL; dns_rdataset_t *tnegsig = NULL; diff --git a/lib/dns/rdataset.c b/lib/dns/rdataset.c index 69947568364..97fce56b8fe 100644 --- a/lib/dns/rdataset.c +++ b/lib/dns/rdataset.c @@ -100,7 +100,7 @@ dns_rdataset_invalidate(dns_rdataset_t *rdataset) { } void -dns_rdataset_disassociate(dns_rdataset_t *rdataset) { +dns__rdataset_disassociate(dns_rdataset_t *rdataset DNS__DB_FLARG) { /* * Disassociate 'rdataset' from its rdata, allowing it to be reused. */ @@ -108,7 +108,7 @@ dns_rdataset_disassociate(dns_rdataset_t *rdataset) { REQUIRE(DNS_RDATASET_VALID(rdataset)); REQUIRE(rdataset->methods != NULL); - (rdataset->methods->disassociate)(rdataset); + (rdataset->methods->disassociate)(rdataset DNS__DB_FLARG_PASS); rdataset->methods = NULL; ISC_LINK_INIT(rdataset, link); rdataset->rdclass = 0; @@ -142,7 +142,7 @@ dns_rdataset_isassociated(dns_rdataset_t *rdataset) { } static void -question_disassociate(dns_rdataset_t *rdataset) { +question_disassociate(dns_rdataset_t *rdataset DNS__DB_FLARG) { UNUSED(rdataset); } @@ -165,7 +165,7 @@ question_current(dns_rdataset_t *rdataset, dns_rdata_t *rdata) { } static void -question_clone(dns_rdataset_t *source, dns_rdataset_t *target) { +question_clone(dns_rdataset_t *source, dns_rdataset_t *target DNS__DB_FLARG) { *target = *source; } @@ -219,7 +219,8 @@ dns_rdataset_count(dns_rdataset_t *rdataset) { } void -dns_rdataset_clone(dns_rdataset_t *source, dns_rdataset_t *target) { +dns__rdataset_clone(dns_rdataset_t *source, + dns_rdataset_t *target DNS__DB_FLARG) { /* * Make 'target' refer to the same rdataset as 'source'. */ @@ -229,7 +230,7 @@ dns_rdataset_clone(dns_rdataset_t *source, dns_rdataset_t *target) { REQUIRE(DNS_RDATASET_VALID(target)); REQUIRE(target->methods == NULL); - (source->methods->clone)(source, target); + (source->methods->clone)(source, target DNS__DB_FLARG_PASS); } isc_result_t @@ -609,15 +610,17 @@ dns_rdataset_addnoqname(dns_rdataset_t *rdataset, dns_name_t *name) { } isc_result_t -dns_rdataset_getnoqname(dns_rdataset_t *rdataset, dns_name_t *name, - dns_rdataset_t *neg, dns_rdataset_t *negsig) { +dns__rdataset_getnoqname(dns_rdataset_t *rdataset, dns_name_t *name, + dns_rdataset_t *neg, + dns_rdataset_t *negsig DNS__DB_FLARG) { REQUIRE(DNS_RDATASET_VALID(rdataset)); REQUIRE(rdataset->methods != NULL); if (rdataset->methods->getnoqname == NULL) { return (ISC_R_NOTIMPLEMENTED); } - return ((rdataset->methods->getnoqname)(rdataset, name, neg, negsig)); + return ((rdataset->methods->getnoqname)(rdataset, name, neg, + negsig DNS__DB_FLARG_PASS)); } isc_result_t @@ -631,15 +634,17 @@ dns_rdataset_addclosest(dns_rdataset_t *rdataset, const dns_name_t *name) { } isc_result_t -dns_rdataset_getclosest(dns_rdataset_t *rdataset, dns_name_t *name, - dns_rdataset_t *neg, dns_rdataset_t *negsig) { +dns__rdataset_getclosest(dns_rdataset_t *rdataset, dns_name_t *name, + dns_rdataset_t *neg, + dns_rdataset_t *negsig DNS__DB_FLARG) { REQUIRE(DNS_RDATASET_VALID(rdataset)); REQUIRE(rdataset->methods != NULL); if (rdataset->methods->getclosest == NULL) { return (ISC_R_NOTIMPLEMENTED); } - return ((rdataset->methods->getclosest)(rdataset, name, neg, negsig)); + return ((rdataset->methods->getclosest)(rdataset, name, neg, + negsig DNS__DB_FLARG_PASS)); } void @@ -655,12 +660,12 @@ dns_rdataset_settrust(dns_rdataset_t *rdataset, dns_trust_t trust) { } void -dns_rdataset_expire(dns_rdataset_t *rdataset) { +dns__rdataset_expire(dns_rdataset_t *rdataset DNS__DB_FLARG) { REQUIRE(DNS_RDATASET_VALID(rdataset)); REQUIRE(rdataset->methods != NULL); if (rdataset->methods->expire != NULL) { - (rdataset->methods->expire)(rdataset); + (rdataset->methods->expire)(rdataset DNS__DB_FLARG_PASS); } } diff --git a/lib/dns/rdatasetiter.c b/lib/dns/rdatasetiter.c index 8e8159f50f5..a052aca5ecf 100644 --- a/lib/dns/rdatasetiter.c +++ b/lib/dns/rdatasetiter.c @@ -21,7 +21,7 @@ #include void -dns_rdatasetiter_destroy(dns_rdatasetiter_t **iteratorp) { +dns__rdatasetiter_destroy(dns_rdatasetiter_t **iteratorp DNS__DB_FLARG) { /* * Destroy '*iteratorp'. */ @@ -29,36 +29,36 @@ dns_rdatasetiter_destroy(dns_rdatasetiter_t **iteratorp) { REQUIRE(iteratorp != NULL); REQUIRE(DNS_RDATASETITER_VALID(*iteratorp)); - (*iteratorp)->methods->destroy(iteratorp); + (*iteratorp)->methods->destroy(iteratorp DNS__DB_FLARG_PASS); ENSURE(*iteratorp == NULL); } isc_result_t -dns_rdatasetiter_first(dns_rdatasetiter_t *iterator) { +dns__rdatasetiter_first(dns_rdatasetiter_t *iterator DNS__DB_FLARG) { /* * Move the rdataset cursor to the first rdataset at the node (if any). */ REQUIRE(DNS_RDATASETITER_VALID(iterator)); - return (iterator->methods->first(iterator)); + return (iterator->methods->first(iterator DNS__DB_FLARG_PASS)); } isc_result_t -dns_rdatasetiter_next(dns_rdatasetiter_t *iterator) { +dns__rdatasetiter_next(dns_rdatasetiter_t *iterator DNS__DB_FLARG) { /* * Move the rdataset cursor to the next rdataset at the node (if any). */ REQUIRE(DNS_RDATASETITER_VALID(iterator)); - return (iterator->methods->next(iterator)); + return (iterator->methods->next(iterator DNS__DB_FLARG_PASS)); } void -dns_rdatasetiter_current(dns_rdatasetiter_t *iterator, - dns_rdataset_t *rdataset) { +dns__rdatasetiter_current(dns_rdatasetiter_t *iterator, + dns_rdataset_t *rdataset DNS__DB_FLARG) { /* * Return the current rdataset. */ @@ -67,5 +67,5 @@ dns_rdatasetiter_current(dns_rdatasetiter_t *iterator, REQUIRE(DNS_RDATASET_VALID(rdataset)); REQUIRE(!dns_rdataset_isassociated(rdataset)); - iterator->methods->current(iterator, rdataset); + iterator->methods->current(iterator, rdataset DNS__DB_FLARG_PASS); } diff --git a/lib/dns/resolver.c b/lib/dns/resolver.c index 89d697860b6..fc68a5405f0 100644 --- a/lib/dns/resolver.c +++ b/lib/dns/resolver.c @@ -6915,7 +6915,7 @@ check_section(void *arg, const dns_name_t *addname, dns_rdatatype_t type, static isc_result_t check_related(void *arg, const dns_name_t *addname, dns_rdatatype_t type, - dns_rdataset_t *found) { + dns_rdataset_t *found DNS__DB_FLARG) { return (check_section(arg, addname, type, found, DNS_SECTION_ADDITIONAL)); } diff --git a/lib/dns/sdlz.c b/lib/dns/sdlz.c index 870dad35226..2580823a24e 100644 --- a/lib/dns/sdlz.c +++ b/lib/dns/sdlz.c @@ -189,23 +189,24 @@ list_tordataset(dns_rdatalist_t *rdatalist, dns_db_t *db, dns_dbnode_t *node, dns_rdataset_t *rdataset); static void -detachnode(dns_db_t *db, dns_dbnode_t **targetp); +detachnode(dns_db_t *db, dns_dbnode_t **targetp DNS__DB_FLARG); static void -dbiterator_destroy(dns_dbiterator_t **iteratorp); +dbiterator_destroy(dns_dbiterator_t **iteratorp DNS__DB_FLARG); static isc_result_t -dbiterator_first(dns_dbiterator_t *iterator); +dbiterator_first(dns_dbiterator_t *iterator DNS__DB_FLARG); static isc_result_t -dbiterator_last(dns_dbiterator_t *iterator); +dbiterator_last(dns_dbiterator_t *iterator DNS__DB_FLARG); static isc_result_t -dbiterator_seek(dns_dbiterator_t *iterator, const dns_name_t *name); +dbiterator_seek(dns_dbiterator_t *iterator, + const dns_name_t *name DNS__DB_FLARG); static isc_result_t -dbiterator_prev(dns_dbiterator_t *iterator); +dbiterator_prev(dns_dbiterator_t *iterator DNS__DB_FLARG); static isc_result_t -dbiterator_next(dns_dbiterator_t *iterator); +dbiterator_next(dns_dbiterator_t *iterator DNS__DB_FLARG); static isc_result_t dbiterator_current(dns_dbiterator_t *iterator, dns_dbnode_t **nodep, - dns_name_t *name); + dns_name_t *name DNS__DB_FLARG); static isc_result_t dbiterator_pause(dns_dbiterator_t *iterator); static isc_result_t @@ -245,17 +246,18 @@ initial_size(const char *data) { */ static void -rdatasetiter_destroy(dns_rdatasetiter_t **iteratorp) { +rdatasetiter_destroy(dns_rdatasetiter_t **iteratorp DNS__DB_FLARG) { sdlz_rdatasetiter_t *sdlziterator = (sdlz_rdatasetiter_t *)(*iteratorp); - detachnode(sdlziterator->common.db, &sdlziterator->common.node); + detachnode(sdlziterator->common.db, + &sdlziterator->common.node DNS__DB_FLARG_PASS); isc_mem_put(sdlziterator->common.db->mctx, sdlziterator, sizeof(sdlz_rdatasetiter_t)); *iteratorp = NULL; } static isc_result_t -rdatasetiter_first(dns_rdatasetiter_t *iterator) { +rdatasetiter_first(dns_rdatasetiter_t *iterator DNS__DB_FLARG) { sdlz_rdatasetiter_t *sdlziterator = (sdlz_rdatasetiter_t *)iterator; dns_sdlznode_t *sdlznode = (dns_sdlznode_t *)iterator->node; @@ -267,7 +269,7 @@ rdatasetiter_first(dns_rdatasetiter_t *iterator) { } static isc_result_t -rdatasetiter_next(dns_rdatasetiter_t *iterator) { +rdatasetiter_next(dns_rdatasetiter_t *iterator DNS__DB_FLARG) { sdlz_rdatasetiter_t *sdlziterator = (sdlz_rdatasetiter_t *)iterator; sdlziterator->current = ISC_LIST_NEXT(sdlziterator->current, link); @@ -279,7 +281,8 @@ rdatasetiter_next(dns_rdatasetiter_t *iterator) { } static void -rdatasetiter_current(dns_rdatasetiter_t *iterator, dns_rdataset_t *rdataset) { +rdatasetiter_current(dns_rdatasetiter_t *iterator, + dns_rdataset_t *rdataset DNS__DB_FLARG) { sdlz_rdatasetiter_t *sdlziterator = (sdlz_rdatasetiter_t *)iterator; list_tordataset(sdlziterator->current, iterator->db, iterator->node, @@ -358,7 +361,8 @@ attachversion(dns_db_t *db, dns_dbversion_t *source, } static void -closeversion(dns_db_t *db, dns_dbversion_t **versionp, bool commit) { +closeversion(dns_db_t *db, dns_dbversion_t **versionp, + bool commit DNS__DB_FLARG) { dns_sdlz_db_t *sdlz = (dns_sdlz_db_t *)db; char origin[DNS_NAME_MAXTEXT + 1]; @@ -608,34 +612,43 @@ getnodedata(dns_db_t *db, const dns_name_t *name, bool create, static isc_result_t findnodeext(dns_db_t *db, const dns_name_t *name, bool create, dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo, - dns_dbnode_t **nodep) { + dns_dbnode_t **nodep DNS__DB_FLARG) { return (getnodedata(db, name, create, 0, methods, clientinfo, nodep)); } static isc_result_t findnode(dns_db_t *db, const dns_name_t *name, bool create, - dns_dbnode_t **nodep) { + dns_dbnode_t **nodep DNS__DB_FLARG) { return (getnodedata(db, name, create, 0, NULL, NULL, nodep)); } static void -attachnode(dns_db_t *db, dns_dbnode_t *source, dns_dbnode_t **targetp) { +attachnode(dns_db_t *db, dns_dbnode_t *source, + dns_dbnode_t **targetp DNS__DB_FLARG) { dns_sdlz_db_t *sdlz = (dns_sdlz_db_t *)db; dns_sdlznode_t *node = (dns_sdlznode_t *)source; + uint_fast32_t refs; REQUIRE(VALID_SDLZDB(sdlz)); UNUSED(sdlz); - isc_refcount_increment(&node->references); + refs = isc_refcount_increment(&node->references); +#if DNS_DB_NODETRACE + fprintf(stderr, "incr:node:%s:%s:%u:%p->references = %" PRIuFAST32 "\n", + func, file, line, node, refs + 1); +#else + UNUSED(refs); +#endif *targetp = source; } static void -detachnode(dns_db_t *db, dns_dbnode_t **targetp) { +detachnode(dns_db_t *db, dns_dbnode_t **targetp DNS__DB_FLARG) { dns_sdlz_db_t *sdlz = (dns_sdlz_db_t *)db; dns_sdlznode_t *node; + uint_fast32_t refs; REQUIRE(VALID_SDLZDB(sdlz)); REQUIRE(targetp != NULL && *targetp != NULL); @@ -645,7 +658,15 @@ detachnode(dns_db_t *db, dns_dbnode_t **targetp) { node = (dns_sdlznode_t *)(*targetp); *targetp = NULL; - if (isc_refcount_decrement(&node->references) == 1) { + refs = isc_refcount_decrement(&node->references); +#if DNS_DB_NODETRACE + fprintf(stderr, "decr:node:%s:%s:%u:%p->references = %" PRIuFAST32 "\n", + func, file, line, node, refs - 1); +#else + UNUSED(refs); +#endif + + if (refs == 1) { destroynode(node); } } @@ -715,7 +736,7 @@ createiterator(dns_db_t *db, unsigned int options, MAYBE_UNLOCK(sdlz->dlzimp); if (result != ISC_R_SUCCESS) { dns_dbiterator_t *iter = &sdlziter->common; - dbiterator_destroy(&iter); + dbiterator_destroy(&iter DNS__DB_FILELINE); return (result); } @@ -732,7 +753,8 @@ createiterator(dns_db_t *db, unsigned int options, static isc_result_t findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, dns_rdatatype_t type, dns_rdatatype_t covers, isc_stdtime_t now, - dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset) { + dns_rdataset_t *rdataset, + dns_rdataset_t *sigrdataset DNS__DB_FLARG) { REQUIRE(VALID_SDLZNODE(node)); dns_rdatalist_t *list; dns_sdlznode_t *sdlznode = (dns_sdlznode_t *)node; @@ -768,7 +790,7 @@ findext(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, dns_rdatatype_t type, unsigned int options, isc_stdtime_t now, dns_dbnode_t **nodep, dns_name_t *foundname, dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo, - dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset) { + dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset DNS__DB_FLARG) { dns_sdlz_db_t *sdlz = (dns_sdlz_db_t *)db; dns_dbnode_t *node = NULL; dns_fixedname_t fname; @@ -830,9 +852,9 @@ findext(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, * the qname. */ if (i < nlabels) { - result = findrdataset(db, node, version, - dns_rdatatype_dname, 0, now, - rdataset, sigrdataset); + result = findrdataset( + db, node, version, dns_rdatatype_dname, 0, now, + rdataset, sigrdataset DNS__DB_FLARG_PASS); if (result == ISC_R_SUCCESS) { result = DNS_R_DNAME; break; @@ -846,9 +868,9 @@ findext(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, if (i != olabels && (options & DNS_DBFIND_GLUEOK) == 0 && (options & DNS_DBFIND_NOZONECUT) == 0) { - result = findrdataset(db, node, version, - dns_rdatatype_ns, 0, now, - rdataset, sigrdataset); + result = findrdataset( + db, node, version, dns_rdatatype_ns, 0, now, + rdataset, sigrdataset DNS__DB_FLARG_PASS); if (result == ISC_R_SUCCESS && i == nlabels && type == dns_rdatatype_any) @@ -872,7 +894,7 @@ findext(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, * and try again. */ if (i < nlabels) { - detachnode(db, &node); + detachnode(db, &node DNS__DB_FLARG_PASS); node = NULL; continue; } @@ -889,7 +911,7 @@ findext(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, * Look for the qtype. */ result = findrdataset(db, node, version, type, 0, now, rdataset, - sigrdataset); + sigrdataset DNS__DB_FLARG_PASS); if (result == ISC_R_SUCCESS) { break; } @@ -898,9 +920,9 @@ findext(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, * Look for a CNAME */ if (type != dns_rdatatype_cname) { - result = findrdataset(db, node, version, - dns_rdatatype_cname, 0, now, - rdataset, sigrdataset); + result = findrdataset( + db, node, version, dns_rdatatype_cname, 0, now, + rdataset, sigrdataset DNS__DB_FLARG_PASS); if (result == ISC_R_SUCCESS) { result = DNS_R_CNAME; break; @@ -922,7 +944,7 @@ findext(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, if (nodep != NULL) { *nodep = node; } else if (node != NULL) { - detachnode(db, &node); + detachnode(db, &node DNS__DB_FLARG_PASS); } return (result); @@ -932,15 +954,15 @@ static isc_result_t find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, dns_rdatatype_t type, unsigned int options, isc_stdtime_t now, dns_dbnode_t **nodep, dns_name_t *foundname, dns_rdataset_t *rdataset, - dns_rdataset_t *sigrdataset) { + dns_rdataset_t *sigrdataset DNS__DB_FLARG) { return (findext(db, name, version, type, options, now, nodep, foundname, - NULL, NULL, rdataset, sigrdataset)); + NULL, NULL, rdataset, sigrdataset DNS__DB_FLARG_PASS)); } static isc_result_t allrdatasets(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, unsigned int options, isc_stdtime_t now, - dns_rdatasetiter_t **iteratorp) { + dns_rdatasetiter_t **iteratorp DNS__DB_FLARG) { dns_sdlz_db_t *sdlz = (dns_sdlz_db_t *)db; sdlz_rdatasetiter_t *iterator; @@ -958,7 +980,7 @@ allrdatasets(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, iterator->common.methods = &rdatasetiter_methods; iterator->common.db = db; iterator->common.node = NULL; - attachnode(db, node, &iterator->common.node); + attachnode(db, node, &iterator->common.node DNS__DB_FLARG_PASS); iterator->common.version = version; iterator->common.options = options; iterator->common.now = now; @@ -1038,7 +1060,7 @@ cleanup: static isc_result_t addrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, isc_stdtime_t now, dns_rdataset_t *rdataset, unsigned int options, - dns_rdataset_t *addedrdataset) { + dns_rdataset_t *addedrdataset DNS__DB_FLARG) { dns_sdlz_db_t *sdlz = (dns_sdlz_db_t *)db; isc_result_t result; @@ -1058,7 +1080,7 @@ addrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, static isc_result_t subtractrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, dns_rdataset_t *rdataset, unsigned int options, - dns_rdataset_t *newrdataset) { + dns_rdataset_t *newrdataset DNS__DB_FLARG) { dns_sdlz_db_t *sdlz = (dns_sdlz_db_t *)db; isc_result_t result; @@ -1076,7 +1098,7 @@ subtractrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, static isc_result_t deleterdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, - dns_rdatatype_t type, dns_rdatatype_t covers) { + dns_rdatatype_t type, dns_rdatatype_t covers DNS__DB_FLARG) { dns_sdlz_db_t *sdlz = (dns_sdlz_db_t *)db; char name[DNS_NAME_MAXTEXT + 1]; char b_type[DNS_RDATATYPE_FORMATSIZE]; @@ -1135,7 +1157,7 @@ setloop(dns_db_t *db, isc_loop_t *loop) { * dns_rdatatype_dnskey record for a zone */ static isc_result_t -getoriginnode(dns_db_t *db, dns_dbnode_t **nodep) { +getoriginnode(dns_db_t *db, dns_dbnode_t **nodep DNS__DB_FLARG) { dns_sdlz_db_t *sdlz = (dns_sdlz_db_t *)db; isc_result_t result; @@ -1186,7 +1208,7 @@ static dns_dbmethods_t sdlzdb_methods = { */ static void -dbiterator_destroy(dns_dbiterator_t **iteratorp) { +dbiterator_destroy(dns_dbiterator_t **iteratorp DNS__DB_FLARG) { sdlz_dbiterator_t *sdlziter = (sdlz_dbiterator_t *)(*iteratorp); dns_sdlz_db_t *sdlz = (dns_sdlz_db_t *)sdlziter->common.db; @@ -1205,7 +1227,7 @@ dbiterator_destroy(dns_dbiterator_t **iteratorp) { } static isc_result_t -dbiterator_first(dns_dbiterator_t *iterator) { +dbiterator_first(dns_dbiterator_t *iterator DNS__DB_FLARG) { sdlz_dbiterator_t *sdlziter = (sdlz_dbiterator_t *)iterator; sdlziter->current = ISC_LIST_HEAD(sdlziter->nodelist); @@ -1217,7 +1239,7 @@ dbiterator_first(dns_dbiterator_t *iterator) { } static isc_result_t -dbiterator_last(dns_dbiterator_t *iterator) { +dbiterator_last(dns_dbiterator_t *iterator DNS__DB_FLARG) { sdlz_dbiterator_t *sdlziter = (sdlz_dbiterator_t *)iterator; sdlziter->current = ISC_LIST_TAIL(sdlziter->nodelist); @@ -1229,7 +1251,8 @@ dbiterator_last(dns_dbiterator_t *iterator) { } static isc_result_t -dbiterator_seek(dns_dbiterator_t *iterator, const dns_name_t *name) { +dbiterator_seek(dns_dbiterator_t *iterator, + const dns_name_t *name DNS__DB_FLARG) { sdlz_dbiterator_t *sdlziter = (sdlz_dbiterator_t *)iterator; sdlziter->current = ISC_LIST_HEAD(sdlziter->nodelist); @@ -1243,7 +1266,7 @@ dbiterator_seek(dns_dbiterator_t *iterator, const dns_name_t *name) { } static isc_result_t -dbiterator_prev(dns_dbiterator_t *iterator) { +dbiterator_prev(dns_dbiterator_t *iterator DNS__DB_FLARG) { sdlz_dbiterator_t *sdlziter = (sdlz_dbiterator_t *)iterator; sdlziter->current = ISC_LIST_PREV(sdlziter->current, link); @@ -1255,7 +1278,7 @@ dbiterator_prev(dns_dbiterator_t *iterator) { } static isc_result_t -dbiterator_next(dns_dbiterator_t *iterator) { +dbiterator_next(dns_dbiterator_t *iterator DNS__DB_FLARG) { sdlz_dbiterator_t *sdlziter = (sdlz_dbiterator_t *)iterator; sdlziter->current = ISC_LIST_NEXT(sdlziter->current, link); @@ -1268,10 +1291,10 @@ dbiterator_next(dns_dbiterator_t *iterator) { static isc_result_t dbiterator_current(dns_dbiterator_t *iterator, dns_dbnode_t **nodep, - dns_name_t *name) { + dns_name_t *name DNS__DB_FLARG) { sdlz_dbiterator_t *sdlziter = (sdlz_dbiterator_t *)iterator; - attachnode(iterator->db, sdlziter->current, nodep); + attachnode(iterator->db, sdlziter->current, nodep DNS__DB_FLARG_PASS); if (name != NULL) { dns_name_copy(sdlziter->current->name, name); return (ISC_R_SUCCESS); @@ -1298,24 +1321,24 @@ dbiterator_origin(dns_dbiterator_t *iterator, dns_name_t *name) { */ static void -disassociate(dns_rdataset_t *rdataset) { +disassociate(dns_rdataset_t *rdataset DNS__DB_FLARG) { dns_dbnode_t *node = rdataset->private5; dns_sdlznode_t *sdlznode = (dns_sdlznode_t *)node; dns_db_t *db = (dns_db_t *)sdlznode->sdlz; - detachnode(db, &node); - dns_rdatalist_disassociate(rdataset); + detachnode(db, &node DNS__DB_FLARG_PASS); + dns_rdatalist_disassociate(rdataset DNS__DB_FLARG_PASS); } static void -rdataset_clone(dns_rdataset_t *source, dns_rdataset_t *target) { +rdataset_clone(dns_rdataset_t *source, dns_rdataset_t *target DNS__DB_FLARG) { dns_dbnode_t *node = source->private5; dns_sdlznode_t *sdlznode = (dns_sdlznode_t *)node; dns_db_t *db = (dns_db_t *)sdlznode->sdlz; dns_dbnode_t *tempdb = NULL; - dns_rdatalist_clone(source, target); - attachnode(db, node, &tempdb); + dns_rdatalist_clone(source, target DNS__DB_FLARG_PASS); + attachnode(db, node, &tempdb DNS__DB_FLARG_PASS); source->private5 = tempdb; } diff --git a/lib/ns/query.c b/lib/ns/query.c index c86a97880e5..2fe7386c3c8 100644 --- a/lib/ns/query.c +++ b/lib/ns/query.c @@ -1670,7 +1670,7 @@ query_additionalauth(query_ctx_t *qctx, const dns_name_t *name, static isc_result_t query_additional_cb(void *arg, const dns_name_t *name, dns_rdatatype_t qtype, - dns_rdataset_t *found) { + dns_rdataset_t *found DNS__DB_FLARG) { query_ctx_t *qctx = arg; ns_client_t *client = qctx->client; isc_result_t result, eresult = ISC_R_SUCCESS; diff --git a/tests/dns/master_test.c b/tests/dns/master_test.c index 00d0f12dc5b..a2076395a8f 100644 --- a/tests/dns/master_test.c +++ b/tests/dns/master_test.c @@ -62,7 +62,8 @@ static void rawdata_callback(dns_zone_t *zone, dns_masterrawheader_t *header); static isc_result_t -add_callback(void *arg, const dns_name_t *owner, dns_rdataset_t *dataset) { +add_callback(void *arg, const dns_name_t *owner, + dns_rdataset_t *dataset DNS__DB_FLARG) { char buf[BIGBUFLEN]; isc_buffer_t target; isc_result_t result; diff --git a/tests/dns/rdata_test.c b/tests/dns/rdata_test.c index 68050a21692..234c74b54bc 100644 --- a/tests/dns/rdata_test.c +++ b/tests/dns/rdata_test.c @@ -183,7 +183,7 @@ rdata_towire(dns_rdata_t *rdata, unsigned char *dst, size_t dstlen, static isc_result_t additionaldata_cb(void *arg, const dns_name_t *name, dns_rdatatype_t qtype, - dns_rdataset_t *found) { + dns_rdataset_t *found DNS__DB_FLARG) { UNUSED(arg); UNUSED(name); UNUSED(qtype);