/* $NetBSD: cache.c,v 1.9.2.2 2024/02/25 15:46:48 martin Exp $ */ /* * Copyright (C) Internet Systems Consortium, Inc. ("ISC") * * SPDX-License-Identifier: MPL-2.0 * * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, you can obtain one at https://mozilla.org/MPL/2.0/. * * See the COPYRIGHT file distributed with this work for additional * information regarding copyright ownership. */ /*! \file */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef HAVE_JSON_C #include #endif /* HAVE_JSON_C */ #ifdef HAVE_LIBXML2 #include #define ISC_XMLCHAR (const xmlChar *) #endif /* HAVE_LIBXML2 */ #include "rbtdb.h" #define CACHE_MAGIC ISC_MAGIC('$', '$', '$', '$') #define VALID_CACHE(cache) ISC_MAGIC_VALID(cache, CACHE_MAGIC) /*! * Control incremental cleaning. * DNS_CACHE_MINSIZE is how many bytes is the floor for * dns_cache_setcachesize(). See also DNS_CACHE_CLEANERINCREMENT */ #define DNS_CACHE_MINSIZE 2097152U /*%< Bytes. 2097152 = 2 MB */ /*! * Control incremental cleaning. * CLEANERINCREMENT is how many nodes are examined in one pass. * See also DNS_CACHE_MINSIZE */ #define DNS_CACHE_CLEANERINCREMENT 1000U /*%< Number of nodes. */ /*** *** Types ***/ /* * A cache_cleaner_t encapsulates the state of the periodic * cache cleaning. */ typedef struct cache_cleaner cache_cleaner_t; typedef enum { cleaner_s_idle, /*%< Waiting for cleaning interval to expire. */ cleaner_s_busy, /*%< Currently cleaning. */ cleaner_s_done /*%< Freed enough memory after being overmem. */ } cleaner_state_t; /* * Convenience macros for comprehensive assertion checking. */ #define CLEANER_IDLE(c) \ ((c)->state == cleaner_s_idle && (c)->resched_event != NULL) #define CLEANER_BUSY(c) \ ((c)->state == cleaner_s_busy && (c)->iterator != NULL && \ (c)->resched_event == NULL) /*% * Accesses to a cache cleaner object are synchronized through * task/event serialization, or locked from the cache object. */ struct cache_cleaner { isc_mutex_t lock; /*%< * Locks overmem_event, overmem. Note: never allocate memory * while holding this lock - that could lead to deadlock since * the lock is take by water() which is called from the memory * allocator. */ dns_cache_t *cache; isc_task_t *task; isc_event_t *resched_event; /*% Sent by cleaner task to * itself to reschedule */ isc_event_t *overmem_event; dns_dbiterator_t *iterator; unsigned int increment; /*% Number of names to * clean in one increment */ cleaner_state_t state; /*% Idle/Busy. */ bool overmem; /*% The cache is in an overmem state. * */ bool replaceiterator; }; /*% * The actual cache object. */ struct dns_cache { /* Unlocked. */ unsigned int magic; isc_mutex_t lock; isc_mem_t *mctx; /* Main cache memory */ isc_mem_t *hmctx; /* Heap memory */ char *name; isc_refcount_t references; isc_refcount_t live_tasks; /* Locked by 'lock'. */ dns_rdataclass_t rdclass; dns_db_t *db; cache_cleaner_t cleaner; char *db_type; int db_argc; char **db_argv; size_t size; dns_ttl_t serve_stale_ttl; dns_ttl_t serve_stale_refresh; isc_stats_t *stats; }; /*** *** Functions ***/ static isc_result_t cache_cleaner_init(dns_cache_t *cache, isc_taskmgr_t *taskmgr, isc_timermgr_t *timermgr, cache_cleaner_t *cleaner); static void incremental_cleaning_action(isc_task_t *task, isc_event_t *event); static void cleaner_shutdown_action(isc_task_t *task, isc_event_t *event); static void overmem_cleaning_action(isc_task_t *task, isc_event_t *event); static void water(void *arg, int mark); static isc_result_t cache_create_db(dns_cache_t *cache, dns_db_t **db) { isc_result_t result; result = dns_db_create(cache->mctx, cache->db_type, dns_rootname, dns_dbtype_cache, cache->rdclass, cache->db_argc, cache->db_argv, db); if (result == ISC_R_SUCCESS) { dns_db_setservestalettl(*db, cache->serve_stale_ttl); dns_db_setservestalerefresh(*db, cache->serve_stale_refresh); } return (result); } isc_result_t dns_cache_create(isc_mem_t *cmctx, isc_mem_t *hmctx, isc_taskmgr_t *taskmgr, isc_timermgr_t *timermgr, dns_rdataclass_t rdclass, const char *cachename, const char *db_type, unsigned int db_argc, char **db_argv, dns_cache_t **cachep) { isc_result_t result; dns_cache_t *cache; int i, extra = 0; isc_task_t *dbtask; REQUIRE(cachep != NULL); REQUIRE(*cachep == NULL); REQUIRE(cmctx != NULL); REQUIRE(hmctx != NULL); REQUIRE(cachename != NULL); cache = isc_mem_get(cmctx, sizeof(*cache)); cache->mctx = cache->hmctx = NULL; isc_mem_attach(cmctx, &cache->mctx); isc_mem_attach(hmctx, &cache->hmctx); cache->name = NULL; if (cachename != NULL) { cache->name = isc_mem_strdup(cmctx, cachename); } isc_mutex_init(&cache->lock); isc_refcount_init(&cache->references, 1); isc_refcount_init(&cache->live_tasks, 1); cache->rdclass = rdclass; cache->serve_stale_ttl = 0; cache->stats = NULL; result = isc_stats_create(cmctx, &cache->stats, dns_cachestatscounter_max); if (result != ISC_R_SUCCESS) { goto cleanup_lock; } cache->db_type = isc_mem_strdup(cmctx, db_type); /* * For databases of type "rbt" we pass hmctx to dns_db_create() * via cache->db_argv, followed by the rest of the arguments in * db_argv (of which there really shouldn't be any). */ if (strcmp(cache->db_type, "rbt") == 0) { extra = 1; } cache->db_argc = db_argc + extra; cache->db_argv = NULL; if (cache->db_argc != 0) { cache->db_argv = isc_mem_get(cmctx, cache->db_argc * sizeof(char *)); for (i = 0; i < cache->db_argc; i++) { cache->db_argv[i] = NULL; } cache->db_argv[0] = (char *)hmctx; for (i = extra; i < cache->db_argc; i++) { cache->db_argv[i] = isc_mem_strdup(cmctx, db_argv[i - extra]); } } /* * Create the database */ cache->db = NULL; result = cache_create_db(cache, &cache->db); if (result != ISC_R_SUCCESS) { goto cleanup_dbargv; } if (taskmgr != NULL) { dbtask = NULL; result = isc_task_create(taskmgr, 1, &dbtask); if (result != ISC_R_SUCCESS) { goto cleanup_db; } isc_task_setname(dbtask, "cache_dbtask", NULL); dns_db_settask(cache->db, dbtask); isc_task_detach(&dbtask); } cache->magic = CACHE_MAGIC; /* * RBT-type cache DB has its own mechanism of cache cleaning and doesn't * need the control of the generic cleaner. */ if (strcmp(db_type, "rbt") == 0) { result = cache_cleaner_init(cache, NULL, NULL, &cache->cleaner); } else { result = cache_cleaner_init(cache, taskmgr, timermgr, &cache->cleaner); } if (result != ISC_R_SUCCESS) { goto cleanup_db; } result = dns_db_setcachestats(cache->db, cache->stats); if (result != ISC_R_SUCCESS) { goto cleanup_db; } *cachep = cache; return (ISC_R_SUCCESS); cleanup_db: dns_db_detach(&cache->db); cleanup_dbargv: for (i = extra; i < cache->db_argc; i++) { if (cache->db_argv[i] != NULL) { isc_mem_free(cmctx, cache->db_argv[i]); } } if (cache->db_argv != NULL) { isc_mem_put(cmctx, cache->db_argv, cache->db_argc * sizeof(char *)); } isc_mem_free(cmctx, cache->db_type); isc_stats_detach(&cache->stats); cleanup_lock: isc_mutex_destroy(&cache->lock); if (cache->name != NULL) { isc_mem_free(cmctx, cache->name); } isc_mem_detach(&cache->hmctx); isc_mem_putanddetach(&cache->mctx, cache, sizeof(*cache)); return (result); } static void cache_free(dns_cache_t *cache) { REQUIRE(VALID_CACHE(cache)); isc_refcount_destroy(&cache->references); isc_refcount_destroy(&cache->live_tasks); isc_mem_clearwater(cache->mctx); if (cache->cleaner.task != NULL) { isc_task_detach(&cache->cleaner.task); } if (cache->cleaner.overmem_event != NULL) { isc_event_free(&cache->cleaner.overmem_event); } if (cache->cleaner.resched_event != NULL) { isc_event_free(&cache->cleaner.resched_event); } if (cache->cleaner.iterator != NULL) { dns_dbiterator_destroy(&cache->cleaner.iterator); } isc_mutex_destroy(&cache->cleaner.lock); if (cache->db != NULL) { dns_db_detach(&cache->db); } if (cache->db_argv != NULL) { /* * We don't free db_argv[0] in "rbt" cache databases * as it's a pointer to hmctx */ int extra = 0; if (strcmp(cache->db_type, "rbt") == 0) { extra = 1; } for (int i = extra; i < cache->db_argc; i++) { if (cache->db_argv[i] != NULL) { isc_mem_free(cache->mctx, cache->db_argv[i]); } } isc_mem_put(cache->mctx, cache->db_argv, cache->db_argc * sizeof(char *)); } if (cache->db_type != NULL) { isc_mem_free(cache->mctx, cache->db_type); } if (cache->name != NULL) { isc_mem_free(cache->mctx, cache->name); } if (cache->stats != NULL) { isc_stats_detach(&cache->stats); } isc_mutex_destroy(&cache->lock); cache->magic = 0; isc_mem_detach(&cache->hmctx); isc_mem_putanddetach(&cache->mctx, cache, sizeof(*cache)); } void dns_cache_attach(dns_cache_t *cache, dns_cache_t **targetp) { REQUIRE(VALID_CACHE(cache)); REQUIRE(targetp != NULL && *targetp == NULL); isc_refcount_increment(&cache->references); *targetp = cache; } void dns_cache_detach(dns_cache_t **cachep) { dns_cache_t *cache; REQUIRE(cachep != NULL); cache = *cachep; *cachep = NULL; REQUIRE(VALID_CACHE(cache)); if (isc_refcount_decrement(&cache->references) == 1) { cache->cleaner.overmem = false; /* * If the cleaner task exists, let it free the cache. */ if (isc_refcount_decrement(&cache->live_tasks) > 1) { isc_task_shutdown(cache->cleaner.task); } else { cache_free(cache); } } } void dns_cache_attachdb(dns_cache_t *cache, dns_db_t **dbp) { REQUIRE(VALID_CACHE(cache)); REQUIRE(dbp != NULL && *dbp == NULL); REQUIRE(cache->db != NULL); LOCK(&cache->lock); dns_db_attach(cache->db, dbp); UNLOCK(&cache->lock); } const char * dns_cache_getname(dns_cache_t *cache) { REQUIRE(VALID_CACHE(cache)); return (cache->name); } /* * Initialize the cache cleaner object at *cleaner. * Space for the object must be allocated by the caller. */ static isc_result_t cache_cleaner_init(dns_cache_t *cache, isc_taskmgr_t *taskmgr, isc_timermgr_t *timermgr, cache_cleaner_t *cleaner) { isc_result_t result; isc_mutex_init(&cleaner->lock); cleaner->increment = DNS_CACHE_CLEANERINCREMENT; cleaner->state = cleaner_s_idle; cleaner->cache = cache; cleaner->iterator = NULL; cleaner->overmem = false; cleaner->replaceiterator = false; cleaner->task = NULL; cleaner->resched_event = NULL; cleaner->overmem_event = NULL; result = dns_db_createiterator(cleaner->cache->db, false, &cleaner->iterator); if (result != ISC_R_SUCCESS) { goto cleanup; } if (taskmgr != NULL && timermgr != NULL) { result = isc_task_create(taskmgr, 1, &cleaner->task); if (result != ISC_R_SUCCESS) { UNEXPECTED_ERROR("isc_task_create() failed: %s", isc_result_totext(result)); result = ISC_R_UNEXPECTED; goto cleanup; } isc_refcount_increment(&cleaner->cache->live_tasks); isc_task_setname(cleaner->task, "cachecleaner", cleaner); result = isc_task_onshutdown(cleaner->task, cleaner_shutdown_action, cache); if (result != ISC_R_SUCCESS) { isc_refcount_decrement0(&cleaner->cache->live_tasks); UNEXPECTED_ERROR("cache cleaner: " "isc_task_onshutdown() failed: %s", isc_result_totext(result)); goto cleanup; } cleaner->resched_event = isc_event_allocate( cache->mctx, cleaner, DNS_EVENT_CACHECLEAN, incremental_cleaning_action, cleaner, sizeof(isc_event_t)); cleaner->overmem_event = isc_event_allocate( cache->mctx, cleaner, DNS_EVENT_CACHEOVERMEM, overmem_cleaning_action, cleaner, sizeof(isc_event_t)); } return (ISC_R_SUCCESS); cleanup: if (cleaner->overmem_event != NULL) { isc_event_free(&cleaner->overmem_event); } if (cleaner->resched_event != NULL) { isc_event_free(&cleaner->resched_event); } if (cleaner->task != NULL) { isc_task_detach(&cleaner->task); } if (cleaner->iterator != NULL) { dns_dbiterator_destroy(&cleaner->iterator); } isc_mutex_destroy(&cleaner->lock); return (result); } static void begin_cleaning(cache_cleaner_t *cleaner) { isc_result_t result = ISC_R_SUCCESS; REQUIRE(CLEANER_IDLE(cleaner)); /* * Create an iterator, if it does not already exist, and * position it at the beginning of the cache. */ if (cleaner->iterator == NULL) { result = dns_db_createiterator(cleaner->cache->db, false, &cleaner->iterator); } if (result != ISC_R_SUCCESS) { isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_CACHE, ISC_LOG_WARNING, "cache cleaner could not create " "iterator: %s", isc_result_totext(result)); } else { dns_dbiterator_setcleanmode(cleaner->iterator, true); result = dns_dbiterator_first(cleaner->iterator); } if (result != ISC_R_SUCCESS) { /* * If the result is ISC_R_NOMORE, the database is empty, * so there is nothing to be cleaned. */ if (result != ISC_R_NOMORE && cleaner->iterator != NULL) { UNEXPECTED_ERROR("cache cleaner: " "dns_dbiterator_first() failed: %s", isc_result_totext(result)); dns_dbiterator_destroy(&cleaner->iterator); } else if (cleaner->iterator != NULL) { result = dns_dbiterator_pause(cleaner->iterator); RUNTIME_CHECK(result == ISC_R_SUCCESS); } } else { /* * Pause the iterator to free its lock. */ result = dns_dbiterator_pause(cleaner->iterator); RUNTIME_CHECK(result == ISC_R_SUCCESS); isc_log_write( dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_CACHE, ISC_LOG_DEBUG(1), "begin cache cleaning, mem inuse %lu", (unsigned long)isc_mem_inuse(cleaner->cache->mctx)); cleaner->state = cleaner_s_busy; isc_task_send(cleaner->task, &cleaner->resched_event); } return; } static void end_cleaning(cache_cleaner_t *cleaner, isc_event_t *event) { isc_result_t result; REQUIRE(CLEANER_BUSY(cleaner)); REQUIRE(event != NULL); result = dns_dbiterator_pause(cleaner->iterator); if (result != ISC_R_SUCCESS) { dns_dbiterator_destroy(&cleaner->iterator); } isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_CACHE, ISC_LOG_DEBUG(1), "end cache cleaning, mem inuse %lu", (unsigned long)isc_mem_inuse(cleaner->cache->mctx)); cleaner->state = cleaner_s_idle; cleaner->resched_event = event; } /* * This is called when the cache either surpasses its upper limit * or shrinks beyond its lower limit. */ static void overmem_cleaning_action(isc_task_t *task, isc_event_t *event) { cache_cleaner_t *cleaner = event->ev_arg; bool want_cleaning = false; UNUSED(task); INSIST(task == cleaner->task); INSIST(event->ev_type == DNS_EVENT_CACHEOVERMEM); INSIST(cleaner->overmem_event == NULL); isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_CACHE, ISC_LOG_DEBUG(1), "overmem_cleaning_action called, " "overmem = %d, state = %d", cleaner->overmem, cleaner->state); LOCK(&cleaner->lock); if (cleaner->overmem) { if (cleaner->state == cleaner_s_idle) { want_cleaning = true; } } else { if (cleaner->state == cleaner_s_busy) { /* * end_cleaning() can't be called here because * then both cleaner->overmem_event and * cleaner->resched_event will point to this * event. Set the state to done, and then * when the incremental_cleaning_action() event * is posted, it will handle the end_cleaning. */ cleaner->state = cleaner_s_done; } } cleaner->overmem_event = event; UNLOCK(&cleaner->lock); if (want_cleaning) { begin_cleaning(cleaner); } } /* * Do incremental cleaning. */ static void incremental_cleaning_action(isc_task_t *task, isc_event_t *event) { cache_cleaner_t *cleaner = event->ev_arg; isc_result_t result; unsigned int n_names; isc_time_t start; UNUSED(task); INSIST(task == cleaner->task); INSIST(event->ev_type == DNS_EVENT_CACHECLEAN); if (cleaner->state == cleaner_s_done) { cleaner->state = cleaner_s_busy; end_cleaning(cleaner, event); LOCK(&cleaner->cache->lock); LOCK(&cleaner->lock); if (cleaner->replaceiterator) { dns_dbiterator_destroy(&cleaner->iterator); (void)dns_db_createiterator(cleaner->cache->db, false, &cleaner->iterator); cleaner->replaceiterator = false; } UNLOCK(&cleaner->lock); UNLOCK(&cleaner->cache->lock); return; } INSIST(CLEANER_BUSY(cleaner)); n_names = cleaner->increment; REQUIRE(DNS_DBITERATOR_VALID(cleaner->iterator)); isc_time_now(&start); while (n_names-- > 0) { dns_dbnode_t *node = NULL; result = dns_dbiterator_current(cleaner->iterator, &node, NULL); if (result != ISC_R_SUCCESS) { UNEXPECTED_ERROR("cache cleaner: " "dns_dbiterator_current() failed: %s", isc_result_totext(result)); end_cleaning(cleaner, event); return; } /* * The node was not needed, but was required by * dns_dbiterator_current(). Give up its reference. */ dns_db_detachnode(cleaner->cache->db, &node); /* * Step to the next node. */ result = dns_dbiterator_next(cleaner->iterator); if (result != ISC_R_SUCCESS) { /* * Either the end was reached (ISC_R_NOMORE) or * some error was signaled. If the cache is still * overmem and no error was encountered, * keep trying to clean it, otherwise stop cleaning. */ if (result != ISC_R_NOMORE) { UNEXPECTED_ERROR("cache cleaner: " "dns_dbiterator_next() " "failed: %s", isc_result_totext(result)); } else if (cleaner->overmem) { result = dns_dbiterator_first(cleaner->iterator); if (result == ISC_R_SUCCESS) { isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_CACHE, ISC_LOG_DEBUG(1), "cache cleaner: " "still overmem, " "reset and try again"); continue; } } end_cleaning(cleaner, event); return; } } /* * We have successfully performed a cleaning increment but have * not gone through the entire cache. Free the iterator locks * and reschedule another batch. If it fails, just try to continue * anyway. */ result = dns_dbiterator_pause(cleaner->iterator); RUNTIME_CHECK(result == ISC_R_SUCCESS); isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_CACHE, ISC_LOG_DEBUG(1), "cache cleaner: checked %u nodes, " "mem inuse %lu, sleeping", cleaner->increment, (unsigned long)isc_mem_inuse(cleaner->cache->mctx)); isc_task_send(task, &event); INSIST(CLEANER_BUSY(cleaner)); return; } /* * Do immediate cleaning. */ isc_result_t dns_cache_clean(dns_cache_t *cache, isc_stdtime_t now) { isc_result_t result; dns_dbiterator_t *iterator = NULL; REQUIRE(VALID_CACHE(cache)); result = dns_db_createiterator(cache->db, 0, &iterator); if (result != ISC_R_SUCCESS) { return (result); } result = dns_dbiterator_first(iterator); while (result == ISC_R_SUCCESS) { dns_dbnode_t *node = NULL; result = dns_dbiterator_current(iterator, &node, (dns_name_t *)NULL); if (result != ISC_R_SUCCESS) { break; } /* * Check TTLs, mark expired rdatasets stale. */ result = dns_db_expirenode(cache->db, node, now); if (result != ISC_R_SUCCESS) { UNEXPECTED_ERROR("cache cleaner: dns_db_expirenode() " "failed: %s", isc_result_totext(result)); /* * Continue anyway. */ } /* * This is where the actual freeing takes place. */ dns_db_detachnode(cache->db, &node); result = dns_dbiterator_next(iterator); } dns_dbiterator_destroy(&iterator); if (result == ISC_R_NOMORE) { result = ISC_R_SUCCESS; } return (result); } static void water(void *arg, int mark) { dns_cache_t *cache = arg; bool overmem = (mark == ISC_MEM_HIWATER); REQUIRE(VALID_CACHE(cache)); LOCK(&cache->cleaner.lock); if (overmem != cache->cleaner.overmem) { dns_db_overmem(cache->db, overmem); cache->cleaner.overmem = overmem; isc_mem_waterack(cache->mctx, mark); } if (cache->cleaner.overmem_event != NULL) { isc_task_send(cache->cleaner.task, &cache->cleaner.overmem_event); } UNLOCK(&cache->cleaner.lock); } void dns_cache_setcachesize(dns_cache_t *cache, size_t size) { size_t hiwater, lowater; REQUIRE(VALID_CACHE(cache)); /* * Impose a minimum cache size; pathological things happen if there * is too little room. */ if (size != 0U && size < DNS_CACHE_MINSIZE) { size = DNS_CACHE_MINSIZE; } LOCK(&cache->lock); cache->size = size; UNLOCK(&cache->lock); hiwater = size - (size >> 3); /* Approximately 7/8ths. */ lowater = size - (size >> 2); /* Approximately 3/4ths. */ /* * If the cache was overmem and cleaning, but now with the new limits * it is no longer in an overmem condition, then the next * isc_mem_put for cache memory will do the right thing and trigger * water(). */ if (size == 0U || hiwater == 0U || lowater == 0U) { /* * Disable cache memory limiting. */ isc_mem_clearwater(cache->mctx); } else { /* * Establish new cache memory limits (either for the first * time, or replacing other limits). */ isc_mem_setwater(cache->mctx, water, cache, hiwater, lowater); } } size_t dns_cache_getcachesize(dns_cache_t *cache) { size_t size; REQUIRE(VALID_CACHE(cache)); LOCK(&cache->lock); size = cache->size; UNLOCK(&cache->lock); return (size); } void dns_cache_setservestalettl(dns_cache_t *cache, dns_ttl_t ttl) { REQUIRE(VALID_CACHE(cache)); LOCK(&cache->lock); cache->serve_stale_ttl = ttl; UNLOCK(&cache->lock); (void)dns_db_setservestalettl(cache->db, ttl); } dns_ttl_t dns_cache_getservestalettl(dns_cache_t *cache) { dns_ttl_t ttl; isc_result_t result; REQUIRE(VALID_CACHE(cache)); /* * Could get it straight from the dns_cache_t, but use db * to confirm the value that the db is really using. */ result = dns_db_getservestalettl(cache->db, &ttl); return (result == ISC_R_SUCCESS ? ttl : 0); } void dns_cache_setservestalerefresh(dns_cache_t *cache, dns_ttl_t interval) { REQUIRE(VALID_CACHE(cache)); LOCK(&cache->lock); cache->serve_stale_refresh = interval; UNLOCK(&cache->lock); (void)dns_db_setservestalerefresh(cache->db, interval); } dns_ttl_t dns_cache_getservestalerefresh(dns_cache_t *cache) { isc_result_t result; dns_ttl_t interval; REQUIRE(VALID_CACHE(cache)); result = dns_db_getservestalerefresh(cache->db, &interval); return (result == ISC_R_SUCCESS ? interval : 0); } /* * The cleaner task is shutting down; do the necessary cleanup. */ static void cleaner_shutdown_action(isc_task_t *task, isc_event_t *event) { dns_cache_t *cache = event->ev_arg; UNUSED(task); INSIST(task == cache->cleaner.task); INSIST(event->ev_type == ISC_TASKEVENT_SHUTDOWN); if (CLEANER_BUSY(&cache->cleaner)) { end_cleaning(&cache->cleaner, event); } else { isc_event_free(&event); } /* Make sure we don't reschedule anymore. */ (void)isc_task_purge(task, NULL, DNS_EVENT_CACHECLEAN, NULL); isc_refcount_decrementz(&cache->live_tasks); cache_free(cache); } isc_result_t dns_cache_flush(dns_cache_t *cache) { dns_db_t *db = NULL, *olddb; dns_dbiterator_t *dbiterator = NULL, *olddbiterator = NULL; isc_result_t result; result = cache_create_db(cache, &db); if (result != ISC_R_SUCCESS) { return (result); } result = dns_db_createiterator(db, false, &dbiterator); if (result != ISC_R_SUCCESS) { dns_db_detach(&db); return (result); } LOCK(&cache->lock); LOCK(&cache->cleaner.lock); if (cache->cleaner.state == cleaner_s_idle) { olddbiterator = cache->cleaner.iterator; cache->cleaner.iterator = dbiterator; dbiterator = NULL; } else { if (cache->cleaner.state == cleaner_s_busy) { cache->cleaner.state = cleaner_s_done; } cache->cleaner.replaceiterator = true; } olddb = cache->db; cache->db = db; dns_db_setcachestats(cache->db, cache->stats); UNLOCK(&cache->cleaner.lock); UNLOCK(&cache->lock); if (dbiterator != NULL) { dns_dbiterator_destroy(&dbiterator); } if (olddbiterator != NULL) { dns_dbiterator_destroy(&olddbiterator); } dns_db_detach(&olddb); return (ISC_R_SUCCESS); } static isc_result_t clearnode(dns_db_t *db, dns_dbnode_t *node) { isc_result_t result; dns_rdatasetiter_t *iter = NULL; result = dns_db_allrdatasets(db, node, NULL, DNS_DB_STALEOK, (isc_stdtime_t)0, &iter); if (result != ISC_R_SUCCESS) { return (result); } for (result = dns_rdatasetiter_first(iter); result == ISC_R_SUCCESS; result = dns_rdatasetiter_next(iter)) { dns_rdataset_t rdataset; dns_rdataset_init(&rdataset); dns_rdatasetiter_current(iter, &rdataset); result = dns_db_deleterdataset(db, node, NULL, rdataset.type, rdataset.covers); dns_rdataset_disassociate(&rdataset); if (result != ISC_R_SUCCESS && result != DNS_R_UNCHANGED) { break; } } if (result == ISC_R_NOMORE) { result = ISC_R_SUCCESS; } dns_rdatasetiter_destroy(&iter); return (result); } static isc_result_t cleartree(dns_db_t *db, const dns_name_t *name) { isc_result_t result, answer = ISC_R_SUCCESS; dns_dbiterator_t *iter = NULL; dns_dbnode_t *node = NULL, *top = NULL; dns_fixedname_t fnodename; dns_name_t *nodename; /* * Create the node if it doesn't exist so dns_dbiterator_seek() * can find it. We will continue even if this fails. */ (void)dns_db_findnode(db, name, true, &top); nodename = dns_fixedname_initname(&fnodename); result = dns_db_createiterator(db, 0, &iter); if (result != ISC_R_SUCCESS) { goto cleanup; } result = dns_dbiterator_seek(iter, name); if (result == DNS_R_PARTIALMATCH) { result = dns_dbiterator_next(iter); } if (result != ISC_R_SUCCESS) { goto cleanup; } while (result == ISC_R_SUCCESS) { result = dns_dbiterator_current(iter, &node, nodename); if (result == DNS_R_NEWORIGIN) { result = ISC_R_SUCCESS; } if (result != ISC_R_SUCCESS) { goto cleanup; } /* * Are we done? */ if (!dns_name_issubdomain(nodename, name)) { goto cleanup; } /* * If clearnode fails record and move onto the next node. */ result = clearnode(db, node); if (result != ISC_R_SUCCESS && answer == ISC_R_SUCCESS) { answer = result; } dns_db_detachnode(db, &node); result = dns_dbiterator_next(iter); } cleanup: if (result == ISC_R_NOMORE || result == ISC_R_NOTFOUND) { result = ISC_R_SUCCESS; } if (result != ISC_R_SUCCESS && answer == ISC_R_SUCCESS) { answer = result; } if (node != NULL) { dns_db_detachnode(db, &node); } if (iter != NULL) { dns_dbiterator_destroy(&iter); } if (top != NULL) { dns_db_detachnode(db, &top); } return (answer); } isc_result_t dns_cache_flushname(dns_cache_t *cache, const dns_name_t *name) { return (dns_cache_flushnode(cache, name, false)); } isc_result_t dns_cache_flushnode(dns_cache_t *cache, const dns_name_t *name, bool tree) { isc_result_t result; dns_dbnode_t *node = NULL; dns_db_t *db = NULL; if (tree && dns_name_equal(name, dns_rootname)) { return (dns_cache_flush(cache)); } LOCK(&cache->lock); if (cache->db != NULL) { dns_db_attach(cache->db, &db); } UNLOCK(&cache->lock); if (db == NULL) { return (ISC_R_SUCCESS); } if (tree) { result = cleartree(cache->db, name); } else { result = dns_db_findnode(cache->db, name, false, &node); if (result == ISC_R_NOTFOUND) { result = ISC_R_SUCCESS; goto cleanup_db; } if (result != ISC_R_SUCCESS) { goto cleanup_db; } result = clearnode(cache->db, node); dns_db_detachnode(cache->db, &node); } cleanup_db: dns_db_detach(&db); return (result); } isc_stats_t * dns_cache_getstats(dns_cache_t *cache) { REQUIRE(VALID_CACHE(cache)); return (cache->stats); } void dns_cache_updatestats(dns_cache_t *cache, isc_result_t result) { REQUIRE(VALID_CACHE(cache)); if (cache->stats == NULL) { return; } switch (result) { case ISC_R_SUCCESS: case DNS_R_NCACHENXDOMAIN: case DNS_R_NCACHENXRRSET: case DNS_R_CNAME: case DNS_R_DNAME: case DNS_R_GLUE: case DNS_R_ZONECUT: case DNS_R_COVERINGNSEC: isc_stats_increment(cache->stats, dns_cachestatscounter_queryhits); break; default: isc_stats_increment(cache->stats, dns_cachestatscounter_querymisses); } } /* * XXX: Much of the following code has been copied in from statschannel.c. * We should refactor this into a generic function in stats.c that can be * called from both places. */ typedef struct cache_dumparg { isc_statsformat_t type; void *arg; /* type dependent argument */ int ncounters; /* for general statistics */ int *counterindices; /* for general statistics */ uint64_t *countervalues; /* for general statistics */ isc_result_t result; } cache_dumparg_t; static void getcounter(isc_statscounter_t counter, uint64_t val, void *arg) { cache_dumparg_t *dumparg = arg; REQUIRE(counter < dumparg->ncounters); dumparg->countervalues[counter] = val; } static void getcounters(isc_stats_t *stats, isc_statsformat_t type, int ncounters, int *indices, uint64_t *values) { cache_dumparg_t dumparg; memset(values, 0, sizeof(values[0]) * ncounters); dumparg.type = type; dumparg.ncounters = ncounters; dumparg.counterindices = indices; dumparg.countervalues = values; isc_stats_dump(stats, getcounter, &dumparg, ISC_STATSDUMP_VERBOSE); } void dns_cache_dumpstats(dns_cache_t *cache, FILE *fp) { int indices[dns_cachestatscounter_max]; uint64_t values[dns_cachestatscounter_max]; REQUIRE(VALID_CACHE(cache)); getcounters(cache->stats, isc_statsformat_file, dns_cachestatscounter_max, indices, values); fprintf(fp, "%20" PRIu64 " %s\n", values[dns_cachestatscounter_hits], "cache hits"); fprintf(fp, "%20" PRIu64 " %s\n", values[dns_cachestatscounter_misses], "cache misses"); fprintf(fp, "%20" PRIu64 " %s\n", values[dns_cachestatscounter_queryhits], "cache hits (from query)"); fprintf(fp, "%20" PRIu64 " %s\n", values[dns_cachestatscounter_querymisses], "cache misses (from query)"); fprintf(fp, "%20" PRIu64 " %s\n", values[dns_cachestatscounter_deletelru], "cache records deleted due to memory exhaustion"); fprintf(fp, "%20" PRIu64 " %s\n", values[dns_cachestatscounter_deletettl], "cache records deleted due to TTL expiration"); fprintf(fp, "%20" PRIu64 " %s\n", values[dns_cachestatscounter_coveringnsec], "covering nsec returned"); fprintf(fp, "%20u %s\n", dns_db_nodecount(cache->db, dns_dbtree_main), "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_total(cache->mctx), "cache tree memory total"); fprintf(fp, "%20" PRIu64 " %s\n", (uint64_t)isc_mem_inuse(cache->mctx), "cache tree memory in use"); fprintf(fp, "%20" PRIu64 " %s\n", (uint64_t)isc_mem_maxinuse(cache->mctx), "cache tree highest memory in use"); fprintf(fp, "%20" PRIu64 " %s\n", (uint64_t)isc_mem_total(cache->hmctx), "cache heap memory total"); fprintf(fp, "%20" PRIu64 " %s\n", (uint64_t)isc_mem_inuse(cache->hmctx), "cache heap memory in use"); fprintf(fp, "%20" PRIu64 " %s\n", (uint64_t)isc_mem_maxinuse(cache->hmctx), "cache heap highest memory in use"); } #ifdef HAVE_LIBXML2 #define TRY0(a) \ do { \ xmlrc = (a); \ if (xmlrc < 0) \ goto error; \ } while (0) static int renderstat(const char *name, uint64_t value, xmlTextWriterPtr writer) { int xmlrc; TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "counter")); TRY0(xmlTextWriterWriteAttribute(writer, ISC_XMLCHAR "name", ISC_XMLCHAR name)); TRY0(xmlTextWriterWriteFormatString(writer, "%" PRIu64 "", value)); TRY0(xmlTextWriterEndElement(writer)); /* counter */ error: return (xmlrc); } int dns_cache_renderxml(dns_cache_t *cache, void *writer0) { int indices[dns_cachestatscounter_max]; uint64_t values[dns_cachestatscounter_max]; int xmlrc; xmlTextWriterPtr writer = (xmlTextWriterPtr)writer0; REQUIRE(VALID_CACHE(cache)); getcounters(cache->stats, isc_statsformat_file, dns_cachestatscounter_max, indices, values); TRY0(renderstat("CacheHits", values[dns_cachestatscounter_hits], writer)); TRY0(renderstat("CacheMisses", values[dns_cachestatscounter_misses], writer)); TRY0(renderstat("QueryHits", values[dns_cachestatscounter_queryhits], writer)); TRY0(renderstat("QueryMisses", values[dns_cachestatscounter_querymisses], writer)); TRY0(renderstat("DeleteLRU", values[dns_cachestatscounter_deletelru], writer)); TRY0(renderstat("DeleteTTL", values[dns_cachestatscounter_deletettl], writer)); TRY0(renderstat("CoveringNSEC", values[dns_cachestatscounter_coveringnsec], writer)); TRY0(renderstat("CacheNodes", 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("TreeMemTotal", isc_mem_total(cache->mctx), writer)); TRY0(renderstat("TreeMemInUse", isc_mem_inuse(cache->mctx), writer)); TRY0(renderstat("TreeMemMax", isc_mem_maxinuse(cache->mctx), writer)); TRY0(renderstat("HeapMemTotal", isc_mem_total(cache->hmctx), writer)); TRY0(renderstat("HeapMemInUse", isc_mem_inuse(cache->hmctx), writer)); TRY0(renderstat("HeapMemMax", isc_mem_maxinuse(cache->hmctx), writer)); error: return (xmlrc); } #endif /* ifdef HAVE_LIBXML2 */ #ifdef HAVE_JSON_C #define CHECKMEM(m) \ do { \ if (m == NULL) { \ result = ISC_R_NOMEMORY; \ goto error; \ } \ } while (0) isc_result_t dns_cache_renderjson(dns_cache_t *cache, void *cstats0) { isc_result_t result = ISC_R_SUCCESS; int indices[dns_cachestatscounter_max]; uint64_t values[dns_cachestatscounter_max]; json_object *obj; json_object *cstats = (json_object *)cstats0; REQUIRE(VALID_CACHE(cache)); getcounters(cache->stats, isc_statsformat_file, dns_cachestatscounter_max, indices, values); obj = json_object_new_int64(values[dns_cachestatscounter_hits]); CHECKMEM(obj); json_object_object_add(cstats, "CacheHits", obj); obj = json_object_new_int64(values[dns_cachestatscounter_misses]); CHECKMEM(obj); json_object_object_add(cstats, "CacheMisses", obj); obj = json_object_new_int64(values[dns_cachestatscounter_queryhits]); CHECKMEM(obj); json_object_object_add(cstats, "QueryHits", obj); obj = json_object_new_int64(values[dns_cachestatscounter_querymisses]); CHECKMEM(obj); json_object_object_add(cstats, "QueryMisses", obj); obj = json_object_new_int64(values[dns_cachestatscounter_deletelru]); CHECKMEM(obj); json_object_object_add(cstats, "DeleteLRU", obj); obj = json_object_new_int64(values[dns_cachestatscounter_deletettl]); CHECKMEM(obj); json_object_object_add(cstats, "DeleteTTL", obj); obj = json_object_new_int64(values[dns_cachestatscounter_coveringnsec]); CHECKMEM(obj); json_object_object_add(cstats, "CoveringNSEC", obj); obj = json_object_new_int64( dns_db_nodecount(cache->db, dns_dbtree_main)); CHECKMEM(obj); json_object_object_add(cstats, "CacheNodes", obj); obj = json_object_new_int64( dns_db_nodecount(cache->db, dns_dbtree_nsec)); 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_total(cache->mctx)); CHECKMEM(obj); json_object_object_add(cstats, "TreeMemTotal", obj); obj = json_object_new_int64(isc_mem_inuse(cache->mctx)); CHECKMEM(obj); json_object_object_add(cstats, "TreeMemInUse", obj); obj = json_object_new_int64(isc_mem_maxinuse(cache->mctx)); CHECKMEM(obj); json_object_object_add(cstats, "TreeMemMax", obj); obj = json_object_new_int64(isc_mem_total(cache->hmctx)); CHECKMEM(obj); json_object_object_add(cstats, "HeapMemTotal", obj); obj = json_object_new_int64(isc_mem_inuse(cache->hmctx)); CHECKMEM(obj); json_object_object_add(cstats, "HeapMemInUse", obj); obj = json_object_new_int64(isc_mem_maxinuse(cache->hmctx)); CHECKMEM(obj); json_object_object_add(cstats, "HeapMemMax", obj); result = ISC_R_SUCCESS; error: return (result); } #endif /* ifdef HAVE_JSON_C */