* Updating LRU requires write locking, so we don't do it every time the
* record is touched - only after some time passes.
*/
-#ifndef DNS_RBTDB_LIMITLRUUPDATE
-#define DNS_RBTDB_LIMITLRUUPDATE 1
+#ifndef DNS_QPDB_LIMITLRUUPDATE
+#define DNS_QPDB_LIMITLRUUPDATE 1
#endif
/*% Time after which we update LRU for glue records, 5 minutes */
-#define DNS_RBTDB_LRUUPDATE_GLUE 300
+#define DNS_QPDB_LRUUPDATE_GLUE 300
/*% Time after which we update LRU for all other records, 10 minutes */
-#define DNS_RBTDB_LRUUPDATE_REGULAR 600
+#define DNS_QPDB_LRUUPDATE_REGULAR 600
#define EXISTS(header) \
((atomic_load_acquire(&(header)->attributes) & \
((atomic_load_acquire(&(header)->attributes) & \
DNS_SLABHEADERATTR_STATCOUNT) != 0)
-#define STALE_TTL(header, rbtdb) \
- (NXDOMAIN(header) ? 0 : rbtdb->common.serve_stale_ttl)
+#define STALE_TTL(header, qpdb) \
+ (NXDOMAIN(header) ? 0 : qpdb->common.serve_stale_ttl)
#define ACTIVE(header, now) \
(((header)->ttl > (now)) || ((header)->ttl == (now) && ZEROTTL(header)))
-#define KEEPSTALE(rbtdb) ((rbtdb)->common.serve_stale_ttl > 0)
+#define KEEPSTALE(qpdb) ((qpdb)->common.serve_stale_ttl > 0)
/*%
* Routines for LRU-based cache management.
* expected to return true for almost all cases. When used with threads,
* however, this may cause a non-negligible performance penalty because a
* writer lock will have to be acquired before updating the list.
- * If DNS_RBTDB_LIMITLRUUPDATE is defined to be non 0 at compilation time, this
+ * If DNS_QPDB_LIMITLRUUPDATE is defined to be non 0 at compilation time, this
* function returns true if the entry has not been updated for some period of
* time. We differentiate the NS or glue address case and the others since
* experiments have shown that the former tends to be accessed relatively
return (false);
}
-#if DNS_RBTDB_LIMITLRUUPDATE
+#if DNS_QPDB_LIMITLRUUPDATE
if (header->type == dns_rdatatype_ns ||
(header->trust == dns_trust_glue &&
(header->type == dns_rdatatype_a ||
header->type == dns_rdatatype_aaaa)))
{
/*
- * Glue records are updated if at least DNS_RBTDB_LRUUPDATE_GLUE
+ * Glue records are updated if at least DNS_QPDB_LRUUPDATE_GLUE
* seconds have passed since the previous update time.
*/
- return (header->last_used + DNS_RBTDB_LRUUPDATE_GLUE <= now);
+ return (header->last_used + DNS_QPDB_LRUUPDATE_GLUE <= now);
}
/*
- * Other records are updated if DNS_RBTDB_LRUUPDATE_REGULAR seconds
+ * Other records are updated if DNS_QPDB_LRUUPDATE_REGULAR seconds
* have passed.
*/
- return (header->last_used + DNS_RBTDB_LRUUPDATE_REGULAR <= now);
+ return (header->last_used + DNS_QPDB_LRUUPDATE_REGULAR <= now);
#else
UNUSED(now);
return (true);
-#endif /* if DNS_RBTDB_LIMITLRUUPDATE */
+#endif /* if DNS_QPDB_LIMITLRUUPDATE */
}
/*%
* Note that the we do NOT touch the heap here, as the TTL has not changed.
*/
static void
-update_header(dns_rbtdb_t *rbtdb, dns_slabheader_t *header, isc_stdtime_t now) {
- INSIST(IS_CACHE(rbtdb));
+update_header(dns_qpdb_t *qpdb, dns_slabheader_t *header, isc_stdtime_t now) {
+ INSIST(IS_CACHE(qpdb));
/* To be checked: can we really assume this? XXXMLG */
INSIST(ISC_LINK_LINKED(header, link));
- ISC_LIST_UNLINK(rbtdb->lru[RBTDB_HEADERNODE(header)->locknum], header,
+ ISC_LIST_UNLINK(qpdb->lru[QPDB_HEADERNODE(header)->locknum], header,
link);
header->last_used = now;
- ISC_LIST_PREPEND(rbtdb->lru[RBTDB_HEADERNODE(header)->locknum], header,
+ ISC_LIST_PREPEND(qpdb->lru[QPDB_HEADERNODE(header)->locknum], header,
link);
}
*/
static void
-update_cachestats(dns_rbtdb_t *rbtdb, isc_result_t result) {
- INSIST(IS_CACHE(rbtdb));
+update_cachestats(dns_qpdb_t *qpdb, isc_result_t result) {
+ INSIST(IS_CACHE(qpdb));
- if (rbtdb->cachestats == NULL) {
+ if (qpdb->cachestats == NULL) {
return;
}
switch (result) {
case DNS_R_COVERINGNSEC:
- isc_stats_increment(rbtdb->cachestats,
+ isc_stats_increment(qpdb->cachestats,
dns_cachestatscounter_coveringnsec);
FALLTHROUGH;
case ISC_R_SUCCESS:
case DNS_R_DELEGATION:
case DNS_R_NCACHENXDOMAIN:
case DNS_R_NCACHENXRRSET:
- isc_stats_increment(rbtdb->cachestats,
+ isc_stats_increment(qpdb->cachestats,
dns_cachestatscounter_hits);
break;
default:
- isc_stats_increment(rbtdb->cachestats,
+ isc_stats_increment(qpdb->cachestats,
dns_cachestatscounter_misses);
}
}
}
static isc_result_t
-setup_delegation(rbtdb_search_t *search, dns_dbnode_t **nodep,
+setup_delegation(qpdb_search_t *search, dns_dbnode_t **nodep,
dns_name_t *foundname, dns_rdataset_t *rdataset,
dns_rdataset_t *sigrdataset DNS__DB_FLARG) {
dns_name_t *zcname = NULL;
}
if (rdataset != NULL) {
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
- NODE_RDLOCK(&(search->rbtdb->node_locks[node->locknum].lock),
+ NODE_RDLOCK(&(search->qpdb->node_locks[node->locknum].lock),
&nlocktype);
- dns__rbtdb_bindrdataset(search->rbtdb, node,
- search->zonecut_header, search->now,
- isc_rwlocktype_read,
- rdataset DNS__DB_FLARG_PASS);
+ dns__qpdb_bindrdataset(
+ search->qpdb, node, search->zonecut_header, search->now,
+ isc_rwlocktype_read, rdataset DNS__DB_FLARG_PASS);
if (sigrdataset != NULL && search->zonecut_sigheader != NULL) {
- dns__rbtdb_bindrdataset(
- search->rbtdb, node, search->zonecut_sigheader,
- search->now, isc_rwlocktype_read,
- sigrdataset DNS__DB_FLARG_PASS);
+ dns__qpdb_bindrdataset(search->qpdb, node,
+ search->zonecut_sigheader,
+ search->now, isc_rwlocktype_read,
+ sigrdataset DNS__DB_FLARG_PASS);
}
- NODE_UNLOCK(&(search->rbtdb->node_locks[node->locknum].lock),
+ NODE_UNLOCK(&(search->qpdb->node_locks[node->locknum].lock),
&nlocktype);
}
static bool
check_stale_header(dns_rbtnode_t *node, dns_slabheader_t *header,
isc_rwlocktype_t *nlocktypep, isc_rwlock_t *lock,
- rbtdb_search_t *search, dns_slabheader_t **header_prev) {
+ qpdb_search_t *search, dns_slabheader_t **header_prev) {
if (!ACTIVE(header, search->now)) {
- dns_ttl_t stale = header->ttl +
- STALE_TTL(header, search->rbtdb);
+ dns_ttl_t stale = header->ttl + STALE_TTL(header, search->qpdb);
/*
* If this data is in the stale window keep it and if
* DNS_DBFIND_STALEOK is not set we tell the caller to
*/
DNS_SLABHEADER_CLRATTR(header, DNS_SLABHEADERATTR_STALE_WINDOW);
- if (!ZEROTTL(header) && KEEPSTALE(search->rbtdb) &&
+ if (!ZEROTTL(header) && KEEPSTALE(search->qpdb) &&
stale > search->now)
{
- dns__rbtdb_mark(header, DNS_SLABHEADERATTR_STALE);
+ dns__qpdb_mark(header, DNS_SLABHEADERATTR_STALE);
*header_prev = header;
/*
* If DNS_DBFIND_STALESTART is set then it means we
search->now <
(atomic_load_acquire(
&header->last_refresh_fail_ts) +
- search->rbtdb->serve_stale_refresh))
+ search->qpdb->serve_stale_refresh))
{
/*
* If we are within interval between last
* it as ancient, and the node as dirty, so it will get
* cleaned up later.
*/
- if ((header->ttl < search->now - RBTDB_VIRTUAL) &&
+ if ((header->ttl < search->now - QPDB_VIRTUAL) &&
(*nlocktypep == isc_rwlocktype_write ||
NODE_TRYUPGRADE(lock, nlocktypep) == ISC_R_SUCCESS))
{
/*
* header->down can be non-NULL if the
* refcount has just decremented to 0
- * but dns__rbtdb_decref() has not
+ * but dns__qpdb_decref() has not
* performed clean_cache_node(), in
* which case we need to purge the stale
* headers first.
}
dns_slabheader_destroy(&header);
} else {
- dns__rbtdb_mark(header,
- DNS_SLABHEADERATTR_ANCIENT);
- RBTDB_HEADERNODE(header)->dirty = 1;
+ dns__qpdb_mark(header,
+ DNS_SLABHEADERATTR_ANCIENT);
+ QPDB_HEADERNODE(header)->dirty = 1;
*header_prev = header;
}
} else {
static isc_result_t
cache_zonecut_callback(dns_rbtnode_t *node, dns_name_t *name,
void *arg DNS__DB_FLARG) {
- rbtdb_search_t *search = arg;
+ qpdb_search_t *search = arg;
dns_slabheader_t *header = NULL;
dns_slabheader_t *header_prev = NULL, *header_next = NULL;
dns_slabheader_t *dname_header = NULL, *sigdname_header = NULL;
*/
UNUSED(name);
- lock = &(search->rbtdb->node_locks[node->locknum].lock);
+ lock = &(search->qpdb->node_locks[node->locknum].lock);
NODE_RDLOCK(lock, &nlocktype);
/*
* We increment the reference count on node to ensure that
* search->zonecut_header will still be valid later.
*/
- dns__rbtdb_newref(search->rbtdb, node,
- nlocktype DNS__DB_FLARG_PASS);
+ dns__qpdb_newref(search->qpdb, node,
+ nlocktype DNS__DB_FLARG_PASS);
search->zonecut = node;
search->zonecut_header = dname_header;
search->zonecut_sigheader = sigdname_header;
}
static isc_result_t
-find_deepest_zonecut(rbtdb_search_t *search, dns_rbtnode_t *node,
+find_deepest_zonecut(qpdb_search_t *search, dns_rbtnode_t *node,
dns_dbnode_t **nodep, dns_name_t *foundname,
dns_rdataset_t *rdataset,
dns_rdataset_t *sigrdataset DNS__DB_FLARG) {
unsigned int i;
isc_result_t result = ISC_R_NOTFOUND;
dns_name_t name;
- dns_rbtdb_t *rbtdb = NULL;
+ dns_qpdb_t *qpdb = NULL;
bool done;
/*
* Caller must be holding the tree lock.
*/
- rbtdb = search->rbtdb;
+ qpdb = search->qpdb;
i = search->chain.level_matches;
done = false;
do {
dns_slabheader_t *header = NULL;
dns_slabheader_t *header_prev = NULL, *header_next = NULL;
dns_slabheader_t *found = NULL, *foundsig = NULL;
- isc_rwlock_t *lock = &rbtdb->node_locks[node->locknum].lock;
+ isc_rwlock_t *lock = &qpdb->node_locks[node->locknum].lock;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
NODE_RDLOCK(lock, &nlocktype);
}
result = DNS_R_DELEGATION;
if (nodep != NULL) {
- dns__rbtdb_newref(search->rbtdb, node,
- nlocktype DNS__DB_FLARG_PASS);
+ dns__qpdb_newref(search->qpdb, node,
+ nlocktype DNS__DB_FLARG_PASS);
*nodep = node;
}
- dns__rbtdb_bindrdataset(search->rbtdb, node, found,
- search->now, nlocktype,
- rdataset DNS__DB_FLARG_PASS);
+ dns__qpdb_bindrdataset(search->qpdb, node, found,
+ search->now, nlocktype,
+ rdataset DNS__DB_FLARG_PASS);
if (foundsig != NULL) {
- dns__rbtdb_bindrdataset(
- search->rbtdb, node, foundsig,
+ dns__qpdb_bindrdataset(
+ search->qpdb, node, foundsig,
search->now, nlocktype,
sigrdataset DNS__DB_FLARG_PASS);
}
POST(nlocktype);
}
if (need_headerupdate(found, search->now)) {
- update_header(search->rbtdb, found,
+ update_header(search->qpdb, found,
search->now);
}
if (foundsig != NULL &&
need_headerupdate(foundsig, search->now))
{
- update_header(search->rbtdb, foundsig,
+ update_header(search->qpdb, foundsig,
search->now);
}
}
* Otherwise, return ISC_R_NOTFOUND.
*/
static isc_result_t
-find_coveringnsec(rbtdb_search_t *search, const dns_name_t *name,
+find_coveringnsec(qpdb_search_t *search, const dns_name_t *name,
dns_dbnode_t **nodep, isc_stdtime_t now,
dns_name_t *foundname, dns_rdataset_t *rdataset,
dns_rdataset_t *sigrdataset DNS__DB_FLARG) {
*/
dns_rbtnodechain_init(&chain);
target = dns_fixedname_initname(&ftarget);
- result = dns_rbt_findnode(search->rbtdb->nsec, name, target, &node,
+ result = dns_rbt_findnode(search->qpdb->nsec, name, target, &node,
&chain, DNS_RBTFIND_EMPTYDATA, NULL, NULL);
if (result != DNS_R_PARTIALMATCH) {
dns_rbtnodechain_reset(&chain);
* Lookup the predecessor in the main tree.
*/
node = NULL;
- result = dns_rbt_findnode(search->rbtdb->tree, target, fname, &node,
+ result = dns_rbt_findnode(search->qpdb->tree, target, fname, &node,
NULL, DNS_RBTFIND_EMPTYDATA, NULL, NULL);
if (result != ISC_R_SUCCESS) {
return (ISC_R_NOTFOUND);
}
- lock = &(search->rbtdb->node_locks[node->locknum].lock);
+ lock = &(search->qpdb->node_locks[node->locknum].lock);
NODE_RDLOCK(lock, &nlocktype);
for (header = node->data; header != NULL; header = header_next) {
header_next = header->next;
header_prev = header;
}
if (found != NULL) {
- dns__rbtdb_bindrdataset(search->rbtdb, node, found, now,
- nlocktype, rdataset DNS__DB_FLARG_PASS);
+ dns__qpdb_bindrdataset(search->qpdb, node, found, now,
+ nlocktype, rdataset DNS__DB_FLARG_PASS);
if (foundsig != NULL) {
- dns__rbtdb_bindrdataset(search->rbtdb, node, foundsig,
- now, nlocktype,
- sigrdataset DNS__DB_FLARG_PASS);
+ dns__qpdb_bindrdataset(search->qpdb, node, foundsig,
+ now, nlocktype,
+ sigrdataset DNS__DB_FLARG_PASS);
}
- dns__rbtdb_newref(search->rbtdb, node,
- nlocktype DNS__DB_FLARG_PASS);
+ dns__qpdb_newref(search->qpdb, node,
+ nlocktype DNS__DB_FLARG_PASS);
dns_name_copy(fname, foundname);
dns_rdataset_t *sigrdataset DNS__DB_FLARG) {
dns_rbtnode_t *node = NULL;
isc_result_t result;
- rbtdb_search_t search;
+ qpdb_search_t search;
bool cname_ok = true;
bool found_noqname = false;
bool all_negative = true;
UNUSED(version);
- REQUIRE(VALID_RBTDB((dns_rbtdb_t *)db));
+ REQUIRE(VALID_QPDB((dns_qpdb_t *)db));
REQUIRE(version == NULL);
if (now == 0) {
now = isc_stdtime_now();
}
- search = (rbtdb_search_t){
- .rbtdb = (dns_rbtdb_t *)db,
+ search = (qpdb_search_t){
+ .qpdb = (dns_qpdb_t *)db,
.serial = 1,
.options = options,
.now = now,
dns_fixedname_init(&search.zonecut_name);
dns_rbtnodechain_init(&search.chain);
- TREE_RDLOCK(&search.rbtdb->tree_lock, &tlocktype);
+ TREE_RDLOCK(&search.qpdb->tree_lock, &tlocktype);
/*
* Search down from the root of the tree. If, while going down, we
* encounter a callback node, cache_zonecut_callback() will search the
* rdatasets at the zone cut for a DNAME rdataset.
*/
- result = dns_rbt_findnode(search.rbtdb->tree, name, foundname, &node,
+ result = dns_rbt_findnode(search.qpdb->tree, name, foundname, &node,
&search.chain, DNS_RBTFIND_EMPTYDATA,
cache_zonecut_callback, &search);
* We now go looking for rdata...
*/
- lock = &(search.rbtdb->node_locks[node->locknum].lock);
+ lock = &(search.qpdb->node_locks[node->locknum].lock);
NODE_RDLOCK(lock, &nlocktype);
/*
nsecheader != NULL)
{
if (nodep != NULL) {
- dns__rbtdb_newref(search.rbtdb, node,
- nlocktype DNS__DB_FLARG_PASS);
+ dns__qpdb_newref(search.qpdb, node,
+ nlocktype DNS__DB_FLARG_PASS);
*nodep = node;
}
- dns__rbtdb_bindrdataset(search.rbtdb, node, nsecheader,
- search.now, nlocktype,
- rdataset DNS__DB_FLARG_PASS);
+ dns__qpdb_bindrdataset(search.qpdb, node, nsecheader,
+ search.now, nlocktype,
+ rdataset DNS__DB_FLARG_PASS);
if (need_headerupdate(nsecheader, search.now)) {
update = nsecheader;
}
if (nsecsig != NULL) {
- dns__rbtdb_bindrdataset(
- search.rbtdb, node, nsecsig, search.now,
+ dns__qpdb_bindrdataset(
+ search.qpdb, node, nsecsig, search.now,
nlocktype,
sigrdataset DNS__DB_FLARG_PASS);
if (need_headerupdate(nsecsig, search.now)) {
*/
if (nsheader != NULL) {
if (nodep != NULL) {
- dns__rbtdb_newref(search.rbtdb, node,
- nlocktype DNS__DB_FLARG_PASS);
+ dns__qpdb_newref(search.qpdb, node,
+ nlocktype DNS__DB_FLARG_PASS);
*nodep = node;
}
- dns__rbtdb_bindrdataset(search.rbtdb, node, nsheader,
- search.now, nlocktype,
- rdataset DNS__DB_FLARG_PASS);
+ dns__qpdb_bindrdataset(search.qpdb, node, nsheader,
+ search.now, nlocktype,
+ rdataset DNS__DB_FLARG_PASS);
if (need_headerupdate(nsheader, search.now)) {
update = nsheader;
}
if (nssig != NULL) {
- dns__rbtdb_bindrdataset(
- search.rbtdb, node, nssig, search.now,
+ dns__qpdb_bindrdataset(
+ search.qpdb, node, nssig, search.now,
nlocktype,
sigrdataset DNS__DB_FLARG_PASS);
if (need_headerupdate(nssig, search.now)) {
*/
if (nodep != NULL) {
- dns__rbtdb_newref(search.rbtdb, node,
- nlocktype DNS__DB_FLARG_PASS);
+ dns__qpdb_newref(search.qpdb, node,
+ nlocktype DNS__DB_FLARG_PASS);
*nodep = node;
}
if (type != dns_rdatatype_any || result == DNS_R_NCACHENXDOMAIN ||
result == DNS_R_NCACHENXRRSET)
{
- dns__rbtdb_bindrdataset(search.rbtdb, node, found, search.now,
- nlocktype, rdataset DNS__DB_FLARG_PASS);
+ dns__qpdb_bindrdataset(search.qpdb, node, found, search.now,
+ nlocktype, rdataset DNS__DB_FLARG_PASS);
if (need_headerupdate(found, search.now)) {
update = found;
}
if (!NEGATIVE(found) && foundsig != NULL) {
- dns__rbtdb_bindrdataset(search.rbtdb, node, foundsig,
- search.now, nlocktype,
- sigrdataset DNS__DB_FLARG_PASS);
+ dns__qpdb_bindrdataset(search.qpdb, node, foundsig,
+ search.now, nlocktype,
+ sigrdataset DNS__DB_FLARG_PASS);
if (need_headerupdate(foundsig, search.now)) {
updatesig = foundsig;
}
POST(nlocktype);
}
if (update != NULL && need_headerupdate(update, search.now)) {
- update_header(search.rbtdb, update, search.now);
+ update_header(search.qpdb, update, search.now);
}
if (updatesig != NULL && need_headerupdate(updatesig, search.now)) {
- update_header(search.rbtdb, updatesig, search.now);
+ update_header(search.qpdb, updatesig, search.now);
}
NODE_UNLOCK(lock, &nlocktype);
tree_exit:
- TREE_UNLOCK(&search.rbtdb->tree_lock, &tlocktype);
+ TREE_UNLOCK(&search.qpdb->tree_lock, &tlocktype);
/*
* If we found a zonecut but aren't going to use it, we have to
if (search.need_cleanup) {
node = search.zonecut;
INSIST(node != NULL);
- lock = &(search.rbtdb->node_locks[node->locknum].lock);
+ lock = &(search.qpdb->node_locks[node->locknum].lock);
NODE_RDLOCK(lock, &nlocktype);
- dns__rbtdb_decref(search.rbtdb, node, 0, &nlocktype, &tlocktype,
- true, false DNS__DB_FLARG_PASS);
+ dns__qpdb_decref(search.qpdb, node, 0, &nlocktype, &tlocktype,
+ true, false DNS__DB_FLARG_PASS);
NODE_UNLOCK(lock, &nlocktype);
INSIST(tlocktype == isc_rwlocktype_none);
}
dns_rbtnodechain_reset(&search.chain);
- update_cachestats(search.rbtdb, result);
+ update_cachestats(search.qpdb, result);
return (result);
}
dns_rbtnode_t *node = NULL;
isc_rwlock_t *lock = NULL;
isc_result_t result;
- rbtdb_search_t search;
+ qpdb_search_t search;
dns_slabheader_t *header = NULL;
dns_slabheader_t *header_prev = NULL, *header_next = NULL;
dns_slabheader_t *found = NULL, *foundsig = NULL;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
bool dcnull = (dcname == NULL);
- REQUIRE(VALID_RBTDB((dns_rbtdb_t *)db));
+ REQUIRE(VALID_QPDB((dns_qpdb_t *)db));
if (now == 0) {
now = isc_stdtime_now();
}
- search = (rbtdb_search_t){
- .rbtdb = (dns_rbtdb_t *)db,
+ search = (qpdb_search_t){
+ .qpdb = (dns_qpdb_t *)db,
.serial = 1,
.options = options,
.now = now,
rbtoptions |= DNS_RBTFIND_NOEXACT;
}
- TREE_RDLOCK(&search.rbtdb->tree_lock, &tlocktype);
+ TREE_RDLOCK(&search.qpdb->tree_lock, &tlocktype);
/*
* Search down from the root of the tree.
*/
- result = dns_rbt_findnode(search.rbtdb->tree, name, dcname, &node,
+ result = dns_rbt_findnode(search.qpdb->tree, name, dcname, &node,
&search.chain, rbtoptions, NULL, &search);
if (result == DNS_R_PARTIALMATCH) {
* We now go looking for an NS rdataset at the node.
*/
- lock = &(search.rbtdb->node_locks[node->locknum].lock);
+ lock = &(search.qpdb->node_locks[node->locknum].lock);
NODE_RDLOCK(lock, &nlocktype);
for (header = node->data; header != NULL; header = header_next) {
}
if (nodep != NULL) {
- dns__rbtdb_newref(search.rbtdb, node,
- nlocktype DNS__DB_FLARG_PASS);
+ dns__qpdb_newref(search.qpdb, node,
+ nlocktype DNS__DB_FLARG_PASS);
*nodep = node;
}
- dns__rbtdb_bindrdataset(search.rbtdb, node, found, search.now,
- nlocktype, rdataset DNS__DB_FLARG_PASS);
+ dns__qpdb_bindrdataset(search.qpdb, node, found, search.now, nlocktype,
+ rdataset DNS__DB_FLARG_PASS);
if (foundsig != NULL) {
- dns__rbtdb_bindrdataset(search.rbtdb, node, foundsig,
- search.now, nlocktype,
- sigrdataset DNS__DB_FLARG_PASS);
+ dns__qpdb_bindrdataset(search.qpdb, node, foundsig, search.now,
+ nlocktype,
+ sigrdataset DNS__DB_FLARG_PASS);
}
if (need_headerupdate(found, search.now) ||
POST(nlocktype);
}
if (need_headerupdate(found, search.now)) {
- update_header(search.rbtdb, found, search.now);
+ update_header(search.qpdb, found, search.now);
}
if (foundsig != NULL && need_headerupdate(foundsig, search.now))
{
- update_header(search.rbtdb, foundsig, search.now);
+ update_header(search.qpdb, foundsig, search.now);
}
}
NODE_UNLOCK(lock, &nlocktype);
tree_exit:
- TREE_UNLOCK(&search.rbtdb->tree_lock, &tlocktype);
+ TREE_UNLOCK(&search.qpdb->tree_lock, &tlocktype);
INSIST(!search.need_cleanup);
dns_rdatatype_t type, dns_rdatatype_t covers,
isc_stdtime_t now, dns_rdataset_t *rdataset,
dns_rdataset_t *sigrdataset DNS__DB_FLARG) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node;
dns_slabheader_t *header = NULL, *header_next = NULL;
dns_slabheader_t *found = NULL, *foundsig = NULL;
isc_rwlock_t *lock = NULL;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
- REQUIRE(VALID_RBTDB(rbtdb));
+ REQUIRE(VALID_QPDB(qpdb));
REQUIRE(type != dns_rdatatype_any);
UNUSED(version);
now = isc_stdtime_now();
}
- lock = &rbtdb->node_locks[rbtnode->locknum].lock;
+ lock = &qpdb->node_locks[rbtnode->locknum].lock;
NODE_RDLOCK(lock, &nlocktype);
matchtype = DNS_TYPEPAIR_VALUE(type, covers);
for (header = rbtnode->data; header != NULL; header = header_next) {
header_next = header->next;
if (!ACTIVE(header, now)) {
- if ((header->ttl + STALE_TTL(header, rbtdb) <
- now - RBTDB_VIRTUAL) &&
+ if ((header->ttl + STALE_TTL(header, qpdb) <
+ now - QPDB_VIRTUAL) &&
(nlocktype == isc_rwlocktype_write ||
NODE_TRYUPGRADE(lock, &nlocktype) ==
ISC_R_SUCCESS))
* non-zero. This is so because 'node' is an
* argument to the function.
*/
- dns__rbtdb_mark(header,
- DNS_SLABHEADERATTR_ANCIENT);
- RBTDB_HEADERNODE(header)->dirty = 1;
+ dns__qpdb_mark(header,
+ DNS_SLABHEADERATTR_ANCIENT);
+ QPDB_HEADERNODE(header)->dirty = 1;
}
} else if (EXISTS(header) && !ANCIENT(header)) {
if (header->type == matchtype) {
}
}
if (found != NULL) {
- dns__rbtdb_bindrdataset(rbtdb, rbtnode, found, now, nlocktype,
- rdataset DNS__DB_FLARG_PASS);
+ dns__qpdb_bindrdataset(qpdb, rbtnode, found, now, nlocktype,
+ rdataset DNS__DB_FLARG_PASS);
if (!NEGATIVE(found) && foundsig != NULL) {
- dns__rbtdb_bindrdataset(rbtdb, rbtnode, foundsig, now,
- nlocktype,
- sigrdataset DNS__DB_FLARG_PASS);
+ dns__qpdb_bindrdataset(qpdb, rbtnode, foundsig, now,
+ nlocktype,
+ sigrdataset DNS__DB_FLARG_PASS);
}
}
}
}
- update_cachestats(rbtdb, result);
+ update_cachestats(qpdb, result);
return (result);
}
static size_t
hashsize(dns_db_t *db) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
size_t size;
isc_rwlocktype_t tlocktype = isc_rwlocktype_none;
- REQUIRE(VALID_RBTDB(rbtdb));
+ REQUIRE(VALID_QPDB(qpdb));
- TREE_RDLOCK(&rbtdb->tree_lock, &tlocktype);
- size = dns_rbt_hashsize(rbtdb->tree);
- TREE_UNLOCK(&rbtdb->tree_lock, &tlocktype);
+ TREE_RDLOCK(&qpdb->tree_lock, &tlocktype);
+ size = dns_rbt_hashsize(qpdb->tree);
+ TREE_UNLOCK(&qpdb->tree_lock, &tlocktype);
return (size);
}
static isc_result_t
setcachestats(dns_db_t *db, isc_stats_t *stats) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
- REQUIRE(VALID_RBTDB(rbtdb));
- REQUIRE(IS_CACHE(rbtdb)); /* current restriction */
+ REQUIRE(VALID_QPDB(qpdb));
+ REQUIRE(IS_CACHE(qpdb)); /* current restriction */
REQUIRE(stats != NULL);
- isc_stats_attach(stats, &rbtdb->cachestats);
+ isc_stats_attach(stats, &qpdb->cachestats);
return (ISC_R_SUCCESS);
}
static dns_stats_t *
getrrsetstats(dns_db_t *db) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
- REQUIRE(VALID_RBTDB(rbtdb));
- REQUIRE(IS_CACHE(rbtdb)); /* current restriction */
+ REQUIRE(VALID_QPDB(qpdb));
+ REQUIRE(IS_CACHE(qpdb)); /* current restriction */
- return (rbtdb->rrsetstats);
+ return (qpdb->rrsetstats);
}
static isc_result_t
setservestalettl(dns_db_t *db, dns_ttl_t ttl) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
- REQUIRE(VALID_RBTDB(rbtdb));
- REQUIRE(IS_CACHE(rbtdb));
+ REQUIRE(VALID_QPDB(qpdb));
+ REQUIRE(IS_CACHE(qpdb));
/* currently no bounds checking. 0 means disable. */
- rbtdb->common.serve_stale_ttl = ttl;
+ qpdb->common.serve_stale_ttl = ttl;
return (ISC_R_SUCCESS);
}
static isc_result_t
getservestalettl(dns_db_t *db, dns_ttl_t *ttl) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
- REQUIRE(VALID_RBTDB(rbtdb));
- REQUIRE(IS_CACHE(rbtdb));
+ REQUIRE(VALID_QPDB(qpdb));
+ REQUIRE(IS_CACHE(qpdb));
- *ttl = rbtdb->common.serve_stale_ttl;
+ *ttl = qpdb->common.serve_stale_ttl;
return (ISC_R_SUCCESS);
}
static isc_result_t
setservestalerefresh(dns_db_t *db, uint32_t interval) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
- REQUIRE(VALID_RBTDB(rbtdb));
- REQUIRE(IS_CACHE(rbtdb));
+ REQUIRE(VALID_QPDB(qpdb));
+ REQUIRE(IS_CACHE(qpdb));
/* currently no bounds checking. 0 means disable. */
- rbtdb->serve_stale_refresh = interval;
+ qpdb->serve_stale_refresh = interval;
return (ISC_R_SUCCESS);
}
static isc_result_t
getservestalerefresh(dns_db_t *db, uint32_t *interval) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
- REQUIRE(VALID_RBTDB(rbtdb));
- REQUIRE(IS_CACHE(rbtdb));
+ REQUIRE(VALID_QPDB(qpdb));
+ REQUIRE(IS_CACHE(qpdb));
- *interval = rbtdb->serve_stale_refresh;
+ *interval = qpdb->serve_stale_refresh;
return (ISC_R_SUCCESS);
}
static void
expiredata(dns_db_t *db, dns_dbnode_t *node, void *data) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node;
dns_slabheader_t *header = data;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
isc_rwlocktype_t tlocktype = isc_rwlocktype_none;
- NODE_WRLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype);
- dns__cacherbt_expireheader(header, &tlocktype,
- dns_expire_flush DNS__DB_FLARG_PASS);
- NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype);
+ NODE_WRLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype);
+ dns__qpcache_expireheader(header, &tlocktype,
+ dns_expire_flush DNS__DB_FLARG_PASS);
+ NODE_UNLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype);
INSIST(tlocktype == isc_rwlocktype_none);
}
-dns_dbmethods_t dns__rbtdb_cachemethods = {
- .destroy = dns__rbtdb_destroy,
- .currentversion = dns__rbtdb_currentversion,
- .newversion = dns__rbtdb_newversion,
- .attachversion = dns__rbtdb_attachversion,
- .closeversion = dns__rbtdb_closeversion,
- .findnode = dns__rbtdb_findnode,
+dns_dbmethods_t dns__qpdb_cachemethods = {
+ .destroy = dns__qpdb_destroy,
+ .currentversion = dns__qpdb_currentversion,
+ .newversion = dns__qpdb_newversion,
+ .attachversion = dns__qpdb_attachversion,
+ .closeversion = dns__qpdb_closeversion,
+ .findnode = dns__qpdb_findnode,
.find = cache_find,
.findzonecut = cache_findzonecut,
- .attachnode = dns__rbtdb_attachnode,
- .detachnode = dns__rbtdb_detachnode,
- .createiterator = dns__rbtdb_createiterator,
+ .attachnode = dns__qpdb_attachnode,
+ .detachnode = dns__qpdb_detachnode,
+ .createiterator = dns__qpdb_createiterator,
.findrdataset = cache_findrdataset,
- .allrdatasets = dns__rbtdb_allrdatasets,
- .addrdataset = dns__rbtdb_addrdataset,
- .subtractrdataset = dns__rbtdb_subtractrdataset,
- .deleterdataset = dns__rbtdb_deleterdataset,
- .nodecount = dns__rbtdb_nodecount,
- .setloop = dns__rbtdb_setloop,
- .getoriginnode = dns__rbtdb_getoriginnode,
+ .allrdatasets = dns__qpdb_allrdatasets,
+ .addrdataset = dns__qpdb_addrdataset,
+ .subtractrdataset = dns__qpdb_subtractrdataset,
+ .deleterdataset = dns__qpdb_deleterdataset,
+ .nodecount = dns__qpdb_nodecount,
+ .setloop = dns__qpdb_setloop,
+ .getoriginnode = dns__qpdb_getoriginnode,
.getrrsetstats = getrrsetstats,
.setcachestats = setcachestats,
.hashsize = hashsize,
.getservestalettl = getservestalettl,
.setservestalerefresh = setservestalerefresh,
.getservestalerefresh = getservestalerefresh,
- .locknode = dns__rbtdb_locknode,
- .unlocknode = dns__rbtdb_unlocknode,
+ .locknode = dns__qpdb_locknode,
+ .unlocknode = dns__qpdb_unlocknode,
.expiredata = expiredata,
- .deletedata = dns__rbtdb_deletedata,
+ .deletedata = dns__qpdb_deletedata,
};
/*
* Caller must hold the node (write) lock.
*/
void
-dns__cacherbt_expireheader(dns_slabheader_t *header,
- isc_rwlocktype_t *tlocktypep,
- dns_expire_t reason DNS__DB_FLARG) {
- dns__rbtdb_setttl(header, 0);
- dns__rbtdb_mark(header, DNS_SLABHEADERATTR_ANCIENT);
- RBTDB_HEADERNODE(header)->dirty = 1;
-
- if (isc_refcount_current(&RBTDB_HEADERNODE(header)->references) == 0) {
+dns__qpcache_expireheader(dns_slabheader_t *header,
+ isc_rwlocktype_t *tlocktypep,
+ dns_expire_t reason DNS__DB_FLARG) {
+ dns__qpdb_setttl(header, 0);
+ dns__qpdb_mark(header, DNS_SLABHEADERATTR_ANCIENT);
+ QPDB_HEADERNODE(header)->dirty = 1;
+
+ if (isc_refcount_current(&QPDB_HEADERNODE(header)->references) == 0) {
isc_rwlocktype_t nlocktype = isc_rwlocktype_write;
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)header->db;
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)header->db;
/*
* If no one else is using the node, we can clean it up now.
* We first need to gain a new reference to the node to meet a
- * requirement of dns__rbtdb_decref().
+ * requirement of dns__qpdb_decref().
*/
- dns__rbtdb_newref(rbtdb, RBTDB_HEADERNODE(header),
- nlocktype DNS__DB_FLARG_PASS);
- dns__rbtdb_decref(rbtdb, RBTDB_HEADERNODE(header), 0,
- &nlocktype, tlocktypep, true,
- false DNS__DB_FLARG_PASS);
+ dns__qpdb_newref(qpdb, QPDB_HEADERNODE(header),
+ nlocktype DNS__DB_FLARG_PASS);
+ dns__qpdb_decref(qpdb, QPDB_HEADERNODE(header), 0, &nlocktype,
+ tlocktypep, true, false DNS__DB_FLARG_PASS);
- if (rbtdb->cachestats == NULL) {
+ if (qpdb->cachestats == NULL) {
return;
}
switch (reason) {
case dns_expire_ttl:
- isc_stats_increment(rbtdb->cachestats,
+ isc_stats_increment(qpdb->cachestats,
dns_cachestatscounter_deletettl);
break;
case dns_expire_lru:
- isc_stats_increment(rbtdb->cachestats,
+ isc_stats_increment(qpdb->cachestats,
dns_cachestatscounter_deletelru);
break;
default:
}
static size_t
-expire_lru_headers(dns_rbtdb_t *rbtdb, unsigned int locknum,
+expire_lru_headers(dns_qpdb_t *qpdb, unsigned int locknum,
isc_rwlocktype_t *tlocktypep,
size_t purgesize DNS__DB_FLARG) {
dns_slabheader_t *header = NULL;
size_t purged = 0;
- for (header = ISC_LIST_TAIL(rbtdb->lru[locknum]);
- header != NULL && header->last_used <= rbtdb->last_used &&
+ for (header = ISC_LIST_TAIL(qpdb->lru[locknum]);
+ header != NULL && header->last_used <= qpdb->last_used &&
purged <= purgesize;
- header = ISC_LIST_TAIL(rbtdb->lru[locknum]))
+ header = ISC_LIST_TAIL(qpdb->lru[locknum]))
{
size_t header_size = rdataset_size(header);
* referenced any more (so unlinking is safe) since the
* TTL will be reset to 0.
*/
- ISC_LIST_UNLINK(rbtdb->lru[locknum], header, link);
- dns__cacherbt_expireheader(header, tlocktypep,
- dns_expire_lru DNS__DB_FLARG_PASS);
+ ISC_LIST_UNLINK(qpdb->lru[locknum], header, link);
+ dns__qpcache_expireheader(header, tlocktypep,
+ dns_expire_lru DNS__DB_FLARG_PASS);
purged += header_size;
}
* A write lock on the tree must be held.
*/
void
-dns__cacherbt_overmem(dns_rbtdb_t *rbtdb, dns_slabheader_t *newheader,
- isc_rwlocktype_t *tlocktypep DNS__DB_FLARG) {
- uint32_t locknum_start = rbtdb->lru_sweep++ % rbtdb->node_lock_count;
+dns__qpcache_overmem(dns_qpdb_t *qpdb, dns_slabheader_t *newheader,
+ isc_rwlocktype_t *tlocktypep DNS__DB_FLARG) {
+ uint32_t locknum_start = qpdb->lru_sweep++ % qpdb->node_lock_count;
uint32_t locknum = locknum_start;
/* Size of added data, possible node and possible ENT node. */
- size_t purgesize =
- rdataset_size(newheader) +
- 2 * dns__rbtnode_getsize(RBTDB_HEADERNODE(newheader));
+ size_t purgesize = rdataset_size(newheader) +
+ 2 * dns__rbtnode_getsize(QPDB_HEADERNODE(newheader));
size_t purged = 0;
isc_stdtime_t min_last_used = 0;
size_t max_passes = 8;
again:
do {
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
- NODE_WRLOCK(&rbtdb->node_locks[locknum].lock, &nlocktype);
+ NODE_WRLOCK(&qpdb->node_locks[locknum].lock, &nlocktype);
- purged += expire_lru_headers(rbtdb, locknum, tlocktypep,
+ purged += expire_lru_headers(qpdb, locknum, tlocktypep,
purgesize -
purged DNS__DB_FLARG_PASS);
* Work out the oldest remaining last_used values of the list
* tails as we walk across the array of lru lists.
*/
- dns_slabheader_t *header = ISC_LIST_TAIL(rbtdb->lru[locknum]);
+ dns_slabheader_t *header = ISC_LIST_TAIL(qpdb->lru[locknum]);
if (header != NULL &&
(min_last_used == 0 || header->last_used < min_last_used))
{
min_last_used = header->last_used;
}
- NODE_UNLOCK(&rbtdb->node_locks[locknum].lock, &nlocktype);
- locknum = (locknum + 1) % rbtdb->node_lock_count;
+ NODE_UNLOCK(&qpdb->node_locks[locknum].lock, &nlocktype);
+ locknum = (locknum + 1) % qpdb->node_lock_count;
} while (locknum != locknum_start && purged <= purgesize);
/*
- * Update rbtdb->last_used if we have walked all the list tails and have
+ * Update qpdb->last_used if we have walked all the list tails and have
* not freed the required amount of memory.
*/
if (purged < purgesize) {
if (min_last_used != 0) {
- rbtdb->last_used = min_last_used;
+ qpdb->last_used = min_last_used;
if (max_passes-- > 0) {
goto again;
}
((atomic_load_acquire(&(header)->attributes) & \
DNS_SLABHEADERATTR_ANCIENT) != 0)
-#define RBTDB_ATTR_LOADED 0x01
-#define RBTDB_ATTR_LOADING 0x02
+#define QPDB_ATTR_LOADED 0x01
+#define QPDB_ATTR_LOADING 0x02
static isc_result_t
findnsec3node(dns_db_t *db, const dns_name_t *name, bool create,
dns_dbnode_t **nodep DNS__DB_FLARG) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
- REQUIRE(VALID_RBTDB(rbtdb));
+ REQUIRE(VALID_QPDB(qpdb));
- return (dns__rbtdb_findnodeintree(rbtdb, rbtdb->nsec3, name, create,
- nodep DNS__DB_FLARG_PASS));
+ return (dns__qpdb_findnodeintree(qpdb, qpdb->nsec3, name, create,
+ nodep DNS__DB_FLARG_PASS));
}
static isc_result_t
zone_zonecut_callback(dns_rbtnode_t *node, dns_name_t *name,
void *arg DNS__DB_FLARG) {
- rbtdb_search_t *search = arg;
+ qpdb_search_t *search = arg;
dns_slabheader_t *header = NULL, *header_next = NULL;
dns_slabheader_t *dname_header = NULL, *sigdname_header = NULL;
dns_slabheader_t *ns_header = NULL;
return (result);
}
- onode = search->rbtdb->origin_node;
+ onode = search->qpdb->origin_node;
- NODE_RDLOCK(&(search->rbtdb->node_locks[node->locknum].lock),
+ NODE_RDLOCK(&(search->qpdb->node_locks[node->locknum].lock),
&nlocktype);
/*
{
sigdname_header = header;
} else if (node != onode ||
- IS_STUB(search->rbtdb))
+ IS_STUB(search->qpdb))
{
/*
* We've found an NS rdataset that
/*
* Did we find anything?
*/
- if (!IS_STUB(search->rbtdb) && ns_header != NULL) {
+ if (!IS_STUB(search->qpdb) && ns_header != NULL) {
/*
* Note that NS has precedence over DNAME if both exist
* in a zone. Otherwise DNAME take precedence over NS.
* We increment the reference count on node to ensure that
* search->zonecut_header will still be valid later.
*/
- dns__rbtdb_newref(search->rbtdb, node,
- isc_rwlocktype_read DNS__DB_FLARG_PASS);
+ dns__qpdb_newref(search->qpdb, node,
+ isc_rwlocktype_read DNS__DB_FLARG_PASS);
search->zonecut = node;
search->zonecut_header = found;
search->need_cleanup = true;
}
}
- NODE_UNLOCK(&(search->rbtdb->node_locks[node->locknum].lock),
+ NODE_UNLOCK(&(search->qpdb->node_locks[node->locknum].lock),
&nlocktype);
return (result);
}
static isc_result_t
-setup_delegation(rbtdb_search_t *search, dns_dbnode_t **nodep,
+setup_delegation(qpdb_search_t *search, dns_dbnode_t **nodep,
dns_name_t *foundname, dns_rdataset_t *rdataset,
dns_rdataset_t *sigrdataset DNS__DB_FLARG) {
dns_name_t *zcname = NULL;
}
if (rdataset != NULL) {
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
- NODE_RDLOCK(&(search->rbtdb->node_locks[node->locknum].lock),
+ NODE_RDLOCK(&(search->qpdb->node_locks[node->locknum].lock),
&nlocktype);
- dns__rbtdb_bindrdataset(search->rbtdb, node,
- search->zonecut_header, search->now,
- isc_rwlocktype_read,
- rdataset DNS__DB_FLARG_PASS);
+ dns__qpdb_bindrdataset(
+ search->qpdb, node, search->zonecut_header, search->now,
+ isc_rwlocktype_read, rdataset DNS__DB_FLARG_PASS);
if (sigrdataset != NULL && search->zonecut_sigheader != NULL) {
- dns__rbtdb_bindrdataset(
- search->rbtdb, node, search->zonecut_sigheader,
- search->now, isc_rwlocktype_read,
- sigrdataset DNS__DB_FLARG_PASS);
+ dns__qpdb_bindrdataset(search->qpdb, node,
+ search->zonecut_sigheader,
+ search->now, isc_rwlocktype_read,
+ sigrdataset DNS__DB_FLARG_PASS);
}
- NODE_UNLOCK(&(search->rbtdb->node_locks[node->locknum].lock),
+ NODE_UNLOCK(&(search->qpdb->node_locks[node->locknum].lock),
&nlocktype);
}
* Return true if we found a predecessor or successor.
*/
static bool
-step(rbtdb_search_t *search, dns_rbtnodechain_t *chain, direction_t direction,
+step(qpdb_search_t *search, dns_rbtnodechain_t *chain, direction_t direction,
dns_name_t *nextname) {
dns_fixedname_t forigin;
dns_name_t *origin = NULL;
dns_name_t prefix;
- dns_rbtdb_t *rbtdb = NULL;
+ dns_qpdb_t *qpdb = NULL;
dns_rbtnode_t *node = NULL;
isc_result_t result = ISC_R_SUCCESS;
dns_slabheader_t *header = NULL;
- rbtdb = search->rbtdb;
+ qpdb = search->qpdb;
dns_name_init(&prefix, NULL);
origin = dns_fixedname_initname(&forigin);
if (result != ISC_R_SUCCESS) {
break;
}
- NODE_RDLOCK(&(rbtdb->node_locks[node->locknum].lock),
+ NODE_RDLOCK(&(qpdb->node_locks[node->locknum].lock),
&nlocktype);
for (header = node->data; header != NULL; header = header->next)
{
break;
}
}
- NODE_UNLOCK(&(rbtdb->node_locks[node->locknum].lock),
+ NODE_UNLOCK(&(qpdb->node_locks[node->locknum].lock),
&nlocktype);
if (header != NULL) {
break;
* of the database.
*/
static bool
-activeempty(rbtdb_search_t *search, dns_rbtnodechain_t *chain,
+activeempty(qpdb_search_t *search, dns_rbtnodechain_t *chain,
const dns_name_t *current) {
isc_result_t result;
dns_fixedname_t fnext;
}
static bool
-wildcard_blocked(rbtdb_search_t *search, const dns_name_t *qname,
+wildcard_blocked(qpdb_search_t *search, const dns_name_t *qname,
dns_name_t *wname) {
isc_result_t result;
dns_fixedname_t fnext;
}
static isc_result_t
-find_wildcard(rbtdb_search_t *search, dns_rbtnode_t **nodep,
+find_wildcard(qpdb_search_t *search, dns_rbtnode_t **nodep,
const dns_name_t *qname) {
unsigned int i, j;
dns_rbtnode_t *node = NULL, *level_node = NULL, *wnode = NULL;
dns_name_t name;
dns_name_t *wname = NULL;
dns_fixedname_t fwname;
- dns_rbtdb_t *rbtdb = NULL;
+ dns_qpdb_t *qpdb = NULL;
bool done, wild, active;
dns_rbtnodechain_t wchain;
* continue the search.
*/
- rbtdb = search->rbtdb;
+ qpdb = search->qpdb;
i = search->chain.level_matches;
done = false;
node = *nodep;
do {
- isc_rwlock_t *lock = &rbtdb->node_locks[node->locknum].lock;
+ isc_rwlock_t *lock = &qpdb->node_locks[node->locknum].lock;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
NODE_RDLOCK(lock, &nlocktype);
wnode = NULL;
dns_rbtnodechain_init(&wchain);
result = dns_rbt_findnode(
- rbtdb->tree, wname, NULL, &wnode, &wchain,
+ qpdb->tree, wname, NULL, &wnode, &wchain,
DNS_RBTFIND_EMPTYDATA, NULL, NULL);
if (result == ISC_R_SUCCESS) {
/*
* is active in the search's version, we're
* done.
*/
- lock = &rbtdb->node_locks[wnode->locknum].lock;
+ lock = &qpdb->node_locks[wnode->locknum].lock;
NODE_RDLOCK(lock, &nlocktype);
for (header = wnode->data; header != NULL;
header = header->next)
}
static bool
-matchparams(dns_slabheader_t *header, rbtdb_search_t *search) {
+matchparams(dns_slabheader_t *header, qpdb_search_t *search) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdata_nsec3_t nsec3;
unsigned char *raw = NULL;
raw += DNS_RDATASET_ORDER + DNS_RDATASET_LENGTH;
region.base = raw;
region.length = rdlen;
- dns_rdata_fromregion(&rdata, search->rbtdb->common.rdclass,
+ dns_rdata_fromregion(&rdata, search->qpdb->common.rdclass,
dns_rdatatype_nsec3, ®ion);
raw += rdlen;
result = dns_rdata_tostruct(&rdata, &nsec3, NULL);
* Find node of the NSEC/NSEC3 record that is 'name'.
*/
static isc_result_t
-previous_closest_nsec(dns_rdatatype_t type, rbtdb_search_t *search,
+previous_closest_nsec(dns_rdatatype_t type, qpdb_search_t *search,
dns_name_t *name, dns_name_t *origin,
dns_rbtnode_t **nodep, dns_rbtnodechain_t *nsecchain,
bool *firstp) {
}
nsecnode = NULL;
result = dns_rbt_findnode(
- search->rbtdb->nsec, target, NULL, &nsecnode,
+ search->qpdb->nsec, target, NULL, &nsecnode,
nsecchain, DNS_RBTFIND_EMPTYDATA, NULL, NULL);
if (result == ISC_R_SUCCESS) {
/*
}
*nodep = NULL;
- result = dns_rbt_findnode(search->rbtdb->tree, target, NULL,
+ result = dns_rbt_findnode(search->qpdb->tree, target, NULL,
nodep, &search->chain,
DNS_RBTFIND_EMPTYDATA, NULL, NULL);
if (result == ISC_R_SUCCESS) {
* current NSEC3PARAM record are considered.
*/
static isc_result_t
-find_closest_nsec(rbtdb_search_t *search, dns_dbnode_t **nodep,
+find_closest_nsec(qpdb_search_t *search, dns_dbnode_t **nodep,
dns_name_t *foundname, dns_rdataset_t *rdataset,
dns_rdataset_t *sigrdataset, dns_qp_t *tree,
bool secure DNS__DB_FLARG) {
bool first = true;
bool need_sig = secure;
- if (tree == search->rbtdb->nsec3) {
+ if (tree == search->qpdb->nsec3) {
type = dns_rdatatype_nsec3;
sigtype = DNS_SIGTYPE(dns_rdatatype_nsec3);
wraps = true;
do {
dns_slabheader_t *found = NULL, *foundsig = NULL;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
- NODE_RDLOCK(&(search->rbtdb->node_locks[node->locknum].lock),
+ NODE_RDLOCK(&(search->qpdb->node_locks[node->locknum].lock),
&nlocktype);
empty_node = true;
for (header = node->data; header != NULL; header = header_next)
foundname, NULL);
if (result == ISC_R_SUCCESS) {
if (nodep != NULL) {
- dns__rbtdb_newref(
- search->rbtdb, node,
+ dns__qpdb_newref(
+ search->qpdb, node,
isc_rwlocktype_read
DNS__DB_FLARG_PASS);
*nodep = node;
}
- dns__rbtdb_bindrdataset(
- search->rbtdb, node, found,
+ dns__qpdb_bindrdataset(
+ search->qpdb, node, found,
search->now,
isc_rwlocktype_read,
rdataset DNS__DB_FLARG_PASS);
if (foundsig != NULL) {
- dns__rbtdb_bindrdataset(
- search->rbtdb, node,
+ dns__qpdb_bindrdataset(
+ search->qpdb, node,
foundsig, search->now,
isc_rwlocktype_read,
sigrdataset
origin, &prevnode,
&nsecchain, &first);
}
- NODE_UNLOCK(&(search->rbtdb->node_locks[node->locknum].lock),
+ NODE_UNLOCK(&(search->qpdb->node_locks[node->locknum].lock),
&nlocktype);
node = prevnode;
prevnode = NULL;
dns_rdataset_t *sigrdataset DNS__DB_FLARG) {
dns_rbtnode_t *node = NULL;
isc_result_t result;
- rbtdb_search_t search;
+ qpdb_search_t search;
bool cname_ok = true;
bool close_version = false;
bool maybe_zonecut = false;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
isc_rwlocktype_t tlocktype = isc_rwlocktype_none;
- REQUIRE(VALID_RBTDB((dns_rbtdb_t *)db));
+ REQUIRE(VALID_QPDB((dns_qpdb_t *)db));
INSIST(version == NULL ||
- ((dns_rbtdb_version_t *)version)->rbtdb == (dns_rbtdb_t *)db);
+ ((dns_qpdb_version_t *)version)->qpdb == (dns_qpdb_t *)db);
/*
* If the caller didn't supply a version, attach to the current
* version.
*/
if (version == NULL) {
- dns__rbtdb_currentversion(db, &version);
+ dns__qpdb_currentversion(db, &version);
close_version = true;
}
- search = (rbtdb_search_t){
- .rbtdb = (dns_rbtdb_t *)db,
+ search = (qpdb_search_t){
+ .qpdb = (dns_qpdb_t *)db,
.rbtversion = version,
- .serial = ((dns_rbtdb_version_t *)version)->serial,
+ .serial = ((dns_qpdb_version_t *)version)->serial,
.options = options,
};
dns_fixedname_init(&search.zonecut_name);
dns_rbtnodechain_init(&search.chain);
- TREE_RDLOCK(&search.rbtdb->tree_lock, &tlocktype);
+ TREE_RDLOCK(&search.qpdb->tree_lock, &tlocktype);
/*
* Search down from the root of the tree. If, while going down, we
* encounter a callback node, zone_zonecut_callback() will search the
* rdatasets at the zone cut for active DNAME or NS rdatasets.
*/
- tree = (options & DNS_DBFIND_FORCENSEC3) != 0 ? search.rbtdb->nsec3
- : search.rbtdb->tree;
+ tree = (options & DNS_DBFIND_FORCENSEC3) != 0 ? search.qpdb->nsec3
+ : search.qpdb->tree;
result = dns_rbt_findnode(tree, name, foundname, &node, &search.chain,
DNS_RBTFIND_EMPTYDATA, zone_zonecut_callback,
&search);
* Stub zones don't have anything "above" the delegation so
* we always return a referral.
*/
- if (node->find_callback &&
- ((node != search.rbtdb->origin_node &&
- !dns_rdatatype_atparent(type)) ||
- IS_STUB(search.rbtdb)))
+ if (node->find_callback && ((node != search.qpdb->origin_node &&
+ !dns_rdatatype_atparent(type)) ||
+ IS_STUB(search.qpdb)))
{
maybe_zonecut = true;
}
* We now go looking for rdata...
*/
- lock = &search.rbtdb->node_locks[node->locknum].lock;
+ lock = &search.qpdb->node_locks[node->locknum].lock;
NODE_RDLOCK(lock, &nlocktype);
found = NULL;
* ensure that search->zonecut_header will
* still be valid later.
*/
- dns__rbtdb_newref(search.rbtdb, node,
- nlocktype DNS__DB_FLARG_PASS);
+ dns__qpdb_newref(search.qpdb, node,
+ nlocktype DNS__DB_FLARG_PASS);
search.zonecut = node;
search.zonecut_header = header;
search.zonecut_sigheader = NULL;
NODE_UNLOCK(lock, &nlocktype);
result = find_closest_nsec(
&search, nodep, foundname, rdataset,
- sigrdataset, search.rbtdb->tree,
+ sigrdataset, search.qpdb->tree,
search.rbtversion->secure DNS__DB_FLARG_PASS);
if (result == ISC_R_SUCCESS) {
result = DNS_R_EMPTYWILD;
goto tree_exit;
}
if (nodep != NULL) {
- dns__rbtdb_newref(search.rbtdb, node,
- nlocktype DNS__DB_FLARG_PASS);
+ dns__qpdb_newref(search.qpdb, node,
+ nlocktype DNS__DB_FLARG_PASS);
*nodep = node;
}
if ((search.rbtversion->secure &&
!search.rbtversion->havensec3))
{
- dns__rbtdb_bindrdataset(search.rbtdb, node, nsecheader,
- 0, nlocktype,
- rdataset DNS__DB_FLARG_PASS);
+ dns__qpdb_bindrdataset(search.qpdb, node, nsecheader, 0,
+ nlocktype,
+ rdataset DNS__DB_FLARG_PASS);
if (nsecsig != NULL) {
- dns__rbtdb_bindrdataset(
- search.rbtdb, node, nsecsig, 0,
+ dns__qpdb_bindrdataset(
+ search.qpdb, node, nsecsig, 0,
nlocktype,
sigrdataset DNS__DB_FLARG_PASS);
}
if (nodep != NULL) {
if (!at_zonecut) {
- dns__rbtdb_newref(search.rbtdb, node,
- nlocktype DNS__DB_FLARG_PASS);
+ dns__qpdb_newref(search.qpdb, node,
+ nlocktype DNS__DB_FLARG_PASS);
} else {
search.need_cleanup = false;
}
}
if (type != dns_rdatatype_any) {
- dns__rbtdb_bindrdataset(search.rbtdb, node, found, 0, nlocktype,
- rdataset DNS__DB_FLARG_PASS);
+ dns__qpdb_bindrdataset(search.qpdb, node, found, 0, nlocktype,
+ rdataset DNS__DB_FLARG_PASS);
if (foundsig != NULL) {
- dns__rbtdb_bindrdataset(search.rbtdb, node, foundsig, 0,
- nlocktype,
- sigrdataset DNS__DB_FLARG_PASS);
+ dns__qpdb_bindrdataset(search.qpdb, node, foundsig, 0,
+ nlocktype,
+ sigrdataset DNS__DB_FLARG_PASS);
}
}
NODE_UNLOCK(lock, &nlocktype);
tree_exit:
- TREE_UNLOCK(&search.rbtdb->tree_lock, &tlocktype);
+ TREE_UNLOCK(&search.qpdb->tree_lock, &tlocktype);
/*
* If we found a zonecut but aren't going to use it, we have to
if (search.need_cleanup) {
node = search.zonecut;
INSIST(node != NULL);
- lock = &(search.rbtdb->node_locks[node->locknum].lock);
+ lock = &(search.qpdb->node_locks[node->locknum].lock);
NODE_RDLOCK(lock, &nlocktype);
- dns__rbtdb_decref(search.rbtdb, node, 0, &nlocktype, &tlocktype,
- true, false DNS__DB_FLARG_PASS);
+ dns__qpdb_decref(search.qpdb, node, 0, &nlocktype, &tlocktype,
+ true, false DNS__DB_FLARG_PASS);
NODE_UNLOCK(lock, &nlocktype);
INSIST(tlocktype == isc_rwlocktype_none);
}
if (close_version) {
- dns__rbtdb_closeversion(db, &version, false DNS__DB_FLARG_PASS);
+ dns__qpdb_closeversion(db, &version, false DNS__DB_FLARG_PASS);
}
dns_rbtnodechain_reset(&search.chain);
dns_rdatatype_t type, dns_rdatatype_t covers,
isc_stdtime_t now, dns_rdataset_t *rdataset,
dns_rdataset_t *sigrdataset DNS__DB_FLARG) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node;
dns_slabheader_t *header = NULL, *header_next = NULL;
dns_slabheader_t *found = NULL, *foundsig = NULL;
uint32_t serial;
- dns_rbtdb_version_t *rbtversion = version;
+ dns_qpdb_version_t *rbtversion = version;
bool close_version = false;
dns_typepair_t matchtype, sigmatchtype;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
- REQUIRE(VALID_RBTDB(rbtdb));
+ REQUIRE(VALID_QPDB(qpdb));
REQUIRE(type != dns_rdatatype_any);
- INSIST(rbtversion == NULL || rbtversion->rbtdb == rbtdb);
+ INSIST(rbtversion == NULL || rbtversion->qpdb == qpdb);
if (rbtversion == NULL) {
- dns__rbtdb_currentversion(
+ dns__qpdb_currentversion(
db, (dns_dbversion_t **)(void *)(&rbtversion));
close_version = true;
}
serial = rbtversion->serial;
now = 0;
- NODE_RDLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype);
+ NODE_RDLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype);
matchtype = DNS_TYPEPAIR_VALUE(type, covers);
if (covers == 0) {
}
}
if (found != NULL) {
- dns__rbtdb_bindrdataset(rbtdb, rbtnode, found, now,
- isc_rwlocktype_read,
- rdataset DNS__DB_FLARG_PASS);
+ dns__qpdb_bindrdataset(qpdb, rbtnode, found, now,
+ isc_rwlocktype_read,
+ rdataset DNS__DB_FLARG_PASS);
if (foundsig != NULL) {
- dns__rbtdb_bindrdataset(rbtdb, rbtnode, foundsig, now,
- isc_rwlocktype_read,
- sigrdataset DNS__DB_FLARG_PASS);
+ dns__qpdb_bindrdataset(qpdb, rbtnode, foundsig, now,
+ isc_rwlocktype_read,
+ sigrdataset DNS__DB_FLARG_PASS);
}
}
- NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype);
+ NODE_UNLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype);
if (close_version) {
- dns__rbtdb_closeversion(
+ dns__qpdb_closeversion(
db, (dns_dbversion_t **)(void *)(&rbtversion),
false DNS__DB_FLARG_PASS);
}
}
static bool
-delegating_type(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, dns_typepair_t type) {
+delegating_type(dns_qpdb_t *qpdb, dns_rbtnode_t *node, dns_typepair_t type) {
if (type == dns_rdatatype_dname ||
(type == dns_rdatatype_ns &&
- (node != rbtdb->origin_node || IS_STUB(rbtdb))))
+ (node != qpdb->origin_node || IS_STUB(qpdb))))
{
return (true);
}
* load a non-NSEC3 node in the main tree and optionally to the auxiliary NSEC
*/
static isc_result_t
-loadnode(dns_rbtdb_t *rbtdb, const dns_name_t *name, dns_rbtnode_t **nodep,
+loadnode(dns_qpdb_t *qpdb, const dns_name_t *name, dns_rbtnode_t **nodep,
bool hasnsec) {
isc_result_t noderesult, nsecresult, tmpresult;
dns_rbtnode_t *nsecnode = NULL, *node = NULL;
- noderesult = dns_rbt_addnode(rbtdb->tree, name, &node);
+ noderesult = dns_rbt_addnode(qpdb->tree, name, &node);
if (!hasnsec) {
goto done;
}
* Add nodes to the auxiliary tree after corresponding nodes have
* been added to the main tree.
*/
- nsecresult = dns_rbt_addnode(rbtdb->nsec, name, &nsecnode);
+ nsecresult = dns_rbt_addnode(qpdb->nsec, name, &nsecnode);
if (nsecresult == ISC_R_SUCCESS) {
nsecnode->nsec = DNS_DB_NSEC_NSEC;
node->nsec = DNS_DB_NSEC_HAS_NSEC;
/*
* Remove the node we just added above.
*/
- tmpresult = dns_rbt_deletenode(rbtdb->tree, node, false);
+ tmpresult = dns_rbt_deletenode(qpdb->tree, node, false);
if (tmpresult != ISC_R_SUCCESS) {
isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
DNS_LOGMODULE_CACHE, ISC_LOG_WARNING,
static isc_result_t
loading_addrdataset(void *arg, const dns_name_t *name,
dns_rdataset_t *rdataset DNS__DB_FLARG) {
- rbtdb_load_t *loadctx = arg;
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)loadctx->db;
+ qpdb_load_t *loadctx = arg;
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)loadctx->db;
dns_rbtnode_t *node = NULL;
isc_result_t result;
isc_region_t region;
dns_slabheader_t *newheader = NULL;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
- REQUIRE(rdataset->rdclass == rbtdb->common.rdclass);
+ REQUIRE(rdataset->rdclass == qpdb->common.rdclass);
/*
* SOA records are only allowed at top of zone.
*/
if (rdataset->type == dns_rdatatype_soa &&
- !dns_name_equal(name, &rbtdb->common.origin))
+ !dns_name_equal(name, &qpdb->common.origin))
{
return (DNS_R_NOTZONETOP);
}
if (rdataset->type != dns_rdatatype_nsec3 &&
rdataset->covers != dns_rdatatype_nsec3)
{
- dns__zonerbt_addwildcards(rbtdb, name, false);
+ dns__qpzone_addwildcards(qpdb, name, false);
}
if (dns_name_iswildcard(name)) {
if (rdataset->type == dns_rdatatype_nsec3) {
return (DNS_R_INVALIDNSEC3);
}
- result = dns__zonerbt_wildcardmagic(rbtdb, name, false);
+ result = dns__qpzone_wildcardmagic(qpdb, name, false);
if (result != ISC_R_SUCCESS) {
return (result);
}
if (rdataset->type == dns_rdatatype_nsec3 ||
rdataset->covers == dns_rdatatype_nsec3)
{
- result = dns_rbt_addnode(rbtdb->nsec3, name, &node);
+ result = dns_rbt_addnode(qpdb->nsec3, name, &node);
if (result == ISC_R_SUCCESS) {
node->nsec = DNS_DB_NSEC_NSEC3;
}
} else if (rdataset->type == dns_rdatatype_nsec) {
- result = loadnode(rbtdb, name, &node, true);
+ result = loadnode(qpdb, name, &node, true);
} else {
- result = loadnode(rbtdb, name, &node, false);
+ result = loadnode(qpdb, name, &node, false);
}
if (result != ISC_R_SUCCESS && result != ISC_R_EXISTS) {
return (result);
}
if (result == ISC_R_SUCCESS) {
- node->locknum = node->hashval % rbtdb->node_lock_count;
+ node->locknum = node->hashval % qpdb->node_lock_count;
}
- result = dns_rdataslab_fromrdataset(rdataset, rbtdb->common.mctx,
+ result = dns_rdataslab_fromrdataset(rdataset, qpdb->common.mctx,
®ion, sizeof(dns_slabheader_t));
if (result != ISC_R_SUCCESS) {
return (result);
.count = 1,
};
- dns_slabheader_reset(newheader, (dns_db_t *)rbtdb, node);
+ dns_slabheader_reset(newheader, (dns_db_t *)qpdb, node);
dns_slabheader_setownercase(newheader, name);
if ((rdataset->attributes & DNS_RDATASETATTR_RESIGN) != 0) {
newheader->resign_lsb = rdataset->resign & 0x1;
}
- NODE_WRLOCK(&rbtdb->node_locks[node->locknum].lock, &nlocktype);
- result = dns__rbtdb_add(rbtdb, node, name, rbtdb->current_version,
- newheader, DNS_DBADD_MERGE, true, NULL,
- 0 DNS__DB_FLARG_PASS);
- NODE_UNLOCK(&rbtdb->node_locks[node->locknum].lock, &nlocktype);
+ NODE_WRLOCK(&qpdb->node_locks[node->locknum].lock, &nlocktype);
+ result = dns__qpdb_add(qpdb, node, name, qpdb->current_version,
+ newheader, DNS_DBADD_MERGE, true, NULL,
+ 0 DNS__DB_FLARG_PASS);
+ NODE_UNLOCK(&qpdb->node_locks[node->locknum].lock, &nlocktype);
if (result == ISC_R_SUCCESS &&
- delegating_type(rbtdb, node, rdataset->type))
+ delegating_type(qpdb, node, rdataset->type))
{
node->find_callback = 1;
} else if (result == DNS_R_UNCHANGED) {
static isc_result_t
beginload(dns_db_t *db, dns_rdatacallbacks_t *callbacks) {
- rbtdb_load_t *loadctx = NULL;
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
+ qpdb_load_t *loadctx = NULL;
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
REQUIRE(DNS_CALLBACK_VALID(callbacks));
- REQUIRE(VALID_RBTDB(rbtdb));
+ REQUIRE(VALID_QPDB(qpdb));
- loadctx = isc_mem_get(rbtdb->common.mctx, sizeof(*loadctx));
+ loadctx = isc_mem_get(qpdb->common.mctx, sizeof(*loadctx));
loadctx->db = db;
loadctx->now = 0;
- RWLOCK(&rbtdb->lock, isc_rwlocktype_write);
+ RWLOCK(&qpdb->lock, isc_rwlocktype_write);
- REQUIRE((rbtdb->attributes &
- (RBTDB_ATTR_LOADED | RBTDB_ATTR_LOADING)) == 0);
- rbtdb->attributes |= RBTDB_ATTR_LOADING;
+ REQUIRE((qpdb->attributes & (QPDB_ATTR_LOADED | QPDB_ATTR_LOADING)) ==
+ 0);
+ qpdb->attributes |= QPDB_ATTR_LOADING;
- RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write);
+ RWUNLOCK(&qpdb->lock, isc_rwlocktype_write);
callbacks->add = loading_addrdataset;
callbacks->add_private = loadctx;
static isc_result_t
endload(dns_db_t *db, dns_rdatacallbacks_t *callbacks) {
- rbtdb_load_t *loadctx = NULL;
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
+ qpdb_load_t *loadctx = NULL;
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
- REQUIRE(VALID_RBTDB(rbtdb));
+ REQUIRE(VALID_QPDB(qpdb));
REQUIRE(DNS_CALLBACK_VALID(callbacks));
loadctx = callbacks->add_private;
REQUIRE(loadctx != NULL);
REQUIRE(loadctx->db == db);
- RWLOCK(&rbtdb->lock, isc_rwlocktype_write);
+ RWLOCK(&qpdb->lock, isc_rwlocktype_write);
- REQUIRE((rbtdb->attributes & RBTDB_ATTR_LOADING) != 0);
- REQUIRE((rbtdb->attributes & RBTDB_ATTR_LOADED) == 0);
+ REQUIRE((qpdb->attributes & QPDB_ATTR_LOADING) != 0);
+ REQUIRE((qpdb->attributes & QPDB_ATTR_LOADED) == 0);
- rbtdb->attributes &= ~RBTDB_ATTR_LOADING;
- rbtdb->attributes |= RBTDB_ATTR_LOADED;
+ qpdb->attributes &= ~QPDB_ATTR_LOADING;
+ qpdb->attributes |= QPDB_ATTR_LOADED;
/*
* If there's a KEY rdataset at the zone origin containing a
* zone key, we consider the zone secure.
*/
- if (rbtdb->origin_node != NULL) {
- dns_dbversion_t *version = rbtdb->current_version;
- RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write);
- dns__rbtdb_setsecure(db, version, rbtdb->origin_node);
+ if (qpdb->origin_node != NULL) {
+ dns_dbversion_t *version = qpdb->current_version;
+ RWUNLOCK(&qpdb->lock, isc_rwlocktype_write);
+ dns__qpdb_setsecure(db, version, qpdb->origin_node);
} else {
- RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write);
+ RWUNLOCK(&qpdb->lock, isc_rwlocktype_write);
}
callbacks->add = NULL;
callbacks->add_private = NULL;
- isc_mem_put(rbtdb->common.mctx, loadctx, sizeof(*loadctx));
+ isc_mem_put(qpdb->common.mctx, loadctx, sizeof(*loadctx));
return (ISC_R_SUCCESS);
}
static bool
issecure(dns_db_t *db) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
bool secure;
- REQUIRE(VALID_RBTDB(rbtdb));
+ REQUIRE(VALID_QPDB(qpdb));
- RWLOCK(&rbtdb->lock, isc_rwlocktype_read);
- secure = rbtdb->current_version->secure;
- RWUNLOCK(&rbtdb->lock, isc_rwlocktype_read);
+ RWLOCK(&qpdb->lock, isc_rwlocktype_read);
+ secure = qpdb->current_version->secure;
+ RWUNLOCK(&qpdb->lock, isc_rwlocktype_read);
return (secure);
}
getnsec3parameters(dns_db_t *db, dns_dbversion_t *version, dns_hash_t *hash,
uint8_t *flags, uint16_t *iterations, unsigned char *salt,
size_t *salt_length) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
isc_result_t result = ISC_R_NOTFOUND;
- dns_rbtdb_version_t *rbtversion = version;
+ dns_qpdb_version_t *rbtversion = version;
- REQUIRE(VALID_RBTDB(rbtdb));
- INSIST(rbtversion == NULL || rbtversion->rbtdb == rbtdb);
+ REQUIRE(VALID_QPDB(qpdb));
+ INSIST(rbtversion == NULL || rbtversion->qpdb == qpdb);
- RWLOCK(&rbtdb->lock, isc_rwlocktype_read);
+ RWLOCK(&qpdb->lock, isc_rwlocktype_read);
if (rbtversion == NULL) {
- rbtversion = rbtdb->current_version;
+ rbtversion = qpdb->current_version;
}
if (rbtversion->havensec3) {
}
result = ISC_R_SUCCESS;
}
- RWUNLOCK(&rbtdb->lock, isc_rwlocktype_read);
+ RWUNLOCK(&qpdb->lock, isc_rwlocktype_read);
return (result);
}
static isc_result_t
getsize(dns_db_t *db, dns_dbversion_t *version, uint64_t *records,
uint64_t *xfrsize) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
isc_result_t result = ISC_R_SUCCESS;
- dns_rbtdb_version_t *rbtversion = version;
+ dns_qpdb_version_t *rbtversion = version;
- REQUIRE(VALID_RBTDB(rbtdb));
- INSIST(rbtversion == NULL || rbtversion->rbtdb == rbtdb);
+ REQUIRE(VALID_QPDB(qpdb));
+ INSIST(rbtversion == NULL || rbtversion->qpdb == qpdb);
- RWLOCK(&rbtdb->lock, isc_rwlocktype_read);
+ RWLOCK(&qpdb->lock, isc_rwlocktype_read);
if (rbtversion == NULL) {
- rbtversion = rbtdb->current_version;
+ rbtversion = qpdb->current_version;
}
RWLOCK(&rbtversion->rwlock, isc_rwlocktype_read);
SET_IF_NOT_NULL(xfrsize, rbtversion->xfrsize);
RWUNLOCK(&rbtversion->rwlock, isc_rwlocktype_read);
- RWUNLOCK(&rbtdb->lock, isc_rwlocktype_read);
+ RWUNLOCK(&qpdb->lock, isc_rwlocktype_read);
return (result);
}
static isc_result_t
setsigningtime(dns_db_t *db, dns_rdataset_t *rdataset, isc_stdtime_t resign) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
dns_slabheader_t *header, oldheader;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
- REQUIRE(VALID_RBTDB(rbtdb));
- REQUIRE(!IS_CACHE(rbtdb));
+ REQUIRE(VALID_QPDB(qpdb));
+ REQUIRE(!IS_CACHE(qpdb));
REQUIRE(rdataset != NULL);
REQUIRE(rdataset->methods == &dns_rdataslab_rdatasetmethods);
header = dns_slabheader_fromrdataset(rdataset);
- NODE_WRLOCK(&rbtdb->node_locks[RBTDB_HEADERNODE(header)->locknum].lock,
+ NODE_WRLOCK(&qpdb->node_locks[QPDB_HEADERNODE(header)->locknum].lock,
&nlocktype);
oldheader = *header;
INSIST(RESIGN(header));
if (resign == 0) {
isc_heap_delete(
- rbtdb->heaps[RBTDB_HEADERNODE(header)->locknum],
+ qpdb->heaps[QPDB_HEADERNODE(header)->locknum],
header->heap_index);
header->heap_index = 0;
header->heap = NULL;
- } else if (rbtdb->sooner(header, &oldheader)) {
+ } else if (qpdb->sooner(header, &oldheader)) {
isc_heap_increased(
- rbtdb->heaps[RBTDB_HEADERNODE(header)->locknum],
+ qpdb->heaps[QPDB_HEADERNODE(header)->locknum],
header->heap_index);
- } else if (rbtdb->sooner(&oldheader, header)) {
+ } else if (qpdb->sooner(&oldheader, header)) {
isc_heap_decreased(
- rbtdb->heaps[RBTDB_HEADERNODE(header)->locknum],
+ qpdb->heaps[QPDB_HEADERNODE(header)->locknum],
header->heap_index);
}
} else if (resign != 0) {
DNS_SLABHEADER_SETATTR(header, DNS_SLABHEADERATTR_RESIGN);
- dns__zonerbt_resigninsert(
- rbtdb, RBTDB_HEADERNODE(header)->locknum, header);
+ dns__qpzone_resigninsert(qpdb, QPDB_HEADERNODE(header)->locknum,
+ header);
}
- NODE_UNLOCK(&rbtdb->node_locks[RBTDB_HEADERNODE(header)->locknum].lock,
+ NODE_UNLOCK(&qpdb->node_locks[QPDB_HEADERNODE(header)->locknum].lock,
&nlocktype);
return (ISC_R_SUCCESS);
}
static isc_result_t
getsigningtime(dns_db_t *db, dns_rdataset_t *rdataset,
dns_name_t *foundname DNS__DB_FLARG) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
dns_slabheader_t *header = NULL, *this = NULL;
unsigned int i;
isc_result_t result = ISC_R_NOTFOUND;
isc_rwlocktype_t tlocktype = isc_rwlocktype_none;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
- REQUIRE(VALID_RBTDB(rbtdb));
+ REQUIRE(VALID_QPDB(qpdb));
- TREE_RDLOCK(&rbtdb->tree_lock, &tlocktype);
+ TREE_RDLOCK(&qpdb->tree_lock, &tlocktype);
- for (i = 0; i < rbtdb->node_lock_count; i++) {
- NODE_RDLOCK(&rbtdb->node_locks[i].lock, &nlocktype);
+ for (i = 0; i < qpdb->node_lock_count; i++) {
+ NODE_RDLOCK(&qpdb->node_locks[i].lock, &nlocktype);
/*
* Find for the earliest signing time among all of the
* heaps, each of which is covered by a different bucket
* lock.
*/
- this = isc_heap_element(rbtdb->heaps[i], 1);
+ this = isc_heap_element(qpdb->heaps[i], 1);
if (this == NULL) {
/* Nothing found; unlock and try the next heap. */
- NODE_UNLOCK(&rbtdb->node_locks[i].lock, &nlocktype);
+ NODE_UNLOCK(&qpdb->node_locks[i].lock, &nlocktype);
continue;
}
header = this;
locknum = i;
nlocktype = isc_rwlocktype_none;
- } else if (rbtdb->sooner(this, header)) {
+ } else if (qpdb->sooner(this, header)) {
/*
* Found an earlier signing time; release the
* previous bucket lock and retain this one instead.
*/
- NODE_UNLOCK(&rbtdb->node_locks[locknum].lock,
+ NODE_UNLOCK(&qpdb->node_locks[locknum].lock,
&nlocktype);
header = this;
locknum = i;
* Earliest signing time in this heap isn't
* an improvement; unlock and try the next heap.
*/
- NODE_UNLOCK(&rbtdb->node_locks[i].lock, &nlocktype);
+ NODE_UNLOCK(&qpdb->node_locks[i].lock, &nlocktype);
}
}
* Found something; pass back the answer and unlock
* the bucket.
*/
- dns__rbtdb_bindrdataset(rbtdb, RBTDB_HEADERNODE(header), header,
- 0, isc_rwlocktype_read,
- rdataset DNS__DB_FLARG_PASS);
+ dns__qpdb_bindrdataset(qpdb, QPDB_HEADERNODE(header), header, 0,
+ isc_rwlocktype_read,
+ rdataset DNS__DB_FLARG_PASS);
if (foundname != NULL) {
- dns_rbt_fullnamefromnode(RBTDB_HEADERNODE(header),
+ dns_rbt_fullnamefromnode(QPDB_HEADERNODE(header),
foundname);
}
- NODE_UNLOCK(&rbtdb->node_locks[locknum].lock, &nlocktype);
+ NODE_UNLOCK(&qpdb->node_locks[locknum].lock, &nlocktype);
result = ISC_R_SUCCESS;
}
- TREE_UNLOCK(&rbtdb->tree_lock, &tlocktype);
+ TREE_UNLOCK(&qpdb->tree_lock, &tlocktype);
return (result);
}
static isc_result_t
setgluecachestats(dns_db_t *db, isc_stats_t *stats) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
- REQUIRE(VALID_RBTDB(rbtdb));
- REQUIRE(!IS_CACHE(rbtdb) && !IS_STUB(rbtdb));
+ REQUIRE(VALID_QPDB(qpdb));
+ REQUIRE(!IS_CACHE(qpdb) && !IS_STUB(qpdb));
REQUIRE(stats != NULL);
- isc_stats_attach(stats, &rbtdb->gluecachestats);
+ isc_stats_attach(stats, &qpdb->gluecachestats);
return (ISC_R_SUCCESS);
}
}
static dns_glue_t *
-newglue(dns_rbtdb_t *rbtdb, dns_rbtdb_version_t *rbtversion,
- dns_rbtnode_t *node, dns_rdataset_t *rdataset) {
+newglue(dns_qpdb_t *qpdb, dns_qpdb_version_t *rbtversion, dns_rbtnode_t *node,
+ dns_rdataset_t *rdataset) {
dns_fixedname_t nodename;
dns_glue_additionaldata_ctx_t ctx = {
- .db = (dns_db_t *)rbtdb,
+ .db = (dns_db_t *)qpdb,
.version = (dns_dbversion_t *)rbtversion,
.nodename = dns_fixedname_initname(&nodename),
};
* determining which NS records in the delegation are
* in-bailiwick).
*/
- dns__rbtdb_nodefullname((dns_db_t *)rbtdb, node, ctx.nodename);
+ dns__qpdb_nodefullname((dns_db_t *)qpdb, node, ctx.nodename);
(void)dns_rdataset_additionaldata(rdataset, dns_rootname,
glue_nsdname_cb, &ctx);
static isc_result_t
addglue(dns_db_t *db, dns_dbversion_t *version, dns_rdataset_t *rdataset,
dns_message_t *msg) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
- dns_rbtdb_version_t *rbtversion = version;
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
+ dns_qpdb_version_t *rbtversion = version;
dns_rbtnode_t *node = (dns_rbtnode_t *)rdataset->slab.node;
dns_slabheader_t *header = dns_slabheader_fromrdataset(rdataset);
REQUIRE(rdataset->type == dns_rdatatype_ns);
- REQUIRE(rbtdb == (dns_rbtdb_t *)rdataset->slab.db);
- REQUIRE(rbtdb == rbtversion->rbtdb);
- REQUIRE(!IS_CACHE(rbtdb) && !IS_STUB(rbtdb));
+ REQUIRE(qpdb == (dns_qpdb_t *)rdataset->slab.db);
+ REQUIRE(qpdb == rbtversion->qpdb);
+ REQUIRE(!IS_CACHE(qpdb) && !IS_STUB(qpdb));
rcu_read_lock();
dns_glue_t *glue = rcu_dereference(header->glue_list);
if (glue == NULL) {
/* No cached glue was found in the table. Get new glue. */
- glue = newglue(rbtdb, rbtversion, node, rdataset);
+ glue = newglue(qpdb, rbtversion, node, rdataset);
/* Cache the glue or (void *)-1 if no glue was found. */
dns_glue_t *old_glue = rcu_cmpxchg_pointer(
&header->glue_list, NULL, (glue) ? glue : (void *)-1);
if (old_glue != NULL) {
/* Somebody else was faster */
- dns__rbtdb_freeglue(glue);
+ dns__qpdb_freeglue(glue);
glue = old_glue;
} else if (glue != NULL) {
cds_wfs_push(&rbtversion->glue_stack,
/* We have a cached result. Add it to the message and return. */
- if (rbtdb->gluecachestats != NULL) {
+ if (qpdb->gluecachestats != NULL) {
isc_stats_increment(
- rbtdb->gluecachestats,
+ qpdb->gluecachestats,
(glue == (void *)-1)
? dns_gluecachestatscounter_hits_absent
: dns_gluecachestatscounter_hits_present);
return (ISC_R_SUCCESS);
}
-dns_dbmethods_t dns__rbtdb_zonemethods = {
- .destroy = dns__rbtdb_destroy,
+dns_dbmethods_t dns__qpdb_zonemethods = {
+ .destroy = dns__qpdb_destroy,
.beginload = beginload,
.endload = endload,
- .currentversion = dns__rbtdb_currentversion,
- .newversion = dns__rbtdb_newversion,
- .attachversion = dns__rbtdb_attachversion,
- .closeversion = dns__rbtdb_closeversion,
- .findnode = dns__rbtdb_findnode,
+ .currentversion = dns__qpdb_currentversion,
+ .newversion = dns__qpdb_newversion,
+ .attachversion = dns__qpdb_attachversion,
+ .closeversion = dns__qpdb_closeversion,
+ .findnode = dns__qpdb_findnode,
.find = zone_find,
- .attachnode = dns__rbtdb_attachnode,
- .detachnode = dns__rbtdb_detachnode,
- .createiterator = dns__rbtdb_createiterator,
+ .attachnode = dns__qpdb_attachnode,
+ .detachnode = dns__qpdb_detachnode,
+ .createiterator = dns__qpdb_createiterator,
.findrdataset = zone_findrdataset,
- .allrdatasets = dns__rbtdb_allrdatasets,
- .addrdataset = dns__rbtdb_addrdataset,
- .subtractrdataset = dns__rbtdb_subtractrdataset,
- .deleterdataset = dns__rbtdb_deleterdataset,
+ .allrdatasets = dns__qpdb_allrdatasets,
+ .addrdataset = dns__qpdb_addrdataset,
+ .subtractrdataset = dns__qpdb_subtractrdataset,
+ .deleterdataset = dns__qpdb_deleterdataset,
.issecure = issecure,
- .nodecount = dns__rbtdb_nodecount,
- .setloop = dns__rbtdb_setloop,
- .getoriginnode = dns__rbtdb_getoriginnode,
+ .nodecount = dns__qpdb_nodecount,
+ .setloop = dns__qpdb_setloop,
+ .getoriginnode = dns__qpdb_getoriginnode,
.getnsec3parameters = getnsec3parameters,
.findnsec3node = findnsec3node,
.setsigningtime = setsigningtime,
.getsigningtime = getsigningtime,
.getsize = getsize,
.setgluecachestats = setgluecachestats,
- .locknode = dns__rbtdb_locknode,
- .unlocknode = dns__rbtdb_unlocknode,
+ .locknode = dns__qpdb_locknode,
+ .unlocknode = dns__qpdb_unlocknode,
.addglue = addglue,
- .deletedata = dns__rbtdb_deletedata,
+ .deletedata = dns__qpdb_deletedata,
};
void
-dns__zonerbt_resigninsert(dns_rbtdb_t *rbtdb, int idx,
- dns_slabheader_t *newheader) {
- INSIST(!IS_CACHE(rbtdb));
+dns__qpzone_resigninsert(dns_qpdb_t *qpdb, int idx,
+ dns_slabheader_t *newheader) {
+ INSIST(!IS_CACHE(qpdb));
INSIST(newheader->heap_index == 0);
INSIST(!ISC_LINK_LINKED(newheader, link));
- isc_heap_insert(rbtdb->heaps[idx], newheader);
- newheader->heap = rbtdb->heaps[idx];
+ isc_heap_insert(qpdb->heaps[idx], newheader);
+ newheader->heap = qpdb->heaps[idx];
}
void
-dns__zonerbt_resigndelete(dns_rbtdb_t *rbtdb, dns_rbtdb_version_t *version,
- dns_slabheader_t *header DNS__DB_FLARG) {
+dns__qpzone_resigndelete(dns_qpdb_t *qpdb, dns_qpdb_version_t *version,
+ dns_slabheader_t *header DNS__DB_FLARG) {
/*
* Remove the old header from the heap
*/
if (header != NULL && header->heap_index != 0) {
- isc_heap_delete(rbtdb->heaps[RBTDB_HEADERNODE(header)->locknum],
+ isc_heap_delete(qpdb->heaps[QPDB_HEADERNODE(header)->locknum],
header->heap_index);
header->heap_index = 0;
if (version != NULL) {
- dns__rbtdb_newref(
- rbtdb, RBTDB_HEADERNODE(header),
+ dns__qpdb_newref(
+ qpdb, QPDB_HEADERNODE(header),
isc_rwlocktype_write DNS__DB_FLARG_PASS);
ISC_LIST_APPEND(version->resigned_list, header, link);
}
}
isc_result_t
-dns__zonerbt_wildcardmagic(dns_rbtdb_t *rbtdb, const dns_name_t *name,
- bool lock) {
+dns__qpzone_wildcardmagic(dns_qpdb_t *qpdb, const dns_name_t *name, bool lock) {
isc_result_t result;
dns_name_t foundname;
dns_offsets_t offsets;
INSIST(n >= 2);
n--;
dns_name_getlabelsequence(name, 1, n, &foundname);
- result = dns_rbt_addnode(rbtdb->tree, &foundname, &node);
+ result = dns_rbt_addnode(qpdb->tree, &foundname, &node);
if (result != ISC_R_SUCCESS && result != ISC_R_EXISTS) {
return (result);
}
}
node->find_callback = 1;
if (lock) {
- NODE_WRLOCK(&rbtdb->node_locks[node->locknum].lock, &nlocktype);
+ NODE_WRLOCK(&qpdb->node_locks[node->locknum].lock, &nlocktype);
}
node->wild = 1;
if (lock) {
- NODE_UNLOCK(&rbtdb->node_locks[node->locknum].lock, &nlocktype);
+ NODE_UNLOCK(&qpdb->node_locks[node->locknum].lock, &nlocktype);
}
return (ISC_R_SUCCESS);
}
isc_result_t
-dns__zonerbt_addwildcards(dns_rbtdb_t *rbtdb, const dns_name_t *name,
- bool lock) {
+dns__qpzone_addwildcards(dns_qpdb_t *qpdb, const dns_name_t *name, bool lock) {
isc_result_t result;
dns_name_t foundname;
dns_offsets_t offsets;
dns_name_init(&foundname, offsets);
n = dns_name_countlabels(name);
- l = dns_name_countlabels(&rbtdb->common.origin);
+ l = dns_name_countlabels(&qpdb->common.origin);
i = l + 1;
while (i < n) {
dns_rbtnode_t *node = NULL;
dns_name_getlabelsequence(name, n - i, i, &foundname);
if (dns_name_iswildcard(&foundname)) {
- result = dns__zonerbt_wildcardmagic(rbtdb, &foundname,
- lock);
+ result = dns__qpzone_wildcardmagic(qpdb, &foundname,
+ lock);
if (result != ISC_R_SUCCESS) {
return (result);
}
- result = dns_rbt_addnode(rbtdb->tree, &foundname,
- &node);
+ result = dns_rbt_addnode(qpdb->tree, &foundname, &node);
if (result != ISC_R_SUCCESS && result != ISC_R_EXISTS) {
return (result);
}
((atomic_load_acquire(&(header)->attributes) & \
DNS_SLABHEADERATTR_STATCOUNT) != 0)
-#define STALE_TTL(header, rbtdb) \
- (NXDOMAIN(header) ? 0 : rbtdb->common.serve_stale_ttl)
+#define STALE_TTL(header, qpdb) \
+ (NXDOMAIN(header) ? 0 : qpdb->common.serve_stale_ttl)
#define ACTIVE(header, now) \
(((header)->ttl > (now)) || ((header)->ttl == (now) && ZEROTTL(header)))
#define STALEOK(rbtiterator) \
(((rbtiterator)->common.options & DNS_DB_STALEOK) != 0)
-#define KEEPSTALE(rbtdb) ((rbtdb)->common.serve_stale_ttl > 0)
+#define KEEPSTALE(qpdb) ((qpdb)->common.serve_stale_ttl > 0)
-#define RBTDBITER_NSEC3_ORIGIN_NODE(rbtdb, iterator) \
+#define QPDBITER_NSEC3_ORIGIN_NODE(qpdb, iterator) \
((iterator)->current == &(iterator)->nsec3chain && \
- (iterator)->node == (rbtdb)->nsec3_origin_node)
+ (iterator)->node == (qpdb)->nsec3_origin_node)
/*%
* Number of buckets for cache DB entries (locks, LRU lists, TTL heaps).
* LRU purge algorithm won't work well (entries tend to be purged prematurely).
* The default value should work well for most environments, but this can
* also be configurable at compilation time via the
- * DNS_RBTDB_CACHE_NODE_LOCK_COUNT variable. This value must be larger than
- * 1 due to the assumption of dns__cacherbt_overmem().
+ * DNS_QPDB_CACHE_NODE_LOCK_COUNT variable. This value must be larger than
+ * 1 due to the assumption of dns__qpcache_overmem().
*/
-#ifdef DNS_RBTDB_CACHE_NODE_LOCK_COUNT
-#if DNS_RBTDB_CACHE_NODE_LOCK_COUNT <= 1
-#error "DNS_RBTDB_CACHE_NODE_LOCK_COUNT must be larger than 1"
-#else /* if DNS_RBTDB_CACHE_NODE_LOCK_COUNT <= 1 */
-#define DEFAULT_CACHE_NODE_LOCK_COUNT DNS_RBTDB_CACHE_NODE_LOCK_COUNT
-#endif /* if DNS_RBTDB_CACHE_NODE_LOCK_COUNT <= 1 */
-#else /* ifdef DNS_RBTDB_CACHE_NODE_LOCK_COUNT */
+#ifdef DNS_QPDB_CACHE_NODE_LOCK_COUNT
+#if DNS_QPDB_CACHE_NODE_LOCK_COUNT <= 1
+#error "DNS_QPDB_CACHE_NODE_LOCK_COUNT must be larger than 1"
+#else /* if DNS_QPDB_CACHE_NODE_LOCK_COUNT <= 1 */
+#define DEFAULT_CACHE_NODE_LOCK_COUNT DNS_QPDB_CACHE_NODE_LOCK_COUNT
+#endif /* if DNS_QPDB_CACHE_NODE_LOCK_COUNT <= 1 */
+#else /* ifdef DNS_QPDB_CACHE_NODE_LOCK_COUNT */
#define DEFAULT_CACHE_NODE_LOCK_COUNT 17
-#endif /* DNS_RBTDB_CACHE_NODE_LOCK_COUNT */
+#endif /* DNS_QPDB_CACHE_NODE_LOCK_COUNT */
/*
* This defines the number of headers that we try to expire each time the
* TTL-based header expiration doesn't take too long, but it should be large
* enough, so we expire enough headers if their TTL is clustered.
*/
-#define DNS_RBTDB_EXPIRE_TTL_COUNT 10
+#define DNS_QPDB_EXPIRE_TTL_COUNT 10
/* QP methods */
static void
static void
prune_tree(void *arg);
static void
-free_gluetable(dns_rbtdb_version_t *version);
+free_gluetable(dns_qpdb_version_t *version);
static void
rdatasetiter_destroy(dns_rdatasetiter_t **iteratorp DNS__DB_FLARG);
rdatasetiter_current
};
-typedef struct rbtdb_rdatasetiter {
+typedef struct qpdb_rdatasetiter {
dns_rdatasetiter_t common;
dns_slabheader_t *current;
-} rbtdb_rdatasetiter_t;
+} qpdb_rdatasetiter_t;
/*
* Note that these iterators, unless created with either DNS_DB_NSEC3ONLY or
/*
* If 'paused' is true, then the tree lock is not being held.
*/
-typedef struct rbtdb_dbiterator {
+typedef struct qpdb_dbiterator {
dns_dbiterator_t common;
bool paused;
bool new_origin;
dns_rbtnodechain_t *current;
dns_rbtnode_t *node;
enum { full, nonsec3, nsec3only } nsec3mode;
-} rbtdb_dbiterator_t;
+} qpdb_dbiterator_t;
static void
-free_rbtdb(dns_rbtdb_t *rbtdb, bool log);
+free_qpdb(dns_qpdb_t *qpdb, bool log);
static void
-setnsec3parameters(dns_db_t *db, dns_rbtdb_version_t *version);
+setnsec3parameters(dns_db_t *db, dns_qpdb_version_t *version);
/*%
* 'init_count' is used to initialize 'newheader->count' which inturn
}
void
-dns__rbtdb_setttl(dns_slabheader_t *header, dns_ttl_t newttl) {
+dns__qpdb_setttl(dns_slabheader_t *header, dns_ttl_t newttl) {
dns_ttl_t oldttl = header->ttl;
header->ttl = newttl;
}
static void
-free_rbtdb(dns_rbtdb_t *rbtdb, bool log) {
+free_qpdb(dns_qpdb_t *qpdb, bool log) {
unsigned int i;
char buf[DNS_NAME_FORMATSIZE];
dns_qp_t **treep = NULL;
- REQUIRE(rbtdb->current_version != NULL || EMPTY(rbtdb->open_versions));
- REQUIRE(rbtdb->future_version == NULL);
+ REQUIRE(qpdb->current_version != NULL || EMPTY(qpdb->open_versions));
+ REQUIRE(qpdb->future_version == NULL);
- if (rbtdb->current_version != NULL) {
- isc_refcount_decrementz(&rbtdb->current_version->references);
+ if (qpdb->current_version != NULL) {
+ isc_refcount_decrementz(&qpdb->current_version->references);
- isc_refcount_destroy(&rbtdb->current_version->references);
- UNLINK(rbtdb->open_versions, rbtdb->current_version, link);
- cds_wfs_destroy(&rbtdb->current_version->glue_stack);
- isc_rwlock_destroy(&rbtdb->current_version->rwlock);
- isc_mem_put(rbtdb->common.mctx, rbtdb->current_version,
- sizeof(*rbtdb->current_version));
+ isc_refcount_destroy(&qpdb->current_version->references);
+ UNLINK(qpdb->open_versions, qpdb->current_version, link);
+ cds_wfs_destroy(&qpdb->current_version->glue_stack);
+ isc_rwlock_destroy(&qpdb->current_version->rwlock);
+ isc_mem_put(qpdb->common.mctx, qpdb->current_version,
+ sizeof(*qpdb->current_version));
}
/*
* We assume the number of remaining dead nodes is reasonably small;
* the overhead of unlinking all nodes here should be negligible.
*/
- for (i = 0; i < rbtdb->node_lock_count; i++) {
+ for (i = 0; i < qpdb->node_lock_count; i++) {
dns_rbtnode_t *node = NULL;
- node = ISC_LIST_HEAD(rbtdb->deadnodes[i]);
+ node = ISC_LIST_HEAD(qpdb->deadnodes[i]);
while (node != NULL) {
- ISC_LIST_UNLINK(rbtdb->deadnodes[i], node, deadlink);
- node = ISC_LIST_HEAD(rbtdb->deadnodes[i]);
+ ISC_LIST_UNLINK(qpdb->deadnodes[i], node, deadlink);
+ node = ISC_LIST_HEAD(qpdb->deadnodes[i]);
}
}
- rbtdb->quantum = (rbtdb->loop != NULL) ? 100 : 0;
+ qpdb->quantum = (qpdb->loop != NULL) ? 100 : 0;
for (;;) {
/*
* pick the next tree to (start to) destroy
*/
- treep = &rbtdb->tree;
+ treep = &qpdb->tree;
if (*treep == NULL) {
- treep = &rbtdb->nsec;
+ treep = &qpdb->nsec;
if (*treep == NULL) {
- treep = &rbtdb->nsec3;
+ treep = &qpdb->nsec3;
/*
* we're finished after clear cutting
*/
}
if (log) {
- if (dns_name_dynamic(&rbtdb->common.origin)) {
- dns_name_format(&rbtdb->common.origin, buf,
- sizeof(buf));
+ if (dns_name_dynamic(&qpdb->common.origin)) {
+ dns_name_format(&qpdb->common.origin, buf, sizeof(buf));
} else {
strlcpy(buf, "<UNKNOWN>", sizeof(buf));
}
isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
DNS_LOGMODULE_CACHE, ISC_LOG_DEBUG(1),
- "done free_rbtdb(%s)", buf);
+ "done free_qpdb(%s)", buf);
}
- if (dns_name_dynamic(&rbtdb->common.origin)) {
- dns_name_free(&rbtdb->common.origin, rbtdb->common.mctx);
+ if (dns_name_dynamic(&qpdb->common.origin)) {
+ dns_name_free(&qpdb->common.origin, qpdb->common.mctx);
}
- for (i = 0; i < rbtdb->node_lock_count; i++) {
- isc_refcount_destroy(&rbtdb->node_locks[i].references);
- NODE_DESTROYLOCK(&rbtdb->node_locks[i].lock);
+ for (i = 0; i < qpdb->node_lock_count; i++) {
+ isc_refcount_destroy(&qpdb->node_locks[i].references);
+ NODE_DESTROYLOCK(&qpdb->node_locks[i].lock);
}
/*
* Clean up LRU / re-signing order lists.
*/
- if (rbtdb->lru != NULL) {
- for (i = 0; i < rbtdb->node_lock_count; i++) {
- INSIST(ISC_LIST_EMPTY(rbtdb->lru[i]));
+ if (qpdb->lru != NULL) {
+ for (i = 0; i < qpdb->node_lock_count; i++) {
+ INSIST(ISC_LIST_EMPTY(qpdb->lru[i]));
}
- isc_mem_cput(rbtdb->common.mctx, rbtdb->lru,
- rbtdb->node_lock_count,
+ isc_mem_cput(qpdb->common.mctx, qpdb->lru,
+ qpdb->node_lock_count,
sizeof(dns_slabheaderlist_t));
}
/*
* Clean up dead node buckets.
*/
- if (rbtdb->deadnodes != NULL) {
- for (i = 0; i < rbtdb->node_lock_count; i++) {
- INSIST(ISC_LIST_EMPTY(rbtdb->deadnodes[i]));
+ if (qpdb->deadnodes != NULL) {
+ for (i = 0; i < qpdb->node_lock_count; i++) {
+ INSIST(ISC_LIST_EMPTY(qpdb->deadnodes[i]));
}
- isc_mem_cput(rbtdb->common.mctx, rbtdb->deadnodes,
- rbtdb->node_lock_count, sizeof(dns_rbtnodelist_t));
+ isc_mem_cput(qpdb->common.mctx, qpdb->deadnodes,
+ qpdb->node_lock_count, sizeof(dns_rbtnodelist_t));
}
/*
* Clean up heap objects.
*/
- if (rbtdb->heaps != NULL) {
- for (i = 0; i < rbtdb->node_lock_count; i++) {
- isc_heap_destroy(&rbtdb->heaps[i]);
+ if (qpdb->heaps != NULL) {
+ for (i = 0; i < qpdb->node_lock_count; i++) {
+ isc_heap_destroy(&qpdb->heaps[i]);
}
- isc_mem_cput(rbtdb->hmctx, rbtdb->heaps, rbtdb->node_lock_count,
+ isc_mem_cput(qpdb->hmctx, qpdb->heaps, qpdb->node_lock_count,
sizeof(isc_heap_t *));
}
- if (rbtdb->rrsetstats != NULL) {
- dns_stats_detach(&rbtdb->rrsetstats);
+ if (qpdb->rrsetstats != NULL) {
+ dns_stats_detach(&qpdb->rrsetstats);
}
- if (rbtdb->cachestats != NULL) {
- isc_stats_detach(&rbtdb->cachestats);
+ if (qpdb->cachestats != NULL) {
+ isc_stats_detach(&qpdb->cachestats);
}
- if (rbtdb->gluecachestats != NULL) {
- isc_stats_detach(&rbtdb->gluecachestats);
+ if (qpdb->gluecachestats != NULL) {
+ isc_stats_detach(&qpdb->gluecachestats);
}
- isc_mem_cput(rbtdb->common.mctx, rbtdb->node_locks,
- rbtdb->node_lock_count, sizeof(db_nodelock_t));
- TREE_DESTROYLOCK(&rbtdb->tree_lock);
- isc_refcount_destroy(&rbtdb->common.references);
- if (rbtdb->loop != NULL) {
- isc_loop_detach(&rbtdb->loop);
+ isc_mem_cput(qpdb->common.mctx, qpdb->node_locks, qpdb->node_lock_count,
+ sizeof(db_nodelock_t));
+ TREE_DESTROYLOCK(&qpdb->tree_lock);
+ isc_refcount_destroy(&qpdb->common.references);
+ if (qpdb->loop != NULL) {
+ isc_loop_detach(&qpdb->loop);
}
- isc_rwlock_destroy(&rbtdb->lock);
- rbtdb->common.magic = 0;
- rbtdb->common.impmagic = 0;
- isc_mem_detach(&rbtdb->hmctx);
+ isc_rwlock_destroy(&qpdb->lock);
+ qpdb->common.magic = 0;
+ qpdb->common.impmagic = 0;
+ isc_mem_detach(&qpdb->hmctx);
- if (rbtdb->common.update_listeners != NULL) {
- INSIST(!cds_lfht_destroy(rbtdb->common.update_listeners, NULL));
+ if (qpdb->common.update_listeners != NULL) {
+ INSIST(!cds_lfht_destroy(qpdb->common.update_listeners, NULL));
}
- isc_mem_putanddetach(&rbtdb->common.mctx, rbtdb, sizeof(*rbtdb));
+ isc_mem_putanddetach(&qpdb->common.mctx, qpdb, sizeof(*qpdb));
}
void
-dns__rbtdb_destroy(dns_db_t *arg) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)arg;
+dns__qpdb_destroy(dns_db_t *arg) {
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)arg;
bool want_free = false;
unsigned int i;
unsigned int inactive = 0;
/* XXX check for open versions here */
- if (rbtdb->soanode != NULL) {
- dns_db_detachnode((dns_db_t *)rbtdb, &rbtdb->soanode);
+ if (qpdb->soanode != NULL) {
+ dns_db_detachnode((dns_db_t *)qpdb, &qpdb->soanode);
}
- if (rbtdb->nsnode != NULL) {
- dns_db_detachnode((dns_db_t *)rbtdb, &rbtdb->nsnode);
+ if (qpdb->nsnode != NULL) {
+ dns_db_detachnode((dns_db_t *)qpdb, &qpdb->nsnode);
}
/*
* so the nodes are dereferenced before we check the active
* node count below.
*/
- if (rbtdb->current_version != NULL) {
- free_gluetable(rbtdb->current_version);
+ if (qpdb->current_version != NULL) {
+ free_gluetable(qpdb->current_version);
}
/*
* Even though there are no external direct references, there still
* may be nodes in use.
*/
- for (i = 0; i < rbtdb->node_lock_count; i++) {
+ for (i = 0; i < qpdb->node_lock_count; i++) {
isc_rwlocktype_t nodelock = isc_rwlocktype_none;
- NODE_WRLOCK(&rbtdb->node_locks[i].lock, &nodelock);
- rbtdb->node_locks[i].exiting = true;
- if (isc_refcount_current(&rbtdb->node_locks[i].references) == 0)
+ NODE_WRLOCK(&qpdb->node_locks[i].lock, &nodelock);
+ qpdb->node_locks[i].exiting = true;
+ if (isc_refcount_current(&qpdb->node_locks[i].references) == 0)
{
inactive++;
}
- NODE_UNLOCK(&rbtdb->node_locks[i].lock, &nodelock);
+ NODE_UNLOCK(&qpdb->node_locks[i].lock, &nodelock);
}
if (inactive != 0) {
- RWLOCK(&rbtdb->lock, isc_rwlocktype_write);
- rbtdb->active -= inactive;
- if (rbtdb->active == 0) {
+ RWLOCK(&qpdb->lock, isc_rwlocktype_write);
+ qpdb->active -= inactive;
+ if (qpdb->active == 0) {
want_free = true;
}
- RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write);
+ RWUNLOCK(&qpdb->lock, isc_rwlocktype_write);
if (want_free) {
char buf[DNS_NAME_FORMATSIZE];
- if (dns_name_dynamic(&rbtdb->common.origin)) {
- dns_name_format(&rbtdb->common.origin, buf,
+ if (dns_name_dynamic(&qpdb->common.origin)) {
+ dns_name_format(&qpdb->common.origin, buf,
sizeof(buf));
} else {
strlcpy(buf, "<UNKNOWN>", sizeof(buf));
}
isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
DNS_LOGMODULE_CACHE, ISC_LOG_DEBUG(1),
- "calling free_rbtdb(%s)", buf);
- free_rbtdb(rbtdb, true);
+ "calling free_qpdb(%s)", buf);
+ free_qpdb(qpdb, true);
}
}
}
void
-dns__rbtdb_currentversion(dns_db_t *db, dns_dbversion_t **versionp) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
- dns_rbtdb_version_t *version = NULL;
+dns__qpdb_currentversion(dns_db_t *db, dns_dbversion_t **versionp) {
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
+ dns_qpdb_version_t *version = NULL;
- REQUIRE(VALID_RBTDB(rbtdb));
+ REQUIRE(VALID_QPDB(qpdb));
- RWLOCK(&rbtdb->lock, isc_rwlocktype_read);
- version = rbtdb->current_version;
+ RWLOCK(&qpdb->lock, isc_rwlocktype_read);
+ version = qpdb->current_version;
isc_refcount_increment(&version->references);
- RWUNLOCK(&rbtdb->lock, isc_rwlocktype_read);
+ RWUNLOCK(&qpdb->lock, isc_rwlocktype_read);
*versionp = (dns_dbversion_t *)version;
}
-static dns_rbtdb_version_t *
+static dns_qpdb_version_t *
allocate_version(isc_mem_t *mctx, uint32_t serial, unsigned int references,
bool writer) {
- dns_rbtdb_version_t *version = isc_mem_get(mctx, sizeof(*version));
- *version = (dns_rbtdb_version_t){
+ dns_qpdb_version_t *version = isc_mem_get(mctx, sizeof(*version));
+ *version = (dns_qpdb_version_t){
.serial = serial,
.writer = writer,
.changed_list = ISC_LIST_INITIALIZER,
}
isc_result_t
-dns__rbtdb_newversion(dns_db_t *db, dns_dbversion_t **versionp) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
- dns_rbtdb_version_t *version = NULL;
+dns__qpdb_newversion(dns_db_t *db, dns_dbversion_t **versionp) {
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
+ dns_qpdb_version_t *version = NULL;
- REQUIRE(VALID_RBTDB(rbtdb));
+ REQUIRE(VALID_QPDB(qpdb));
REQUIRE(versionp != NULL && *versionp == NULL);
- REQUIRE(rbtdb->future_version == NULL);
+ REQUIRE(qpdb->future_version == NULL);
- RWLOCK(&rbtdb->lock, isc_rwlocktype_write);
- RUNTIME_CHECK(rbtdb->next_serial != 0); /* XXX Error? */
- version = allocate_version(rbtdb->common.mctx, rbtdb->next_serial, 1,
+ RWLOCK(&qpdb->lock, isc_rwlocktype_write);
+ RUNTIME_CHECK(qpdb->next_serial != 0); /* XXX Error? */
+ version = allocate_version(qpdb->common.mctx, qpdb->next_serial, 1,
true);
- version->rbtdb = rbtdb;
+ version->qpdb = qpdb;
version->commit_ok = true;
- version->secure = rbtdb->current_version->secure;
- version->havensec3 = rbtdb->current_version->havensec3;
+ version->secure = qpdb->current_version->secure;
+ version->havensec3 = qpdb->current_version->havensec3;
if (version->havensec3) {
- version->flags = rbtdb->current_version->flags;
- version->iterations = rbtdb->current_version->iterations;
- version->hash = rbtdb->current_version->hash;
- version->salt_length = rbtdb->current_version->salt_length;
- memmove(version->salt, rbtdb->current_version->salt,
+ version->flags = qpdb->current_version->flags;
+ version->iterations = qpdb->current_version->iterations;
+ version->hash = qpdb->current_version->hash;
+ version->salt_length = qpdb->current_version->salt_length;
+ memmove(version->salt, qpdb->current_version->salt,
version->salt_length);
} else {
version->flags = 0;
memset(version->salt, 0, sizeof(version->salt));
}
isc_rwlock_init(&version->rwlock);
- RWLOCK(&rbtdb->current_version->rwlock, isc_rwlocktype_read);
- version->records = rbtdb->current_version->records;
- version->xfrsize = rbtdb->current_version->xfrsize;
- RWUNLOCK(&rbtdb->current_version->rwlock, isc_rwlocktype_read);
- rbtdb->next_serial++;
- rbtdb->future_version = version;
- RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write);
+ RWLOCK(&qpdb->current_version->rwlock, isc_rwlocktype_read);
+ version->records = qpdb->current_version->records;
+ version->xfrsize = qpdb->current_version->xfrsize;
+ RWUNLOCK(&qpdb->current_version->rwlock, isc_rwlocktype_read);
+ qpdb->next_serial++;
+ qpdb->future_version = version;
+ RWUNLOCK(&qpdb->lock, isc_rwlocktype_write);
*versionp = version;
}
void
-dns__rbtdb_attachversion(dns_db_t *db, dns_dbversion_t *source,
- dns_dbversion_t **targetp) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
- dns_rbtdb_version_t *rbtversion = source;
+dns__qpdb_attachversion(dns_db_t *db, dns_dbversion_t *source,
+ dns_dbversion_t **targetp) {
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
+ dns_qpdb_version_t *rbtversion = source;
- REQUIRE(VALID_RBTDB(rbtdb));
- INSIST(rbtversion != NULL && rbtversion->rbtdb == rbtdb);
+ REQUIRE(VALID_QPDB(qpdb));
+ INSIST(rbtversion != NULL && rbtversion->qpdb == qpdb);
isc_refcount_increment(&rbtversion->references);
*targetp = rbtversion;
}
-static rbtdb_changed_t *
+static qpdb_changed_t *
add_changed(dns_slabheader_t *header,
- dns_rbtdb_version_t *version DNS__DB_FLARG) {
- rbtdb_changed_t *changed = NULL;
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)header->db;
+ dns_qpdb_version_t *version DNS__DB_FLARG) {
+ qpdb_changed_t *changed = NULL;
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)header->db;
/*
* Caller must be holding the node lock if its reference must be
* protected by the lock.
*/
- changed = isc_mem_get(rbtdb->common.mctx, sizeof(*changed));
+ changed = isc_mem_get(qpdb->common.mctx, sizeof(*changed));
- RWLOCK(&rbtdb->lock, isc_rwlocktype_write);
+ RWLOCK(&qpdb->lock, isc_rwlocktype_write);
REQUIRE(version->writer);
version->commit_ok = false;
}
- RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write);
+ RWUNLOCK(&qpdb->lock, isc_rwlocktype_write);
return (changed);
}
}
void
-dns__rbtdb_mark(dns_slabheader_t *header, uint_least16_t flag) {
+dns__qpdb_mark(dns_slabheader_t *header, uint_least16_t flag) {
uint_least16_t attributes = atomic_load_acquire(&header->attributes);
uint_least16_t newattributes = 0;
dns_stats_t *stats = NULL;
static void
mark_ancient(dns_slabheader_t *header) {
- dns__rbtdb_setttl(header, 0);
- dns__rbtdb_mark(header, DNS_SLABHEADERATTR_ANCIENT);
- RBTDB_HEADERNODE(header)->dirty = 1;
+ dns__qpdb_setttl(header, 0);
+ dns__qpdb_mark(header, DNS_SLABHEADERATTR_ANCIENT);
+ QPDB_HEADERNODE(header)->dirty = 1;
}
static void
}
static void
-clean_cache_node(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node) {
+clean_cache_node(dns_qpdb_t *qpdb, dns_rbtnode_t *node) {
dns_slabheader_t *current = NULL, *top_prev = NULL, *top_next = NULL;
/*
* we are not keeping stale, we can clean it up.
*/
if (NONEXISTENT(current) || ANCIENT(current) ||
- (STALE(current) && !KEEPSTALE(rbtdb)))
+ (STALE(current) && !KEEPSTALE(qpdb)))
{
if (top_prev != NULL) {
top_prev->next = current->next;
* tree_lock(write) must be held.
*/
static void
-delete_node(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node) {
+delete_node(dns_qpdb_t *qpdb, dns_rbtnode_t *node) {
dns_rbtnode_t *nsecnode = NULL;
dns_fixedname_t fname;
dns_name_t *name = NULL;
switch (node->nsec) {
case DNS_DB_NSEC_NORMAL:
- result = dns_rbt_deletenode(rbtdb->tree, node, false);
+ result = dns_rbt_deletenode(qpdb->tree, node, false);
break;
case DNS_DB_NSEC_HAS_NSEC:
/*
* tree before deleting from the main tree.
*/
nsecnode = NULL;
- result = dns_rbt_findnode(rbtdb->nsec, name, NULL, &nsecnode,
+ result = dns_rbt_findnode(qpdb->nsec, name, NULL, &nsecnode,
NULL, DNS_RBTFIND_EMPTYDATA, NULL,
NULL);
if (result != ISC_R_SUCCESS) {
"dns_rbt_findnode(nsec): %s",
isc_result_totext(result));
} else {
- result = dns_rbt_deletenode(rbtdb->nsec, nsecnode,
+ result = dns_rbt_deletenode(qpdb->nsec, nsecnode,
false);
if (result != ISC_R_SUCCESS) {
isc_log_write(
isc_result_totext(result));
}
}
- result = dns_rbt_deletenode(rbtdb->tree, node, false);
+ result = dns_rbt_deletenode(qpdb->tree, node, false);
break;
case DNS_DB_NSEC_NSEC:
- result = dns_rbt_deletenode(rbtdb->nsec, node, false);
+ result = dns_rbt_deletenode(qpdb->nsec, node, false);
break;
case DNS_DB_NSEC_NSEC3:
- result = dns_rbt_deletenode(rbtdb->nsec3, node, false);
+ result = dns_rbt_deletenode(qpdb->nsec3, node, false);
break;
}
if (result != ISC_R_SUCCESS) {
* Caller must be holding the node lock.
*/
void
-dns__rbtdb_newref(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node,
- isc_rwlocktype_t nlocktype DNS__DB_FLARG) {
+dns__qpdb_newref(dns_qpdb_t *qpdb, dns_rbtnode_t *node,
+ isc_rwlocktype_t nlocktype DNS__DB_FLARG) {
uint_fast32_t refs;
if (nlocktype == isc_rwlocktype_write &&
ISC_LINK_LINKED(node, deadlink))
{
- ISC_LIST_UNLINK(rbtdb->deadnodes[node->locknum], node,
- deadlink);
+ ISC_LIST_UNLINK(qpdb->deadnodes[node->locknum], node, deadlink);
}
refs = isc_refcount_increment0(&node->references);
if (refs == 0) {
/* this is the first reference to the node */
refs = isc_refcount_increment0(
- &rbtdb->node_locks[node->locknum].references);
+ &qpdb->node_locks[node->locknum].references);
#if DNS_DB_NODETRACE
fprintf(stderr,
"incr:nodelock:%s:%s:%u:%p:%p->references = "
"%" PRIuFAST32 "\n",
func, file, line, node,
- &rbtdb->node_locks[node->locknum], refs + 1);
+ &qpdb->node_locks[node->locknum], refs + 1);
#else
UNUSED(refs);
#endif
}
static void
-send_to_prune_tree(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node,
+send_to_prune_tree(dns_qpdb_t *qpdb, dns_rbtnode_t *node,
isc_rwlocktype_t nlocktype DNS__DB_FLARG) {
- prune_t *prune = isc_mem_get(rbtdb->common.mctx, sizeof(*prune));
- *prune = (prune_t){ .node = node };
+ qpdb_prune_t *prune = isc_mem_get(qpdb->common.mctx, sizeof(*prune));
+ *prune = (qpdb_prune_t){ .node = node };
- dns_db_attach((dns_db_t *)rbtdb, &prune->db);
- dns__rbtdb_newref(rbtdb, node, nlocktype DNS__DB_FLARG_PASS);
+ dns_db_attach((dns_db_t *)qpdb, &prune->db);
+ dns__qpdb_newref(qpdb, node, nlocktype DNS__DB_FLARG_PASS);
- isc_async_run(rbtdb->loop, prune_tree, prune);
+ isc_async_run(qpdb->loop, prune_tree, prune);
}
/*%
* The caller must hold a tree write lock and bucketnum'th node (write) lock.
*/
static void
-cleanup_dead_nodes(dns_rbtdb_t *rbtdb, int bucketnum DNS__DB_FLARG) {
+cleanup_dead_nodes(dns_qpdb_t *qpdb, int bucketnum DNS__DB_FLARG) {
dns_rbtnode_t *node = NULL;
int count = 10; /* XXXJT: should be adjustable */
- node = ISC_LIST_HEAD(rbtdb->deadnodes[bucketnum]);
+ node = ISC_LIST_HEAD(qpdb->deadnodes[bucketnum]);
while (node != NULL && count > 0) {
- ISC_LIST_UNLINK(rbtdb->deadnodes[bucketnum], node, deadlink);
+ ISC_LIST_UNLINK(qpdb->deadnodes[bucketnum], node, deadlink);
/*
* We might have reactivated this node without a tree write
if (isc_refcount_current(&node->references) != 0 ||
node->data != NULL)
{
- node = ISC_LIST_HEAD(rbtdb->deadnodes[bucketnum]);
+ node = ISC_LIST_HEAD(qpdb->deadnodes[bucketnum]);
count--;
continue;
}
- if (is_leaf(node) && rbtdb->loop != NULL) {
+ if (is_leaf(node) && qpdb->loop != NULL) {
send_to_prune_tree(
- rbtdb, node,
+ qpdb, node,
isc_rwlocktype_write DNS__DB_FLARG_PASS);
} else if (node->down == NULL && node->data == NULL) {
/*
* Not a interior node and not needing to be
* reactivated.
*/
- delete_node(rbtdb, node);
+ delete_node(qpdb, node);
} else if (node->data == NULL) {
/*
* A interior node without data. Leave linked to
* to be cleaned up when node->down becomes NULL.
*/
- ISC_LIST_APPEND(rbtdb->deadnodes[bucketnum], node,
+ ISC_LIST_APPEND(qpdb->deadnodes[bucketnum], node,
deadlink);
}
- node = ISC_LIST_HEAD(rbtdb->deadnodes[bucketnum]);
+ node = ISC_LIST_HEAD(qpdb->deadnodes[bucketnum]);
count--;
}
}
* have been added to the list).
*/
static void
-reactivate_node(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node,
+reactivate_node(dns_qpdb_t *qpdb, dns_rbtnode_t *node,
isc_rwlocktype_t tlocktype DNS__DB_FLARG) {
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
- isc_rwlock_t *nodelock = &rbtdb->node_locks[node->locknum].lock;
+ isc_rwlock_t *nodelock = &qpdb->node_locks[node->locknum].lock;
bool maybe_cleanup = false;
POST(nlocktype);
* Check if we can possibly cleanup the dead node. If so, upgrade
* the node lock below to perform the cleanup.
*/
- if (!ISC_LIST_EMPTY(rbtdb->deadnodes[node->locknum]) &&
+ if (!ISC_LIST_EMPTY(qpdb->deadnodes[node->locknum]) &&
tlocktype == isc_rwlocktype_write)
{
maybe_cleanup = true;
NODE_FORCEUPGRADE(nodelock, &nlocktype);
POST(nlocktype);
if (ISC_LINK_LINKED(node, deadlink)) {
- ISC_LIST_UNLINK(rbtdb->deadnodes[node->locknum], node,
+ ISC_LIST_UNLINK(qpdb->deadnodes[node->locknum], node,
deadlink);
}
if (maybe_cleanup) {
- cleanup_dead_nodes(rbtdb,
+ cleanup_dead_nodes(qpdb,
node->locknum DNS__DB_FILELINE);
}
}
- dns__rbtdb_newref(rbtdb, node, nlocktype DNS__DB_FLARG_PASS);
+ dns__qpdb_newref(qpdb, node, nlocktype DNS__DB_FLARG_PASS);
NODE_UNLOCK(nodelock, &nlocktype);
}
* will be immediately freed.
*/
bool
-dns__rbtdb_decref(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node,
- uint32_t least_serial, isc_rwlocktype_t *nlocktypep,
- isc_rwlocktype_t *tlocktypep, bool tryupgrade,
- bool pruning DNS__DB_FLARG) {
+dns__qpdb_decref(dns_qpdb_t *qpdb, dns_rbtnode_t *node, uint32_t least_serial,
+ isc_rwlocktype_t *nlocktypep, isc_rwlocktype_t *tlocktypep,
+ bool tryupgrade, bool pruning DNS__DB_FLARG) {
isc_result_t result;
bool locked = *tlocktypep != isc_rwlocktype_none;
bool write_locked = false;
REQUIRE(*nlocktypep != isc_rwlocktype_none);
- nodelock = &rbtdb->node_locks[bucket];
+ nodelock = &qpdb->node_locks[bucket];
#define KEEP_NODE(n, r, l) \
((n)->data != NULL || ((l) && (n)->down != NULL) || \
(n) == (r)->origin_node || (n) == (r)->nsec3_origin_node)
/* Handle easy and typical case first. */
- if (!node->dirty && KEEP_NODE(node, rbtdb, locked)) {
+ if (!node->dirty && KEEP_NODE(node, qpdb, locked)) {
refs = isc_refcount_decrement(&node->references);
#if DNS_DB_NODETRACE
fprintf(stderr,
}
if (node->dirty) {
- if (IS_CACHE(rbtdb)) {
- clean_cache_node(rbtdb, node);
+ if (IS_CACHE(qpdb)) {
+ clean_cache_node(qpdb, node);
} else {
if (least_serial == 0) {
/*
* Caller doesn't know the least serial.
* Get it.
*/
- RWLOCK(&rbtdb->lock, isc_rwlocktype_read);
- least_serial = rbtdb->least_serial;
- RWUNLOCK(&rbtdb->lock, isc_rwlocktype_read);
+ RWLOCK(&qpdb->lock, isc_rwlocktype_read);
+ least_serial = qpdb->least_serial;
+ RWUNLOCK(&qpdb->lock, isc_rwlocktype_read);
}
clean_zone_node(node, least_serial);
}
break;
case isc_rwlocktype_read:
if (tryupgrade) {
- result = TREE_TRYUPGRADE(&rbtdb->tree_lock, tlocktypep);
+ result = TREE_TRYUPGRADE(&qpdb->tree_lock, tlocktypep);
} else {
result = ISC_R_LOCKBUSY;
}
break;
case isc_rwlocktype_none:
- result = TREE_TRYWRLOCK(&rbtdb->tree_lock, tlocktypep);
+ result = TREE_TRYWRLOCK(&qpdb->tree_lock, tlocktypep);
break;
default:
UNREACHABLE();
UNUSED(refs);
#endif
- if (KEEP_NODE(node, rbtdb, (locked || write_locked))) {
+ if (KEEP_NODE(node, qpdb, (locked || write_locked))) {
goto restore_locks;
}
* cleaning. We need to check whether we're deleting the node
* as a result of pruning to avoid infinite dispatching.
* Note: pruning happens only when a loop has been set for the
- * rbtdb. If the user of the rbtdb chooses not to set a loop,
+ * qpdb. If the user of the qpdb chooses not to set a loop,
* it's their responsibility to purge stale leaves (e.g. by
* periodic walk-through).
*/
- if (!pruning && is_leaf(node) && rbtdb->loop != NULL) {
- send_to_prune_tree(rbtdb, node,
+ if (!pruning && is_leaf(node) && qpdb->loop != NULL) {
+ send_to_prune_tree(qpdb, node,
*nlocktypep DNS__DB_FLARG_PASS);
no_reference = false;
} else {
/* We can now delete the node. */
- delete_node(rbtdb, node);
+ delete_node(qpdb, node);
}
} else {
INSIST(node->data == NULL);
if (!ISC_LINK_LINKED(node, deadlink)) {
- ISC_LIST_APPEND(rbtdb->deadnodes[bucket], node,
+ ISC_LIST_APPEND(qpdb->deadnodes[bucket], node,
deadlink);
}
}
* Relock a read lock, or unlock the write lock if no lock was held.
*/
if (!locked && write_locked) {
- TREE_UNLOCK(&rbtdb->tree_lock, tlocktypep);
+ TREE_UNLOCK(&qpdb->tree_lock, tlocktypep);
}
return (no_reference);
*/
static void
prune_tree(void *arg) {
- prune_t *prune = (prune_t *)arg;
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)prune->db;
+ qpdb_prune_t *prune = (qpdb_prune_t *)arg;
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)prune->db;
dns_rbtnode_t *node = prune->node;
dns_rbtnode_t *parent = NULL;
unsigned int locknum = node->locknum;
isc_rwlocktype_t tlocktype = isc_rwlocktype_none;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
- isc_mem_put(rbtdb->common.mctx, prune, sizeof(*prune));
+ isc_mem_put(qpdb->common.mctx, prune, sizeof(*prune));
- TREE_WRLOCK(&rbtdb->tree_lock, &tlocktype);
+ TREE_WRLOCK(&qpdb->tree_lock, &tlocktype);
parent = node->parent;
- NODE_WRLOCK(&rbtdb->node_locks[locknum].lock, &nlocktype);
- dns__rbtdb_decref(rbtdb, node, 0, &nlocktype, &tlocktype, true,
- true DNS__DB_FILELINE);
- NODE_UNLOCK(&rbtdb->node_locks[locknum].lock, &nlocktype);
+ NODE_WRLOCK(&qpdb->node_locks[locknum].lock, &nlocktype);
+ dns__qpdb_decref(qpdb, node, 0, &nlocktype, &tlocktype, true,
+ true DNS__DB_FILELINE);
+ NODE_UNLOCK(&qpdb->node_locks[locknum].lock, &nlocktype);
if (parent != NULL && is_leaf(parent)) {
- NODE_WRLOCK(&rbtdb->node_locks[parent->locknum].lock,
+ NODE_WRLOCK(&qpdb->node_locks[parent->locknum].lock,
&nlocktype);
- send_to_prune_tree(rbtdb, parent, nlocktype);
- NODE_UNLOCK(&rbtdb->node_locks[parent->locknum].lock,
+ send_to_prune_tree(qpdb, parent, nlocktype);
+ NODE_UNLOCK(&qpdb->node_locks[parent->locknum].lock,
&nlocktype);
}
- TREE_UNLOCK(&rbtdb->tree_lock, &tlocktype);
+ TREE_UNLOCK(&qpdb->tree_lock, &tlocktype);
- dns_db_detach((dns_db_t **)&rbtdb);
+ dns_db_detach((dns_db_t **)&qpdb);
}
static void
-make_least_version(dns_rbtdb_t *rbtdb, dns_rbtdb_version_t *version,
- rbtdb_changedlist_t *cleanup_list) {
+make_least_version(dns_qpdb_t *qpdb, dns_qpdb_version_t *version,
+ qpdb_changedlist_t *cleanup_list) {
/*
* Caller must be holding the database lock.
*/
- rbtdb->least_serial = version->serial;
+ qpdb->least_serial = version->serial;
*cleanup_list = version->changed_list;
ISC_LIST_INIT(version->changed_list);
}
static void
-cleanup_nondirty(dns_rbtdb_version_t *version,
- rbtdb_changedlist_t *cleanup_list) {
- rbtdb_changed_t *changed = NULL, *next_changed = NULL;
+cleanup_nondirty(dns_qpdb_version_t *version,
+ qpdb_changedlist_t *cleanup_list) {
+ qpdb_changed_t *changed = NULL, *next_changed = NULL;
/*
* If the changed record is dirty, then
}
void
-dns__rbtdb_setsecure(dns_db_t *db, dns_rbtdb_version_t *version,
- dns_dbnode_t *origin) {
+dns__qpdb_setsecure(dns_db_t *db, dns_qpdb_version_t *version,
+ dns_dbnode_t *origin) {
dns_rdataset_t keyset;
dns_rdataset_t nsecset, signsecset;
bool haszonekey = false;
* Cache the nsec3 parameters.
*/
static void
-setnsec3parameters(dns_db_t *db, dns_rbtdb_version_t *version) {
+setnsec3parameters(dns_db_t *db, dns_qpdb_version_t *version) {
dns_rbtnode_t *node = NULL;
dns_rdata_nsec3param_t nsec3param;
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_slabheader_t *header = NULL, *header_next = NULL;
unsigned char *raw; /* RDATASLAB */
unsigned int count, length;
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
isc_rwlocktype_t tlocktype = isc_rwlocktype_none;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
- TREE_RDLOCK(&rbtdb->tree_lock, &tlocktype);
+ TREE_RDLOCK(&qpdb->tree_lock, &tlocktype);
version->havensec3 = false;
- node = rbtdb->origin_node;
- NODE_RDLOCK(&(rbtdb->node_locks[node->locknum].lock), &nlocktype);
+ node = qpdb->origin_node;
+ NODE_RDLOCK(&(qpdb->node_locks[node->locknum].lock), &nlocktype);
for (header = node->data; header != NULL; header = header_next) {
header_next = header->next;
do {
region.length = length;
raw += length;
dns_rdata_fromregion(
- &rdata, rbtdb->common.rdclass,
+ &rdata, qpdb->common.rdclass,
dns_rdatatype_nsec3param, ®ion);
result = dns_rdata_tostruct(&rdata, &nsec3param,
NULL);
}
}
unlock:
- NODE_UNLOCK(&(rbtdb->node_locks[node->locknum].lock), &nlocktype);
- TREE_UNLOCK(&rbtdb->tree_lock, &tlocktype);
+ NODE_UNLOCK(&(qpdb->node_locks[node->locknum].lock), &nlocktype);
+ TREE_UNLOCK(&qpdb->tree_lock, &tlocktype);
}
static void
cleanup_dead_nodes_callback(void *arg) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)arg;
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)arg;
bool again = false;
unsigned int locknum;
isc_rwlocktype_t tlocktype = isc_rwlocktype_none;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
- TREE_WRLOCK(&rbtdb->tree_lock, &tlocktype);
- for (locknum = 0; locknum < rbtdb->node_lock_count; locknum++) {
- NODE_WRLOCK(&rbtdb->node_locks[locknum].lock, &nlocktype);
- cleanup_dead_nodes(rbtdb, locknum DNS__DB_FILELINE);
- if (ISC_LIST_HEAD(rbtdb->deadnodes[locknum]) != NULL) {
+ TREE_WRLOCK(&qpdb->tree_lock, &tlocktype);
+ for (locknum = 0; locknum < qpdb->node_lock_count; locknum++) {
+ NODE_WRLOCK(&qpdb->node_locks[locknum].lock, &nlocktype);
+ cleanup_dead_nodes(qpdb, locknum DNS__DB_FILELINE);
+ if (ISC_LIST_HEAD(qpdb->deadnodes[locknum]) != NULL) {
again = true;
}
- NODE_UNLOCK(&rbtdb->node_locks[locknum].lock, &nlocktype);
+ NODE_UNLOCK(&qpdb->node_locks[locknum].lock, &nlocktype);
}
- TREE_UNLOCK(&rbtdb->tree_lock, &tlocktype);
+ TREE_UNLOCK(&qpdb->tree_lock, &tlocktype);
if (again) {
- isc_async_run(rbtdb->loop, cleanup_dead_nodes_callback, rbtdb);
+ isc_async_run(qpdb->loop, cleanup_dead_nodes_callback, qpdb);
} else {
- dns_db_detach((dns_db_t **)&rbtdb);
+ dns_db_detach((dns_db_t **)&qpdb);
}
}
void
-dns__rbtdb_closeversion(dns_db_t *db, dns_dbversion_t **versionp,
- bool commit DNS__DB_FLARG) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
- dns_rbtdb_version_t *version = NULL, *cleanup_version = NULL;
- dns_rbtdb_version_t *least_greater = NULL;
+dns__qpdb_closeversion(dns_db_t *db, dns_dbversion_t **versionp,
+ bool commit DNS__DB_FLARG) {
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
+ dns_qpdb_version_t *version = NULL, *cleanup_version = NULL;
+ dns_qpdb_version_t *least_greater = NULL;
bool rollback = false;
- rbtdb_changedlist_t cleanup_list;
+ qpdb_changedlist_t cleanup_list;
dns_slabheaderlist_t resigned_list;
- rbtdb_changed_t *changed = NULL, *next_changed = NULL;
+ qpdb_changed_t *changed = NULL, *next_changed = NULL;
uint32_t serial, least_serial;
dns_rbtnode_t *rbtnode = NULL;
dns_slabheader_t *header = NULL;
- REQUIRE(VALID_RBTDB(rbtdb));
- version = (dns_rbtdb_version_t *)*versionp;
- INSIST(version->rbtdb == rbtdb);
+ REQUIRE(VALID_QPDB(qpdb));
+ version = (dns_qpdb_version_t *)*versionp;
+ INSIST(version->qpdb == qpdb);
ISC_LIST_INIT(cleanup_list);
ISC_LIST_INIT(resigned_list);
if (isc_refcount_decrement(&version->references) > 1) {
/* typical and easy case first */
if (commit) {
- RWLOCK(&rbtdb->lock, isc_rwlocktype_read);
+ RWLOCK(&qpdb->lock, isc_rwlocktype_read);
INSIST(!version->writer);
- RWUNLOCK(&rbtdb->lock, isc_rwlocktype_read);
+ RWUNLOCK(&qpdb->lock, isc_rwlocktype_read);
}
goto end;
}
* Update the zone's secure status in version before making
* it the current version.
*/
- if (version->writer && commit && !IS_CACHE(rbtdb)) {
- dns__rbtdb_setsecure(db, version, rbtdb->origin_node);
+ if (version->writer && commit && !IS_CACHE(qpdb)) {
+ dns__qpdb_setsecure(db, version, qpdb->origin_node);
}
- RWLOCK(&rbtdb->lock, isc_rwlocktype_write);
+ RWLOCK(&qpdb->lock, isc_rwlocktype_write);
serial = version->serial;
if (version->writer) {
if (commit) {
unsigned int cur_ref;
- dns_rbtdb_version_t *cur_version = NULL;
+ dns_qpdb_version_t *cur_version = NULL;
INSIST(version->commit_ok);
- INSIST(version == rbtdb->future_version);
+ INSIST(version == qpdb->future_version);
/*
* The current version is going to be replaced.
* Release the (likely last) reference to it from the
* DB itself and unlink it from the open list.
*/
- cur_version = rbtdb->current_version;
+ cur_version = qpdb->current_version;
cur_ref = isc_refcount_decrement(
&cur_version->references);
if (cur_ref == 1) {
(void)isc_refcount_current(
&cur_version->references);
- if (cur_version->serial == rbtdb->least_serial)
- {
+ if (cur_version->serial == qpdb->least_serial) {
INSIST(EMPTY(
cur_version->changed_list));
}
- UNLINK(rbtdb->open_versions, cur_version, link);
+ UNLINK(qpdb->open_versions, cur_version, link);
}
- if (EMPTY(rbtdb->open_versions)) {
+ if (EMPTY(qpdb->open_versions)) {
/*
* We're going to become the least open
* version.
*/
- make_least_version(rbtdb, version,
+ make_least_version(qpdb, version,
&cleanup_list);
} else {
/*
* Become the current version.
*/
version->writer = false;
- rbtdb->current_version = version;
- rbtdb->current_serial = version->serial;
- rbtdb->future_version = NULL;
+ qpdb->current_version = version;
+ qpdb->current_serial = version->serial;
+ qpdb->future_version = NULL;
/*
* Keep the current version in the open list, and
*/
INSIST(isc_refcount_increment0(&version->references) ==
0);
- PREPEND(rbtdb->open_versions, rbtdb->current_version,
+ PREPEND(qpdb->open_versions, qpdb->current_version,
link);
resigned_list = version->resigned_list;
ISC_LIST_INIT(version->resigned_list);
ISC_LIST_INIT(version->resigned_list);
rollback = true;
cleanup_version = version;
- rbtdb->future_version = NULL;
+ qpdb->future_version = NULL;
}
} else {
- if (version != rbtdb->current_version) {
+ if (version != qpdb->current_version) {
/*
* There are no external or internal references
* to this version and it can be cleaned up.
*/
least_greater = PREV(version, link);
if (least_greater == NULL) {
- least_greater = rbtdb->current_version;
+ least_greater = qpdb->current_version;
}
INSIST(version->serial < least_greater->serial);
/*
* Is this the least open version?
*/
- if (version->serial == rbtdb->least_serial) {
+ if (version->serial == qpdb->least_serial) {
/*
* Yes. Install the new least open
* version.
*/
- make_least_version(rbtdb, least_greater,
+ make_least_version(qpdb, least_greater,
&cleanup_list);
} else {
/*
APPENDLIST(least_greater->changed_list,
version->changed_list, link);
}
- } else if (version->serial == rbtdb->least_serial) {
+ } else if (version->serial == qpdb->least_serial) {
INSIST(EMPTY(version->changed_list));
}
- UNLINK(rbtdb->open_versions, version, link);
+ UNLINK(qpdb->open_versions, version, link);
}
- least_serial = rbtdb->least_serial;
- RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write);
+ least_serial = qpdb->least_serial;
+ RWUNLOCK(&qpdb->lock, isc_rwlocktype_write);
if (cleanup_version != NULL) {
isc_refcount_destroy(&cleanup_version->references);
free_gluetable(cleanup_version);
cds_wfs_destroy(&cleanup_version->glue_stack);
isc_rwlock_destroy(&cleanup_version->rwlock);
- isc_mem_put(rbtdb->common.mctx, cleanup_version,
+ isc_mem_put(qpdb->common.mctx, cleanup_version,
sizeof(*cleanup_version));
}
ISC_LIST_UNLINK(resigned_list, header, link);
- lock = &rbtdb->node_locks[RBTDB_HEADERNODE(header)->locknum]
- .lock;
+ lock = &qpdb->node_locks[QPDB_HEADERNODE(header)->locknum].lock;
NODE_WRLOCK(lock, &nlocktype);
if (rollback && !IGNORE(header)) {
- dns__zonerbt_resigninsert(
- rbtdb, RBTDB_HEADERNODE(header)->locknum,
- header);
+ dns__qpzone_resigninsert(
+ qpdb, QPDB_HEADERNODE(header)->locknum, header);
}
- dns__rbtdb_decref(rbtdb, RBTDB_HEADERNODE(header), least_serial,
- &nlocktype, &tlocktype, true,
- false DNS__DB_FLARG_PASS);
+ dns__qpdb_decref(qpdb, QPDB_HEADERNODE(header), least_serial,
+ &nlocktype, &tlocktype, true,
+ false DNS__DB_FLARG_PASS);
NODE_UNLOCK(lock, &nlocktype);
INSIST(tlocktype == isc_rwlocktype_none);
}
if (!EMPTY(cleanup_list)) {
isc_rwlocktype_t tlocktype = isc_rwlocktype_none;
- if (rbtdb->loop == NULL) {
+ if (qpdb->loop == NULL) {
/*
* We acquire a tree write lock here in order to make
* sure that stale nodes will be removed in
- * dns__rbtdb_decref(). If we didn't have the lock,
+ * dns__qpdb_decref(). If we didn't have the lock,
* those nodes could miss the chance to be removed
* until the server stops. The write lock is
* expensive, but this should be rare enough
* to justify the cost.
*/
- TREE_WRLOCK(&rbtdb->tree_lock, &tlocktype);
+ TREE_WRLOCK(&qpdb->tree_lock, &tlocktype);
}
for (changed = HEAD(cleanup_list); changed != NULL;
next_changed = NEXT(changed, link);
rbtnode = changed->node;
- lock = &rbtdb->node_locks[rbtnode->locknum].lock;
+ lock = &qpdb->node_locks[rbtnode->locknum].lock;
NODE_WRLOCK(lock, &nlocktype);
/*
* This is a good opportunity to purge any dead nodes,
* so use it.
*/
- if (rbtdb->loop == NULL) {
+ if (qpdb->loop == NULL) {
cleanup_dead_nodes(
- rbtdb,
+ qpdb,
rbtnode->locknum DNS__DB_FLARG_PASS);
}
if (rollback) {
rollback_node(rbtnode, serial);
}
- dns__rbtdb_decref(rbtdb, rbtnode, least_serial,
- &nlocktype, &tlocktype, true,
- false DNS__DB_FILELINE);
+ dns__qpdb_decref(qpdb, rbtnode, least_serial,
+ &nlocktype, &tlocktype, true,
+ false DNS__DB_FILELINE);
NODE_UNLOCK(lock, &nlocktype);
- isc_mem_put(rbtdb->common.mctx, changed,
+ isc_mem_put(qpdb->common.mctx, changed,
sizeof(*changed));
}
- if (rbtdb->loop != NULL) {
- isc_refcount_increment(&rbtdb->common.references);
- isc_async_run(rbtdb->loop, cleanup_dead_nodes_callback,
- rbtdb);
+ if (qpdb->loop != NULL) {
+ isc_refcount_increment(&qpdb->common.references);
+ isc_async_run(qpdb->loop, cleanup_dead_nodes_callback,
+ qpdb);
} else {
- TREE_UNLOCK(&rbtdb->tree_lock, &tlocktype);
+ TREE_UNLOCK(&qpdb->tree_lock, &tlocktype);
}
INSIST(tlocktype == isc_rwlocktype_none);
}
isc_result_t
-dns__rbtdb_findnodeintree(dns_rbtdb_t *rbtdb, dns_qp_t *tree,
- const dns_name_t *name, bool create,
- dns_dbnode_t **nodep DNS__DB_FLARG) {
+dns__qpdb_findnodeintree(dns_qpdb_t *qpdb, dns_qp_t *tree,
+ const dns_name_t *name, bool create,
+ dns_dbnode_t **nodep DNS__DB_FLARG) {
dns_rbtnode_t *node = NULL;
dns_name_t nodename;
isc_result_t result;
isc_rwlocktype_t tlocktype = isc_rwlocktype_none;
- INSIST(tree == rbtdb->tree || tree == rbtdb->nsec3);
+ INSIST(tree == qpdb->tree || tree == qpdb->nsec3);
dns_name_init(&nodename, NULL);
- TREE_RDLOCK(&rbtdb->tree_lock, &tlocktype);
+ TREE_RDLOCK(&qpdb->tree_lock, &tlocktype);
result = dns_rbt_findnode(tree, name, NULL, &node, NULL,
DNS_RBTFIND_EMPTYDATA, NULL, NULL);
if (result != ISC_R_SUCCESS) {
/*
* Try to upgrade the lock and if that fails unlock then relock.
*/
- TREE_FORCEUPGRADE(&rbtdb->tree_lock, &tlocktype);
+ TREE_FORCEUPGRADE(&qpdb->tree_lock, &tlocktype);
node = NULL;
result = dns_rbt_addnode(tree, name, &node);
if (result == ISC_R_SUCCESS) {
dns_rbt_namefromnode(node, &nodename);
- node->locknum = node->hashval % rbtdb->node_lock_count;
- if (tree == rbtdb->tree) {
- dns__zonerbt_addwildcards(rbtdb, name, true);
+ node->locknum = node->hashval % qpdb->node_lock_count;
+ if (tree == qpdb->tree) {
+ dns__qpzone_addwildcards(qpdb, name, true);
if (dns_name_iswildcard(name)) {
- result = dns__zonerbt_wildcardmagic(
- rbtdb, name, true);
+ result = dns__qpzone_wildcardmagic(
+ qpdb, name, true);
if (result != ISC_R_SUCCESS) {
goto unlock;
}
}
}
- if (tree == rbtdb->nsec3) {
+ if (tree == qpdb->nsec3) {
node->nsec = DNS_DB_NSEC_NSEC3;
}
} else if (result == ISC_R_EXISTS) {
}
}
- if (tree == rbtdb->nsec3) {
+ if (tree == qpdb->nsec3) {
INSIST(node->nsec == DNS_DB_NSEC_NSEC3);
}
- reactivate_node(rbtdb, node, tlocktype DNS__DB_FLARG_PASS);
+ reactivate_node(qpdb, node, tlocktype DNS__DB_FLARG_PASS);
*nodep = (dns_dbnode_t *)node;
unlock:
- TREE_UNLOCK(&rbtdb->tree_lock, &tlocktype);
+ TREE_UNLOCK(&qpdb->tree_lock, &tlocktype);
return (result);
}
isc_result_t
-dns__rbtdb_findnode(dns_db_t *db, const dns_name_t *name, bool create,
- dns_dbnode_t **nodep DNS__DB_FLARG) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
+dns__qpdb_findnode(dns_db_t *db, const dns_name_t *name, bool create,
+ dns_dbnode_t **nodep DNS__DB_FLARG) {
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
- REQUIRE(VALID_RBTDB(rbtdb));
+ REQUIRE(VALID_QPDB(qpdb));
- return (dns__rbtdb_findnodeintree(rbtdb, rbtdb->tree, name, create,
- nodep DNS__DB_FLARG_PASS));
+ return (dns__qpdb_findnodeintree(qpdb, qpdb->tree, name, create,
+ nodep DNS__DB_FLARG_PASS));
}
void
-dns__rbtdb_bindrdataset(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node,
- dns_slabheader_t *header, isc_stdtime_t now,
- isc_rwlocktype_t locktype,
- dns_rdataset_t *rdataset DNS__DB_FLARG) {
+dns__qpdb_bindrdataset(dns_qpdb_t *qpdb, dns_rbtnode_t *node,
+ dns_slabheader_t *header, isc_stdtime_t now,
+ isc_rwlocktype_t locktype,
+ dns_rdataset_t *rdataset DNS__DB_FLARG) {
bool stale = STALE(header);
bool ancient = ANCIENT(header);
return;
}
- dns__rbtdb_newref(rbtdb, node, locktype DNS__DB_FLARG_PASS);
+ dns__qpdb_newref(qpdb, node, locktype DNS__DB_FLARG_PASS);
INSIST(rdataset->methods == NULL); /* We must be disassociated. */
* Mark header stale or ancient if the RRset is no longer active.
*/
if (!ACTIVE(header, now)) {
- dns_ttl_t stale_ttl = header->ttl + STALE_TTL(header, rbtdb);
+ dns_ttl_t stale_ttl = header->ttl + STALE_TTL(header, qpdb);
/*
* If this data is in the stale window keep it and if
* DNS_DBFIND_STALEOK is not set we tell the caller to
* (these records should not be cached anyway).
*/
- if (KEEPSTALE(rbtdb) && stale_ttl > now) {
+ if (KEEPSTALE(qpdb) && stale_ttl > now) {
stale = true;
} else {
/*
}
rdataset->methods = &dns_rdataslab_rdatasetmethods;
- rdataset->rdclass = rbtdb->common.rdclass;
+ rdataset->rdclass = qpdb->common.rdclass;
rdataset->type = DNS_TYPEPAIR_TYPE(header->type);
rdataset->covers = DNS_TYPEPAIR_COVERS(header->type);
rdataset->ttl = header->ttl - now;
}
if (stale && !ancient) {
- dns_ttl_t stale_ttl = header->ttl + STALE_TTL(header, rbtdb);
+ dns_ttl_t stale_ttl = header->ttl + STALE_TTL(header, qpdb);
if (stale_ttl > now) {
rdataset->ttl = stale_ttl - now;
} else {
rdataset->attributes |= DNS_RDATASETATTR_STALE_WINDOW;
}
rdataset->attributes |= DNS_RDATASETATTR_STALE;
- } else if (IS_CACHE(rbtdb) && !ACTIVE(header, now)) {
+ } else if (IS_CACHE(qpdb) && !ACTIVE(header, now)) {
rdataset->attributes |= DNS_RDATASETATTR_ANCIENT;
rdataset->ttl = header->ttl;
}
rdataset->count = atomic_fetch_add_relaxed(&header->count, 1);
- rdataset->slab.db = (dns_db_t *)rbtdb;
+ rdataset->slab.db = (dns_db_t *)qpdb;
rdataset->slab.node = (dns_dbnode_t *)node;
rdataset->slab.raw = dns_slabheader_raw(header);
rdataset->slab.iter_pos = NULL;
}
void
-dns__rbtdb_attachnode(dns_db_t *db, dns_dbnode_t *source,
- dns_dbnode_t **targetp DNS__DB_FLARG) {
- REQUIRE(VALID_RBTDB((dns_rbtdb_t *)db));
+dns__qpdb_attachnode(dns_db_t *db, dns_dbnode_t *source,
+ dns_dbnode_t **targetp DNS__DB_FLARG) {
+ REQUIRE(VALID_QPDB((dns_qpdb_t *)db));
REQUIRE(targetp != NULL && *targetp == NULL);
dns_rbtnode_t *node = (dns_rbtnode_t *)source;
}
void
-dns__rbtdb_detachnode(dns_db_t *db, dns_dbnode_t **targetp DNS__DB_FLARG) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
+dns__qpdb_detachnode(dns_db_t *db, dns_dbnode_t **targetp DNS__DB_FLARG) {
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
dns_rbtnode_t *node = NULL;
bool want_free = false;
bool inactive = false;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
isc_rwlocktype_t tlocktype = isc_rwlocktype_none;
- REQUIRE(VALID_RBTDB(rbtdb));
+ REQUIRE(VALID_QPDB(qpdb));
REQUIRE(targetp != NULL && *targetp != NULL);
node = (dns_rbtnode_t *)(*targetp);
- nodelock = &rbtdb->node_locks[node->locknum];
+ nodelock = &qpdb->node_locks[node->locknum];
NODE_RDLOCK(&nodelock->lock, &nlocktype);
- if (dns__rbtdb_decref(rbtdb, node, 0, &nlocktype, &tlocktype, true,
- false DNS__DB_FLARG_PASS))
+ if (dns__qpdb_decref(qpdb, node, 0, &nlocktype, &tlocktype, true,
+ false DNS__DB_FLARG_PASS))
{
if (isc_refcount_current(&nodelock->references) == 0 &&
nodelock->exiting)
*targetp = NULL;
if (inactive) {
- RWLOCK(&rbtdb->lock, isc_rwlocktype_write);
- rbtdb->active--;
- if (rbtdb->active == 0) {
+ RWLOCK(&qpdb->lock, isc_rwlocktype_write);
+ qpdb->active--;
+ if (qpdb->active == 0) {
want_free = true;
}
- RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write);
+ RWUNLOCK(&qpdb->lock, isc_rwlocktype_write);
if (want_free) {
char buf[DNS_NAME_FORMATSIZE];
- if (dns_name_dynamic(&rbtdb->common.origin)) {
- dns_name_format(&rbtdb->common.origin, buf,
+ if (dns_name_dynamic(&qpdb->common.origin)) {
+ dns_name_format(&qpdb->common.origin, buf,
sizeof(buf));
} else {
strlcpy(buf, "<UNKNOWN>", sizeof(buf));
}
isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
DNS_LOGMODULE_CACHE, ISC_LOG_DEBUG(1),
- "calling free_rbtdb(%s)", buf);
- free_rbtdb(rbtdb, true);
+ "calling free_qpdb(%s)", buf);
+ free_qpdb(qpdb, true);
}
}
}
isc_result_t
-dns__rbtdb_createiterator(dns_db_t *db, unsigned int options,
- dns_dbiterator_t **iteratorp) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
- rbtdb_dbiterator_t *rbtdbiter = NULL;
+dns__qpdb_createiterator(dns_db_t *db, unsigned int options,
+ dns_dbiterator_t **iteratorp) {
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
+ qpdb_dbiterator_t *qpdbiter = NULL;
- REQUIRE(VALID_RBTDB(rbtdb));
+ REQUIRE(VALID_QPDB(qpdb));
REQUIRE((options & (DNS_DB_NSEC3ONLY | DNS_DB_NONSEC3)) !=
(DNS_DB_NSEC3ONLY | DNS_DB_NONSEC3));
- rbtdbiter = isc_mem_get(rbtdb->common.mctx, sizeof(*rbtdbiter));
-
- rbtdbiter->common.methods = &dbiterator_methods;
- rbtdbiter->common.db = NULL;
- dns_db_attach(db, &rbtdbiter->common.db);
- rbtdbiter->common.relative_names = ((options & DNS_DB_RELATIVENAMES) !=
- 0);
- rbtdbiter->common.magic = DNS_DBITERATOR_MAGIC;
- rbtdbiter->paused = true;
- rbtdbiter->tree_locked = isc_rwlocktype_none;
- rbtdbiter->result = ISC_R_SUCCESS;
- dns_fixedname_init(&rbtdbiter->name);
- dns_fixedname_init(&rbtdbiter->origin);
- rbtdbiter->node = NULL;
+ qpdbiter = isc_mem_get(qpdb->common.mctx, sizeof(*qpdbiter));
+
+ qpdbiter->common.methods = &dbiterator_methods;
+ qpdbiter->common.db = NULL;
+ dns_db_attach(db, &qpdbiter->common.db);
+ qpdbiter->common.relative_names = ((options & DNS_DB_RELATIVENAMES) !=
+ 0);
+ qpdbiter->common.magic = DNS_DBITERATOR_MAGIC;
+ qpdbiter->paused = true;
+ qpdbiter->tree_locked = isc_rwlocktype_none;
+ qpdbiter->result = ISC_R_SUCCESS;
+ dns_fixedname_init(&qpdbiter->name);
+ dns_fixedname_init(&qpdbiter->origin);
+ qpdbiter->node = NULL;
if ((options & DNS_DB_NSEC3ONLY) != 0) {
- rbtdbiter->nsec3mode = nsec3only;
+ qpdbiter->nsec3mode = nsec3only;
} else if ((options & DNS_DB_NONSEC3) != 0) {
- rbtdbiter->nsec3mode = nonsec3;
+ qpdbiter->nsec3mode = nonsec3;
} else {
- rbtdbiter->nsec3mode = full;
+ qpdbiter->nsec3mode = full;
}
- dns_rbtnodechain_init(&rbtdbiter->chain);
- dns_rbtnodechain_init(&rbtdbiter->nsec3chain);
- if (rbtdbiter->nsec3mode == nsec3only) {
- rbtdbiter->current = &rbtdbiter->nsec3chain;
+ dns_rbtnodechain_init(&qpdbiter->chain);
+ dns_rbtnodechain_init(&qpdbiter->nsec3chain);
+ if (qpdbiter->nsec3mode == nsec3only) {
+ qpdbiter->current = &qpdbiter->nsec3chain;
} else {
- rbtdbiter->current = &rbtdbiter->chain;
+ qpdbiter->current = &qpdbiter->chain;
}
- *iteratorp = (dns_dbiterator_t *)rbtdbiter;
+ *iteratorp = (dns_dbiterator_t *)qpdbiter;
return (ISC_R_SUCCESS);
}
isc_result_t
-dns__rbtdb_allrdatasets(dns_db_t *db, dns_dbnode_t *node,
- dns_dbversion_t *version, unsigned int options,
- isc_stdtime_t now,
- dns_rdatasetiter_t **iteratorp DNS__DB_FLARG) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
+dns__qpdb_allrdatasets(dns_db_t *db, dns_dbnode_t *node,
+ dns_dbversion_t *version, unsigned int options,
+ isc_stdtime_t now,
+ dns_rdatasetiter_t **iteratorp DNS__DB_FLARG) {
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node;
- dns_rbtdb_version_t *rbtversion = version;
- rbtdb_rdatasetiter_t *iterator = NULL;
+ dns_qpdb_version_t *rbtversion = version;
+ qpdb_rdatasetiter_t *iterator = NULL;
uint_fast32_t refs;
- REQUIRE(VALID_RBTDB(rbtdb));
+ REQUIRE(VALID_QPDB(qpdb));
- iterator = isc_mem_get(rbtdb->common.mctx, sizeof(*iterator));
+ iterator = isc_mem_get(qpdb->common.mctx, sizeof(*iterator));
if ((db->attributes & DNS_DBATTR_CACHE) == 0) {
now = 0;
if (rbtversion == NULL) {
- dns__rbtdb_currentversion(
+ dns__qpdb_currentversion(
db, (dns_dbversion_t **)(void *)(&rbtversion));
} else {
- INSIST(rbtversion->rbtdb == rbtdb);
+ INSIST(rbtversion->qpdb == qpdb);
(void)isc_refcount_increment(&rbtversion->references);
}
}
static void
-update_recordsandxfrsize(bool add, dns_rbtdb_version_t *rbtversion,
+update_recordsandxfrsize(bool add, dns_qpdb_version_t *rbtversion,
dns_slabheader_t *header, unsigned int namelen) {
unsigned char *hdr = (unsigned char *)header;
size_t hdrsize = sizeof(*header);
}
isc_result_t
-dns__rbtdb_add(dns_rbtdb_t *rbtdb, dns_rbtnode_t *rbtnode,
- const dns_name_t *nodename, dns_rbtdb_version_t *rbtversion,
- dns_slabheader_t *newheader, unsigned int options, bool loading,
- dns_rdataset_t *addedrdataset, isc_stdtime_t now DNS__DB_FLARG) {
- rbtdb_changed_t *changed = NULL;
+dns__qpdb_add(dns_qpdb_t *qpdb, dns_rbtnode_t *rbtnode,
+ const dns_name_t *nodename, dns_qpdb_version_t *rbtversion,
+ dns_slabheader_t *newheader, unsigned int options, bool loading,
+ dns_rdataset_t *addedrdataset, isc_stdtime_t now DNS__DB_FLARG) {
+ qpdb_changed_t *changed = NULL;
dns_slabheader_t *topheader = NULL, *topheader_prev = NULL;
dns_slabheader_t *header = NULL, *sigheader = NULL;
dns_slabheader_t *prioheader = NULL;
*/
dns_slabheader_destroy(&newheader);
if (addedrdataset != NULL) {
- dns__rbtdb_bindrdataset(
- rbtdb, rbtnode,
+ dns__qpdb_bindrdataset(
+ qpdb, rbtnode,
topheader, now,
isc_rwlocktype_write,
addedrdataset
{
dns_slabheader_destroy(&newheader);
if (addedrdataset != NULL) {
- dns__rbtdb_bindrdataset(
- rbtdb, rbtnode, header, now,
+ dns__qpdb_bindrdataset(
+ qpdb, rbtnode, header, now,
isc_rwlocktype_write,
addedrdataset DNS__DB_FLARG_PASS);
}
(unsigned char *)header,
(unsigned char *)newheader,
(unsigned int)(sizeof(*newheader)),
- rbtdb->common.mctx,
- rbtdb->common.rdclass,
+ qpdb->common.mctx, qpdb->common.rdclass,
(dns_rdatatype_t)header->type, flags,
&merged);
}
dns_slabheader_destroy(&newheader);
newheader = (dns_slabheader_t *)merged;
dns_slabheader_reset(newheader,
- (dns_db_t *)rbtdb,
+ (dns_db_t *)qpdb,
(dns_dbnode_t *)rbtnode);
dns_slabheader_copycase(newheader, header);
if (loading && RESIGN(newheader) &&
* special to be done w.r.t stale data; it gets replaced
* normally further down.
*/
- if (IS_CACHE(rbtdb) && ACTIVE(header, now) &&
+ if (IS_CACHE(qpdb) && ACTIVE(header, now) &&
header->type == dns_rdatatype_ns && !header_nx &&
!newheader_nx && header->trust >= newheader->trust &&
dns_rdataslab_equalx((unsigned char *)header,
(unsigned char *)newheader,
(unsigned int)(sizeof(*newheader)),
- rbtdb->common.rdclass,
+ qpdb->common.rdclass,
(dns_rdatatype_t)header->type))
{
/*
* older one.
*/
if (header->ttl > newheader->ttl) {
- dns__rbtdb_setttl(header, newheader->ttl);
+ dns__qpdb_setttl(header, newheader->ttl);
}
if (header->last_used != now) {
ISC_LIST_UNLINK(
- rbtdb->lru[RBTDB_HEADERNODE(header)
- ->locknum],
+ qpdb->lru[QPDB_HEADERNODE(header)
+ ->locknum],
header, link);
header->last_used = now;
ISC_LIST_PREPEND(
- rbtdb->lru[RBTDB_HEADERNODE(header)
- ->locknum],
+ qpdb->lru[QPDB_HEADERNODE(header)
+ ->locknum],
header, link);
}
if (header->noqname == NULL &&
}
dns_slabheader_destroy(&newheader);
if (addedrdataset != NULL) {
- dns__rbtdb_bindrdataset(
- rbtdb, rbtnode, header, now,
+ dns__qpdb_bindrdataset(
+ qpdb, rbtnode, header, now,
isc_rwlocktype_write,
addedrdataset DNS__DB_FLARG_PASS);
}
* to be no more than the current NS RRset's TTL. This
* ensures the delegations that are withdrawn are honoured.
*/
- if (IS_CACHE(rbtdb) && ACTIVE(header, now) &&
+ if (IS_CACHE(qpdb) && ACTIVE(header, now) &&
header->type == dns_rdatatype_ns && !header_nx &&
!newheader_nx && header->trust <= newheader->trust)
{
newheader->ttl = header->ttl;
}
}
- if (IS_CACHE(rbtdb) && ACTIVE(header, now) &&
+ if (IS_CACHE(qpdb) && ACTIVE(header, now) &&
(options & DNS_DBADD_PREFETCH) == 0 &&
(header->type == dns_rdatatype_a ||
header->type == dns_rdatatype_aaaa ||
* older one.
*/
if (header->ttl > newheader->ttl) {
- dns__rbtdb_setttl(header, newheader->ttl);
+ dns__qpdb_setttl(header, newheader->ttl);
}
if (header->last_used != now) {
ISC_LIST_UNLINK(
- rbtdb->lru[RBTDB_HEADERNODE(header)
- ->locknum],
+ qpdb->lru[QPDB_HEADERNODE(header)
+ ->locknum],
header, link);
header->last_used = now;
ISC_LIST_PREPEND(
- rbtdb->lru[RBTDB_HEADERNODE(header)
- ->locknum],
+ qpdb->lru[QPDB_HEADERNODE(header)
+ ->locknum],
header, link);
}
if (header->noqname == NULL &&
}
dns_slabheader_destroy(&newheader);
if (addedrdataset != NULL) {
- dns__rbtdb_bindrdataset(
- rbtdb, rbtnode, header, now,
+ dns__qpdb_bindrdataset(
+ qpdb, rbtnode, header, now,
isc_rwlocktype_write,
addedrdataset DNS__DB_FLARG_PASS);
}
rbtversion->serial >= topheader->serial);
if (loading) {
newheader->down = NULL;
- idx = RBTDB_HEADERNODE(newheader)->locknum;
- if (IS_CACHE(rbtdb)) {
+ idx = QPDB_HEADERNODE(newheader)->locknum;
+ if (IS_CACHE(qpdb)) {
if (ZEROTTL(newheader)) {
- newheader->last_used =
- rbtdb->last_used + 1;
- ISC_LIST_APPEND(rbtdb->lru[idx],
+ newheader->last_used = qpdb->last_used +
+ 1;
+ ISC_LIST_APPEND(qpdb->lru[idx],
newheader, link);
} else {
- ISC_LIST_PREPEND(rbtdb->lru[idx],
+ ISC_LIST_PREPEND(qpdb->lru[idx],
newheader, link);
}
- INSIST(rbtdb->heaps != NULL);
- isc_heap_insert(rbtdb->heaps[idx], newheader);
- newheader->heap = rbtdb->heaps[idx];
+ INSIST(qpdb->heaps != NULL);
+ isc_heap_insert(qpdb->heaps[idx], newheader);
+ newheader->heap = qpdb->heaps[idx];
} else if (RESIGN(newheader)) {
- dns__zonerbt_resigninsert(rbtdb, idx,
- newheader);
+ dns__qpzone_resigninsert(qpdb, idx, newheader);
/*
* Don't call resigndelete, we don't need
* to reverse the delete. The free_slabheader
}
dns_slabheader_destroy(&header);
} else {
- idx = RBTDB_HEADERNODE(newheader)->locknum;
- if (IS_CACHE(rbtdb)) {
- INSIST(rbtdb->heaps != NULL);
- isc_heap_insert(rbtdb->heaps[idx], newheader);
- newheader->heap = rbtdb->heaps[idx];
+ idx = QPDB_HEADERNODE(newheader)->locknum;
+ if (IS_CACHE(qpdb)) {
+ INSIST(qpdb->heaps != NULL);
+ isc_heap_insert(qpdb->heaps[idx], newheader);
+ newheader->heap = qpdb->heaps[idx];
if (ZEROTTL(newheader)) {
- newheader->last_used =
- rbtdb->last_used + 1;
- ISC_LIST_APPEND(rbtdb->lru[idx],
+ newheader->last_used = qpdb->last_used +
+ 1;
+ ISC_LIST_APPEND(qpdb->lru[idx],
newheader, link);
} else {
- ISC_LIST_PREPEND(rbtdb->lru[idx],
+ ISC_LIST_PREPEND(qpdb->lru[idx],
newheader, link);
}
} else if (RESIGN(newheader)) {
- dns__zonerbt_resigninsert(rbtdb, idx,
- newheader);
- dns__zonerbt_resigndelete(
- rbtdb, rbtversion,
+ dns__qpzone_resigninsert(qpdb, idx, newheader);
+ dns__qpzone_resigndelete(
+ qpdb, rbtversion,
header DNS__DB_FLARG_PASS);
}
if (topheader_prev != NULL) {
return (DNS_R_UNCHANGED);
}
- idx = RBTDB_HEADERNODE(newheader)->locknum;
- if (IS_CACHE(rbtdb)) {
- isc_heap_insert(rbtdb->heaps[idx], newheader);
- newheader->heap = rbtdb->heaps[idx];
+ idx = QPDB_HEADERNODE(newheader)->locknum;
+ if (IS_CACHE(qpdb)) {
+ isc_heap_insert(qpdb->heaps[idx], newheader);
+ newheader->heap = qpdb->heaps[idx];
if (ZEROTTL(newheader)) {
- ISC_LIST_APPEND(rbtdb->lru[idx], newheader,
+ ISC_LIST_APPEND(qpdb->lru[idx], newheader,
link);
} else {
- ISC_LIST_PREPEND(rbtdb->lru[idx], newheader,
+ ISC_LIST_PREPEND(qpdb->lru[idx], newheader,
link);
}
} else if (RESIGN(newheader)) {
- dns__zonerbt_resigninsert(rbtdb, idx, newheader);
- dns__zonerbt_resigndelete(rbtdb, rbtversion,
- header DNS__DB_FLARG_PASS);
+ dns__qpzone_resigninsert(qpdb, idx, newheader);
+ dns__qpzone_resigndelete(qpdb, rbtversion,
+ header DNS__DB_FLARG_PASS);
}
if (topheader != NULL) {
}
if (addedrdataset != NULL) {
- dns__rbtdb_bindrdataset(rbtdb, rbtnode, newheader, now,
- isc_rwlocktype_write,
- addedrdataset DNS__DB_FLARG_PASS);
+ dns__qpdb_bindrdataset(qpdb, rbtnode, newheader, now,
+ isc_rwlocktype_write,
+ addedrdataset DNS__DB_FLARG_PASS);
}
return (ISC_R_SUCCESS);
}
static bool
-delegating_type(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, dns_typepair_t type) {
- if (IS_CACHE(rbtdb)) {
+delegating_type(dns_qpdb_t *qpdb, dns_rbtnode_t *node, dns_typepair_t type) {
+ if (IS_CACHE(qpdb)) {
if (type == dns_rdatatype_dname) {
return (true);
} else {
}
} else if (type == dns_rdatatype_dname ||
(type == dns_rdatatype_ns &&
- (node != rbtdb->origin_node || IS_STUB(rbtdb))))
+ (node != qpdb->origin_node || IS_STUB(qpdb))))
{
return (true);
}
}
static void
-expire_ttl_headers(dns_rbtdb_t *rbtdb, unsigned int locknum,
+expire_ttl_headers(dns_qpdb_t *qpdb, unsigned int locknum,
isc_rwlocktype_t *tlocktypep, isc_stdtime_t now,
bool cache_is_overmem DNS__DB_FLARG);
isc_result_t
-dns__rbtdb_addrdataset(dns_db_t *db, dns_dbnode_t *node,
- dns_dbversion_t *version, isc_stdtime_t now,
- dns_rdataset_t *rdataset, unsigned int options,
- dns_rdataset_t *addedrdataset DNS__DB_FLARG) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
+dns__qpdb_addrdataset(dns_db_t *db, dns_dbnode_t *node,
+ dns_dbversion_t *version, isc_stdtime_t now,
+ dns_rdataset_t *rdataset, unsigned int options,
+ dns_rdataset_t *addedrdataset DNS__DB_FLARG) {
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node;
- dns_rbtdb_version_t *rbtversion = version;
+ dns_qpdb_version_t *rbtversion = version;
isc_region_t region;
dns_slabheader_t *newheader = NULL;
isc_result_t result;
dns_fixedname_t fixed;
dns_name_t *name = NULL;
- REQUIRE(VALID_RBTDB(rbtdb));
- INSIST(rbtversion == NULL || rbtversion->rbtdb == rbtdb);
+ REQUIRE(VALID_QPDB(qpdb));
+ INSIST(rbtversion == NULL || rbtversion->qpdb == qpdb);
- if (!IS_CACHE(rbtdb)) {
+ if (!IS_CACHE(qpdb)) {
/*
* SOA records are only allowed at top of zone.
*/
if (rdataset->type == dns_rdatatype_soa &&
- node != rbtdb->origin_node)
+ node != qpdb->origin_node)
{
return (DNS_R_NOTZONETOP);
}
- TREE_RDLOCK(&rbtdb->tree_lock, &tlocktype);
+ TREE_RDLOCK(&qpdb->tree_lock, &tlocktype);
REQUIRE(((rbtnode->nsec == DNS_DB_NSEC_NSEC3 &&
(rdataset->type == dns_rdatatype_nsec3 ||
rdataset->covers == dns_rdatatype_nsec3)) ||
(rbtnode->nsec != DNS_DB_NSEC_NSEC3 &&
rdataset->type != dns_rdatatype_nsec3 &&
rdataset->covers != dns_rdatatype_nsec3)));
- TREE_UNLOCK(&rbtdb->tree_lock, &tlocktype);
+ TREE_UNLOCK(&qpdb->tree_lock, &tlocktype);
}
if (rbtversion == NULL) {
now = 0;
}
- result = dns_rdataslab_fromrdataset(rdataset, rbtdb->common.mctx,
+ result = dns_rdataslab_fromrdataset(rdataset, qpdb->common.mctx,
®ion, sizeof(dns_slabheader_t));
if (result != ISC_R_SUCCESS) {
return (result);
}
name = dns_fixedname_initname(&fixed);
- dns__rbtdb_nodefullname(db, node, name);
+ dns__qpdb_nodefullname(db, node, name);
dns_rdataset_getownercase(rdataset, name);
newheader = (dns_slabheader_t *)region.base;
};
dns_slabheader_reset(newheader, db, node);
- dns__rbtdb_setttl(newheader, rdataset->ttl + now);
+ dns__qpdb_setttl(newheader, rdataset->ttl + now);
if (rdataset->ttl == 0U) {
DNS_SLABHEADER_SETATTR(newheader, DNS_SLABHEADERATTR_ZEROTTL);
}
DNS_SLABHEADERATTR_OPTOUT);
}
if ((rdataset->attributes & DNS_RDATASETATTR_NOQNAME) != 0) {
- result = addnoqname(rbtdb->common.mctx, newheader,
+ result = addnoqname(qpdb->common.mctx, newheader,
rdataset);
if (result != ISC_R_SUCCESS) {
dns_slabheader_destroy(&newheader);
}
}
if ((rdataset->attributes & DNS_RDATASETATTR_CLOSEST) != 0) {
- result = addclosest(rbtdb->common.mctx, newheader,
+ result = addclosest(qpdb->common.mctx, newheader,
rdataset);
if (result != ISC_R_SUCCESS) {
dns_slabheader_destroy(&newheader);
* just DNAME for the cache), then we need to set the callback bit
* on the node.
*/
- if (delegating_type(rbtdb, rbtnode, rdataset->type)) {
+ if (delegating_type(qpdb, rbtnode, rdataset->type)) {
delegating = true;
} else {
delegating = false;
/*
* Add to the auxiliary NSEC tree if we're adding an NSEC record.
*/
- TREE_RDLOCK(&rbtdb->tree_lock, &tlocktype);
+ TREE_RDLOCK(&qpdb->tree_lock, &tlocktype);
if (rbtnode->nsec != DNS_DB_NSEC_HAS_NSEC &&
rdataset->type == dns_rdatatype_nsec)
{
} else {
newnsec = false;
}
- TREE_UNLOCK(&rbtdb->tree_lock, &tlocktype);
+ TREE_UNLOCK(&qpdb->tree_lock, &tlocktype);
/*
* If we're adding a delegation type, adding to the auxiliary NSEC
* not necessarily have to be acquired but it will help purge
* ancient entries more effectively.
*/
- if (IS_CACHE(rbtdb) && isc_mem_isovermem(rbtdb->common.mctx)) {
+ if (IS_CACHE(qpdb) && isc_mem_isovermem(qpdb->common.mctx)) {
cache_is_overmem = true;
}
if (delegating || newnsec || cache_is_overmem) {
- TREE_WRLOCK(&rbtdb->tree_lock, &tlocktype);
+ TREE_WRLOCK(&qpdb->tree_lock, &tlocktype);
}
if (cache_is_overmem) {
- dns__cacherbt_overmem(rbtdb, newheader,
- &tlocktype DNS__DB_FLARG_PASS);
+ dns__qpcache_overmem(qpdb, newheader,
+ &tlocktype DNS__DB_FLARG_PASS);
}
- NODE_WRLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype);
+ NODE_WRLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype);
- if (rbtdb->rrsetstats != NULL) {
+ if (qpdb->rrsetstats != NULL) {
DNS_SLABHEADER_SETATTR(newheader, DNS_SLABHEADERATTR_STATCOUNT);
- update_rrsetstats(rbtdb->rrsetstats, newheader->type,
+ update_rrsetstats(qpdb->rrsetstats, newheader->type,
atomic_load_acquire(&newheader->attributes),
true);
}
- if (IS_CACHE(rbtdb)) {
+ if (IS_CACHE(qpdb)) {
if (tlocktype == isc_rwlocktype_write) {
- cleanup_dead_nodes(rbtdb,
+ cleanup_dead_nodes(qpdb,
rbtnode->locknum DNS__DB_FLARG_PASS);
}
- expire_ttl_headers(rbtdb, rbtnode->locknum, &tlocktype, now,
+ expire_ttl_headers(qpdb, rbtnode->locknum, &tlocktype, now,
cache_is_overmem DNS__DB_FLARG_PASS);
/*
if (tlocktype == isc_rwlocktype_write && !delegating &&
!newnsec)
{
- TREE_UNLOCK(&rbtdb->tree_lock, &tlocktype);
+ TREE_UNLOCK(&qpdb->tree_lock, &tlocktype);
}
}
if (newnsec) {
dns_rbtnode_t *nsecnode = NULL;
- result = dns_rbt_addnode(rbtdb->nsec, name, &nsecnode);
+ result = dns_rbt_addnode(qpdb->nsec, name, &nsecnode);
if (result == ISC_R_SUCCESS) {
nsecnode->nsec = DNS_DB_NSEC_NSEC;
rbtnode->nsec = DNS_DB_NSEC_HAS_NSEC;
}
if (result == ISC_R_SUCCESS) {
- result = dns__rbtdb_add(rbtdb, rbtnode, name, rbtversion,
- newheader, options, false,
- addedrdataset, now DNS__DB_FLARG_PASS);
+ result = dns__qpdb_add(qpdb, rbtnode, name, rbtversion,
+ newheader, options, false, addedrdataset,
+ now DNS__DB_FLARG_PASS);
}
if (result == ISC_R_SUCCESS && delegating) {
rbtnode->find_callback = 1;
}
- NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype);
+ NODE_UNLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype);
if (tlocktype != isc_rwlocktype_none) {
- TREE_UNLOCK(&rbtdb->tree_lock, &tlocktype);
+ TREE_UNLOCK(&qpdb->tree_lock, &tlocktype);
}
INSIST(tlocktype == isc_rwlocktype_none);
/*
* Update the zone's secure status. If version is non-NULL
- * this is deferred until dns__rbtdb_closeversion() is called.
+ * this is deferred until dns__qpdb_closeversion() is called.
*/
- if (result == ISC_R_SUCCESS && version == NULL && !IS_CACHE(rbtdb)) {
- dns__rbtdb_setsecure(db, version, rbtdb->origin_node);
+ if (result == ISC_R_SUCCESS && version == NULL && !IS_CACHE(qpdb)) {
+ dns__qpdb_setsecure(db, version, qpdb->origin_node);
}
return (result);
}
isc_result_t
-dns__rbtdb_subtractrdataset(dns_db_t *db, dns_dbnode_t *node,
- dns_dbversion_t *version, dns_rdataset_t *rdataset,
- unsigned int options,
- dns_rdataset_t *newrdataset DNS__DB_FLARG) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
+dns__qpdb_subtractrdataset(dns_db_t *db, dns_dbnode_t *node,
+ dns_dbversion_t *version, dns_rdataset_t *rdataset,
+ unsigned int options,
+ dns_rdataset_t *newrdataset DNS__DB_FLARG) {
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node;
- dns_rbtdb_version_t *rbtversion = version;
+ dns_qpdb_version_t *rbtversion = version;
dns_fixedname_t fname;
dns_name_t *nodename = dns_fixedname_initname(&fname);
dns_slabheader_t *topheader = NULL, *topheader_prev = NULL;
unsigned char *subresult = NULL;
isc_region_t region;
isc_result_t result;
- rbtdb_changed_t *changed = NULL;
+ qpdb_changed_t *changed = NULL;
isc_rwlocktype_t tlocktype = isc_rwlocktype_none;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
- REQUIRE(VALID_RBTDB(rbtdb));
- REQUIRE(rbtversion != NULL && rbtversion->rbtdb == rbtdb);
+ REQUIRE(VALID_QPDB(qpdb));
+ REQUIRE(rbtversion != NULL && rbtversion->qpdb == qpdb);
- if (!IS_CACHE(rbtdb)) {
- TREE_RDLOCK(&rbtdb->tree_lock, &tlocktype);
+ if (!IS_CACHE(qpdb)) {
+ TREE_RDLOCK(&qpdb->tree_lock, &tlocktype);
REQUIRE(((rbtnode->nsec == DNS_DB_NSEC_NSEC3 &&
(rdataset->type == dns_rdatatype_nsec3 ||
rdataset->covers == dns_rdatatype_nsec3)) ||
(rbtnode->nsec != DNS_DB_NSEC_NSEC3 &&
rdataset->type != dns_rdatatype_nsec3 &&
rdataset->covers != dns_rdatatype_nsec3)));
- TREE_UNLOCK(&rbtdb->tree_lock, &tlocktype);
+ TREE_UNLOCK(&qpdb->tree_lock, &tlocktype);
}
- dns__rbtdb_nodefullname(db, node, nodename);
+ dns__qpdb_nodefullname(db, node, nodename);
- result = dns_rdataslab_fromrdataset(rdataset, rbtdb->common.mctx,
+ result = dns_rdataslab_fromrdataset(rdataset, qpdb->common.mctx,
®ion, sizeof(dns_slabheader_t));
if (result != ISC_R_SUCCESS) {
return (result);
newheader = (dns_slabheader_t *)region.base;
dns_slabheader_reset(newheader, db, node);
- dns__rbtdb_setttl(newheader, rdataset->ttl);
+ dns__qpdb_setttl(newheader, rdataset->ttl);
newheader->type = DNS_TYPEPAIR_VALUE(rdataset->type, rdataset->covers);
atomic_init(&newheader->attributes, 0);
newheader->serial = rbtversion->serial;
atomic_fetch_add_relaxed(&init_count, 1));
newheader->last_used = 0;
newheader->node = rbtnode;
- newheader->db = (dns_db_t *)rbtdb;
+ newheader->db = (dns_db_t *)qpdb;
if ((rdataset->attributes & DNS_RDATASETATTR_RESIGN) != 0) {
DNS_SLABHEADER_SETATTR(newheader, DNS_SLABHEADERATTR_RESIGN);
newheader->resign =
newheader->resign_lsb = 0;
}
- NODE_WRLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype);
+ NODE_WRLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype);
changed = add_changed(newheader, rbtversion DNS__DB_FLARG_PASS);
if (changed == NULL) {
dns_slabheader_destroy(&newheader);
- NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock,
+ NODE_UNLOCK(&qpdb->node_locks[rbtnode->locknum].lock,
&nlocktype);
return (ISC_R_NOMEMORY);
}
(unsigned char *)header,
(unsigned char *)newheader,
(unsigned int)(sizeof(*newheader)),
- rbtdb->common.mctx, rbtdb->common.rdclass,
+ qpdb->common.mctx, qpdb->common.rdclass,
(dns_rdatatype_t)header->type, flags,
&subresult);
}
newheader, DNS_SLABHEADERATTR_RESIGN);
newheader->resign = header->resign;
newheader->resign_lsb = header->resign_lsb;
- dns__zonerbt_resigninsert(
- rbtdb, rbtnode->locknum, newheader);
+ dns__qpzone_resigninsert(qpdb, rbtnode->locknum,
+ newheader);
}
/*
* We have to set the serial since the rdataslab
* add a nonexistent header instead.
*/
dns_slabheader_destroy(&newheader);
- newheader = dns_slabheader_new((dns_db_t *)rbtdb,
+ newheader = dns_slabheader_new((dns_db_t *)qpdb,
(dns_dbnode_t *)rbtnode);
- dns__rbtdb_setttl(newheader, 0);
+ dns__qpdb_setttl(newheader, 0);
newheader->type = topheader->type;
atomic_init(&newheader->attributes,
DNS_SLABHEADERATTR_NONEXISTENT);
topheader->next = newheader;
rbtnode->dirty = 1;
changed->dirty = true;
- dns__zonerbt_resigndelete(rbtdb, rbtversion,
- header DNS__DB_FLARG_PASS);
+ dns__qpzone_resigndelete(qpdb, rbtversion,
+ header DNS__DB_FLARG_PASS);
} else {
/*
* The rdataset doesn't exist, so we don't need to do anything
}
if (result == ISC_R_SUCCESS && newrdataset != NULL) {
- dns__rbtdb_bindrdataset(rbtdb, rbtnode, newheader, 0,
- isc_rwlocktype_write,
- newrdataset DNS__DB_FLARG_PASS);
+ dns__qpdb_bindrdataset(qpdb, rbtnode, newheader, 0,
+ isc_rwlocktype_write,
+ newrdataset DNS__DB_FLARG_PASS);
}
if (result == DNS_R_NXRRSET && newrdataset != NULL &&
(options & DNS_DBSUB_WANTOLD) != 0)
{
- dns__rbtdb_bindrdataset(rbtdb, rbtnode, header, 0,
- isc_rwlocktype_write,
- newrdataset DNS__DB_FLARG_PASS);
+ dns__qpdb_bindrdataset(qpdb, rbtnode, header, 0,
+ isc_rwlocktype_write,
+ newrdataset DNS__DB_FLARG_PASS);
}
unlock:
- NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype);
+ NODE_UNLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype);
/*
* Update the zone's secure status. If version is non-NULL
- * this is deferred until dns__rbtdb_closeversion() is called.
+ * this is deferred until dns__qpdb_closeversion() is called.
*/
- if (result == ISC_R_SUCCESS && version == NULL && !IS_CACHE(rbtdb)) {
- RWLOCK(&rbtdb->lock, isc_rwlocktype_read);
- version = rbtdb->current_version;
- RWUNLOCK(&rbtdb->lock, isc_rwlocktype_read);
- dns__rbtdb_setsecure(db, version, rbtdb->origin_node);
+ if (result == ISC_R_SUCCESS && version == NULL && !IS_CACHE(qpdb)) {
+ RWLOCK(&qpdb->lock, isc_rwlocktype_read);
+ version = qpdb->current_version;
+ RWUNLOCK(&qpdb->lock, isc_rwlocktype_read);
+ dns__qpdb_setsecure(db, version, qpdb->origin_node);
}
return (result);
}
isc_result_t
-dns__rbtdb_deleterdataset(dns_db_t *db, dns_dbnode_t *node,
- dns_dbversion_t *version, dns_rdatatype_t type,
- dns_rdatatype_t covers DNS__DB_FLARG) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
+dns__qpdb_deleterdataset(dns_db_t *db, dns_dbnode_t *node,
+ dns_dbversion_t *version, dns_rdatatype_t type,
+ dns_rdatatype_t covers DNS__DB_FLARG) {
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node;
- dns_rbtdb_version_t *rbtversion = version;
+ dns_qpdb_version_t *rbtversion = version;
dns_fixedname_t fname;
dns_name_t *nodename = dns_fixedname_initname(&fname);
isc_result_t result;
dns_slabheader_t *newheader = NULL;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
- REQUIRE(VALID_RBTDB(rbtdb));
- INSIST(rbtversion == NULL || rbtversion->rbtdb == rbtdb);
+ REQUIRE(VALID_QPDB(qpdb));
+ INSIST(rbtversion == NULL || rbtversion->qpdb == qpdb);
if (type == dns_rdatatype_any) {
return (ISC_R_NOTIMPLEMENTED);
newheader = dns_slabheader_new(db, node);
newheader->type = DNS_TYPEPAIR_VALUE(type, covers);
- dns__rbtdb_setttl(newheader, 0);
+ dns__qpdb_setttl(newheader, 0);
atomic_init(&newheader->attributes, DNS_SLABHEADERATTR_NONEXISTENT);
if (rbtversion != NULL) {
newheader->serial = rbtversion->serial;
}
- dns__rbtdb_nodefullname(db, node, nodename);
+ dns__qpdb_nodefullname(db, node, nodename);
- NODE_WRLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype);
- result = dns__rbtdb_add(rbtdb, rbtnode, nodename, rbtversion, newheader,
- DNS_DBADD_FORCE, false, NULL,
- 0 DNS__DB_FLARG_PASS);
- NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype);
+ NODE_WRLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype);
+ result = dns__qpdb_add(qpdb, rbtnode, nodename, rbtversion, newheader,
+ DNS_DBADD_FORCE, false, NULL,
+ 0 DNS__DB_FLARG_PASS);
+ NODE_UNLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype);
/*
* Update the zone's secure status. If version is non-NULL
- * this is deferred until dns__rbtdb_closeversion() is called.
+ * this is deferred until dns__qpdb_closeversion() is called.
*/
- if (result == ISC_R_SUCCESS && version == NULL && !IS_CACHE(rbtdb)) {
- RWLOCK(&rbtdb->lock, isc_rwlocktype_read);
- version = rbtdb->current_version;
- RWUNLOCK(&rbtdb->lock, isc_rwlocktype_read);
- dns__rbtdb_setsecure(db, version, rbtdb->origin_node);
+ if (result == ISC_R_SUCCESS && version == NULL && !IS_CACHE(qpdb)) {
+ RWLOCK(&qpdb->lock, isc_rwlocktype_read);
+ version = qpdb->current_version;
+ RWUNLOCK(&qpdb->lock, isc_rwlocktype_read);
+ dns__qpdb_setsecure(db, version, qpdb->origin_node);
}
return (result);
}
unsigned int
-dns__rbtdb_nodecount(dns_db_t *db, dns_dbtree_t tree) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
+dns__qpdb_nodecount(dns_db_t *db, dns_dbtree_t tree) {
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
unsigned int count;
isc_rwlocktype_t tlocktype = isc_rwlocktype_none;
- REQUIRE(VALID_RBTDB(rbtdb));
+ REQUIRE(VALID_QPDB(qpdb));
- TREE_RDLOCK(&rbtdb->tree_lock, &tlocktype);
+ TREE_RDLOCK(&qpdb->tree_lock, &tlocktype);
switch (tree) {
case dns_dbtree_main:
- count = dns_rbt_nodecount(rbtdb->tree);
+ count = dns_rbt_nodecount(qpdb->tree);
break;
case dns_dbtree_nsec:
- count = dns_rbt_nodecount(rbtdb->nsec);
+ count = dns_rbt_nodecount(qpdb->nsec);
break;
case dns_dbtree_nsec3:
- count = dns_rbt_nodecount(rbtdb->nsec3);
+ count = dns_rbt_nodecount(qpdb->nsec3);
break;
default:
UNREACHABLE();
}
- TREE_UNLOCK(&rbtdb->tree_lock, &tlocktype);
+ TREE_UNLOCK(&qpdb->tree_lock, &tlocktype);
return (count);
}
void
-dns__rbtdb_setloop(dns_db_t *db, isc_loop_t *loop) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
+dns__qpdb_setloop(dns_db_t *db, isc_loop_t *loop) {
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
- REQUIRE(VALID_RBTDB(rbtdb));
+ REQUIRE(VALID_QPDB(qpdb));
- RWLOCK(&rbtdb->lock, isc_rwlocktype_write);
- if (rbtdb->loop != NULL) {
- isc_loop_detach(&rbtdb->loop);
+ RWLOCK(&qpdb->lock, isc_rwlocktype_write);
+ if (qpdb->loop != NULL) {
+ isc_loop_detach(&qpdb->loop);
}
if (loop != NULL) {
- isc_loop_attach(loop, &rbtdb->loop);
+ isc_loop_attach(loop, &qpdb->loop);
}
- RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write);
+ RWUNLOCK(&qpdb->lock, isc_rwlocktype_write);
}
isc_result_t
-dns__rbtdb_getoriginnode(dns_db_t *db, dns_dbnode_t **nodep DNS__DB_FLARG) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
+dns__qpdb_getoriginnode(dns_db_t *db, dns_dbnode_t **nodep DNS__DB_FLARG) {
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
dns_rbtnode_t *onode = NULL;
isc_result_t result = ISC_R_SUCCESS;
- REQUIRE(VALID_RBTDB(rbtdb));
+ REQUIRE(VALID_QPDB(qpdb));
REQUIRE(nodep != NULL && *nodep == NULL);
/* Note that the access to origin_node doesn't require a DB lock */
- onode = (dns_rbtnode_t *)rbtdb->origin_node;
+ onode = (dns_rbtnode_t *)qpdb->origin_node;
if (onode != NULL) {
- dns__rbtdb_newref(rbtdb, onode,
- isc_rwlocktype_none DNS__DB_FLARG_PASS);
- *nodep = rbtdb->origin_node;
+ dns__qpdb_newref(qpdb, onode,
+ isc_rwlocktype_none DNS__DB_FLARG_PASS);
+ *nodep = qpdb->origin_node;
} else {
- INSIST(IS_CACHE(rbtdb));
+ INSIST(IS_CACHE(qpdb));
result = ISC_R_NOTFOUND;
}
}
void
-dns__rbtdb_locknode(dns_db_t *db, dns_dbnode_t *node, isc_rwlocktype_t type) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
+dns__qpdb_locknode(dns_db_t *db, dns_dbnode_t *node, isc_rwlocktype_t type) {
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node;
- RWLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, type);
+ RWLOCK(&qpdb->node_locks[rbtnode->locknum].lock, type);
}
void
-dns__rbtdb_unlocknode(dns_db_t *db, dns_dbnode_t *node, isc_rwlocktype_t type) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
+dns__qpdb_unlocknode(dns_db_t *db, dns_dbnode_t *node, isc_rwlocktype_t type) {
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node;
- RWUNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, type);
+ RWUNLOCK(&qpdb->node_locks[rbtnode->locknum].lock, type);
}
isc_result_t
-dns__rbtdb_nodefullname(dns_db_t *db, dns_dbnode_t *node, dns_name_t *name) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
+dns__qpdb_nodefullname(dns_db_t *db, dns_dbnode_t *node, dns_name_t *name) {
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node;
isc_result_t result;
isc_rwlocktype_t tlocktype = isc_rwlocktype_none;
- REQUIRE(VALID_RBTDB(rbtdb));
+ REQUIRE(VALID_QPDB(qpdb));
REQUIRE(node != NULL);
REQUIRE(name != NULL);
- TREE_RDLOCK(&rbtdb->tree_lock, &tlocktype);
+ TREE_RDLOCK(&qpdb->tree_lock, &tlocktype);
result = dns_rbt_fullnamefromnode(rbtnode, name);
- TREE_UNLOCK(&rbtdb->tree_lock, &tlocktype);
+ TREE_UNLOCK(&qpdb->tree_lock, &tlocktype);
return (result);
}
isc_result_t
-dns__rbtdb_create(isc_mem_t *mctx, const dns_name_t *origin, dns_dbtype_t type,
- dns_rdataclass_t rdclass, unsigned int argc, char *argv[],
- void *driverarg ISC_ATTR_UNUSED, dns_db_t **dbp) {
- dns_rbtdb_t *rbtdb = NULL;
+dns__qpdb_create(isc_mem_t *mctx, const dns_name_t *origin, dns_dbtype_t type,
+ dns_rdataclass_t rdclass, unsigned int argc, char *argv[],
+ void *driverarg ISC_ATTR_UNUSED, dns_db_t **dbp) {
+ dns_qpdb_t *qpdb = NULL;
isc_result_t result;
int i;
isc_mem_t *hmctx = mctx;
- rbtdb = isc_mem_get(mctx, sizeof(*rbtdb));
- *rbtdb = (dns_rbtdb_t){
+ qpdb = isc_mem_get(mctx, sizeof(*qpdb));
+ *qpdb = (dns_qpdb_t){
.common.origin = DNS_NAME_INITEMPTY,
.common.rdclass = rdclass,
.current_serial = 1,
.open_versions = ISC_LIST_INITIALIZER,
};
- isc_refcount_init(&rbtdb->common.references, 1);
+ isc_refcount_init(&qpdb->common.references, 1);
/*
* If argv[0] exists, it points to a memory context to use for heap
}
if (type == dns_dbtype_cache) {
- rbtdb->common.methods = &dns__rbtdb_cachemethods;
- rbtdb->common.attributes |= DNS_DBATTR_CACHE;
+ qpdb->common.methods = &dns__qpdb_cachemethods;
+ qpdb->common.attributes |= DNS_DBATTR_CACHE;
} else if (type == dns_dbtype_stub) {
- rbtdb->common.methods = &dns__rbtdb_zonemethods;
- rbtdb->common.attributes |= DNS_DBATTR_STUB;
+ qpdb->common.methods = &dns__qpdb_zonemethods;
+ qpdb->common.attributes |= DNS_DBATTR_STUB;
} else {
- rbtdb->common.methods = &dns__rbtdb_zonemethods;
+ qpdb->common.methods = &dns__qpdb_zonemethods;
}
- isc_rwlock_init(&rbtdb->lock);
- TREE_INITLOCK(&rbtdb->tree_lock);
+ isc_rwlock_init(&qpdb->lock);
+ TREE_INITLOCK(&qpdb->tree_lock);
/*
* Initialize node_lock_count in a generic way to support future
* Note that when specified for a cache DB it must be larger than 1
* as commented with the definition of DEFAULT_CACHE_NODE_LOCK_COUNT.
*/
- if (rbtdb->node_lock_count == 0) {
- if (IS_CACHE(rbtdb)) {
- rbtdb->node_lock_count = DEFAULT_CACHE_NODE_LOCK_COUNT;
+ if (qpdb->node_lock_count == 0) {
+ if (IS_CACHE(qpdb)) {
+ qpdb->node_lock_count = DEFAULT_CACHE_NODE_LOCK_COUNT;
} else {
- rbtdb->node_lock_count = DEFAULT_NODE_LOCK_COUNT;
+ qpdb->node_lock_count = DEFAULT_NODE_LOCK_COUNT;
}
- } else if (rbtdb->node_lock_count < 2 && IS_CACHE(rbtdb)) {
+ } else if (qpdb->node_lock_count < 2 && IS_CACHE(qpdb)) {
result = ISC_R_RANGE;
goto cleanup_tree_lock;
}
- INSIST(rbtdb->node_lock_count < (1 << DNS_RBT_LOCKLENGTH));
- rbtdb->node_locks = isc_mem_get(mctx, rbtdb->node_lock_count *
- sizeof(db_nodelock_t));
+ INSIST(qpdb->node_lock_count < (1 << DNS_RBT_LOCKLENGTH));
+ qpdb->node_locks = isc_mem_get(mctx, qpdb->node_lock_count *
+ sizeof(db_nodelock_t));
- rbtdb->common.update_listeners = cds_lfht_new(16, 16, 0, 0, NULL);
+ qpdb->common.update_listeners = cds_lfht_new(16, 16, 0, 0, NULL);
- if (IS_CACHE(rbtdb)) {
- dns_rdatasetstats_create(mctx, &rbtdb->rrsetstats);
- rbtdb->lru = isc_mem_get(mctx,
- rbtdb->node_lock_count *
- sizeof(dns_slabheaderlist_t));
- for (i = 0; i < (int)rbtdb->node_lock_count; i++) {
- ISC_LIST_INIT(rbtdb->lru[i]);
+ if (IS_CACHE(qpdb)) {
+ dns_rdatasetstats_create(mctx, &qpdb->rrsetstats);
+ qpdb->lru = isc_mem_get(mctx,
+ qpdb->node_lock_count *
+ sizeof(dns_slabheaderlist_t));
+ for (i = 0; i < (int)qpdb->node_lock_count; i++) {
+ ISC_LIST_INIT(qpdb->lru[i]);
}
}
/*
* Create the heaps.
*/
- rbtdb->heaps = isc_mem_get(hmctx, rbtdb->node_lock_count *
- sizeof(isc_heap_t *));
- for (i = 0; i < (int)rbtdb->node_lock_count; i++) {
- rbtdb->heaps[i] = NULL;
+ qpdb->heaps = isc_mem_get(hmctx,
+ qpdb->node_lock_count * sizeof(isc_heap_t *));
+ for (i = 0; i < (int)qpdb->node_lock_count; i++) {
+ qpdb->heaps[i] = NULL;
}
- rbtdb->sooner = IS_CACHE(rbtdb) ? ttl_sooner : resign_sooner;
- for (i = 0; i < (int)rbtdb->node_lock_count; i++) {
- isc_heap_create(hmctx, rbtdb->sooner, set_index, 0,
- &rbtdb->heaps[i]);
+ qpdb->sooner = IS_CACHE(qpdb) ? ttl_sooner : resign_sooner;
+ for (i = 0; i < (int)qpdb->node_lock_count; i++) {
+ isc_heap_create(hmctx, qpdb->sooner, set_index, 0,
+ &qpdb->heaps[i]);
}
/*
* Create deadnode lists.
*/
- rbtdb->deadnodes = isc_mem_get(mctx, rbtdb->node_lock_count *
- sizeof(dns_rbtnodelist_t));
- for (i = 0; i < (int)rbtdb->node_lock_count; i++) {
- ISC_LIST_INIT(rbtdb->deadnodes[i]);
+ qpdb->deadnodes = isc_mem_get(mctx, qpdb->node_lock_count *
+ sizeof(dns_rbtnodelist_t));
+ for (i = 0; i < (int)qpdb->node_lock_count; i++) {
+ ISC_LIST_INIT(qpdb->deadnodes[i]);
}
- rbtdb->active = rbtdb->node_lock_count;
+ qpdb->active = qpdb->node_lock_count;
- for (i = 0; i < (int)(rbtdb->node_lock_count); i++) {
- NODE_INITLOCK(&rbtdb->node_locks[i].lock);
- isc_refcount_init(&rbtdb->node_locks[i].references, 0);
- rbtdb->node_locks[i].exiting = false;
+ for (i = 0; i < (int)(qpdb->node_lock_count); i++) {
+ NODE_INITLOCK(&qpdb->node_locks[i].lock);
+ isc_refcount_init(&qpdb->node_locks[i].references, 0);
+ qpdb->node_locks[i].exiting = false;
}
/*
* are references to it, and attaching to the mctx ensures that our
* mctx won't disappear out from under us.
*/
- isc_mem_attach(mctx, &rbtdb->common.mctx);
- isc_mem_attach(hmctx, &rbtdb->hmctx);
+ isc_mem_attach(mctx, &qpdb->common.mctx);
+ isc_mem_attach(hmctx, &qpdb->hmctx);
/*
* Make a copy of the origin name.
*/
- result = dns_name_dupwithoffsets(origin, mctx, &rbtdb->common.origin);
+ result = dns_name_dupwithoffsets(origin, mctx, &qpdb->common.origin);
if (result != ISC_R_SUCCESS) {
- free_rbtdb(rbtdb, false);
+ free_qpdb(qpdb, false);
return (result);
}
/*
* Make the qp tries.
*/
- dns_qp_create(mctx, &qpmethods, rbtdb, &rbtdb->tree);
- dns_qp_create(mctx, &qpmethods, rbtdb, &rbtdb->nsec);
- dns_qp_create(mctx, &qpmethods, rbtdb, &rbtdb->nsec3);
+ dns_qp_create(mctx, &qpmethods, qpdb, &qpdb->tree);
+ dns_qp_create(mctx, &qpmethods, qpdb, &qpdb->nsec);
+ dns_qp_create(mctx, &qpmethods, qpdb, &qpdb->nsec3);
/*
* In order to set the node callback bit correctly in zone databases,
* we need to know if the node has the origin name of the zone.
* In loading_addrdataset() we could simply compare the new name
* to the origin name, but this is expensive. Also, we don't know the
- * node name in dns__rbtdb_addrdataset(), so we need another way of
+ * node name in dns__qpdb_addrdataset(), so we need another way of
* knowing the zone's top.
*
* We now explicitly create a node for the zone's origin, and then
* the top-of-zone node can never be deleted, nor can its address
* change.
*/
- if (!IS_CACHE(rbtdb)) {
- result = dns_rbt_addnode(rbtdb->tree, &rbtdb->common.origin,
- &rbtdb->origin_node);
+ if (!IS_CACHE(qpdb)) {
+ result = dns_rbt_addnode(qpdb->tree, &qpdb->common.origin,
+ &qpdb->origin_node);
if (result != ISC_R_SUCCESS) {
INSIST(result != ISC_R_EXISTS);
- free_rbtdb(rbtdb, false);
+ free_qpdb(qpdb, false);
return (result);
}
- INSIST(rbtdb->origin_node != NULL);
- rbtdb->origin_node->nsec = DNS_DB_NSEC_NORMAL;
+ INSIST(qpdb->origin_node != NULL);
+ qpdb->origin_node->nsec = DNS_DB_NSEC_NORMAL;
/*
* Add an apex node to the NSEC3 tree so that NSEC3 searches
* return partial matches when there is only a single NSEC3
* record in the tree.
*/
- result = dns_rbt_addnode(rbtdb->nsec3, &rbtdb->common.origin,
- &rbtdb->nsec3_origin_node);
+ result = dns_rbt_addnode(qpdb->nsec3, &qpdb->common.origin,
+ &qpdb->nsec3_origin_node);
if (result != ISC_R_SUCCESS) {
INSIST(result != ISC_R_EXISTS);
- free_rbtdb(rbtdb, false);
+ free_qpdb(qpdb, false);
return (result);
}
INSIST(result == ISC_R_SUCCESS);
- INSIST(rbtdb->nsec3_origin_node != NULL);
- rbtdb->nsec3_origin_node->nsec = DNS_DB_NSEC_NSEC3;
+ INSIST(qpdb->nsec3_origin_node != NULL);
+ qpdb->nsec3_origin_node->nsec = DNS_DB_NSEC_NSEC3;
}
/*
* Version Initialization.
*/
- rbtdb->current_version = allocate_version(mctx, 1, 1, false);
- rbtdb->current_version->rbtdb = rbtdb;
- isc_rwlock_init(&rbtdb->current_version->rwlock);
+ qpdb->current_version = allocate_version(mctx, 1, 1, false);
+ qpdb->current_version->qpdb = qpdb;
+ isc_rwlock_init(&qpdb->current_version->rwlock);
/*
* Keep the current version in the open list so that list operation
* won't happen in normal lookup operations.
*/
- PREPEND(rbtdb->open_versions, rbtdb->current_version, link);
+ PREPEND(qpdb->open_versions, qpdb->current_version, link);
- rbtdb->common.magic = DNS_DB_MAGIC;
- rbtdb->common.impmagic = RBTDB_MAGIC;
+ qpdb->common.magic = DNS_DB_MAGIC;
+ qpdb->common.impmagic = QPDB_MAGIC;
- *dbp = (dns_db_t *)rbtdb;
+ *dbp = (dns_db_t *)qpdb;
return (ISC_R_SUCCESS);
cleanup_tree_lock:
- TREE_DESTROYLOCK(&rbtdb->tree_lock);
- isc_rwlock_destroy(&rbtdb->lock);
- isc_mem_put(mctx, rbtdb, sizeof(*rbtdb));
+ TREE_DESTROYLOCK(&qpdb->tree_lock);
+ isc_rwlock_destroy(&qpdb->lock);
+ isc_mem_put(mctx, qpdb, sizeof(*qpdb));
return (result);
}
static void
rdatasetiter_destroy(dns_rdatasetiter_t **iteratorp DNS__DB_FLARG) {
- rbtdb_rdatasetiter_t *rbtiterator = NULL;
+ qpdb_rdatasetiter_t *rbtiterator = NULL;
- rbtiterator = (rbtdb_rdatasetiter_t *)(*iteratorp);
+ rbtiterator = (qpdb_rdatasetiter_t *)(*iteratorp);
if (rbtiterator->common.version != NULL) {
- dns__rbtdb_closeversion(rbtiterator->common.db,
- &rbtiterator->common.version,
- false DNS__DB_FLARG_PASS);
+ dns__qpdb_closeversion(rbtiterator->common.db,
+ &rbtiterator->common.version,
+ false DNS__DB_FLARG_PASS);
}
dns__db_detachnode(rbtiterator->common.db,
&rbtiterator->common.node DNS__DB_FLARG_PASS);
}
static bool
-iterator_active(dns_rbtdb_t *rbtdb, rbtdb_rdatasetiter_t *rbtiterator,
+iterator_active(dns_qpdb_t *qpdb, qpdb_rdatasetiter_t *rbtiterator,
dns_slabheader_t *header) {
- dns_ttl_t stale_ttl = header->ttl + STALE_TTL(header, rbtdb);
+ dns_ttl_t stale_ttl = header->ttl + STALE_TTL(header, qpdb);
/*
* Is this a "this rdataset doesn't exist" record?
/*
* If this is a zone or this header still active then return it.
*/
- if (!IS_CACHE(rbtdb) || ACTIVE(header, rbtiterator->common.now)) {
+ if (!IS_CACHE(qpdb) || ACTIVE(header, rbtiterator->common.now)) {
return (true);
}
static isc_result_t
rdatasetiter_first(dns_rdatasetiter_t *iterator DNS__DB_FLARG) {
- rbtdb_rdatasetiter_t *rbtiterator = (rbtdb_rdatasetiter_t *)iterator;
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)(rbtiterator->common.db);
+ qpdb_rdatasetiter_t *rbtiterator = (qpdb_rdatasetiter_t *)iterator;
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)(rbtiterator->common.db);
dns_rbtnode_t *rbtnode = rbtiterator->common.node;
- dns_rbtdb_version_t *rbtversion = rbtiterator->common.version;
+ dns_qpdb_version_t *rbtversion = rbtiterator->common.version;
dns_slabheader_t *header = NULL, *top_next = NULL;
- uint32_t serial = IS_CACHE(rbtdb) ? 1 : rbtversion->serial;
+ uint32_t serial = IS_CACHE(qpdb) ? 1 : rbtversion->serial;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
- NODE_RDLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype);
+ NODE_RDLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype);
for (header = rbtnode->data; header != NULL; header = top_next) {
top_next = header->next;
header = header->down;
} else if (header->serial <= serial && !IGNORE(header))
{
- if (!iterator_active(rbtdb, rbtiterator,
- header))
+ if (!iterator_active(qpdb, rbtiterator, header))
{
header = NULL;
}
}
}
- NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype);
+ NODE_UNLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype);
rbtiterator->current = header;
static isc_result_t
rdatasetiter_next(dns_rdatasetiter_t *iterator DNS__DB_FLARG) {
- rbtdb_rdatasetiter_t *rbtiterator = (rbtdb_rdatasetiter_t *)iterator;
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)(rbtiterator->common.db);
+ qpdb_rdatasetiter_t *rbtiterator = (qpdb_rdatasetiter_t *)iterator;
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)(rbtiterator->common.db);
dns_rbtnode_t *rbtnode = rbtiterator->common.node;
- dns_rbtdb_version_t *rbtversion = rbtiterator->common.version;
+ dns_qpdb_version_t *rbtversion = rbtiterator->common.version;
dns_slabheader_t *header = NULL, *top_next = NULL;
- uint32_t serial = IS_CACHE(rbtdb) ? 1 : rbtversion->serial;
+ uint32_t serial = IS_CACHE(qpdb) ? 1 : rbtversion->serial;
dns_typepair_t type, negtype;
dns_rdatatype_t rdtype, covers;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
return (ISC_R_NOMORE);
}
- NODE_RDLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype);
+ NODE_RDLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype);
type = header->type;
rdtype = DNS_TYPEPAIR_TYPE(header->type);
header = header->down;
} else if (header->serial <= serial && !IGNORE(header))
{
- if (!iterator_active(rbtdb, rbtiterator,
- header))
+ if (!iterator_active(qpdb, rbtiterator, header))
{
header = NULL;
}
}
}
- NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype);
+ NODE_UNLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype);
rbtiterator->current = header;
static void
rdatasetiter_current(dns_rdatasetiter_t *iterator,
dns_rdataset_t *rdataset DNS__DB_FLARG) {
- rbtdb_rdatasetiter_t *rbtiterator = (rbtdb_rdatasetiter_t *)iterator;
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)(rbtiterator->common.db);
+ qpdb_rdatasetiter_t *rbtiterator = (qpdb_rdatasetiter_t *)iterator;
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)(rbtiterator->common.db);
dns_rbtnode_t *rbtnode = rbtiterator->common.node;
dns_slabheader_t *header = NULL;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
header = rbtiterator->current;
REQUIRE(header != NULL);
- NODE_RDLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype);
+ NODE_RDLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype);
- dns__rbtdb_bindrdataset(rbtdb, rbtnode, header, rbtiterator->common.now,
- isc_rwlocktype_read,
- rdataset DNS__DB_FLARG_PASS);
+ dns__qpdb_bindrdataset(qpdb, rbtnode, header, rbtiterator->common.now,
+ isc_rwlocktype_read,
+ rdataset DNS__DB_FLARG_PASS);
- NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype);
+ NODE_UNLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype);
}
/*
*/
static void
-reference_iter_node(rbtdb_dbiterator_t *rbtdbiter DNS__DB_FLARG) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)rbtdbiter->common.db;
- dns_rbtnode_t *node = rbtdbiter->node;
+reference_iter_node(qpdb_dbiterator_t *qpdbiter DNS__DB_FLARG) {
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)qpdbiter->common.db;
+ dns_rbtnode_t *node = qpdbiter->node;
if (node == NULL) {
return;
}
- INSIST(rbtdbiter->tree_locked != isc_rwlocktype_none);
- reactivate_node(rbtdb, node, rbtdbiter->tree_locked DNS__DB_FLARG_PASS);
+ INSIST(qpdbiter->tree_locked != isc_rwlocktype_none);
+ reactivate_node(qpdb, node, qpdbiter->tree_locked DNS__DB_FLARG_PASS);
}
static void
-dereference_iter_node(rbtdb_dbiterator_t *rbtdbiter DNS__DB_FLARG) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)rbtdbiter->common.db;
- dns_rbtnode_t *node = rbtdbiter->node;
+dereference_iter_node(qpdb_dbiterator_t *qpdbiter DNS__DB_FLARG) {
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)qpdbiter->common.db;
+ dns_rbtnode_t *node = qpdbiter->node;
isc_rwlock_t *lock = NULL;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
- isc_rwlocktype_t tlocktype = rbtdbiter->tree_locked;
+ isc_rwlocktype_t tlocktype = qpdbiter->tree_locked;
if (node == NULL) {
return;
REQUIRE(tlocktype != isc_rwlocktype_write);
- lock = &rbtdb->node_locks[node->locknum].lock;
+ lock = &qpdb->node_locks[node->locknum].lock;
NODE_RDLOCK(lock, &nlocktype);
- dns__rbtdb_decref(rbtdb, node, 0, &nlocktype, &rbtdbiter->tree_locked,
- false, false DNS__DB_FLARG_PASS);
+ dns__qpdb_decref(qpdb, node, 0, &nlocktype, &qpdbiter->tree_locked,
+ false, false DNS__DB_FLARG_PASS);
NODE_UNLOCK(lock, &nlocktype);
- INSIST(rbtdbiter->tree_locked == tlocktype);
+ INSIST(qpdbiter->tree_locked == tlocktype);
- rbtdbiter->node = NULL;
+ qpdbiter->node = NULL;
}
static void
-resume_iteration(rbtdb_dbiterator_t *rbtdbiter) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)rbtdbiter->common.db;
+resume_iteration(qpdb_dbiterator_t *qpdbiter) {
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)qpdbiter->common.db;
- REQUIRE(rbtdbiter->paused);
- REQUIRE(rbtdbiter->tree_locked == isc_rwlocktype_none);
+ REQUIRE(qpdbiter->paused);
+ REQUIRE(qpdbiter->tree_locked == isc_rwlocktype_none);
- TREE_RDLOCK(&rbtdb->tree_lock, &rbtdbiter->tree_locked);
+ TREE_RDLOCK(&qpdb->tree_lock, &qpdbiter->tree_locked);
- rbtdbiter->paused = false;
+ qpdbiter->paused = false;
}
static void
dbiterator_destroy(dns_dbiterator_t **iteratorp DNS__DB_FLARG) {
- rbtdb_dbiterator_t *rbtdbiter = (rbtdb_dbiterator_t *)(*iteratorp);
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)rbtdbiter->common.db;
+ qpdb_dbiterator_t *qpdbiter = (qpdb_dbiterator_t *)(*iteratorp);
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)qpdbiter->common.db;
dns_db_t *db = NULL;
- if (rbtdbiter->tree_locked == isc_rwlocktype_read) {
- TREE_UNLOCK(&rbtdb->tree_lock, &rbtdbiter->tree_locked);
+ if (qpdbiter->tree_locked == isc_rwlocktype_read) {
+ TREE_UNLOCK(&qpdb->tree_lock, &qpdbiter->tree_locked);
}
- INSIST(rbtdbiter->tree_locked == isc_rwlocktype_none);
+ INSIST(qpdbiter->tree_locked == isc_rwlocktype_none);
- dereference_iter_node(rbtdbiter DNS__DB_FLARG_PASS);
+ dereference_iter_node(qpdbiter DNS__DB_FLARG_PASS);
- dns_db_attach(rbtdbiter->common.db, &db);
- dns_db_detach(&rbtdbiter->common.db);
+ dns_db_attach(qpdbiter->common.db, &db);
+ dns_db_detach(&qpdbiter->common.db);
- dns_rbtnodechain_reset(&rbtdbiter->chain);
- dns_rbtnodechain_reset(&rbtdbiter->nsec3chain);
- isc_mem_put(db->mctx, rbtdbiter, sizeof(*rbtdbiter));
+ dns_rbtnodechain_reset(&qpdbiter->chain);
+ dns_rbtnodechain_reset(&qpdbiter->nsec3chain);
+ isc_mem_put(db->mctx, qpdbiter, sizeof(*qpdbiter));
dns_db_detach(&db);
*iteratorp = NULL;
static isc_result_t
dbiterator_first(dns_dbiterator_t *iterator DNS__DB_FLARG) {
isc_result_t result;
- rbtdb_dbiterator_t *rbtdbiter = (rbtdb_dbiterator_t *)iterator;
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)iterator->db;
+ qpdb_dbiterator_t *qpdbiter = (qpdb_dbiterator_t *)iterator;
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)iterator->db;
dns_name_t *name = NULL, *origin = NULL;
- if (rbtdbiter->result != ISC_R_SUCCESS &&
- rbtdbiter->result != ISC_R_NOTFOUND &&
- rbtdbiter->result != DNS_R_PARTIALMATCH &&
- rbtdbiter->result != ISC_R_NOMORE)
+ if (qpdbiter->result != ISC_R_SUCCESS &&
+ qpdbiter->result != ISC_R_NOTFOUND &&
+ qpdbiter->result != DNS_R_PARTIALMATCH &&
+ qpdbiter->result != ISC_R_NOMORE)
{
- return (rbtdbiter->result);
+ return (qpdbiter->result);
}
- if (rbtdbiter->paused) {
- resume_iteration(rbtdbiter);
+ if (qpdbiter->paused) {
+ resume_iteration(qpdbiter);
}
- dereference_iter_node(rbtdbiter DNS__DB_FLARG_PASS);
+ dereference_iter_node(qpdbiter DNS__DB_FLARG_PASS);
- name = dns_fixedname_name(&rbtdbiter->name);
- origin = dns_fixedname_name(&rbtdbiter->origin);
- dns_rbtnodechain_reset(&rbtdbiter->chain);
- dns_rbtnodechain_reset(&rbtdbiter->nsec3chain);
+ name = dns_fixedname_name(&qpdbiter->name);
+ origin = dns_fixedname_name(&qpdbiter->origin);
+ dns_rbtnodechain_reset(&qpdbiter->chain);
+ dns_rbtnodechain_reset(&qpdbiter->nsec3chain);
- switch (rbtdbiter->nsec3mode) {
+ switch (qpdbiter->nsec3mode) {
case nsec3only:
- rbtdbiter->current = &rbtdbiter->nsec3chain;
- result = dns_rbtnodechain_first(rbtdbiter->current,
- rbtdb->nsec3, name, origin);
+ qpdbiter->current = &qpdbiter->nsec3chain;
+ result = dns_rbtnodechain_first(qpdbiter->current, qpdb->nsec3,
+ name, origin);
break;
case nonsec3:
- rbtdbiter->current = &rbtdbiter->chain;
- result = dns_rbtnodechain_first(rbtdbiter->current, rbtdb->tree,
+ qpdbiter->current = &qpdbiter->chain;
+ result = dns_rbtnodechain_first(qpdbiter->current, qpdb->tree,
name, origin);
break;
case full:
- rbtdbiter->current = &rbtdbiter->chain;
- result = dns_rbtnodechain_first(rbtdbiter->current, rbtdb->tree,
+ qpdbiter->current = &qpdbiter->chain;
+ result = dns_rbtnodechain_first(qpdbiter->current, qpdb->tree,
name, origin);
if (result == ISC_R_NOTFOUND) {
- rbtdbiter->current = &rbtdbiter->nsec3chain;
+ qpdbiter->current = &qpdbiter->nsec3chain;
result = dns_rbtnodechain_first(
- rbtdbiter->current, rbtdb->nsec3, name, origin);
+ qpdbiter->current, qpdb->nsec3, name, origin);
}
break;
default:
}
if (result == ISC_R_SUCCESS || result == DNS_R_NEWORIGIN) {
- result = dns_rbtnodechain_current(rbtdbiter->current, NULL,
- NULL, &rbtdbiter->node);
+ result = dns_rbtnodechain_current(qpdbiter->current, NULL, NULL,
+ &qpdbiter->node);
/* If we're in the NSEC3 tree, skip the origin */
- if (RBTDBITER_NSEC3_ORIGIN_NODE(rbtdb, rbtdbiter)) {
- rbtdbiter->node = NULL;
- result = dns_rbtnodechain_next(rbtdbiter->current, name,
+ if (QPDBITER_NSEC3_ORIGIN_NODE(qpdb, qpdbiter)) {
+ qpdbiter->node = NULL;
+ result = dns_rbtnodechain_next(qpdbiter->current, name,
origin);
if (result == ISC_R_SUCCESS ||
result == DNS_R_NEWORIGIN)
{
result = dns_rbtnodechain_current(
- rbtdbiter->current, NULL, NULL,
- &rbtdbiter->node);
+ qpdbiter->current, NULL, NULL,
+ &qpdbiter->node);
}
}
if (result == ISC_R_SUCCESS) {
- rbtdbiter->new_origin = true;
- reference_iter_node(rbtdbiter DNS__DB_FLARG_PASS);
+ qpdbiter->new_origin = true;
+ reference_iter_node(qpdbiter DNS__DB_FLARG_PASS);
}
} else {
INSIST(result == ISC_R_NOTFOUND);
result = ISC_R_NOMORE; /* The tree is empty. */
}
- rbtdbiter->result = result;
+ qpdbiter->result = result;
if (result != ISC_R_SUCCESS) {
- ENSURE(!rbtdbiter->paused);
+ ENSURE(!qpdbiter->paused);
}
return (result);
static isc_result_t
dbiterator_last(dns_dbiterator_t *iterator DNS__DB_FLARG) {
isc_result_t result;
- rbtdb_dbiterator_t *rbtdbiter = (rbtdb_dbiterator_t *)iterator;
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)iterator->db;
+ qpdb_dbiterator_t *qpdbiter = (qpdb_dbiterator_t *)iterator;
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)iterator->db;
dns_name_t *name = NULL, *origin = NULL;
- if (rbtdbiter->result != ISC_R_SUCCESS &&
- rbtdbiter->result != ISC_R_NOTFOUND &&
- rbtdbiter->result != DNS_R_PARTIALMATCH &&
- rbtdbiter->result != ISC_R_NOMORE)
+ if (qpdbiter->result != ISC_R_SUCCESS &&
+ qpdbiter->result != ISC_R_NOTFOUND &&
+ qpdbiter->result != DNS_R_PARTIALMATCH &&
+ qpdbiter->result != ISC_R_NOMORE)
{
- return (rbtdbiter->result);
+ return (qpdbiter->result);
}
- if (rbtdbiter->paused) {
- resume_iteration(rbtdbiter);
+ if (qpdbiter->paused) {
+ resume_iteration(qpdbiter);
}
- dereference_iter_node(rbtdbiter DNS__DB_FLARG_PASS);
+ dereference_iter_node(qpdbiter DNS__DB_FLARG_PASS);
- name = dns_fixedname_name(&rbtdbiter->name);
- origin = dns_fixedname_name(&rbtdbiter->origin);
- dns_rbtnodechain_reset(&rbtdbiter->chain);
- dns_rbtnodechain_reset(&rbtdbiter->nsec3chain);
+ name = dns_fixedname_name(&qpdbiter->name);
+ origin = dns_fixedname_name(&qpdbiter->origin);
+ dns_rbtnodechain_reset(&qpdbiter->chain);
+ dns_rbtnodechain_reset(&qpdbiter->nsec3chain);
- switch (rbtdbiter->nsec3mode) {
+ switch (qpdbiter->nsec3mode) {
case nsec3only:
- rbtdbiter->current = &rbtdbiter->nsec3chain;
- result = dns_rbtnodechain_last(rbtdbiter->current, rbtdb->nsec3,
+ qpdbiter->current = &qpdbiter->nsec3chain;
+ result = dns_rbtnodechain_last(qpdbiter->current, qpdb->nsec3,
name, origin);
break;
case nonsec3:
- rbtdbiter->current = &rbtdbiter->chain;
- result = dns_rbtnodechain_last(rbtdbiter->current, rbtdb->tree,
+ qpdbiter->current = &qpdbiter->chain;
+ result = dns_rbtnodechain_last(qpdbiter->current, qpdb->tree,
name, origin);
break;
case full:
- rbtdbiter->current = &rbtdbiter->nsec3chain;
- result = dns_rbtnodechain_last(rbtdbiter->current, rbtdb->nsec3,
+ qpdbiter->current = &qpdbiter->nsec3chain;
+ result = dns_rbtnodechain_last(qpdbiter->current, qpdb->nsec3,
name, origin);
if (result == ISC_R_NOTFOUND) {
- rbtdbiter->current = &rbtdbiter->chain;
+ qpdbiter->current = &qpdbiter->chain;
result = dns_rbtnodechain_last(
- rbtdbiter->current, rbtdb->tree, name, origin);
+ qpdbiter->current, qpdb->tree, name, origin);
}
break;
default:
}
if (result == ISC_R_SUCCESS || result == DNS_R_NEWORIGIN) {
- result = dns_rbtnodechain_current(rbtdbiter->current, NULL,
- NULL, &rbtdbiter->node);
- if (RBTDBITER_NSEC3_ORIGIN_NODE(rbtdb, rbtdbiter)) {
+ result = dns_rbtnodechain_current(qpdbiter->current, NULL, NULL,
+ &qpdbiter->node);
+ if (QPDBITER_NSEC3_ORIGIN_NODE(qpdb, qpdbiter)) {
/*
* NSEC3 tree only has an origin node.
*/
- rbtdbiter->node = NULL;
- switch (rbtdbiter->nsec3mode) {
+ qpdbiter->node = NULL;
+ switch (qpdbiter->nsec3mode) {
case nsec3only:
result = ISC_R_NOMORE;
break;
case nonsec3:
case full:
- rbtdbiter->current = &rbtdbiter->chain;
+ qpdbiter->current = &qpdbiter->chain;
result = dns_rbtnodechain_last(
- rbtdbiter->current, rbtdb->tree, name,
+ qpdbiter->current, qpdb->tree, name,
origin);
if (result == ISC_R_SUCCESS ||
result == DNS_R_NEWORIGIN)
{
result = dns_rbtnodechain_current(
- rbtdbiter->current, NULL, NULL,
- &rbtdbiter->node);
+ qpdbiter->current, NULL, NULL,
+ &qpdbiter->node);
}
break;
default:
}
}
if (result == ISC_R_SUCCESS) {
- rbtdbiter->new_origin = true;
- reference_iter_node(rbtdbiter DNS__DB_FLARG_PASS);
+ qpdbiter->new_origin = true;
+ reference_iter_node(qpdbiter DNS__DB_FLARG_PASS);
}
} else {
INSIST(result == ISC_R_NOTFOUND);
result = ISC_R_NOMORE; /* The tree is empty. */
}
- rbtdbiter->result = result;
+ qpdbiter->result = result;
return (result);
}
dbiterator_seek(dns_dbiterator_t *iterator,
const dns_name_t *name DNS__DB_FLARG) {
isc_result_t result, tresult;
- rbtdb_dbiterator_t *rbtdbiter = (rbtdb_dbiterator_t *)iterator;
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)iterator->db;
+ qpdb_dbiterator_t *qpdbiter = (qpdb_dbiterator_t *)iterator;
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)iterator->db;
dns_name_t *iname = NULL, *origin = NULL;
- if (rbtdbiter->result != ISC_R_SUCCESS &&
- rbtdbiter->result != ISC_R_NOTFOUND &&
- rbtdbiter->result != DNS_R_PARTIALMATCH &&
- rbtdbiter->result != ISC_R_NOMORE)
+ if (qpdbiter->result != ISC_R_SUCCESS &&
+ qpdbiter->result != ISC_R_NOTFOUND &&
+ qpdbiter->result != DNS_R_PARTIALMATCH &&
+ qpdbiter->result != ISC_R_NOMORE)
{
- return (rbtdbiter->result);
+ return (qpdbiter->result);
}
- if (rbtdbiter->paused) {
- resume_iteration(rbtdbiter);
+ if (qpdbiter->paused) {
+ resume_iteration(qpdbiter);
}
- dereference_iter_node(rbtdbiter DNS__DB_FLARG_PASS);
+ dereference_iter_node(qpdbiter DNS__DB_FLARG_PASS);
- iname = dns_fixedname_name(&rbtdbiter->name);
- origin = dns_fixedname_name(&rbtdbiter->origin);
- dns_rbtnodechain_reset(&rbtdbiter->chain);
- dns_rbtnodechain_reset(&rbtdbiter->nsec3chain);
+ iname = dns_fixedname_name(&qpdbiter->name);
+ origin = dns_fixedname_name(&qpdbiter->origin);
+ dns_rbtnodechain_reset(&qpdbiter->chain);
+ dns_rbtnodechain_reset(&qpdbiter->nsec3chain);
- switch (rbtdbiter->nsec3mode) {
+ switch (qpdbiter->nsec3mode) {
case nsec3only:
- rbtdbiter->current = &rbtdbiter->nsec3chain;
- result = dns_rbt_findnode(rbtdb->nsec3, name, NULL,
- &rbtdbiter->node, rbtdbiter->current,
+ qpdbiter->current = &qpdbiter->nsec3chain;
+ result = dns_rbt_findnode(qpdb->nsec3, name, NULL,
+ &qpdbiter->node, qpdbiter->current,
DNS_RBTFIND_EMPTYDATA, NULL, NULL);
break;
case nonsec3:
- rbtdbiter->current = &rbtdbiter->chain;
- result = dns_rbt_findnode(rbtdb->tree, name, NULL,
- &rbtdbiter->node, rbtdbiter->current,
+ qpdbiter->current = &qpdbiter->chain;
+ result = dns_rbt_findnode(qpdb->tree, name, NULL,
+ &qpdbiter->node, qpdbiter->current,
DNS_RBTFIND_EMPTYDATA, NULL, NULL);
break;
case full:
/*
* Stay on main chain if not found on either chain.
*/
- rbtdbiter->current = &rbtdbiter->chain;
- result = dns_rbt_findnode(rbtdb->tree, name, NULL,
- &rbtdbiter->node, rbtdbiter->current,
+ qpdbiter->current = &qpdbiter->chain;
+ result = dns_rbt_findnode(qpdb->tree, name, NULL,
+ &qpdbiter->node, qpdbiter->current,
DNS_RBTFIND_EMPTYDATA, NULL, NULL);
if (result == DNS_R_PARTIALMATCH) {
dns_rbtnode_t *node = NULL;
- tresult = dns_rbt_findnode(
- rbtdb->nsec3, name, NULL, &node,
- &rbtdbiter->nsec3chain, DNS_RBTFIND_EMPTYDATA,
- NULL, NULL);
+ tresult = dns_rbt_findnode(qpdb->nsec3, name, NULL,
+ &node, &qpdbiter->nsec3chain,
+ DNS_RBTFIND_EMPTYDATA, NULL,
+ NULL);
if (tresult == ISC_R_SUCCESS) {
- rbtdbiter->node = node;
- rbtdbiter->current = &rbtdbiter->nsec3chain;
+ qpdbiter->node = node;
+ qpdbiter->current = &qpdbiter->nsec3chain;
result = tresult;
}
}
}
if (result == ISC_R_SUCCESS || result == DNS_R_PARTIALMATCH) {
- tresult = dns_rbtnodechain_current(rbtdbiter->current, iname,
+ tresult = dns_rbtnodechain_current(qpdbiter->current, iname,
origin, NULL);
if (tresult == ISC_R_SUCCESS) {
- rbtdbiter->new_origin = true;
- reference_iter_node(rbtdbiter DNS__DB_FLARG_PASS);
+ qpdbiter->new_origin = true;
+ reference_iter_node(qpdbiter DNS__DB_FLARG_PASS);
} else {
result = tresult;
- rbtdbiter->node = NULL;
+ qpdbiter->node = NULL;
}
} else {
- rbtdbiter->node = NULL;
+ qpdbiter->node = NULL;
}
- rbtdbiter->result = (result == DNS_R_PARTIALMATCH) ? ISC_R_SUCCESS
- : result;
+ qpdbiter->result = (result == DNS_R_PARTIALMATCH) ? ISC_R_SUCCESS
+ : result;
return (result);
}
static isc_result_t
dbiterator_prev(dns_dbiterator_t *iterator DNS__DB_FLARG) {
isc_result_t result;
- rbtdb_dbiterator_t *rbtdbiter = (rbtdb_dbiterator_t *)iterator;
+ qpdb_dbiterator_t *qpdbiter = (qpdb_dbiterator_t *)iterator;
dns_name_t *name = NULL, *origin = NULL;
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)iterator->db;
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)iterator->db;
- REQUIRE(rbtdbiter->node != NULL);
+ REQUIRE(qpdbiter->node != NULL);
- if (rbtdbiter->result != ISC_R_SUCCESS) {
- return (rbtdbiter->result);
+ if (qpdbiter->result != ISC_R_SUCCESS) {
+ return (qpdbiter->result);
}
- if (rbtdbiter->paused) {
- resume_iteration(rbtdbiter);
+ if (qpdbiter->paused) {
+ resume_iteration(qpdbiter);
}
- dereference_iter_node(rbtdbiter DNS__DB_FLARG_PASS);
+ dereference_iter_node(qpdbiter DNS__DB_FLARG_PASS);
- name = dns_fixedname_name(&rbtdbiter->name);
- origin = dns_fixedname_name(&rbtdbiter->origin);
- result = dns_rbtnodechain_prev(rbtdbiter->current, name, origin);
- if (rbtdbiter->current == &rbtdbiter->nsec3chain &&
+ name = dns_fixedname_name(&qpdbiter->name);
+ origin = dns_fixedname_name(&qpdbiter->origin);
+ result = dns_rbtnodechain_prev(qpdbiter->current, name, origin);
+ if (qpdbiter->current == &qpdbiter->nsec3chain &&
(result == ISC_R_SUCCESS || result == DNS_R_NEWORIGIN))
{
/*
* If we're in the NSEC3 tree, it's empty or we've
* reached the origin, then we're done with it.
*/
- result = dns_rbtnodechain_current(rbtdbiter->current, NULL,
- NULL, &rbtdbiter->node);
+ result = dns_rbtnodechain_current(qpdbiter->current, NULL, NULL,
+ &qpdbiter->node);
if (result == ISC_R_NOTFOUND ||
- RBTDBITER_NSEC3_ORIGIN_NODE(rbtdb, rbtdbiter))
+ QPDBITER_NSEC3_ORIGIN_NODE(qpdb, qpdbiter))
{
- rbtdbiter->node = NULL;
+ qpdbiter->node = NULL;
result = ISC_R_NOMORE;
}
}
- if (result == ISC_R_NOMORE && rbtdbiter->nsec3mode != nsec3only &&
- &rbtdbiter->nsec3chain == rbtdbiter->current)
+ if (result == ISC_R_NOMORE && qpdbiter->nsec3mode != nsec3only &&
+ &qpdbiter->nsec3chain == qpdbiter->current)
{
- rbtdbiter->current = &rbtdbiter->chain;
- dns_rbtnodechain_reset(rbtdbiter->current);
- result = dns_rbtnodechain_last(rbtdbiter->current, rbtdb->tree,
+ qpdbiter->current = &qpdbiter->chain;
+ dns_rbtnodechain_reset(qpdbiter->current);
+ result = dns_rbtnodechain_last(qpdbiter->current, qpdb->tree,
name, origin);
if (result == ISC_R_NOTFOUND) {
result = ISC_R_NOMORE;
}
if (result == DNS_R_NEWORIGIN || result == ISC_R_SUCCESS) {
- rbtdbiter->new_origin = (result == DNS_R_NEWORIGIN);
- result = dns_rbtnodechain_current(rbtdbiter->current, NULL,
- NULL, &rbtdbiter->node);
+ qpdbiter->new_origin = (result == DNS_R_NEWORIGIN);
+ result = dns_rbtnodechain_current(qpdbiter->current, NULL, NULL,
+ &qpdbiter->node);
}
if (result == ISC_R_SUCCESS) {
- reference_iter_node(rbtdbiter DNS__DB_FLARG_PASS);
+ reference_iter_node(qpdbiter DNS__DB_FLARG_PASS);
}
- rbtdbiter->result = result;
+ qpdbiter->result = result;
return (result);
}
static isc_result_t
dbiterator_next(dns_dbiterator_t *iterator DNS__DB_FLARG) {
isc_result_t result;
- rbtdb_dbiterator_t *rbtdbiter = (rbtdb_dbiterator_t *)iterator;
+ qpdb_dbiterator_t *qpdbiter = (qpdb_dbiterator_t *)iterator;
dns_name_t *name = NULL, *origin = NULL;
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)iterator->db;
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)iterator->db;
- REQUIRE(rbtdbiter->node != NULL);
+ REQUIRE(qpdbiter->node != NULL);
- if (rbtdbiter->result != ISC_R_SUCCESS) {
- return (rbtdbiter->result);
+ if (qpdbiter->result != ISC_R_SUCCESS) {
+ return (qpdbiter->result);
}
- if (rbtdbiter->paused) {
- resume_iteration(rbtdbiter);
+ if (qpdbiter->paused) {
+ resume_iteration(qpdbiter);
}
- name = dns_fixedname_name(&rbtdbiter->name);
- origin = dns_fixedname_name(&rbtdbiter->origin);
- result = dns_rbtnodechain_next(rbtdbiter->current, name, origin);
- if (result == ISC_R_NOMORE && rbtdbiter->nsec3mode != nonsec3 &&
- &rbtdbiter->chain == rbtdbiter->current)
+ name = dns_fixedname_name(&qpdbiter->name);
+ origin = dns_fixedname_name(&qpdbiter->origin);
+ result = dns_rbtnodechain_next(qpdbiter->current, name, origin);
+ if (result == ISC_R_NOMORE && qpdbiter->nsec3mode != nonsec3 &&
+ &qpdbiter->chain == qpdbiter->current)
{
- rbtdbiter->current = &rbtdbiter->nsec3chain;
- dns_rbtnodechain_reset(rbtdbiter->current);
- result = dns_rbtnodechain_first(rbtdbiter->current,
- rbtdb->nsec3, name, origin);
+ qpdbiter->current = &qpdbiter->nsec3chain;
+ dns_rbtnodechain_reset(qpdbiter->current);
+ result = dns_rbtnodechain_first(qpdbiter->current, qpdb->nsec3,
+ name, origin);
if (result == ISC_R_NOTFOUND) {
result = ISC_R_NOMORE;
}
}
- dereference_iter_node(rbtdbiter DNS__DB_FLARG_PASS);
+ dereference_iter_node(qpdbiter DNS__DB_FLARG_PASS);
if (result == DNS_R_NEWORIGIN || result == ISC_R_SUCCESS) {
/*
* If we've just started the NSEC3 tree,
* skip over the origin.
*/
- rbtdbiter->new_origin = (result == DNS_R_NEWORIGIN);
- result = dns_rbtnodechain_current(rbtdbiter->current, NULL,
- NULL, &rbtdbiter->node);
- if (RBTDBITER_NSEC3_ORIGIN_NODE(rbtdb, rbtdbiter)) {
- rbtdbiter->node = NULL;
- result = dns_rbtnodechain_next(rbtdbiter->current, name,
+ qpdbiter->new_origin = (result == DNS_R_NEWORIGIN);
+ result = dns_rbtnodechain_current(qpdbiter->current, NULL, NULL,
+ &qpdbiter->node);
+ if (QPDBITER_NSEC3_ORIGIN_NODE(qpdb, qpdbiter)) {
+ qpdbiter->node = NULL;
+ result = dns_rbtnodechain_next(qpdbiter->current, name,
origin);
if (result == ISC_R_SUCCESS ||
result == DNS_R_NEWORIGIN)
{
result = dns_rbtnodechain_current(
- rbtdbiter->current, NULL, NULL,
- &rbtdbiter->node);
+ qpdbiter->current, NULL, NULL,
+ &qpdbiter->node);
}
}
}
if (result == ISC_R_SUCCESS) {
- reference_iter_node(rbtdbiter DNS__DB_FLARG_PASS);
+ reference_iter_node(qpdbiter DNS__DB_FLARG_PASS);
}
- rbtdbiter->result = result;
+ qpdbiter->result = result;
return (result);
}
static isc_result_t
dbiterator_current(dns_dbiterator_t *iterator, dns_dbnode_t **nodep,
dns_name_t *name DNS__DB_FLARG) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)iterator->db;
- rbtdb_dbiterator_t *rbtdbiter = (rbtdb_dbiterator_t *)iterator;
- dns_rbtnode_t *node = rbtdbiter->node;
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)iterator->db;
+ qpdb_dbiterator_t *qpdbiter = (qpdb_dbiterator_t *)iterator;
+ dns_rbtnode_t *node = qpdbiter->node;
isc_result_t result;
- dns_name_t *nodename = dns_fixedname_name(&rbtdbiter->name);
- dns_name_t *origin = dns_fixedname_name(&rbtdbiter->origin);
+ dns_name_t *nodename = dns_fixedname_name(&qpdbiter->name);
+ dns_name_t *origin = dns_fixedname_name(&qpdbiter->origin);
- REQUIRE(rbtdbiter->result == ISC_R_SUCCESS);
- REQUIRE(rbtdbiter->node != NULL);
+ REQUIRE(qpdbiter->result == ISC_R_SUCCESS);
+ REQUIRE(qpdbiter->node != NULL);
- if (rbtdbiter->paused) {
- resume_iteration(rbtdbiter);
+ if (qpdbiter->paused) {
+ resume_iteration(qpdbiter);
}
if (name != NULL) {
- if (rbtdbiter->common.relative_names) {
+ if (qpdbiter->common.relative_names) {
origin = NULL;
}
result = dns_name_concatenate(nodename, origin, name, NULL);
if (result != ISC_R_SUCCESS) {
return (result);
}
- if (rbtdbiter->common.relative_names && rbtdbiter->new_origin) {
+ if (qpdbiter->common.relative_names && qpdbiter->new_origin) {
result = DNS_R_NEWORIGIN;
}
} else {
result = ISC_R_SUCCESS;
}
- dns__rbtdb_newref(rbtdb, node, isc_rwlocktype_none DNS__DB_FLARG_PASS);
+ dns__qpdb_newref(qpdb, node, isc_rwlocktype_none DNS__DB_FLARG_PASS);
- *nodep = rbtdbiter->node;
+ *nodep = qpdbiter->node;
return (result);
}
static isc_result_t
dbiterator_pause(dns_dbiterator_t *iterator) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)iterator->db;
- rbtdb_dbiterator_t *rbtdbiter = (rbtdb_dbiterator_t *)iterator;
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)iterator->db;
+ qpdb_dbiterator_t *qpdbiter = (qpdb_dbiterator_t *)iterator;
- if (rbtdbiter->result != ISC_R_SUCCESS &&
- rbtdbiter->result != ISC_R_NOTFOUND &&
- rbtdbiter->result != DNS_R_PARTIALMATCH &&
- rbtdbiter->result != ISC_R_NOMORE)
+ if (qpdbiter->result != ISC_R_SUCCESS &&
+ qpdbiter->result != ISC_R_NOTFOUND &&
+ qpdbiter->result != DNS_R_PARTIALMATCH &&
+ qpdbiter->result != ISC_R_NOMORE)
{
- return (rbtdbiter->result);
+ return (qpdbiter->result);
}
- if (rbtdbiter->paused) {
+ if (qpdbiter->paused) {
return (ISC_R_SUCCESS);
}
- rbtdbiter->paused = true;
+ qpdbiter->paused = true;
- if (rbtdbiter->tree_locked == isc_rwlocktype_read) {
- TREE_UNLOCK(&rbtdb->tree_lock, &rbtdbiter->tree_locked);
+ if (qpdbiter->tree_locked == isc_rwlocktype_read) {
+ TREE_UNLOCK(&qpdb->tree_lock, &qpdbiter->tree_locked);
}
- INSIST(rbtdbiter->tree_locked == isc_rwlocktype_none);
+ INSIST(qpdbiter->tree_locked == isc_rwlocktype_none);
return (ISC_R_SUCCESS);
}
static isc_result_t
dbiterator_origin(dns_dbiterator_t *iterator, dns_name_t *name) {
- rbtdb_dbiterator_t *rbtdbiter = (rbtdb_dbiterator_t *)iterator;
- dns_name_t *origin = dns_fixedname_name(&rbtdbiter->origin);
+ qpdb_dbiterator_t *qpdbiter = (qpdb_dbiterator_t *)iterator;
+ dns_name_t *origin = dns_fixedname_name(&qpdbiter->origin);
- if (rbtdbiter->result != ISC_R_SUCCESS) {
- return (rbtdbiter->result);
+ if (qpdbiter->result != ISC_R_SUCCESS) {
+ return (qpdbiter->result);
}
dns_name_copy(origin, name);
}
void
-dns__rbtdb_freeglue(dns_glue_t *glue_list) {
+dns__qpdb_freeglue(dns_glue_t *glue_list) {
if (glue_list == (void *)-1) {
return;
}
free_gluelist_rcu(struct rcu_head *rcu_head) {
dns_glue_t *glue = caa_container_of(rcu_head, dns_glue_t, rcu_head);
- dns__rbtdb_freeglue(glue);
+ dns__qpdb_freeglue(glue);
}
static void
-free_gluetable(dns_rbtdb_version_t *rbtversion) {
+free_gluetable(dns_qpdb_version_t *rbtversion) {
struct cds_wfs_head *head = __cds_wfs_pop_all(&rbtversion->glue_stack);
struct cds_wfs_node *node = NULL, *next = NULL;
}
void
-dns__rbtdb_deletedata(dns_db_t *db ISC_ATTR_UNUSED,
- dns_dbnode_t *node ISC_ATTR_UNUSED, void *data) {
+dns__qpdb_deletedata(dns_db_t *db ISC_ATTR_UNUSED,
+ dns_dbnode_t *node ISC_ATTR_UNUSED, void *data) {
dns_slabheader_t *header = data;
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)header->db;
+ dns_qpdb_t *qpdb = (dns_qpdb_t *)header->db;
if (header->heap != NULL && header->heap_index != 0) {
isc_heap_delete(header->heap, header->heap_index);
}
- if (IS_CACHE(rbtdb)) {
- update_rrsetstats(rbtdb->rrsetstats, header->type,
+ if (IS_CACHE(qpdb)) {
+ update_rrsetstats(qpdb->rrsetstats, header->type,
atomic_load_acquire(&header->attributes),
false);
if (ISC_LINK_LINKED(header, link)) {
- int idx = RBTDB_HEADERNODE(header)->locknum;
- INSIST(IS_CACHE(rbtdb));
- ISC_LIST_UNLINK(rbtdb->lru[idx], header, link);
+ int idx = QPDB_HEADERNODE(header)->locknum;
+ INSIST(IS_CACHE(qpdb));
+ ISC_LIST_UNLINK(qpdb->lru[idx], header, link);
}
if (header->noqname != NULL) {
}
} else {
if (header->glue_list) {
- dns__rbtdb_freeglue(header->glue_list);
+ dns__qpdb_freeglue(header->glue_list);
}
}
}
* Caller must be holding the node write lock.
*/
static void
-expire_ttl_headers(dns_rbtdb_t *rbtdb, unsigned int locknum,
+expire_ttl_headers(dns_qpdb_t *qpdb, unsigned int locknum,
isc_rwlocktype_t *tlocktypep, isc_stdtime_t now,
bool cache_is_overmem DNS__DB_FLARG) {
- isc_heap_t *heap = rbtdb->heaps[locknum];
+ isc_heap_t *heap = qpdb->heaps[locknum];
- for (size_t i = 0; i < DNS_RBTDB_EXPIRE_TTL_COUNT; i++) {
+ for (size_t i = 0; i < DNS_QPDB_EXPIRE_TTL_COUNT; i++) {
dns_slabheader_t *header = isc_heap_element(heap, 1);
if (header == NULL) {
if (!cache_is_overmem) {
/* Only account for stale TTL if cache is not overmem */
- ttl += STALE_TTL(header, rbtdb);
+ ttl += STALE_TTL(header, qpdb);
}
- if (ttl >= now - RBTDB_VIRTUAL) {
+ if (ttl >= now - QPDB_VIRTUAL) {
/*
* The header at the top of this TTL heap is not yet
* eligible for expiry, so none of the other headers on
return;
}
- dns__cacherbt_expireheader(header, tlocktypep,
- dns_expire_ttl DNS__DB_FLARG_PASS);
+ dns__qpcache_expireheader(header, tlocktypep,
+ dns_expire_ttl DNS__DB_FLARG_PASS);
}
}
dns_qpdata_t *
-dns_qpdata_create(dns_rbtdb_t *rbtdb, const dns_name_t *name) {
- dns_qpdata_t *newdata = isc_mem_get(rbtdb->common.mctx,
+dns_qpdata_create(dns_qpdb_t *qpdb, const dns_name_t *name) {
+ dns_qpdata_t *newdata = isc_mem_get(qpdb->common.mctx,
sizeof(*newdata));
*newdata = (dns_qpdata_t){
.references = ISC_REFCOUNT_INITIALIZER(1),
};
newdata->hashval = dns_name_hash(name);
- newdata->locknum = newdata->hashval % rbtdb->node_lock_count;
+ newdata->locknum = newdata->hashval % qpdb->node_lock_count;
newdata->name = dns_fixedname_initname(&newdata->fn);
dns_name_copy(name, newdata->name);
- isc_mem_attach(rbtdb->common.mctx, &newdata->mctx);
+ isc_mem_attach(qpdb->common.mctx, &newdata->mctx);
ISC_LINK_INIT(newdata, deadlink);
- ISC_LINK_INIT(newdata, prunelink);
#ifdef DNS_DB_NODETRACE
fprintf(stderr, "dns_qpdata_create:%s:%s:%d:%p->references = 1\n",
projects / thirdparty / bind9.git / commitdiff
