clientinfo.c \
compress.c \
db.c \
+ db_p.h \
dbiterator.c \
diff.c \
dispatch.c \
* Built in database implementations are registered here.
*/
+#include "db_p.h"
#include "rbtdb_p.h"
unsigned int dns_pps = 0U;
--- /dev/null
+/*
+ * Copyright (C) Internet Systems Consortium, Inc. ("ISC")
+ *
+ * SPDX-License-Identifier: MPL-2.0
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, you can obtain one at https://mozilla.org/MPL/2.0/.
+ *
+ * See the COPYRIGHT file distributed with this work for additional
+ * information regarding copyright ownership.
+ */
+
+#pragma once
+
+#include <isc/heap.h>
+#include <isc/lang.h>
+#include <isc/urcu.h>
+
+#include <dns/nsec3.h>
+#include <dns/rbt.h>
+#include <dns/types.h>
+
+#define RDATATYPE_NCACHEANY DNS_TYPEPAIR_VALUE(0, dns_rdatatype_any)
+
+#ifdef STRONG_RWLOCK_CHECK
+#define STRONG_RWLOCK_CHECK(cond) REQUIRE(cond)
+#else
+#define STRONG_RWLOCK_CHECK(cond)
+#endif
+
+#define NODE_INITLOCK(l) isc_rwlock_init((l))
+#define NODE_DESTROYLOCK(l) isc_rwlock_destroy(l)
+#define NODE_LOCK(l, t, tp) \
+ { \
+ STRONG_RWLOCK_CHECK(*tp == isc_rwlocktype_none); \
+ RWLOCK((l), (t)); \
+ *tp = t; \
+ }
+#define NODE_UNLOCK(l, tp) \
+ { \
+ STRONG_RWLOCK_CHECK(*tp != isc_rwlocktype_none); \
+ RWUNLOCK(l, *tp); \
+ *tp = isc_rwlocktype_none; \
+ }
+#define NODE_RDLOCK(l, tp) NODE_LOCK(l, isc_rwlocktype_read, tp);
+#define NODE_WRLOCK(l, tp) NODE_LOCK(l, isc_rwlocktype_write, tp);
+#define NODE_TRYLOCK(l, t, tp) \
+ ({ \
+ STRONG_RWLOCK_CHECK(*tp == isc_rwlocktype_none); \
+ isc_result_t _result = isc_rwlock_trylock(l, t); \
+ if (_result == ISC_R_SUCCESS) { \
+ *tp = t; \
+ }; \
+ _result; \
+ })
+#define NODE_TRYRDLOCK(l, tp) NODE_TRYLOCK(l, isc_rwlocktype_read, tp)
+#define NODE_TRYWRLOCK(l, tp) NODE_TRYLOCK(l, isc_rwlocktype_write, tp)
+#define NODE_TRYUPGRADE(l, tp) \
+ ({ \
+ STRONG_RWLOCK_CHECK(*tp == isc_rwlocktype_read); \
+ isc_result_t _result = isc_rwlock_tryupgrade(l); \
+ if (_result == ISC_R_SUCCESS) { \
+ *tp = isc_rwlocktype_write; \
+ }; \
+ _result; \
+ })
+#define NODE_FORCEUPGRADE(l, tp) \
+ if (NODE_TRYUPGRADE(l, tp) != ISC_R_SUCCESS) { \
+ NODE_UNLOCK(l, tp); \
+ NODE_WRLOCK(l, tp); \
+ }
+
+#define TREE_INITLOCK(l) isc_rwlock_init(l)
+#define TREE_DESTROYLOCK(l) isc_rwlock_destroy(l)
+#define TREE_LOCK(l, t, tp) \
+ { \
+ STRONG_RWLOCK_CHECK(*tp == isc_rwlocktype_none); \
+ RWLOCK(l, t); \
+ *tp = t; \
+ }
+#define TREE_UNLOCK(l, tp) \
+ { \
+ STRONG_RWLOCK_CHECK(*tp != isc_rwlocktype_none); \
+ RWUNLOCK(l, *tp); \
+ *tp = isc_rwlocktype_none; \
+ }
+#define TREE_RDLOCK(l, tp) TREE_LOCK(l, isc_rwlocktype_read, tp);
+#define TREE_WRLOCK(l, tp) TREE_LOCK(l, isc_rwlocktype_write, tp);
+#define TREE_TRYLOCK(l, t, tp) \
+ ({ \
+ STRONG_RWLOCK_CHECK(*tp == isc_rwlocktype_none); \
+ isc_result_t _result = isc_rwlock_trylock(l, t); \
+ if (_result == ISC_R_SUCCESS) { \
+ *tp = t; \
+ }; \
+ _result; \
+ })
+#define TREE_TRYRDLOCK(l, tp) TREE_TRYLOCK(l, isc_rwlocktype_read, tp)
+#define TREE_TRYWRLOCK(l, tp) TREE_TRYLOCK(l, isc_rwlocktype_write, tp)
+#define TREE_TRYUPGRADE(l, tp) \
+ ({ \
+ STRONG_RWLOCK_CHECK(*tp == isc_rwlocktype_read); \
+ isc_result_t _result = isc_rwlock_tryupgrade(l); \
+ if (_result == ISC_R_SUCCESS) { \
+ *tp = isc_rwlocktype_write; \
+ }; \
+ _result; \
+ })
+#define TREE_FORCEUPGRADE(l, tp) \
+ if (TREE_TRYUPGRADE(l, tp) != ISC_R_SUCCESS) { \
+ TREE_UNLOCK(l, tp); \
+ TREE_WRLOCK(l, tp); \
+ }
+
+#define IS_STUB(db) (((db)->common.attributes & DNS_DBATTR_STUB) != 0)
+#define IS_CACHE(db) (((db)->common.attributes & DNS_DBATTR_CACHE) != 0)
+
+ISC_LANG_BEGINDECLS
+
+struct dns_glue {
+ struct dns_glue *next;
+ dns_fixedname_t fixedname;
+ dns_rdataset_t rdataset_a;
+ dns_rdataset_t sigrdataset_a;
+ dns_rdataset_t rdataset_aaaa;
+ dns_rdataset_t sigrdataset_aaaa;
+
+ isc_mem_t *mctx;
+ struct rcu_head rcu_head;
+};
+
+typedef struct {
+ dns_glue_t *glue_list;
+ dns_db_t *db;
+ dns_dbversion_t *version;
+ dns_name_t *nodename;
+} dns_glue_additionaldata_ctx_t;
+
+typedef struct {
+ isc_rwlock_t lock;
+ /* Protected in the refcount routines. */
+ isc_refcount_t references;
+ /* Locked by lock. */
+ bool exiting;
+} db_nodelock_t;
+
+/*%
+ * Prune context
+ */
+typedef struct {
+ dns_db_t *db;
+ dns_dbnode_t *node;
+} db_prune_t;
+
+ISC_LANG_ENDDECLS
* comments in rbtdb.c for details.)
*/
struct {
- struct dns_db *db;
- dns_dbnode_t *node;
- unsigned char *raw;
- unsigned char *iter_pos;
- unsigned int iter_count;
- dns_proof_t *noqname, *closest;
+ struct dns_db *db;
+ dns_dbnode_t *node;
+ unsigned char *raw;
+ unsigned char *iter_pos;
+ unsigned int iter_count;
+ dns_slabheader_proof_t *noqname, *closest;
} slab;
/*
#define DNS_RDATASLAB_OFFLINE 0x01 /* RRSIG is for offline DNSKEY */
-struct dns_proof {
+struct dns_slabheader_proof {
dns_name_t name;
void *neg;
void *negsig;
atomic_uint_fast32_t last_refresh_fail_ts;
- dns_proof_t *noqname;
- dns_proof_t *closest;
+ dns_slabheader_proof_t *noqname;
+ dns_slabheader_proof_t *closest;
/*%<
* We don't use the LIST macros, because the LIST structure has
* both head and tail pointers, and is doubly linked.
/*%<
* Free all memory associated with '*headerp'.
*/
+
+void
+dns_slabheader_freeproof(isc_mem_t *mctx, dns_slabheader_proof_t **proof);
+/*%<
+ * Free all memory associated with a nonexistence proof.
+ */
ISC_LANG_ENDDECLS
#define DNS_TYPEPAIR_COVERS(type) ((dns_rdatatype_t)((type) >> 16))
#define DNS_TYPEPAIR_VALUE(base, ext) \
((dns_typepair_t)(((uint32_t)ext) << 16) | (((uint32_t)base) & 0xffff))
+#define DNS_SIGTYPE(type) \
+ ((dns_typepair_t)(((uint32_t)type) << 16) | \
+ (((uint32_t)dns_rdatatype_rrsig) & 0xffff))
ISC_LANG_BEGINDECLS
typedef struct dns_name dns_name_t;
typedef struct dns_nametree dns_nametree_t;
typedef ISC_LIST(dns_name_t) dns_namelist_t;
-typedef struct dns_ntatable dns_ntatable_t;
-typedef struct dns_ntnode dns_ntnode_t;
-typedef uint16_t dns_opcode_t;
-typedef struct dns_order dns_order_t;
-typedef struct dns_peer dns_peer_t;
-typedef struct dns_peerlist dns_peerlist_t;
-typedef struct dns_proof dns_proof_t;
-typedef struct dns_rbt dns_rbt_t;
-typedef struct dns_rbtdb dns_rbtdb_t;
-typedef struct dns_rbtdb_version dns_rbtdb_version_t;
-typedef struct dns_rbtnode dns_rbtnode_t;
+typedef struct dns_ntatable dns_ntatable_t;
+typedef struct dns_ntnode dns_ntnode_t;
+typedef uint16_t dns_opcode_t;
+typedef struct dns_order dns_order_t;
+typedef struct dns_peer dns_peer_t;
+typedef struct dns_peerlist dns_peerlist_t;
+typedef struct dns_slabheader_proof dns_slabheader_proof_t;
+typedef struct dns_rbt dns_rbt_t;
+typedef struct dns_rbtdb dns_rbtdb_t;
+typedef struct dns_rbtdb_version dns_rbtdb_version_t;
+typedef struct dns_rbtnode dns_rbtnode_t;
typedef ISC_LIST(dns_rbtnode_t) dns_rbtnodelist_t;
typedef uint16_t dns_rcode_t;
typedef struct dns_rdata dns_rdata_t;
#include <dns/zone.h>
#include <dns/zonekey.h>
+#include "db_p.h"
#include "rbtdb_p.h"
#define CHECK(op) \
/* To be checked: can we really assume this? XXXMLG */
INSIST(ISC_LINK_LINKED(header, link));
- ISC_LIST_UNLINK(rbtdb->lru[HEADER_NODE(header)->locknum], header, link);
+ ISC_LIST_UNLINK(rbtdb->lru[RBTDB_HEADERNODE(header)->locknum], header,
+ link);
header->last_used = now;
- ISC_LIST_PREPEND(rbtdb->lru[HEADER_NODE(header)->locknum], header,
+ ISC_LIST_PREPEND(rbtdb->lru[RBTDB_HEADERNODE(header)->locknum], header,
link);
}
} else {
dns__rbtdb_mark(header,
DNS_SLABHEADERATTR_ANCIENT);
- HEADER_NODE(header)->dirty = 1;
+ RBTDB_HEADERNODE(header)->dirty = 1;
*header_prev = header;
}
} else {
{
dname_header = header;
header_prev = header;
- } else if (header->type == RBTDB_RDATATYPE_SIGDNAME &&
+ } else if (header->type == DNS_SIGTYPE(dns_rdatatype_dname) &&
EXISTS(header) && !ANCIENT(header))
{
sigdname_header = header;
break;
}
} else if (header->type ==
- RBTDB_RDATATYPE_SIGNS)
+ DNS_SIGTYPE(dns_rdatatype_ns))
{
foundsig = header;
if (found != NULL) {
fname = dns_fixedname_initname(&fixed);
matchtype = DNS_TYPEPAIR_VALUE(dns_rdatatype_nsec, 0);
- sigmatchtype = DNS_TYPEPAIR_VALUE(dns_rdatatype_rrsig,
- dns_rdatatype_nsec);
+ sigmatchtype = DNS_SIGTYPE(dns_rdatatype_nsec);
/*
* Extract predecessor from chain.
*/
found = NULL;
foundsig = NULL;
- sigtype = DNS_TYPEPAIR_VALUE(dns_rdatatype_rrsig, type);
+ sigtype = DNS_SIGTYPE(type);
negtype = DNS_TYPEPAIR_VALUE(0, type);
nsheader = NULL;
nsecheader = NULL;
if (cnamesig != NULL) {
foundsig = cnamesig;
} else {
- sigtype =
- RBTDB_RDATATYPE_SIGCNAME;
+ sigtype = DNS_SIGTYPE(
+ dns_rdatatype_cname);
}
}
} else if (header->type == sigtype) {
* target type. Remember it.
*/
foundsig = header;
- } else if (header->type == RBTDB_RDATATYPE_NCACHEANY ||
+ } else if (header->type == RDATATYPE_NCACHEANY ||
header->type == negtype)
{
/*
* we might need it later.
*/
nsheader = header;
- } else if (header->type == RBTDB_RDATATYPE_SIGNS) {
+ } else if (header->type ==
+ DNS_SIGTYPE(dns_rdatatype_ns))
+ {
/*
* If we need the NS rdataset, we'll also
* need its signature.
nssig = header;
} else if (header->type == dns_rdatatype_nsec) {
nsecheader = header;
- } else if (header->type == RBTDB_RDATATYPE_SIGNSEC) {
+ } else if (header->type ==
+ DNS_SIGTYPE(dns_rdatatype_nsec))
+ {
nsecsig = header;
- } else if (cname_ok &&
- header->type == RBTDB_RDATATYPE_SIGCNAME)
+ } else if (cname_ok && DNS_SIGTYPE(dns_rdatatype_cname))
{
/*
* If we get a CNAME match, we'll also need
* we might need it later.
*/
found = header;
- } else if (header->type == RBTDB_RDATATYPE_SIGNS) {
+ } else if (header->type ==
+ DNS_SIGTYPE(dns_rdatatype_ns))
+ {
/*
* If we need the NS rdataset, we'll also
* need its signature.
matchtype = DNS_TYPEPAIR_VALUE(type, covers);
negtype = DNS_TYPEPAIR_VALUE(0, type);
if (covers == 0) {
- sigmatchtype = DNS_TYPEPAIR_VALUE(dns_rdatatype_rrsig, type);
+ sigmatchtype = DNS_SIGTYPE(type);
} else {
sigmatchtype = 0;
}
*/
dns__rbtdb_mark(header,
DNS_SLABHEADERATTR_ANCIENT);
- HEADER_NODE(header)->dirty = 1;
+ RBTDB_HEADERNODE(header)->dirty = 1;
}
} else if (EXISTS(header) && !ANCIENT(header)) {
if (header->type == matchtype) {
found = header;
- } else if (header->type == RBTDB_RDATATYPE_NCACHEANY ||
+ } else if (header->type == RDATATYPE_NCACHEANY ||
header->type == negtype)
{
found = header;
static size_t
hashsize(dns_db_t *db) {
- dns_rbtdb_t *rbtdb = NULL;
+ dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
size_t size;
isc_rwlocktype_t tlocktype = isc_rwlocktype_none;
- rbtdb = (dns_rbtdb_t *)db;
-
REQUIRE(VALID_RBTDB(rbtdb));
TREE_RDLOCK(&rbtdb->tree_lock, &tlocktype);
isc_rwlocktype_t tlocktype = isc_rwlocktype_none;
NODE_WRLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype);
- dns__cachedb_expireheader(header, &tlocktype,
- dns_expire_flush DNS__DB_FLARG_PASS);
+ dns__cacherbt_expireheader(header, &tlocktype,
+ dns_expire_flush DNS__DB_FLARG_PASS);
NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype);
INSIST(tlocktype == isc_rwlocktype_none);
}
* Caller must hold the node (write) lock.
*/
void
-dns__cachedb_expireheader(dns_slabheader_t *header,
- isc_rwlocktype_t *tlocktypep,
- dns_expire_t reason DNS__DB_FLARG) {
+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);
- HEADER_NODE(header)->dirty = 1;
+ RBTDB_HEADERNODE(header)->dirty = 1;
- if (isc_refcount_current(&HEADER_NODE(header)->references) == 0) {
+ if (isc_refcount_current(&RBTDB_HEADERNODE(header)->references) == 0) {
isc_rwlocktype_t nlocktype = isc_rwlocktype_write;
dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)header->db;
* We first need to gain a new reference to the node to meet a
* requirement of dns__rbtdb_decref().
*/
- dns__rbtdb_newref(rbtdb, HEADER_NODE(header),
+ dns__rbtdb_newref(rbtdb, RBTDB_HEADERNODE(header),
nlocktype DNS__DB_FLARG_PASS);
- dns__rbtdb_decref(rbtdb, HEADER_NODE(header), 0, &nlocktype,
- tlocktypep, true, false DNS__DB_FLARG_PASS);
+ dns__rbtdb_decref(rbtdb, RBTDB_HEADERNODE(header), 0,
+ &nlocktype, tlocktypep, true,
+ false DNS__DB_FLARG_PASS);
if (rbtdb->cachestats == NULL) {
return;
* TTL was reset to 0.
*/
ISC_LIST_UNLINK(rbtdb->lru[locknum], header, link);
- dns__cachedb_expireheader(header, tlocktypep,
- dns_expire_lru DNS__DB_FLARG_PASS);
+ dns__cacherbt_expireheader(header, tlocktypep,
+ dns_expire_lru DNS__DB_FLARG_PASS);
purged += header_size;
}
* A write lock on the tree must be held.
*/
void
-dns__cachedb_overmem(dns_rbtdb_t *rbtdb, dns_slabheader_t *newheader,
- isc_rwlocktype_t *tlocktypep DNS__DB_FLARG) {
+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;
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(HEADER_NODE(newheader));
+ size_t purgesize =
+ rdataset_size(newheader) +
+ 2 * dns__rbtnode_getsize(RBTDB_HEADERNODE(newheader));
size_t purged = 0;
isc_stdtime_t min_last_used = 0;
size_t max_passes = 8;
#include <dns/zone.h>
#include <dns/zonekey.h>
+#include "db_p.h"
#include "rbtdb_p.h"
#define CHECK(op) \
header_next = header->next;
if (header->type == dns_rdatatype_ns ||
header->type == dns_rdatatype_dname ||
- header->type == RBTDB_RDATATYPE_SIGDNAME)
+ header->type == DNS_SIGTYPE(dns_rdatatype_dname))
{
do {
if (header->serial <= search->serial &&
if (header->type == dns_rdatatype_dname) {
dname_header = header;
} else if (header->type ==
- RBTDB_RDATATYPE_SIGDNAME)
+ DNS_SIGTYPE(dns_rdatatype_dname))
{
sigdname_header = header;
} else if (node != onode ||
if (tree == search->rbtdb->nsec3) {
type = dns_rdatatype_nsec3;
- sigtype = RBTDB_RDATATYPE_SIGNSEC3;
+ sigtype = DNS_SIGTYPE(dns_rdatatype_nsec3);
wraps = true;
} else {
type = dns_rdatatype_nsec;
- sigtype = RBTDB_RDATATYPE_SIGNSEC;
+ sigtype = DNS_SIGTYPE(dns_rdatatype_nsec);
wraps = false;
}
found = NULL;
foundsig = NULL;
- sigtype = DNS_TYPEPAIR_VALUE(dns_rdatatype_rrsig, type);
+ sigtype = DNS_SIGTYPE(type);
nsecheader = NULL;
nsecsig = NULL;
cnamesig = NULL;
if (cnamesig != NULL) {
foundsig = cnamesig;
} else {
- sigtype =
- RBTDB_RDATATYPE_SIGCNAME;
+ sigtype = DNS_SIGTYPE(
+ dns_rdatatype_cname);
}
}
/*
* we might need it later.
*/
nsecheader = header;
- } else if (header->type == RBTDB_RDATATYPE_SIGNSEC &&
+ } else if (header->type ==
+ DNS_SIGTYPE(dns_rdatatype_nsec) &&
!search.rbtversion->havensec3)
{
/*
*/
nsecsig = header;
} else if (cname_ok &&
- header->type == RBTDB_RDATATYPE_SIGCNAME)
+ header->type ==
+ DNS_SIGTYPE(dns_rdatatype_cname))
{
/*
* If we get a CNAME match, we'll also need
matchtype = DNS_TYPEPAIR_VALUE(type, covers);
if (covers == 0) {
- sigmatchtype = DNS_TYPEPAIR_VALUE(dns_rdatatype_rrsig, type);
+ sigmatchtype = DNS_SIGTYPE(type);
} else {
sigmatchtype = 0;
}
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 = loadctx->rbtdb;
+ dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)loadctx->db;
dns_rbtnode_t *node = NULL;
isc_result_t result;
isc_region_t region;
if (rdataset->type != dns_rdatatype_nsec3 &&
rdataset->covers != dns_rdatatype_nsec3)
{
- dns__zonedb_addwildcards(rbtdb, name, false);
+ dns__zonerbt_addwildcards(rbtdb, name, false);
}
if (dns_name_iswildcard(name)) {
if (rdataset->type == dns_rdatatype_nsec3) {
return (DNS_R_INVALIDNSEC3);
}
- result = dns__zonedb_wildcardmagic(rbtdb, name, false);
+ result = dns__zonerbt_wildcardmagic(rbtdb, name, false);
if (result != ISC_R_SUCCESS) {
return (result);
}
static isc_result_t
beginload(dns_db_t *db, dns_rdatacallbacks_t *callbacks) {
rbtdb_load_t *loadctx = NULL;
- dns_rbtdb_t *rbtdb = NULL;
- rbtdb = (dns_rbtdb_t *)db;
+ dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
REQUIRE(DNS_CALLBACK_VALID(callbacks));
REQUIRE(VALID_RBTDB(rbtdb));
loadctx = isc_mem_get(rbtdb->common.mctx, sizeof(*loadctx));
- loadctx->rbtdb = rbtdb;
+ loadctx->db = db;
loadctx->now = 0;
- RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_write);
+ RWLOCK(&rbtdb->lock, isc_rwlocktype_write);
REQUIRE((rbtdb->attributes &
(RBTDB_ATTR_LOADED | RBTDB_ATTR_LOADING)) == 0);
rbtdb->attributes |= RBTDB_ATTR_LOADING;
- RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_write);
+ RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write);
callbacks->add = loading_addrdataset;
callbacks->add_private = loadctx;
REQUIRE(DNS_CALLBACK_VALID(callbacks));
loadctx = callbacks->add_private;
REQUIRE(loadctx != NULL);
- REQUIRE(loadctx->rbtdb == rbtdb);
+ REQUIRE(loadctx->db == db);
- RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_write);
+ RWLOCK(&rbtdb->lock, isc_rwlocktype_write);
REQUIRE((rbtdb->attributes & RBTDB_ATTR_LOADING) != 0);
REQUIRE((rbtdb->attributes & RBTDB_ATTR_LOADED) == 0);
*/
if (rbtdb->origin_node != NULL) {
dns_dbversion_t *version = rbtdb->current_version;
- RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_write);
+ RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write);
dns__rbtdb_setsecure(db, version, rbtdb->origin_node);
} else {
- RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_write);
+ RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write);
}
callbacks->add = NULL;
static bool
issecure(dns_db_t *db) {
- dns_rbtdb_t *rbtdb = NULL;
+ dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
bool secure;
- rbtdb = (dns_rbtdb_t *)db;
-
REQUIRE(VALID_RBTDB(rbtdb));
- RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_read);
+ RWLOCK(&rbtdb->lock, isc_rwlocktype_read);
secure = rbtdb->current_version->secure;
- RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_read);
+ RWUNLOCK(&rbtdb->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 = NULL;
+ dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
isc_result_t result = ISC_R_NOTFOUND;
dns_rbtdb_version_t *rbtversion = version;
- rbtdb = (dns_rbtdb_t *)db;
-
REQUIRE(VALID_RBTDB(rbtdb));
INSIST(rbtversion == NULL || rbtversion->rbtdb == rbtdb);
- RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_read);
+ RWLOCK(&rbtdb->lock, isc_rwlocktype_read);
if (rbtversion == NULL) {
rbtversion = rbtdb->current_version;
}
}
result = ISC_R_SUCCESS;
}
- RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_read);
+ RWUNLOCK(&rbtdb->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 = NULL;
+ dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
isc_result_t result = ISC_R_SUCCESS;
dns_rbtdb_version_t *rbtversion = version;
- rbtdb = (dns_rbtdb_t *)db;
-
REQUIRE(VALID_RBTDB(rbtdb));
INSIST(rbtversion == NULL || rbtversion->rbtdb == rbtdb);
- RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_read);
+ RWLOCK(&rbtdb->lock, isc_rwlocktype_read);
if (rbtversion == NULL) {
rbtversion = rbtdb->current_version;
}
SET_IF_NOT_NULL(xfrsize, rbtversion->xfrsize);
RWUNLOCK(&rbtversion->rwlock, isc_rwlocktype_read);
- RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_read);
+ RWUNLOCK(&rbtdb->lock, isc_rwlocktype_read);
return (result);
}
header = dns_slabheader_fromrdataset(rdataset);
- NODE_WRLOCK(&rbtdb->node_locks[HEADER_NODE(header)->locknum].lock,
+ NODE_WRLOCK(&rbtdb->node_locks[RBTDB_HEADERNODE(header)->locknum].lock,
&nlocktype);
oldheader = *header;
INSIST(RESIGN(header));
if (resign == 0) {
isc_heap_delete(
- rbtdb->heaps[HEADER_NODE(header)->locknum],
+ rbtdb->heaps[RBTDB_HEADERNODE(header)->locknum],
header->heap_index);
header->heap_index = 0;
header->heap = NULL;
} else if (rbtdb->sooner(header, &oldheader)) {
isc_heap_increased(
- rbtdb->heaps[HEADER_NODE(header)->locknum],
+ rbtdb->heaps[RBTDB_HEADERNODE(header)->locknum],
header->heap_index);
} else if (rbtdb->sooner(&oldheader, header)) {
isc_heap_decreased(
- rbtdb->heaps[HEADER_NODE(header)->locknum],
+ rbtdb->heaps[RBTDB_HEADERNODE(header)->locknum],
header->heap_index);
}
} else if (resign != 0) {
DNS_SLABHEADER_SETATTR(header, DNS_SLABHEADERATTR_RESIGN);
- dns__zonedb_resigninsert(rbtdb, HEADER_NODE(header)->locknum,
- header);
+ dns__zonerbt_resigninsert(
+ rbtdb, RBTDB_HEADERNODE(header)->locknum, header);
}
- NODE_UNLOCK(&rbtdb->node_locks[HEADER_NODE(header)->locknum].lock,
+ NODE_UNLOCK(&rbtdb->node_locks[RBTDB_HEADERNODE(header)->locknum].lock,
&nlocktype);
return (ISC_R_SUCCESS);
}
* Found something; pass back the answer and unlock
* the bucket.
*/
- dns__rbtdb_bindrdataset(rbtdb, HEADER_NODE(header), header, 0,
- isc_rwlocktype_read,
+ dns__rbtdb_bindrdataset(rbtdb, RBTDB_HEADERNODE(header), header,
+ 0, isc_rwlocktype_read,
rdataset DNS__DB_FLARG_PASS);
if (foundname != NULL) {
- dns_rbt_fullnamefromnode(HEADER_NODE(header),
+ dns_rbt_fullnamefromnode(RBTDB_HEADERNODE(header),
foundname);
}
dns_rdataset_init(&rdataset_aaaa);
dns_rdataset_init(&sigrdataset_aaaa);
- result = zone_find((dns_db_t *)ctx->rbtdb, name, ctx->rbtversion,
- dns_rdatatype_a, DNS_DBFIND_GLUEOK, 0,
- (dns_dbnode_t **)&node_a, name_a, &rdataset_a,
+ result = zone_find(ctx->db, name, ctx->version, dns_rdatatype_a,
+ DNS_DBFIND_GLUEOK, 0, (dns_dbnode_t **)&node_a,
+ name_a, &rdataset_a,
&sigrdataset_a DNS__DB_FLARG_PASS);
if (result == DNS_R_GLUE) {
- glue = new_gluelist(ctx->rbtdb->common.mctx, name_a);
+ glue = new_gluelist(ctx->db->mctx, name_a);
dns_rdataset_init(&glue->rdataset_a);
dns_rdataset_init(&glue->sigrdataset_a);
}
}
- result = zone_find((dns_db_t *)ctx->rbtdb, name, ctx->rbtversion,
- dns_rdatatype_aaaa, DNS_DBFIND_GLUEOK, 0,
- (dns_dbnode_t **)&node_aaaa, name_aaaa,
- &rdataset_aaaa,
+ result = zone_find(ctx->db, name, ctx->version, dns_rdatatype_aaaa,
+ DNS_DBFIND_GLUEOK, 0, (dns_dbnode_t **)&node_aaaa,
+ name_aaaa, &rdataset_aaaa,
&sigrdataset_aaaa DNS__DB_FLARG_PASS);
if (result == DNS_R_GLUE) {
if (glue == NULL) {
- glue = new_gluelist(ctx->rbtdb->common.mctx, name_aaaa);
+ glue = new_gluelist(ctx->db->mctx, name_aaaa);
dns_rdataset_init(&glue->rdataset_a);
dns_rdataset_init(&glue->sigrdataset_a);
}
if (node_a != NULL) {
- dns__db_detachnode((dns_db_t *)ctx->rbtdb,
+ dns__db_detachnode(ctx->db,
(dns_dbnode_t *)&node_a DNS__DB_FLARG_PASS);
}
if (node_aaaa != NULL) {
dns__db_detachnode(
- (dns_db_t *)ctx->rbtdb,
- (dns_dbnode_t *)&node_aaaa DNS__DB_FLARG_PASS);
+ ctx->db, (dns_dbnode_t *)&node_aaaa DNS__DB_FLARG_PASS);
}
return (result);
dns_rbtnode_t *node, dns_rdataset_t *rdataset) {
dns_fixedname_t nodename;
dns_glue_additionaldata_ctx_t ctx = {
- .rbtdb = rbtdb,
- .rbtversion = rbtversion,
+ .db = (dns_db_t *)rbtdb,
+ .version = (dns_dbversion_t *)rbtversion,
.nodename = dns_fixedname_initname(&nodename),
};
dns_message_t *msg) {
dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
dns_rbtdb_version_t *rbtversion = version;
- dns_rbtnode_t *node = RDATASET_DBNODE(rdataset);
+ 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 == RDATASET_RBTDB(rdataset));
+ REQUIRE(rbtdb == (dns_rbtdb_t *)rdataset->slab.db);
REQUIRE(rbtdb == rbtversion->rbtdb);
REQUIRE(!IS_CACHE(rbtdb) && !IS_STUB(rbtdb));
};
void
-dns__zonedb_resigninsert(dns_rbtdb_t *rbtdb, int idx,
- dns_slabheader_t *newheader) {
+dns__zonerbt_resigninsert(dns_rbtdb_t *rbtdb, int idx,
+ dns_slabheader_t *newheader) {
INSIST(!IS_CACHE(rbtdb));
INSIST(newheader->heap_index == 0);
INSIST(!ISC_LINK_LINKED(newheader, link));
}
void
-dns__zonedb_resigndelete(dns_rbtdb_t *rbtdb, dns_rbtdb_version_t *version,
- dns_slabheader_t *header DNS__DB_FLARG) {
+dns__zonerbt_resigndelete(dns_rbtdb_t *rbtdb, dns_rbtdb_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[HEADER_NODE(header)->locknum],
+ isc_heap_delete(rbtdb->heaps[RBTDB_HEADERNODE(header)->locknum],
header->heap_index);
header->heap_index = 0;
if (version != NULL) {
dns__rbtdb_newref(
- rbtdb, HEADER_NODE(header),
+ rbtdb, RBTDB_HEADERNODE(header),
isc_rwlocktype_write DNS__DB_FLARG_PASS);
ISC_LIST_APPEND(version->resigned_list, header, link);
}
}
isc_result_t
-dns__zonedb_wildcardmagic(dns_rbtdb_t *rbtdb, const dns_name_t *name,
- bool lock) {
+dns__zonerbt_wildcardmagic(dns_rbtdb_t *rbtdb, const dns_name_t *name,
+ bool lock) {
isc_result_t result;
dns_name_t foundname;
dns_offsets_t offsets;
}
isc_result_t
-dns__zonedb_addwildcards(dns_rbtdb_t *rbtdb, const dns_name_t *name,
- bool lock) {
+dns__zonerbt_addwildcards(dns_rbtdb_t *rbtdb, const dns_name_t *name,
+ bool lock) {
isc_result_t result;
dns_name_t foundname;
dns_offsets_t offsets;
dns_rbtnode_t *node = NULL;
dns_name_getlabelsequence(name, n - i, i, &foundname);
if (dns_name_iswildcard(&foundname)) {
- result = dns__zonedb_wildcardmagic(rbtdb, &foundname,
- lock);
+ result = dns__zonerbt_wildcardmagic(rbtdb, &foundname,
+ lock);
if (result != ISC_R_SUCCESS) {
return (result);
}
#include <dns/zone.h>
#include <dns/zonekey.h>
+#include "db_p.h"
#include "rbtdb_p.h"
#define CHECK(op) \
* 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__cachedb_overmem().
+ * 1 due to the assumption of dns__cacherbt_overmem().
*/
#ifdef DNS_RBTDB_CACHE_NODE_LOCK_COUNT
#if DNS_RBTDB_CACHE_NODE_LOCK_COUNT <= 1
prio_type(dns_typepair_t type) {
switch (type) {
case dns_rdatatype_soa:
- case DNS_TYPEPAIR_VALUE(dns_rdatatype_rrsig, dns_rdatatype_soa):
+ case DNS_SIGTYPE(dns_rdatatype_soa):
case dns_rdatatype_a:
- case DNS_TYPEPAIR_VALUE(dns_rdatatype_rrsig, dns_rdatatype_a):
+ case DNS_SIGTYPE(dns_rdatatype_a):
case dns_rdatatype_aaaa:
- case DNS_TYPEPAIR_VALUE(dns_rdatatype_rrsig, dns_rdatatype_aaaa):
+ case DNS_SIGTYPE(dns_rdatatype_aaaa):
case dns_rdatatype_nsec:
- case DNS_TYPEPAIR_VALUE(dns_rdatatype_rrsig, dns_rdatatype_nsec):
+ case DNS_SIGTYPE(dns_rdatatype_nsec):
case dns_rdatatype_nsec3:
- case DNS_TYPEPAIR_VALUE(dns_rdatatype_rrsig, dns_rdatatype_nsec3):
+ case DNS_SIGTYPE(dns_rdatatype_nsec3):
case dns_rdatatype_ns:
- case DNS_TYPEPAIR_VALUE(dns_rdatatype_rrsig, dns_rdatatype_ns):
+ case DNS_SIGTYPE(dns_rdatatype_ns):
case dns_rdatatype_ds:
- case DNS_TYPEPAIR_VALUE(dns_rdatatype_rrsig, dns_rdatatype_ds):
+ case DNS_SIGTYPE(dns_rdatatype_ds):
case dns_rdatatype_cname:
- case DNS_TYPEPAIR_VALUE(dns_rdatatype_rrsig, dns_rdatatype_cname):
+ case DNS_SIGTYPE(dns_rdatatype_cname):
return (true);
}
return (false);
return (h1->resign < h2->resign ||
(h1->resign == h2->resign && h1->resign_lsb < h2->resign_lsb) ||
(h1->resign == h2->resign && h1->resign_lsb == h2->resign_lsb &&
- h2->type == RBTDB_RDATATYPE_SIGSOA));
+ h2->type == DNS_SIGTYPE(dns_rdatatype_soa)));
}
/*%
}
isc_mem_cput(rbtdb->common.mctx, rbtdb->node_locks,
- rbtdb->node_lock_count, sizeof(rbtdb_nodelock_t));
+ 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);
}
- RBTDB_DESTROYLOCK(&rbtdb->lock);
+ isc_rwlock_destroy(&rbtdb->lock);
rbtdb->common.magic = 0;
rbtdb->common.impmagic = 0;
isc_mem_detach(&rbtdb->hmctx);
}
if (inactive != 0) {
- RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_write);
+ RWLOCK(&rbtdb->lock, isc_rwlocktype_write);
rbtdb->active -= inactive;
if (rbtdb->active == 0) {
want_free = true;
}
- RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_write);
+ RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write);
if (want_free) {
char buf[DNS_NAME_FORMATSIZE];
if (dns_name_dynamic(&rbtdb->common.origin)) {
REQUIRE(VALID_RBTDB(rbtdb));
- RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_read);
+ RWLOCK(&rbtdb->lock, isc_rwlocktype_read);
version = rbtdb->current_version;
isc_refcount_increment(&version->references);
- RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_read);
+ RWUNLOCK(&rbtdb->lock, isc_rwlocktype_read);
*versionp = (dns_dbversion_t *)version;
}
REQUIRE(versionp != NULL && *versionp == NULL);
REQUIRE(rbtdb->future_version == NULL);
- RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_write);
+ RWLOCK(&rbtdb->lock, isc_rwlocktype_write);
RUNTIME_CHECK(rbtdb->next_serial != 0); /* XXX Error? */
version = allocate_version(rbtdb->common.mctx, rbtdb->next_serial, 1,
true);
RWUNLOCK(&rbtdb->current_version->rwlock, isc_rwlocktype_read);
rbtdb->next_serial++;
rbtdb->future_version = version;
- RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_write);
+ RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write);
*versionp = version;
changed = isc_mem_get(rbtdb->common.mctx, sizeof(*changed));
- RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_write);
+ RWLOCK(&rbtdb->lock, isc_rwlocktype_write);
REQUIRE(version->writer);
version->commit_ok = false;
}
- RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_write);
+ RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write);
return (changed);
}
mark_ancient(dns_slabheader_t *header) {
dns__rbtdb_setttl(header, 0);
dns__rbtdb_mark(header, DNS_SLABHEADERATTR_ANCIENT);
- HEADER_NODE(header)->dirty = 1;
+ RBTDB_HEADERNODE(header)->dirty = 1;
}
static void
static void
send_to_prune_tree(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node,
isc_rwlocktype_t locktype DNS__DB_FLARG) {
- prune_t *prune = isc_mem_get(rbtdb->common.mctx, sizeof(*prune));
- *prune = (prune_t){ .node = node };
+ db_prune_t *prune = isc_mem_get(rbtdb->common.mctx, sizeof(*prune));
+ *prune = (db_prune_t){ .node = node };
dns_db_attach((dns_db_t *)rbtdb, &prune->db);
dns__rbtdb_newref(rbtdb, node, locktype DNS__DB_FLARG_PASS);
isc_result_t result;
bool locked = *tlocktypep != isc_rwlocktype_none;
bool write_locked = false;
- rbtdb_nodelock_t *nodelock = NULL;
+ db_nodelock_t *nodelock = NULL;
int bucket = node->locknum;
bool no_reference = true;
uint_fast32_t refs;
* Caller doesn't know the least serial.
* Get it.
*/
- RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_read);
+ RWLOCK(&rbtdb->lock, isc_rwlocktype_read);
least_serial = rbtdb->least_serial;
- RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_read);
+ RWUNLOCK(&rbtdb->lock, isc_rwlocktype_read);
}
clean_zone_node(node, least_serial);
}
*/
static void
prune_tree(void *arg) {
- prune_t *prune = (prune_t *)arg;
+ db_prune_t *prune = (db_prune_t *)arg;
dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)prune->db;
dns_rbtnode_t *node = prune->node;
dns_rbtnode_t *parent = NULL;
if (isc_refcount_decrement(&version->references) > 1) {
/* typical and easy case first */
if (commit) {
- RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_read);
+ RWLOCK(&rbtdb->lock, isc_rwlocktype_read);
INSIST(!version->writer);
- RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_read);
+ RWUNLOCK(&rbtdb->lock, isc_rwlocktype_read);
}
goto end;
}
dns__rbtdb_setsecure(db, version, rbtdb->origin_node);
}
- RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_write);
+ RWLOCK(&rbtdb->lock, isc_rwlocktype_write);
serial = version->serial;
if (version->writer) {
if (commit) {
UNLINK(rbtdb->open_versions, version, link);
}
least_serial = rbtdb->least_serial;
- RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_write);
+ RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write);
if (cleanup_version != NULL) {
isc_refcount_destroy(&cleanup_version->references);
ISC_LIST_UNLINK(resigned_list, header, link);
- lock = &rbtdb->node_locks[HEADER_NODE(header)->locknum].lock;
+ lock = &rbtdb->node_locks[RBTDB_HEADERNODE(header)->locknum]
+ .lock;
NODE_WRLOCK(lock, &nlocktype);
if (rollback && !IGNORE(header)) {
- dns__zonedb_resigninsert(
- rbtdb, HEADER_NODE(header)->locknum, header);
+ dns__zonerbt_resigninsert(
+ rbtdb, RBTDB_HEADERNODE(header)->locknum,
+ header);
}
- dns__rbtdb_decref(rbtdb, HEADER_NODE(header), least_serial,
+ dns__rbtdb_decref(rbtdb, RBTDB_HEADERNODE(header), least_serial,
&nlocktype, &tlocktype, true,
false DNS__DB_FLARG_PASS);
NODE_UNLOCK(lock, &nlocktype);
dns_rbt_namefromnode(node, &nodename);
node->locknum = node->hashval % rbtdb->node_lock_count;
if (tree == rbtdb->tree) {
- dns__zonedb_addwildcards(rbtdb, name, true);
+ dns__zonerbt_addwildcards(rbtdb, name, true);
if (dns_name_iswildcard(name)) {
- result = dns__zonedb_wildcardmagic(
+ result = dns__zonerbt_wildcardmagic(
rbtdb, name, true);
if (result != ISC_R_SUCCESS) {
goto unlock;
dns_rbtnode_t *node = NULL;
bool want_free = false;
bool inactive = false;
- rbtdb_nodelock_t *nodelock = NULL;
+ db_nodelock_t *nodelock = NULL;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
isc_rwlocktype_t tlocktype = isc_rwlocktype_none;
*targetp = NULL;
if (inactive) {
- RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_write);
+ RWLOCK(&rbtdb->lock, isc_rwlocktype_write);
rbtdb->active--;
if (rbtdb->active == 0) {
want_free = true;
}
- RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_write);
+ RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write);
if (want_free) {
char buf[DNS_NAME_FORMATSIZE];
if (dns_name_dynamic(&rbtdb->common.origin)) {
if (rbtversion == NULL && !newheader_nx) {
rdtype = DNS_TYPEPAIR_TYPE(newheader->type);
covers = DNS_TYPEPAIR_COVERS(newheader->type);
- sigtype = DNS_TYPEPAIR_VALUE(dns_rdatatype_rrsig, covers);
+ sigtype = DNS_SIGTYPE(covers);
if (NEGATIVE(newheader)) {
/*
* We're adding a negative cache entry.
for (topheader = rbtnode->data; topheader != NULL;
topheader = topheader->next)
{
- if ((topheader->type ==
- RBTDB_RDATATYPE_NCACHEANY) ||
+ if ((topheader->type == RDATATYPE_NCACHEANY) ||
(newheader->type == sigtype &&
topheader->type ==
DNS_TYPEPAIR_VALUE(0, covers)))
}
if (header->last_used != now) {
ISC_LIST_UNLINK(
- rbtdb->lru[HEADER_NODE(header)->locknum],
+ rbtdb->lru[RBTDB_HEADERNODE(header)
+ ->locknum],
header, link);
header->last_used = now;
ISC_LIST_PREPEND(
- rbtdb->lru[HEADER_NODE(header)->locknum],
+ rbtdb->lru[RBTDB_HEADERNODE(header)
+ ->locknum],
header, link);
}
if (header->noqname == NULL &&
(header->type == dns_rdatatype_a ||
header->type == dns_rdatatype_aaaa ||
header->type == dns_rdatatype_ds ||
- header->type == RBTDB_RDATATYPE_SIGDS) &&
+ header->type == DNS_SIGTYPE(dns_rdatatype_ds)) &&
!header_nx && !newheader_nx &&
header->trust >= newheader->trust &&
dns_rdataslab_equal((unsigned char *)header,
}
if (header->last_used != now) {
ISC_LIST_UNLINK(
- rbtdb->lru[HEADER_NODE(header)->locknum],
+ rbtdb->lru[RBTDB_HEADERNODE(header)
+ ->locknum],
header, link);
header->last_used = now;
ISC_LIST_PREPEND(
- rbtdb->lru[HEADER_NODE(header)->locknum],
+ rbtdb->lru[RBTDB_HEADERNODE(header)
+ ->locknum],
header, link);
}
if (header->noqname == NULL &&
rbtversion->serial >= topheader->serial);
if (loading) {
newheader->down = NULL;
- idx = HEADER_NODE(newheader)->locknum;
+ idx = RBTDB_HEADERNODE(newheader)->locknum;
if (IS_CACHE(rbtdb)) {
if (ZEROTTL(newheader)) {
newheader->last_used =
isc_heap_insert(rbtdb->heaps[idx], newheader);
newheader->heap = rbtdb->heaps[idx];
} else if (RESIGN(newheader)) {
- dns__zonedb_resigninsert(rbtdb, idx, newheader);
+ dns__zonerbt_resigninsert(rbtdb, idx,
+ newheader);
/*
* Don't call resigndelete, we don't need
* to reverse the delete. The free_slabheader
}
dns_slabheader_destroy(&header);
} else {
- idx = HEADER_NODE(newheader)->locknum;
+ idx = RBTDB_HEADERNODE(newheader)->locknum;
if (IS_CACHE(rbtdb)) {
INSIST(rbtdb->heaps != NULL);
isc_heap_insert(rbtdb->heaps[idx], newheader);
newheader, link);
}
} else if (RESIGN(newheader)) {
- dns__zonedb_resigninsert(rbtdb, idx, newheader);
- dns__zonedb_resigndelete(
+ dns__zonerbt_resigninsert(rbtdb, idx,
+ newheader);
+ dns__zonerbt_resigndelete(
rbtdb, rbtversion,
header DNS__DB_FLARG_PASS);
}
return (DNS_R_UNCHANGED);
}
- idx = HEADER_NODE(newheader)->locknum;
+ idx = RBTDB_HEADERNODE(newheader)->locknum;
if (IS_CACHE(rbtdb)) {
isc_heap_insert(rbtdb->heaps[idx], newheader);
newheader->heap = rbtdb->heaps[idx];
link);
}
} else if (RESIGN(newheader)) {
- dns__zonedb_resigninsert(rbtdb, idx, newheader);
- dns__zonedb_resigndelete(rbtdb, rbtversion,
- header DNS__DB_FLARG_PASS);
+ dns__zonerbt_resigninsert(rbtdb, idx, newheader);
+ dns__zonerbt_resigndelete(rbtdb, rbtversion,
+ header DNS__DB_FLARG_PASS);
}
if (topheader != NULL) {
addnoqname(isc_mem_t *mctx, dns_slabheader_t *newheader,
dns_rdataset_t *rdataset) {
isc_result_t result;
- dns_proof_t *noqname = NULL;
+ dns_slabheader_proof_t *noqname = NULL;
dns_name_t name = DNS_NAME_INITEMPTY;
dns_rdataset_t neg = DNS_RDATASET_INIT, negsig = DNS_RDATASET_INIT;
isc_region_t r1, r2;
}
noqname = isc_mem_get(mctx, sizeof(*noqname));
- *noqname = (dns_proof_t){
+ *noqname = (dns_slabheader_proof_t){
.neg = r1.base,
.negsig = r2.base,
.type = neg.type,
addclosest(isc_mem_t *mctx, dns_slabheader_t *newheader,
dns_rdataset_t *rdataset) {
isc_result_t result;
- dns_proof_t *closest = NULL;
+ dns_slabheader_proof_t *closest = NULL;
dns_name_t name = DNS_NAME_INITEMPTY;
dns_rdataset_t neg = DNS_RDATASET_INIT, negsig = DNS_RDATASET_INIT;
isc_region_t r1, r2;
}
closest = isc_mem_get(mctx, sizeof(*closest));
- *closest = (dns_proof_t){
+ *closest = (dns_slabheader_proof_t){
.neg = r1.base,
.negsig = r2.base,
.name = DNS_NAME_INITEMPTY,
}
if (cache_is_overmem) {
- dns__cachedb_overmem(rbtdb, newheader,
- &tlocktype DNS__DB_FLARG_PASS);
+ dns__cacherbt_overmem(rbtdb, newheader,
+ &tlocktype DNS__DB_FLARG_PASS);
}
NODE_WRLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype);
if (header != NULL && header->ttl + STALE_TTL(header, rbtdb) <
now - RBTDB_VIRTUAL)
{
- dns__cachedb_expireheader(
+ dns__cacherbt_expireheader(
header, &tlocktype,
dns_expire_ttl DNS__DB_FLARG_PASS);
}
newheader, DNS_SLABHEADERATTR_RESIGN);
newheader->resign = header->resign;
newheader->resign_lsb = header->resign_lsb;
- dns__zonedb_resigninsert(
+ dns__zonerbt_resigninsert(
rbtdb, rbtnode->locknum, newheader);
}
/*
topheader->next = newheader;
rbtnode->dirty = 1;
changed->dirty = true;
- dns__zonedb_resigndelete(rbtdb, rbtversion,
- header DNS__DB_FLARG_PASS);
+ dns__zonerbt_resigndelete(rbtdb, rbtversion,
+ header DNS__DB_FLARG_PASS);
} else {
/*
* The rdataset doesn't exist, so we don't need to do anything
* this is deferred until dns__rbtdb_closeversion() is called.
*/
if (result == ISC_R_SUCCESS && version == NULL && !IS_CACHE(rbtdb)) {
- RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_read);
+ RWLOCK(&rbtdb->lock, isc_rwlocktype_read);
version = rbtdb->current_version;
- RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_read);
+ RWUNLOCK(&rbtdb->lock, isc_rwlocktype_read);
dns__rbtdb_setsecure(db, version, rbtdb->origin_node);
}
* this is deferred until dns__rbtdb_closeversion() is called.
*/
if (result == ISC_R_SUCCESS && version == NULL && !IS_CACHE(rbtdb)) {
- RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_read);
+ RWLOCK(&rbtdb->lock, isc_rwlocktype_read);
version = rbtdb->current_version;
- RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_read);
+ RWUNLOCK(&rbtdb->lock, isc_rwlocktype_read);
dns__rbtdb_setsecure(db, version, rbtdb->origin_node);
}
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
current = data;
- locknum = HEADER_NODE(current)->locknum;
+ locknum = RBTDB_HEADERNODE(current)->locknum;
NODE_WRLOCK(&rbtdb->node_locks[locknum].lock, &nlocktype);
while (current != NULL) {
next = current->next;
unsigned int
dns__rbtdb_nodecount(dns_db_t *db, dns_dbtree_t tree) {
- dns_rbtdb_t *rbtdb = NULL;
+ dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
unsigned int count;
isc_rwlocktype_t tlocktype = isc_rwlocktype_none;
- rbtdb = (dns_rbtdb_t *)db;
-
REQUIRE(VALID_RBTDB(rbtdb));
TREE_RDLOCK(&rbtdb->tree_lock, &tlocktype);
void
dns__rbtdb_setloop(dns_db_t *db, isc_loop_t *loop) {
- dns_rbtdb_t *rbtdb = NULL;
-
- rbtdb = (dns_rbtdb_t *)db;
+ dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
REQUIRE(VALID_RBTDB(rbtdb));
- RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_write);
+ RWLOCK(&rbtdb->lock, isc_rwlocktype_write);
if (rbtdb->loop != NULL) {
isc_loop_detach(&rbtdb->loop);
}
if (loop != NULL) {
isc_loop_attach(loop, &rbtdb->loop);
}
- RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_write);
+ RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write);
}
isc_result_t
rbtdb->common.methods = &dns__rbtdb_zonemethods;
}
- RBTDB_INITLOCK(&rbtdb->lock);
+ isc_rwlock_init(&rbtdb->lock);
TREE_INITLOCK(&rbtdb->tree_lock);
/*
}
INSIST(rbtdb->node_lock_count < (1 << DNS_RBT_LOCKLENGTH));
rbtdb->node_locks = isc_mem_get(mctx, rbtdb->node_lock_count *
- sizeof(rbtdb_nodelock_t));
+ sizeof(db_nodelock_t));
rbtdb->common.update_listeners = cds_lfht_new(16, 16, 0, 0, NULL);
cleanup_tree_lock:
TREE_DESTROYLOCK(&rbtdb->tree_lock);
- RBTDB_DESTROYLOCK(&rbtdb->lock);
+ isc_rwlock_destroy(&rbtdb->lock);
isc_mem_put(mctx, rbtdb, sizeof(*rbtdb));
return (result);
}
rcu_read_unlock();
}
-static void
-free_proof(isc_mem_t *mctx, dns_proof_t **noqname) {
- if (dns_name_dynamic(&(*noqname)->name)) {
- dns_name_free(&(*noqname)->name, mctx);
- }
- if ((*noqname)->neg != NULL) {
- isc_mem_put(mctx, (*noqname)->neg,
- dns_rdataslab_size((*noqname)->neg, 0));
- }
- if ((*noqname)->negsig != NULL) {
- isc_mem_put(mctx, (*noqname)->negsig,
- dns_rdataslab_size((*noqname)->negsig, 0));
- }
- isc_mem_put(mctx, *noqname, sizeof(**noqname));
- *noqname = NULL;
-}
-
void
dns__rbtdb_deletedata(dns_db_t *db ISC_ATTR_UNUSED,
dns_dbnode_t *node ISC_ATTR_UNUSED, void *data) {
false);
if (ISC_LINK_LINKED(header, link)) {
- int idx = HEADER_NODE(header)->locknum;
+ int idx = RBTDB_HEADERNODE(header)->locknum;
INSIST(IS_CACHE(rbtdb));
ISC_LIST_UNLINK(rbtdb->lru[idx], header, link);
}
if (header->noqname != NULL) {
- free_proof(db->mctx, &header->noqname);
+ dns_slabheader_freeproof(db->mctx, &header->noqname);
}
if (header->closest != NULL) {
- free_proof(db->mctx, &header->closest);
+ dns_slabheader_freeproof(db->mctx, &header->closest);
}
} else {
if (header->glue_list) {
#define VALID_RBTDB(rbtdb) \
((rbtdb) != NULL && (rbtdb)->common.impmagic == RBTDB_MAGIC)
-#define RBTDB_RDATATYPE_SIGNSEC \
- DNS_TYPEPAIR_VALUE(dns_rdatatype_rrsig, dns_rdatatype_nsec)
-#define RBTDB_RDATATYPE_SIGNSEC3 \
- DNS_TYPEPAIR_VALUE(dns_rdatatype_rrsig, dns_rdatatype_nsec3)
-#define RBTDB_RDATATYPE_SIGNS \
- DNS_TYPEPAIR_VALUE(dns_rdatatype_rrsig, dns_rdatatype_ns)
-#define RBTDB_RDATATYPE_SIGCNAME \
- DNS_TYPEPAIR_VALUE(dns_rdatatype_rrsig, dns_rdatatype_cname)
-#define RBTDB_RDATATYPE_SIGDNAME \
- DNS_TYPEPAIR_VALUE(dns_rdatatype_rrsig, dns_rdatatype_dname)
-#define RBTDB_RDATATYPE_SIGDS \
- DNS_TYPEPAIR_VALUE(dns_rdatatype_rrsig, dns_rdatatype_ds)
-#define RBTDB_RDATATYPE_SIGSOA \
- DNS_TYPEPAIR_VALUE(dns_rdatatype_rrsig, dns_rdatatype_soa)
-#define RBTDB_RDATATYPE_NCACHEANY DNS_TYPEPAIR_VALUE(0, dns_rdatatype_any)
-
-#define RBTDB_INITLOCK(l) isc_rwlock_init((l))
-#define RBTDB_DESTROYLOCK(l) isc_rwlock_destroy(l)
-#define RBTDB_LOCK(l, t) RWLOCK((l), (t))
-#define RBTDB_UNLOCK(l, t) RWUNLOCK((l), (t))
-
-#ifdef DNS_RBTDB_STRONG_RWLOCK_CHECK
-#define STRONG_RWLOCK_CHECK(cond) REQUIRE(cond)
-#else
-#define STRONG_RWLOCK_CHECK(cond)
-#endif
-
-#define NODE_INITLOCK(l) isc_rwlock_init((l))
-#define NODE_DESTROYLOCK(l) isc_rwlock_destroy(l)
-#define NODE_LOCK(l, t, tp) \
- { \
- STRONG_RWLOCK_CHECK(*tp == isc_rwlocktype_none); \
- RWLOCK((l), (t)); \
- *tp = t; \
- }
-#define NODE_UNLOCK(l, tp) \
- { \
- STRONG_RWLOCK_CHECK(*tp != isc_rwlocktype_none); \
- RWUNLOCK(l, *tp); \
- *tp = isc_rwlocktype_none; \
- }
-#define NODE_RDLOCK(l, tp) NODE_LOCK(l, isc_rwlocktype_read, tp);
-#define NODE_WRLOCK(l, tp) NODE_LOCK(l, isc_rwlocktype_write, tp);
-#define NODE_TRYLOCK(l, t, tp) \
- ({ \
- STRONG_RWLOCK_CHECK(*tp == isc_rwlocktype_none); \
- isc_result_t _result = isc_rwlock_trylock(l, t); \
- if (_result == ISC_R_SUCCESS) { \
- *tp = t; \
- }; \
- _result; \
- })
-#define NODE_TRYRDLOCK(l, tp) NODE_TRYLOCK(l, isc_rwlocktype_read, tp)
-#define NODE_TRYWRLOCK(l, tp) NODE_TRYLOCK(l, isc_rwlocktype_write, tp)
-#define NODE_TRYUPGRADE(l, tp) \
- ({ \
- STRONG_RWLOCK_CHECK(*tp == isc_rwlocktype_read); \
- isc_result_t _result = isc_rwlock_tryupgrade(l); \
- if (_result == ISC_R_SUCCESS) { \
- *tp = isc_rwlocktype_write; \
- }; \
- _result; \
- })
-#define NODE_FORCEUPGRADE(l, tp) \
- if (NODE_TRYUPGRADE(l, tp) != ISC_R_SUCCESS) { \
- NODE_UNLOCK(l, tp); \
- NODE_WRLOCK(l, tp); \
- }
-
-#define TREE_INITLOCK(l) isc_rwlock_init(l)
-#define TREE_DESTROYLOCK(l) isc_rwlock_destroy(l)
-#define TREE_LOCK(l, t, tp) \
- { \
- STRONG_RWLOCK_CHECK(*tp == isc_rwlocktype_none); \
- RWLOCK(l, t); \
- *tp = t; \
- }
-#define TREE_UNLOCK(l, tp) \
- { \
- STRONG_RWLOCK_CHECK(*tp != isc_rwlocktype_none); \
- RWUNLOCK(l, *tp); \
- *tp = isc_rwlocktype_none; \
- }
-#define TREE_RDLOCK(l, tp) TREE_LOCK(l, isc_rwlocktype_read, tp);
-#define TREE_WRLOCK(l, tp) TREE_LOCK(l, isc_rwlocktype_write, tp);
-#define TREE_TRYLOCK(l, t, tp) \
- ({ \
- STRONG_RWLOCK_CHECK(*tp == isc_rwlocktype_none); \
- isc_result_t _result = isc_rwlock_trylock(l, t); \
- if (_result == ISC_R_SUCCESS) { \
- *tp = t; \
- }; \
- _result; \
- })
-#define TREE_TRYRDLOCK(l, tp) TREE_TRYLOCK(l, isc_rwlocktype_read, tp)
-#define TREE_TRYWRLOCK(l, tp) TREE_TRYLOCK(l, isc_rwlocktype_write, tp)
-#define TREE_TRYUPGRADE(l, tp) \
- ({ \
- STRONG_RWLOCK_CHECK(*tp == isc_rwlocktype_read); \
- isc_result_t _result = isc_rwlock_tryupgrade(l); \
- if (_result == ISC_R_SUCCESS) { \
- *tp = isc_rwlocktype_write; \
- }; \
- _result; \
- })
-#define TREE_FORCEUPGRADE(l, tp) \
- if (TREE_TRYUPGRADE(l, tp) != ISC_R_SUCCESS) { \
- TREE_UNLOCK(l, tp); \
- TREE_WRLOCK(l, tp); \
- }
-
-#define RDATASET_RBTDB(r) ((dns_rbtdb_t *)(r)->slab.db)
-#define RDATASET_DBNODE(r) ((dns_rbtnode_t *)(r)->slab.node)
-
-#define HEADER_NODE(h) ((dns_rbtnode_t *)((h)->node))
-
-#define IS_STUB(rbtdb) (((rbtdb)->common.attributes & DNS_DBATTR_STUB) != 0)
-#define IS_CACHE(rbtdb) (((rbtdb)->common.attributes & DNS_DBATTR_CACHE) != 0)
+#define RBTDB_HEADERNODE(h) ((dns_rbtnode_t *)((h)->node))
/*
* Allow clients with a virtual time of up to 5 minutes in the past to see
ISC_LANG_BEGINDECLS
-typedef struct {
- isc_rwlock_t lock;
- /* Protected in the refcount routines. */
- isc_refcount_t references;
- /* Locked by lock. */
- bool exiting;
-} rbtdb_nodelock_t;
-
typedef struct rbtdb_changed {
dns_rbtnode_t *node;
bool dirty;
typedef ISC_LIST(rbtdb_changed_t) rbtdb_changedlist_t;
-struct dns_glue {
- struct dns_glue *next;
- dns_fixedname_t fixedname;
- dns_rdataset_t rdataset_a;
- dns_rdataset_t sigrdataset_a;
- dns_rdataset_t rdataset_aaaa;
- dns_rdataset_t sigrdataset_aaaa;
-
- isc_mem_t *mctx;
- struct rcu_head rcu_head;
-};
-
-typedef struct {
- dns_glue_t *glue_list;
- dns_rbtdb_t *rbtdb;
- dns_rbtdb_version_t *rbtversion;
- dns_name_t *nodename;
-} dns_glue_additionaldata_ctx_t;
-
struct dns_rbtdb_version {
/* Not locked */
uint32_t serial;
isc_rwlock_t tree_lock;
/* Locks for individual tree nodes */
unsigned int node_lock_count;
- rbtdb_nodelock_t *node_locks;
+ db_nodelock_t *node_locks;
dns_rbtnode_t *origin_node;
dns_rbtnode_t *nsec3_origin_node;
dns_stats_t *rrsetstats; /* cache DB only */
* Load Context
*/
typedef struct {
- dns_rbtdb_t *rbtdb;
+ dns_db_t *db;
isc_stdtime_t now;
} rbtdb_load_t;
-/*%
- * Prune context
- */
-typedef struct {
- dns_db_t *db;
- dns_rbtnode_t *node;
-} prune_t;
-
extern dns_dbmethods_t dns__rbtdb_zonemethods;
extern dns_dbmethods_t dns__rbtdb_cachemethods;
* Functions specific to zone databases that are also called from rbtdb.c.
*/
void
-dns__zonedb_resigninsert(dns_rbtdb_t *rbtdb, int idx,
- dns_slabheader_t *newheader);
+dns__zonerbt_resigninsert(dns_rbtdb_t *rbtdb, int idx,
+ dns_slabheader_t *newheader);
void
-dns__zonedb_resigndelete(dns_rbtdb_t *rbtdb, dns_rbtdb_version_t *version,
- dns_slabheader_t *header DNS__DB_FLARG);
+dns__zonerbt_resigndelete(dns_rbtdb_t *rbtdb, dns_rbtdb_version_t *version,
+ dns_slabheader_t *header DNS__DB_FLARG);
/*%<
* Insert/delete a node from the zone database's resigning heap.
*/
isc_result_t
-dns__zonedb_wildcardmagic(dns_rbtdb_t *rbtdb, const dns_name_t *name,
- bool lock);
+dns__zonerbt_wildcardmagic(dns_rbtdb_t *rbtdb, const dns_name_t *name,
+ bool lock);
/*%<
* Add the necessary magic for the wildcard name 'name'
* to be found in 'rbtdb'.
* The tree must be write-locked.
*/
isc_result_t
-dns__zonedb_addwildcards(dns_rbtdb_t *rbtdb, const dns_name_t *name, bool lock);
+dns__zonerbt_addwildcards(dns_rbtdb_t *rbtdb, const dns_name_t *name,
+ bool lock);
/*%<
* If 'name' is or contains a wildcard name, create a node for it in the
* database. The tree must be write-locked.
* Cache-specific functions that are called from rbtdb.c
*/
void
-dns__cachedb_expireheader(dns_slabheader_t *header,
- isc_rwlocktype_t *tlocktypep,
- dns_expire_t reason DNS__DB_FLARG);
+dns__cacherbt_expireheader(dns_slabheader_t *header,
+ isc_rwlocktype_t *tlocktypep,
+ dns_expire_t reason DNS__DB_FLARG);
void
-dns__cachedb_overmem(dns_rbtdb_t *rbtdb, dns_slabheader_t *newheader,
- isc_rwlocktype_t *tlocktypep DNS__DB_FLARG);
+dns__cacherbt_overmem(dns_rbtdb_t *rbtdb, dns_slabheader_t *newheader,
+ isc_rwlocktype_t *tlocktypep DNS__DB_FLARG);
ISC_LANG_ENDDECLS
#endif /* if DNS_RDATASET_FIXED */
};
-struct dns_glue {
- struct dns_glue *next;
- dns_fixedname_t fixedname;
- dns_rdataset_t rdataset_a;
- dns_rdataset_t sigrdataset_a;
- dns_rdataset_t rdataset_aaaa;
- dns_rdataset_t sigrdataset_aaaa;
- struct cds_wfs_node wfs_node;
-};
-
-typedef struct {
- dns_glue_t *glue_list;
- dns_rbtdb_t *rbtdb;
- dns_rbtdb_version_t *rbtversion;
- dns_name_t *nodename;
-} dns_glue_additionaldata_ctx_t;
-
static void
rdataset_disassociate(dns_rdataset_t *rdataset DNS__DB_FLARG);
static isc_result_t
isc_mem_put(mctx, header, size);
}
+void
+dns_slabheader_freeproof(isc_mem_t *mctx, dns_slabheader_proof_t **proof) {
+ if (dns_name_dynamic(&(*proof)->name)) {
+ dns_name_free(&(*proof)->name, mctx);
+ }
+ if ((*proof)->neg != NULL) {
+ isc_mem_put(mctx, (*proof)->neg,
+ dns_rdataslab_size((*proof)->neg, 0));
+ }
+ if ((*proof)->negsig != NULL) {
+ isc_mem_put(mctx, (*proof)->negsig,
+ dns_rdataslab_size((*proof)->negsig, 0));
+ }
+ isc_mem_put(mctx, *proof, sizeof(**proof));
+ *proof = NULL;
+}
+
dns_rdatasetmethods_t dns_rdataslab_rdatasetmethods = {
.disassociate = rdataset_disassociate,
.first = rdataset_first,
dns_rdataset_t *nsecsig DNS__DB_FLARG) {
dns_db_t *db = rdataset->slab.db;
dns_dbnode_t *node = rdataset->slab.node;
- const dns_proof_t *noqname = rdataset->slab.noqname;
+ const dns_slabheader_proof_t *noqname = rdataset->slab.noqname;
/*
* Usually, rdataset->slab.raw refers the data following a
dns_rdataset_t *nsecsig DNS__DB_FLARG) {
dns_db_t *db = rdataset->slab.db;
dns_dbnode_t *node = rdataset->slab.node;
- const dns_proof_t *closest = rdataset->slab.closest;
+ const dns_slabheader_proof_t *closest = rdataset->slab.closest;
/*
* As mentioned above, rdataset->slab.raw usually refers the data
static bool
ownercase_test_one(const char *str1, const char *str2) {
isc_result_t result;
- rbtdb_nodelock_t node_locks[1];
+ db_nodelock_t node_locks[1];
dns_rbtdb_t rbtdb = {
.common.methods = &dns__rbtdb_zonemethods,
.common.mctx = mctx,
ISC_RUN_TEST_IMPL(setownercase) {
isc_result_t result;
- rbtdb_nodelock_t node_locks[1];
+ db_nodelock_t node_locks[1];
dns_rbtdb_t rbtdb = {
.common.methods = &dns__rbtdb_zonemethods,
.common.mctx = mctx,
projects / thirdparty / bind9.git / commitdiff
