Lines Matching refs:rbtdb
70 #include "rbtdb.h"
83 #define VALID_RBTDB(rbtdb) ((rbtdb) != NULL && \
84 (rbtdb)->common.impmagic == RBTDB_MAGIC)
374 dns_rbtdb_t * rbtdb;
466 dns_rbtdb_t * rbtdb;
485 dns_rbtdb_t * rbtdb;
529 static void update_header(dns_rbtdb_t *rbtdb, rdatasetheader_t *header,
531 static void expire_header(dns_rbtdb_t *rbtdb, rdatasetheader_t *header,
533 static void overmem_purge(dns_rbtdb_t *rbtdb, unsigned int locknum_start,
535 static isc_result_t resign_insert(dns_rbtdb_t *rbtdb, int idx,
627 #define IS_STUB(rbtdb) (((rbtdb)->common.attributes & DNS_DBATTR_STUB) != 0)
628 #define IS_CACHE(rbtdb) (((rbtdb)->common.attributes & DNS_DBATTR_CACHE) != 0)
630 static void free_rbtdb(dns_rbtdb_t *rbtdb, isc_boolean_t log,
678 dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)source;
680 REQUIRE(VALID_RBTDB(rbtdb));
682 isc_refcount_increment(&rbtdb->references, NULL);
689 dns_rbtdb_t *rbtdb = event->ev_arg;
693 free_rbtdb(rbtdb, ISC_TRUE, event);
697 update_rrsetstats(dns_rbtdb_t *rbtdb, rdatasetheader_t *header,
705 INSIST(IS_CACHE(rbtdb));
719 dns_rdatasetstats_increment(rbtdb->rrsetstats, type);
721 dns_rdatasetstats_decrement(rbtdb->rrsetstats, type);
725 set_ttl(dns_rbtdb_t *rbtdb, rdatasetheader_t *header, dns_ttl_t newttl) {
733 if (!IS_CACHE(rbtdb))
737 * It's possible the rbtdb is not a cache. If this is the case,
744 if (rbtdb->heaps == NULL || rbtdb->heaps[idx] == NULL)
746 heap = rbtdb->heaps[idx];
837 free_rbtdb(dns_rbtdb_t *rbtdb, isc_boolean_t log, isc_event_t *event) {
844 if (IS_CACHE(rbtdb) && rbtdb->common.rdclass == dns_rdataclass_in)
845 overmem((dns_db_t *)rbtdb, (isc_boolean_t)-1);
847 REQUIRE(rbtdb->current_version != NULL || EMPTY(rbtdb->open_versions));
848 REQUIRE(rbtdb->future_version == NULL);
850 if (rbtdb->current_version != NULL) {
853 isc_refcount_decrement(&rbtdb->current_version->references,
856 UNLINK(rbtdb->open_versions, rbtdb->current_version, link);
857 isc_refcount_destroy(&rbtdb->current_version->references);
858 isc_mem_put(rbtdb->common.mctx, rbtdb->current_version,
866 for (i = 0; i < rbtdb->node_lock_count; i++) {
869 node = ISC_LIST_HEAD(rbtdb->deadnodes[i]);
871 ISC_LIST_UNLINK(rbtdb->deadnodes[i], node, deadlink);
872 node = ISC_LIST_HEAD(rbtdb->deadnodes[i]);
877 rbtdb->quantum = (rbtdb->task != NULL) ? 100 : 0;
879 if (rbtdb->tree != NULL) {
881 result = dns_rbt_destroy2(&rbtdb->tree, rbtdb->quantum);
883 INSIST(rbtdb->task != NULL);
884 if (rbtdb->quantum != 0)
885 rbtdb->quantum = adjust_quantum(rbtdb->quantum,
888 event = isc_event_allocate(rbtdb->common.mctx,
892 rbtdb,
896 isc_task_send(rbtdb->task, &event);
899 INSIST(result == ISC_R_SUCCESS && rbtdb->tree == NULL);
902 if (rbtdb->nsec3 != NULL) {
904 result = dns_rbt_destroy2(&rbtdb->nsec3, rbtdb->quantum);
906 INSIST(rbtdb->task != NULL);
907 if (rbtdb->quantum != 0)
908 rbtdb->quantum = adjust_quantum(rbtdb->quantum,
911 event = isc_event_allocate(rbtdb->common.mctx,
915 rbtdb,
919 isc_task_send(rbtdb->task, &event);
922 INSIST(result == ISC_R_SUCCESS && rbtdb->nsec3 == NULL);
928 if (dns_name_dynamic(&rbtdb->common.origin))
929 dns_name_format(&rbtdb->common.origin, buf,
937 if (dns_name_dynamic(&rbtdb->common.origin))
938 dns_name_free(&rbtdb->common.origin, rbtdb->common.mctx);
939 for (i = 0; i < rbtdb->node_lock_count; i++) {
940 isc_refcount_destroy(&rbtdb->node_locks[i].references);
941 NODE_DESTROYLOCK(&rbtdb->node_locks[i].lock);
947 if (rbtdb->rdatasets != NULL) {
948 for (i = 0; i < rbtdb->node_lock_count; i++)
949 INSIST(ISC_LIST_EMPTY(rbtdb->rdatasets[i]));
950 isc_mem_put(rbtdb->common.mctx, rbtdb->rdatasets,
951 rbtdb->node_lock_count *
957 if (rbtdb->deadnodes != NULL) {
958 for (i = 0; i < rbtdb->node_lock_count; i++)
959 INSIST(ISC_LIST_EMPTY(rbtdb->deadnodes[i]));
960 isc_mem_put(rbtdb->common.mctx, rbtdb->deadnodes,
961 rbtdb->node_lock_count * sizeof(rbtnodelist_t));
966 if (rbtdb->heaps != NULL) {
967 for (i = 0; i < rbtdb->node_lock_count; i++)
968 isc_heap_destroy(&rbtdb->heaps[i]);
969 isc_mem_put(rbtdb->hmctx, rbtdb->heaps,
970 rbtdb->node_lock_count * sizeof(isc_heap_t *));
973 if (rbtdb->rrsetstats != NULL)
974 dns_stats_detach(&rbtdb->rrsetstats);
976 isc_mem_put(rbtdb->common.mctx, rbtdb->node_locks,
977 rbtdb->node_lock_count * sizeof(rbtdb_nodelock_t));
978 isc_rwlock_destroy(&rbtdb->tree_lock);
979 isc_refcount_destroy(&rbtdb->references);
980 if (rbtdb->task != NULL)
981 isc_task_detach(&rbtdb->task);
983 RBTDB_DESTROYLOCK(&rbtdb->lock);
984 rbtdb->common.magic = 0;
985 rbtdb->common.impmagic = 0;
986 ondest = rbtdb->common.ondest;
987 isc_mem_detach(&rbtdb->hmctx);
988 isc_mem_putanddetach(&rbtdb->common.mctx, rbtdb, sizeof(*rbtdb));
989 isc_ondestroy_notify(&ondest, rbtdb);
993 maybe_free_rbtdb(dns_rbtdb_t *rbtdb) {
1000 if (rbtdb->soanode != NULL)
1001 dns_db_detachnode((dns_db_t *)rbtdb, &rbtdb->soanode);
1002 if (rbtdb->nsnode != NULL)
1003 dns_db_detachnode((dns_db_t *)rbtdb, &rbtdb->nsnode);
1009 for (i = 0; i < rbtdb->node_lock_count; i++) {
1010 NODE_LOCK(&rbtdb->node_locks[i].lock, isc_rwlocktype_write);
1011 rbtdb->node_locks[i].exiting = ISC_TRUE;
1012 NODE_UNLOCK(&rbtdb->node_locks[i].lock, isc_rwlocktype_write);
1013 if (isc_refcount_current(&rbtdb->node_locks[i].references)
1020 RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_write);
1021 rbtdb->active -= inactive;
1022 if (rbtdb->active == 0)
1024 RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_write);
1027 if (dns_name_dynamic(&rbtdb->common.origin))
1028 dns_name_format(&rbtdb->common.origin, buf,
1035 free_rbtdb(rbtdb, ISC_TRUE, NULL);
1042 dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)(*dbp);
1045 REQUIRE(VALID_RBTDB(rbtdb));
1047 isc_refcount_decrement(&rbtdb->references, &refs);
1050 maybe_free_rbtdb(rbtdb);
1057 dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
1061 REQUIRE(VALID_RBTDB(rbtdb));
1063 RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_read);
1064 version = rbtdb->current_version;
1066 RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_read);
1098 dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
1101 REQUIRE(VALID_RBTDB(rbtdb));
1103 REQUIRE(rbtdb->future_version == NULL);
1105 RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_write);
1106 RUNTIME_CHECK(rbtdb->next_serial != 0); /* XXX Error? */
1107 version = allocate_version(rbtdb->common.mctx, rbtdb->next_serial, 1,
1110 version->rbtdb = rbtdb;
1112 version->secure = rbtdb->current_version->secure;
1113 version->havensec3 = rbtdb->current_version->havensec3;
1115 version->flags = rbtdb->current_version->flags;
1117 rbtdb->current_version->iterations;
1118 version->hash = rbtdb->current_version->hash;
1120 rbtdb->current_version->salt_length;
1121 memmove(version->salt, rbtdb->current_version->salt,
1130 rbtdb->next_serial++;
1131 rbtdb->future_version = version;
1133 RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_write);
1147 dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
1151 REQUIRE(VALID_RBTDB(rbtdb));
1152 INSIST(rbtversion != NULL && rbtversion->rbtdb == rbtdb);
1161 add_changed(dns_rbtdb_t *rbtdb, rbtdb_version_t *version,
1172 changed = isc_mem_get(rbtdb->common.mctx, sizeof(*changed));
1174 RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_write);
1187 RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_write);
1237 init_rdataset(dns_rbtdb_t *rbtdb, rdatasetheader_t *h)
1243 if (IS_CACHE(rbtdb) && rbtdb->common.rdclass == dns_rdataclass_in)
1246 UNUSED(rbtdb);
1251 new_rdataset(dns_rbtdb_t *rbtdb, isc_mem_t *mctx)
1260 if (IS_CACHE(rbtdb) && rbtdb->common.rdclass == dns_rdataclass_in)
1263 init_rdataset(rbtdb, h);
1268 free_rdataset(dns_rbtdb_t *rbtdb, isc_mem_t *mctx, rdatasetheader_t *rdataset)
1275 update_rrsetstats(rbtdb, rdataset, ISC_FALSE);
1280 INSIST(IS_CACHE(rbtdb));
1281 ISC_LIST_UNLINK(rbtdb->rdatasets[idx], rdataset, link);
1284 isc_heap_delete(rbtdb->heaps[idx], rdataset->heap_index);
1336 clean_stale_headers(dns_rbtdb_t *rbtdb, isc_mem_t *mctx, rdatasetheader_t *top)
1342 free_rdataset(rbtdb, mctx, d);
1348 clean_cache_node(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node) {
1350 isc_mem_t *mctx = rbtdb->common.mctx;
1359 clean_stale_headers(rbtdb, mctx, current);
1369 free_rdataset(rbtdb, mctx, current);
1377 clean_zone_node(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node,
1382 isc_mem_t *mctx = rbtdb->common.mctx;
1410 free_rdataset(rbtdb, mctx, dcurrent);
1426 free_rdataset(rbtdb, mctx, current);
1442 free_rdataset(rbtdb, mctx, current);
1469 free_rdataset(rbtdb, mctx, dcurrent);
1493 free_rdataset(rbtdb, mctx, current);
1511 cleanup_dead_nodes(dns_rbtdb_t *rbtdb, int bucketnum) {
1516 node = ISC_LIST_HEAD(rbtdb->deadnodes[bucketnum]);
1518 ISC_LIST_UNLINK(rbtdb->deadnodes[bucketnum], node, deadlink);
1529 result = dns_rbt_deletenode(rbtdb->nsec3, node,
1532 result = dns_rbt_deletenode(rbtdb->tree, node,
1540 node = ISC_LIST_HEAD(rbtdb->deadnodes[bucketnum]);
1549 new_reference(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node) {
1556 lockref = &rbtdb->node_locks[node->locknum].references;
1574 reactivate_node(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node,
1578 nodelock_t *nodelock = &rbtdb->node_locks[node->locknum].lock;
1590 if (!ISC_LIST_EMPTY(rbtdb->deadnodes[node->locknum]) &&
1604 ISC_LIST_UNLINK(rbtdb->deadnodes[node->locknum],
1607 cleanup_dead_nodes(rbtdb, node->locknum);
1610 new_reference(rbtdb, node);
1627 decrement_reference(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node,
1639 nodelock = &rbtdb->node_locks[bucket];
1645 if (!node->dirty && KEEP_NODE(node, rbtdb)) {
1671 if (IS_CACHE(rbtdb))
1672 clean_cache_node(rbtdb, node);
1679 RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_read);
1680 least_serial = rbtdb->least_serial;
1681 RBTDB_UNLOCK(&rbtdb->lock,
1684 clean_zone_node(rbtdb, node, least_serial);
1700 result = isc_rwlock_tryupgrade(&rbtdb->tree_lock);
1702 result = isc_rwlock_trylock(&rbtdb->tree_lock,
1714 if (KEEP_NODE(node, rbtdb))
1736 * rbtdb. If the user of the rbtdb chooses not to set a task,
1742 node->right == NULL && rbtdb->task != NULL) {
1746 ev = isc_event_allocate(rbtdb->common.mctx, NULL,
1751 new_reference(rbtdb, node);
1753 attach((dns_db_t *)rbtdb, &db);
1755 isc_task_send(rbtdb->task, &ev);
1775 ISC_LIST_APPEND(rbtdb->deadnodes[bucket], node,
1796 result = dns_rbt_deletenode(rbtdb->nsec3, node,
1799 result = dns_rbt_deletenode(rbtdb->tree, node,
1814 ISC_LIST_APPEND(rbtdb->deadnodes[bucket], node, deadlink);
1827 RWUNLOCK(&rbtdb->tree_lock, isc_rwlocktype_write);
1831 isc_rwlock_downgrade(&rbtdb->tree_lock);
1845 dns_rbtdb_t *rbtdb = event->ev_sender;
1854 RWLOCK(&rbtdb->tree_lock, isc_rwlocktype_write);
1856 NODE_LOCK(&rbtdb->node_locks[locknum].lock, isc_rwlocktype_write);
1859 decrement_reference(rbtdb, node, 0, isc_rwlocktype_write,
1870 NODE_UNLOCK(&rbtdb->node_locks[locknum].lock,
1873 NODE_LOCK(&rbtdb->node_locks[locknum].lock,
1885 ISC_LIST_UNLINK(rbtdb->deadnodes[locknum],
1887 new_reference(rbtdb, parent);
1893 NODE_UNLOCK(&rbtdb->node_locks[locknum].lock, isc_rwlocktype_write);
1894 RWUNLOCK(&rbtdb->tree_lock, isc_rwlocktype_write);
1896 detach((dns_db_t **)&rbtdb);
1900 make_least_version(dns_rbtdb_t *rbtdb, rbtdb_version_t *version,
1907 rbtdb->least_serial = version->serial;
2026 dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
2028 RWLOCK(&rbtdb->tree_lock, isc_rwlocktype_read);
2030 node = rbtdb->origin_node;
2031 NODE_LOCK(&(rbtdb->node_locks[node->locknum].lock),
2070 rbtdb->common.rdclass,
2112 NODE_UNLOCK(&(rbtdb->node_locks[node->locknum].lock),
2114 RWUNLOCK(&rbtdb->tree_lock, isc_rwlocktype_read);
2119 dns_rbtdb_t *rbtdb = event->ev_arg;
2124 RWLOCK(&rbtdb->tree_lock, isc_rwlocktype_write);
2125 for (locknum = 0; locknum < rbtdb->node_lock_count; locknum++) {
2126 NODE_LOCK(&rbtdb->node_locks[locknum].lock,
2128 cleanup_dead_nodes(rbtdb, locknum);
2129 if (ISC_LIST_HEAD(rbtdb->deadnodes[locknum]) != NULL)
2131 NODE_UNLOCK(&rbtdb->node_locks[locknum].lock,
2134 RWUNLOCK(&rbtdb->tree_lock, isc_rwlocktype_write);
2139 isc_refcount_decrement(&rbtdb->references, &refs);
2141 maybe_free_rbtdb(rbtdb);
2147 dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
2159 REQUIRE(VALID_RBTDB(rbtdb));
2161 INSIST(version->rbtdb == rbtdb);
2170 RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_read);
2172 RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_read);
2177 RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_write);
2186 INSIST(version == rbtdb->future_version);
2192 cur_version = rbtdb->current_version;
2196 if (cur_version->serial == rbtdb->least_serial)
2198 UNLINK(rbtdb->open_versions,
2201 if (EMPTY(rbtdb->open_versions)) {
2206 make_least_version(rbtdb, version,
2239 rbtdb->current_version = version;
2240 rbtdb->current_serial = version->serial;
2241 rbtdb->future_version = NULL;
2253 PREPEND(rbtdb->open_versions,
2254 rbtdb->current_version, link);
2267 rbtdb->future_version = NULL;
2270 if (version != rbtdb->current_version) {
2283 least_greater = rbtdb->current_version;
2289 if (version->serial == rbtdb->least_serial) {
2294 make_least_version(rbtdb,
2306 } else if (version->serial == rbtdb->least_serial)
2308 UNLINK(rbtdb->open_versions, version, link);
2310 least_serial = rbtdb->least_serial;
2311 RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_write);
2316 if (writer && commit && !IS_CACHE(rbtdb))
2317 iszonesecure(db, version, rbtdb->origin_node);
2321 isc_mem_put(rbtdb->common.mctx, cleanup_version,
2335 lock = &rbtdb->node_locks[header->node->locknum].lock;
2338 resign_insert(rbtdb, header->node->locknum, header);
2339 decrement_reference(rbtdb, header->node, least_serial,
2349 if (rbtdb->task != NULL)
2350 event = isc_event_allocate(rbtdb->common.mctx, NULL,
2353 rbtdb, sizeof(isc_event_t));
2364 RWLOCK(&rbtdb->tree_lock, isc_rwlocktype_write);
2375 lock = &rbtdb->node_locks[rbtnode->locknum].lock;
2383 cleanup_dead_nodes(rbtdb, rbtnode->locknum);
2387 decrement_reference(rbtdb, rbtnode, least_serial,
2393 isc_mem_put(rbtdb->common.mctx, changed,
2397 isc_refcount_increment(&rbtdb->references, NULL);
2398 isc_task_send(rbtdb->task, &event);
2400 RWUNLOCK(&rbtdb->tree_lock, isc_rwlocktype_write);
2409 * to be found in 'rbtdb'.
2421 add_wildcard_magic(dns_rbtdb_t *rbtdb, dns_name_t *name) {
2433 result = dns_rbt_addnode(rbtdb->tree, &foundname, &node);
2443 add_empty_wildcards(dns_rbtdb_t *rbtdb, dns_name_t *name) {
2451 l = dns_name_countlabels(&rbtdb->common.origin);
2457 result = add_wildcard_magic(rbtdb, &foundname);
2460 result = dns_rbt_addnode(rbtdb->tree, &foundname,
2472 findnodeintree(dns_rbtdb_t *rbtdb, dns_rbt_t *tree, dns_name_t *name,
2480 INSIST(tree == rbtdb->tree || tree == rbtdb->nsec3);
2483 RWLOCK(&rbtdb->tree_lock, locktype);
2487 RWUNLOCK(&rbtdb->tree_lock, locktype);
2498 RWLOCK(&rbtdb->tree_lock, locktype);
2504 node->locknum = node->hashval % rbtdb->node_lock_count;
2507 rbtdb->node_lock_count;
2509 if (tree == rbtdb->tree) {
2511 add_empty_wildcards(rbtdb, name);
2514 result = add_wildcard_magic(rbtdb,
2517 RWUNLOCK(&rbtdb->tree_lock,
2523 if (tree == rbtdb->nsec3)
2526 RWUNLOCK(&rbtdb->tree_lock, locktype);
2531 if (tree == rbtdb->nsec3)
2534 reactivate_node(rbtdb, node, locktype);
2535 RWUNLOCK(&rbtdb->tree_lock, locktype);
2546 dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
2548 REQUIRE(VALID_RBTDB(rbtdb));
2550 return (findnodeintree(rbtdb, rbtdb->tree, name, create, nodep));
2557 dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
2559 REQUIRE(VALID_RBTDB(rbtdb));
2561 return (findnodeintree(rbtdb, rbtdb->nsec3, name, create, nodep));
2583 onode = search->rbtdb->origin_node;
2585 NODE_LOCK(&(search->rbtdb->node_locks[node->locknum].lock),
2619 IS_STUB(search->rbtdb)) {
2637 if (!IS_CACHE(search->rbtdb) && !IS_STUB(search->rbtdb) &&
2658 new_reference(search->rbtdb, node);
2702 NODE_UNLOCK(&(search->rbtdb->node_locks[node->locknum].lock),
2709 bind_rdataset(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node,
2726 new_reference(rbtdb, node);
2731 rdataset->rdclass = rbtdb->common.rdclass;
2742 rdataset->private1 = rbtdb;
2816 NODE_LOCK(&(search->rbtdb->node_locks[node->locknum].lock),
2818 bind_rdataset(search->rbtdb, node, search->zonecut_rdataset,
2821 bind_rdataset(search->rbtdb, node,
2824 NODE_UNLOCK(&(search->rbtdb->node_locks[node->locknum].lock),
2907 dns_rbtdb_t *rbtdb;
2913 rbtdb = search->rbtdb;
2928 NODE_LOCK(&(rbtdb->node_locks[node->locknum].lock),
2937 NODE_UNLOCK(&(rbtdb->node_locks[node->locknum].lock),
2961 dns_rbtdb_t *rbtdb;
2971 rbtdb = search->rbtdb;
2995 NODE_LOCK(&(rbtdb->node_locks[node->locknum].lock),
3004 NODE_UNLOCK(&(rbtdb->node_locks[node->locknum].lock),
3022 NODE_LOCK(&(rbtdb->node_locks[node->locknum].lock),
3031 NODE_UNLOCK(&(rbtdb->node_locks[node->locknum].lock),
3076 dns_rbtdb_t *rbtdb;
3095 rbtdb = search->rbtdb;
3100 NODE_LOCK(&(rbtdb->node_locks[node->locknum].lock),
3126 NODE_UNLOCK(&(rbtdb->node_locks[node->locknum].lock),
3155 result = dns_rbt_findnode(rbtdb->tree, wname,
3167 lock = &rbtdb->node_locks[wnode->locknum].lock;
3249 dns_rdata_fromregion(&rdata, search->rbtdb->common.rdclass,
3285 if (tree == search->rbtdb->nsec3) {
3306 NODE_LOCK(&(search->rbtdb->node_locks[node->locknum].lock),
3373 new_reference(search->rbtdb,
3377 bind_rdataset(search->rbtdb, node,
3381 bind_rdataset(search->rbtdb,
3414 NODE_UNLOCK(&(search->rbtdb->node_locks[node->locknum].lock),
3461 search.rbtdb = (dns_rbtdb_t *)db;
3463 REQUIRE(VALID_RBTDB(search.rbtdb));
3465 ((rbtdb_version_t *)version)->rbtdb == (dns_rbtdb_t *)db);
3489 dns_rbtnodechain_init(&search.chain, search.rbtdb->common.mctx);
3497 RWLOCK(&search.rbtdb->tree_lock, isc_rwlocktype_read);
3504 tree = (options & DNS_DBFIND_FORCENSEC3) != 0 ? search.rbtdb->nsec3 :
3505 search.rbtdb->tree;
3585 ((node != search.rbtdb->origin_node &&
3587 IS_STUB(search.rbtdb)))
3605 lock = &search.rbtdb->node_locks[node->locknum].lock;
3650 new_reference(search.rbtdb, node);
3806 search.rbtdb->tree,
3823 new_reference(search.rbtdb, node);
3830 bind_rdataset(search.rbtdb, node, nsecheader,
3833 bind_rdataset(search.rbtdb, node,
3901 new_reference(search.rbtdb, node);
3908 bind_rdataset(search.rbtdb, node, found, 0, rdataset);
3910 bind_rdataset(search.rbtdb, node, foundsig, 0,
3921 RWUNLOCK(&search.rbtdb->tree_lock, isc_rwlocktype_read);
3930 lock = &(search.rbtdb->node_locks[node->locknum].lock);
3933 decrement_reference(search.rbtdb, node, 0,
3985 lock = &(search->rbtdb->node_locks[node->locknum].lock);
4030 mctx = search->rbtdb->common.mctx;
4031 clean_stale_headers(search->rbtdb,
4039 free_rdataset(search->rbtdb, mctx,
4068 new_reference(search->rbtdb, node);
4094 dns_rbtdb_t *rbtdb;
4103 rbtdb = search->rbtdb;
4108 lock = &rbtdb->node_locks[node->locknum].lock;
4143 m = search->rbtdb->common.mctx;
4145 search->rbtdb,
4153 free_rdataset(rbtdb, m,
4215 new_reference(search->rbtdb, node);
4218 bind_rdataset(search->rbtdb, node, found, search->now,
4221 bind_rdataset(search->rbtdb, node, foundsig,
4233 update_header(search->rbtdb, found,
4237 update_header(search->rbtdb, foundsig,
4288 lock = &(search->rbtdb->node_locks[node->locknum].lock);
4319 m = search->rbtdb->common.mctx;
4321 search->rbtdb,
4328 free_rdataset(search->rbtdb, m,
4357 bind_rdataset(search->rbtdb, node, found,
4360 bind_rdataset(search->rbtdb, node, foundsig,
4362 new_reference(search->rbtdb, node);
4397 search.rbtdb = (dns_rbtdb_t *)db;
4399 REQUIRE(VALID_RBTDB(search.rbtdb));
4413 dns_rbtnodechain_init(&search.chain, search.rbtdb->common.mctx);
4418 RWLOCK(&search.rbtdb->tree_lock, isc_rwlocktype_read);
4425 result = dns_rbt_findnode(search.rbtdb->tree, name, foundname, &node,
4465 lock = &(search.rbtdb->node_locks[node->locknum].lock);
4499 mctx = search.rbtdb->common.mctx;
4500 clean_stale_headers(search.rbtdb, mctx,
4507 free_rdataset(search.rbtdb, mctx,
4610 new_reference(search.rbtdb, node);
4614 bind_rdataset(search.rbtdb, node, nsheader, search.now,
4619 bind_rdataset(search.rbtdb, node, nssig,
4640 new_reference(search.rbtdb, node);
4671 bind_rdataset(search.rbtdb, node, found, search.now,
4676 bind_rdataset(search.rbtdb, node, foundsig, search.now,
4692 update_header(search.rbtdb, update, search.now);
4694 update_header(search.rbtdb, updatesig, search.now);
4699 RWUNLOCK(&search.rbtdb->tree_lock, isc_rwlocktype_read);
4708 lock = &(search.rbtdb->node_locks[node->locknum].lock);
4711 decrement_reference(search.rbtdb, node, 0,
4737 search.rbtdb = (dns_rbtdb_t *)db;
4739 REQUIRE(VALID_RBTDB(search.rbtdb));
4752 dns_rbtnodechain_init(&search.chain, search.rbtdb->common.mctx);
4758 RWLOCK(&search.rbtdb->tree_lock, isc_rwlocktype_read);
4763 result = dns_rbt_findnode(search.rbtdb->tree, name, foundname, &node,
4778 lock = &(search.rbtdb->node_locks[node->locknum].lock);
4806 mctx = search.rbtdb->common.mctx;
4807 clean_stale_headers(search.rbtdb, mctx,
4814 free_rdataset(search.rbtdb, mctx,
4857 new_reference(search.rbtdb, node);
4862 bind_rdataset(search.rbtdb, node, found, search.now, rdataset);
4864 bind_rdataset(search.rbtdb, node, foundsig, search.now,
4876 update_header(search.rbtdb, found, search.now);
4879 update_header(search.rbtdb, foundsig, search.now);
4886 RWUNLOCK(&search.rbtdb->tree_lock, isc_rwlocktype_read);
4900 dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
4904 REQUIRE(VALID_RBTDB(rbtdb));
4907 NODE_STRONGLOCK(&rbtdb->node_locks[node->locknum].lock);
4910 NODE_STRONGUNLOCK(&rbtdb->node_locks[node->locknum].lock);
4917 dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
4923 REQUIRE(VALID_RBTDB(rbtdb));
4927 nodelock = &rbtdb->node_locks[node->locknum];
4931 if (decrement_reference(rbtdb, node, 0, isc_rwlocktype_read,
4944 RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_write);
4945 rbtdb->active--;
4946 if (rbtdb->active == 0)
4948 RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_write);
4951 if (dns_name_dynamic(&rbtdb->common.origin))
4952 dns_name_format(&rbtdb->common.origin, buf,
4959 free_rbtdb(rbtdb, ISC_TRUE, NULL);
4966 dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
4979 REQUIRE(VALID_RBTDB(rbtdb));
4988 if (isc_mem_isovermem(rbtdb->common.mctx)) {
5016 NODE_LOCK(&rbtdb->node_locks[rbtnode->locknum].lock,
5035 set_ttl(rbtdb, header, 0);
5044 } else if (isc_mem_isovermem(rbtdb->common.mctx) && log)
5048 NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock,
5066 dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
5070 REQUIRE(VALID_RBTDB(rbtdb));
5072 NODE_LOCK(&rbtdb->node_locks[rbtnode->locknum].lock,
5105 NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock,
5112 dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
5115 REQUIRE(VALID_RBTDB(rbtdb));
5117 rbtdbiter = isc_mem_get(rbtdb->common.mctx, sizeof(*rbtdbiter));
5156 dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
5164 REQUIRE(VALID_RBTDB(rbtdb));
5166 INSIST(rbtversion == NULL || rbtversion->rbtdb == rbtdb);
5175 NODE_LOCK(&rbtdb->node_locks[rbtnode->locknum].lock,
5218 bind_rdataset(rbtdb, rbtnode, found, now, rdataset);
5220 bind_rdataset(rbtdb, rbtnode, foundsig, now,
5224 NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock,
5243 dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
5251 REQUIRE(VALID_RBTDB(rbtdb));
5261 lock = &rbtdb->node_locks[rbtnode->locknum].lock;
5307 bind_rdataset(rbtdb, rbtnode, found, now, rdataset);
5309 bind_rdataset(rbtdb, rbtnode, foundsig, now,
5335 dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
5341 REQUIRE(VALID_RBTDB(rbtdb));
5343 iterator = isc_mem_get(rbtdb->common.mctx, sizeof(*iterator));
5355 INSIST(rbtversion->rbtdb == rbtdb);
5374 NODE_STRONGLOCK(&rbtdb->node_locks[rbtnode->locknum].lock);
5381 NODE_STRONGUNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock);
5465 resign_insert(dns_rbtdb_t *rbtdb, int idx, rdatasetheader_t *newheader) {
5468 INSIST(!IS_CACHE(rbtdb));
5472 result = isc_heap_insert(rbtdb->heaps[idx], newheader);
5477 add(dns_rbtdb_t *rbtdb, dns_rbtnode_t *rbtnode, rbtdb_version_t *rbtversion,
5518 changed = add_changed(rbtdb, rbtversion, rbtnode);
5520 free_rdataset(rbtdb, rbtdb->common.mctx, newheader);
5554 set_ttl(rbtdb, topheader, 0);
5594 free_rdataset(rbtdb,
5595 rbtdb->common.mctx,
5598 bind_rdataset(rbtdb, rbtnode,
5607 set_ttl(rbtdb, topheader, 0);
5642 free_rdataset(rbtdb, rbtdb->common.mctx, newheader);
5652 free_rdataset(rbtdb, rbtdb->common.mctx, newheader);
5654 bind_rdataset(rbtdb, rbtnode, header, now,
5687 rbtdb->common.mctx,
5688 rbtdb->common.rdclass,
5700 free_rdataset(rbtdb, rbtdb->common.mctx,
5708 free_rdataset(rbtdb, rbtdb->common.mctx,
5720 if (IS_CACHE(rbtdb) && header->rdh_ttl >= now &&
5727 rbtdb->common.rdclass,
5734 set_ttl(rbtdb, header, newheader->rdh_ttl);
5745 free_rdataset(rbtdb, rbtdb->common.mctx, newheader);
5747 bind_rdataset(rbtdb, rbtnode, header, now,
5756 if (IS_CACHE(rbtdb) && header->rdh_ttl >= now &&
5764 if (IS_CACHE(rbtdb) && header->rdh_ttl >= now &&
5779 set_ttl(rbtdb, header, newheader->rdh_ttl);
5790 free_rdataset(rbtdb, rbtdb->common.mctx, newheader);
5792 bind_rdataset(rbtdb, rbtnode, header, now,
5811 free_rdataset(rbtdb, rbtdb->common.mctx, header);
5819 set_ttl(rbtdb, header, 0);
5822 set_ttl(rbtdb, sigheader, 0);
5828 if (IS_CACHE(rbtdb)) {
5829 ISC_LIST_PREPEND(rbtdb->rdatasets[idx],
5838 INSIST(rbtdb->heaps != NULL);
5839 isc_heap_insert(rbtdb->heaps[idx], newheader);
5841 resign_insert(rbtdb, idx, newheader);
5853 free_rdataset(rbtdb, rbtdb->common.mctx, newheader);
5888 if (IS_CACHE(rbtdb)) {
5889 ISC_LIST_PREPEND(rbtdb->rdatasets[idx],
5891 isc_heap_insert(rbtdb->heaps[idx], newheader);
5893 resign_insert(rbtdb, idx, newheader);
5905 bind_rdataset(rbtdb, rbtnode, newheader, now, addedrdataset);
5911 delegating_type(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node,
5914 if (IS_CACHE(rbtdb)) {
5921 (node != rbtdb->origin_node || IS_STUB(rbtdb))))
5927 addnoqname(dns_rbtdb_t *rbtdb, rdatasetheader_t *newheader,
5931 isc_mem_t *mctx = rbtdb->common.mctx;
5978 addclosest(dns_rbtdb_t *rbtdb, rdatasetheader_t *newheader,
5982 isc_mem_t *mctx = rbtdb->common.mctx;
6035 dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
6046 REQUIRE(VALID_RBTDB(rbtdb));
6047 INSIST(rbtversion == NULL || rbtversion->rbtdb == rbtdb);
6049 if (rbtdb->common.methods == &zone_methods)
6063 result = dns_rdataslab_fromrdataset(rdataset, rbtdb->common.mctx,
6069 init_rdataset(rbtdb, newheader);
6070 set_ttl(rbtdb, newheader, rdataset->ttl + now);
6101 result = addnoqname(rbtdb, newheader, rdataset);
6103 free_rdataset(rbtdb, rbtdb->common.mctx,
6109 result = addclosest(rbtdb, newheader, rdataset);
6111 free_rdataset(rbtdb, rbtdb->common.mctx,
6123 if (delegating_type(rbtdb, rbtnode, rdataset->type))
6134 if (IS_CACHE(rbtdb) && isc_mem_isovermem(rbtdb->common.mctx))
6138 RWLOCK(&rbtdb->tree_lock, isc_rwlocktype_write);
6142 overmem_purge(rbtdb, rbtnode->locknum, now, tree_locked);
6144 NODE_LOCK(&rbtdb->node_locks[rbtnode->locknum].lock,
6147 if (rbtdb->rrsetstats != NULL) {
6149 update_rrsetstats(rbtdb, newheader, ISC_TRUE);
6152 if (IS_CACHE(rbtdb)) {
6154 cleanup_dead_nodes(rbtdb, rbtnode->locknum);
6156 header = isc_heap_element(rbtdb->heaps[rbtnode->locknum], 1);
6158 expire_header(rbtdb, header, tree_locked);
6166 RWUNLOCK(&rbtdb->tree_lock, isc_rwlocktype_write);
6171 result = add(rbtdb, rbtnode, rbtversion, newheader, options, ISC_FALSE,
6176 NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock,
6180 RWUNLOCK(&rbtdb->tree_lock, isc_rwlocktype_write);
6186 if (result == ISC_R_SUCCESS && version == NULL && !IS_CACHE(rbtdb))
6187 iszonesecure(db, version, rbtdb->origin_node);
6197 dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
6206 REQUIRE(VALID_RBTDB(rbtdb));
6207 REQUIRE(rbtversion != NULL && rbtversion->rbtdb == rbtdb);
6209 if (rbtdb->common.methods == &zone_methods)
6217 result = dns_rdataslab_fromrdataset(rdataset, rbtdb->common.mctx,
6223 init_rdataset(rbtdb, newheader);
6224 set_ttl(rbtdb, newheader, rdataset->ttl);
6243 NODE_LOCK(&rbtdb->node_locks[rbtnode->locknum].lock,
6246 changed = add_changed(rbtdb, rbtversion, rbtnode);
6248 free_rdataset(rbtdb, rbtdb->common.mctx, newheader);
6249 NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock,
6284 rbtdb->common.mctx,
6285 rbtdb->common.rdclass,
6289 free_rdataset(rbtdb, rbtdb->common.mctx, newheader);
6291 init_rdataset(rbtdb, newheader);
6310 free_rdataset(rbtdb, rbtdb->common.mctx, newheader);
6311 newheader = new_rdataset(rbtdb, rbtdb->common.mctx);
6316 set_ttl(rbtdb, newheader, 0);
6330 free_rdataset(rbtdb, rbtdb->common.mctx, newheader);
6353 free_rdataset(rbtdb, rbtdb->common.mctx, newheader);
6361 bind_rdataset(rbtdb, rbtnode, newheader, 0, newrdataset);
6364 NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock,
6371 if (result == ISC_R_SUCCESS && version == NULL && !IS_CACHE(rbtdb))
6372 iszonesecure(db, rbtdb->current_version, rbtdb->origin_node);
6381 dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
6387 REQUIRE(VALID_RBTDB(rbtdb));
6388 INSIST(rbtversion == NULL || rbtversion->rbtdb == rbtdb);
6395 newheader = new_rdataset(rbtdb, rbtdb->common.mctx);
6398 set_ttl(rbtdb, newheader, 0);
6414 NODE_LOCK(&rbtdb->node_locks[rbtnode->locknum].lock,
6417 result = add(rbtdb, rbtnode, rbtversion, newheader, DNS_DBADD_FORCE,
6420 NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock,
6427 if (result == ISC_R_SUCCESS && version == NULL && !IS_CACHE(rbtdb))
6428 iszonesecure(db, rbtdb->current_version, rbtdb->origin_node);
6436 dns_rbtdb_t *rbtdb = loadctx->rbtdb;
6453 !IS_CACHE(rbtdb) && !dns_name_equal(name, &rbtdb->common.origin))
6458 add_empty_wildcards(rbtdb, name);
6471 result = add_wildcard_magic(rbtdb, name);
6479 result = dns_rbt_addnode(rbtdb->nsec3, name, &node);
6483 result = dns_rbt_addnode(rbtdb->tree, name, &node);
6494 node->locknum = node->hashval % rbtdb->node_lock_count;
6497 rbtdb->node_lock_count;
6501 result = dns_rdataslab_fromrdataset(rdataset, rbtdb->common.mctx,
6507 init_rdataset(rbtdb, newheader);
6508 set_ttl(rbtdb, newheader,
6528 result = add(rbtdb, node, rbtdb->current_version, newheader,
6531 delegating_type(rbtdb, node, rdataset->type))
6542 dns_rbtdb_t *rbtdb;
6544 rbtdb = (dns_rbtdb_t *)db;
6546 REQUIRE(VALID_RBTDB(rbtdb));
6548 loadctx = isc_mem_get(rbtdb->common.mctx, sizeof(*loadctx));
6552 loadctx->rbtdb = rbtdb;
6553 if (IS_CACHE(rbtdb))
6558 RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_write);
6560 REQUIRE((rbtdb->attributes & (RBTDB_ATTR_LOADED|RBTDB_ATTR_LOADING))
6562 rbtdb->attributes |= RBTDB_ATTR_LOADING;
6564 RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_write);
6575 dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
6577 REQUIRE(VALID_RBTDB(rbtdb));
6580 REQUIRE(loadctx->rbtdb == rbtdb);
6582 RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_write);
6584 REQUIRE((rbtdb->attributes & RBTDB_ATTR_LOADING) != 0);
6585 REQUIRE((rbtdb->attributes & RBTDB_ATTR_LOADED) == 0);
6587 rbtdb->attributes &= ~RBTDB_ATTR_LOADING;
6588 rbtdb->attributes |= RBTDB_ATTR_LOADED;
6590 RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_write);
6596 if (! IS_CACHE(rbtdb))
6597 iszonesecure(db, rbtdb->current_version, rbtdb->origin_node);
6601 isc_mem_put(rbtdb->common.mctx, loadctx, sizeof(*loadctx));
6609 dns_rbtdb_t *rbtdb;
6611 rbtdb = (dns_rbtdb_t *)db;
6613 REQUIRE(VALID_RBTDB(rbtdb));
6615 return (dns_master_dump2(rbtdb->common.mctx, db, version,
6622 dns_rbtdb_t *rbtdb = arg;
6628 NODE_LOCK(&rbtdb->node_locks[locknum].lock, isc_rwlocktype_write);
6631 free_rdataset(rbtdb, rbtdb->common.mctx, current);
6634 NODE_UNLOCK(&rbtdb->node_locks[locknum].lock, isc_rwlocktype_write);
6639 dns_rbtdb_t *rbtdb;
6642 rbtdb = (dns_rbtdb_t *)db;
6644 REQUIRE(VALID_RBTDB(rbtdb));
6646 RWLOCK(&rbtdb->tree_lock, isc_rwlocktype_read);
6647 secure = ISC_TF(rbtdb->current_version->secure == dns_db_secure);
6648 RWUNLOCK(&rbtdb->tree_lock, isc_rwlocktype_read);
6655 dns_rbtdb_t *rbtdb;
6658 rbtdb = (dns_rbtdb_t *)db;
6660 REQUIRE(VALID_RBTDB(rbtdb));
6662 RWLOCK(&rbtdb->tree_lock, isc_rwlocktype_read);
6663 dnssec = ISC_TF(rbtdb->current_version->secure != dns_db_insecure);
6664 RWUNLOCK(&rbtdb->tree_lock, isc_rwlocktype_read);
6671 dns_rbtdb_t *rbtdb;
6674 rbtdb = (dns_rbtdb_t *)db;
6676 REQUIRE(VALID_RBTDB(rbtdb));
6678 RWLOCK(&rbtdb->tree_lock, isc_rwlocktype_read);
6679 count = dns_rbt_nodecount(rbtdb->tree);
6680 RWUNLOCK(&rbtdb->tree_lock, isc_rwlocktype_read);
6687 dns_rbtdb_t *rbtdb;
6689 rbtdb = (dns_rbtdb_t *)db;
6691 REQUIRE(VALID_RBTDB(rbtdb));
6693 RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_write);
6694 if (rbtdb->task != NULL)
6695 isc_task_detach(&rbtdb->task);
6697 isc_task_attach(task, &rbtdb->task);
6698 RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_write);
6709 dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
6713 REQUIRE(VALID_RBTDB(rbtdb));
6717 onode = (dns_rbtnode_t *)rbtdb->origin_node;
6719 NODE_STRONGLOCK(&rbtdb->node_locks[onode->locknum].lock);
6720 new_reference(rbtdb, onode);
6721 NODE_STRONGUNLOCK(&rbtdb->node_locks[onode->locknum].lock);
6723 *nodep = rbtdb->origin_node;
6725 INSIST(IS_CACHE(rbtdb));
6737 dns_rbtdb_t *rbtdb;
6741 rbtdb = (dns_rbtdb_t *)db;
6743 REQUIRE(VALID_RBTDB(rbtdb));
6744 INSIST(rbtversion == NULL || rbtversion->rbtdb == rbtdb);
6746 RWLOCK(&rbtdb->tree_lock, isc_rwlocktype_read);
6749 rbtversion = rbtdb->current_version;
6767 RWUNLOCK(&rbtdb->tree_lock, isc_rwlocktype_read);
6774 dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
6779 REQUIRE(VALID_RBTDB(rbtdb));
6780 REQUIRE(!IS_CACHE(rbtdb));
6786 NODE_LOCK(&rbtdb->node_locks[header->node->locknum].lock,
6794 isc_heap_delete(rbtdb->heaps[header->node->locknum],
6798 isc_heap_increased(rbtdb->heaps[header->node->locknum],
6801 isc_heap_decreased(rbtdb->heaps[header->node->locknum],
6805 result = resign_insert(rbtdb, header->node->locknum, header);
6807 NODE_UNLOCK(&rbtdb->node_locks[header->node->locknum].lock,
6816 dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
6822 REQUIRE(VALID_RBTDB(rbtdb));
6824 RWLOCK(&rbtdb->tree_lock, isc_rwlocktype_read);
6826 for (i = 0; i < rbtdb->node_lock_count; i++) {
6827 NODE_LOCK(&rbtdb->node_locks[i].lock, isc_rwlocktype_read);
6828 this = isc_heap_element(rbtdb->heaps[i], 1);
6830 NODE_UNLOCK(&rbtdb->node_locks[i].lock,
6838 NODE_UNLOCK(&rbtdb->node_locks[locknum].lock,
6842 NODE_UNLOCK(&rbtdb->node_locks[i].lock,
6849 bind_rdataset(rbtdb, header->node, header, 0, rdataset);
6854 NODE_UNLOCK(&rbtdb->node_locks[header->node->locknum].lock,
6860 RWUNLOCK(&rbtdb->tree_lock, isc_rwlocktype_read);
6869 dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
6873 REQUIRE(VALID_RBTDB(rbtdb));
6876 REQUIRE(rbtdb->future_version == rbtversion);
6879 REQUIRE(rbtversion->rbtdb == rbtdb);
6887 RWLOCK(&rbtdb->tree_lock, isc_rwlocktype_write);
6888 NODE_LOCK(&rbtdb->node_locks[node->locknum].lock,
6894 new_reference(rbtdb, node);
6895 isc_heap_delete(rbtdb->heaps[node->locknum], header->heap_index);
6899 NODE_UNLOCK(&rbtdb->node_locks[node->locknum].lock,
6901 RWUNLOCK(&rbtdb->tree_lock, isc_rwlocktype_write);
6906 dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
6908 REQUIRE(VALID_RBTDB(rbtdb));
6909 REQUIRE(IS_CACHE(rbtdb)); /* current restriction */
6911 return (rbtdb->rrsetstats);
7002 dns_rbtdb_t *rbtdb;
7012 rbtdb = isc_mem_get(mctx, sizeof(*rbtdb));
7013 if (rbtdb == NULL)
7022 memset(rbtdb, '\0', sizeof(*rbtdb));
7023 dns_name_init(&rbtdb->common.origin, NULL);
7024 rbtdb->common.attributes = 0;
7026 rbtdb->common.methods = &cache_methods;
7027 rbtdb->common.attributes |= DNS_DBATTR_CACHE;
7029 rbtdb->common.methods = &zone_methods;
7030 rbtdb->common.attributes |= DNS_DBATTR_STUB;
7032 rbtdb->common.methods = &zone_methods;
7033 rbtdb->common.rdclass = rdclass;
7034 rbtdb->common.mctx = NULL;
7036 result = RBTDB_INITLOCK(&rbtdb->lock);
7040 result = isc_rwlock_init(&rbtdb->tree_lock, 0, 0);
7050 if (rbtdb->node_lock_count == 0) {
7051 if (IS_CACHE(rbtdb))
7052 rbtdb->node_lock_count = DEFAULT_CACHE_NODE_LOCK_COUNT;
7054 rbtdb->node_lock_count = DEFAULT_NODE_LOCK_COUNT;
7055 } else if (rbtdb->node_lock_count < 2 && IS_CACHE(rbtdb)) {
7059 INSIST(rbtdb->node_lock_count < (1 << DNS_RBT_LOCKLENGTH));
7060 rbtdb->node_locks = isc_mem_get(mctx, rbtdb->node_lock_count *
7062 if (rbtdb->node_locks == NULL) {
7067 rbtdb->rrsetstats = NULL;
7068 if (IS_CACHE(rbtdb)) {
7069 result = dns_rdatasetstats_create(mctx, &rbtdb->rrsetstats);
7072 rbtdb->rdatasets = isc_mem_get(mctx, rbtdb->node_lock_count *
7074 if (rbtdb->rdatasets == NULL) {
7078 for (i = 0; i < (int)rbtdb->node_lock_count; i++)
7079 ISC_LIST_INIT(rbtdb->rdatasets[i]);
7081 rbtdb->rdatasets = NULL;
7086 rbtdb->heaps = isc_mem_get(hmctx, rbtdb->node_lock_count *
7088 if (rbtdb->heaps == NULL) {
7092 for (i = 0; i < (int)rbtdb->node_lock_count; i++)
7093 rbtdb->heaps[i] = NULL;
7094 sooner = IS_CACHE(rbtdb) ? ttl_sooner : resign_sooner;
7095 for (i = 0; i < (int)rbtdb->node_lock_count; i++) {
7097 &rbtdb->heaps[i]);
7105 rbtdb->deadnodes = isc_mem_get(mctx, rbtdb->node_lock_count *
7107 if (rbtdb->deadnodes == NULL) {
7111 for (i = 0; i < (int)rbtdb->node_lock_count; i++)
7112 ISC_LIST_INIT(rbtdb->deadnodes[i]);
7114 rbtdb->active = rbtdb->node_lock_count;
7116 for (i = 0; i < (int)(rbtdb->node_lock_count); i++) {
7117 result = NODE_INITLOCK(&rbtdb->node_locks[i].lock);
7119 result = isc_refcount_init(&rbtdb->node_locks[i].references, 0);
7121 NODE_DESTROYLOCK(&rbtdb->node_locks[i].lock);
7125 NODE_DESTROYLOCK(&rbtdb->node_locks[i].lock);
7126 isc_refcount_decrement(&rbtdb->node_locks[i].references, NULL);
7127 isc_refcount_destroy(&rbtdb->node_locks[i].references);
7131 rbtdb->node_locks[i].exiting = ISC_FALSE;
7139 isc_mem_attach(mctx, &rbtdb->common.mctx);
7140 isc_mem_attach(hmctx, &rbtdb->hmctx);
7145 isc_ondestroy_init(&rbtdb->common.ondest);
7150 result = dns_name_dupwithoffsets(origin, mctx, &rbtdb->common.origin);
7152 free_rbtdb(rbtdb, ISC_FALSE, NULL);
7159 result = dns_rbt_create(mctx, delete_callback, rbtdb, &rbtdb->tree);
7161 free_rbtdb(rbtdb, ISC_FALSE, NULL);
7165 result = dns_rbt_create(mctx, delete_callback, rbtdb, &rbtdb->nsec3);
7167 free_rbtdb(rbtdb, ISC_FALSE, NULL);
7184 if (!IS_CACHE(rbtdb)) {
7187 rbtdb->origin_node = NULL;
7188 result = dns_rbt_addnode(rbtdb->tree, &rbtdb->common.origin,
7189 &rbtdb->origin_node);
7192 free_rbtdb(rbtdb, ISC_FALSE, NULL);
7195 rbtdb->origin_node->nsec3 = 0;
7200 dns_rbt_namefromnode(rbtdb->origin_node, &name);
7202 rbtdb->origin_node->locknum =
7203 rbtdb->origin_node->hashval %
7204 rbtdb->node_lock_count;
7206 rbtdb->origin_node->locknum =
7208 rbtdb->node_lock_count;
7216 result = dns_rbt_addnode(rbtdb->nsec3, &rbtdb->common.origin,
7220 free_rbtdb(rbtdb, ISC_FALSE, NULL);
7231 rbtdb->node_lock_count;
7234 rbtdb->node_lock_count;
7241 result = isc_refcount_init(&rbtdb->references, 1);
7243 free_rbtdb(rbtdb, ISC_FALSE, NULL);
7246 rbtdb->attributes = 0;
7247 rbtdb->task = NULL;
7252 rbtdb->current_serial = 1;
7253 rbtdb->least_serial = 1;
7254 rbtdb->next_serial = 2;
7255 rbtdb->current_version = allocate_version(mctx, 1, 1, ISC_FALSE);
7256 if (rbtdb->current_version == NULL) {
7257 isc_refcount_decrement(&rbtdb->references, NULL);
7258 isc_refcount_destroy(&rbtdb->references);
7259 free_rbtdb(rbtdb, ISC_FALSE, NULL);
7262 rbtdb->current_version->rbtdb = rbtdb;
7263 rbtdb->current_version->secure = dns_db_insecure;
7264 rbtdb->current_version->havensec3 = ISC_FALSE;
7265 rbtdb->current_version->flags = 0;
7266 rbtdb->current_version->iterations = 0;
7267 rbtdb->current_version->hash = 0;
7268 rbtdb->current_version->salt_length = 0;
7269 memset(rbtdb->current_version->salt, 0,
7270 sizeof(rbtdb->current_version->salt));
7271 rbtdb->future_version = NULL;
7272 ISC_LIST_INIT(rbtdb->open_versions);
7277 PREPEND(rbtdb->open_versions, rbtdb->current_version, link);
7279 rbtdb->common.magic = DNS_DB_MAGIC;
7280 rbtdb->common.impmagic = RBTDB_MAGIC;
7282 *dbp = (dns_db_t *)rbtdb;
7287 isc_mem_put(mctx, rbtdb->deadnodes,
7288 rbtdb->node_lock_count * sizeof(rbtnodelist_t));
7291 if (rbtdb->heaps != NULL) {
7292 for (i = 0 ; i < (int)rbtdb->node_lock_count ; i++)
7293 if (rbtdb->heaps[i] != NULL)
7294 isc_heap_destroy(&rbtdb->heaps[i]);
7295 isc_mem_put(hmctx, rbtdb->heaps,
7296 rbtdb->node_lock_count * sizeof(isc_heap_t *));
7300 if (rbtdb->rdatasets != NULL)
7301 isc_mem_put(mctx, rbtdb->rdatasets, rbtdb->node_lock_count *
7304 if (rbtdb->rrsetstats != NULL)
7305 dns_stats_detach(&rbtdb->rrsetstats);
7308 isc_mem_put(mctx, rbtdb->node_locks,
7309 rbtdb->node_lock_count * sizeof(rbtdb_nodelock_t));
7312 isc_rwlock_destroy(&rbtdb->tree_lock);
7315 RBTDB_DESTROYLOCK(&rbtdb->lock);
7318 isc_mem_put(mctx, rbtdb, sizeof(*rbtdb));
7564 dns_rbtdb_t *rbtdb = rdataset->private1;
7569 NODE_LOCK(&rbtdb->node_locks[rbtnode->locknum].lock,
7572 NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock,
7578 dns_rbtdb_t *rbtdb = rdataset->private1;
7583 NODE_LOCK(&rbtdb->node_locks[rbtnode->locknum].lock,
7585 expire_header(rbtdb, header, ISC_FALSE);
7586 NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock,
7613 dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)(rbtiterator->common.db);
7620 if (IS_CACHE(rbtdb)) {
7628 NODE_LOCK(&rbtdb->node_locks[rbtnode->locknum].lock,
7656 NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock,
7670 dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)(rbtiterator->common.db);
7683 if (IS_CACHE(rbtdb)) {
7691 NODE_LOCK(&rbtdb->node_locks[rbtnode->locknum].lock,
7733 NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock,
7747 dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)(rbtiterator->common.db);
7754 NODE_LOCK(&rbtdb->node_locks[rbtnode->locknum].lock,
7757 bind_rdataset(rbtdb, rbtnode, header, rbtiterator->common.now,
7760 NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock,
7771 dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)rbtdbiter->common.db;
7778 reactivate_node(rbtdb, node, rbtdbiter->tree_locked);
7783 dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)rbtdbiter->common.db;
7790 lock = &rbtdb->node_locks[node->locknum].lock;
7792 decrement_reference(rbtdb, node, 0, isc_rwlocktype_read,
7802 dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)rbtdbiter->common.db;
7818 dns_rbt_nodecount(rbtdb->tree));
7821 RWUNLOCK(&rbtdb->tree_lock, isc_rwlocktype_read);
7824 RWLOCK(&rbtdb->tree_lock, isc_rwlocktype_write);
7829 lock = &rbtdb->node_locks[node->locknum].lock;
7832 decrement_reference(rbtdb, node, 0,
7840 RWUNLOCK(&rbtdb->tree_lock, isc_rwlocktype_write);
7842 RWLOCK(&rbtdb->tree_lock, isc_rwlocktype_read);
7853 dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)rbtdbiter->common.db;
7858 RWLOCK(&rbtdb->tree_lock, isc_rwlocktype_read);
7867 dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)rbtdbiter->common.db;
7871 RWUNLOCK(&rbtdb->tree_lock, isc_rwlocktype_read);
7895 dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)iterator->db;
7915 rbtdb->nsec3, name, origin);
7919 rbtdb->tree, name, origin);
7923 rbtdb->nsec3, name,
7948 dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)iterator->db;
7969 rbtdb->nsec3, name, origin);
7973 result = dns_rbtnodechain_last(rbtdbiter->current, rbtdb->tree,
7997 dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)iterator->db;
8017 result = dns_rbt_findnode(rbtdb->nsec3, name, NULL,
8023 result = dns_rbt_findnode(rbtdb->tree, name, NULL,
8032 result = dns_rbt_findnode(rbtdb->tree, name, NULL,
8038 tresult = dns_rbt_findnode(rbtdb->nsec3, name, NULL,
8091 dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)iterator->db;
8109 result = dns_rbtnodechain_last(rbtdbiter->current, rbtdb->tree,
8136 dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)iterator->db;
8154 rbtdb->nsec3, name, origin);
8178 dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)iterator->db;
8202 NODE_STRONGLOCK(&rbtdb->node_locks[node->locknum].lock);
8203 new_reference(rbtdb, node);
8204 NODE_STRONGUNLOCK(&rbtdb->node_locks[node->locknum].lock);
8228 NODE_STRONGLOCK(&rbtdb->node_locks[node->locknum].lock);
8231 NODE_STRONGUNLOCK(&rbtdb->node_locks[node->locknum].lock);
8240 dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)iterator->db;
8254 RWUNLOCK(&rbtdb->tree_lock, isc_rwlocktype_read);
8285 dns_rbtdb_t *rbtdb = rdataset->private1;
8308 nodelock = &rbtdb->node_locks[rbtnode->locknum].lock;
8353 dns_rbtdb_t *rbtdb;
8367 rbtdb = (dns_rbtdb_t *)cbarg->db;
8370 nodelock = &rbtdb->node_locks[rbtnode->locknum].lock;
8389 isc_mem_put(rbtdb->common.mctx, cbarg, sizeof(acache_cbarg_t));
8395 dns_db_detachnode((dns_db_t *)rbtdb, (dns_dbnode_t **)(void*)&rbtnode);
8396 dns_db_detach((dns_db_t **)(void*)&rbtdb);
8430 dns_rbtdb_t *rbtdb = rdataset->private1;
8453 newcbarg = isc_mem_get(rbtdb->common.mctx, sizeof(*newcbarg));
8460 dns_db_attach((dns_db_t *)rbtdb, &newcbarg->db);
8462 dns_db_attachnode((dns_db_t *)rbtdb, (dns_dbnode_t *)rbtnode,
8465 result = dns_acache_createentry(acache, (dns_db_t *)rbtdb,
8476 nodelock = &rbtdb->node_locks[rbtnode->locknum].lock;
8494 acarray = isc_mem_get(rbtdb->common.mctx, total_count *
8533 acache_cancelentry(rbtdb->common.mctx, oldentry, &oldcbarg);
8542 acache_cancelentry(rbtdb->common.mctx, newentry,
8546 dns_db_detachnode((dns_db_t *)rbtdb, &newcbarg->node);
8548 isc_mem_put(rbtdb->common.mctx, newcbarg,
8560 dns_rbtdb_t *rbtdb = rdataset->private1;
8586 nodelock = &rbtdb->node_locks[rbtnode->locknum].lock;
8619 acache_cancelentry(rbtdb->common.mctx, entry, &cbarg);
8682 update_header(dns_rbtdb_t *rbtdb, rdatasetheader_t *header,
8685 INSIST(IS_CACHE(rbtdb));
8690 ISC_LIST_UNLINK(rbtdb->rdatasets[header->node->locknum], header, link);
8692 ISC_LIST_PREPEND(rbtdb->rdatasets[header->node->locknum], header, link);
8706 overmem_purge(dns_rbtdb_t *rbtdb, unsigned int locknum_start,
8713 for (locknum = (locknum_start + 1) % rbtdb->node_lock_count;
8715 locknum = (locknum + 1) % rbtdb->node_lock_count) {
8716 NODE_LOCK(&rbtdb->node_locks[locknum].lock,
8719 header = isc_heap_element(rbtdb->heaps[locknum], 1);
8721 expire_header(rbtdb, header, tree_locked);
8725 for (header = ISC_LIST_TAIL(rbtdb->rdatasets[locknum]);
8736 ISC_LIST_UNLINK(rbtdb->rdatasets[locknum], header,
8738 expire_header(rbtdb, header, tree_locked);
8742 NODE_UNLOCK(&rbtdb->node_locks[locknum].lock,
8748 expire_header(dns_rbtdb_t *rbtdb, rdatasetheader_t *header,
8751 set_ttl(rbtdb, header, 0);
8765 new_reference(rbtdb, header->node);
8766 decrement_reference(rbtdb, header->node, 0,