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.
* 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 = {
*/
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;
}
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);
}
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,
}
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));
}
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;
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;
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;
* 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?
* 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;
* 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;
* 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;
}
* 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;
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;
}
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;
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;
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);
.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;
}
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
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;
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)
{
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;
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;
}
*/
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
}
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
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
}
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
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
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
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 \
#include <isc/result.h>
#include <isc/rwlock.h>
#include <isc/string.h>
+#include <isc/tid.h>
#include <isc/util.h>
#include <dns/callbacks.h>
}
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;
/*
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);
***/
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'.
*/
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.
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'.
*/
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'.
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'.
!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
!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.
*/
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.
*/
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);
}
***/
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));
!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'.
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'.
*/
!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'.
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'.
((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);
}
}
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);
}
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);
}
}
#include <dns/name.h>
void
-dns_dbiterator_destroy(dns_dbiterator_t **iteratorp) {
+dns__dbiterator_destroy(dns_dbiterator_t **iteratorp DNS__DB_FLARG) {
/*
* Destroy '*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.
*/
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
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,
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);
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,
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,
* \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'.
*
*** 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'.
*
* 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'.
*
* 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'.
*
* 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.
*
* \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.
*
* 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
* 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'.
* 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'.
*
* 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'.
* 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'.
* \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
* \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'.
*
* \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.
* \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'
*****/
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;
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'.
*
*\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).
*
*\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).
*
*\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'.
*
*\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).
*
*\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).
*
*\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.
*
/*@}*/
};
-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);
*\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'.
*
*\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'.
*
*\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.
*
*/
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);
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);
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);
} 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);
* 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.
*
*\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'.
*
*\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.
*
* 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.
*
* 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.
*/
*****/
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')
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'.
*
*\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).
*
*\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).
*
*\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.
*
--- /dev/null
+/*
+ * 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 */
#include <isc/types.h>
+#include <dns/trace.h>
+
typedef struct dns_acl dns_acl_t;
typedef struct dns_aclelement dns_aclelement_t;
typedef struct dns_aclenv dns_aclenv_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 *);
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
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,
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 {
}
static void
-keynode_disassociate(dns_rdataset_t *rdataset) {
+keynode_disassociate(dns_rdataset_t *rdataset DNS__DB_FLARG) {
dns_keynode_t *keynode;
REQUIRE(rdataset != NULL);
}
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);
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));
#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.
*
*/
}
static void
-rdataset_disassociate(dns_rdataset_t *rdataset) {
+rdataset_disassociate(dns_rdataset_t *rdataset DNS__DB_FLARG) {
UNUSED(rdataset);
}
}
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;
/*
* 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;
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;
/*
* 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;
* 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;
* ->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) {
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
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
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
};
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,
* 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
}
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;
/*
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);
*/
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
}
}
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);
}
* 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 */
}
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
*/
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;
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);
}
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;
/* 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);
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);
}
}
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;
* 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);
do {
parent = node->parent;
decrement_reference(rbtdb, node, 0, &nlocktype, &tlocktype,
- true, true);
+ true, true DNS__DB_FILELINE);
if (parent != NULL && parent->down == NULL) {
/*
ISC_LIST_UNLINK(rbtdb->deadnodes[locknum],
parent, deadlink);
}
- new_reference(rbtdb, parent, nlocktype);
+ new_reference(rbtdb, parent,
+ nlocktype DNS__DB_FILELINE);
} else {
parent = NULL;
}
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;
}
}
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;
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);
}
* 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) {
}
decrement_reference(rbtdb, rbtnode, least_serial,
&nlocktype, &tlocktype, true,
- false);
+ false DNS__DB_FILELINE);
NODE_UNLOCK(lock, &nlocktype);
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;
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:
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;
* 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;
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);
return;
}
- new_reference(rbtdb, node, locktype);
+ new_reference(rbtdb, node, locktype DNS__DB_FLARG_PASS);
INSIST(rdataset->methods == NULL); /* We must be disassociated. */
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;
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);
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;
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) {
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;
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;
}
(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;
* 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;
* 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;
}
/*
}
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;
}
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 &&
(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) {
!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 {
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;
}
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);
}
}
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);
}
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;
* 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;
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;
}
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 &&
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;
}
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);
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;
(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) {
*/
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;
}
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;
}
(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;
}
*/
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;
}
*/
if (nodep != NULL) {
- new_reference(search.rbtdb, node, nlocktype);
+ new_reference(search.rbtdb, node, nlocktype DNS__DB_FLARG_PASS);
*nodep = node;
}
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;
}
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);
}
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;
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;
* 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)) {
*/
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) ||
}
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;
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)
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;
}
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);
}
}
if (close_version) {
closeversion(db, (dns_dbversion_t **)(void *)(&rbtversion),
- false);
+ false DNS__DB_FLARG_PASS);
}
if (found == NULL) {
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;
}
}
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);
}
}
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));
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;
*/
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
*/
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);
}
}
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;
* 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);
rbtdb, rbtnode,
topheader, now,
isc_rwlocktype_write,
- addedrdataset);
+ addedrdataset
+ DNS__DB_FLARG_PASS);
}
return (DNS_R_UNCHANGED);
}
if (addedrdataset != NULL) {
bind_rdataset(rbtdb, rbtnode, header, now,
isc_rwlocktype_write,
- addedrdataset);
+ addedrdataset DNS__DB_FLARG_PASS);
}
return (DNS_R_UNCHANGED);
}
if (addedrdataset != NULL) {
bind_rdataset(rbtdb, rbtnode, header, now,
isc_rwlocktype_write,
- addedrdataset);
+ addedrdataset DNS__DB_FLARG_PASS);
}
return (ISC_R_SUCCESS);
}
if (addedrdataset != NULL) {
bind_rdataset(rbtdb, rbtnode, header, now,
isc_rwlocktype_write,
- addedrdataset);
+ addedrdataset DNS__DB_FLARG_PASS);
}
return (ISC_R_SUCCESS);
}
}
} 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;
}
} 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) {
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);
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;
}
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);
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);
now - RBTDB_VIRTUAL)
{
expire_header(rbtdb, header, &nlocktype, &tlocktype,
- expire_ttl);
+ expire_ttl DNS__DB_FLARG_PASS);
}
/*
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;
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;
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,
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
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:
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;
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);
/*
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;
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 &&
}
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;
/* 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));
}
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;
* 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);
}
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;
* 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);
}
*/
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
}
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);
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;
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;
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;
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;
}
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;
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);
}
*/
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));
}
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;
}
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;
}
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;
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);
}
*/
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;
}
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;
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);
}
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;
}
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);
}
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;
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);
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);
}
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;
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);
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);
}
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;
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);
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;
}
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;
}
}
- 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);
}
if (result == ISC_R_SUCCESS) {
- reference_iter_node(rbtdbiter);
+ reference_iter_node(rbtdbiter DNS__DB_FLARG_PASS);
}
rbtdbiter->result = result;
}
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;
}
}
- 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);
NULL, &rbtdbiter->node);
}
if (result == ISC_R_SUCCESS) {
- reference_iter_node(rbtdbiter);
+ reference_iter_node(rbtdbiter DNS__DB_FLARG_PASS);
}
rbtdbiter->result = result;
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;
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;
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;
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));
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,
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);
*/
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;
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--;
}
ISC_LIST_UNLINK(rbtdb->rdatasets[locknum], header,
link);
expire_header(rbtdb, header, &nlocktype, tlocktypep,
- expire_lru);
+ expire_lru DNS__DB_FLARG_PASS);
purgecount--;
}
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);
* 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;
#include <dns/callbacks.h>
#include <dns/cert.h>
#include <dns/compress.h>
+#include <dns/db.h>
#include <dns/dsdigest.h>
#include <dns/enumtype.h>
#include <dns/fixedname.h>
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
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
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
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
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
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);
}
}
return ((add)(arg, dns_fixedname_name(&fixed), dns_rdatatype_tlsa,
- NULL));
+ NULL DNS__DB_FILELINE));
}
static isc_result_t
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);
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
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
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
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);
}
}
return ((add)(arg, dns_fixedname_name(&fixed), dns_rdatatype_tlsa,
- NULL));
+ NULL DNS__DB_FILELINE));
}
static isc_result_t
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));
}
/*
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);
* 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.
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
}
void
-dns_rdatalist_disassociate(dns_rdataset_t *rdataset) {
+dns_rdatalist_disassociate(dns_rdataset_t *rdataset DNS__DB_FLARG) {
UNUSED(rdataset);
}
}
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);
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;
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;
}
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.
*/
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;
}
static void
-question_disassociate(dns_rdataset_t *rdataset) {
+question_disassociate(dns_rdataset_t *rdataset DNS__DB_FLARG) {
UNUSED(rdataset);
}
}
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;
}
}
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'.
*/
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
}
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
}
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
}
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);
}
}
#include <dns/rdatasetiter.h>
void
-dns_rdatasetiter_destroy(dns_rdatasetiter_t **iteratorp) {
+dns__rdatasetiter_destroy(dns_rdatasetiter_t **iteratorp DNS__DB_FLARG) {
/*
* Destroy '*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.
*/
REQUIRE(DNS_RDATASET_VALID(rdataset));
REQUIRE(!dns_rdataset_isassociated(rdataset));
- iterator->methods->current(iterator, rdataset);
+ iterator->methods->current(iterator, rdataset DNS__DB_FLARG_PASS);
}
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));
}
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
*/
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;
}
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);
}
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,
}
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];
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);
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);
}
}
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);
}
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;
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;
* 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;
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)
* and try again.
*/
if (i < nlabels) {
- detachnode(db, &node);
+ detachnode(db, &node DNS__DB_FLARG_PASS);
node = NULL;
continue;
}
* 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;
}
* 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;
if (nodep != NULL) {
*nodep = node;
} else if (node != NULL) {
- detachnode(db, &node);
+ detachnode(db, &node DNS__DB_FLARG_PASS);
}
return (result);
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;
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;
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;
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;
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];
* 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;
*/
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;
}
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);
}
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);
}
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);
}
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);
}
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);
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);
*/
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;
}
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;
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;
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);
projects / thirdparty / bind9.git / commitdiff
