#define VALID_QPDB(qpdb) \
((qpdb) != NULL && (qpdb)->common.impmagic == QPDB_MAGIC)
-#define QPDB_HEADERNODE(h) ((dns_qpdata_t *)((h)->node))
+#define QPDB_HEADERNODE(h) ((qpcnode_t *)((h)->node))
/*
* Allow clients with a virtual time of up to 5 minutes in the past to see
* This is the structure that is used for each node in the qp trie of trees.
* For now it is a copy of the dns_rbtnode structure.
*/
-struct dns_qpdata {
+typedef struct qpcnode qpcnode_t;
+typedef ISC_LIST(qpcnode_t) qpcnodelist_t;
+struct qpcnode {
unsigned int magic;
/*@{*/
/*!
* have no data any longer, but we cannot unlink at that exact moment
* because we did not or could not obtain a write lock on the tree.
*/
- ISC_LINK(dns_qpdata_t) deadlink;
+ ISC_LINK(qpcnode_t) deadlink;
/*@{*/
/*!
};
typedef struct qpdb_changed {
- dns_qpdata_t *node;
+ qpcnode_t *node;
bool dirty;
ISC_LINK(struct qpdb_changed) link;
} qpdb_changed_t;
+typedef struct qpcache qpcache_t;
typedef ISC_LIST(qpdb_changed_t) qpdb_changedlist_t;
-struct dns_qpdb {
+struct qpcache {
/* Unlocked. */
dns_db_t common;
/* Locks the data in this struct */
/* Locks for individual tree nodes */
unsigned int node_lock_count;
db_nodelock_t *node_locks;
- dns_qpdata_t *origin_node;
- dns_qpdata_t *nsec3_origin_node;
+ qpcnode_t *origin_node;
+ qpcnode_t *nsec3_origin_node;
dns_stats_t *rrsetstats; /* cache DB only */
isc_stats_t *cachestats; /* cache DB only */
isc_stats_t *gluecachestats; /* zone DB only */
* Temporary storage for stale cache nodes and dynamically deleted
* nodes that await being cleaned up.
*/
- dns_qpdatalist_t *deadnodes;
+ qpcnodelist_t *deadnodes;
/*
* Heaps. These are used for TTL based expiry in a cache,
* Search Context
*/
typedef struct {
- dns_qpdb_t *qpdb;
+ qpcache_t *qpdb;
uint32_t serial;
unsigned int options;
dns_qpchain_t chain;
bool copy_name;
bool need_cleanup;
bool wild;
- dns_qpdata_t *zonecut;
+ qpcnode_t *zonecut;
dns_slabheader_t *zonecut_header;
dns_slabheader_t *zonecut_sigheader;
dns_fixedname_t zonecut_name;
} qpdb_search_t;
#ifdef DNS_DB_NODETRACE
-#define dns_qpdata_ref(ptr) dns_qpdata__ref(ptr, __func__, __FILE__, __LINE__)
-#define dns_qpdata_unref(ptr) \
- dns_qpdata__unref(ptr, __func__, __FILE__, __LINE__)
-#define dns_qpdata_attach(ptr, ptrp) \
- dns_qpdata__attach(ptr, ptrp, __func__, __FILE__, __LINE__)
-#define dns_qpdata_detach(ptrp) \
- dns_qpdata__detach(ptrp, __func__, __FILE__, __LINE__)
-ISC_REFCOUNT_TRACE_DECL(dns_qpdata);
+#define qpcnode_ref(ptr) qpcnode__ref(ptr, __func__, __FILE__, __LINE__)
+#define qpcnode_unref(ptr) qpcnode__unref(ptr, __func__, __FILE__, __LINE__)
+#define qpcnode_attach(ptr, ptrp) \
+ qpcnode__attach(ptr, ptrp, __func__, __FILE__, __LINE__)
+#define qpcnode_detach(ptrp) qpcnode__detach(ptrp, __func__, __FILE__, __LINE__)
+ISC_REFCOUNT_STATIC_TRACE_DECL(qpcnode);
#else
-ISC_REFCOUNT_DECL(dns_qpdata);
+ISC_REFCOUNT_STATIC_DECL(qpcnode);
#endif
/* QP methods */
static void
qp_attach(void *uctx ISC_ATTR_UNUSED, void *pval,
uint32_t ival ISC_ATTR_UNUSED) {
- dns_qpdata_t *data = pval;
- dns_qpdata_ref(data);
+ qpcnode_t *data = pval;
+ qpcnode_ref(data);
}
static void
qp_detach(void *uctx ISC_ATTR_UNUSED, void *pval,
uint32_t ival ISC_ATTR_UNUSED) {
- dns_qpdata_t *data = pval;
- dns_qpdata_detach(&data);
+ qpcnode_t *data = pval;
+ qpcnode_detach(&data);
}
static size_t
qp_makekey(dns_qpkey_t key, void *uctx ISC_ATTR_UNUSED, void *pval,
uint32_t ival ISC_ATTR_UNUSED) {
- dns_qpdata_t *data = pval;
+ qpcnode_t *data = pval;
return (dns_qpkey_fromname(key, &data->name));
}
dns_qpiter_t iter;
dns_qpiter_t nsec3iter;
dns_qpiter_t *current;
- dns_qpdata_t *node;
+ qpcnode_t *node;
enum { full, nonsec3, nsec3only } nsec3mode;
} qpdb_dbiterator_t;
static void
-free_qpdb(dns_qpdb_t *qpdb, bool log);
+free_qpdb(qpcache_t *qpdb, bool log);
static dns_dbmethods_t qpdb_cachemethods;
* Note that the we do NOT touch the heap here, as the TTL has not changed.
*/
static void
-update_header(dns_qpdb_t *qpdb, dns_slabheader_t *header, isc_stdtime_t now) {
+update_header(qpcache_t *qpdb, dns_slabheader_t *header, isc_stdtime_t now) {
/* To be checked: can we really assume this? XXXMLG */
INSIST(ISC_LINK_LINKED(header, link));
}
static void
-clean_cache_node(dns_qpdb_t *qpdb, dns_qpdata_t *node) {
+clean_cache_node(qpcache_t *qpdb, qpcnode_t *node) {
dns_slabheader_t *current = NULL, *top_prev = NULL, *top_next = NULL;
/*
* tree_lock(write) must be held.
*/
static void
-delete_node(dns_qpdb_t *qpdb, dns_qpdata_t *node) {
+delete_node(qpcache_t *qpdb, qpcnode_t *node) {
isc_result_t result = ISC_R_UNEXPECTED;
INSIST(!ISC_LINK_LINKED(node, deadlink));
* then the caller must be holding at least one lock.
*/
static void
-newref(dns_qpdb_t *qpdb, dns_qpdata_t *node, isc_rwlocktype_t nlocktype,
+newref(qpcache_t *qpdb, qpcnode_t *node, isc_rwlocktype_t nlocktype,
isc_rwlocktype_t tlocktype DNS__DB_FLARG) {
uint_fast32_t refs;
ISC_LIST_UNLINK(qpdb->deadnodes[node->locknum], node, deadlink);
}
- dns_qpdata_ref(node);
+ qpcnode_ref(node);
refs = isc_refcount_increment0(&node->erefs);
#if DNS_DB_NODETRACE
* not mean it will be immediately freed.)
*/
static bool
-decref(dns_qpdb_t *qpdb, dns_qpdata_t *node, uint32_t least_serial,
+decref(qpcache_t *qpdb, qpcnode_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;
no_reference = false;
}
- dns_qpdata_unref(node);
+ qpcnode_unref(node);
return (no_reference);
}
#endif
if (refs > 1) {
- dns_qpdata_unref(node);
+ qpcnode_unref(node);
return (false);
}
TREE_UNLOCK(&qpdb->tree_lock, tlocktypep);
}
- dns_qpdata_unref(node);
+ qpcnode_unref(node);
return (no_reference);
}
QPDB_HEADERNODE(header)->dirty = 1;
if (isc_refcount_current(&QPDB_HEADERNODE(header)->erefs) == 0) {
- dns_qpdb_t *qpdb = (dns_qpdb_t *)header->db;
+ qpcache_t *qpdb = (qpcache_t *)header->db;
/*
* If no one else is using the node, we can clean it up now.
}
static void
-update_cachestats(dns_qpdb_t *qpdb, isc_result_t result) {
+update_cachestats(qpcache_t *qpdb, isc_result_t result) {
if (qpdb->cachestats == NULL) {
return;
}
}
static void
-bindrdataset(dns_qpdb_t *qpdb, dns_qpdata_t *node, dns_slabheader_t *header,
+bindrdataset(qpcache_t *qpdb, qpcnode_t *node, dns_slabheader_t *header,
isc_stdtime_t now, isc_rwlocktype_t nlocktype,
isc_rwlocktype_t tlocktype,
dns_rdataset_t *rdataset DNS__DB_FLARG) {
isc_rwlocktype_t tlocktype DNS__DB_FLARG) {
dns_name_t *zcname = NULL;
dns_typepair_t type;
- dns_qpdata_t *node = NULL;
+ qpcnode_t *node = NULL;
REQUIRE(search != NULL);
REQUIRE(search->zonecut != NULL);
}
static bool
-check_stale_header(dns_qpdata_t *node, dns_slabheader_t *header,
+check_stale_header(qpcnode_t *node, dns_slabheader_t *header,
isc_rwlocktype_t *nlocktypep, isc_rwlock_t *lock,
qpdb_search_t *search, dns_slabheader_t **header_prev) {
if (!ACTIVE(header, search->now)) {
}
static isc_result_t
-check_zonecut(dns_qpdata_t *node, void *arg DNS__DB_FLARG) {
+check_zonecut(qpcnode_t *node, void *arg DNS__DB_FLARG) {
qpdb_search_t *search = arg;
dns_slabheader_t *header = NULL;
dns_slabheader_t *header_prev = NULL, *header_next = NULL;
}
static isc_result_t
-find_deepest_zonecut(qpdb_search_t *search, dns_qpdata_t *node,
+find_deepest_zonecut(qpdb_search_t *search, qpcnode_t *node,
dns_dbnode_t **nodep, dns_name_t *foundname,
dns_rdataset_t *rdataset,
dns_rdataset_t *sigrdataset DNS__DB_FLARG) {
isc_result_t result = ISC_R_NOTFOUND;
- dns_qpdb_t *qpdb = NULL;
+ qpcache_t *qpdb = NULL;
/*
* Caller must be holding the tree lock.
dns_rdataset_t *sigrdataset DNS__DB_FLARG) {
dns_fixedname_t fpredecessor, fixed;
dns_name_t *predecessor = NULL, *fname = NULL;
- dns_qpdata_t *node = NULL;
+ qpcnode_t *node = NULL;
dns_qpiter_t iter;
isc_result_t result;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
dns_rdatatype_t type, unsigned int options, isc_stdtime_t now,
dns_dbnode_t **nodep, dns_name_t *foundname, dns_rdataset_t *rdataset,
dns_rdataset_t *sigrdataset DNS__DB_FLARG) {
- dns_qpdata_t *node = NULL;
+ qpcnode_t *node = NULL;
isc_result_t result;
qpdb_search_t search;
bool cname_ok = true;
UNUSED(version);
- REQUIRE(VALID_QPDB((dns_qpdb_t *)db));
+ REQUIRE(VALID_QPDB((qpcache_t *)db));
REQUIRE(version == NULL);
if (now == 0) {
}
search = (qpdb_search_t){
- .qpdb = (dns_qpdb_t *)db,
+ .qpdb = (qpcache_t *)db,
.serial = 1,
.options = options,
.now = now,
for (unsigned int i = 0; i < len; i++) {
isc_result_t zcresult;
- dns_qpdata_t *encloser = NULL;
+ qpcnode_t *encloser = NULL;
dns_qpchain_node(&search.chain, i, NULL, (void **)&encloser,
NULL);
isc_stdtime_t now, dns_dbnode_t **nodep, dns_name_t *foundname,
dns_name_t *dcname, dns_rdataset_t *rdataset,
dns_rdataset_t *sigrdataset DNS__DB_FLARG) {
- dns_qpdata_t *node = NULL;
+ qpcnode_t *node = NULL;
isc_rwlock_t *lock = NULL;
isc_result_t result;
qpdb_search_t search;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
bool dcnull = (dcname == NULL);
- REQUIRE(VALID_QPDB((dns_qpdb_t *)db));
+ REQUIRE(VALID_QPDB((qpcache_t *)db));
if (now == 0) {
now = isc_stdtime_now();
}
search = (qpdb_search_t){
- .qpdb = (dns_qpdb_t *)db,
+ .qpdb = (qpcache_t *)db,
.serial = 1,
.options = options,
.now = now,
dns_rdatatype_t type, dns_rdatatype_t covers, isc_stdtime_t now,
dns_rdataset_t *rdataset,
dns_rdataset_t *sigrdataset DNS__DB_FLARG) {
- dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
- dns_qpdata_t *qpnode = (dns_qpdata_t *)node;
+ qpcache_t *qpdb = (qpcache_t *)db;
+ qpcnode_t *qpnode = (qpcnode_t *)node;
dns_slabheader_t *header = NULL, *header_next = NULL;
dns_slabheader_t *found = NULL, *foundsig = NULL;
dns_typepair_t matchtype, sigmatchtype, negtype;
static isc_result_t
setcachestats(dns_db_t *db, isc_stats_t *stats) {
- dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
+ qpcache_t *qpdb = (qpcache_t *)db;
REQUIRE(VALID_QPDB(qpdb));
REQUIRE(stats != NULL);
static dns_stats_t *
getrrsetstats(dns_db_t *db) {
- dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
+ qpcache_t *qpdb = (qpcache_t *)db;
REQUIRE(VALID_QPDB(qpdb));
static isc_result_t
setservestalettl(dns_db_t *db, dns_ttl_t ttl) {
- dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
+ qpcache_t *qpdb = (qpcache_t *)db;
REQUIRE(VALID_QPDB(qpdb));
static isc_result_t
getservestalettl(dns_db_t *db, dns_ttl_t *ttl) {
- dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
+ qpcache_t *qpdb = (qpcache_t *)db;
REQUIRE(VALID_QPDB(qpdb));
static isc_result_t
setservestalerefresh(dns_db_t *db, uint32_t interval) {
- dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
+ qpcache_t *qpdb = (qpcache_t *)db;
REQUIRE(VALID_QPDB(qpdb));
static isc_result_t
getservestalerefresh(dns_db_t *db, uint32_t *interval) {
- dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
+ qpcache_t *qpdb = (qpcache_t *)db;
REQUIRE(VALID_QPDB(qpdb));
static void
expiredata(dns_db_t *db, dns_dbnode_t *node, void *data) {
- dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
- dns_qpdata_t *qpnode = (dns_qpdata_t *)node;
+ qpcache_t *qpdb = (qpcache_t *)db;
+ qpcnode_t *qpnode = (qpcnode_t *)node;
dns_slabheader_t *header = data;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
isc_rwlocktype_t tlocktype = isc_rwlocktype_none;
}
static size_t
-expire_lru_headers(dns_qpdb_t *qpdb, unsigned int locknum,
+expire_lru_headers(qpcache_t *qpdb, unsigned int locknum,
isc_rwlocktype_t *nlocktypep, isc_rwlocktype_t *tlocktypep,
size_t purgesize DNS__DB_FLARG) {
dns_slabheader_t *header = NULL;
* A write lock on the tree must be held.
*/
static void
-overmem(dns_qpdb_t *qpdb, dns_slabheader_t *newheader,
+overmem(qpcache_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 * sizeof(dns_qpdata_t);
+ size_t purgesize = rdataset_size(newheader) + 2 * sizeof(qpcnode_t);
size_t purged = 0;
isc_stdtime_t min_last_used = 0;
size_t max_passes = 8;
}
static void
-free_qpdb(dns_qpdb_t *qpdb, bool log) {
+free_qpdb(qpcache_t *qpdb, bool log) {
unsigned int i;
char buf[DNS_NAME_FORMATSIZE];
dns_qp_t **treep = NULL;
* the overhead of unlinking all nodes here should be negligible.
*/
for (i = 0; i < qpdb->node_lock_count; i++) {
- dns_qpdata_t *node = NULL;
+ qpcnode_t *node = NULL;
node = ISC_LIST_HEAD(qpdb->deadnodes[i]);
while (node != NULL) {
INSIST(ISC_LIST_EMPTY(qpdb->deadnodes[i]));
}
isc_mem_cput(qpdb->common.mctx, qpdb->deadnodes,
- qpdb->node_lock_count, sizeof(dns_qpdatalist_t));
+ qpdb->node_lock_count, sizeof(qpcnodelist_t));
}
/*
* Clean up heap objects.
static void
qpdb_destroy(dns_db_t *arg) {
- dns_qpdb_t *qpdb = (dns_qpdb_t *)arg;
+ qpcache_t *qpdb = (qpcache_t *)arg;
bool want_free = false;
unsigned int i;
unsigned int inactive = 0;
if (qpdb->origin_node != NULL) {
- dns_qpdata_detach(&qpdb->origin_node);
+ qpcnode_detach(&qpdb->origin_node);
}
if (qpdb->nsec3_origin_node != NULL) {
- dns_qpdata_detach(&qpdb->nsec3_origin_node);
+ qpcnode_detach(&qpdb->nsec3_origin_node);
}
/* XXX check for open versions here */
* The caller must hold a tree write lock and bucketnum'th node (write) lock.
*/
static void
-cleanup_dead_nodes(dns_qpdb_t *qpdb, int bucketnum DNS__DB_FLARG) {
- dns_qpdata_t *node = NULL;
+cleanup_dead_nodes(qpcache_t *qpdb, int bucketnum DNS__DB_FLARG) {
+ qpcnode_t *node = NULL;
int count = 10; /* XXXJT: should be adjustable */
node = ISC_LIST_HEAD(qpdb->deadnodes[bucketnum]);
* have been added to the list).
*/
static void
-reactivate_node(dns_qpdb_t *qpdb, dns_qpdata_t *node,
+reactivate_node(qpcache_t *qpdb, qpcnode_t *node,
isc_rwlocktype_t tlocktype DNS__DB_FLARG) {
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
isc_rwlock_t *nodelock = &qpdb->node_locks[node->locknum].lock;
NODE_UNLOCK(nodelock, &nlocktype);
}
-static dns_qpdata_t *
-new_qpdata(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){
+static qpcnode_t *
+new_qpcnode(qpcache_t *qpdb, const dns_name_t *name) {
+ qpcnode_t *newdata = isc_mem_get(qpdb->common.mctx, sizeof(*newdata));
+ *newdata = (qpcnode_t){
.name = DNS_NAME_INITEMPTY,
.references = ISC_REFCOUNT_INITIALIZER(1),
};
ISC_LINK_INIT(newdata, deadlink);
#ifdef DNS_DB_NODETRACE
- fprintf(stderr, "new_qpdata:%s:%s:%d:%p->references = 1\n", __func__,
+ fprintf(stderr, "new_qpcnode:%s:%s:%d:%p->references = 1\n", __func__,
__FILE__, __LINE__ + 1, name);
#endif
return (newdata);
static isc_result_t
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;
- dns_qpdata_t *node = NULL;
+ qpcache_t *qpdb = (qpcache_t *)db;
+ qpcnode_t *node = NULL;
isc_result_t result;
isc_rwlocktype_t tlocktype = isc_rwlocktype_none;
result = dns_qp_lookup(qpdb->tree, name, NULL, NULL, NULL,
(void **)&node, NULL);
if (result != ISC_R_SUCCESS) {
- node = new_qpdata(qpdb, name);
+ node = new_qpcnode(qpdb, name);
result = dns_qp_insert(qpdb->tree, node, 0);
INSIST(result == ISC_R_SUCCESS);
- dns_qpdata_unref(node);
+ qpcnode_unref(node);
}
}
static void
attachnode(dns_db_t *db, dns_dbnode_t *source,
dns_dbnode_t **targetp DNS__DB_FLARG) {
- REQUIRE(VALID_QPDB((dns_qpdb_t *)db));
+ REQUIRE(VALID_QPDB((qpcache_t *)db));
REQUIRE(targetp != NULL && *targetp == NULL);
- dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
- dns_qpdata_t *node = (dns_qpdata_t *)source;
+ qpcache_t *qpdb = (qpcache_t *)db;
+ qpcnode_t *node = (qpcnode_t *)source;
newref(qpdb, node, isc_rwlocktype_none,
isc_rwlocktype_none DNS__DB_FLARG_PASS);
static void
detachnode(dns_db_t *db, dns_dbnode_t **targetp DNS__DB_FLARG) {
- dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
- dns_qpdata_t *node = NULL;
+ qpcache_t *qpdb = (qpcache_t *)db;
+ qpcnode_t *node = NULL;
bool want_free = false;
bool inactive = false;
db_nodelock_t *nodelock = NULL;
REQUIRE(VALID_QPDB(qpdb));
REQUIRE(targetp != NULL && *targetp != NULL);
- node = (dns_qpdata_t *)(*targetp);
+ node = (qpcnode_t *)(*targetp);
nodelock = &qpdb->node_locks[node->locknum];
NODE_RDLOCK(&nodelock->lock, &nlocktype);
static isc_result_t
createiterator(dns_db_t *db, unsigned int options,
dns_dbiterator_t **iteratorp) {
- dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
+ qpcache_t *qpdb = (qpcache_t *)db;
qpdb_dbiterator_t *qpdbiter = NULL;
REQUIRE(VALID_QPDB(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_qpdata_t *qpnode = (dns_qpdata_t *)node;
+ qpcache_t *qpdb = (qpcache_t *)db;
+ qpcnode_t *qpnode = (qpcnode_t *)node;
qpdb_rdatasetiter_t *iterator = NULL;
REQUIRE(VALID_QPDB(qpdb));
}
static isc_result_t
-add(dns_qpdb_t *qpdb, dns_qpdata_t *qpnode,
+add(qpcache_t *qpdb, qpcnode_t *qpnode,
const dns_name_t *nodename ISC_ATTR_UNUSED, dns_slabheader_t *newheader,
unsigned int options, bool loading, dns_rdataset_t *addedrdataset,
isc_stdtime_t now, isc_rwlocktype_t nlocktype,
}
static void
-expire_ttl_headers(dns_qpdb_t *qpdb, unsigned int locknum,
+expire_ttl_headers(qpcache_t *qpdb, unsigned int locknum,
isc_rwlocktype_t *nlocktypep, isc_rwlocktype_t *tlocktypep,
isc_stdtime_t now, bool cache_is_overmem DNS__DB_FLARG);
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_qpdata_t *qpnode = (dns_qpdata_t *)node;
+ qpcache_t *qpdb = (qpcache_t *)db;
+ qpcnode_t *qpnode = (qpcnode_t *)node;
isc_region_t region;
dns_slabheader_t *newheader = NULL;
isc_result_t result;
result = ISC_R_SUCCESS;
if (newnsec) {
- dns_qpdata_t *nsecnode = NULL;
+ qpcnode_t *nsecnode = NULL;
result = dns_qp_getname(qpdb->nsec, name, (void **)&nsecnode,
NULL);
result = ISC_R_SUCCESS;
} else {
INSIST(nsecnode == NULL);
- nsecnode = new_qpdata(qpdb, name);
+ nsecnode = new_qpcnode(qpdb, name);
nsecnode->nsec = DNS_DB_NSEC_NSEC;
result = dns_qp_insert(qpdb->nsec, nsecnode, 0);
INSIST(result == ISC_R_SUCCESS);
- dns_qpdata_detach(&nsecnode);
+ qpcnode_detach(&nsecnode);
}
qpnode->nsec = DNS_DB_NSEC_HAS_NSEC;
}
static isc_result_t
deleterdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
dns_rdatatype_t type, dns_rdatatype_t covers DNS__DB_FLARG) {
- dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
- dns_qpdata_t *qpnode = (dns_qpdata_t *)node;
+ qpcache_t *qpdb = (qpcache_t *)db;
+ qpcnode_t *qpnode = (qpcnode_t *)node;
isc_result_t result;
dns_slabheader_t *newheader = NULL;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
static unsigned int
nodecount(dns_db_t *db, dns_dbtree_t tree) {
- dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
+ qpcache_t *qpdb = (qpcache_t *)db;
dns_qp_memusage_t mu;
isc_rwlocktype_t tlocktype = isc_rwlocktype_none;
static void
setloop(dns_db_t *db, isc_loop_t *loop) {
- dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
+ qpcache_t *qpdb = (qpcache_t *)db;
REQUIRE(VALID_QPDB(qpdb));
static isc_result_t
getoriginnode(dns_db_t *db, dns_dbnode_t **nodep DNS__DB_FLARG) {
- dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
- dns_qpdata_t *onode = NULL;
+ qpcache_t *qpdb = (qpcache_t *)db;
+ qpcnode_t *onode = NULL;
isc_result_t result = ISC_R_SUCCESS;
REQUIRE(VALID_QPDB(qpdb));
REQUIRE(nodep != NULL && *nodep == NULL);
/* Note that the access to origin_node doesn't require a DB lock */
- onode = (dns_qpdata_t *)qpdb->origin_node;
+ onode = (qpcnode_t *)qpdb->origin_node;
if (onode != NULL) {
newref(qpdb, onode, isc_rwlocktype_none,
isc_rwlocktype_none DNS__DB_FLARG_PASS);
static void
locknode(dns_db_t *db, dns_dbnode_t *node, isc_rwlocktype_t type) {
- dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
- dns_qpdata_t *qpnode = (dns_qpdata_t *)node;
+ qpcache_t *qpdb = (qpcache_t *)db;
+ qpcnode_t *qpnode = (qpcnode_t *)node;
RWLOCK(&qpdb->node_locks[qpnode->locknum].lock, type);
}
static void
unlocknode(dns_db_t *db, dns_dbnode_t *node, isc_rwlocktype_t type) {
- dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
- dns_qpdata_t *qpnode = (dns_qpdata_t *)node;
+ qpcache_t *qpdb = (qpcache_t *)db;
+ qpcnode_t *qpnode = (qpcnode_t *)node;
RWUNLOCK(&qpdb->node_locks[qpnode->locknum].lock, type);
}
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;
+ qpcache_t *qpdb = NULL;
isc_mem_t *hmctx = mctx;
int i;
REQUIRE(type == dns_dbtype_cache);
qpdb = isc_mem_get(mctx, sizeof(*qpdb));
- *qpdb = (dns_qpdb_t){
+ *qpdb = (qpcache_t){
.common.origin = DNS_NAME_INITEMPTY,
.common.rdclass = rdclass,
.current_serial = 1,
* Create deadnode lists.
*/
qpdb->deadnodes = isc_mem_cget(mctx, qpdb->node_lock_count,
- sizeof(dns_qpdatalist_t));
+ sizeof(qpcnodelist_t));
for (i = 0; i < (int)qpdb->node_lock_count; i++) {
ISC_LIST_INIT(qpdb->deadnodes[i]);
}
}
static bool
-iterator_active(dns_qpdb_t *qpdb, qpdb_rdatasetiter_t *rbtiterator,
+iterator_active(qpcache_t *qpdb, qpdb_rdatasetiter_t *rbtiterator,
dns_slabheader_t *header) {
dns_ttl_t stale_ttl = header->ttl + STALE_TTL(header, qpdb);
static isc_result_t
rdatasetiter_first(dns_rdatasetiter_t *iterator DNS__DB_FLARG) {
qpdb_rdatasetiter_t *rbtiterator = (qpdb_rdatasetiter_t *)iterator;
- dns_qpdb_t *qpdb = (dns_qpdb_t *)(rbtiterator->common.db);
- dns_qpdata_t *qpnode = rbtiterator->common.node;
+ qpcache_t *qpdb = (qpcache_t *)(rbtiterator->common.db);
+ qpcnode_t *qpnode = rbtiterator->common.node;
dns_slabheader_t *header = NULL, *top_next = NULL;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
static isc_result_t
rdatasetiter_next(dns_rdatasetiter_t *iterator DNS__DB_FLARG) {
qpdb_rdatasetiter_t *rbtiterator = (qpdb_rdatasetiter_t *)iterator;
- dns_qpdb_t *qpdb = (dns_qpdb_t *)(rbtiterator->common.db);
- dns_qpdata_t *qpnode = rbtiterator->common.node;
+ qpcache_t *qpdb = (qpcache_t *)(rbtiterator->common.db);
+ qpcnode_t *qpnode = rbtiterator->common.node;
dns_slabheader_t *header = NULL, *top_next = NULL;
dns_typepair_t type, negtype;
dns_rdatatype_t rdtype, covers;
rdatasetiter_current(dns_rdatasetiter_t *iterator,
dns_rdataset_t *rdataset DNS__DB_FLARG) {
qpdb_rdatasetiter_t *rbtiterator = (qpdb_rdatasetiter_t *)iterator;
- dns_qpdb_t *qpdb = (dns_qpdb_t *)(rbtiterator->common.db);
- dns_qpdata_t *qpnode = rbtiterator->common.node;
+ qpcache_t *qpdb = (qpcache_t *)(rbtiterator->common.db);
+ qpcnode_t *qpnode = rbtiterator->common.node;
dns_slabheader_t *header = NULL;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
static void
reference_iter_node(qpdb_dbiterator_t *qpdbiter DNS__DB_FLARG) {
- dns_qpdb_t *qpdb = (dns_qpdb_t *)qpdbiter->common.db;
- dns_qpdata_t *node = qpdbiter->node;
+ qpcache_t *qpdb = (qpcache_t *)qpdbiter->common.db;
+ qpcnode_t *node = qpdbiter->node;
if (node == NULL) {
return;
static void
dereference_iter_node(qpdb_dbiterator_t *qpdbiter DNS__DB_FLARG) {
- dns_qpdb_t *qpdb = (dns_qpdb_t *)qpdbiter->common.db;
- dns_qpdata_t *node = qpdbiter->node;
+ qpcache_t *qpdb = (qpcache_t *)qpdbiter->common.db;
+ qpcnode_t *node = qpdbiter->node;
isc_rwlock_t *lock = NULL;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
isc_rwlocktype_t tlocktype = qpdbiter->tree_locked;
static void
resume_iteration(qpdb_dbiterator_t *qpdbiter, bool continuing) {
- dns_qpdb_t *qpdb = (dns_qpdb_t *)qpdbiter->common.db;
+ qpcache_t *qpdb = (qpcache_t *)qpdbiter->common.db;
REQUIRE(qpdbiter->paused);
REQUIRE(qpdbiter->tree_locked == isc_rwlocktype_none);
static void
dbiterator_destroy(dns_dbiterator_t **iteratorp DNS__DB_FLARG) {
qpdb_dbiterator_t *qpdbiter = (qpdb_dbiterator_t *)(*iteratorp);
- dns_qpdb_t *qpdb = (dns_qpdb_t *)qpdbiter->common.db;
+ qpcache_t *qpdb = (qpcache_t *)qpdbiter->common.db;
dns_db_t *db = NULL;
if (qpdbiter->tree_locked == isc_rwlocktype_read) {
dbiterator_first(dns_dbiterator_t *iterator DNS__DB_FLARG) {
isc_result_t result;
qpdb_dbiterator_t *qpdbiter = (qpdb_dbiterator_t *)iterator;
- dns_qpdb_t *qpdb = (dns_qpdb_t *)iterator->db;
+ qpcache_t *qpdb = (qpcache_t *)iterator->db;
if (qpdbiter->result != ISC_R_SUCCESS &&
qpdbiter->result != ISC_R_NOTFOUND &&
dbiterator_last(dns_dbiterator_t *iterator DNS__DB_FLARG) {
isc_result_t result;
qpdb_dbiterator_t *qpdbiter = (qpdb_dbiterator_t *)iterator;
- dns_qpdb_t *qpdb = (dns_qpdb_t *)iterator->db;
+ qpcache_t *qpdb = (qpcache_t *)iterator->db;
if (qpdbiter->result != ISC_R_SUCCESS &&
qpdbiter->result != ISC_R_NOTFOUND &&
const dns_name_t *name DNS__DB_FLARG) {
isc_result_t result, tresult;
qpdb_dbiterator_t *qpdbiter = (qpdb_dbiterator_t *)iterator;
- dns_qpdb_t *qpdb = (dns_qpdb_t *)iterator->db;
+ qpcache_t *qpdb = (qpcache_t *)iterator->db;
if (qpdbiter->result != ISC_R_SUCCESS &&
qpdbiter->result != ISC_R_NOTFOUND &&
qpdbiter->current, NULL,
(void **)&qpdbiter->node, NULL);
if (result == DNS_R_PARTIALMATCH) {
- dns_qpdata_t *node = NULL;
+ qpcnode_t *node = NULL;
tresult = dns_qp_lookup(qpdb->nsec3, name, NULL,
&qpdbiter->nsec3iter, NULL,
(void **)&node, NULL);
dbiterator_prev(dns_dbiterator_t *iterator DNS__DB_FLARG) {
isc_result_t result;
qpdb_dbiterator_t *qpdbiter = (qpdb_dbiterator_t *)iterator;
- dns_qpdb_t *qpdb = (dns_qpdb_t *)iterator->db;
+ qpcache_t *qpdb = (qpcache_t *)iterator->db;
REQUIRE(qpdbiter->node != NULL);
dbiterator_next(dns_dbiterator_t *iterator DNS__DB_FLARG) {
isc_result_t result;
qpdb_dbiterator_t *qpdbiter = (qpdb_dbiterator_t *)iterator;
- dns_qpdb_t *qpdb = (dns_qpdb_t *)iterator->db;
+ qpcache_t *qpdb = (qpcache_t *)iterator->db;
REQUIRE(qpdbiter->node != NULL);
static isc_result_t
dbiterator_current(dns_dbiterator_t *iterator, dns_dbnode_t **nodep,
dns_name_t *name DNS__DB_FLARG) {
- dns_qpdb_t *qpdb = (dns_qpdb_t *)iterator->db;
+ qpcache_t *qpdb = (qpcache_t *)iterator->db;
qpdb_dbiterator_t *qpdbiter = (qpdb_dbiterator_t *)iterator;
- dns_qpdata_t *node = qpdbiter->node;
+ qpcnode_t *node = qpdbiter->node;
isc_result_t result = ISC_R_SUCCESS;
REQUIRE(qpdbiter->result == ISC_R_SUCCESS);
static isc_result_t
dbiterator_pause(dns_dbiterator_t *iterator) {
- dns_qpdb_t *qpdb = (dns_qpdb_t *)iterator->db;
+ qpcache_t *qpdb = (qpcache_t *)iterator->db;
qpdb_dbiterator_t *qpdbiter = (qpdb_dbiterator_t *)iterator;
if (qpdbiter->result != ISC_R_SUCCESS &&
deletedata(dns_db_t *db ISC_ATTR_UNUSED, dns_dbnode_t *node ISC_ATTR_UNUSED,
void *data) {
dns_slabheader_t *header = data;
- dns_qpdb_t *qpdb = (dns_qpdb_t *)header->db;
+ qpcache_t *qpdb = (qpcache_t *)header->db;
if (header->heap != NULL && header->heap_index != 0) {
isc_heap_delete(header->heap, header->heap_index);
* Caller must be holding the node write lock.
*/
static void
-expire_ttl_headers(dns_qpdb_t *qpdb, unsigned int locknum,
+expire_ttl_headers(qpcache_t *qpdb, unsigned int locknum,
isc_rwlocktype_t *nlocktypep, isc_rwlocktype_t *tlocktypep,
isc_stdtime_t now, bool cache_is_overmem DNS__DB_FLARG) {
isc_heap_t *heap = qpdb->heaps[locknum];
};
static void
-qpdata_destroy(dns_qpdata_t *data) {
+qpcnode_destroy(qpcnode_t *data) {
dns_slabheader_t *current = NULL, *next = NULL;
for (current = data->data; current != NULL; current = next) {
}
dns_name_free(&data->name, data->mctx);
- isc_mem_putanddetach(&data->mctx, data, sizeof(dns_qpdata_t));
+ isc_mem_putanddetach(&data->mctx, data, sizeof(qpcnode_t));
}
#ifdef DNS_DB_NODETRACE
-ISC_REFCOUNT_TRACE_IMPL(dns_qpdata, qpdata_destroy);
+ISC_REFCOUNT_TRACE_IMPL(qpcnode, qpcnode_destroy);
#else
-ISC_REFCOUNT_IMPL(dns_qpdata, qpdata_destroy);
+ISC_REFCOUNT_IMPL(qpcnode, qpcnode_destroy);
#endif
((atomic_load_acquire(&(header)->attributes) & \
DNS_SLABHEADERATTR_STATCOUNT) != 0)
-#define HEADERNODE(h) ((qpdata_t *)((h)->node))
+#define HEADERNODE(h) ((qpznode_t *)((h)->node))
#define QPDB_ATTR_LOADED 0x01
#define QPDB_ATTR_LOADING 0x02
#define DEFAULT_NODE_LOCK_COUNT 7 /*%< Should be prime. */
-#define HEADERNODE(h) ((qpdata_t *)((h)->node))
+#define HEADERNODE(h) ((qpznode_t *)((h)->node))
#define QPDBITER_NSEC3_ORIGIN_NODE(qpdb, iterator) \
((iterator)->current == &(iterator)->nsec3iter && \
((qpdb) != NULL && (qpdb)->common.impmagic == QPZONE_DB_MAGIC)
typedef struct qpzonedb qpzonedb_t;
-typedef struct qpdata qpdata_t;
+typedef struct qpznode qpznode_t;
typedef struct qpdb_changed {
- qpdata_t *node;
+ qpznode_t *node;
bool dirty;
ISC_LINK(struct qpdb_changed) link;
} qpdb_changed_t;
typedef ISC_LIST(qpdb_version_t) qpdb_versionlist_t;
-struct qpdata {
+struct qpznode {
dns_name_t name;
isc_mem_t *mctx;
isc_refcount_t references;
/* Locks for tree nodes */
int node_lock_count;
db_nodelock_t *node_locks;
- qpdata_t *origin;
- qpdata_t *nsec3_origin;
+ qpznode_t *origin;
+ qpznode_t *nsec3_origin;
isc_stats_t *gluecachestats;
/* Locked by lock. */
unsigned int active;
bool copy_name;
bool need_cleanup;
bool wild;
- qpdata_t *zonecut;
+ qpznode_t *zonecut;
dns_slabheader_t *zonecut_header;
dns_slabheader_t *zonecut_sigheader;
dns_fixedname_t zonecut_name;
static dns_dbmethods_t qpdb_zonemethods;
#if DNS_DB_NODETRACE
-#define qpdata_ref(ptr) qpdata__ref(ptr, __func__, __FILE__, __LINE__)
-#define qpdata_unref(ptr) qpdata__unref(ptr, __func__, __FILE__, __LINE__)
-#define qpdata_attach(ptr, ptrp) \
- qpdata__attach(ptr, ptrp, __func__, __FILE__, __LINE__)
-#define qpdata_detach(ptrp) qpdata__detach(ptrp, __func__, __FILE__, __LINE__)
-ISC_REFCOUNT_TRACE_DECL(qpdata);
+#define qpznode_ref(ptr) qpznode__ref(ptr, __func__, __FILE__, __LINE__)
+#define qpznode_unref(ptr) qpznode__unref(ptr, __func__, __FILE__, __LINE__)
+#define qpznode_attach(ptr, ptrp) \
+ qpznode__attach(ptr, ptrp, __func__, __FILE__, __LINE__)
+#define qpznode_detach(ptrp) qpznode__detach(ptrp, __func__, __FILE__, __LINE__)
+ISC_REFCOUNT_STATIC_TRACE_DECL(qpznode);
#else
-ISC_REFCOUNT_DECL(qpdata);
+ISC_REFCOUNT_STATIC_DECL(qpznode);
#endif
/* QP trie methods */
dns_qpiter_t *current; /* current iterator, which is one of: */
dns_qpiter_t mainiter; /* - main tree iterator */
dns_qpiter_t nsec3iter; /* - nsec3 tree iterator */
- qpdata_t *node;
+ qpznode_t *node;
enum { full, nonsec3, nsec3only } nsec3mode;
} qpdb_dbiterator_t;
unsigned int inactive = 0;
if (qpdb->origin != NULL) {
- qpdata_detach(&qpdb->origin);
+ qpznode_detach(&qpdb->origin);
}
if (qpdb->nsec3_origin != NULL) {
- qpdata_detach(&qpdb->nsec3_origin);
+ qpznode_detach(&qpdb->nsec3_origin);
}
/*
}
}
-static qpdata_t *
-new_qpdata(qpzonedb_t *qpdb, const dns_name_t *name) {
- qpdata_t *newdata = isc_mem_get(qpdb->common.mctx, sizeof(*newdata));
- *newdata = (qpdata_t){
+static qpznode_t *
+new_qpznode(qpzonedb_t *qpdb, const dns_name_t *name) {
+ qpznode_t *newdata = isc_mem_get(qpdb->common.mctx, sizeof(*newdata));
+ *newdata = (qpznode_t){
.name = DNS_NAME_INITEMPTY,
.references = ISC_REFCOUNT_INITIALIZER(1),
};
isc_mem_attach(qpdb->common.mctx, &newdata->mctx);
#if DNS_DB_NODETRACE
- fprintf(stderr, "new_qpdata:%s:%s:%d:%p->references = 1\n", __func__,
+ fprintf(stderr, "new_qpznode:%s:%s:%d:%p->references = 1\n", __func__,
__FILE__, __LINE__ + 1, name);
#endif
return (newdata);
*/
dns_qpmulti_write(qpdb->tree, &qp);
- qpdb->origin = new_qpdata(qpdb, &qpdb->common.origin);
+ qpdb->origin = new_qpznode(qpdb, &qpdb->common.origin);
result = dns_qp_insert(qp, qpdb->origin, 0);
qpdb->origin->nsec = DNS_DB_NSEC_NORMAL;
dns_qpmulti_commit(qpdb->tree, &qp);
* record in the tree.
*/
dns_qpmulti_write(qpdb->nsec3, &qp);
- qpdb->nsec3_origin = new_qpdata(qpdb, &qpdb->common.origin);
+ qpdb->nsec3_origin = new_qpznode(qpdb, &qpdb->common.origin);
qpdb->nsec3_origin->nsec = DNS_DB_NSEC_NSEC3;
result = dns_qp_insert(qp, qpdb->nsec3_origin, 0);
dns_qpmulti_commit(qpdb->nsec3, &qp);
}
static void
-newref(qpzonedb_t *qpdb, qpdata_t *node DNS__DB_FLARG) {
+newref(qpzonedb_t *qpdb, qpznode_t *node DNS__DB_FLARG) {
uint_fast32_t refs;
- qpdata_ref(node);
+ qpznode_ref(node);
refs = isc_refcount_increment0(&node->erefs);
#if DNS_DB_NODETRACE
fprintf(stderr, "incr:node:%s:%s:%u:%p->erefs = %" PRIuFAST32 "\n",
}
static void
-clean_zone_node(qpdata_t *node, uint32_t least_serial) {
+clean_zone_node(qpznode_t *node, uint32_t least_serial) {
dns_slabheader_t *current = NULL, *dcurrent = NULL;
dns_slabheader_t *down_next = NULL, *dparent = NULL;
dns_slabheader_t *top_prev = NULL, *top_next = NULL;
* not mean it will be immediately freed.)
*/
static void
-decref(qpzonedb_t *qpdb, qpdata_t *node, uint32_t least_serial,
+decref(qpzonedb_t *qpdb, qpznode_t *node, uint32_t least_serial,
isc_rwlocktype_t *nlocktypep DNS__DB_FLARG) {
db_nodelock_t *nodelock = NULL;
int bucket = node->locknum;
}
done:
- qpdata_unref(node);
+ qpznode_unref(node);
}
static void
-bindrdataset(qpzonedb_t *qpdb, qpdata_t *node, dns_slabheader_t *header,
+bindrdataset(qpzonedb_t *qpdb, qpznode_t *node, dns_slabheader_t *header,
isc_stdtime_t now, dns_rdataset_t *rdataset DNS__DB_FLARG) {
if (rdataset == NULL) {
return;
static void
setnsec3parameters(dns_db_t *db, qpdb_version_t *version) {
- qpdata_t *node = NULL;
+ qpznode_t *node = NULL;
dns_rdata_nsec3param_t nsec3param;
dns_rdata_t rdata = DNS_RDATA_INIT;
isc_region_t region;
}
static void
-rollback_node(qpdata_t *node, uint32_t serial) {
+rollback_node(qpznode_t *node, uint32_t serial) {
dns_slabheader_t *header = NULL, *dcurrent = NULL;
bool make_dirty = false;
qpzonedb_t *qpdb = (qpzonedb_t *)db;
qpdb_version_t *version = NULL, *cleanup_version = NULL;
qpdb_version_t *least_greater = NULL;
- qpdata_t *node = NULL;
+ qpznode_t *node = NULL;
bool rollback = false;
qpdb_changed_t *changed = NULL, *next_changed = NULL;
qpdb_changedlist_t cleanup_list;
isc_stdtime_t now ISC_ATTR_UNUSED, dns_rdataset_t *rdataset,
dns_rdataset_t *sigrdataset DNS__DB_FLARG) {
qpzonedb_t *qpdb = (qpzonedb_t *)db;
- qpdata_t *node = (qpdata_t *)dbnode;
+ qpznode_t *node = (qpznode_t *)dbnode;
dns_slabheader_t *header = NULL, *header_next = NULL;
dns_slabheader_t *found = NULL, *foundsig = NULL;
uint32_t serial;
}
static bool
-delegating_type(qpzonedb_t *qpdb, qpdata_t *node, dns_typepair_t type) {
+delegating_type(qpzonedb_t *qpdb, qpznode_t *node, dns_typepair_t type) {
return (type == dns_rdatatype_dname ||
(type == dns_rdatatype_ns &&
(node != qpdb->origin || IS_STUB(qpdb))));
static void
loading_addnode(qpdb_load_t *loadctx, const dns_name_t *name,
dns_rdatatype_t type, dns_rdatatype_t covers,
- qpdata_t **nodep) {
+ qpznode_t **nodep) {
qpzonedb_t *qpdb = (qpzonedb_t *)loadctx->db;
isc_result_t result;
- qpdata_t *node = NULL, *nsecnode = NULL;
+ qpznode_t *node = NULL, *nsecnode = NULL;
if (type == dns_rdatatype_nsec3 || covers == dns_rdatatype_nsec3) {
result = dns_qp_getname(loadctx->nsec3, name, (void **)&node,
if (result == ISC_R_SUCCESS) {
*nodep = node;
} else {
- node = new_qpdata(qpdb, name);
+ node = new_qpznode(qpdb, name);
result = dns_qp_insert(loadctx->nsec3, node, 0);
INSIST(result == ISC_R_SUCCESS);
node->nsec = DNS_DB_NSEC_NSEC3;
*nodep = node;
- qpdata_detach(&node);
+ qpznode_detach(&node);
}
return;
}
}
} else {
INSIST(node == NULL);
- node = new_qpdata(qpdb, name);
+ node = new_qpznode(qpdb, name);
result = dns_qp_insert(loadctx->tree, node, 0);
INSIST(result == ISC_R_SUCCESS);
- qpdata_unref(node);
+ qpznode_unref(node);
}
if (type != dns_rdatatype_nsec) {
goto done;
* too. This tree speeds searches for closest NSECs that would
* otherwise need to examine many irrelevant nodes in large TLDs.
*/
- nsecnode = new_qpdata(qpdb, name);
+ nsecnode = new_qpznode(qpdb, name);
result = dns_qp_insert(loadctx->nsec, nsecnode, 0);
node->nsec = DNS_DB_NSEC_HAS_NSEC;
if (result == ISC_R_SUCCESS) {
nsecnode->nsec = DNS_DB_NSEC_NSEC;
}
- qpdata_detach(&nsecnode);
+ qpznode_detach(&nsecnode);
done:
*nodep = node;
}
static bool
-cname_and_other(qpdata_t *node, uint32_t serial) {
+cname_and_other(qpznode_t *node, uint32_t serial) {
dns_slabheader_t *header = NULL, *header_next = NULL;
bool cname = false, other = false;
dns_rdatatype_t rdtype;
add_changed(dns_slabheader_t *header, qpdb_version_t *version DNS__DB_FLARG) {
qpdb_changed_t *changed = NULL;
qpzonedb_t *qpdb = (qpzonedb_t *)header->db;
- qpdata_t *node = (qpdata_t *)header->node;
+ qpznode_t *node = (qpznode_t *)header->node;
changed = isc_mem_get(qpdb->common.mctx, sizeof(*changed));
}
static isc_result_t
-add(qpzonedb_t *qpdb, qpdata_t *node, const dns_name_t *nodename,
+add(qpzonedb_t *qpdb, qpznode_t *node, const dns_name_t *nodename,
qpdb_version_t *version, dns_slabheader_t *newheader, unsigned int options,
bool loading, dns_rdataset_t *addedrdataset,
isc_stdtime_t now DNS__DB_FLARG) {
dns_name_t foundname;
dns_offsets_t offsets;
unsigned int n;
- qpdata_t *node = NULL;
+ qpznode_t *node = NULL;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
dns_name_init(&foundname, offsets);
result = dns_qp_getname(qp, &foundname, (void **)&node, NULL);
if (result != ISC_R_SUCCESS) {
INSIST(node == NULL);
- node = new_qpdata(qpdb, &foundname);
+ node = new_qpznode(qpdb, &foundname);
result = dns_qp_insert(qp, node, 0);
INSIST(result == ISC_R_SUCCESS);
- qpdata_unref(node);
+ qpznode_unref(node);
}
/* set the bit, locking if necessary */
dns_rdataset_t *rdataset DNS__DB_FLARG) {
qpdb_load_t *loadctx = arg;
qpzonedb_t *qpdb = (qpzonedb_t *)loadctx->db;
- qpdata_t *node = NULL;
+ qpznode_t *node = NULL;
isc_result_t result = ISC_R_SUCCESS;
isc_region_t region;
dns_slabheader_t *newheader = NULL;
findnodeintree(qpzonedb_t *qpdb, const dns_name_t *name, bool create,
bool nsec3, dns_dbnode_t **nodep DNS__DB_FLARG) {
isc_result_t result;
- qpdata_t *node = NULL;
+ qpznode_t *node = NULL;
dns_qpmulti_t *dbtree = nsec3 ? qpdb->nsec3 : qpdb->tree;
dns_qpread_t qpr = { 0 };
dns_qp_t *qp = NULL;
return (result);
}
- node = new_qpdata(qpdb, name);
+ node = new_qpznode(qpdb, name);
result = dns_qp_insert(qp, node, 0);
- qpdata_unref(node);
+ qpznode_unref(node);
if (result == ISC_R_SUCCESS) {
if (nsec3) {
dns_rdataset_t *sigrdataset DNS__DB_FLARG) {
dns_name_t *zcname = NULL;
dns_typepair_t type;
- qpdata_t *node = NULL;
+ qpznode_t *node = NULL;
REQUIRE(search != NULL);
REQUIRE(search->zonecut != NULL);
dns_fixedname_t fnodename;
dns_name_t *nodename = dns_fixedname_initname(&fnodename);
qpzonedb_t *qpdb = NULL;
- qpdata_t *node = NULL;
+ qpznode_t *node = NULL;
isc_result_t result = ISC_R_SUCCESS;
dns_slabheader_t *header = NULL;
}
static isc_result_t
-find_wildcard(qpdb_search_t *search, qpdata_t **nodep,
+find_wildcard(qpdb_search_t *search, qpznode_t **nodep,
const dns_name_t *qname) {
dns_slabheader_t *header = NULL;
isc_result_t result = ISC_R_NOTFOUND;
* continue the search.
*/
for (int i = dns_qpchain_length(&search->chain) - 1; i >= 0; i--) {
- qpdata_t *node = NULL;
+ qpznode_t *node = NULL;
isc_rwlock_t *lock = NULL;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
bool wild, active;
NODE_UNLOCK(lock, &nlocktype);
if (wild) {
- qpdata_t *wnode = NULL;
+ qpznode_t *wnode = NULL;
dns_fixedname_t fwname;
dns_name_t *wname = dns_fixedname_initname(&fwname);
dns_qpiter_t wit;
*/
static isc_result_t
previous_closest_nsec(dns_rdatatype_t type, qpdb_search_t *search,
- dns_name_t *name, qpdata_t **nodep, dns_qpiter_t *nit,
+ dns_name_t *name, qpznode_t **nodep, dns_qpiter_t *nit,
bool *firstp) {
isc_result_t result;
dns_qpread_t qpr;
dns_name_t *foundname, dns_rdataset_t *rdataset,
dns_rdataset_t *sigrdataset, bool nsec3,
bool secure DNS__DB_FLARG) {
- qpdata_t *node = NULL, *prevnode = NULL;
+ qpznode_t *node = NULL, *prevnode = NULL;
dns_slabheader_t *header = NULL, *header_next = NULL;
dns_qpiter_t nseciter;
bool empty_node;
}
static isc_result_t
-check_zonecut(qpdata_t *node, void *arg DNS__DB_FLARG) {
+check_zonecut(qpznode_t *node, void *arg DNS__DB_FLARG) {
qpdb_search_t *search = arg;
dns_slabheader_t *header = NULL, *header_next = NULL;
dns_slabheader_t *dname_header = NULL, *sigdname_header = NULL;
dns_rdataset_t *sigrdataset DNS__DB_FLARG) {
isc_result_t result;
qpzonedb_t *qpdb = (qpzonedb_t *)db;
- qpdata_t *node = NULL;
+ qpznode_t *node = NULL;
qpdb_search_t search;
bool cname_ok = true, close_version = false;
bool maybe_zonecut = false, at_zonecut = false;
clen--;
}
for (unsigned int i = 0; i < clen && search.zonecut == NULL; i++) {
- qpdata_t *n = NULL;
+ qpznode_t *n = NULL;
isc_result_t tresult;
dns_qpchain_node(&search.chain, i, NULL, (void **)&n, NULL);
unsigned int options, isc_stdtime_t now ISC_ATTR_UNUSED,
dns_rdatasetiter_t **iteratorp DNS__DB_FLARG) {
qpzonedb_t *qpdb = (qpzonedb_t *)db;
- qpdata_t *node = (qpdata_t *)dbnode;
+ qpznode_t *node = (qpznode_t *)dbnode;
qpdb_version_t *version = dbversion;
qpdb_rdatasetiter_t *iterator = NULL;
attachnode(dns_db_t *db, dns_dbnode_t *source,
dns_dbnode_t **targetp DNS__DB_FLARG) {
qpzonedb_t *qpdb = (qpzonedb_t *)db;
- qpdata_t *node = (qpdata_t *)source;
+ qpznode_t *node = (qpznode_t *)source;
REQUIRE(VALID_QPZONE(qpdb));
REQUIRE(targetp != NULL && *targetp == NULL);
static void
detachnode(dns_db_t *db, dns_dbnode_t **targetp DNS__DB_FLARG) {
qpzonedb_t *qpdb = (qpzonedb_t *)db;
- qpdata_t *node = NULL;
+ qpznode_t *node = NULL;
bool want_free = false;
bool inactive = false;
db_nodelock_t *nodelock = NULL;
REQUIRE(VALID_QPZONE(qpdb));
REQUIRE(targetp != NULL && *targetp != NULL);
- node = (qpdata_t *)(*targetp);
+ node = (qpznode_t *)(*targetp);
nodelock = &qpdb->node_locks[node->locknum];
NODE_RDLOCK(&nodelock->lock, &nlocktype);
static isc_result_t
getoriginnode(dns_db_t *db, dns_dbnode_t **nodep DNS__DB_FLARG) {
qpzonedb_t *qpdb = (qpzonedb_t *)db;
- qpdata_t *onode = NULL;
+ qpznode_t *onode = NULL;
REQUIRE(VALID_QPZONE(qpdb));
REQUIRE(nodep != NULL && *nodep == NULL);
/* Note that the access to the origin node doesn't require a DB lock */
- onode = (qpdata_t *)qpdb->origin;
+ onode = (qpznode_t *)qpdb->origin;
INSIST(onode != NULL);
newref(qpdb, onode DNS__DB_FLARG_PASS);
*nodep = onode;
static void
locknode(dns_db_t *db, dns_dbnode_t *dbnode, isc_rwlocktype_t type) {
qpzonedb_t *qpdb = (qpzonedb_t *)db;
- qpdata_t *node = (qpdata_t *)dbnode;
+ qpznode_t *node = (qpznode_t *)dbnode;
RWLOCK(&qpdb->node_locks[node->locknum].lock, type);
}
static void
unlocknode(dns_db_t *db, dns_dbnode_t *dbnode, isc_rwlocktype_t type) {
qpzonedb_t *qpdb = (qpzonedb_t *)db;
- qpdata_t *node = (qpdata_t *)dbnode;
+ qpznode_t *node = (qpznode_t *)dbnode;
RWUNLOCK(&qpdb->node_locks[node->locknum].lock, type);
}
rdatasetiter_first(dns_rdatasetiter_t *iterator DNS__DB_FLARG) {
qpdb_rdatasetiter_t *qrditer = (qpdb_rdatasetiter_t *)iterator;
qpzonedb_t *qpdb = (qpzonedb_t *)(qrditer->common.db);
- qpdata_t *node = qrditer->common.node;
+ qpznode_t *node = qrditer->common.node;
qpdb_version_t *version = qrditer->common.version;
dns_slabheader_t *header = NULL, *top_next = NULL;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
rdatasetiter_next(dns_rdatasetiter_t *iterator DNS__DB_FLARG) {
qpdb_rdatasetiter_t *qrditer = (qpdb_rdatasetiter_t *)iterator;
qpzonedb_t *qpdb = (qpzonedb_t *)(qrditer->common.db);
- qpdata_t *node = qrditer->common.node;
+ qpznode_t *node = qrditer->common.node;
qpdb_version_t *version = qrditer->common.version;
dns_slabheader_t *header = NULL, *top_next = NULL;
dns_typepair_t type, negtype;
dns_rdataset_t *rdataset DNS__DB_FLARG) {
qpdb_rdatasetiter_t *qrditer = (qpdb_rdatasetiter_t *)iterator;
qpzonedb_t *qpdb = (qpzonedb_t *)(qrditer->common.db);
- qpdata_t *node = qrditer->common.node;
+ qpznode_t *node = qrditer->common.node;
dns_slabheader_t *header = NULL;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
static void
reference_iter_node(qpdb_dbiterator_t *iter DNS__DB_FLARG) {
qpzonedb_t *qpdb = (qpzonedb_t *)iter->common.db;
- qpdata_t *node = iter->node;
+ qpznode_t *node = iter->node;
if (node == NULL) {
return;
static void
dereference_iter_node(qpdb_dbiterator_t *iter DNS__DB_FLARG) {
qpzonedb_t *qpdb = (qpzonedb_t *)iter->common.db;
- qpdata_t *node = iter->node;
+ qpznode_t *node = iter->node;
isc_rwlock_t *lock = NULL;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
qpdbiter->current, NULL,
(void **)&qpdbiter->node, NULL);
if (result == DNS_R_PARTIALMATCH) {
- dns_qpdata_t *node = NULL;
+ qpznode_t *node = NULL;
tresult = dns_qp_lookup(qpdbiter->nsnap, name, NULL,
&qpdbiter->nsec3iter, NULL,
(void **)&node, NULL);
dns_name_t *name DNS__DB_FLARG) {
qpzonedb_t *qpdb = (qpzonedb_t *)iterator->db;
qpdb_dbiterator_t *qpdbiter = (qpdb_dbiterator_t *)iterator;
- qpdata_t *node = qpdbiter->node;
+ qpznode_t *node = qpdbiter->node;
REQUIRE(qpdbiter->result == ISC_R_SUCCESS);
REQUIRE(qpdbiter->node != NULL);
unsigned int options, dns_rdataset_t *addedrdataset DNS__DB_FLARG) {
isc_result_t result;
qpzonedb_t *qpdb = (qpzonedb_t *)db;
- qpdata_t *node = (qpdata_t *)dbnode;
+ qpznode_t *node = (qpznode_t *)dbnode;
qpdb_version_t *version = dbversion;
isc_region_t region;
dns_slabheader_t *newheader = NULL;
result = ISC_R_SUCCESS;
if (nsec != NULL) {
- qpdata_t *nsecnode = new_qpdata(qpdb, name);
+ qpznode_t *nsecnode = new_qpznode(qpdb, name);
result = dns_qp_insert(nsec, nsecnode, 0);
if (result == ISC_R_SUCCESS) {
nsecnode->nsec = DNS_DB_NSEC_NSEC;
node->nsec = DNS_DB_NSEC_HAS_NSEC;
result = ISC_R_SUCCESS;
}
- qpdata_detach(&nsecnode);
+ qpznode_detach(&nsecnode);
}
if (result == ISC_R_SUCCESS) {
dns_rdataset_t *rdataset, unsigned int options,
dns_rdataset_t *newrdataset DNS__DB_FLARG) {
qpzonedb_t *qpdb = (qpzonedb_t *)db;
- qpdata_t *node = (qpdata_t *)dbnode;
+ qpznode_t *node = (qpznode_t *)dbnode;
qpdb_version_t *version = dbversion;
dns_fixedname_t fname;
dns_name_t *nodename = dns_fixedname_initname(&fname);
deleterdataset(dns_db_t *db, dns_dbnode_t *dbnode, dns_dbversion_t *dbversion,
dns_rdatatype_t type, dns_rdatatype_t covers DNS__DB_FLARG) {
qpzonedb_t *qpdb = (qpzonedb_t *)db;
- qpdata_t *node = (qpdata_t *)dbnode;
+ qpznode_t *node = (qpznode_t *)dbnode;
qpdb_version_t *version = dbversion;
dns_fixedname_t fname;
dns_name_t *nodename = dns_fixedname_initname(&fname);
static isc_result_t
nodefullname(dns_db_t *db, dns_dbnode_t *node, dns_name_t *name) {
qpzonedb_t *qpdb = (qpzonedb_t *)db;
- qpdata_t *qpnode = (qpdata_t *)node;
+ qpznode_t *qpnode = (qpznode_t *)node;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
REQUIRE(VALID_QPZONE(qpdb));
dns_fixedname_t fixedname_a;
dns_name_t *name_a = NULL;
dns_rdataset_t rdataset_a, sigrdataset_a;
- qpdata_t *node_a = NULL;
+ qpznode_t *node_a = NULL;
dns_fixedname_t fixedname_aaaa;
dns_name_t *name_aaaa = NULL;
dns_rdataset_t rdataset_aaaa, sigrdataset_aaaa;
- qpdata_t *node_aaaa = NULL;
+ qpznode_t *node_aaaa = NULL;
dns_glue_t *glue = NULL;
UNUSED(unused);
}
static dns_glue_t *
-newglue(qpzonedb_t *qpdb, qpdb_version_t *version, qpdata_t *node,
+newglue(qpzonedb_t *qpdb, qpdb_version_t *version, qpznode_t *node,
dns_rdataset_t *rdataset) {
dns_fixedname_t nodename;
dns_glue_additionaldata_ctx_t ctx = {
dns_message_t *msg) {
qpzonedb_t *qpdb = (qpzonedb_t *)db;
qpdb_version_t *version = dbversion;
- qpdata_t *node = (qpdata_t *)rdataset->slab.node;
+ qpznode_t *node = (qpznode_t *)rdataset->slab.node;
dns_slabheader_t *header = dns_slabheader_fromrdataset(rdataset);
REQUIRE(rdataset->type == dns_rdatatype_ns);
};
static void
-destroy_qpdata(qpdata_t *node) {
+destroy_qpznode(qpznode_t *node) {
dns_slabheader_t *current = NULL, *next = NULL;
for (current = node->data; current != NULL; current = next) {
}
dns_name_free(&node->name, node->mctx);
- isc_mem_putanddetach(&node->mctx, node, sizeof(qpdata_t));
+ isc_mem_putanddetach(&node->mctx, node, sizeof(qpznode_t));
}
#if DNS_DB_NODETRACE
-ISC_REFCOUNT_TRACE_IMPL(qpdata, destroy_qpdata);
+ISC_REFCOUNT_TRACE_IMPL(qpznode, destroy_qpznode);
#else
-ISC_REFCOUNT_IMPL(qpdata, destroy_qpdata);
+ISC_REFCOUNT_IMPL(qpznode, destroy_qpznode);
#endif
static void
qp_attach(void *uctx ISC_ATTR_UNUSED, void *pval,
uint32_t ival ISC_ATTR_UNUSED) {
- qpdata_t *data = pval;
- qpdata_ref(data);
+ qpznode_t *data = pval;
+ qpznode_ref(data);
}
static void
qp_detach(void *uctx ISC_ATTR_UNUSED, void *pval,
uint32_t ival ISC_ATTR_UNUSED) {
- qpdata_t *data = pval;
- qpdata_detach(&data);
+ qpznode_t *data = pval;
+ qpznode_detach(&data);
}
static size_t
qp_makekey(dns_qpkey_t key, void *uctx ISC_ATTR_UNUSED, void *pval,
uint32_t ival ISC_ATTR_UNUSED) {
- qpdata_t *data = pval;
+ qpznode_t *data = pval;
return (dns_qpkey_fromname(key, &data->name));
}
projects / thirdparty / bind9.git / commitdiff
