2 * Copyright (C) 2004-2006 Internet Systems Consortium, Inc. ("ISC")
3 * Copyright (C) 1999-2003 Internet Software Consortium.
5 * Permission to use, copy, modify, and 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.57.18.16 2006/08/01 01:06:48 marka Exp $ */
27 #include <isc/timer.h>
30 #include <dns/cache.h>
32 #include <dns/dbiterator.h>
33 #include <dns/events.h>
36 #include <dns/masterdump.h>
37 #include <dns/rdata.h>
38 #include <dns/rdataset.h>
39 #include <dns/rdatasetiter.h>
40 #include <dns/result.h>
42 #define CACHE_MAGIC ISC_MAGIC('$', '$', '$', '$')
43 #define VALID_CACHE(cache) ISC_MAGIC_VALID(cache, CACHE_MAGIC)
46 * Control incremental cleaning.
47 * DNS_CACHE_MINSIZE is how many bytes is the floor for dns_cache_setcachesize().
48 * See also DNS_CACHE_CLEANERINCREMENT
50 #define DNS_CACHE_MINSIZE 2097152 /*%< Bytes. 2097152 = 2 MB */
52 * Control incremental cleaning.
53 * CLEANERINCREMENT is how many nodes are examined in one pass.
54 * See also DNS_CACHE_MINSIZE
56 #define DNS_CACHE_CLEANERINCREMENT 1000U /*%< Number of nodes. */
63 * A cache_cleaner_t encapsulsates the state of the periodic
67 typedef struct cache_cleaner cache_cleaner_t;
70 cleaner_s_idle, /*%< Waiting for cleaning-interval to expire. */
71 cleaner_s_busy, /*%< Currently cleaning. */
72 cleaner_s_done /*%< Freed enough memory after being overmem. */
76 * Convenience macros for comprehensive assertion checking.
78 #define CLEANER_IDLE(c) ((c)->state == cleaner_s_idle && \
79 (c)->resched_event != NULL)
80 #define CLEANER_BUSY(c) ((c)->state == cleaner_s_busy && \
81 (c)->iterator != NULL && \
82 (c)->resched_event == NULL)
85 * Accesses to a cache cleaner object are synchronized through
86 * task/event serialization, or locked from the cache object.
88 struct cache_cleaner {
91 * Locks overmem_event, overmem. Note: never allocate memory
92 * while holding this lock - that could lead to deadlock since
93 * the lock is take by water() which is called from the memory
99 unsigned int cleaning_interval; /*% The cleaning-interval from
100 named.conf, in seconds. */
101 isc_timer_t *cleaning_timer;
102 isc_event_t *resched_event; /*% Sent by cleaner task to
103 itself to reschedule */
104 isc_event_t *overmem_event;
106 dns_dbiterator_t *iterator;
107 unsigned int increment; /*% Number of names to
108 clean in one increment */
109 cleaner_state_t state; /*% Idle/Busy. */
110 isc_boolean_t overmem; /*% The cache is in an overmem state. */
111 isc_boolean_t replaceiterator;
115 * The actual cache object.
122 isc_mutex_t filelock;
125 /* Locked by 'lock'. */
128 dns_rdataclass_t rdclass;
130 cache_cleaner_t cleaner;
135 /* Locked by 'filelock'. */
137 /* Access to the on-disk cache file is also locked by 'filelock'. */
145 cache_cleaner_init(dns_cache_t *cache, isc_taskmgr_t *taskmgr,
146 isc_timermgr_t *timermgr, cache_cleaner_t *cleaner);
149 cleaning_timer_action(isc_task_t *task, isc_event_t *event);
152 incremental_cleaning_action(isc_task_t *task, isc_event_t *event);
155 cleaner_shutdown_action(isc_task_t *task, isc_event_t *event);
158 overmem_cleaning_action(isc_task_t *task, isc_event_t *event);
161 * Work out how many nodes can be cleaned in the time between two
162 * requests to the nameserver. Smooth the resulting number and use
163 * it as a estimate for the number of nodes to be cleaned in the next
167 adjust_increment(cache_cleaner_t *cleaner, unsigned int remaining,
173 unsigned int pps = dns_pps;
174 unsigned int interval;
178 * Tune for minumum of 100 packets per second (pps).
185 interval = 1000000 / pps; /* Interval between packets in usecs. */
189 INSIST(cleaner->increment >= remaining);
190 names = cleaner->increment - remaining;
191 usecs = isc_time_microdiff(&end, start);
193 isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_CACHE,
194 ISC_LOG_DEBUG(1), "adjust_increment interval=%u "
195 "names=%u usec=%" ISC_PLATFORM_QUADFORMAT "u",
196 interval, names, usecs);
200 * If we cleaned all the nodes in unmeasurable time
201 * double the number of nodes to be cleaned next time.
203 if (names == cleaner->increment) {
204 cleaner->increment *= 2;
205 if (cleaner->increment > DNS_CACHE_CLEANERINCREMENT)
206 cleaner->increment = DNS_CACHE_CLEANERINCREMENT;
207 isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
208 DNS_LOGMODULE_CACHE, ISC_LOG_DEBUG(1),
209 "%p:new cleaner->increment = %u\n",
210 cleaner, cleaner->increment);
215 new = (names * interval);
221 new = (new + cleaner->increment * 7) / 8;
223 if (new > DNS_CACHE_CLEANERINCREMENT)
224 new = DNS_CACHE_CLEANERINCREMENT;
226 cleaner->increment = (unsigned int)new;
228 isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_CACHE,
229 ISC_LOG_DEBUG(1), "%p:new cleaner->increment = %u\n",
230 cleaner, cleaner->increment);
233 static inline isc_result_t
234 cache_create_db(dns_cache_t *cache, dns_db_t **db) {
235 return (dns_db_create(cache->mctx, cache->db_type, dns_rootname,
236 dns_dbtype_cache, cache->rdclass,
237 cache->db_argc, cache->db_argv, db));
241 dns_cache_create(isc_mem_t *mctx, isc_taskmgr_t *taskmgr,
242 isc_timermgr_t *timermgr, dns_rdataclass_t rdclass,
243 const char *db_type, unsigned int db_argc, char **db_argv,
244 dns_cache_t **cachep)
250 REQUIRE(cachep != NULL);
251 REQUIRE(*cachep == NULL);
252 REQUIRE(mctx != NULL);
254 cache = isc_mem_get(mctx, sizeof(*cache));
256 return (ISC_R_NOMEMORY);
259 isc_mem_attach(mctx, &cache->mctx);
261 result = isc_mutex_init(&cache->lock);
262 if (result != ISC_R_SUCCESS)
265 result = isc_mutex_init(&cache->filelock);
266 if (result != ISC_R_SUCCESS)
269 cache->references = 1;
270 cache->live_tasks = 0;
271 cache->rdclass = rdclass;
273 cache->db_type = isc_mem_strdup(mctx, db_type);
274 if (cache->db_type == NULL) {
275 result = ISC_R_NOMEMORY;
276 goto cleanup_filelock;
279 cache->db_argc = db_argc;
280 if (cache->db_argc == 0)
281 cache->db_argv = NULL;
283 cache->db_argv = isc_mem_get(mctx,
284 cache->db_argc * sizeof(char *));
285 if (cache->db_argv == NULL) {
286 result = ISC_R_NOMEMORY;
289 for (i = 0; i < cache->db_argc; i++)
290 cache->db_argv[i] = NULL;
291 for (i = 0; i < cache->db_argc; i++) {
292 cache->db_argv[i] = isc_mem_strdup(mctx, db_argv[i]);
293 if (cache->db_argv[i] == NULL) {
294 result = ISC_R_NOMEMORY;
301 result = cache_create_db(cache, &cache->db);
302 if (result != ISC_R_SUCCESS)
305 cache->filename = NULL;
307 cache->magic = CACHE_MAGIC;
309 result = cache_cleaner_init(cache, taskmgr, timermgr, &cache->cleaner);
310 if (result != ISC_R_SUCCESS)
314 return (ISC_R_SUCCESS);
317 dns_db_detach(&cache->db);
319 for (i = 0; i < cache->db_argc; i++)
320 if (cache->db_argv[i] != NULL)
321 isc_mem_free(mctx, cache->db_argv[i]);
322 if (cache->db_argv != NULL)
323 isc_mem_put(mctx, cache->db_argv,
324 cache->db_argc * sizeof(char *));
326 isc_mem_free(mctx, cache->db_type);
328 DESTROYLOCK(&cache->filelock);
330 DESTROYLOCK(&cache->lock);
332 isc_mem_put(mctx, cache, sizeof(*cache));
333 isc_mem_detach(&mctx);
338 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) {
370 for (i = 0; i < cache->db_argc; i++)
371 if (cache->db_argv[i] != NULL)
372 isc_mem_free(cache->mctx, cache->db_argv[i]);
373 isc_mem_put(cache->mctx, cache->db_argv,
374 cache->db_argc * sizeof(char *));
377 if (cache->db_type != NULL)
378 isc_mem_free(cache->mctx, cache->db_type);
380 DESTROYLOCK(&cache->lock);
381 DESTROYLOCK(&cache->filelock);
384 isc_mem_put(cache->mctx, cache, sizeof(*cache));
385 isc_mem_detach(&mctx);
390 dns_cache_attach(dns_cache_t *cache, dns_cache_t **targetp) {
392 REQUIRE(VALID_CACHE(cache));
393 REQUIRE(targetp != NULL && *targetp == NULL);
397 UNLOCK(&cache->lock);
403 dns_cache_detach(dns_cache_t **cachep) {
405 isc_boolean_t free_cache = ISC_FALSE;
407 REQUIRE(cachep != NULL);
409 REQUIRE(VALID_CACHE(cache));
412 REQUIRE(cache->references > 0);
414 if (cache->references == 0) {
415 cache->cleaner.overmem = ISC_FALSE;
416 free_cache = ISC_TRUE;
423 * When the cache is shut down, dump it to a file if one is
426 isc_result_t result = dns_cache_dump(cache);
427 if (result != ISC_R_SUCCESS)
428 isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
429 DNS_LOGMODULE_CACHE, ISC_LOG_WARNING,
430 "error dumping cache: %s ",
431 isc_result_totext(result));
434 * If the cleaner task exists, let it free the cache.
436 if (cache->live_tasks > 0) {
437 isc_task_shutdown(cache->cleaner.task);
438 free_cache = ISC_FALSE;
442 UNLOCK(&cache->lock);
449 dns_cache_attachdb(dns_cache_t *cache, dns_db_t **dbp) {
450 REQUIRE(VALID_CACHE(cache));
451 REQUIRE(dbp != NULL && *dbp == NULL);
452 REQUIRE(cache->db != NULL);
455 dns_db_attach(cache->db, dbp);
456 UNLOCK(&cache->lock);
461 dns_cache_setfilename(dns_cache_t *cache, const char *filename) {
464 REQUIRE(VALID_CACHE(cache));
465 REQUIRE(filename != NULL);
467 newname = isc_mem_strdup(cache->mctx, filename);
469 return (ISC_R_NOMEMORY);
471 LOCK(&cache->filelock);
473 isc_mem_free(cache->mctx, cache->filename);
474 cache->filename = newname;
475 UNLOCK(&cache->filelock);
477 return (ISC_R_SUCCESS);
481 dns_cache_load(dns_cache_t *cache) {
484 REQUIRE(VALID_CACHE(cache));
486 if (cache->filename == NULL)
487 return (ISC_R_SUCCESS);
489 LOCK(&cache->filelock);
490 result = dns_db_load(cache->db, cache->filename);
491 UNLOCK(&cache->filelock);
497 dns_cache_dump(dns_cache_t *cache) {
500 REQUIRE(VALID_CACHE(cache));
502 if (cache->filename == NULL)
503 return (ISC_R_SUCCESS);
505 LOCK(&cache->filelock);
506 result = dns_master_dump(cache->mctx, cache->db, NULL,
507 &dns_master_style_cache, cache->filename);
508 UNLOCK(&cache->filelock);
514 dns_cache_setcleaninginterval(dns_cache_t *cache, unsigned int t) {
515 isc_interval_t interval;
521 * It may be the case that the cache has already shut down.
522 * If so, it has no timer.
524 if (cache->cleaner.cleaning_timer == NULL)
527 cache->cleaner.cleaning_interval = t;
530 result = isc_timer_reset(cache->cleaner.cleaning_timer,
531 isc_timertype_inactive,
532 NULL, NULL, ISC_TRUE);
534 isc_interval_set(&interval, cache->cleaner.cleaning_interval,
536 result = isc_timer_reset(cache->cleaner.cleaning_timer,
537 isc_timertype_ticker,
538 NULL, &interval, ISC_FALSE);
540 if (result != ISC_R_SUCCESS)
541 isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
542 DNS_LOGMODULE_CACHE, ISC_LOG_WARNING,
543 "could not set cache cleaning interval: %s",
544 isc_result_totext(result));
547 UNLOCK(&cache->lock);
551 * Initialize the cache cleaner object at *cleaner.
552 * Space for the object must be allocated by the caller.
556 cache_cleaner_init(dns_cache_t *cache, isc_taskmgr_t *taskmgr,
557 isc_timermgr_t *timermgr, cache_cleaner_t *cleaner)
561 result = isc_mutex_init(&cleaner->lock);
562 if (result != ISC_R_SUCCESS)
565 cleaner->increment = DNS_CACHE_CLEANERINCREMENT;
566 cleaner->state = cleaner_s_idle;
567 cleaner->cache = cache;
568 cleaner->iterator = NULL;
569 cleaner->overmem = ISC_FALSE;
570 cleaner->replaceiterator = ISC_FALSE;
572 cleaner->task = NULL;
573 cleaner->cleaning_timer = NULL;
574 cleaner->resched_event = NULL;
575 cleaner->overmem_event = NULL;
577 result = dns_db_createiterator(cleaner->cache->db, ISC_FALSE,
579 if (result != ISC_R_SUCCESS)
582 if (taskmgr != NULL && timermgr != NULL) {
583 result = isc_task_create(taskmgr, 1, &cleaner->task);
584 if (result != ISC_R_SUCCESS) {
585 UNEXPECTED_ERROR(__FILE__, __LINE__,
586 "isc_task_create() failed: %s",
587 dns_result_totext(result));
588 result = ISC_R_UNEXPECTED;
591 cleaner->cache->live_tasks++;
592 isc_task_setname(cleaner->task, "cachecleaner", cleaner);
594 result = isc_task_onshutdown(cleaner->task,
595 cleaner_shutdown_action, cache);
596 if (result != ISC_R_SUCCESS) {
597 UNEXPECTED_ERROR(__FILE__, __LINE__,
599 "isc_task_onshutdown() failed: %s",
600 dns_result_totext(result));
604 cleaner->cleaning_interval = 0; /* Initially turned off. */
605 result = isc_timer_create(timermgr, isc_timertype_inactive,
608 cleaning_timer_action, cleaner,
609 &cleaner->cleaning_timer);
610 if (result != ISC_R_SUCCESS) {
611 UNEXPECTED_ERROR(__FILE__, __LINE__,
612 "isc_timer_create() failed: %s",
613 dns_result_totext(result));
614 result = ISC_R_UNEXPECTED;
618 cleaner->resched_event =
619 isc_event_allocate(cache->mctx, cleaner,
620 DNS_EVENT_CACHECLEAN,
621 incremental_cleaning_action,
622 cleaner, sizeof(isc_event_t));
623 if (cleaner->resched_event == NULL) {
624 result = ISC_R_NOMEMORY;
628 cleaner->overmem_event =
629 isc_event_allocate(cache->mctx, cleaner,
630 DNS_EVENT_CACHEOVERMEM,
631 overmem_cleaning_action,
632 cleaner, sizeof(isc_event_t));
633 if (cleaner->overmem_event == NULL) {
634 result = ISC_R_NOMEMORY;
639 return (ISC_R_SUCCESS);
642 if (cleaner->overmem_event != NULL)
643 isc_event_free(&cleaner->overmem_event);
644 if (cleaner->resched_event != NULL)
645 isc_event_free(&cleaner->resched_event);
646 if (cleaner->cleaning_timer != NULL)
647 isc_timer_detach(&cleaner->cleaning_timer);
648 if (cleaner->task != NULL)
649 isc_task_detach(&cleaner->task);
650 if (cleaner->iterator != NULL)
651 dns_dbiterator_destroy(&cleaner->iterator);
652 DESTROYLOCK(&cleaner->lock);
658 begin_cleaning(cache_cleaner_t *cleaner) {
659 isc_result_t result = ISC_R_SUCCESS;
661 REQUIRE(CLEANER_IDLE(cleaner));
664 * Create an iterator, if it does not already exist, and
665 * position it at the beginning of the cache.
667 if (cleaner->iterator == NULL)
668 result = dns_db_createiterator(cleaner->cache->db, ISC_FALSE,
670 if (result != ISC_R_SUCCESS)
671 isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
672 DNS_LOGMODULE_CACHE, ISC_LOG_WARNING,
673 "cache cleaner could not create "
674 "iterator: %s", isc_result_totext(result));
676 dns_dbiterator_setcleanmode(cleaner->iterator, ISC_TRUE);
677 result = dns_dbiterator_first(cleaner->iterator);
679 if (result != ISC_R_SUCCESS) {
681 * If the result is ISC_R_NOMORE, the database is empty,
682 * so there is nothing to be cleaned.
684 if (result != ISC_R_NOMORE && cleaner->iterator != NULL) {
685 UNEXPECTED_ERROR(__FILE__, __LINE__,
687 "dns_dbiterator_first() failed: %s",
688 dns_result_totext(result));
689 dns_dbiterator_destroy(&cleaner->iterator);
690 } else if (cleaner->iterator != NULL) {
691 result = dns_dbiterator_pause(cleaner->iterator);
692 RUNTIME_CHECK(result == ISC_R_SUCCESS);
696 * Pause the iterator to free its lock.
698 result = dns_dbiterator_pause(cleaner->iterator);
699 RUNTIME_CHECK(result == ISC_R_SUCCESS);
701 isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
702 DNS_LOGMODULE_CACHE, ISC_LOG_DEBUG(1),
703 "begin cache cleaning, mem inuse %lu",
704 (unsigned long)isc_mem_inuse(cleaner->cache->mctx));
705 cleaner->state = cleaner_s_busy;
706 isc_task_send(cleaner->task, &cleaner->resched_event);
713 end_cleaning(cache_cleaner_t *cleaner, isc_event_t *event) {
716 REQUIRE(CLEANER_BUSY(cleaner));
717 REQUIRE(event != NULL);
719 result = dns_dbiterator_pause(cleaner->iterator);
720 if (result != ISC_R_SUCCESS)
721 dns_dbiterator_destroy(&cleaner->iterator);
723 dns_cache_setcleaninginterval(cleaner->cache,
724 cleaner->cleaning_interval);
726 isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_CACHE,
727 ISC_LOG_DEBUG(1), "end cache cleaning, mem inuse %lu",
728 (unsigned long)isc_mem_inuse(cleaner->cache->mctx));
730 cleaner->state = cleaner_s_idle;
731 cleaner->resched_event = event;
735 * This is run once for every cache-cleaning-interval as defined in named.conf.
738 cleaning_timer_action(isc_task_t *task, isc_event_t *event) {
739 cache_cleaner_t *cleaner = event->ev_arg;
743 INSIST(task == cleaner->task);
744 INSIST(event->ev_type == ISC_TIMEREVENT_TICK);
746 isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_CACHE,
747 ISC_LOG_DEBUG(1), "cache cleaning timer fired, "
748 "cleaner state = %d", cleaner->state);
750 if (cleaner->state == cleaner_s_idle)
751 begin_cleaning(cleaner);
753 isc_event_free(&event);
757 * This is called when the cache either surpasses its upper limit
758 * or shrinks beyond its lower limit.
761 overmem_cleaning_action(isc_task_t *task, isc_event_t *event) {
762 cache_cleaner_t *cleaner = event->ev_arg;
763 isc_boolean_t want_cleaning = ISC_FALSE;
767 INSIST(task == cleaner->task);
768 INSIST(event->ev_type == DNS_EVENT_CACHEOVERMEM);
769 INSIST(cleaner->overmem_event == NULL);
771 isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_CACHE,
772 ISC_LOG_DEBUG(1), "overmem_cleaning_action called, "
773 "overmem = %d, state = %d", cleaner->overmem,
776 LOCK(&cleaner->lock);
778 if (cleaner->overmem) {
779 if (cleaner->state == cleaner_s_idle)
780 want_cleaning = ISC_TRUE;
782 if (cleaner->state == cleaner_s_busy)
784 * end_cleaning() can't be called here because
785 * then both cleaner->overmem_event and
786 * cleaner->resched_event will point to this
787 * event. Set the state to done, and then
788 * when the incremental_cleaning_action() event
789 * is posted, it will handle the end_cleaning.
791 cleaner->state = cleaner_s_done;
794 cleaner->overmem_event = event;
796 UNLOCK(&cleaner->lock);
799 begin_cleaning(cleaner);
803 * Do incremental cleaning.
806 incremental_cleaning_action(isc_task_t *task, isc_event_t *event) {
807 cache_cleaner_t *cleaner = event->ev_arg;
809 unsigned int n_names;
814 INSIST(task == cleaner->task);
815 INSIST(event->ev_type == DNS_EVENT_CACHECLEAN);
817 if (cleaner->state == cleaner_s_done) {
818 cleaner->state = cleaner_s_busy;
819 end_cleaning(cleaner, event);
820 LOCK(&cleaner->cache->lock);
821 LOCK(&cleaner->lock);
822 if (cleaner->replaceiterator) {
823 dns_dbiterator_destroy(&cleaner->iterator);
824 (void) dns_db_createiterator(cleaner->cache->db,
827 cleaner->replaceiterator = ISC_FALSE;
829 UNLOCK(&cleaner->lock);
830 UNLOCK(&cleaner->cache->lock);
834 INSIST(CLEANER_BUSY(cleaner));
836 n_names = cleaner->increment;
838 REQUIRE(DNS_DBITERATOR_VALID(cleaner->iterator));
840 isc_time_now(&start);
841 while (n_names-- > 0) {
842 dns_dbnode_t *node = NULL;
844 result = dns_dbiterator_current(cleaner->iterator, &node,
846 if (result != ISC_R_SUCCESS) {
847 UNEXPECTED_ERROR(__FILE__, __LINE__,
848 "cache cleaner: dns_dbiterator_current() "
849 "failed: %s", dns_result_totext(result));
851 adjust_increment(cleaner, n_names, &start);
852 end_cleaning(cleaner, event);
857 * The node was not needed, but was required by
858 * dns_dbiterator_current(). Give up its reference.
860 dns_db_detachnode(cleaner->cache->db, &node);
863 * Step to the next node.
865 result = dns_dbiterator_next(cleaner->iterator);
867 if (result != ISC_R_SUCCESS) {
869 * Either the end was reached (ISC_R_NOMORE) or
870 * some error was signaled. If the cache is still
871 * overmem and no error was encountered,
872 * keep trying to clean it, otherwise stop cleaning.
874 if (result != ISC_R_NOMORE)
875 UNEXPECTED_ERROR(__FILE__, __LINE__,
877 "dns_dbiterator_next() "
879 dns_result_totext(result));
880 else if (cleaner->overmem) {
881 result = dns_dbiterator_first(cleaner->
883 if (result == ISC_R_SUCCESS) {
884 isc_log_write(dns_lctx,
885 DNS_LOGCATEGORY_DATABASE,
890 "reset and try again");
895 adjust_increment(cleaner, n_names, &start);
896 end_cleaning(cleaner, event);
901 adjust_increment(cleaner, 0U, &start);
904 * We have successfully performed a cleaning increment but have
905 * not gone through the entire cache. Free the iterator locks
906 * and reschedule another batch. If it fails, just try to continue
909 result = dns_dbiterator_pause(cleaner->iterator);
910 RUNTIME_CHECK(result == ISC_R_SUCCESS);
912 isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_CACHE,
913 ISC_LOG_DEBUG(1), "cache cleaner: checked %u nodes, "
914 "mem inuse %lu, sleeping", cleaner->increment,
915 (unsigned long)isc_mem_inuse(cleaner->cache->mctx));
917 isc_task_send(task, &event);
918 INSIST(CLEANER_BUSY(cleaner));
923 * Do immediate cleaning.
926 dns_cache_clean(dns_cache_t *cache, isc_stdtime_t now) {
928 dns_dbiterator_t *iterator = NULL;
930 REQUIRE(VALID_CACHE(cache));
932 result = dns_db_createiterator(cache->db, ISC_FALSE, &iterator);
933 if (result != ISC_R_SUCCESS)
936 result = dns_dbiterator_first(iterator);
938 while (result == ISC_R_SUCCESS) {
939 dns_dbnode_t *node = NULL;
940 result = dns_dbiterator_current(iterator, &node,
942 if (result != ISC_R_SUCCESS)
946 * Check TTLs, mark expired rdatasets stale.
948 result = dns_db_expirenode(cache->db, node, now);
949 if (result != ISC_R_SUCCESS) {
950 UNEXPECTED_ERROR(__FILE__, __LINE__,
951 "cache cleaner: dns_db_expirenode() "
953 dns_result_totext(result));
960 * This is where the actual freeing takes place.
962 dns_db_detachnode(cache->db, &node);
964 result = dns_dbiterator_next(iterator);
967 dns_dbiterator_destroy(&iterator);
969 if (result == ISC_R_NOMORE)
970 result = ISC_R_SUCCESS;
976 water(void *arg, int mark) {
977 dns_cache_t *cache = arg;
978 isc_boolean_t overmem = ISC_TF(mark == ISC_MEM_HIWATER);
980 REQUIRE(VALID_CACHE(cache));
982 LOCK(&cache->cleaner.lock);
984 dns_db_overmem(cache->db, overmem);
985 cache->cleaner.overmem = overmem;
987 if (cache->cleaner.overmem_event != NULL)
988 isc_task_send(cache->cleaner.task,
989 &cache->cleaner.overmem_event);
991 UNLOCK(&cache->cleaner.lock);
995 dns_cache_setcachesize(dns_cache_t *cache, isc_uint32_t size) {
996 isc_uint32_t lowater;
997 isc_uint32_t hiwater;
999 REQUIRE(VALID_CACHE(cache));
1002 * Impose a minumum cache size; pathological things happen if there
1003 * is too little room.
1005 if (size != 0 && size < DNS_CACHE_MINSIZE)
1006 size = DNS_CACHE_MINSIZE;
1008 hiwater = size - (size >> 3); /* Approximately 7/8ths. */
1009 lowater = size - (size >> 2); /* Approximately 3/4ths. */
1012 * If the cache was overmem and cleaning, but now with the new limits
1013 * it is no longer in an overmem condition, then the next
1014 * isc_mem_put for cache memory will do the right thing and trigger
1018 if (size == 0 || hiwater == 0 || lowater == 0)
1020 * Disable cache memory limiting.
1022 isc_mem_setwater(cache->mctx, water, cache, 0, 0);
1025 * Establish new cache memory limits (either for the first
1026 * time, or replacing other limits).
1028 isc_mem_setwater(cache->mctx, water, cache, hiwater, lowater);
1032 * The cleaner task is shutting down; do the necessary cleanup.
1035 cleaner_shutdown_action(isc_task_t *task, isc_event_t *event) {
1036 dns_cache_t *cache = event->ev_arg;
1037 isc_boolean_t should_free = ISC_FALSE;
1041 INSIST(task == cache->cleaner.task);
1042 INSIST(event->ev_type == ISC_TASKEVENT_SHUTDOWN);
1044 if (CLEANER_BUSY(&cache->cleaner))
1045 end_cleaning(&cache->cleaner, event);
1047 isc_event_free(&event);
1051 cache->live_tasks--;
1052 INSIST(cache->live_tasks == 0);
1054 if (cache->references == 0)
1055 should_free = ISC_TRUE;
1058 * By detaching the timer in the context of its task,
1059 * we are guaranteed that there will be no further timer
1062 if (cache->cleaner.cleaning_timer != NULL)
1063 isc_timer_detach(&cache->cleaner.cleaning_timer);
1065 /* Make sure we don't reschedule anymore. */
1066 (void)isc_task_purge(task, NULL, DNS_EVENT_CACHECLEAN, NULL);
1068 UNLOCK(&cache->lock);
1075 dns_cache_flush(dns_cache_t *cache) {
1076 dns_db_t *db = NULL;
1077 isc_result_t result;
1079 result = cache_create_db(cache, &db);
1080 if (result != ISC_R_SUCCESS)
1084 LOCK(&cache->cleaner.lock);
1085 if (cache->cleaner.state == cleaner_s_idle) {
1086 if (cache->cleaner.iterator != NULL)
1087 dns_dbiterator_destroy(&cache->cleaner.iterator);
1088 (void) dns_db_createiterator(db, ISC_FALSE,
1089 &cache->cleaner.iterator);
1091 if (cache->cleaner.state == cleaner_s_busy)
1092 cache->cleaner.state = cleaner_s_done;
1093 cache->cleaner.replaceiterator = ISC_TRUE;
1095 dns_db_detach(&cache->db);
1097 UNLOCK(&cache->cleaner.lock);
1098 UNLOCK(&cache->lock);
1100 return (ISC_R_SUCCESS);
1104 dns_cache_flushname(dns_cache_t *cache, dns_name_t *name) {
1105 isc_result_t result;
1106 dns_rdatasetiter_t *iter = NULL;
1107 dns_dbnode_t *node = NULL;
1108 dns_db_t *db = NULL;
1111 if (cache->db != NULL)
1112 dns_db_attach(cache->db, &db);
1113 UNLOCK(&cache->lock);
1115 return (ISC_R_SUCCESS);
1116 result = dns_db_findnode(cache->db, name, ISC_FALSE, &node);
1117 if (result == ISC_R_NOTFOUND) {
1118 result = ISC_R_SUCCESS;
1121 if (result != ISC_R_SUCCESS)
1124 result = dns_db_allrdatasets(cache->db, node, NULL,
1125 (isc_stdtime_t)0, &iter);
1126 if (result != ISC_R_SUCCESS)
1129 for (result = dns_rdatasetiter_first(iter);
1130 result == ISC_R_SUCCESS;
1131 result = dns_rdatasetiter_next(iter))
1133 dns_rdataset_t rdataset;
1134 dns_rdataset_init(&rdataset);
1136 dns_rdatasetiter_current(iter, &rdataset);
1137 result = dns_db_deleterdataset(cache->db, node, NULL,
1138 rdataset.type, rdataset.covers);
1139 dns_rdataset_disassociate(&rdataset);
1140 if (result != ISC_R_SUCCESS && result != DNS_R_UNCHANGED)
1143 if (result == ISC_R_NOMORE)
1144 result = ISC_R_SUCCESS;
1146 dns_rdatasetiter_destroy(&iter);
1149 dns_db_detachnode(cache->db, &node);