diff --git a/bin/dnssec/dnssec-ksr.c b/bin/dnssec/dnssec-ksr.c
index e891c0a910..787ffe4ff3 100644
--- a/bin/dnssec/dnssec-ksr.c
+++ b/bin/dnssec/dnssec-ksr.c
@@ -913,23 +913,19 @@ sign_bundle(ksr_ctx_t *ksr, dns_kasp_t *kasp, isc_stdtime_t inception,
 			next_bundle = next_time;
 		}
 
-		for (isc_result_t r = dns_rdatalist_first(&ksk);
-		     r == ISC_R_SUCCESS; r = dns_rdatalist_next(&ksk))
-		{
+		DNS_RDATASET_FOREACH(&ksk) {
 			dns_rdata_t *clone = isc_mem_get(isc_g_mctx,
 							 sizeof(*clone));
 			dns_rdata_init(clone);
-			dns_rdatalist_current(&ksk, clone);
+			dns_rdataset_current(&ksk, clone);
 			ISC_LIST_APPEND(dnskeylist->rdata, clone, link);
 		}
 
-		for (isc_result_t r = dns_rdatalist_first(&zsk);
-		     r == ISC_R_SUCCESS; r = dns_rdatalist_next(&zsk))
-		{
+		DNS_RDATASET_FOREACH(&zsk) {
 			dns_rdata_t *clone = isc_mem_get(isc_g_mctx,
 							 sizeof(*clone));
 			dns_rdata_init(clone);
-			dns_rdatalist_current(&zsk, clone);
+			dns_rdataset_current(&zsk, clone);
 			ISC_LIST_APPEND(dnskeylist->rdata, clone, link);
 		}
 
diff --git a/bin/named/builtin.c b/bin/named/builtin.c
index f03cf3a8d9..c24fbe164e 100644
--- a/bin/named/builtin.c
+++ b/bin/named/builtin.c
@@ -631,19 +631,19 @@ static void
 rdataset_clone(dns_rdataset_t *source, dns_rdataset_t *target DNS__DB_FLARG) {
 	dns_dbnode_t *node = source->rdlist.node;
 
-	dns_rdatalist_clone(source, target DNS__DB_FLARG_PASS);
+	dns__rdatalist_clone(source, target DNS__DB_FLARG_PASS);
 	bdbnode_attachnode(node, &target->rdlist.node DNS__DB_FLARG_PASS);
 }
 
 static dns_rdatasetmethods_t bdb_rdataset_methods = {
 	.disassociate = disassociate,
-	.first = dns_rdatalist_first,
-	.next = dns_rdatalist_next,
-	.current = dns_rdatalist_current,
+	.first = dns__rdatalist_first,
+	.next = dns__rdatalist_next,
+	.current = dns__rdatalist_current,
 	.clone = rdataset_clone,
-	.count = dns_rdatalist_count,
-	.addnoqname = dns_rdatalist_addnoqname,
-	.getnoqname = dns_rdatalist_getnoqname,
+	.count = dns__rdatalist_count,
+	.addnoqname = dns__rdatalist_addnoqname,
+	.getnoqname = dns__rdatalist_getnoqname,
 };
 
 static void
@@ -822,43 +822,10 @@ destroynode(bdbnode_t *node) {
 	dns_db_detach((dns_db_t **)(void *)&bdb);
 }
 
-static isc_result_t
-getoriginnode(dns_db_t *db, dns_dbnode_t **nodep DNS__DB_FLARG) {
-	bdb_t *bdb = (bdb_t *)db;
-	bdbnode_t *node = NULL;
-	isc_result_t result;
-	dns_name_t relname;
-	dns_name_t *name = NULL;
-
-	REQUIRE(VALID_BDB(bdb));
-	REQUIRE(nodep != NULL && *nodep == NULL);
-
-	dns_name_init(&relname);
-	name = &relname;
-
-	result = createnode(bdb, &node);
-	if (result != ISC_R_SUCCESS) {
-		return result;
-	}
-
-	result = builtin_lookup(bdb, name, node);
-	if (result != ISC_R_SUCCESS && result != ISC_R_NOTFOUND) {
-		destroynode(node);
-		return result;
-	}
-
-	result = builtin_authority(bdb, node);
-	if (result != ISC_R_SUCCESS) {
-		destroynode(node);
-		return result;
-	}
-
-	*nodep = (dns_dbnode_t *)node;
-	return ISC_R_SUCCESS;
-}
-
 static isc_result_t
 findnode(dns_db_t *db, const dns_name_t *name, bool create,
+	 dns_clientinfomethods_t *methods ISC_ATTR_UNUSED,
+	 dns_clientinfo_t *clientinfo ISC_ATTR_UNUSED,
 	 dns_dbnode_t **nodep DNS__DB_FLARG) {
 	bdb_t *bdb = (bdb_t *)db;
 	bdbnode_t *node = NULL;
@@ -906,7 +873,9 @@ findnode(dns_db_t *db, const dns_name_t *name, bool create,
 static isc_result_t
 find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
      dns_rdatatype_t type, unsigned int options, isc_stdtime_t now,
-     dns_dbnode_t **nodep, dns_name_t *foundname, dns_rdataset_t *rdataset,
+     dns_dbnode_t **nodep, dns_name_t *foundname,
+     dns_clientinfomethods_t *methods ISC_ATTR_UNUSED,
+     dns_clientinfo_t *clientinfo ISC_ATTR_UNUSED, dns_rdataset_t *rdataset,
      dns_rdataset_t *sigrdataset DNS__DB_FLARG) {
 	bdb_t *bdb = (bdb_t *)db;
 	isc_result_t result;
@@ -942,7 +911,8 @@ find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
 		 * Look up the next label.
 		 */
 		dns_name_getlabelsequence(name, nlabels - i, i, xname);
-		result = findnode(db, xname, false, &node DNS__DB_FLARG_PASS);
+		result = findnode(db, xname, false, NULL, NULL,
+				  &node DNS__DB_FLARG_PASS);
 		if (result == ISC_R_NOTFOUND) {
 			/*
 			 * No data at zone apex?
@@ -1149,7 +1119,6 @@ static dns_dbmethods_t bdb_methods = {
 	.closeversion = closeversion,
 	.findrdataset = findrdataset,
 	.allrdatasets = allrdatasets,
-	.getoriginnode = getoriginnode,
 	.findnode = findnode,
 	.find = find,
 };
diff --git a/bin/tests/system/dyndb/driver/db.c b/bin/tests/system/dyndb/driver/db.c
index 23de0c79ab..f23e0793c8 100644
--- a/bin/tests/system/dyndb/driver/db.c
+++ b/bin/tests/system/dyndb/driver/db.c
@@ -125,31 +125,6 @@ closeversion(dns_db_t *db, dns_dbversion_t **versionp,
 	dns__db_closeversion(sampledb->db, versionp, commit DNS__DB_FLARG_PASS);
 }
 
-static isc_result_t
-findnode(dns_db_t *db, const dns_name_t *name, bool create,
-	 dns_dbnode_t **nodep DNS__DB_FLARG) {
-	sampledb_t *sampledb = (sampledb_t *)db;
-
-	REQUIRE(VALID_SAMPLEDB(sampledb));
-
-	return dns__db_findnode(sampledb->db, name, create,
-				nodep DNS__DB_FLARG_PASS);
-}
-
-static isc_result_t
-find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
-     dns_rdatatype_t type, unsigned int options, isc_stdtime_t now,
-     dns_dbnode_t **nodep, dns_name_t *foundname, dns_rdataset_t *rdataset,
-     dns_rdataset_t *sigrdataset DNS__DB_FLARG) {
-	sampledb_t *sampledb = (sampledb_t *)db;
-
-	REQUIRE(VALID_SAMPLEDB(sampledb));
-
-	return dns__db_find(sampledb->db, name, version, type, options, now,
-			    nodep, foundname, rdataset,
-			    sigrdataset DNS__DB_FLARG_PASS);
-}
-
 static isc_result_t
 findzonecut(dns_db_t *db, const dns_name_t *name, unsigned int options,
 	    isc_stdtime_t now, dns_dbnode_t **nodep, dns_name_t *foundname,
@@ -214,9 +189,8 @@ addrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
 	CHECK(dns__db_addrdataset(sampledb->db, node, version, now, rdataset,
 				  options, addedrdataset DNS__DB_FLARG_PASS));
 	if (dns_rdatatype_isaddr(rdataset->type)) {
-		CHECK(dns_db_nodefullname(node, dns_fixedname_name(&name)));
-		CHECK(syncptrs(sampledb->inst, dns_fixedname_name(&name),
-			       rdataset, DNS_DIFFOP_ADD));
+		CHECK(syncptrs(sampledb->inst, &node->name, rdataset,
+			       DNS_DIFFOP_ADD));
 	}
 
 cleanup:
@@ -242,9 +216,8 @@ subtractrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
 	}
 
 	if (dns_rdatatype_isaddr(rdataset->type)) {
-		CHECK(dns_db_nodefullname(node, dns_fixedname_name(&name)));
-		CHECK(syncptrs(sampledb->inst, dns_fixedname_name(&name),
-			       rdataset, DNS_DIFFOP_DEL));
+		CHECK(syncptrs(sampledb->inst, &node->name, rdataset,
+			       DNS_DIFFOP_DEL));
 	}
 
 cleanup:
@@ -284,15 +257,6 @@ nodecount(dns_db_t *db, dns_dbtree_t tree) {
 	return dns_db_nodecount(sampledb->db, tree);
 }
 
-static void
-setloop(dns_db_t *db, isc_loop_t *loop) {
-	sampledb_t *sampledb = (sampledb_t *)db;
-
-	REQUIRE(VALID_SAMPLEDB(sampledb));
-
-	dns_db_setloop(sampledb->db, loop);
-}
-
 static isc_result_t
 getoriginnode(dns_db_t *db, dns_dbnode_t **nodep DNS__DB_FLARG) {
 	sampledb_t *sampledb = (sampledb_t *)db;
@@ -354,30 +318,30 @@ getrrsetstats(dns_db_t *db) {
 }
 
 static isc_result_t
-findnodeext(dns_db_t *db, const dns_name_t *name, bool create,
-	    dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo,
-	    dns_dbnode_t **nodep DNS__DB_FLARG) {
+findnode(dns_db_t *db, const dns_name_t *name, bool create,
+	 dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo,
+	 dns_dbnode_t **nodep DNS__DB_FLARG) {
 	sampledb_t *sampledb = (sampledb_t *)db;
 
 	REQUIRE(VALID_SAMPLEDB(sampledb));
 
-	return dns__db_findnodeext(sampledb->db, name, create, methods,
-				   clientinfo, nodep DNS__DB_FLARG_PASS);
+	return dns__db_findnode(sampledb->db, name, create, methods, clientinfo,
+				nodep DNS__DB_FLARG_PASS);
 }
 
 static isc_result_t
-findext(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
-	dns_rdatatype_t type, unsigned int options, isc_stdtime_t now,
-	dns_dbnode_t **nodep, dns_name_t *foundname,
-	dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo,
-	dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset DNS__DB_FLARG) {
+find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
+     dns_rdatatype_t type, unsigned int options, isc_stdtime_t now,
+     dns_dbnode_t **nodep, dns_name_t *foundname,
+     dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo,
+     dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset DNS__DB_FLARG) {
 	sampledb_t *sampledb = (sampledb_t *)db;
 
 	REQUIRE(VALID_SAMPLEDB(sampledb));
 
-	return dns__db_findext(sampledb->db, name, version, type, options, now,
-			       nodep, foundname, methods, clientinfo, rdataset,
-			       sigrdataset DNS__DB_FLARG_PASS);
+	return dns__db_find(sampledb->db, name, version, type, options, now,
+			    nodep, foundname, methods, clientinfo, rdataset,
+			    sigrdataset DNS__DB_FLARG_PASS);
 }
 
 static isc_result_t
@@ -399,8 +363,6 @@ static dns_dbmethods_t sampledb_methods = {
 	.newversion = newversion,
 	.attachversion = attachversion,
 	.closeversion = closeversion,
-	.findnode = findnode,
-	.find = find,
 	.findzonecut = findzonecut,
 	.createiterator = createiterator,
 	.findrdataset = findrdataset,
@@ -410,15 +372,14 @@ static dns_dbmethods_t sampledb_methods = {
 	.deleterdataset = deleterdataset,
 	.issecure = issecure,
 	.nodecount = nodecount,
-	.setloop = setloop,
 	.getoriginnode = getoriginnode,
 	.getnsec3parameters = getnsec3parameters,
 	.findnsec3node = findnsec3node,
 	.setsigningtime = setsigningtime,
 	.getsigningtime = getsigningtime,
 	.getrrsetstats = getrrsetstats,
-	.findnodeext = findnodeext,
-	.findext = findext,
+	.findnode = findnode,
+	.find = find,
 	.setcachestats = setcachestats,
 };
 
diff --git a/lib/dns/cache.c b/lib/dns/cache.c
index faf414b379..69267ea4d4 100644
--- a/lib/dns/cache.c
+++ b/lib/dns/cache.c
@@ -130,12 +130,6 @@ cache_create_db(dns_cache_t *cache, dns_db_t **dbp, isc_mem_t **tmctxp,
 	dns_db_setmaxrrperset(db, cache->maxrrperset);
 	dns_db_setmaxtypepername(db, cache->maxtypepername);
 
-	/*
-	 * XXX this is only used by the RBT cache, and can
-	 * be removed when it is.
-	 */
-	dns_db_setloop(db, isc_loop_main());
-
 	*dbp = db;
 	*hmctxp = hmctx;
 	*tmctxp = tmctx;
@@ -628,8 +622,6 @@ dns_cache_dumpstats(dns_cache_t *cache, FILE *fp) {
 		"cache database nodes");
 	fprintf(fp, "%20u %s\n", dns_db_nodecount(cache->db, dns_dbtree_nsec),
 		"cache NSEC auxiliary database nodes");
-	fprintf(fp, "%20" PRIu64 " %s\n", (uint64_t)dns_db_hashsize(cache->db),
-		"cache database hash buckets");
 
 	fprintf(fp, "%20" PRIu64 " %s\n", (uint64_t)isc_mem_inuse(cache->tmctx),
 		"cache tree memory in use");
@@ -689,7 +681,6 @@ dns_cache_renderxml(dns_cache_t *cache, void *writer0) {
 			dns_db_nodecount(cache->db, dns_dbtree_main), writer));
 	TRY0(renderstat("CacheNSECNodes",
 			dns_db_nodecount(cache->db, dns_dbtree_nsec), writer));
-	TRY0(renderstat("CacheBuckets", dns_db_hashsize(cache->db), writer));
 
 	TRY0(renderstat("TreeMemInUse", isc_mem_inuse(cache->tmctx), writer));
 
@@ -759,10 +750,6 @@ dns_cache_renderjson(dns_cache_t *cache, void *cstats0) {
 	CHECKMEM(obj);
 	json_object_object_add(cstats, "CacheNSECNodes", obj);
 
-	obj = json_object_new_int64(dns_db_hashsize(cache->db));
-	CHECKMEM(obj);
-	json_object_object_add(cstats, "CacheBuckets", obj);
-
 	obj = json_object_new_int64(isc_mem_inuse(cache->tmctx));
 	CHECKMEM(obj);
 	json_object_object_add(cstats, "TreeMemInUse", obj);
diff --git a/lib/dns/db.c b/lib/dns/db.c
index acb8051e39..9200352024 100644
--- a/lib/dns/db.c
+++ b/lib/dns/db.c
@@ -415,28 +415,8 @@ dns__db_closeversion(dns_db_t *db, dns_dbversion_t **versionp,
 
 isc_result_t
 dns__db_findnode(dns_db_t *db, const dns_name_t *name, bool create,
+		 dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo,
 		 dns_dbnode_t **nodep DNS__DB_FLARG) {
-	/*
-	 * Find the node with name 'name'.
-	 */
-
-	REQUIRE(DNS_DB_VALID(db));
-	REQUIRE(nodep != NULL && *nodep == NULL);
-
-	if (db->methods->findnode != NULL) {
-		return (db->methods->findnode)(db, name, create,
-					       nodep DNS__DB_FLARG_PASS);
-	} else {
-		return (db->methods->findnodeext)(db, name, create, NULL, NULL,
-						  nodep DNS__DB_FLARG_PASS);
-	}
-}
-
-isc_result_t
-dns__db_findnodeext(dns_db_t *db, const dns_name_t *name, bool create,
-		    dns_clientinfomethods_t *methods,
-		    dns_clientinfo_t *clientinfo,
-		    dns_dbnode_t **nodep DNS__DB_FLARG) {
 	/*
 	 * Find the node with name 'name', passing 'arg' to the database
 	 * implementation.
@@ -445,14 +425,12 @@ dns__db_findnodeext(dns_db_t *db, const dns_name_t *name, bool create,
 	REQUIRE(DNS_DB_VALID(db));
 	REQUIRE(nodep != NULL && *nodep == NULL);
 
-	if (db->methods->findnodeext != NULL) {
-		return (db->methods->findnodeext)(db, name, create, methods,
-						  clientinfo,
-						  nodep DNS__DB_FLARG_PASS);
-	} else {
-		return (db->methods->findnode)(db, name, create,
+	if (db->methods->findnode != NULL) {
+		return (db->methods->findnode)(db, name, create, methods,
+					       clientinfo,
 					       nodep DNS__DB_FLARG_PASS);
 	}
+	return ISC_R_NOTIMPLEMENTED;
 }
 
 isc_result_t
@@ -473,41 +451,9 @@ isc_result_t
 dns__db_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
 	     dns_rdatatype_t type, unsigned int options, isc_stdtime_t now,
 	     dns_dbnode_t **nodep, dns_name_t *foundname,
+	     dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo,
 	     dns_rdataset_t *rdataset,
 	     dns_rdataset_t *sigrdataset DNS__DB_FLARG) {
-	/*
-	 * Find the best match for 'name' and 'type' in version 'version'
-	 * of 'db'.
-	 */
-
-	REQUIRE(DNS_DB_VALID(db));
-	REQUIRE(type != dns_rdatatype_rrsig);
-	REQUIRE(nodep == NULL || *nodep == NULL);
-	REQUIRE(dns_name_hasbuffer(foundname));
-	REQUIRE(rdataset == NULL || (DNS_RDATASET_VALID(rdataset) &&
-				     !dns_rdataset_isassociated(rdataset)));
-	REQUIRE(sigrdataset == NULL ||
-		(DNS_RDATASET_VALID(sigrdataset) &&
-		 !dns_rdataset_isassociated(sigrdataset)));
-
-	if (db->methods->find != NULL) {
-		return (db->methods->find)(db, name, version, type, options,
-					   now, nodep, foundname, rdataset,
-					   sigrdataset DNS__DB_FLARG_PASS);
-	} else {
-		return (db->methods->findext)(
-			db, name, version, type, options, now, nodep, foundname,
-			NULL, NULL, rdataset, sigrdataset DNS__DB_FLARG_PASS);
-	}
-}
-
-isc_result_t
-dns__db_findext(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
-		dns_rdatatype_t type, unsigned int options, isc_stdtime_t now,
-		dns_dbnode_t **nodep, dns_name_t *foundname,
-		dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo,
-		dns_rdataset_t *rdataset,
-		dns_rdataset_t *sigrdataset DNS__DB_FLARG) {
 	/*
 	 * Find the best match for 'name' and 'type' in version 'version'
 	 * of 'db', passing in 'arg'.
@@ -523,16 +469,13 @@ dns__db_findext(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
 		(DNS_RDATASET_VALID(sigrdataset) &&
 		 !dns_rdataset_isassociated(sigrdataset)));
 
-	if (db->methods->findext != NULL) {
-		return (db->methods->findext)(db, name, version, type, options,
-					      now, nodep, foundname, methods,
-					      clientinfo, rdataset,
-					      sigrdataset DNS__DB_FLARG_PASS);
-	} else {
+	if (db->methods->find != NULL) {
 		return (db->methods->find)(db, name, version, type, options,
-					   now, nodep, foundname, rdataset,
+					   now, nodep, foundname, methods,
+					   clientinfo, rdataset,
 					   sigrdataset DNS__DB_FLARG_PASS);
 	}
+	return ISC_R_NOTIMPLEMENTED;
 }
 
 isc_result_t
@@ -800,26 +743,6 @@ dns_db_nodecount(dns_db_t *db, dns_dbtree_t tree) {
 	return 0;
 }
 
-size_t
-dns_db_hashsize(dns_db_t *db) {
-	REQUIRE(DNS_DB_VALID(db));
-
-	if (db->methods->hashsize == NULL) {
-		return 0;
-	}
-
-	return (db->methods->hashsize)(db);
-}
-
-void
-dns_db_setloop(dns_db_t *db, isc_loop_t *loop) {
-	REQUIRE(DNS_DB_VALID(db));
-
-	if (db->methods->setloop != NULL) {
-		(db->methods->setloop)(db, loop);
-	}
-}
-
 isc_result_t
 dns_db_register(const char *name, dns_dbcreatefunc_t create, void *driverarg,
 		isc_mem_t *mctx, dns_dbimplementation_t **dbimp) {
@@ -874,6 +797,9 @@ dns__db_getoriginnode(dns_db_t *db, dns_dbnode_t **nodep DNS__DB_FLARG) {
 	if (db->methods->getoriginnode != NULL) {
 		return (db->methods->getoriginnode)(db,
 						    nodep DNS__DB_FLARG_PASS);
+	} else if (db->methods->findnode != NULL) {
+		return (db->methods->findnode)(db, &db->origin, false, NULL,
+					       NULL, nodep DNS__DB_FLARG_PASS);
 	}
 
 	return ISC_R_NOTFOUND;
@@ -1117,22 +1043,6 @@ dns_db_addglue(dns_db_t *db, dns_dbversion_t *version, dns_rdataset_t *rdataset,
 	return ISC_R_NOTIMPLEMENTED;
 }
 
-void
-dns_db_locknode(dns_dbnode_t *node, isc_rwlocktype_t type) {
-	REQUIRE(node != NULL && node->methods != NULL);
-	if (node->methods->locknode != NULL) {
-		(node->methods->locknode)(node, type);
-	}
-}
-
-void
-dns_db_unlocknode(dns_dbnode_t *node, isc_rwlocktype_t type) {
-	REQUIRE(node != NULL && node->methods != NULL);
-	if (node->methods->unlocknode != NULL) {
-		(node->methods->unlocknode)(node, type);
-	}
-}
-
 void
 dns_db_expiredata(dns_dbnode_t *node, void *data) {
 	REQUIRE(node != NULL && node->methods != NULL);
@@ -1149,17 +1059,6 @@ dns_db_deletedata(dns_dbnode_t *node, void *data) {
 	}
 }
 
-isc_result_t
-dns_db_nodefullname(dns_dbnode_t *node, dns_name_t *name) {
-	REQUIRE(node != NULL && node->methods != NULL);
-	REQUIRE(name != NULL);
-
-	if (node->methods != NULL && node->methods->nodefullname != NULL) {
-		return node->methods->nodefullname(node, name);
-	}
-	return ISC_R_NOTIMPLEMENTED;
-}
-
 void
 dns_db_setmaxrrperset(dns_db_t *db, uint32_t value) {
 	REQUIRE(DNS_DB_VALID(db));
diff --git a/lib/dns/include/dns/db.h b/lib/dns/include/dns/db.h
index cc80d5fa7b..7ebeeb2253 100644
--- a/lib/dns/include/dns/db.h
+++ b/lib/dns/include/dns/db.h
@@ -76,15 +76,10 @@ extern unsigned int dns_pps;
 *****/
 
 typedef struct dns_dbnode_methods {
-	isc_result_t (*nodefullname)(dns_dbnode_t *node, dns_name_t *name);
-
 	void (*attachnode)(dns_dbnode_t		 *source,
 			   dns_dbnode_t **targetp DNS__DB_FLARG);
 	void (*detachnode)(dns_dbnode_t **targetp DNS__DB_FLARG);
 
-	void (*locknode)(dns_dbnode_t *node, isc_rwlocktype_t t);
-	void (*unlocknode)(dns_dbnode_t *node, isc_rwlocktype_t t);
-
 	void (*deletedata)(dns_dbnode_t *node, void *data);
 	void (*expiredata)(dns_dbnode_t *node, void *data);
 } dns_dbnode_methods_t;
@@ -100,15 +95,6 @@ typedef struct dns_db_methods {
 			      dns_dbversion_t **targetp);
 	void (*closeversion)(dns_db_t *db, dns_dbversion_t **versionp,
 			     bool commit DNS__DB_FLARG);
-	isc_result_t (*findnode)(dns_db_t *db, const dns_name_t *name,
-				 bool		      create,
-				 dns_dbnode_t **nodep DNS__DB_FLARG);
-	isc_result_t (*find)(dns_db_t *db, const dns_name_t *name,
-			     dns_dbversion_t *version, dns_rdatatype_t type,
-			     unsigned int options, isc_stdtime_t now,
-			     dns_dbnode_t **nodep, dns_name_t *foundname,
-			     dns_rdataset_t		*rdataset,
-			     dns_rdataset_t *sigrdataset DNS__DB_FLARG);
 	isc_result_t (*findzonecut)(dns_db_t *db, const dns_name_t *name,
 				    unsigned int options, isc_stdtime_t now,
 				    dns_dbnode_t **nodep, dns_name_t *foundname,
@@ -142,7 +128,6 @@ typedef struct dns_db_methods {
 				       dns_rdatatype_t covers DNS__DB_FLARG);
 	bool (*issecure)(dns_db_t *db);
 	unsigned int (*nodecount)(dns_db_t *db, dns_dbtree_t);
-	void (*setloop)(dns_db_t *db, isc_loop_t *);
 	isc_result_t (*getoriginnode)(dns_db_t		  *db,
 				      dns_dbnode_t **nodep DNS__DB_FLARG);
 	isc_result_t (*getnsec3parameters)(dns_db_t	   *db,
@@ -160,21 +145,19 @@ typedef struct dns_db_methods {
 				       dns_name_t     *name,
 				       dns_typepair_t *typepair);
 	dns_stats_t *(*getrrsetstats)(dns_db_t *db);
-	isc_result_t (*findnodeext)(dns_db_t *db, const dns_name_t *name,
-				    bool		     create,
-				    dns_clientinfomethods_t *methods,
-				    dns_clientinfo_t	    *clientinfo,
-				    dns_dbnode_t **nodep     DNS__DB_FLARG);
-	isc_result_t (*findext)(dns_db_t *db, const dns_name_t *name,
-				dns_dbversion_t *version, dns_rdatatype_t type,
-				unsigned int options, isc_stdtime_t now,
-				dns_dbnode_t **nodep, dns_name_t *foundname,
-				dns_clientinfomethods_t	   *methods,
-				dns_clientinfo_t	   *clientinfo,
-				dns_rdataset_t		   *rdataset,
-				dns_rdataset_t *sigrdataset DNS__DB_FLARG);
+	isc_result_t (*findnode)(dns_db_t *db, const dns_name_t *name,
+				 bool create, dns_clientinfomethods_t *methods,
+				 dns_clientinfo_t    *clientinfo,
+				 dns_dbnode_t **nodep DNS__DB_FLARG);
+	isc_result_t (*find)(dns_db_t *db, const dns_name_t *name,
+			     dns_dbversion_t *version, dns_rdatatype_t type,
+			     unsigned int options, isc_stdtime_t now,
+			     dns_dbnode_t **nodep, dns_name_t *foundname,
+			     dns_clientinfomethods_t	*methods,
+			     dns_clientinfo_t		*clientinfo,
+			     dns_rdataset_t		*rdataset,
+			     dns_rdataset_t *sigrdataset DNS__DB_FLARG);
 	isc_result_t (*setcachestats)(dns_db_t *db, isc_stats_t *stats);
-	size_t (*hashsize)(dns_db_t *db);
 	isc_result_t (*getsize)(dns_db_t *db, dns_dbversion_t *version,
 				uint64_t *records, uint64_t *bytes);
 	isc_result_t (*setservestalettl)(dns_db_t *db, dns_ttl_t ttl);
@@ -696,19 +679,14 @@ dns__db_closeversion(dns_db_t *db, dns_dbversion_t **versionp,
  ***/
 
 #define dns_db_findnode(db, name, create, nodep) \
-	dns__db_findnode(db, name, create, nodep DNS__DB_FILELINE)
+	dns__db_findnode(db, name, create, NULL, NULL, nodep DNS__DB_FILELINE)
+#define dns_db_findnodeext(db, name, create, methods, clientinfo, nodep) \
+	dns__db_findnode(db, name, create, methods, clientinfo,          \
+			 nodep DNS__DB_FILELINE)
 isc_result_t
 dns__db_findnode(dns_db_t *db, const dns_name_t *name, bool create,
+		 dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo,
 		 dns_dbnode_t **nodep DNS__DB_FLARG);
-
-#define dns_db_findnodeext(db, name, create, methods, clientinfo, nodep) \
-	dns__db_findnodeext(db, name, create, methods, clientinfo,       \
-			    nodep DNS__DB_FILELINE)
-isc_result_t
-dns__db_findnodeext(dns_db_t *db, const dns_name_t *name, bool create,
-		    dns_clientinfomethods_t *methods,
-		    dns_clientinfo_t	    *clientinfo,
-		    dns_dbnode_t **nodep     DNS__DB_FLARG);
 /*%<
  * Find the node with name 'name'.
  *
@@ -750,26 +728,19 @@ dns__db_findnodeext(dns_db_t *db, const dns_name_t *name, bool create,
 #define dns_db_find(db, name, version, type, options, now, nodep, foundname,  \
 		    rdataset, sigrdataset)                                    \
 	dns__db_find(db, name, version, type, options, now, nodep, foundname, \
-		     rdataset, sigrdataset DNS__DB_FILELINE)
+		     NULL, NULL, rdataset, sigrdataset DNS__DB_FILELINE)
+#define dns_db_findext(db, name, version, type, options, now, nodep,          \
+		       foundname, methods, clientinfo, rdataset, sigrdataset) \
+	dns__db_find(db, name, version, type, options, now, nodep, foundname, \
+		     methods, clientinfo, rdataset,                           \
+		     sigrdataset DNS__DB_FILELINE)
 isc_result_t
 dns__db_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
 	     dns_rdatatype_t type, unsigned int options, isc_stdtime_t now,
 	     dns_dbnode_t **nodep, dns_name_t *foundname,
+	     dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo,
 	     dns_rdataset_t		*rdataset,
 	     dns_rdataset_t *sigrdataset DNS__DB_FLARG);
-
-#define dns_db_findext(db, name, version, type, options, now, nodep,          \
-		       foundname, methods, clientinfo, rdataset, sigrdataset) \
-	dns__db_findext(db, name, version, type, options, now, nodep,         \
-			foundname, methods, clientinfo, rdataset,             \
-			sigrdataset DNS__DB_FILELINE)
-isc_result_t
-dns__db_findext(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
-		dns_rdatatype_t type, unsigned int options, isc_stdtime_t now,
-		dns_dbnode_t **nodep, dns_name_t *foundname,
-		dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo,
-		dns_rdataset_t		   *rdataset,
-		dns_rdataset_t *sigrdataset DNS__DB_FLARG);
 /*%<
  * Find the best match for 'name' and 'type' in version 'version' of 'db'.
  *
@@ -1422,16 +1393,6 @@ dns_db_hashsize(dns_db_t *db);
  *      0 if not implemented.
  */
 
-void
-dns_db_setloop(dns_db_t *db, isc_loop_t *loop);
-/*%<
- * If loop is set then the final detach may be performed asynchronously.
- *
- * Requires:
- * \li	'db' is a valid database.
- * \li	'loop' to be valid or NULL.
- */
-
 bool
 dns_db_ispersistent(dns_db_t *db);
 /*%<
@@ -1754,15 +1715,6 @@ dns_db_setgluecachestats(dns_db_t *db, isc_stats_t *stats);
  *	dns_rdatasetstats_create(); otherwise NULL.
  */
 
-void
-dns_db_locknode(dns_dbnode_t *node, isc_rwlocktype_t type);
-void
-dns_db_unlocknode(dns_dbnode_t *node, isc_rwlocktype_t type);
-/*%<
- * Lock/unlock a single node within a database so that data stored
- * there can be manipulated directly.
- */
-
 isc_result_t
 dns_db_addglue(dns_db_t *db, dns_dbversion_t *version, dns_rdataset_t *rdataset,
 	       dns_message_t *msg);
@@ -1798,17 +1750,6 @@ dns_db_deletedata(dns_dbnode_t *node, void *data);
  * data from an LRU list or a heap.
  */
 
-isc_result_t
-dns_db_nodefullname(dns_dbnode_t *node, dns_name_t *name);
-/*%<
- * Get the name associated with a database node.
- *
- * Requires:
- *
- * \li 'db' is a valid database
- * \li 'node' and 'name' are not NULL
- */
-
 void
 dns_db_setmaxrrperset(dns_db_t *db, uint32_t value);
 /*%<
diff --git a/lib/dns/include/dns/rdatalist.h b/lib/dns/include/dns/rdatalist.h
index e71a089fd1..35e490de38 100644
--- a/lib/dns/include/dns/rdatalist.h
+++ b/lib/dns/include/dns/rdatalist.h
@@ -107,43 +107,38 @@ dns_rdatalist_fromrdataset(dns_rdataset_t   *rdataset,
  *\li		'rdatalist' is pointed to the rdatalist in rdataset.
  */
 
+/*%
+ * The following are implementation functions for list-based rdatasets.
+ * They are called by rdataset implementations in rdatalist.c, sdlz.c,
+ * and builtin.c. They are not meant to be used directly by callers of
+ * those implmentations.
+ */
 void
 dns_rdatalist_disassociate(dns_rdataset_t *rdatasetp DNS__DB_FLARG);
-
 isc_result_t
-dns_rdatalist_first(dns_rdataset_t *rdataset);
-
+dns__rdatalist_first(dns_rdataset_t *rdataset);
 isc_result_t
-dns_rdatalist_next(dns_rdataset_t *rdataset);
-
+dns__rdatalist_next(dns_rdataset_t *rdataset);
 void
-dns_rdatalist_current(dns_rdataset_t *rdataset, dns_rdata_t *rdata);
-
+dns__rdatalist_current(dns_rdataset_t *rdataset, dns_rdata_t *rdata);
 void
-dns_rdatalist_clone(dns_rdataset_t	  *source,
-		    dns_rdataset_t *target DNS__DB_FLARG);
-
+dns__rdatalist_clone(dns_rdataset_t	   *source,
+		     dns_rdataset_t *target DNS__DB_FLARG);
 unsigned int
-dns_rdatalist_count(dns_rdataset_t *rdataset);
-
+dns__rdatalist_count(dns_rdataset_t *rdataset);
 isc_result_t
-dns_rdatalist_addnoqname(dns_rdataset_t *rdataset, dns_name_t *name);
-
+dns__rdatalist_addnoqname(dns_rdataset_t *rdataset, dns_name_t *name);
 isc_result_t
-dns_rdatalist_getnoqname(dns_rdataset_t *rdataset, dns_name_t *name,
-			 dns_rdataset_t	       *neg,
-			 dns_rdataset_t *negsig DNS__DB_FLARG);
-
+dns__rdatalist_getnoqname(dns_rdataset_t *rdataset, dns_name_t *name,
+			  dns_rdataset_t	*neg,
+			  dns_rdataset_t *negsig DNS__DB_FLARG);
 isc_result_t
-dns_rdatalist_addclosest(dns_rdataset_t *rdataset, dns_name_t *name);
-
+dns__rdatalist_addclosest(dns_rdataset_t *rdataset, dns_name_t *name);
 isc_result_t
-dns_rdatalist_getclosest(dns_rdataset_t *rdataset, dns_name_t *name,
-			 dns_rdataset_t	       *neg,
-			 dns_rdataset_t *negsig DNS__DB_FLARG);
-
+dns__rdatalist_getclosest(dns_rdataset_t *rdataset, dns_name_t *name,
+			  dns_rdataset_t	*neg,
+			  dns_rdataset_t *negsig DNS__DB_FLARG);
 void
-dns_rdatalist_setownercase(dns_rdataset_t *rdataset, const dns_name_t *name);
-
+dns__rdatalist_setownercase(dns_rdataset_t *rdataset, const dns_name_t *name);
 void
-dns_rdatalist_getownercase(const dns_rdataset_t *rdataset, dns_name_t *name);
+dns__rdatalist_getownercase(const dns_rdataset_t *rdataset, dns_name_t *name);
diff --git a/lib/dns/include/dns/rdataslab.h b/lib/dns/include/dns/rdataslab.h
index da60c8d469..76df3b78fe 100644
--- a/lib/dns/include/dns/rdataslab.h
+++ b/lib/dns/include/dns/rdataslab.h
@@ -83,13 +83,13 @@ struct dns_slabtop {
 };
 
 struct dns_slabheader {
-	_Atomic(uint16_t) attributes;
+	_Atomic(uint16_t)    attributes;
+	_Atomic(dns_trust_t) trust;
 
 	/*%
 	 * Locked by the owning node's lock.
 	 */
-	dns_trust_t trust;
-	uint32_t    serial;
+	uint32_t serial;
 	union {
 		isc_stdtime_t expire;
 		dns_ttl_t     ttl;
diff --git a/lib/dns/qpcache.c b/lib/dns/qpcache.c
index 13bc5ecb27..0d0e9b1bd2 100644
--- a/lib/dns/qpcache.c
+++ b/lib/dns/qpcache.c
@@ -305,10 +305,6 @@ qpcnode_attachnode(dns_dbnode_t *source, dns_dbnode_t **targetp DNS__DB_FLARG);
 static void
 qpcnode_detachnode(dns_dbnode_t **nodep DNS__DB_FLARG);
 static void
-qpcnode_locknode(dns_dbnode_t *node, isc_rwlocktype_t type);
-static void
-qpcnode_unlocknode(dns_dbnode_t *node, isc_rwlocktype_t type);
-static void
 qpcnode_deletedata(dns_dbnode_t *node, void *data);
 static void
 qpcnode_expiredata(dns_dbnode_t *node, void *data);
@@ -316,8 +312,6 @@ qpcnode_expiredata(dns_dbnode_t *node, void *data);
 static dns_dbnode_methods_t qpcnode_methods = (dns_dbnode_methods_t){
 	.attachnode = qpcnode_attachnode,
 	.detachnode = qpcnode_detachnode,
-	.locknode = qpcnode_locknode,
-	.unlocknode = qpcnode_unlocknode,
 	.deletedata = qpcnode_deletedata,
 	.expiredata = qpcnode_expiredata,
 };
@@ -1045,7 +1039,7 @@ bindrdataset(qpcache_t *qpdb, qpcnode_t *node, dns_slabheader_t *header,
 		rdataset->covers = DNS_TYPEPAIR_COVERS(header->typepair);
 	}
 	rdataset->ttl = !ZEROTTL(header) ? header->expire - now : 0;
-	rdataset->trust = header->trust;
+	rdataset->trust = atomic_load(&header->trust);
 	rdataset->resign = 0;
 
 	if (NEGATIVE(header)) {
@@ -1313,7 +1307,7 @@ check_zonecut(qpcnode_t *node, void *arg DNS__DB_FLARG) {
 		}
 	}
 
-	if (found != NULL && (!DNS_TRUST_PENDING(found->trust) ||
+	if (found != NULL && (!DNS_TRUST_PENDING(atomic_load(&found->trust)) ||
 			      (search->options & DNS_DBFIND_PENDINGOK) != 0))
 	{
 		/*
@@ -1506,14 +1500,19 @@ find_coveringnsec(qpc_search_t *search, const dns_name_t *name,
 	return result;
 }
 
-#define MISSING_ANSWER(found, options)                     \
-	((found) == NULL ||                                \
-	 (DNS_TRUST_ADDITIONAL((found)->trust) &&          \
-	  (((options) & DNS_DBFIND_ADDITIONALOK) == 0)) || \
-	 ((found)->trust == dns_trust_glue &&              \
-	  (((options) & DNS_DBFIND_GLUEOK) == 0)) ||       \
-	 (DNS_TRUST_PENDING((found)->trust) &&             \
-	  (((options) & DNS_DBFIND_PENDINGOK) == 0)))
+static inline bool
+missing_answer(dns_slabheader_t *found, unsigned int options) {
+	if (found == NULL) {
+		return true;
+	}
+
+	dns_trust_t trust = atomic_load(&found->trust);
+	return (DNS_TRUST_ADDITIONAL(trust) &&
+		(options & DNS_DBFIND_ADDITIONALOK) == 0) ||
+	       (DNS_TRUST_GLUE(trust) && (options & DNS_DBFIND_GLUEOK) == 0) ||
+	       (DNS_TRUST_PENDING(trust) &&
+		(options & DNS_DBFIND_PENDINGOK) == 0);
+}
 
 static void
 qpc_search_init(qpc_search_t *search, qpcache_t *db, unsigned int options,
@@ -1542,6 +1541,8 @@ static isc_result_t
 qpcache_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
 	     dns_rdatatype_t type, unsigned int options, isc_stdtime_t __now,
 	     dns_dbnode_t **nodep, dns_name_t *foundname,
+	     dns_clientinfomethods_t *methods ISC_ATTR_UNUSED,
+	     dns_clientinfo_t *clientinfo ISC_ATTR_UNUSED,
 	     dns_rdataset_t *rdataset,
 	     dns_rdataset_t *sigrdataset DNS__DB_FLARG) {
 	qpcnode_t *node = NULL;
@@ -1696,7 +1697,7 @@ qpcache_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
 		empty_node = false;
 
 		if (header->noqname != NULL &&
-		    header->trust == dns_trust_secure)
+		    atomic_load(&header->trust) == dns_trust_secure)
 		{
 			found_noqname = true;
 		}
@@ -1708,15 +1709,14 @@ qpcache_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
 		bool match = false;
 		if (related_headers(header, typepair, sigpair, &found,
 				    &foundsig, &match) &&
-		    !MISSING_ANSWER(found, options))
+		    !missing_answer(found, options))
 		{
 			/*
 			 * We can't exit early until we have an answer with
-			 * sufficient trust level, see MISSING_ANSWER() macro
-			 * for details, because we might need NS or NSEC
+			 * sufficient trust level - see missing_answer()
+			 * for details - because we might need NS or NSEC
 			 * records.
 			 */
-
 			break;
 		}
 
@@ -1806,7 +1806,7 @@ qpcache_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
 	/*
 	 * If we didn't find what we were looking for...
 	 */
-	if (MISSING_ANSWER(found, options)) {
+	if (missing_answer(found, options)) {
 		/*
 		 * Return covering NODATA NSEC record.
 		 */
@@ -2420,6 +2420,8 @@ new_qpcnode(qpcache_t *qpdb, const dns_name_t *name, dns_namespace_t nspace) {
 
 static isc_result_t
 qpcache_findnode(dns_db_t *db, const dns_name_t *name, bool create,
+		 dns_clientinfomethods_t *methods ISC_ATTR_UNUSED,
+		 dns_clientinfo_t *clientinfo ISC_ATTR_UNUSED,
 		 dns_dbnode_t **nodep DNS__DB_FLARG) {
 	qpcache_t *qpdb = (qpcache_t *)db;
 	qpcnode_t *node = NULL;
@@ -2744,7 +2746,8 @@ add(qpcache_t *qpdb, qpcnode_t *qpnode, dns_slabheader_t *newheader,
 		 * data will supersede it below. Unclear what the best
 		 * policy is here.
 		 */
-		if (trust < oldheader->trust &&
+		dns_trust_t oldtrust = atomic_load(&oldheader->trust);
+		if (trust < oldtrust &&
 		    (ACTIVE(oldheader, now) || !EXISTS(oldheader)))
 		{
 			qpcache_hit(qpdb, oldheader);
@@ -2777,7 +2780,7 @@ add(qpcache_t *qpdb, qpcnode_t *qpnode, dns_slabheader_t *newheader,
 		if (ACTIVE(oldheader, now) &&
 		    oldheader->typepair == DNS_TYPEPAIR(dns_rdatatype_ns) &&
 		    EXISTS(oldheader) && EXISTS(newheader) &&
-		    oldheader->trust >= newheader->trust &&
+		    newheader->trust < oldtrust &&
 		    oldheader->expire < newheader->expire &&
 		    dns_rdataslab_equalx(
 			    oldheader, newheader, qpdb->common.rdclass,
@@ -2811,14 +2814,14 @@ add(qpcache_t *qpdb, qpcnode_t *qpnode, dns_slabheader_t *newheader,
 		}
 
 		/*
-		 * If we will be replacing a NS RRset force its TTL
+		 * If we will be replacing an NS RRset, force its TTL
 		 * to be no more than the current NS RRset's TTL.  This
 		 * ensures the delegations that are withdrawn are honoured.
 		 */
 		if (ACTIVE(oldheader, now) &&
 		    oldheader->typepair == DNS_TYPEPAIR(dns_rdatatype_ns) &&
 		    EXISTS(oldheader) && EXISTS(newheader) &&
-		    oldheader->trust <= newheader->trust)
+		    newheader->trust > oldtrust)
 		{
 			if (newheader->expire > oldheader->expire) {
 				if (ZEROTTL(oldheader)) {
@@ -2837,7 +2840,7 @@ add(qpcache_t *qpdb, qpcnode_t *qpnode, dns_slabheader_t *newheader,
 		     oldheader->typepair ==
 			     DNS_SIGTYPEPAIR(dns_rdatatype_ds)) &&
 		    EXISTS(oldheader) && EXISTS(newheader) &&
-		    oldheader->trust >= newheader->trust &&
+		    newheader->trust < oldtrust &&
 		    oldheader->expire < newheader->expire &&
 		    dns_rdataslab_equal(oldheader, newheader))
 		{
@@ -3255,22 +3258,6 @@ nodecount(dns_db_t *db, dns_dbtree_t tree) {
 	return mu.leaves;
 }
 
-static void
-qpcnode_locknode(dns_dbnode_t *node, isc_rwlocktype_t type) {
-	qpcnode_t *qpnode = (qpcnode_t *)node;
-	qpcache_t *qpdb = qpnode->qpdb;
-
-	RWLOCK(&qpdb->buckets[qpnode->locknum].lock, type);
-}
-
-static void
-qpcnode_unlocknode(dns_dbnode_t *node, isc_rwlocktype_t type) {
-	qpcnode_t *qpnode = (qpcnode_t *)node;
-	qpcache_t *qpdb = qpnode->qpdb;
-
-	RWUNLOCK(&qpdb->buckets[qpnode->locknum].lock, type);
-}
-
 isc_result_t
 dns__qpcache_create(isc_mem_t *mctx, const dns_name_t *origin,
 		    dns_dbtype_t type, dns_rdataclass_t rdclass,
diff --git a/lib/dns/qpzone.c b/lib/dns/qpzone.c
index 5f5de351b2..e081f15c26 100644
--- a/lib/dns/qpzone.c
+++ b/lib/dns/qpzone.c
@@ -25,7 +25,6 @@
 #include <isc/heap.h>
 #include <isc/hex.h>
 #include <isc/log.h>
-#include <isc/loop.h>
 #include <isc/mem.h>
 #include <isc/mutex.h>
 #include <isc/os.h>
@@ -238,7 +237,6 @@ struct qpzonedb {
 	qpz_version_t *current_version;
 	qpz_version_t *future_version;
 	qpz_versionlist_t open_versions;
-	isc_loop_t *loop;
 	struct rcu_head rcu_head;
 
 	qpz_heap_t *heap; /* Resigning heap */
@@ -517,10 +515,6 @@ free_db_rcu(struct rcu_head *rcu_head) {
 		isc_stats_detach(&qpdb->gluecachestats);
 	}
 
-	if (qpdb->loop != NULL) {
-		isc_loop_detach(&qpdb->loop);
-	}
-
 	isc_rwlock_destroy(&qpdb->lock);
 	isc_refcount_destroy(&qpdb->common.references);
 
@@ -987,7 +981,7 @@ bindrdataset(qpzonedb_t *qpdb, qpznode_t *node, dns_slabheader_t *header,
 	rdataset->type = DNS_TYPEPAIR_TYPE(header->typepair);
 	rdataset->covers = DNS_TYPEPAIR_COVERS(header->typepair);
 	rdataset->ttl = header->ttl;
-	rdataset->trust = header->trust;
+	rdataset->trust = atomic_load(&header->trust);
 
 	if (OPTOUT(header)) {
 		rdataset->attributes.optout = true;
@@ -2143,7 +2137,7 @@ loading_addrdataset(void *arg, const dns_name_t *name,
 	dns_slabheader_reset(newheader, (dns_dbnode_t *)node);
 
 	newheader->ttl = rdataset->ttl;
-	newheader->trust = rdataset->trust;
+	atomic_store(&newheader->trust, rdataset->trust);
 	newheader->serial = 1;
 
 	dns_slabheader_setownercase(newheader, name);
@@ -2511,6 +2505,8 @@ findnodeintree(qpzonedb_t *qpdb, const dns_name_t *name, bool create,
 
 static isc_result_t
 qpzone_findnode(dns_db_t *db, const dns_name_t *name, bool create,
+		dns_clientinfomethods_t *methods ISC_ATTR_UNUSED,
+		dns_clientinfo_t *clientinfo ISC_ATTR_UNUSED,
 		dns_dbnode_t **nodep DNS__DB_FLARG) {
 	qpzonedb_t *qpdb = (qpzonedb_t *)db;
 
@@ -3275,7 +3271,10 @@ static isc_result_t
 qpzone_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
 	    dns_rdatatype_t type, unsigned int options,
 	    isc_stdtime_t now ISC_ATTR_UNUSED, dns_dbnode_t **nodep,
-	    dns_name_t *foundname, dns_rdataset_t *rdataset,
+	    dns_name_t *foundname,
+	    dns_clientinfomethods_t *methods ISC_ATTR_UNUSED,
+	    dns_clientinfo_t *clientinfo ISC_ATTR_UNUSED,
+	    dns_rdataset_t *rdataset,
 	    dns_rdataset_t *sigrdataset DNS__DB_FLARG) {
 	isc_result_t result;
 	qpzonedb_t *qpdb = (qpzonedb_t *)db;
@@ -3872,24 +3871,6 @@ nodecount(dns_db_t *db, dns_dbtree_t tree ISC_ATTR_UNUSED) {
 	return mu.leaves;
 }
 
-static void
-setloop(dns_db_t *db, isc_loop_t *loop) {
-	qpzonedb_t *qpdb = NULL;
-
-	qpdb = (qpzonedb_t *)db;
-
-	REQUIRE(VALID_QPZONE(qpdb));
-
-	RWLOCK(&qpdb->lock, isc_rwlocktype_write);
-	if (qpdb->loop != NULL) {
-		isc_loop_detach(&qpdb->loop);
-	}
-	if (loop != NULL) {
-		isc_loop_attach(loop, &qpdb->loop);
-	}
-	RWUNLOCK(&qpdb->lock, isc_rwlocktype_write);
-}
-
 static isc_result_t
 getoriginnode(dns_db_t *db, dns_dbnode_t **nodep DNS__DB_FLARG) {
 	qpzonedb_t *qpdb = (qpzonedb_t *)db;
@@ -3905,20 +3886,6 @@ getoriginnode(dns_db_t *db, dns_dbnode_t **nodep DNS__DB_FLARG) {
 	return ISC_R_SUCCESS;
 }
 
-static void
-locknode(dns_dbnode_t *dbnode, isc_rwlocktype_t type) {
-	qpznode_t *node = (qpznode_t *)dbnode;
-
-	RWLOCK(qpzone_get_lock(node), type);
-}
-
-static void
-unlocknode(dns_dbnode_t *dbnode, isc_rwlocktype_t type) {
-	qpznode_t *node = (qpznode_t *)dbnode;
-
-	RWUNLOCK(qpzone_get_lock(node), type);
-}
-
 static void
 deletedata(dns_dbnode_t *node ISC_ATTR_UNUSED, void *data) {
 	dns_slabheader_t *header = data;
@@ -4941,18 +4908,6 @@ qpzone_deleterdataset(dns_db_t *db, dns_dbnode_t *dbnode,
 	return result;
 }
 
-static isc_result_t
-nodefullname(dns_dbnode_t *node, dns_name_t *name) {
-	REQUIRE(node != NULL);
-	REQUIRE(name != NULL);
-
-	qpznode_t *qpnode = (qpznode_t *)node;
-
-	dns_name_copy(&qpnode->name, name);
-
-	return ISC_R_SUCCESS;
-}
-
 static dns_glue_t *
 new_glue(isc_mem_t *mctx, const dns_name_t *name) {
 	dns_glue_t *glue = isc_mem_get(mctx, sizeof(*glue));
@@ -5016,7 +4971,7 @@ glue_nsdname_cb(void *arg, const dns_name_t *name, dns_rdatatype_t qtype,
 
 	result = qpzone_find(ctx->db, name, ctx->version, dns_rdatatype_a,
 			     DNS_DBFIND_GLUEOK, 0, (dns_dbnode_t **)&node_a,
-			     name_a, &rdataset_a,
+			     name_a, NULL, NULL, &rdataset_a,
 			     &sigrdataset_a DNS__DB_FLARG_PASS);
 	if (result == DNS_R_GLUE) {
 		glue = new_glue(ctx->db->mctx, name_a);
@@ -5035,7 +4990,7 @@ glue_nsdname_cb(void *arg, const dns_name_t *name, dns_rdatatype_t qtype,
 
 	result = qpzone_find(ctx->db, name, ctx->version, dns_rdatatype_aaaa,
 			     DNS_DBFIND_GLUEOK, 0, (dns_dbnode_t **)&node_aaaa,
-			     name_aaaa, &rdataset_aaaa,
+			     name_aaaa, NULL, NULL, &rdataset_aaaa,
 			     &sigrdataset_aaaa DNS__DB_FLARG_PASS);
 	if (result == DNS_R_GLUE) {
 		if (glue == NULL) {
@@ -5308,7 +5263,6 @@ static dns_dbmethods_t qpdb_zonemethods = {
 	.deleterdataset = qpzone_deleterdataset,
 	.issecure = issecure,
 	.nodecount = nodecount,
-	.setloop = setloop,
 	.getoriginnode = getoriginnode,
 	.getnsec3parameters = getnsec3parameters,
 	.findnsec3node = qpzone_findnsec3node,
@@ -5322,11 +5276,8 @@ static dns_dbmethods_t qpdb_zonemethods = {
 };
 
 static dns_dbnode_methods_t qpznode_methods = (dns_dbnode_methods_t){
-	.nodefullname = nodefullname,
 	.attachnode = qpzone_attachnode,
 	.detachnode = qpzone_detachnode,
-	.locknode = locknode,
-	.unlocknode = unlocknode,
 	.deletedata = deletedata,
 };
 
diff --git a/lib/dns/rdatalist.c b/lib/dns/rdatalist.c
index eced445df4..d5b650679e 100644
--- a/lib/dns/rdatalist.c
+++ b/lib/dns/rdatalist.c
@@ -26,17 +26,17 @@
 
 static dns_rdatasetmethods_t methods = {
 	.disassociate = dns_rdatalist_disassociate,
-	.first = dns_rdatalist_first,
-	.next = dns_rdatalist_next,
-	.current = dns_rdatalist_current,
-	.clone = dns_rdatalist_clone,
-	.count = dns_rdatalist_count,
-	.addnoqname = dns_rdatalist_addnoqname,
-	.getnoqname = dns_rdatalist_getnoqname,
-	.addclosest = dns_rdatalist_addclosest,
-	.getclosest = dns_rdatalist_getclosest,
-	.setownercase = dns_rdatalist_setownercase,
-	.getownercase = dns_rdatalist_getownercase,
+	.first = dns__rdatalist_first,
+	.next = dns__rdatalist_next,
+	.current = dns__rdatalist_current,
+	.clone = dns__rdatalist_clone,
+	.count = dns__rdatalist_count,
+	.addnoqname = dns__rdatalist_addnoqname,
+	.getnoqname = dns__rdatalist_getnoqname,
+	.addclosest = dns__rdatalist_addclosest,
+	.getclosest = dns__rdatalist_getclosest,
+	.setownercase = dns__rdatalist_setownercase,
+	.getownercase = dns__rdatalist_getownercase,
 };
 
 void
@@ -100,7 +100,7 @@ dns_rdatalist_disassociate(dns_rdataset_t *rdataset DNS__DB_FLARG) {
 }
 
 isc_result_t
-dns_rdatalist_first(dns_rdataset_t *rdataset) {
+dns__rdatalist_first(dns_rdataset_t *rdataset) {
 	dns_rdatalist_t *rdatalist = NULL;
 
 	rdatalist = rdataset->rdlist.list;
@@ -114,7 +114,7 @@ dns_rdatalist_first(dns_rdataset_t *rdataset) {
 }
 
 isc_result_t
-dns_rdatalist_next(dns_rdataset_t *rdataset) {
+dns__rdatalist_next(dns_rdataset_t *rdataset) {
 	dns_rdata_t *rdata;
 
 	rdata = rdataset->rdlist.iter;
@@ -132,7 +132,7 @@ dns_rdatalist_next(dns_rdataset_t *rdataset) {
 }
 
 void
-dns_rdatalist_current(dns_rdataset_t *rdataset, dns_rdata_t *rdata) {
+dns__rdatalist_current(dns_rdataset_t *rdataset, dns_rdata_t *rdata) {
 	dns_rdata_t *list_rdata;
 
 	list_rdata = rdataset->rdlist.iter;
@@ -142,8 +142,8 @@ dns_rdatalist_current(dns_rdataset_t *rdataset, dns_rdata_t *rdata) {
 }
 
 void
-dns_rdatalist_clone(dns_rdataset_t *source,
-		    dns_rdataset_t *target DNS__DB_FLARG) {
+dns__rdatalist_clone(dns_rdataset_t *source,
+		     dns_rdataset_t *target DNS__DB_FLARG) {
 	REQUIRE(source != NULL);
 	REQUIRE(target != NULL);
 
@@ -153,7 +153,7 @@ dns_rdatalist_clone(dns_rdataset_t *source,
 }
 
 unsigned int
-dns_rdatalist_count(dns_rdataset_t *rdataset) {
+dns__rdatalist_count(dns_rdataset_t *rdataset) {
 	dns_rdatalist_t *rdatalist = NULL;
 	unsigned int count;
 
@@ -170,7 +170,7 @@ dns_rdatalist_count(dns_rdataset_t *rdataset) {
 }
 
 isc_result_t
-dns_rdatalist_addnoqname(dns_rdataset_t *rdataset, dns_name_t *name) {
+dns__rdatalist_addnoqname(dns_rdataset_t *rdataset, dns_name_t *name) {
 	dns_rdataset_t *neg = NULL;
 	dns_rdataset_t *negsig = NULL;
 	dns_ttl_t ttl;
@@ -218,9 +218,9 @@ dns_rdatalist_addnoqname(dns_rdataset_t *rdataset, dns_name_t *name) {
 }
 
 isc_result_t
-dns_rdatalist_getnoqname(dns_rdataset_t *rdataset, dns_name_t *name,
-			 dns_rdataset_t *neg,
-			 dns_rdataset_t *negsig DNS__DB_FLARG) {
+dns__rdatalist_getnoqname(dns_rdataset_t *rdataset, dns_name_t *name,
+			  dns_rdataset_t *neg,
+			  dns_rdataset_t *negsig DNS__DB_FLARG) {
 	dns_rdataclass_t rdclass;
 	dns_rdataset_t *tneg = NULL;
 	dns_rdataset_t *tnegsig = NULL;
@@ -264,7 +264,7 @@ dns_rdatalist_getnoqname(dns_rdataset_t *rdataset, dns_name_t *name,
 }
 
 isc_result_t
-dns_rdatalist_addclosest(dns_rdataset_t *rdataset, dns_name_t *name) {
+dns__rdatalist_addclosest(dns_rdataset_t *rdataset, dns_name_t *name) {
 	dns_rdataset_t *neg = NULL;
 	dns_rdataset_t *negsig = NULL;
 	dns_ttl_t ttl;
@@ -311,9 +311,9 @@ dns_rdatalist_addclosest(dns_rdataset_t *rdataset, dns_name_t *name) {
 }
 
 isc_result_t
-dns_rdatalist_getclosest(dns_rdataset_t *rdataset, dns_name_t *name,
-			 dns_rdataset_t *neg,
-			 dns_rdataset_t *negsig DNS__DB_FLARG) {
+dns__rdatalist_getclosest(dns_rdataset_t *rdataset, dns_name_t *name,
+			  dns_rdataset_t *neg,
+			  dns_rdataset_t *negsig DNS__DB_FLARG) {
 	dns_rdataclass_t rdclass;
 	dns_rdataset_t *tneg = NULL;
 	dns_rdataset_t *tnegsig = NULL;
@@ -357,7 +357,7 @@ dns_rdatalist_getclosest(dns_rdataset_t *rdataset, dns_name_t *name,
 }
 
 void
-dns_rdatalist_setownercase(dns_rdataset_t *rdataset, const dns_name_t *name) {
+dns__rdatalist_setownercase(dns_rdataset_t *rdataset, const dns_name_t *name) {
 	dns_rdatalist_t *rdatalist;
 	unsigned int i;
 
@@ -379,7 +379,7 @@ dns_rdatalist_setownercase(dns_rdataset_t *rdataset, const dns_name_t *name) {
 }
 
 void
-dns_rdatalist_getownercase(const dns_rdataset_t *rdataset, dns_name_t *name) {
+dns__rdatalist_getownercase(const dns_rdataset_t *rdataset, dns_name_t *name) {
 	dns_rdatalist_t *rdatalist;
 	unsigned int i;
 
diff --git a/lib/dns/rdataslab.c b/lib/dns/rdataslab.c
index f611da9fe4..3616b3aead 100644
--- a/lib/dns/rdataslab.c
+++ b/lib/dns/rdataslab.c
@@ -1123,9 +1123,8 @@ static void
 rdataset_settrust(dns_rdataset_t *rdataset, dns_trust_t trust) {
 	dns_slabheader_t *header = dns_rdataset_getheader(rdataset);
 
-	dns_db_locknode(header->node, isc_rwlocktype_write);
-	header->trust = rdataset->trust = trust;
-	dns_db_unlocknode(header->node, isc_rwlocktype_write);
+	rdataset->trust = trust;
+	atomic_store(&header->trust, trust);
 }
 
 static void
@@ -1139,9 +1138,7 @@ static void
 rdataset_clearprefetch(dns_rdataset_t *rdataset) {
 	dns_slabheader_t *header = dns_rdataset_getheader(rdataset);
 
-	dns_db_locknode(header->node, isc_rwlocktype_write);
 	DNS_SLABHEADER_CLRATTR(header, DNS_SLABHEADERATTR_PREFETCH);
-	dns_db_unlocknode(header->node, isc_rwlocktype_write);
 }
 
 static void
diff --git a/lib/dns/sdlz.c b/lib/dns/sdlz.c
index 7e2064dc98..3852b06b1e 100644
--- a/lib/dns/sdlz.c
+++ b/lib/dns/sdlz.c
@@ -618,17 +618,11 @@ getnodedata(dns_db_t *db, const dns_name_t *name, bool create,
 	return ISC_R_SUCCESS;
 }
 
-static isc_result_t
-findnodeext(dns_db_t *db, const dns_name_t *name, bool create,
-	    dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo,
-	    dns_dbnode_t **nodep DNS__DB_FLARG) {
-	return getnodedata(db, name, create, 0, methods, clientinfo, nodep);
-}
-
 static isc_result_t
 findnode(dns_db_t *db, const dns_name_t *name, bool create,
+	 dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo,
 	 dns_dbnode_t **nodep DNS__DB_FLARG) {
-	return getnodedata(db, name, create, 0, NULL, NULL, nodep);
+	return getnodedata(db, name, create, 0, methods, clientinfo, nodep);
 }
 
 static void
@@ -771,11 +765,11 @@ findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
 }
 
 static isc_result_t
-findext(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
-	dns_rdatatype_t type, unsigned int options, isc_stdtime_t now,
-	dns_dbnode_t **nodep, dns_name_t *foundname,
-	dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo,
-	dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset DNS__DB_FLARG) {
+find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
+     dns_rdatatype_t type, unsigned int options, isc_stdtime_t now,
+     dns_dbnode_t **nodep, dns_name_t *foundname,
+     dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo,
+     dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset DNS__DB_FLARG) {
 	dns_sdlz_db_t *sdlz = (dns_sdlz_db_t *)db;
 	dns_dbnode_t *node = NULL;
 	dns_fixedname_t fname;
@@ -935,15 +929,6 @@ findext(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
 	return result;
 }
 
-static isc_result_t
-find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
-     dns_rdatatype_t type, unsigned int options, isc_stdtime_t now,
-     dns_dbnode_t **nodep, dns_name_t *foundname, dns_rdataset_t *rdataset,
-     dns_rdataset_t *sigrdataset DNS__DB_FLARG) {
-	return findext(db, name, version, type, options, now, nodep, foundname,
-		       NULL, NULL, rdataset, sigrdataset DNS__DB_FLARG_PASS);
-}
-
 static isc_result_t
 allrdatasets(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
 	     unsigned int options, isc_stdtime_t now,
@@ -1107,50 +1092,6 @@ deleterdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
 	return result;
 }
 
-static bool
-issecure(dns_db_t *db) {
-	UNUSED(db);
-
-	return false;
-}
-
-static unsigned int
-nodecount(dns_db_t *db, dns_dbtree_t tree) {
-	UNUSED(db);
-	UNUSED(tree);
-
-	return 0;
-}
-
-static void
-setloop(dns_db_t *db, isc_loop_t *loop) {
-	UNUSED(db);
-	UNUSED(loop);
-}
-
-/*
- * getoriginnode() is used by the update code to find the
- * dns_rdatatype_dnskey record for a zone
- */
-static isc_result_t
-getoriginnode(dns_db_t *db, dns_dbnode_t **nodep DNS__DB_FLARG) {
-	dns_sdlz_db_t *sdlz = (dns_sdlz_db_t *)db;
-	isc_result_t result;
-
-	REQUIRE(VALID_SDLZDB(sdlz));
-	if (sdlz->dlzimp->methods->newversion == NULL) {
-		return ISC_R_NOTIMPLEMENTED;
-	}
-
-	result = getnodedata(db, &sdlz->common.origin, false, 0, NULL, NULL,
-			     nodep);
-	if (result != ISC_R_SUCCESS) {
-		sdlz_log(ISC_LOG_ERROR, "sdlz getoriginnode failed: %s",
-			 isc_result_totext(result));
-	}
-	return result;
-}
-
 static dns_dbmethods_t sdlzdb_methods = {
 	.destroy = destroy,
 	.currentversion = currentversion,
@@ -1165,12 +1106,6 @@ static dns_dbmethods_t sdlzdb_methods = {
 	.addrdataset = addrdataset,
 	.subtractrdataset = subtractrdataset,
 	.deleterdataset = deleterdataset,
-	.issecure = issecure,
-	.nodecount = nodecount,
-	.setloop = setloop,
-	.getoriginnode = getoriginnode,
-	.findnodeext = findnodeext,
-	.findext = findext,
 };
 
 /*
@@ -1303,19 +1238,19 @@ static void
 rdataset_clone(dns_rdataset_t *source, dns_rdataset_t *target DNS__DB_FLARG) {
 	dns_dbnode_t *node = source->rdlist.node;
 
-	dns_rdatalist_clone(source, target DNS__DB_FLARG_PASS);
+	dns__rdatalist_clone(source, target DNS__DB_FLARG_PASS);
 	sdlznode_attachnode(node, &target->rdlist.node DNS__DB_FLARG_PASS);
 }
 
 static dns_rdatasetmethods_t rdataset_methods = {
 	.disassociate = disassociate,
-	.first = dns_rdatalist_first,
-	.next = dns_rdatalist_next,
-	.current = dns_rdatalist_current,
+	.first = dns__rdatalist_first,
+	.next = dns__rdatalist_next,
+	.current = dns__rdatalist_current,
 	.clone = rdataset_clone,
-	.count = dns_rdatalist_count,
-	.addnoqname = dns_rdatalist_addnoqname,
-	.getnoqname = dns_rdatalist_getnoqname,
+	.count = dns__rdatalist_count,
+	.addnoqname = dns__rdatalist_addnoqname,
+	.getnoqname = dns__rdatalist_getnoqname,
 };
 
 static void
diff --git a/lib/dns/zone.c b/lib/dns/zone.c
index dd16e4ce6e..e12ecae892 100644
--- a/lib/dns/zone.c
+++ b/lib/dns/zone.c
@@ -15128,7 +15128,6 @@ ns_query(dns_zone_t *zone, dns_rdataset_t *soardataset, dns_stub_t *stub) {
 					     isc_result_totext(result));
 				goto cleanup;
 			}
-			dns_db_setloop(stub->db, zone->loop);
 			dns_db_setmaxrrperset(stub->db, zone->maxrrperset);
 			dns_db_setmaxtypepername(stub->db,
 						 zone->maxtypepername);
@@ -18172,7 +18171,6 @@ zone_replacedb(dns_zone_t *zone, dns_db_t *db, bool dump) {
 		zone_detachdb(zone);
 	}
 	zone_attachdb(zone, db);
-	dns_db_setloop(zone->db, zone->loop);
 	dns_db_setmaxrrperset(zone->db, zone->maxrrperset);
 	dns_db_setmaxtypepername(zone->db, zone->maxtypepername);
 	DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_LOADED | DNS_ZONEFLG_NEEDNOTIFY);
@@ -24800,7 +24798,6 @@ dns_zone_makedb(dns_zone_t *zone, dns_db_t **dbp) {
 		break;
 	}
 
-	dns_db_setloop(db, zone->loop);
 	dns_db_setmaxrrperset(db, zone->maxrrperset);
 	dns_db_setmaxtypepername(db, zone->maxtypepername);