Lines Matching refs:cache
31 #include <dns/cache.h>
46 #define VALID_CACHE(cache) ISC_MAGIC_VALID(cache, CACHE_MAGIC)
67 * cache cleaning.
88 * Accesses to a cache cleaner object are synchronized through
89 * task/event serialization, or locked from the cache object.
100 dns_cache_t *cache;
113 isc_boolean_t overmem; /*% The cache is in an overmem state. */
118 * The actual cache object.
126 isc_mem_t *mctx; /* Main cache memory */
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,
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));
201 dns_cache_t *cache;
211 cache = isc_mem_get(cmctx, sizeof(*cache));
212 if (cache == NULL)
215 cache->mctx = cache->hmctx = NULL;
216 isc_mem_attach(cmctx, &cache->mctx);
217 isc_mem_attach(hmctx, &cache->hmctx);
219 cache->name = NULL;
221 cache->name = isc_mem_strdup(cmctx, cachename);
222 if (cache->name == NULL) {
228 result = isc_mutex_init(&cache->lock);
232 result = isc_mutex_init(&cache->filelock);
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) {
248 * via cache->db_argv, followed by the rest of the arguments in
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) {
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) {
282 cache->db = NULL;
283 result = cache_create_db(cache, &cache->db);
291 dns_db_settask(cache->db, 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
304 result = cache_cleaner_init(cache, NULL, NULL, &cache->cleaner);
306 result = cache_cleaner_init(cache, taskmgr, timermgr,
307 &cache->cleaner);
312 *cachep = cache;
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
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);
393 cache->magic = 0;
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));
405 LOCK(&cache->lock);
406 cache->references++;
407 UNLOCK(&cache->lock);
409 *targetp = cache;
414 dns_cache_t *cache;
418 cache = *cachep;
419 REQUIRE(VALID_CACHE(cache));
421 LOCK(&cache->lock);
422 REQUIRE(cache->references > 0);
423 cache->references--;
424 if (cache->references == 0) {
425 cache->cleaner.overmem = ISC_FALSE;
433 * When the cache is shut down, dump it to a file if one is
436 isc_result_t result = dns_cache_dump(cache);
440 "error dumping cache: %s ",
444 * If the cleaner task exists, let it free the cache.
446 if (cache->live_tasks > 0) {
447 isc_task_shutdown(cache->cleaner.task);
452 UNLOCK(&cache->lock);
455 cache_free(cache);
459 dns_cache_attachdb(dns_cache_t *cache, dns_db_t **dbp) {
460 REQUIRE(VALID_CACHE(cache));
462 REQUIRE(cache->db != NULL);
464 LOCK(&cache->lock);
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));
477 newname = isc_mem_strdup(cache->mctx, filename);
481 LOCK(&cache->filelock);
482 if (cache->filename)
483 isc_mem_free(cache->mctx, cache->filename);
484 cache->filename = newname;
485 UNLOCK(&cache->filelock);
492 dns_cache_load(dns_cache_t *cache) {
495 REQUIRE(VALID_CACHE(cache));
497 if (cache->filename == NULL)
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)
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);
532 dns_cache_setcleaninginterval(dns_cache_t *cache, unsigned int t) {
536 LOCK(&cache->lock);
539 * It may be the case that the cache has already shut down.
542 if (cache->cleaner.cleaning_timer == NULL)
545 cache->cleaner.cleaning_interval = t;
548 result = isc_timer_reset(cache->cleaner.cleaning_timer,
552 isc_interval_set(&interval, cache->cleaner.cleaning_interval,
554 result = isc_timer_reset(cache->cleaner.cleaning_timer,
561 "could not set cache cleaning interval: %s",
565 UNLOCK(&cache->lock);
569 dns_cache_getcleaninginterval(dns_cache_t *cache) {
572 REQUIRE(VALID_CACHE(cache));
574 LOCK(&cache->lock);
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.
594 cache_cleaner_init(dns_cache_t *cache, isc_taskmgr_t *taskmgr,
605 cleaner->cache = cache;
616 result = dns_db_createiterator(cleaner->cache->db, ISC_FALSE,
630 cleaner->cache->live_tasks++;
634 cleaner_shutdown_action, cache);
637 "cache cleaner: "
656 isc_event_allocate(cache->mctx, cleaner,
666 isc_event_allocate(cache->mctx, cleaner,
702 * position it at the beginning of the cache.
705 result = dns_db_createiterator(cleaner->cache->db, ISC_FALSE,
710 "cache cleaner could not create "
723 "cache cleaner: "
740 "begin cache cleaning, mem inuse %lu",
741 (unsigned long)isc_mem_inuse(cleaner->cache->mctx));
760 dns_cache_setcleaninginterval(cleaner->cache,
764 ISC_LOG_DEBUG(1), "end cache cleaning, mem inuse %lu",
765 (unsigned long)isc_mem_inuse(cleaner->cache->mctx));
772 * This is run once for every cache-cleaning-interval as defined in named.conf.
784 ISC_LOG_DEBUG(1), "cache cleaning timer fired, "
794 * This is called when the cache either surpasses its upper limit
857 LOCK(&cleaner->cache->lock);
861 (void) dns_db_createiterator(cleaner->cache->db,
867 UNLOCK(&cleaner->cache->lock);
885 "cache cleaner: dns_dbiterator_current() "
896 dns_db_detachnode(cleaner->cache->db, &node);
906 * some error was signaled. If the cache is still
912 "cache cleaner: "
924 "cache cleaner: "
938 * not gone through the entire cache. Free the iterator locks
946 ISC_LOG_DEBUG(1), "cache cleaner: checked %u nodes, "
948 (unsigned long)isc_mem_inuse(cleaner->cache->mctx));
959 dns_cache_clean(dns_cache_t *cache, isc_stdtime_t now) {
963 REQUIRE(VALID_CACHE(cache));
965 result = dns_db_createiterator(cache->db, 0, &iterator);
981 result = dns_db_expirenode(cache->db, node, now);
984 "cache cleaner: dns_db_expirenode() "
995 dns_db_detachnode(cache->db, &node);
1010 dns_cache_t *cache = arg;
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, isc_uint32_t size) {
1035 REQUIRE(VALID_CACHE(cache));
1038 * Impose a minimum cache size; pathological things happen if there
1044 LOCK(&cache->lock);
1045 cache->size = size;
1046 UNLOCK(&cache->lock);
1052 * If the cache was overmem and cleaning, but now with the new limits
1054 * isc_mem_put for cache memory will do the right thing and trigger
1060 * Disable cache memory limiting.
1062 isc_mem_setwater(cache->mctx, water, cache, 0, 0);
1065 * Establish new cache memory limits (either for the first
1068 isc_mem_setwater(cache->mctx, water, cache, hiwater, lowater);
1072 dns_cache_getcachesize(dns_cache_t *cache) {
1075 REQUIRE(VALID_CACHE(cache));
1077 LOCK(&cache->lock);
1078 size = cache->size;
1079 UNLOCK(&cache->lock);
1089 dns_cache_t *cache = event->ev_arg;
1094 INSIST(task == cache->cleaner.task);
1097 if (CLEANER_BUSY(&cache->cleaner))
1098 end_cleaning(&cache->cleaner, event);
1102 LOCK(&cache->lock);
1104 cache->live_tasks--;
1105 INSIST(cache->live_tasks == 0);
1107 if (cache->references == 0)
1115 if (cache->cleaner.cleaning_timer != NULL)
1116 isc_timer_detach(&cache->cleaner.cleaning_timer);
1121 UNLOCK(&cache->lock);
1124 cache_free(cache);
1128 dns_cache_flush(dns_cache_t *cache) {
1132 result = cache_create_db(cache, &db);
1136 LOCK(&cache->lock);
1137 LOCK(&cache->cleaner.lock);
1138 if (cache->cleaner.state == cleaner_s_idle) {
1139 if (cache->cleaner.iterator != NULL)
1140 dns_dbiterator_destroy(&cache->cleaner.iterator);
1142 &cache->cleaner.iterator);
1144 if (cache->cleaner.state == cleaner_s_busy)
1145 cache->cleaner.state = cleaner_s_done;
1146 cache->cleaner.replaceiterator = ISC_TRUE;
1148 dns_db_detach(&cache->db);
1149 cache->db = db;
1150 UNLOCK(&cache->cleaner.lock);
1151 UNLOCK(&cache->lock);
1157 dns_cache_flushname(dns_cache_t *cache, dns_name_t *name) {
1163 LOCK(&cache->lock);
1164 if (cache->db != NULL)
1165 dns_db_attach(cache->db, &db);
1166 UNLOCK(&cache->lock);
1169 result = dns_db_findnode(cache->db, name, ISC_FALSE, &node);
1177 result = dns_db_allrdatasets(cache->db, node, NULL,
1190 result = dns_db_deleterdataset(cache->db, node, NULL,
1202 dns_db_detachnode(cache->db, &node);