2 * Copyright (C) 2004-2009, 2011, 2013 Internet Systems Consortium, Inc. ("ISC")
3 * Copyright (C) 1999-2003 Internet Software Consortium.
5 * Permission to use, copy, modify, and/or distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
9 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
10 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
11 * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
12 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
13 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
14 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
15 * PERFORMANCE OF THIS SOFTWARE.
18 /* $Id: cache.c,v 1.91 2011/08/26 05:12:56 marka Exp $ */
25 #include <isc/string.h>
28 #include <isc/timer.h>
31 #include <dns/cache.h>
33 #include <dns/dbiterator.h>
34 #include <dns/events.h>
37 #include <dns/masterdump.h>
38 #include <dns/rdata.h>
39 #include <dns/rdataset.h>
40 #include <dns/rdatasetiter.h>
41 #include <dns/result.h>
45 #define CACHE_MAGIC ISC_MAGIC('$', '$', '$', '$')
46 #define VALID_CACHE(cache) ISC_MAGIC_VALID(cache, CACHE_MAGIC)
49 * Control incremental cleaning.
50 * DNS_CACHE_MINSIZE is how many bytes is the floor for dns_cache_setcachesize().
51 * See also DNS_CACHE_CLEANERINCREMENT
53 #define DNS_CACHE_MINSIZE 2097152U /*%< Bytes. 2097152 = 2 MB */
55 * Control incremental cleaning.
56 * CLEANERINCREMENT is how many nodes are examined in one pass.
57 * See also DNS_CACHE_MINSIZE
59 #define DNS_CACHE_CLEANERINCREMENT 1000U /*%< Number of nodes. */
66 * A cache_cleaner_t encapsulates the state of the periodic
70 typedef struct cache_cleaner cache_cleaner_t;
73 cleaner_s_idle, /*%< Waiting for cleaning-interval to expire. */
74 cleaner_s_busy, /*%< Currently cleaning. */
75 cleaner_s_done /*%< Freed enough memory after being overmem. */
79 * Convenience macros for comprehensive assertion checking.
81 #define CLEANER_IDLE(c) ((c)->state == cleaner_s_idle && \
82 (c)->resched_event != NULL)
83 #define CLEANER_BUSY(c) ((c)->state == cleaner_s_busy && \
84 (c)->iterator != NULL && \
85 (c)->resched_event == NULL)
88 * Accesses to a cache cleaner object are synchronized through
89 * task/event serialization, or locked from the cache object.
91 struct cache_cleaner {
94 * Locks overmem_event, overmem. Note: never allocate memory
95 * while holding this lock - that could lead to deadlock since
96 * the lock is take by water() which is called from the memory
102 unsigned int cleaning_interval; /*% The cleaning-interval from
103 named.conf, in seconds. */
104 isc_timer_t *cleaning_timer;
105 isc_event_t *resched_event; /*% Sent by cleaner task to
106 itself to reschedule */
107 isc_event_t *overmem_event;
109 dns_dbiterator_t *iterator;
110 unsigned int increment; /*% Number of names to
111 clean in one increment */
112 cleaner_state_t state; /*% Idle/Busy. */
113 isc_boolean_t overmem; /*% The cache is in an overmem state. */
114 isc_boolean_t replaceiterator;
118 * The actual cache object.
125 isc_mutex_t filelock;
126 isc_mem_t *mctx; /* Main cache memory */
127 isc_mem_t *hmctx; /* Heap memory */
130 /* Locked by 'lock'. */
133 dns_rdataclass_t rdclass;
135 cache_cleaner_t cleaner;
141 /* Locked by 'filelock'. */
143 /* Access to the on-disk cache file is also locked by 'filelock'. */
151 cache_cleaner_init(dns_cache_t *cache, isc_taskmgr_t *taskmgr,
152 isc_timermgr_t *timermgr, cache_cleaner_t *cleaner);
155 cleaning_timer_action(isc_task_t *task, isc_event_t *event);
158 incremental_cleaning_action(isc_task_t *task, isc_event_t *event);
161 cleaner_shutdown_action(isc_task_t *task, isc_event_t *event);
164 overmem_cleaning_action(isc_task_t *task, isc_event_t *event);
166 static inline isc_result_t
167 cache_create_db(dns_cache_t *cache, dns_db_t **db) {
168 return (dns_db_create(cache->mctx, cache->db_type, dns_rootname,
169 dns_dbtype_cache, cache->rdclass,
170 cache->db_argc, cache->db_argv, db));
174 dns_cache_create(isc_mem_t *cmctx, isc_taskmgr_t *taskmgr,
175 isc_timermgr_t *timermgr, dns_rdataclass_t rdclass,
176 const char *db_type, unsigned int db_argc, char **db_argv,
177 dns_cache_t **cachep)
179 return (dns_cache_create3(cmctx, cmctx, taskmgr, timermgr, rdclass, "",
180 db_type, db_argc, db_argv, cachep));
184 dns_cache_create2(isc_mem_t *cmctx, isc_taskmgr_t *taskmgr,
185 isc_timermgr_t *timermgr, dns_rdataclass_t rdclass,
186 const char *cachename, const char *db_type,
187 unsigned int db_argc, char **db_argv, dns_cache_t **cachep)
189 return (dns_cache_create3(cmctx, cmctx, taskmgr, timermgr, rdclass,
190 cachename, db_type, db_argc, db_argv,
195 dns_cache_create3(isc_mem_t *cmctx, isc_mem_t *hmctx, isc_taskmgr_t *taskmgr,
196 isc_timermgr_t *timermgr, dns_rdataclass_t rdclass,
197 const char *cachename, const char *db_type,
198 unsigned int db_argc, char **db_argv, dns_cache_t **cachep)
205 REQUIRE(cachep != NULL);
206 REQUIRE(*cachep == NULL);
207 REQUIRE(cmctx != NULL);
208 REQUIRE(hmctx != NULL);
209 REQUIRE(cachename != NULL);
211 cache = isc_mem_get(cmctx, sizeof(*cache));
213 return (ISC_R_NOMEMORY);
215 cache->mctx = cache->hmctx = NULL;
216 isc_mem_attach(cmctx, &cache->mctx);
217 isc_mem_attach(hmctx, &cache->hmctx);
220 if (cachename != NULL) {
221 cache->name = isc_mem_strdup(cmctx, cachename);
222 if (cache->name == NULL) {
223 result = ISC_R_NOMEMORY;
228 result = isc_mutex_init(&cache->lock);
229 if (result != ISC_R_SUCCESS)
232 result = isc_mutex_init(&cache->filelock);
233 if (result != ISC_R_SUCCESS)
236 cache->references = 1;
237 cache->live_tasks = 0;
238 cache->rdclass = rdclass;
240 cache->db_type = isc_mem_strdup(cmctx, db_type);
241 if (cache->db_type == NULL) {
242 result = ISC_R_NOMEMORY;
243 goto cleanup_filelock;
247 * For databases of type "rbt" we pass hmctx to dns_db_create()
248 * via cache->db_argv, followed by the rest of the arguments in
249 * db_argv (of which there really shouldn't be any).
251 if (strcmp(cache->db_type, "rbt") == 0)
254 cache->db_argc = db_argc + extra;
255 cache->db_argv = NULL;
257 if (cache->db_argc != 0) {
258 cache->db_argv = isc_mem_get(cmctx,
259 cache->db_argc * sizeof(char *));
260 if (cache->db_argv == NULL) {
261 result = ISC_R_NOMEMORY;
265 for (i = 0; i < cache->db_argc; i++)
266 cache->db_argv[i] = NULL;
268 cache->db_argv[0] = (char *) hmctx;
269 for (i = extra; i < cache->db_argc; i++) {
270 cache->db_argv[i] = isc_mem_strdup(cmctx,
272 if (cache->db_argv[i] == NULL) {
273 result = ISC_R_NOMEMORY;
280 * Create the database
283 result = cache_create_db(cache, &cache->db);
284 if (result != ISC_R_SUCCESS)
286 if (taskmgr != NULL) {
288 result = isc_task_create(taskmgr, 1, &dbtask);
289 if (result != ISC_R_SUCCESS)
291 dns_db_settask(cache->db, dbtask);
292 isc_task_detach(&dbtask);
295 cache->filename = NULL;
297 cache->magic = CACHE_MAGIC;
300 * RBT-type cache DB has its own mechanism of cache cleaning and doesn't
301 * need the control of the generic cleaner.
303 if (strcmp(db_type, "rbt") == 0)
304 result = cache_cleaner_init(cache, NULL, NULL, &cache->cleaner);
306 result = cache_cleaner_init(cache, taskmgr, timermgr,
309 if (result != ISC_R_SUCCESS)
313 return (ISC_R_SUCCESS);
316 dns_db_detach(&cache->db);
318 for (i = extra; i < cache->db_argc; i++)
319 if (cache->db_argv[i] != NULL)
320 isc_mem_free(cmctx, cache->db_argv[i]);
321 if (cache->db_argv != NULL)
322 isc_mem_put(cmctx, cache->db_argv,
323 cache->db_argc * sizeof(char *));
325 isc_mem_free(cmctx, cache->db_type);
327 DESTROYLOCK(&cache->filelock);
329 DESTROYLOCK(&cache->lock);
331 if (cache->name != NULL)
332 isc_mem_free(cmctx, cache->name);
333 isc_mem_detach(&cache->hmctx);
334 isc_mem_putanddetach(&cache->mctx, cache, sizeof(*cache));
339 cache_free(dns_cache_t *cache) {
342 REQUIRE(VALID_CACHE(cache));
343 REQUIRE(cache->references == 0);
345 isc_mem_setwater(cache->mctx, NULL, NULL, 0, 0);
347 if (cache->cleaner.task != NULL)
348 isc_task_detach(&cache->cleaner.task);
350 if (cache->cleaner.overmem_event != NULL)
351 isc_event_free(&cache->cleaner.overmem_event);
353 if (cache->cleaner.resched_event != NULL)
354 isc_event_free(&cache->cleaner.resched_event);
356 if (cache->cleaner.iterator != NULL)
357 dns_dbiterator_destroy(&cache->cleaner.iterator);
359 DESTROYLOCK(&cache->cleaner.lock);
361 if (cache->filename) {
362 isc_mem_free(cache->mctx, cache->filename);
363 cache->filename = NULL;
366 if (cache->db != NULL)
367 dns_db_detach(&cache->db);
369 if (cache->db_argv != NULL) {
371 * We don't free db_argv[0] in "rbt" cache databases
372 * as it's a pointer to hmctx
375 if (strcmp(cache->db_type, "rbt") == 0)
377 for (i = extra; i < cache->db_argc; i++)
378 if (cache->db_argv[i] != NULL)
379 isc_mem_free(cache->mctx, cache->db_argv[i]);
380 isc_mem_put(cache->mctx, cache->db_argv,
381 cache->db_argc * sizeof(char *));
384 if (cache->db_type != NULL)
385 isc_mem_free(cache->mctx, cache->db_type);
387 if (cache->name != NULL)
388 isc_mem_free(cache->mctx, cache->name);
390 DESTROYLOCK(&cache->lock);
391 DESTROYLOCK(&cache->filelock);
394 isc_mem_detach(&cache->hmctx);
395 isc_mem_putanddetach(&cache->mctx, cache, sizeof(*cache));
400 dns_cache_attach(dns_cache_t *cache, dns_cache_t **targetp) {
402 REQUIRE(VALID_CACHE(cache));
403 REQUIRE(targetp != NULL && *targetp == NULL);
407 UNLOCK(&cache->lock);
413 dns_cache_detach(dns_cache_t **cachep) {
415 isc_boolean_t free_cache = ISC_FALSE;
417 REQUIRE(cachep != NULL);
419 REQUIRE(VALID_CACHE(cache));
422 REQUIRE(cache->references > 0);
424 if (cache->references == 0) {
425 cache->cleaner.overmem = ISC_FALSE;
426 free_cache = ISC_TRUE;
433 * When the cache is shut down, dump it to a file if one is
436 isc_result_t result = dns_cache_dump(cache);
437 if (result != ISC_R_SUCCESS)
438 isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
439 DNS_LOGMODULE_CACHE, ISC_LOG_WARNING,
440 "error dumping cache: %s ",
441 isc_result_totext(result));
444 * If the cleaner task exists, let it free the cache.
446 if (cache->live_tasks > 0) {
447 isc_task_shutdown(cache->cleaner.task);
448 free_cache = ISC_FALSE;
452 UNLOCK(&cache->lock);
459 dns_cache_attachdb(dns_cache_t *cache, dns_db_t **dbp) {
460 REQUIRE(VALID_CACHE(cache));
461 REQUIRE(dbp != NULL && *dbp == NULL);
462 REQUIRE(cache->db != NULL);
465 dns_db_attach(cache->db, dbp);
466 UNLOCK(&cache->lock);
471 dns_cache_setfilename(dns_cache_t *cache, const char *filename) {
474 REQUIRE(VALID_CACHE(cache));
475 REQUIRE(filename != NULL);
477 newname = isc_mem_strdup(cache->mctx, filename);
479 return (ISC_R_NOMEMORY);
481 LOCK(&cache->filelock);
483 isc_mem_free(cache->mctx, cache->filename);
484 cache->filename = newname;
485 UNLOCK(&cache->filelock);
487 return (ISC_R_SUCCESS);
492 dns_cache_load(dns_cache_t *cache) {
495 REQUIRE(VALID_CACHE(cache));
497 if (cache->filename == NULL)
498 return (ISC_R_SUCCESS);
500 LOCK(&cache->filelock);
501 result = dns_db_load(cache->db, cache->filename);
502 UNLOCK(&cache->filelock);
509 dns_cache_dump(dns_cache_t *cache) {
514 REQUIRE(VALID_CACHE(cache));
516 if (cache->filename == NULL)
517 return (ISC_R_SUCCESS);
520 LOCK(&cache->filelock);
521 result = dns_master_dump(cache->mctx, cache->db, NULL,
522 &dns_master_style_cache, cache->filename);
523 UNLOCK(&cache->filelock);
526 return (ISC_R_NOTIMPLEMENTED);
532 dns_cache_setcleaninginterval(dns_cache_t *cache, unsigned int t) {
533 isc_interval_t interval;
539 * It may be the case that the cache has already shut down.
540 * If so, it has no timer.
542 if (cache->cleaner.cleaning_timer == NULL)
545 cache->cleaner.cleaning_interval = t;
548 result = isc_timer_reset(cache->cleaner.cleaning_timer,
549 isc_timertype_inactive,
550 NULL, NULL, ISC_TRUE);
552 isc_interval_set(&interval, cache->cleaner.cleaning_interval,
554 result = isc_timer_reset(cache->cleaner.cleaning_timer,
555 isc_timertype_ticker,
556 NULL, &interval, ISC_FALSE);
558 if (result != ISC_R_SUCCESS)
559 isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
560 DNS_LOGMODULE_CACHE, ISC_LOG_WARNING,
561 "could not set cache cleaning interval: %s",
562 isc_result_totext(result));
565 UNLOCK(&cache->lock);
569 dns_cache_getcleaninginterval(dns_cache_t *cache) {
572 REQUIRE(VALID_CACHE(cache));
575 t = cache->cleaner.cleaning_interval;
576 UNLOCK(&cache->lock);
582 dns_cache_getname(dns_cache_t *cache) {
583 REQUIRE(VALID_CACHE(cache));
585 return (cache->name);
589 * Initialize the cache cleaner object at *cleaner.
590 * Space for the object must be allocated by the caller.
594 cache_cleaner_init(dns_cache_t *cache, isc_taskmgr_t *taskmgr,
595 isc_timermgr_t *timermgr, cache_cleaner_t *cleaner)
599 result = isc_mutex_init(&cleaner->lock);
600 if (result != ISC_R_SUCCESS)
603 cleaner->increment = DNS_CACHE_CLEANERINCREMENT;
604 cleaner->state = cleaner_s_idle;
605 cleaner->cache = cache;
606 cleaner->iterator = NULL;
607 cleaner->overmem = ISC_FALSE;
608 cleaner->replaceiterator = ISC_FALSE;
610 cleaner->task = NULL;
611 cleaner->cleaning_timer = NULL;
612 cleaner->resched_event = NULL;
613 cleaner->overmem_event = NULL;
614 cleaner->cleaning_interval = 0; /* Initially turned off. */
616 result = dns_db_createiterator(cleaner->cache->db, ISC_FALSE,
618 if (result != ISC_R_SUCCESS)
621 if (taskmgr != NULL && timermgr != NULL) {
622 result = isc_task_create(taskmgr, 1, &cleaner->task);
623 if (result != ISC_R_SUCCESS) {
624 UNEXPECTED_ERROR(__FILE__, __LINE__,
625 "isc_task_create() failed: %s",
626 dns_result_totext(result));
627 result = ISC_R_UNEXPECTED;
630 cleaner->cache->live_tasks++;
631 isc_task_setname(cleaner->task, "cachecleaner", cleaner);
633 result = isc_task_onshutdown(cleaner->task,
634 cleaner_shutdown_action, cache);
635 if (result != ISC_R_SUCCESS) {
636 UNEXPECTED_ERROR(__FILE__, __LINE__,
638 "isc_task_onshutdown() failed: %s",
639 dns_result_totext(result));
643 result = isc_timer_create(timermgr, isc_timertype_inactive,
644 NULL, NULL, cleaner->task,
645 cleaning_timer_action, cleaner,
646 &cleaner->cleaning_timer);
647 if (result != ISC_R_SUCCESS) {
648 UNEXPECTED_ERROR(__FILE__, __LINE__,
649 "isc_timer_create() failed: %s",
650 dns_result_totext(result));
651 result = ISC_R_UNEXPECTED;
655 cleaner->resched_event =
656 isc_event_allocate(cache->mctx, cleaner,
657 DNS_EVENT_CACHECLEAN,
658 incremental_cleaning_action,
659 cleaner, sizeof(isc_event_t));
660 if (cleaner->resched_event == NULL) {
661 result = ISC_R_NOMEMORY;
665 cleaner->overmem_event =
666 isc_event_allocate(cache->mctx, cleaner,
667 DNS_EVENT_CACHEOVERMEM,
668 overmem_cleaning_action,
669 cleaner, sizeof(isc_event_t));
670 if (cleaner->overmem_event == NULL) {
671 result = ISC_R_NOMEMORY;
676 return (ISC_R_SUCCESS);
679 if (cleaner->overmem_event != NULL)
680 isc_event_free(&cleaner->overmem_event);
681 if (cleaner->resched_event != NULL)
682 isc_event_free(&cleaner->resched_event);
683 if (cleaner->cleaning_timer != NULL)
684 isc_timer_detach(&cleaner->cleaning_timer);
685 if (cleaner->task != NULL)
686 isc_task_detach(&cleaner->task);
687 if (cleaner->iterator != NULL)
688 dns_dbiterator_destroy(&cleaner->iterator);
689 DESTROYLOCK(&cleaner->lock);
695 begin_cleaning(cache_cleaner_t *cleaner) {
696 isc_result_t result = ISC_R_SUCCESS;
698 REQUIRE(CLEANER_IDLE(cleaner));
701 * Create an iterator, if it does not already exist, and
702 * position it at the beginning of the cache.
704 if (cleaner->iterator == NULL)
705 result = dns_db_createiterator(cleaner->cache->db, ISC_FALSE,
707 if (result != ISC_R_SUCCESS)
708 isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
709 DNS_LOGMODULE_CACHE, ISC_LOG_WARNING,
710 "cache cleaner could not create "
711 "iterator: %s", isc_result_totext(result));
713 dns_dbiterator_setcleanmode(cleaner->iterator, ISC_TRUE);
714 result = dns_dbiterator_first(cleaner->iterator);
716 if (result != ISC_R_SUCCESS) {
718 * If the result is ISC_R_NOMORE, the database is empty,
719 * so there is nothing to be cleaned.
721 if (result != ISC_R_NOMORE && cleaner->iterator != NULL) {
722 UNEXPECTED_ERROR(__FILE__, __LINE__,
724 "dns_dbiterator_first() failed: %s",
725 dns_result_totext(result));
726 dns_dbiterator_destroy(&cleaner->iterator);
727 } else if (cleaner->iterator != NULL) {
728 result = dns_dbiterator_pause(cleaner->iterator);
729 RUNTIME_CHECK(result == ISC_R_SUCCESS);
733 * Pause the iterator to free its lock.
735 result = dns_dbiterator_pause(cleaner->iterator);
736 RUNTIME_CHECK(result == ISC_R_SUCCESS);
738 isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
739 DNS_LOGMODULE_CACHE, ISC_LOG_DEBUG(1),
740 "begin cache cleaning, mem inuse %lu",
741 (unsigned long)isc_mem_inuse(cleaner->cache->mctx));
742 cleaner->state = cleaner_s_busy;
743 isc_task_send(cleaner->task, &cleaner->resched_event);
750 end_cleaning(cache_cleaner_t *cleaner, isc_event_t *event) {
753 REQUIRE(CLEANER_BUSY(cleaner));
754 REQUIRE(event != NULL);
756 result = dns_dbiterator_pause(cleaner->iterator);
757 if (result != ISC_R_SUCCESS)
758 dns_dbiterator_destroy(&cleaner->iterator);
760 dns_cache_setcleaninginterval(cleaner->cache,
761 cleaner->cleaning_interval);
763 isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_CACHE,
764 ISC_LOG_DEBUG(1), "end cache cleaning, mem inuse %lu",
765 (unsigned long)isc_mem_inuse(cleaner->cache->mctx));
767 cleaner->state = cleaner_s_idle;
768 cleaner->resched_event = event;
772 * This is run once for every cache-cleaning-interval as defined in named.conf.
775 cleaning_timer_action(isc_task_t *task, isc_event_t *event) {
776 cache_cleaner_t *cleaner = event->ev_arg;
780 INSIST(task == cleaner->task);
781 INSIST(event->ev_type == ISC_TIMEREVENT_TICK);
783 isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_CACHE,
784 ISC_LOG_DEBUG(1), "cache cleaning timer fired, "
785 "cleaner state = %d", cleaner->state);
787 if (cleaner->state == cleaner_s_idle)
788 begin_cleaning(cleaner);
790 isc_event_free(&event);
794 * This is called when the cache either surpasses its upper limit
795 * or shrinks beyond its lower limit.
798 overmem_cleaning_action(isc_task_t *task, isc_event_t *event) {
799 cache_cleaner_t *cleaner = event->ev_arg;
800 isc_boolean_t want_cleaning = ISC_FALSE;
804 INSIST(task == cleaner->task);
805 INSIST(event->ev_type == DNS_EVENT_CACHEOVERMEM);
806 INSIST(cleaner->overmem_event == NULL);
808 isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_CACHE,
809 ISC_LOG_DEBUG(1), "overmem_cleaning_action called, "
810 "overmem = %d, state = %d", cleaner->overmem,
813 LOCK(&cleaner->lock);
815 if (cleaner->overmem) {
816 if (cleaner->state == cleaner_s_idle)
817 want_cleaning = ISC_TRUE;
819 if (cleaner->state == cleaner_s_busy)
821 * end_cleaning() can't be called here because
822 * then both cleaner->overmem_event and
823 * cleaner->resched_event will point to this
824 * event. Set the state to done, and then
825 * when the incremental_cleaning_action() event
826 * is posted, it will handle the end_cleaning.
828 cleaner->state = cleaner_s_done;
831 cleaner->overmem_event = event;
833 UNLOCK(&cleaner->lock);
836 begin_cleaning(cleaner);
840 * Do incremental cleaning.
843 incremental_cleaning_action(isc_task_t *task, isc_event_t *event) {
844 cache_cleaner_t *cleaner = event->ev_arg;
846 unsigned int n_names;
851 INSIST(task == cleaner->task);
852 INSIST(event->ev_type == DNS_EVENT_CACHECLEAN);
854 if (cleaner->state == cleaner_s_done) {
855 cleaner->state = cleaner_s_busy;
856 end_cleaning(cleaner, event);
857 LOCK(&cleaner->cache->lock);
858 LOCK(&cleaner->lock);
859 if (cleaner->replaceiterator) {
860 dns_dbiterator_destroy(&cleaner->iterator);
861 (void) dns_db_createiterator(cleaner->cache->db,
864 cleaner->replaceiterator = ISC_FALSE;
866 UNLOCK(&cleaner->lock);
867 UNLOCK(&cleaner->cache->lock);
871 INSIST(CLEANER_BUSY(cleaner));
873 n_names = cleaner->increment;
875 REQUIRE(DNS_DBITERATOR_VALID(cleaner->iterator));
877 isc_time_now(&start);
878 while (n_names-- > 0) {
879 dns_dbnode_t *node = NULL;
881 result = dns_dbiterator_current(cleaner->iterator, &node,
883 if (result != ISC_R_SUCCESS) {
884 UNEXPECTED_ERROR(__FILE__, __LINE__,
885 "cache cleaner: dns_dbiterator_current() "
886 "failed: %s", dns_result_totext(result));
888 end_cleaning(cleaner, event);
893 * The node was not needed, but was required by
894 * dns_dbiterator_current(). Give up its reference.
896 dns_db_detachnode(cleaner->cache->db, &node);
899 * Step to the next node.
901 result = dns_dbiterator_next(cleaner->iterator);
903 if (result != ISC_R_SUCCESS) {
905 * Either the end was reached (ISC_R_NOMORE) or
906 * some error was signaled. If the cache is still
907 * overmem and no error was encountered,
908 * keep trying to clean it, otherwise stop cleaning.
910 if (result != ISC_R_NOMORE)
911 UNEXPECTED_ERROR(__FILE__, __LINE__,
913 "dns_dbiterator_next() "
915 dns_result_totext(result));
916 else if (cleaner->overmem) {
917 result = dns_dbiterator_first(cleaner->
919 if (result == ISC_R_SUCCESS) {
920 isc_log_write(dns_lctx,
921 DNS_LOGCATEGORY_DATABASE,
926 "reset and try again");
931 end_cleaning(cleaner, event);
937 * We have successfully performed a cleaning increment but have
938 * not gone through the entire cache. Free the iterator locks
939 * and reschedule another batch. If it fails, just try to continue
942 result = dns_dbiterator_pause(cleaner->iterator);
943 RUNTIME_CHECK(result == ISC_R_SUCCESS);
945 isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_CACHE,
946 ISC_LOG_DEBUG(1), "cache cleaner: checked %u nodes, "
947 "mem inuse %lu, sleeping", cleaner->increment,
948 (unsigned long)isc_mem_inuse(cleaner->cache->mctx));
950 isc_task_send(task, &event);
951 INSIST(CLEANER_BUSY(cleaner));
956 * Do immediate cleaning.
959 dns_cache_clean(dns_cache_t *cache, isc_stdtime_t now) {
961 dns_dbiterator_t *iterator = NULL;
963 REQUIRE(VALID_CACHE(cache));
965 result = dns_db_createiterator(cache->db, 0, &iterator);
966 if (result != ISC_R_SUCCESS)
969 result = dns_dbiterator_first(iterator);
971 while (result == ISC_R_SUCCESS) {
972 dns_dbnode_t *node = NULL;
973 result = dns_dbiterator_current(iterator, &node,
975 if (result != ISC_R_SUCCESS)
979 * Check TTLs, mark expired rdatasets stale.
981 result = dns_db_expirenode(cache->db, node, now);
982 if (result != ISC_R_SUCCESS) {
983 UNEXPECTED_ERROR(__FILE__, __LINE__,
984 "cache cleaner: dns_db_expirenode() "
986 dns_result_totext(result));
993 * This is where the actual freeing takes place.
995 dns_db_detachnode(cache->db, &node);
997 result = dns_dbiterator_next(iterator);
1000 dns_dbiterator_destroy(&iterator);
1002 if (result == ISC_R_NOMORE)
1003 result = ISC_R_SUCCESS;
1009 water(void *arg, int mark) {
1010 dns_cache_t *cache = arg;
1011 isc_boolean_t overmem = ISC_TF(mark == ISC_MEM_HIWATER);
1013 REQUIRE(VALID_CACHE(cache));
1015 LOCK(&cache->cleaner.lock);
1017 if (overmem != cache->cleaner.overmem) {
1018 dns_db_overmem(cache->db, overmem);
1019 cache->cleaner.overmem = overmem;
1020 isc_mem_waterack(cache->mctx, mark);
1023 if (cache->cleaner.overmem_event != NULL)
1024 isc_task_send(cache->cleaner.task,
1025 &cache->cleaner.overmem_event);
1027 UNLOCK(&cache->cleaner.lock);
1031 dns_cache_setcachesize(dns_cache_t *cache, size_t size) {
1032 size_t hiwater, lowater;
1034 REQUIRE(VALID_CACHE(cache));
1037 * Impose a minimum cache size; pathological things happen if there
1038 * is too little room.
1040 if (size != 0U && size < DNS_CACHE_MINSIZE)
1041 size = DNS_CACHE_MINSIZE;
1045 UNLOCK(&cache->lock);
1047 hiwater = size - (size >> 3); /* Approximately 7/8ths. */
1048 lowater = size - (size >> 2); /* Approximately 3/4ths. */
1051 * If the cache was overmem and cleaning, but now with the new limits
1052 * it is no longer in an overmem condition, then the next
1053 * isc_mem_put for cache memory will do the right thing and trigger
1057 if (size == 0U || hiwater == 0U || lowater == 0U)
1059 * Disable cache memory limiting.
1061 isc_mem_setwater(cache->mctx, water, cache, 0, 0);
1064 * Establish new cache memory limits (either for the first
1065 * time, or replacing other limits).
1067 isc_mem_setwater(cache->mctx, water, cache, hiwater, lowater);
1071 dns_cache_getcachesize(dns_cache_t *cache) {
1074 REQUIRE(VALID_CACHE(cache));
1078 UNLOCK(&cache->lock);
1084 * The cleaner task is shutting down; do the necessary cleanup.
1087 cleaner_shutdown_action(isc_task_t *task, isc_event_t *event) {
1088 dns_cache_t *cache = event->ev_arg;
1089 isc_boolean_t should_free = ISC_FALSE;
1093 INSIST(task == cache->cleaner.task);
1094 INSIST(event->ev_type == ISC_TASKEVENT_SHUTDOWN);
1096 if (CLEANER_BUSY(&cache->cleaner))
1097 end_cleaning(&cache->cleaner, event);
1099 isc_event_free(&event);
1103 cache->live_tasks--;
1104 INSIST(cache->live_tasks == 0);
1106 if (cache->references == 0)
1107 should_free = ISC_TRUE;
1110 * By detaching the timer in the context of its task,
1111 * we are guaranteed that there will be no further timer
1114 if (cache->cleaner.cleaning_timer != NULL)
1115 isc_timer_detach(&cache->cleaner.cleaning_timer);
1117 /* Make sure we don't reschedule anymore. */
1118 (void)isc_task_purge(task, NULL, DNS_EVENT_CACHECLEAN, NULL);
1120 UNLOCK(&cache->lock);
1127 dns_cache_flush(dns_cache_t *cache) {
1128 dns_db_t *db = NULL;
1129 isc_result_t result;
1131 result = cache_create_db(cache, &db);
1132 if (result != ISC_R_SUCCESS)
1136 LOCK(&cache->cleaner.lock);
1137 if (cache->cleaner.state == cleaner_s_idle) {
1138 if (cache->cleaner.iterator != NULL)
1139 dns_dbiterator_destroy(&cache->cleaner.iterator);
1140 (void) dns_db_createiterator(db, ISC_FALSE,
1141 &cache->cleaner.iterator);
1143 if (cache->cleaner.state == cleaner_s_busy)
1144 cache->cleaner.state = cleaner_s_done;
1145 cache->cleaner.replaceiterator = ISC_TRUE;
1147 dns_db_detach(&cache->db);
1149 UNLOCK(&cache->cleaner.lock);
1150 UNLOCK(&cache->lock);
1152 return (ISC_R_SUCCESS);
1156 clearnode(dns_db_t *db, dns_dbnode_t *node) {
1157 isc_result_t result;
1158 dns_rdatasetiter_t *iter = NULL;
1160 result = dns_db_allrdatasets(db, node, NULL, (isc_stdtime_t)0, &iter);
1161 if (result != ISC_R_SUCCESS)
1164 for (result = dns_rdatasetiter_first(iter);
1165 result == ISC_R_SUCCESS;
1166 result = dns_rdatasetiter_next(iter))
1168 dns_rdataset_t rdataset;
1169 dns_rdataset_init(&rdataset);
1171 dns_rdatasetiter_current(iter, &rdataset);
1172 result = dns_db_deleterdataset(db, node, NULL,
1173 rdataset.type, rdataset.covers);
1174 dns_rdataset_disassociate(&rdataset);
1175 if (result != ISC_R_SUCCESS && result != DNS_R_UNCHANGED)
1179 if (result == ISC_R_NOMORE)
1180 result = ISC_R_SUCCESS;
1182 dns_rdatasetiter_destroy(&iter);
1187 cleartree(dns_db_t *db, dns_name_t *name) {
1188 isc_result_t result, answer = ISC_R_SUCCESS;
1189 dns_dbiterator_t *iter = NULL;
1190 dns_dbnode_t *node = NULL;
1191 dns_fixedname_t fnodename;
1192 dns_name_t *nodename;
1194 dns_fixedname_init(&fnodename);
1195 nodename = dns_fixedname_name(&fnodename);
1197 result = dns_db_createiterator(db, 0, &iter);
1198 if (result != ISC_R_SUCCESS)
1201 result = dns_dbiterator_seek(iter, name);
1202 if (result != ISC_R_SUCCESS)
1205 while (result == ISC_R_SUCCESS) {
1206 result = dns_dbiterator_current(iter, &node, nodename);
1207 if (result == DNS_R_NEWORIGIN)
1208 result = ISC_R_SUCCESS;
1209 if (result != ISC_R_SUCCESS)
1214 if (! dns_name_issubdomain(nodename, name))
1218 * If clearnode fails record and move onto the next node.
1220 result = clearnode(db, node);
1221 if (result != ISC_R_SUCCESS && answer == ISC_R_SUCCESS)
1223 dns_db_detachnode(db, &node);
1224 result = dns_dbiterator_next(iter);
1228 if (result == ISC_R_NOMORE || result == ISC_R_NOTFOUND)
1229 result = ISC_R_SUCCESS;
1230 if (result != ISC_R_SUCCESS && answer == ISC_R_SUCCESS)
1233 dns_db_detachnode(db, &node);
1235 dns_dbiterator_destroy(&iter);
1241 dns_cache_flushname(dns_cache_t *cache, dns_name_t *name) {
1242 return (dns_cache_flushnode(cache, name, ISC_FALSE));
1246 dns_cache_flushnode(dns_cache_t *cache, dns_name_t *name,
1249 isc_result_t result;
1250 dns_dbnode_t *node = NULL;
1251 dns_db_t *db = NULL;
1253 if (dns_name_equal(name, dns_rootname))
1254 return (dns_cache_flush(cache));
1257 if (cache->db != NULL)
1258 dns_db_attach(cache->db, &db);
1259 UNLOCK(&cache->lock);
1261 return (ISC_R_SUCCESS);
1264 result = cleartree(cache->db, name);
1266 result = dns_db_findnode(cache->db, name, ISC_FALSE, &node);
1267 if (result == ISC_R_NOTFOUND) {
1268 result = ISC_R_SUCCESS;
1271 if (result != ISC_R_SUCCESS)
1273 result = clearnode(cache->db, node);
1274 dns_db_detachnode(cache->db, &node);