Lines Matching defs:adb
1 /* $NetBSD: adb.c,v 1.1 2024/02/18 20:57:30 christos Exp $ */
38 #include <dns/adb.h>
76 * The period in seconds after which an ADB name entry is regarded as stale
99 /*% dns adb structure */
174 dns_adb_t *adb;
320 print_namehook_list(FILE *, const char *legend, dns_adb_t *adb,
421 * Note: since we have removed the support of A6 in adb, FETCH_A and FETCH_AAAA
519 inc_stats(dns_adb_t *adb, isc_statscounter_t counter) {
520 if (adb->view->resstats != NULL) {
521 isc_stats_increment(adb->view->resstats, counter);
526 * Set adb-related statistics counters.
529 set_adbstat(dns_adb_t *adb, uint64_t val, isc_statscounter_t counter) {
530 if (adb->view->adbstats != NULL) {
531 isc_stats_set(adb->view->adbstats, val, counter);
536 dec_adbstats(dns_adb_t *adb, isc_statscounter_t counter) {
537 if (adb->view->adbstats != NULL) {
538 isc_stats_decrement(adb->view->adbstats, counter);
543 inc_adbstats(dns_adb_t *adb, isc_statscounter_t counter) {
544 if (adb->view->adbstats != NULL) {
545 adb->view->adbstats, counter);
579 dns_adb_t *adb;
589 adb = ev->ev_arg;
590 INSIST(DNS_ADB_VALID(adb));
600 while (nbuckets[i] != 0 && adb->nentries >= nbuckets[i]) {
609 DP(ISC_LOG_INFO, "adb: grow_entries to %u starting", n);
614 for (i = 0; i < adb->nentries; i++) {
615 if (adb->entry_sd[i]) {
627 newentries = isc_mem_get(adb->mctx, sizeof(*newentries) * n);
628 newdeadentries = isc_mem_get(adb->mctx, sizeof(*newdeadentries) * n);
629 newentrylocks = isc_mem_get(adb->mctx, sizeof(*newentrylocks) * n);
630 newentry_sd = isc_mem_get(adb->mctx, sizeof(*newentry_sd) * n);
631 newentry_refcnt = isc_mem_get(adb->mctx, sizeof(*newentry_refcnt) * n);
643 adb->irefcnt++;
649 for (i = 0; i < adb->nentries; i++) {
650 e = ISC_LIST_HEAD(adb->entries[i]);
652 ISC_LIST_UNLINK(adb->entries[i], e, plink);
656 INSIST(adb->entry_refcnt[i] > 0);
657 adb->entry_refcnt[i]--;
659 e = ISC_LIST_HEAD(adb->entries[i]);
661 e = ISC_LIST_HEAD(adb->deadentries[i]);
663 ISC_LIST_UNLINK(adb->deadentries[i], e, plink);
667 INSIST(adb->entry_refcnt[i] > 0);
668 adb->entry_refcnt[i]--;
670 e = ISC_LIST_HEAD(adb->deadentries[i]);
672 INSIST(adb->entry_refcnt[i] == 0);
673 adb->irefcnt--;
679 isc_mutexblock_destroy(adb->entrylocks, adb->nentries);
680 isc_mem_put(adb->mctx, adb->entries,
681 sizeof(*adb->entries) * adb->nentries);
682 isc_mem_put(adb->mctx, adb->deadentries,
683 sizeof(*adb->deadentries) * adb->nentries);
684 isc_mem_put(adb->mctx, adb->entrylocks,
685 sizeof(*adb->entrylocks) * adb->nentries);
686 isc_mem_put(adb->mctx, adb->entry_sd,
687 sizeof(*adb->entry_sd) * adb->nentries);
688 isc_mem_put(adb->mctx, adb->entry_refcnt,
689 sizeof(*adb->entry_refcnt) * adb->nentries);
694 adb->entries = newentries;
695 adb->deadentries = newdeadentries;
696 adb->entrylocks = newentrylocks;
697 adb->entry_sd = newentry_sd;
698 adb->entry_refcnt = newentry_refcnt;
699 adb->nentries = n;
701 set_adbstat(adb, adb->nentries, dns_adbstats_nentries);
704 * Only on success do we set adb->growentries_sent to false.
707 adb->growentries_sent = false;
712 isc_mem_put(adb->mctx, newentries, sizeof(*newentries) * n);
715 isc_mem_put(adb->mctx, newdeadentries,
719 isc_mem_put(adb->mctx, newentrylocks,
723 isc_mem_put(adb->mctx, newentry_sd, sizeof(*newentry_sd) * n);
726 isc_mem_put(adb->mctx, newentry_refcnt,
733 LOCK(&adb->lock);
734 if (dec_adb_irefcnt(adb)) {
735 check_exit(adb);
737 UNLOCK(&adb->lock);
738 DP(ISC_LOG_INFO, "adb: grow_entries finished");
743 dns_adb_t *adb;
754 adb = ev->ev_arg;
755 INSIST(DNS_ADB_VALID(adb));
765 while (nbuckets[i] != 0 && adb->nnames >= nbuckets[i]) {
774 DP(ISC_LOG_INFO, "adb: grow_names to %u starting", n);
779 for (i = 0; i < adb->nnames; i++) {
780 if (adb->name_sd[i]) {
792 newnames = isc_mem_get(adb->mctx, sizeof(*newnames) * n);
793 newdeadnames = isc_mem_get(adb->mctx, sizeof(*newdeadnames) * n);
794 newnamelocks = isc_mem_get(adb->mctx, sizeof(*newnamelocks) * n);
795 newname_sd = isc_mem_get(adb->mctx, sizeof(*newname_sd) * n);
796 newname_refcnt = isc_mem_get(adb->mctx, sizeof(*newname_refcnt) * n);
808 adb->irefcnt++;
814 for (i = 0; i < adb->nnames; i++) {
815 name = ISC_LIST_HEAD(adb->names[i]);
817 ISC_LIST_UNLINK(adb->names[i], name, plink);
821 INSIST(adb->name_refcnt[i] > 0);
822 adb->name_refcnt[i]--;
824 name = ISC_LIST_HEAD(adb->names[i]);
826 name = ISC_LIST_HEAD(adb->deadnames[i]);
828 ISC_LIST_UNLINK(adb->deadnames[i], name, plink);
832 INSIST(adb->name_refcnt[i] > 0);
833 adb->name_refcnt[i]--;
835 name = ISC_LIST_HEAD(adb->deadnames[i]);
837 INSIST(adb->name_refcnt[i] == 0);
838 adb->irefcnt--;
844 isc_mutexblock_destroy(adb->namelocks, adb->nnames);
845 isc_mem_put(adb->mctx, adb->names, sizeof(*adb->names) * adb->nnames);
846 isc_mem_put(adb->mctx, adb->deadnames,
847 sizeof(*adb->deadnames) * adb->nnames);
848 isc_mem_put(adb->mctx, adb->namelocks,
849 sizeof(*adb->namelocks) * adb->nnames);
850 isc_mem_put(adb->mctx, adb->name_sd,
851 sizeof(*adb->name_sd) * adb->nnames);
852 isc_mem_put(adb->mctx, adb->name_refcnt,
853 sizeof(*adb->name_refcnt) * adb->nnames);
858 adb->names = newnames;
859 adb->deadnames = newdeadnames;
860 adb->namelocks = newnamelocks;
861 adb->name_sd = newname_sd;
862 adb->name_refcnt = newname_refcnt;
863 adb->nnames = n;
865 set_adbstat(adb, adb->nnames, dns_adbstats_nnames);
868 * Only on success do we set adb->grownames_sent to false.
871 adb->grownames_sent = false;
876 isc_mem_put(adb->mctx, newnames, sizeof(*newnames) * n);
879 isc_mem_put(adb->mctx, newdeadnames, sizeof(*newdeadnames) * n);
882 isc_mem_put(adb->mctx, newnamelocks, sizeof(*newnamelocks) * n);
885 isc_mem_put(adb->mctx, newname_sd, sizeof(*newname_sd) * n);
888 isc_mem_put(adb->mctx, newname_refcnt,
895 LOCK(&adb->lock);
896 if (dec_adb_irefcnt(adb)) {
897 check_exit(adb);
899 UNLOCK(&adb->lock);
900 DP(ISC_LOG_INFO, "adb: grow_names finished");
912 dns_adb_t *adb;
927 adb = adbname->adb;
928 INSIST(DNS_ADB_VALID(adb));
959 nh = new_adbnamehook(adb, NULL);
966 foundentry = find_entry_and_lock(adb, &sockaddr, &addr_bucket,
971 entry = new_adbentry(adb);
984 link_entry(adb, addr_bucket, entry);
998 free_adbnamehook(adb, &nh);
1012 free_adbnamehook(adb, &nh);
1016 UNLOCK(&adb->entrylocks[addr_bucket]);
1063 dns_adb_t *adb;
1069 adb = name->adb;
1070 INSIST(DNS_ADB_VALID(adb));
1079 result = unlink_name(adb, name);
1080 free_adbname(adb, &name);
1082 result = dec_adb_irefcnt(adb);
1092 result4 = clean_namehooks(adb, &name->v4);
1093 result6 = clean_namehooks(adb, &name->v6);
1094 clean_target(adb, &name->target);
1103 result = unlink_name(adb, name);
1104 free_adbname(adb, &name);
1106 result = dec_adb_irefcnt(adb);
1112 ISC_LIST_UNLINK(adb->names[bucket], name, plink);
1113 ISC_LIST_APPEND(adb->deadnames[bucket], name, plink);
1125 dns_adb_t *adb;
1130 adb = name->adb;
1131 INSIST(DNS_ADB_VALID(adb));
1139 result4 = clean_namehooks(adb, &name->v4);
1152 result6 = clean_namehooks(adb, &name->v6);
1163 clean_target(adb, &name->target);
1173 link_name(dns_adb_t *adb, int bucket, dns_adbname_t *name) {
1176 ISC_LIST_PREPEND(adb->names[bucket], name, plink);
1178 adb->name_refcnt[bucket]++;
1185 unlink_name(dns_adb_t *adb, dns_adbname_t *name) {
1193 ISC_LIST_UNLINK(adb->deadnames[bucket], name, plink);
1195 ISC_LIST_UNLINK(adb->names[bucket], name, plink);
1198 INSIST(adb->name_refcnt[bucket] > 0);
1199 adb->name_refcnt[bucket]--;
1200 if (adbadb->name_refcnt[bucket] == 0) {
1210 link_entry(dns_adb_t *adb, int bucket, dns_adbentry_t *entry) {
1214 if (isc_mem_isovermem(adb->mctx)) {
1216 e = ISC_LIST_TAIL(adb->entries[bucket]);
1221 unlink_entry(adb, e);
1222 free_adbentry(adb, &e);
1227 ISC_LIST_UNLINK(adb->entries[bucket], e, plink);
1228 ISC_LIST_PREPEND(adb->deadentries[bucket], e, plink);
1232 ISC_LIST_PREPEND(adb->entries[bucket], entry, plink);
1234 adb->entry_refcnt[bucket]++;
1241 unlink_entry(dns_adb_t *adb, dns_adbentry_t *entry) {
1249 ISC_LIST_UNLINK(adb->deadentries[bucket], entry, plink);
1251 ISC_LIST_UNLINK(adb->entries[bucket], entry, plink);
1254 INSIST(adb->entry_refcnt[bucket] > 0);
1255 adb->entry_refcnt[bucket]--;
1256 if (adb->entry_sd[bucket] && adb->entry_refcnt[bucket] == 0) {
1272 * The ADB _MUST_ be locked before calling. Also, exit conditions must be
1276 shutdown_names(dns_adb_t *adb) {
1282 for (bucket = 0; bucket < adb->nnames; bucket++) {
1283 LOCK(&adb->namelocks[bucket]);
1284 adb->name_sd[bucket] = true;
1286 name = ISC_LIST_HEAD(adb->names[bucket]);
1294 result = dec_adb_irefcnt(adb);
1311 UNLOCK(&adb->namelocks[bucket]);
1317 * The ADB _MUST_ be locked before calling. Also, exit conditions must be
1321 shutdown_entries(dns_adb_t *adb) {
1327 for (bucket = 0; bucket < adb->nentries; bucket++) {
1328 LOCK(&adb->entrylocks[bucket]);
1329 adb->entry_sd[bucket] = true;
1331 entry = ISC_LIST_HEAD(adb->entries[bucket]);
1332 if (adb->entry_refcnt[bucket] == 0) {
1338 result = dec_adb_irefcnt(adb);
1347 result = unlink_entry(adb, entry);
1348 free_adbentry(adb, &entry);
1350 result = dec_adb_irefcnt(adb);
1357 UNLOCK(&adb->entrylocks[bucket]);
1380 clean_namehooks(dns_adb_t *adb, dns_adbnamehooklist_t *namehooks) {
1385 bool overmem = isc_mem_isovermem(adb->mctx);
1401 UNLOCK(&adb->entrylocks[addr_bucket]);
1405 LOCK(&adb->entrylocks[addr_bucket]);
1409 result = dec_entry_refcnt(adb, overmem, entry, false);
1417 free_adbnamehook(adb, &namehook);
1423 UNLOCK(&adb->entrylocks[addr_bucket]);
1429 clean_target(dns_adb_t *adb, dns_name_t *target) {
1431 dns_name_free(target, adb->mctx);
1437 set_target(dns_adb_t *adb, const dns_name_t *name, const dns_name_t *fname,
1464 dns_name_dup(&cname.cname, adb->mctx, target);
1496 dns_name_dup(new_target, adb->mctx, target);
1604 check_exit(dns_adb_t *adb) {
1607 * The caller must be holding the adb lock.
1609 if (adb->shutting_down) {
1614 INSIST(!adb->cevent_out); /* Sanity check. */
1615 ISC_EVENT_INIT(&adb->cevent, sizeof(adb->cevent), 0, NULL,
1616 DNS_EVENT_ADBCONTROL, shutdown_task, adb, adb,
1618 event = &adb->cevent;
1619 isc_task_send(adb->task, &event);
1620 adb->cevent_out = true;
1625 dec_adb_irefcnt(dns_adb_t *adb) {
1630 LOCK(&adb->reflock);
1632 INSIST(adb->irefcnt > 0);
1633 adb->irefcnt--;
1635 if (adb->irefcnt == 0) {
1636 event = ISC_LIST_HEAD(adb->whenshutdown);
1638 ISC_LIST_UNLINK(adb->whenshutdown, event, ev_link);
1640 event->ev_sender = adb;
1642 event = ISC_LIST_HEAD(adb->whenshutdown);
1646 if (adb->irefcnt == 0 && adb->erefcnt == 0) {
1649 UNLOCK(&adb->reflock);
1654 inc_adb_irefcnt(dns_adb_t *adb) {
1655 LOCK(&adb->reflock);
1656 adb->irefcnt++;
1657 UNLOCK(&adb->reflock);
1661 inc_adb_erefcnt(dns_adb_t *adb) {
1662 LOCK(&adb->reflock);
1663 adb->erefcnt++;
1664 UNLOCK(&adb->reflock);
1668 inc_entry_refcnt(dns_adb_t *adb, dns_adbentry_t *entry, bool lock) {
1674 LOCK(&adb->entrylocks[bucket]);
1680 UNLOCK(&adb->entrylocks[bucket]);
1685 dec_entry_refcnt(dns_adb_t *adb, bool overmem, dns_adbentry_t *entry,
1694 LOCK(&adb->entrylocks[bucket]);
1702 (adb->entry_sd[bucket] || entry->expires == 0 || overmem ||
1706 result = unlink_entry(adb, entry);
1710 UNLOCK(&adb->entrylocks[bucket]);
1719 free_adbentry(adb, &entry);
1721 result = dec_adb_irefcnt(adb);
1728 new_adbname(dns_adb_t *adb, const dns_name_t *dnsname) {
1731 name = isc_mem_get(adb->mctx, sizeof(*name));
1734 dns_name_dup(dnsname, adb->mctx, &name->name);
1737 name->adb = adb;
1754 LOCK(&adb->namescntlock);
1755 adb->namescnt++;
1756 inc_adbstats(adb, dns_adbstats_namescnt);
1757 if (!adb->grownames_sent && adb->excl != NULL &&
1758 adb->namescnt > (adb->nnames * 8))
1760 isc_event_t *event = &adb->grownames;
1761 inc_adb_irefcnt(adb);
1762 isc_task_send(adb->excl, &event);
1763 adb->grownames_sent = true;
1765 UNLOCK(&adb->namescntlock);
1771 free_adbname(dns_adb_t *adb, dns_adbname_t **name) {
1784 INSIST(n->adb == adb);
1787 dns_name_free(&n->name, adb->mctx);
1789 isc_mem_put(adb->mctx, n, sizeof(*n));
1790 LOCK(&adb->namescntlock);
1791 adb->namescnt--;
1792 dec_adbstats(adb, dns_adbstats_namescnt);
1793 UNLOCK(&adb->namescntlock);
1797 new_adbnamehook(dns_adb_t *adb, dns_adbentry_t *entry) {
1800 nh = isc_mem_get(adb->mctx, sizeof(*nh));
1801 isc_refcount_increment0(&adb->nhrefcnt);
1811 free_adbnamehook(dns_adb_t *adb, dns_adbnamehook_t **namehook) {
1823 isc_refcount_decrement(&adb->nhrefcnt);
1824 isc_mem_put(adb->mctx, nh, sizeof(*nh));
1828 new_adblameinfo(dns_adb_t *adb, const dns_name_t *qname,
1832 li = isc_mem_get(adb->mctx, sizeof(*li));
1835 dns_name_dup(qname, adb->mctx, &li->qname);
1845 free_adblameinfo(dns_adb_t *adb, dns_adblameinfo_t **lameinfo) {
1854 dns_name_free(&li->qname, adb->mctx);
1858 isc_mem_put(adb->mctx, li, sizeof(*li));
1862 new_adbentry(dns_adb_t *adb) {
1865 e = isc_mem_get(adb->mctx, sizeof(*e));
1889 atomic_init(&e->quota, adb->quota);
1893 LOCK(&adb->entriescntlock);
1894 adb->entriescnt++;
1895 inc_adbstats(adb, dns_adbstats_entriescnt);
1896 if (!adb->growentries_sent && adb->excl != NULL &&
1897 adb->entriescnt > (adb->nentries * 8))
1899 isc_event_t *event = &adb->growentries;
1900 inc_adb_irefcnt(adb);
1901 isc_task_send(adb->excl, &event);
1902 adb->growentries_sent = true;
1904 UNLOCK(&adb->entriescntlock);
1910 free_adbentry(dns_adb_t *adb, dns_adbentry_t **entry) {
1925 isc_mem_put(adb->mctx, e->cookie, e->cookielen);
1931 free_adblameinfo(adb, &li);
1935 isc_mem_put(adb->mctx, e, sizeof(*e));
1936 LOCK(&adb->entriescntlock);
1937 adb->entriescnt--;
1938 dec_adbstats(adb, dns_adbstats_entriescnt);
1939 UNLOCK(&adb->entriescntlock);
1943 new_adbfind(dns_adb_t *adb) {
1946 h = isc_mem_get(adb->mctx, sizeof(*h));
1947 isc_refcount_increment0(&adb->ahrefcnt);
1953 h->adb = adb;
1973 inc_adb_irefcnt(adb);
1979 new_adbfetch(dns_adb_t *adb) {
1982 f = isc_mem_get(adb->mctx, sizeof(*f));
1995 free_adbfetch(dns_adb_t *adb, dns_adbfetch_t **fetch) {
2008 isc_mem_put(adb->mctx, f, sizeof(*f));
2012 free_adbfind(dns_adb_t *adb, dns_adbfind_t **findp) {
2029 isc_refcount_decrement(&adb->ahrefcnt);
2030 isc_mem_put(adb->mctx, find, sizeof(*find));
2031 return (dec_adb_irefcnt(adb));
2040 new_adbaddrinfo(dns_adb_t *adb, dns_adbentry_t *entry, in_port_t port) {
2043 ai = isc_mem_get(adb->mctx, sizeof(*ai));
2058 free_adbaddrinfo(dns_adb_t *adb, dns_adbaddrinfo_t **ainfo) {
2070 isc_mem_put(adb->mctx, ai, sizeof(*ai));
2081 find_name_and_lock(dns_adb_t *adb, const dns_name_t *name, unsigned int options,
2086 bucket = dns_name_fullhash(name, false) % adb->nnames;
2089 LOCK(&adb->namelocks[bucket]);
2092 UNLOCK(&adb->namelocks[*bucketp]);
2093 LOCK(&adb->namelocks[bucket]);
2097 adbname = ISC_LIST_HEAD(adb->names[bucket]);
2124 find_entry_and_lock(dns_adb_t *adb, const isc_sockaddr_t *addr, int *bucketp,
2129 bucket = isc_sockaddr_hash(addr, true) % adb->nentries;
2132 LOCK(&adb->entrylocks[bucket]);
2135 UNLOCK(&adb->entrylocks[*bucketp]);
2136 LOCK(&adb->entrylocks[bucket]);
2141 for (entry = ISC_LIST_HEAD(adb->entries[bucket]); entry != NULL;
2145 (void)check_expire_entry(adb, &entry, now);
2150 ISC_LIST_UNLINK(adb->entries[bucket], entry, plink);
2151 ISC_LIST_PREPEND(adb->entries[bucket], entry, plink);
2163 entry_is_lame(dns_adb_t *adb, dns_adbentry_t *entry, const dns_name_t *qname,
2182 free_adblameinfo(adb, &li);
2219 "adb: quota %s (%" PRIuFAST32 "/%" PRIuFAST32 "): %s",
2225 copy_namehook_lists(dns_adb_t *adb, dns_adbfind_t *find,
2241 LOCK(&adb->entrylocks[bucket]);
2250 entry_is_lame(adb, entry, qname, qtype, now))
2255 addrinfo = new_adbaddrinfo(adb, entry, find->port);
2263 inc_entry_refcnt(adb, entry, false);
2267 UNLOCK(&adb->entrylocks[bucket]);
2279 LOCK(&adb->entrylocks[bucket]);
2288 entry_is_lame(adb, entry, qname, qtype, now))
2293 addrinfo = new_adbaddrinfo(adb, entry, find->port);
2301 inc_entry_refcnt(adb, entry, false);
2305 UNLOCK(&adb->entrylocks[bucket]);
2313 UNLOCK(&adb->entrylocks[bucket]);
2319 dns_adb_t *adb;
2323 adb = ev->ev_arg;
2324 INSIST(DNS_ADB_VALID(adb));
2330 LOCK(&adb->lock);
2331 UNLOCK(&adb->lock);
2332 destroy(adb);
2336 * Name bucket must be locked; adb may be locked; no other locks held.
2377 * (unused for some period); if so, the name entry will be freed. If the ADB
2382 * to lock ADB (if it's not locked).
2384 * Name bucket must be locked; adb may be locked; no other locks held.
2387 check_stale_name(dns_adb_t *adb, int bucket, isc_stdtime_t now) {
2390 bool overmem = isc_mem_isovermem(adb->mctx);
2403 victim = ISC_LIST_TAIL(adb->names[bucket]);
2432 * Entry bucket must be locked; adb may be locked; no other locks held.
2435 check_expire_entry(dns_adb_t *adb, dns_adbentry_t **entryp, isc_stdtime_t now) {
2456 result = unlink_entry(adb, entry);
2457 free_adbentry(adb, &entry);
2459 dec_adb_irefcnt(adb);
2465 * ADB must be locked, and no other locks held.
2468 cleanup_names(dns_adb_t *adb, int bucket, isc_stdtime_t now) {
2475 LOCK(&adb->namelocks[bucket]);
2476 if (adb->name_sd[bucket]) {
2477 UNLOCK(&adb->namelocks[bucket]);
2481 name = ISC_LIST_HEAD(adb->names[bucket]);
2491 UNLOCK(&adb->namelocks[bucket]);
2496 * ADB must be locked, and no other locks held.
2499 cleanup_entries(dns_adb_t *adb, int bucket, isc_stdtime_t now) {
2505 LOCK(&adb->entrylocks[bucket]);
2506 entry = ISC_LIST_HEAD(adb->entries[bucket]);
2510 result = check_expire_entry(adb, &entry, now);
2513 UNLOCK(&adb->entrylocks[bucket]);
2518 destroy(dns_adb_t *adb) {
2519 adb->magic = 0;
2521 isc_task_detach(&adb->task);
2522 if (adb->excl != NULL) {
2523 isc_task_detach(&adb->excl);
2526 isc_mutexblock_destroy(adb->entrylocks, adb->nentries);
2527 isc_mem_put(adb->mctx, adb->entries,
2528 sizeof(*adb->entries) * adb->nentries);
2529 isc_mem_put(adb->mctx, adb->deadentries,
2530 sizeof(*adb->deadentries) * adb->nentries);
2531 isc_mem_put(adb->mctx, adb->entrylocks,
2532 sizeof(*adb->entrylocks) * adb->nentries);
2533 isc_mem_put(adb->mctx, adb->entry_sd,
2534 sizeof(*adb->entry_sd) * adb->nentries);
2535 isc_mem_put(adb->mctx, adb->entry_refcnt,
2536 sizeof(*adb->entry_refcnt) * adb->nentries);
2538 isc_mutexblock_destroy(adb->namelocks, adb->nnames);
2539 isc_mem_put(adb->mctx, adb->names, sizeof(*adb->names) * adb->nnames);
2540 isc_mem_put(adb->mctx, adb->deadnames,
2541 sizeof(*adb->deadnames) * adb->nnames);
2542 isc_mem_put(adb->mctx, adb->namelocks,
2543 sizeof(*adb->namelocks) * adb->nnames);
2544 isc_mem_put(adb->mctx, adb->name_sd,
2545 sizeof(*adb->name_sd) * adb->nnames);
2546 isc_mem_put(adb->mctx, adb->name_refcnt,
2547 sizeof(*adb->name_refcnt) * adb->nnames);
2549 isc_mutex_destroy(&adb->reflock);
2550 isc_mutex_destroy(&adb->lock);
2551 isc_mutex_destroy(&adb->overmemlock);
2552 isc_mutex_destroy(&adb->entriescntlock);
2553 isc_mutex_destroy(&adb->namescntlock);
2555 isc_mem_putanddetach(&adb->mctx, adb, sizeof(dns_adb_t));
2565 dns_adb_t *adb;
2577 adb = isc_mem_get(mem, sizeof(dns_adb_t));
2583 adb->magic = 0;
2584 adb->erefcnt = 1;
2585 adb->irefcnt = 0;
2586 adb->task = NULL;
2587 adb->excl = NULL;
2588 adb->mctx = NULL;
2589 adb->view = view;
2590 adb->taskmgr = taskmgr;
2591 adb->next_cleanbucket = 0;
2592 ISC_EVENT_INIT(&adb->cevent, sizeof(adb->cevent), 0, NULL, 0, NULL,
2594 adb->cevent_out = false;
2595 adb->shutting_down = false;
2596 ISC_LIST_INIT(adb->whenshutdown);
2598 adb->nentries = nbuckets[0];
2599 adb->entriescnt = 0;
2600 adb->entries = NULL;
2601 adb->deadentries = NULL;
2602 adb->entry_sd = NULL;
2603 adb->entry_refcnt = NULL;
2604 adb->entrylocks = NULL;
2605 ISC_EVENT_INIT(&adb->growentries, sizeof(adb->growentries), 0, NULL,
2606 DNS_EVENT_ADBGROWENTRIES, grow_entries, adb, adb, NULL,
2608 adb->growentries_sent = false;
2610 adb->quota = 0;
2611 adb->atr_freq = 0;
2612 adb->atr_low = 0.0;
2613 adb->atr_high = 0.0;
2614 adb->atr_discount = 0.0;
2616 adb->nnames = nbuckets[0];
2617 adb->namescnt = 0;
2618 adb->names = NULL;
2619 adb->deadnames = NULL;
2620 adb->name_sd = NULL;
2621 adb->name_refcnt = NULL;
2622 adb->namelocks = NULL;
2623 ISC_EVENT_INIT(&adb->grownames, sizeof(adb->grownames), 0, NULL,
2624 DNS_EVENT_ADBGROWNAMES, grow_names, adb, adb, NULL,
2626 adb->grownames_sent = false;
2628 result = isc_taskmgr_excltask(adb->taskmgr, &adb->excl);
2631 "adb: task-exclusive mode unavailable, "
2634 adb->nentries = nbuckets[11];
2635 adb->nnames = nbuckets[11];
2638 isc_mem_attach(mem, &adb->mctx);
2640 isc_mutex_init(&adb->lock);
2641 isc_mutex_init(&adb->reflock);
2642 isc_mutex_init(&adb->overmemlock);
2643 isc_mutex_init(&adb->entriescntlock);
2644 isc_mutex_init(&adb->namescntlock);
2646 #define ALLOCENTRY(adb, el) \
2648 (adb)->el = isc_mem_get((adb)->mctx, \
2649 sizeof(*(adb)->el) * (adb)->nentries); \
2651 ALLOCENTRY(adb, entries);
2652 ALLOCENTRY(adb, deadentries);
2653 ALLOCENTRY(adb, entrylocks);
2654 ALLOCENTRY(adb, entry_sd);
2655 ALLOCENTRY(adb, entry_refcnt);
2658 #define ALLOCNAME(adb, el) \
2660 (adb)->el = isc_mem_get((adb)->mctx, \
2661 sizeof(*(adb)->el) * (adb)->nnames); \
2663 ALLOCNAME(adb, names);
2664 ALLOCNAME(adb, deadnames);
2665 ALLOCNAME(adb, namelocks);
2666 ALLOCNAME(adb, name_sd);
2667 ALLOCNAME(adb, name_refcnt);
2674 isc_mutexblock_init(adb->namelocks, adb->nnames);
2676 for (i = 0; i < adb->nnames; i++) {
2677 ISC_LIST_INIT(adb->names[i]);
2678 ISC_LIST_INIT(adb->deadnames[i]);
2679 adb->name_sd[i] = false;
2680 adb->name_refcnt[i] = 0;
2681 adb->irefcnt++;
2683 for (i = 0; i < adb->nentries; i++) {
2684 ISC_LIST_INIT(adb->entries[i]);
2685 ISC_LIST_INIT(adb->deadentries[i]);
2686 adb->entry_sd[i] = false;
2687 adb->entry_refcnt[i] = 0;
2688 adb->irefcnt++;
2690 isc_mutexblock_init(adb->entrylocks, adb->nentries);
2692 isc_refcount_init(&adb->ahrefcnt, 0);
2693 isc_refcount_init(&adb->nhrefcnt, 0);
2698 result = isc_task_create(adb->taskmgr, 0, &adb->task);
2703 isc_task_setname(adb->task, "ADB", adb);
2705 result = isc_stats_create(adb->mctx, &view->adbstats, dns_adbstats_max);
2710 set_adbstat(adb, adb->nentries, dns_adbstats_nentries);
2711 set_adbstat(adb, adb->nnames, dns_adbstats_nnames);
2716 adb->magic = DNS_ADB_MAGIC;
2717 *newadb = adb;
2721 if (adb->task != NULL) {
2722 isc_task_detach(&adb->task);
2726 isc_mutexblock_destroy(adb->entrylocks, adb->nentries);
2727 isc_mutexblock_destroy(adb->namelocks, adb->nnames);
2729 if (adb->entries != NULL) {
2730 isc_mem_put(adb->mctx, adb->entries,
2731 sizeof(*adb->entries) * adb->nentries);
2733 if (adb->deadentries != NULL) {
2734 isc_mem_put(adb->mctx, adb->deadentries,
2735 sizeof(*adb->deadentries) * adb->nentries);
2737 if (adb->entrylocks != NULL) {
2738 isc_mem_put(adb->mctx, adb->entrylocks,
2739 sizeof(*adb->entrylocks) * adb->nentries);
2741 if (adb->entry_sd != NULL) {
2742 isc_mem_put(adb->mctx, adb->entry_sd,
2743 sizeof(*adb->entry_sd) * adb->nentries);
2745 if (adb->entry_refcnt != NULL) {
2746 isc_mem_put(adb->mctx, adb->entry_refcnt,
2747 sizeof(*adb->entry_refcnt) * adb->nentries);
2749 if (adb->names != NULL) {
2750 isc_mem_put(adb->mctx, adb->names,
2751 sizeof(*adb->names) * adb->nnames);
2753 if (adb->deadnames != NULL) {
2754 isc_mem_put(adb->mctx, adb->deadnames,
2755 sizeof(*adb->deadnames) * adb->nnames);
2757 if (adb->namelocks != NULL) {
2758 isc_mem_put(adb->mctx, adb->namelocks,
2759 sizeof(*adb->namelocks) * adb->nnames);
2761 if (adb->name_sd != NULL) {
2762 isc_mem_put(adb->mctx, adb->name_sd,
2763 sizeof(*adb->name_sd) * adb->nnames);
2765 if (adb->name_refcnt != NULL) {
2766 isc_mem_put(adb->mctx, adb->name_refcnt,
2767 sizeof(*adb->name_refcnt) * adb->nnames);
2770 isc_mutex_destroy(&adb->namescntlock);
2771 isc_mutex_destroy(&adb->entriescntlock);
2772 isc_mutex_destroy(&adb->overmemlock);
2773 isc_mutex_destroy(&adb->reflock);
2774 isc_mutex_destroy(&adb->lock);
2775 if (adb->excl != NULL) {
2776 isc_task_detach(&adb->excl);
2778 isc_mem_putanddetach(&adb->mctx, adb, sizeof(dns_adb_t));
2784 dns_adb_attach(dns_adb_t *adb, dns_adb_t **adbx) {
2785 REQUIRE(DNS_ADB_VALID(adb));
2788 inc_adb_erefcnt(adb);
2789 *adbx = adb;
2794 dns_adb_t *adb;
2799 adb = *adbx;
2802 LOCK(&adb->reflock);
2803 INSIST(adb->erefcnt > 0);
2804 adb->erefcnt--;
2805 need_exit_check = (adb->erefcnt == 0 && adb->irefcnt == 0);
2806 UNLOCK(&adb->reflock);
2809 LOCK(&adb->lock);
2810 INSIST(adb->shutting_down);
2811 check_exit(adb);
2812 UNLOCK(&adb->lock);
2817 dns_adb_whenshutdown(dns_adb_t *adb, isc_task_t *task, isc_event_t **eventp) {
2823 * Send '*eventp' to 'task' when 'adb' has shutdown.
2826 REQUIRE(DNS_ADB_VALID(adb));
2832 LOCK(&adb->lock);
2833 LOCK(&adb->reflock);
2835 zeroirefcnt = (adb->irefcnt == 0);
2837 if (adb->shutting_down && zeroirefcnt &&
2838 isc_refcount_current(&adb->ahrefcnt) == 0)
2843 event->ev_sender = adb;
2849 ISC_LIST_APPEND(adb->whenshutdown, event, ev_link);
2852 UNLOCK(&adb->reflock);
2853 UNLOCK(&adb->lock);
2858 dns_adb_t *adb;
2862 adb = event->ev_arg;
2863 INSIST(DNS_ADB_VALID(adb));
2865 LOCK(&adb->lock);
2866 INSIST(adb->shutting_down);
2867 adb->cevent_out = false;
2868 (void)shutdown_names(adb);
2869 (void)shutdown_entries(adb);
2870 if (dec_adb_irefcnt(adb)) {
2871 check_exit(adb);
2873 UNLOCK(&adb->lock);
2877 dns_adb_shutdown(dns_adb_t *adb) {
2881 * Shutdown 'adb'.
2884 LOCK(&adb->lock);
2886 if (!adb->shutting_down) {
2887 adb->shutting_down = true;
2888 isc_mem_setwater(adb->mctx, water, adb, 0, 0);
2892 inc_adb_irefcnt(adb);
2893 ISC_EVENT_INIT(&adb->cevent, sizeof(adb->cevent), 0, NULL,
2894 DNS_EVENT_ADBCONTROL, shutdown_stage2, adb, adb,
2896 adb->cevent_out = true;
2897 event = &adb->cevent;
2898 isc_task_send(adb->task, &event);
2901 UNLOCK(&adb->lock);
2905 dns_adb_createfind(dns_adb_t *adb, isc_task_t *task, isc_taskaction_t action,
2921 REQUIRE(DNS_ADB_VALID(adb));
2966 find = new_adbfind(adb);
2992 adbname = find_name_and_lock(adb, name, find->options, &bucket);
2994 if (adb->name_sd[bucket]) {
2997 RUNTIME_CHECK(!free_adbfind(adb, &find));
3010 check_stale_name(adb, bucket, now);
3012 adbname = new_adbname(adb, name);
3014 RUNTIME_CHECK(!free_adbfind(adb, &find));
3018 link_name(adb, bucket, adbname);
3030 ISC_LIST_UNLINK(adb->names[bucket], adbname, plink);
3031 ISC_LIST_PREPEND(adb->names[bucket], adbname, plink);
3190 copy_namehook_lists(adb, find, qname, qtype, adbname, now);
3274 UNLOCK(&adb->namelocks[bucket]);
3285 dns_adb_t *adb;
3296 adb = find->adb;
3297 REQUIRE(DNS_ADB_VALID(adb));
3308 * Return the find to the memory pool, and decrement the adb's
3311 overmem = isc_mem_isovermem(adb->mctx);
3318 RUNTIME_CHECK(!dec_entry_refcnt(adb, overmem, entry, true));
3319 free_adbaddrinfo(adb, &ai);
3324 * WARNING: The find is freed with the adb locked. This is done
3330 LOCK(&adb->lock);
3331 if (free_adbfind(adb, &find)) {
3332 check_exit(adb);
3334 UNLOCK(&adb->lock);
3341 dns_adb_t *adb;
3349 adb = find->adb;
3350 REQUIRE(DNS_ADB_VALID(adb));
3364 violate_locking_hierarchy(&find->lock, &adb->namelocks[unlock_bucket]);
3371 UNLOCK(&adb->namelocks[unlock_bucket]);
3397 dns_adb_dump(dns_adb_t *adb, FILE *f) {
3401 REQUIRE(DNS_ADB_VALID(adb));
3405 * Lock the adb itself, lock all the name buckets, then lock all
3406 * the entry buckets. This should put the adb into a state where
3411 LOCK(&adb->lock);
3414 for (i = 0; i < adb->nnames; i++) {
3415 RUNTIME_CHECK(!cleanup_names(adb, i, now));
3417 for (i = 0; i < adb->nentries; i++) {
3418 RUNTIME_CHECK(!cleanup_entries(adb, i, now));
3421 dump_adb(adb, f, false, now);
3422 UNLOCK(&adb->lock);
3434 dump_adb(dns_adb_t *adb, FILE *f, bool debug, isc_stdtime_t now) {
3443 LOCK(&adb->reflock);
3447 adb, adb->erefcnt, adb->irefcnt,
3448 isc_refcount_current(&adb->nhrefcnt));
3449 UNLOCK(&adb->reflock);
3459 for (size_t i = 0; i < adb->nnames; i++) {
3460 LOCK(&adb->namelocks[i]);
3462 for (size_t i = 0; i < adb->nentries; i++) {
3463 LOCK(&adb->entrylocks[i]);
3470 for (size_t i = 0; i < adb->nnames; i++) {
3472 LOCK(&adb->namelocks[i]);
3474 name = ISC_LIST_HEAD(adb->names[i]);
3477 UNLOCK(&adb->namelocks[i]);
3506 print_namehook_list(f, "v4", adb, &name->v4, debug,
3508 print_namehook_list(f, "v6", adb, &name->v6, debug,
3517 UNLOCK(&adb->namelocks[i]);
3523 for (size_t i = 0; i < adb->nentries; i++) {
3525 LOCK(&adb->entrylocks[i]);
3527 entry = ISC_LIST_HEAD(adb->entries[i]);
3530 dump_entry(f, adb, entry, debug, now);
3535 UNLOCK(&adb->entrylocks[i]);
3543 for (ssize_t i = adb->nentries - 1; i >= 0; i--) {
3544 UNLOCK(&adb->entrylocks[i]);
3546 for (ssize_t i = adb->nnames - 1; i >= 0; i--) {
3547 UNLOCK(&adb->namelocks[i]);
3553 dump_entry(FILE *f, dns_adb_t *adb, dns_adbentry_t *entry, bool debug,
3588 if (adb != NULL && adb->quota != 0 && adb->atr_freq != 0) {
3672 print_namehook_list(FILE *f, const char *legend, dns_adb_t *adb,
3684 LOCK(&adb->entrylocks[nh->entry->lock_bucket]);
3686 dump_entry(f, adb, nh->entry, debug, now);
3688 UNLOCK(&adb->entrylocks[nh->entry->lock_bucket]);
3723 dns_adb_t *adb;
3728 adb = adbname->adb;
3729 INSIST(DNS_ADB_VALID(adb));
3749 result = dns_view_find(adb->view, &adbname->name, rdtype, now,
3785 "adb name %p: Caching auth negative entry for A",
3794 "adb name %p: Caching auth negative entry for AAAA",
3819 "adb name %p: Caching negative entry for A (ttl %u)",
3823 "adb name %p: Caching negative entry for AAAA (ttl "
3843 clean_target(adb, &adbname->target);
3845 result = set_target(adb, &adbname->name, fname, &rdataset,
3849 DP(NCACHE_LEVEL, "adb name %p: caching alias target",
3872 dns_adb_t *adb;
3887 adb = name->adb;
3888 INSIST(DNS_ADB_VALID(adb));
3891 LOCK(&adb->namelocks[bucket]);
3931 free_adbfetch(adb, &fetch);
3936 UNLOCK(&adb->namelocks[bucket]);
3939 LOCK(&adb->lock);
3940 check_exit(adb);
3941 UNLOCK(&adb->lock);
3956 "adb fetch name %p: "
3966 inc_stats(adb, dns_resstatscounter_gluefetchv4fail);
3969 "adb fetch name %p: "
3979 inc_stats(adb, dns_resstatscounter_gluefetchv6fail);
3989 clean_target(adb, &name->target);
3991 result = set_target(adb, &name->name,
3996 "adb fetch name %p: caching alias target", name);
4010 DP(DEF_LEVEL, "adb: fetch of '%s' %s failed: %s", buf,
4024 inc_stats(adb, dns_resstatscounter_gluefetchv4fail);
4028 inc_stats(adb, dns_resstatscounter_gluefetchv6fail);
4049 free_adbfetch(adb, &fetch);
4054 UNLOCK(&adb->namelocks[bucket]);
4062 dns_adb_t *adb;
4070 adb = adbname->adb;
4071 INSIST(DNS_ADB_VALID(adb));
4087 result = dns_view_findzonecut(adb->view, &adbname->name, name,
4097 fetch = new_adbfetch(adb);
4112 adb->view->resolver, &adbname->name, type, name, nameservers,
4113 NULL, NULL, 0, options, depth, qc, adb->task, fetch_callback,
4123 inc_stats(adb, dns_resstatscounter_gluefetchv4);
4126 inc_stats(adb, dns_resstatscounter_gluefetchv6);
4132 free_adbfetch(adb, &fetch);
4142 * XXXMLG Needs to take a find argument and an address info, no zone or adb,
4146 dns_adb_marklame(dns_adb_t *adb, dns_adbaddrinfo_t *addr,
4153 REQUIRE(DNS_ADB_VALID(adb));
4158 LOCK(&adb->entrylocks[bucket]);
4171 li = new_adblameinfo(adb, qname, qtype);
4181 UNLOCK(&adb->entrylocks[bucket]);
4187 dns_adb_adjustsrtt(dns_adb_t *adb, dns_adbaddrinfo_t *addr, unsigned int rtt,
4192 REQUIRE(DNS_ADB_VALID(adb));
4197 LOCK(&adb->entrylocks[bucket]);
4204 UNLOCK(&adb->entrylocks[bucket]);
4208 dns_adb_agesrtt(dns_adb_t *adb, dns_adbaddrinfo_t *addr, isc_stdtime_t now) {
4211 REQUIRE(DNS_ADB_VALID(adb));
4215 LOCK(&adb->entrylocks[bucket]);
4219 UNLOCK(&adb->entrylocks[bucket]);
4251 dns_adb_changeflags(dns_adb_t *adb, dns_adbaddrinfo_t *addr, unsigned int bits,
4256 REQUIRE(DNS_ADB_VALID(adb));
4263 LOCK(&adb->entrylocks[bucket]);
4277 UNLOCK(&adb->entrylocks[bucket]);
4304 maybe_adjust_quota(dns_adb_t *adb, dns_adbaddrinfo_t *addr, bool timeout) {
4307 UNUSED(adb);
4309 if (adb->quota == 0 || adb->atr_freq == 0) {
4317 if (addr->entry->completed++ <= adb->atr_freq) {
4330 INSIST(adb->atr_discount >= 0.0);
4331 INSIST(adb->atr_discount <= 1.0);
4332 addr->entry->atr *= 1.0 - adb->atr_discount;
4333 addr->entry->atr += tr * adb->atr_discount;
4336 if (addr->entry->atr < adb->atr_low && addr->entry->mode > 0) {
4338 adb->quota * quota_adj[--addr->entry->mode] / 10000;
4344 } else if (addr->entry->atr > adb->atr_high &&
4348 adb->quota * quota_adj[++addr->entry->mode] / 10000;
4359 dns_adb_noedns(dns_adb_t *adb, dns_adbaddrinfo_t *addr) {
4363 REQUIRE(DNS_ADB_VALID(adb));
4367 LOCK(&adb->entrylocks[bucket]);
4390 UNLOCK(&adb->entrylocks[bucket]);
4395 dns_adb_plainresponse(dns_adb_t *adb, dns_adbaddrinfo_t *addr) {
4398 REQUIRE(DNS_ADB_VALID(adb));
4402 LOCK(&adb->entrylocks[bucket]);
4404 maybe_adjust_quota(adb, addr, false);
4416 UNLOCK(&adb->entrylocks[bucket]);
4420 dns_adb_timeout(dns_adb_t *adb, dns_adbaddrinfo_t *addr) {
4423 REQUIRE(DNS_ADB_VALID(adb));
4427 LOCK(&adb->entrylocks[bucket]);
4429 maybe_adjust_quota(adb, addr, true);
4453 UNLOCK(&adb->entrylocks[bucket]);
4457 dns_adb_ednsto(dns_adb_t *adb, dns_adbaddrinfo_t *addr, unsigned int size) {
4460 REQUIRE(DNS_ADB_VALID(adb));
4464 LOCK(&adb->entrylocks[bucket]);
4466 maybe_adjust_quota(adb, addr, true);
4501 UNLOCK(&adb->entrylocks[bucket]);
4505 dns_adb_setudpsize(dns_adb_t *adb, dns_adbaddrinfo_t *addr, unsigned int size) {
4508 REQUIRE(DNS_ADB_VALID(adb));
4512 LOCK(&adb->entrylocks[bucket]);
4520 maybe_adjust_quota(adb, addr, false);
4532 UNLOCK(&adb->entrylocks[bucket]);
4536 dns_adb_getudpsize(dns_adb_t *adb, dns_adbaddrinfo_t *addr) {
4540 REQUIRE(DNS_ADB_VALID(adb));
4544 LOCK(&adb->entrylocks[bucket]);
4546 UNLOCK(&adb->entrylocks[bucket]);
4552 dns_adb_probesize(dns_adb_t *adb, dns_adbaddrinfo_t *addr, int lookups) {
4556 REQUIRE(DNS_ADB_VALID(adb));
4560 LOCK(&adb->entrylocks[bucket]);
4579 UNLOCK(&adb->entrylocks[bucket]);
4585 dns_adb_setcookie(dns_adb_t *adb, dns_adbaddrinfo_t *addr,
4589 REQUIRE(DNS_ADB_VALID(adb));
4593 LOCK(&adb->entrylocks[bucket]);
4598 isc_mem_put(adb->mctx, addr->entry->cookie,
4605 addr->entry->cookie = isc_mem_get(adb->mctx, len);
4612 UNLOCK(&adb->entrylocks[bucket]);
4616 dns_adb_getcookie(dns_adb_t *adb, dns_adbaddrinfo_t *addr,
4620 REQUIRE(DNS_ADB_VALID(adb));
4624 LOCK(&adb->entrylocks[bucket]);
4633 UNLOCK(&adb->entrylocks[bucket]);
4639 dns_adb_findaddrinfo(dns_adb_t *adb, const isc_sockaddr_t *sa,
4647 REQUIRE(DNS_ADB_VALID(adb));
4654 entry = find_entry_and_lock(adb, sa, &bucket, now);
4656 if (adb->entry_sd[bucket]) {
4664 entry = new_adbentry(adb);
4670 link_entry(adb, bucket, entry);
4677 addr = new_adbaddrinfo(adb, entry, port);
4681 inc_entry_refcnt(adb, entry, false);
4686 UNLOCK(&adb->entrylocks[bucket]);
4692 dns_adb_freeaddrinfo(dns_adb_t *adb, dns_adbaddrinfo_t **addrp) {
4700 REQUIRE(DNS_ADB_VALID(adb));
4708 overmem = isc_mem_isovermem(adb->mctx);
4711 LOCK(&adb->entrylocks[bucket]);
4718 want_check_exit = dec_entry_refcnt(adb, overmem, entry, false);
4720 UNLOCK(&adb->entrylocks[bucket]);
4723 free_adbaddrinfo(adb, &addr);
4726 LOCK(&adb->lock);
4727 check_exit(adb);
4728 UNLOCK(&adb->lock);
4733 dns_adb_flush(dns_adb_t *adb) {
4736 INSIST(DNS_ADB_VALID(adb));
4738 LOCK(&adb->lock);
4743 for (i = 0; i < adb->nnames; i++) {
4744 RUNTIME_CHECK(!cleanup_names(adb, i, INT_MAX));
4746 for (i = 0; i < adb->nentries; i++) {
4747 RUNTIME_CHECK(!cleanup_entries(adb, i, INT_MAX));
4751 dump_adb(adb, stdout, true, INT_MAX);
4754 UNLOCK(&adb->lock);
4758 dns_adb_flushname(dns_adb_t *adb, const dns_name_t *name) {
4763 REQUIRE(DNS_ADB_VALID(adb));
4766 LOCK(&adb->lock);
4767 bucket = dns_name_hash(name, false) % adb->nnames;
4768 LOCK(&adb->namelocks[bucket]);
4769 adbname = ISC_LIST_HEAD(adb->names[bucket]);
4779 UNLOCK(&adb->namelocks[bucket]);
4780 UNLOCK(&adb->lock);
4784 dns_adb_flushnames(dns_adb_t *adb, const dns_name_t *name) {
4788 REQUIRE(DNS_ADB_VALID(adb));
4791 LOCK(&adb->lock);
4792 for (i = 0; i < adb->nnames; i++) {
4793 LOCK(&adb->namelocks[i]);
4794 adbname = ISC_LIST_HEAD(adb->names[i]);
4807 UNLOCK(&adb->namelocks[i]);
4809 UNLOCK(&adb->lock);
4822 dns_adb_t *adb = arg;
4825 REQUIRE(DNS_ADB_VALID(adb));
4827 DP(ISC_LOG_DEBUG(1), "adb reached %s water mark",
4832 dns_adb_setadbsize(dns_adb_t *adb, size_t size) {
4835 INSIST(DNS_ADB_VALID(adb));
4845 isc_mem_setwater(adb->mctx, water, adb, 0, 0);
4847 isc_mem_setwater(adb->mctx, water, adb, hiwater, lowater);
4852 dns_adb_setquota(dns_adb_t *adb, uint32_t quota, uint32_t freq, double low,
4854 REQUIRE(DNS_ADB_VALID(adb));
4856 adb->quota = quota;
4857 adb->atr_freq = freq;
4858 adb->atr_low = low;
4859 adb->atr_high = high;
4860 adb->atr_discount = discount;
4874 dns_adb_beginudpfetch(dns_adb_t *adb, dns_adbaddrinfo_t *addr) {
4875 REQUIRE(DNS_ADB_VALID(adb));
4882 dns_adb_endudpfetch(dns_adb_t *adb, dns_adbaddrinfo_t *addr) {
4883 REQUIRE(DNS_ADB_VALID(adb));
Indexes created Tue Mar 03 05:31:39 UTC 2026