lib/dns/cache.c

97  * Accesses to a cache cleaner object are synchronized through
111 	isc_event_t *resched_event; /*% Sent by cleaner task to
141 	cache_cleaner_t cleaner;
157 		   isc_timermgr_t *timermgr, cache_cleaner_t *cleaner);
278 	 * need the control of the generic cleaner.
281 		result = cache_cleaner_init(cache, NULL, NULL, &cache->cleaner);
284 					    &cache->cleaner);
331 	if (cache->cleaner.task != NULL) {
332 		isc_task_detach(&cache->cleaner.task);
335 	if (cache->cleaner.overmem_event != NULL) {
336 		isc_event_free(&cache->cleaner.overmem_event);
339 	if (cache->cleaner.resched_event != NULL) {
340 		isc_event_free(&cache->cleaner.resched_event);
343 	if (cache->cleaner.iterator != NULL) {
344 		dns_dbiterator_destroy(&cache->cleaner.iterator);
347 	isc_mutex_destroy(&cache->cleaner.lock);
410 		cache->cleaner.overmem = false;
413 		 * If the cleaner task exists, let it free the cache.
416 			isc_task_shutdown(cache->cleaner.task);
442  * Initialize the cache cleaner object at *cleaner.
448 		   isc_timermgr_t *timermgr, cache_cleaner_t *cleaner) {
451 	isc_mutex_init(&cleaner->lock);
453 	cleaner->increment = DNS_CACHE_CLEANERINCREMENT;
454 	cleaner->state = cleaner_s_idle;
455 	cleaner->cache = cache;
456 	cleaner->iterator = NULL;
457 	cleaner->overmem = false;
458 	cleaner->replaceiterator = false;
460 	cleaner->task = NULL;
461 	cleaner->resched_event = NULL;
462 	cleaner->overmem_event = NULL;
464 	result = dns_db_createiterator(cleaner->cache->db, false,
465 				       &cleaner->iterator);
471 		result = isc_task_create(taskmgr, 1, &cleaner->task);
478 		isc_refcount_increment(&cleaner->cache->live_tasks);
479 		isc_task_setname(cleaner->task, "cachecleaner", cleaner);
481 		result = isc_task_onshutdown(cleaner->task,
484 			isc_refcount_decrement0(&cleaner->cache->live_tasks);
485 			UNEXPECTED_ERROR("cache cleaner: "
491 		cleaner->resched_event = isc_event_allocate(
492 			cache->mctx, cleaner, DNS_EVENT_CACHECLEAN,
493 			incremental_cleaning_action, cleaner,
496 		cleaner->overmem_event = isc_event_allocate(
497 			cache->mctx, cleaner, DNS_EVENT_CACHEOVERMEM,
498 			overmem_cleaning_action, cleaner, sizeof(isc_event_t));
504 	if (cleaner->overmem_event != NULL) {
505 		isc_event_free(&cleaner->overmem_event);
507 	if (cleaner->resched_event != NULL) {
508 		isc_event_free(&cleaner->resched_event);
510 	if (cleaner->task != NULL) {
511 		isc_task_detach(&cleaner->task);
513 	if (cleaner->iterator != NULL) {
514 		dns_dbiterator_destroy(&cleaner->iterator);
516 	isc_mutex_destroy(&cleaner->lock);
522 begin_cleaning(cache_cleaner_t *cleaner) {
525 	REQUIRE(CLEANER_IDLE(cleaner));
531 	if (cleaner->iterator == NULL) {
532 		result = dns_db_createiterator(cleaner->cache->db, false,
533 					       &cleaner->iterator);
538 			      "cache cleaner could not create "
542 		dns_dbiterator_setcleanmode(cleaner->iterator, true);
543 		result = dns_dbiterator_first(cleaner->iterator);
550 		if (result != ISC_R_NOMORE && cleaner->iterator != NULL) {
551 			UNEXPECTED_ERROR("cache cleaner: "
554 			dns_dbiterator_destroy(&cleaner->iterator);
555 		} else if (cleaner->iterator != NULL) {
556 			result = dns_dbiterator_pause(cleaner->iterator);
563 		result = dns_dbiterator_pause(cleaner->iterator);
569 			(unsigned long)isc_mem_inuse(cleaner->cache->mctx));
570 		cleaner->state = cleaner_s_busy;
571 		isc_task_send(cleaner->task, &cleaner->resched_event);
578 end_cleaning(cache_cleaner_t *cleaner, isc_event_t *event) {
581 	REQUIRE(CLEANER_BUSY(cleaner));
584 	result = dns_dbiterator_pause(cleaner->iterator);
586 		dns_dbiterator_destroy(&cleaner->iterator);
591 		      (unsigned long)isc_mem_inuse(cleaner->cache->mctx));
593 	cleaner->state = cleaner_s_idle;
594 	cleaner->resched_event = event;
603 	cache_cleaner_t *cleaner = event->ev_arg;
608 	INSIST(task == cleaner->task);
610 	INSIST(cleaner->overmem_event == NULL);
616 		      cleaner->overmem, cleaner->state);
618 	LOCK(&cleaner->lock);
620 	if (cleaner->overmem) {
621 		if (cleaner->state == cleaner_s_idle) {
625 		if (cleaner->state == cleaner_s_busy) {
628 			 * then both cleaner->overmem_event and
629 			 * cleaner->resched_event will point to this
634 			cleaner->state = cleaner_s_done;
638 	cleaner->overmem_event = event;
640 	UNLOCK(&cleaner->lock);
643 		begin_cleaning(cleaner);
652 	cache_cleaner_t *cleaner = event->ev_arg;
659 	INSIST(task == cleaner->task);
662 	if (cleaner->state == cleaner_s_done) {
663 		cleaner->state = cleaner_s_busy;
664 		end_cleaning(cleaner, event);
665 		LOCK(&cleaner->cache->lock);
666 		LOCK(&cleaner->lock);
667 		if (cleaner->replaceiterator) {
668 			dns_dbiterator_destroy(&cleaner->iterator);
669 			(void)dns_db_createiterator(cleaner->cache->db, false,
670 						    &cleaner->iterator);
671 			cleaner->replaceiterator = false;
673 		UNLOCK(&cleaner->lock);
674 		UNLOCK(&cleaner->cache->lock);
678 	INSIST(CLEANER_BUSY(cleaner));
680 	n_names = cleaner->increment;
682 	REQUIRE(DNS_DBITERATOR_VALID(cleaner->iterator));
688 		result = dns_dbiterator_current(cleaner->iterator, &node, NULL);
690 			UNEXPECTED_ERROR("cache cleaner: "
694 			end_cleaning(cleaner, event);
702 		dns_db_detachnode(cleaner->cache->db, &node);
707 		result = dns_dbiterator_next(cleaner->iterator);
717 				UNEXPECTED_ERROR("cache cleaner: "
721 			} else if (cleaner->overmem) {
723 					dns_dbiterator_first(cleaner->iterator);
729 						      "cache cleaner: "
736 			end_cleaning(cleaner, event);
747 	result = dns_dbiterator_pause(cleaner->iterator);
752 		      "cache cleaner: checked %u nodes, "
754 		      cleaner->increment,
755 		      (unsigned long)isc_mem_inuse(cleaner->cache->mctx));
758 	INSIST(CLEANER_BUSY(cleaner));
792 			UNEXPECTED_ERROR("cache cleaner: dns_db_expirenode() "
824 	LOCK(&cache->cleaner.lock);
826 	if (overmem != cache->cleaner.overmem) {
828 		cache->cleaner.overmem = overmem;
832 	if (cache->cleaner.overmem_event != NULL) {
833 		isc_task_send(cache->cleaner.task,
834 			      &cache->cleaner.overmem_event);
837 	UNLOCK(&cache->cleaner.lock);
944  * The cleaner task is shutting down; do the necessary cleanup.
952 	INSIST(task == cache->cleaner.task);
955 	if (CLEANER_BUSY(&cache->cleaner)) {
956 		end_cleaning(&cache->cleaner, event);
987 	LOCK(&cache->cleaner.lock);
988 	if (cache->cleaner.state == cleaner_s_idle) {
989 		olddbiterator = cache->cleaner.iterator;
990 		cache->cleaner.iterator = dbiterator;
993 		if (cache->cleaner.state == cleaner_s_busy) {
994 			cache->cleaner.state = cleaner_s_done;
996 		cache->cleaner.replaceiterator = true;
1001 	UNLOCK(&cache->cleaner.lock);