lib/dns/cache.c

	cache.c revision ec5347e2c775f027573ce5648b910361aa926c01
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt/*
0bf752f4835374c820f9c22ac6b64980729d4b4aTinderbox User * Copyright (C) 2004-2006  Internet Systems Consortium, Inc. ("ISC")
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt * Copyright (C) 1999-2003  Internet Software Consortium.
0c27b3fe77ac1d5094ba3521e8142d9e7973133fMark Andrews *
0c27b3fe77ac1d5094ba3521e8142d9e7973133fMark Andrews * Permission to use, copy, modify, and/or distribute this software for any
0c27b3fe77ac1d5094ba3521e8142d9e7973133fMark Andrews * purpose with or without fee is hereby granted, provided that the above
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt * copyright notice and this permission notice appear in all copies.
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt *
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt * PERFORMANCE OF THIS SOFTWARE.
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt */
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt/* $Id: cache.c,v 1.74 2007/06/18 23:47:40 tbox Exp $ */
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt/*! \file */
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt#include <config.h>
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt#include <isc/mem.h>
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt#include <isc/task.h>
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt#include <isc/time.h>
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt#include <isc/timer.h>
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt#include <isc/util.h>
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt#include <dns/cache.h>
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt#include <dns/db.h>
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt#include <dns/dbiterator.h>
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt#include <dns/events.h>
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt#include <dns/lib.h>
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt#include <dns/log.h>
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt#include <dns/masterdump.h>
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt#include <dns/rdata.h>
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt#include <dns/rdataset.h>
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt#include <dns/rdatasetiter.h>
b0ba1a6059b6d6c4b3aa77d8bc84cc443b981e01Mukund Sivaraman#include <dns/result.h>
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt#define CACHE_MAGIC     ISC_MAGIC('$', '$', '$', '$')
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt#define VALID_CACHE(cache)  ISC_MAGIC_VALID(cache, CACHE_MAGIC)
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt/*!
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt * Control incremental cleaning.
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt * DNS_CACHE_MINSIZE is how many bytes is the floor for dns_cache_setcachesize().
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt * See also DNS_CACHE_CLEANERINCREMENT
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt */
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt#define DNS_CACHE_MINSIZE       2097152 /*%< Bytes.  2097152 = 2 MB */
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt/*!
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt * Control incremental cleaning.
0e5c8a65a207418b22de9ef9c12bb52c50ac8a2aMark Andrews * CLEANERINCREMENT is how many nodes are examined in one pass.
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt * See also DNS_CACHE_MINSIZE
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt */
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt#define DNS_CACHE_CLEANERINCREMENT  1000U   /*%< Number of nodes. */
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt/***
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt ***    Types
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt ***/
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt/*
f9f81abff0ea36f19474f3b7a11bf0f17c4f116cMukund Sivaraman * A cache_cleaner_t encapsulsates the state of the periodic
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt * cache cleaning.
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt */
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunttypedef struct cache_cleaner cache_cleaner_t;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunttypedef enum {
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    cleaner_s_idle, /*%< Waiting for cleaning-interval to expire. */
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    cleaner_s_busy, /*%< Currently cleaning. */
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    cleaner_s_done  /*%< Freed enough memory after being overmem. */
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt} cleaner_state_t;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt/*
7712d1660a308ec3de17f1ddbbf801eb0d663f3eEvan Hunt * Convenience macros for comprehensive assertion checking.
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt */
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt#define CLEANER_IDLE(c) ((c)->state == cleaner_s_idle && \
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt             (c)->resched_event != NULL)
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt#define CLEANER_BUSY(c) ((c)->state == cleaner_s_busy && \
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt             (c)->iterator != NULL && \
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt             (c)->resched_event == NULL)
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt/*%
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt * Accesses to a cache cleaner object are synchronized through
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt * task/event serialization, or locked from the cache object.
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt */
b0ba1a6059b6d6c4b3aa77d8bc84cc443b981e01Mukund Sivaramanstruct cache_cleaner {
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    isc_mutex_t lock;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    /*%<
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt     * Locks overmem_event, overmem.  Note: never allocate memory
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt     * while holding this lock - that could lead to deadlock since
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt     * the lock is take by water() which is called from the memory
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt     * allocator.
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt     */
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    dns_cache_t *cache;
07aa16562758a36332bd808f6e597a0b308295c4Mark Andrews    isc_task_t  *task;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    unsigned int    cleaning_interval; /*% The cleaning-interval from
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt                          named.conf, in seconds. */
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    isc_timer_t     *cleaning_timer;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    isc_event_t *resched_event; /*% Sent by cleaner task to
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt                       itself to reschedule */
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    isc_event_t *overmem_event;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    dns_dbiterator_t *iterator;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    unsigned int     increment; /*% Number of names to
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt                       clean in one increment */
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    cleaner_state_t  state;     /*% Idle/Busy. */
7712d1660a308ec3de17f1ddbbf801eb0d663f3eEvan Hunt    isc_boolean_t    overmem;   /*% The cache is in an overmem state. */
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    isc_boolean_t    replaceiterator;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt};
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt/*%
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt * The actual cache object.
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt */
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Huntstruct dns_cache {
b0ba1a6059b6d6c4b3aa77d8bc84cc443b981e01Mukund Sivaraman    /* Unlocked. */
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    unsigned int        magic;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    isc_mutex_t     lock;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    isc_mutex_t     filelock;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    isc_mem_t       *mctx;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    /* Locked by 'lock'. */
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    int         references;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    int         live_tasks;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    dns_rdataclass_t    rdclass;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    dns_db_t        *db;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    cache_cleaner_t     cleaner;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    char            *db_type;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    int         db_argc;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    char            **db_argv;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    /* Locked by 'filelock'. */
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    char *          filename;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    /* Access to the on-disk cache file is also locked by 'filelock'. */
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt};
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt/***
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt ***    Functions
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt ***/
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Huntstatic isc_result_t
2383eb527269d333df4222da20e4b422c3662daaEvan Huntcache_cleaner_init(dns_cache_t *cache, isc_taskmgr_t *taskmgr,
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt           isc_timermgr_t *timermgr, cache_cleaner_t *cleaner);
cfe32752a66fe1f050d5ed7ddce75f6d58fe1637Evan Hunt
c1e42fa06dce9bfa5669cc1915b8a512a741c414Evan Huntstatic void
2383eb527269d333df4222da20e4b422c3662daaEvan Huntcleaning_timer_action(isc_task_t *task, isc_event_t *event);
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Huntstatic void
cfe32752a66fe1f050d5ed7ddce75f6d58fe1637Evan Huntincremental_cleaning_action(isc_task_t *task, isc_event_t *event);
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
cfe32752a66fe1f050d5ed7ddce75f6d58fe1637Evan Huntstatic void
cfe32752a66fe1f050d5ed7ddce75f6d58fe1637Evan Huntcleaner_shutdown_action(isc_task_t *task, isc_event_t *event);
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Huntstatic void
2383eb527269d333df4222da20e4b422c3662daaEvan Huntovermem_cleaning_action(isc_task_t *task, isc_event_t *event);
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt/*%
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt * Work out how many nodes can be cleaned in the time between two
b0ba1a6059b6d6c4b3aa77d8bc84cc443b981e01Mukund Sivaraman * requests to the nameserver.  Smooth the resulting number and use
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt * it as a estimate for the number of nodes to be cleaned in the next
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt * iteration.
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt */
2383eb527269d333df4222da20e4b422c3662daaEvan Huntstatic void
2383eb527269d333df4222da20e4b422c3662daaEvan Huntadjust_increment(cache_cleaner_t *cleaner, unsigned int remaining,
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt         isc_time_t *start)
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt{
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    isc_time_t end;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    isc_uint64_t usecs;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    isc_uint64_t new;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    unsigned int pps = dns_pps;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    unsigned int interval;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    unsigned int names;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    /*
b0ba1a6059b6d6c4b3aa77d8bc84cc443b981e01Mukund Sivaraman     * Tune for minumum of 100 packets per second (pps).
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt     */
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    if (pps < 100)
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt        pps = 100;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    isc_time_now(&end);
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    interval = 1000000 / pps; /* Interval between packets in usecs. */
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    if (interval == 0)
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt        interval = 1;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    INSIST(cleaner->increment >= remaining);
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    names = cleaner->increment - remaining;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    usecs = isc_time_microdiff(&end, start);
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_CACHE,
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt              ISC_LOG_DEBUG(1), "adjust_increment interval=%u "
b0ba1a6059b6d6c4b3aa77d8bc84cc443b981e01Mukund Sivaraman              "names=%u usec=%" ISC_PLATFORM_QUADFORMAT "u",
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt              interval, names, usecs);
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    if (usecs == 0) {
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt        /*
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt         * If we cleaned all the nodes in unmeasurable time
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt         * double the number of nodes to be cleaned next time.
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt         */
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt        if (names == cleaner->increment) {
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt            cleaner->increment *= 2;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt            if (cleaner->increment > DNS_CACHE_CLEANERINCREMENT)
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt                cleaner->increment = DNS_CACHE_CLEANERINCREMENT;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt            isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt                      DNS_LOGMODULE_CACHE, ISC_LOG_DEBUG(1),
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt                      "%p:new cleaner->increment = %u\n",
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt                      cleaner, cleaner->increment);
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt        }
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt        return;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    }
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    new = (names * interval);
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    new /= (usecs * 2);
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    if (new == 0)
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt        new = 1;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    /* Smooth */
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    new = (new + cleaner->increment * 7) / 8;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    if (new > DNS_CACHE_CLEANERINCREMENT)
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt        new = DNS_CACHE_CLEANERINCREMENT;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    cleaner->increment = (unsigned int)new;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_CACHE,
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt              ISC_LOG_DEBUG(1), "%p:new cleaner->increment = %u\n",
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt              cleaner, cleaner->increment);
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt}
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Huntstatic inline isc_result_t
2383eb527269d333df4222da20e4b422c3662daaEvan Huntcache_create_db(dns_cache_t *cache, dns_db_t **db) {
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    return (dns_db_create(cache->mctx, cache->db_type, dns_rootname,
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt                  dns_dbtype_cache, cache->rdclass,
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt                  cache->db_argc, cache->db_argv, db));
b0ba1a6059b6d6c4b3aa77d8bc84cc443b981e01Mukund Sivaraman}
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Huntisc_result_t
2383eb527269d333df4222da20e4b422c3662daaEvan Huntdns_cache_create(isc_mem_t *mctx, isc_taskmgr_t *taskmgr,
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt         isc_timermgr_t *timermgr, dns_rdataclass_t rdclass,
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt         const char *db_type, unsigned int db_argc, char **db_argv,
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt         dns_cache_t **cachep)
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt{
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    isc_result_t result;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    dns_cache_t *cache;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    int i;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    REQUIRE(cachep != NULL);
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    REQUIRE(*cachep == NULL);
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    REQUIRE(mctx != NULL);
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    cache = isc_mem_get(mctx, sizeof(*cache));
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    if (cache == NULL)
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt        return (ISC_R_NOMEMORY);
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    cache->mctx = NULL;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    isc_mem_attach(mctx, &cache->mctx);
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    result = isc_mutex_init(&cache->lock);
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    if (result != ISC_R_SUCCESS)
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt        goto cleanup_mem;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    result = isc_mutex_init(&cache->filelock);
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    if (result != ISC_R_SUCCESS)
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt        goto cleanup_lock;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    cache->references = 1;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    cache->live_tasks = 0;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    cache->rdclass = rdclass;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    cache->db_type = isc_mem_strdup(mctx, db_type);
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    if (cache->db_type == NULL) {
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt        result = ISC_R_NOMEMORY;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt        goto cleanup_filelock;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    }
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    cache->db_argc = db_argc;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    if (cache->db_argc == 0)
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt        cache->db_argv = NULL;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    else {
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt        cache->db_argv = isc_mem_get(mctx,
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt                         cache->db_argc * sizeof(char *));
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt        if (cache->db_argv == NULL) {
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt            result = ISC_R_NOMEMORY;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt            goto cleanup_dbtype;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt        }
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt        for (i = 0; i < cache->db_argc; i++)
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt            cache->db_argv[i] = NULL;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt        for (i = 0; i < cache->db_argc; i++) {
b0ba1a6059b6d6c4b3aa77d8bc84cc443b981e01Mukund Sivaraman            cache->db_argv[i] = isc_mem_strdup(mctx, db_argv[i]);
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt            if (cache->db_argv[i] == NULL) {
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt                result = ISC_R_NOMEMORY;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt                goto cleanup_dbargv;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt            }
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt        }
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    }
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    cache->db = NULL;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    result = cache_create_db(cache, &cache->db);
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    if (result != ISC_R_SUCCESS)
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt        goto cleanup_dbargv;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    cache->filename = NULL;
b0ba1a6059b6d6c4b3aa77d8bc84cc443b981e01Mukund Sivaraman
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    cache->magic = CACHE_MAGIC;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    result = cache_cleaner_init(cache, taskmgr, timermgr, &cache->cleaner);
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    if (result != ISC_R_SUCCESS)
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt        goto cleanup_db;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    *cachep = cache;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    return (ISC_R_SUCCESS);
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt cleanup_db:
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    dns_db_detach(&cache->db);
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt cleanup_dbargv:
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    for (i = 0; i < cache->db_argc; i++)
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt        if (cache->db_argv[i] != NULL)
b0ba1a6059b6d6c4b3aa77d8bc84cc443b981e01Mukund Sivaraman            isc_mem_free(mctx, cache->db_argv[i]);
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    if (cache->db_argv != NULL)
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt        isc_mem_put(mctx, cache->db_argv,
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt                cache->db_argc * sizeof(char *));
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt cleanup_dbtype:
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    isc_mem_free(mctx, cache->db_type);
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt cleanup_filelock:
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    DESTROYLOCK(&cache->filelock);
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt cleanup_lock:
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    DESTROYLOCK(&cache->lock);
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt cleanup_mem:
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    isc_mem_put(mctx, cache, sizeof(*cache));
b0ba1a6059b6d6c4b3aa77d8bc84cc443b981e01Mukund Sivaraman    isc_mem_detach(&mctx);
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    return (result);
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt}
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Huntstatic void
2383eb527269d333df4222da20e4b422c3662daaEvan Huntcache_free(dns_cache_t *cache) {
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    isc_mem_t *mctx;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    int i;
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    REQUIRE(VALID_CACHE(cache));
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    REQUIRE(cache->references == 0);
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    isc_mem_setwater(cache->mctx, NULL, NULL, 0, 0);
b0ba1a6059b6d6c4b3aa77d8bc84cc443b981e01Mukund Sivaraman
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    if (cache->cleaner.task != NULL)
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt        isc_task_detach(&cache->cleaner.task);
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    if (cache->cleaner.overmem_event != NULL)
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt        isc_event_free(&cache->cleaner.overmem_event);
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    if (cache->cleaner.resched_event != NULL)
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt        isc_event_free(&cache->cleaner.resched_event);
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    if (cache->cleaner.iterator != NULL)
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt        dns_dbiterator_destroy(&cache->cleaner.iterator);
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    DESTROYLOCK(&cache->cleaner.lock);
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt    if (cache->filename) {
2383eb527269d333df4222da20e4b422c3662daaEvan Hunt        isc_mem_free(cache->mctx, cache->filename);
        cache->filename = NULL;
    }

    if (cache->db != NULL)
        dns_db_detach(&cache->db);

    if (cache->db_argv != NULL) {
        for (i = 0; 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);

    DESTROYLOCK(&cache->lock);
    DESTROYLOCK(&cache->filelock);
    cache->magic = 0;
    mctx = cache->mctx;
    isc_mem_put(cache->mctx, cache, sizeof(*cache));
    isc_mem_detach(&mctx);
}


void
dns_cache_attach(dns_cache_t *cache, dns_cache_t **targetp) {

    REQUIRE(VALID_CACHE(cache));
    REQUIRE(targetp != NULL && *targetp == NULL);

    LOCK(&cache->lock);
    cache->references++;
    UNLOCK(&cache->lock);

    *targetp = cache;
}

void
dns_cache_detach(dns_cache_t **cachep) {
    dns_cache_t *cache;
    isc_boolean_t free_cache = ISC_FALSE;

    REQUIRE(cachep != NULL);
    cache = *cachep;
    REQUIRE(VALID_CACHE(cache));

    LOCK(&cache->lock);
    REQUIRE(cache->references > 0);
    cache->references--;
    if (cache->references == 0) {
        cache->cleaner.overmem = ISC_FALSE;
        free_cache = ISC_TRUE;
    }

    *cachep = NULL;

    if (free_cache) {
        /*
         * When the cache is shut down, dump it to a file if one is
         * specified.
         */
        isc_result_t result = dns_cache_dump(cache);
        if (result != ISC_R_SUCCESS)
            isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
                      DNS_LOGMODULE_CACHE, ISC_LOG_WARNING,
                      "error dumping cache: %s ",
                      isc_result_totext(result));

        /*
         * If the cleaner task exists, let it free the cache.
         */
        if (cache->live_tasks > 0) {
            isc_task_shutdown(cache->cleaner.task);
            free_cache = ISC_FALSE;
        }
    }

    UNLOCK(&cache->lock);

    if (free_cache)
        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);

}

isc_result_t
dns_cache_setfilename(dns_cache_t *cache, const char *filename) {
    char *newname;

    REQUIRE(VALID_CACHE(cache));
    REQUIRE(filename != NULL);

    newname = isc_mem_strdup(cache->mctx, filename);
    if (newname == NULL)
        return (ISC_R_NOMEMORY);

    LOCK(&cache->filelock);
    if (cache->filename)
        isc_mem_free(cache->mctx, cache->filename);
    cache->filename = newname;
    UNLOCK(&cache->filelock);

    return (ISC_R_SUCCESS);
}

isc_result_t
dns_cache_load(dns_cache_t *cache) {
    isc_result_t result;

    REQUIRE(VALID_CACHE(cache));

    if (cache->filename == NULL)
        return (ISC_R_SUCCESS);

    LOCK(&cache->filelock);
    result = dns_db_load(cache->db, cache->filename);
    UNLOCK(&cache->filelock);

    return (result);
}

isc_result_t
dns_cache_dump(dns_cache_t *cache) {
    isc_result_t result;

    REQUIRE(VALID_CACHE(cache));

    if (cache->filename == NULL)
        return (ISC_R_SUCCESS);

    LOCK(&cache->filelock);
    result = dns_master_dump(cache->mctx, cache->db, NULL,
                 &dns_master_style_cache, cache->filename);
    UNLOCK(&cache->filelock);

    return (result);
}

void
dns_cache_setcleaninginterval(dns_cache_t *cache, unsigned int t) {
    isc_interval_t interval;
    isc_result_t result;

    LOCK(&cache->lock);

    /*
     * It may be the case that the cache has already shut down.
     * If so, it has no timer.
     */
    if (cache->cleaner.cleaning_timer == NULL)
        goto unlock;

    cache->cleaner.cleaning_interval = t;

    if (t == 0) {
        result = isc_timer_reset(cache->cleaner.cleaning_timer,
                     isc_timertype_inactive,
                     NULL, NULL, ISC_TRUE);
    } else {
        isc_interval_set(&interval, cache->cleaner.cleaning_interval,
                 0);
        result = isc_timer_reset(cache->cleaner.cleaning_timer,
                     isc_timertype_ticker,
                     NULL, &interval, ISC_FALSE);
    }
    if (result != ISC_R_SUCCESS)
        isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
                  DNS_LOGMODULE_CACHE, ISC_LOG_WARNING,
                  "could not set cache cleaning interval: %s",
                  isc_result_totext(result));

 unlock:
    UNLOCK(&cache->lock);
}

/*
 * 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;

    result = isc_mutex_init(&cleaner->lock);
    if (result != ISC_R_SUCCESS)
        goto fail;

    cleaner->increment = DNS_CACHE_CLEANERINCREMENT;
    cleaner->state = cleaner_s_idle;
    cleaner->cache = cache;
    cleaner->iterator = NULL;
    cleaner->overmem = ISC_FALSE;
    cleaner->replaceiterator = ISC_FALSE;

    cleaner->task = NULL;
    cleaner->cleaning_timer = NULL;
    cleaner->resched_event = NULL;
    cleaner->overmem_event = NULL;

    result = dns_db_createiterator(cleaner->cache->db, ISC_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(__FILE__, __LINE__,
                     "isc_task_create() failed: %s",
                     dns_result_totext(result));
            result = ISC_R_UNEXPECTED;
            goto cleanup;
        }
        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) {
            UNEXPECTED_ERROR(__FILE__, __LINE__,
                     "cache cleaner: "
                     "isc_task_onshutdown() failed: %s",
                     dns_result_totext(result));
            goto cleanup;
        }

        cleaner->cleaning_interval = 0; /* Initially turned off. */
        result = isc_timer_create(timermgr, isc_timertype_inactive,
                       NULL, NULL,
                       cleaner->task,
                       cleaning_timer_action, cleaner,
                       &cleaner->cleaning_timer);
        if (result != ISC_R_SUCCESS) {
            UNEXPECTED_ERROR(__FILE__, __LINE__,
                     "isc_timer_create() failed: %s",
                     dns_result_totext(result));
            result = ISC_R_UNEXPECTED;
            goto cleanup;
        }

        cleaner->resched_event =
            isc_event_allocate(cache->mctx, cleaner,
                       DNS_EVENT_CACHECLEAN,
                       incremental_cleaning_action,
                       cleaner, sizeof(isc_event_t));
        if (cleaner->resched_event == NULL) {
            result = ISC_R_NOMEMORY;
            goto cleanup;
        }

        cleaner->overmem_event =
            isc_event_allocate(cache->mctx, cleaner,
                       DNS_EVENT_CACHEOVERMEM,
                       overmem_cleaning_action,
                       cleaner, sizeof(isc_event_t));
        if (cleaner->overmem_event == NULL) {
            result = ISC_R_NOMEMORY;
            goto cleanup;
        }
    }

    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->cleaning_timer != NULL)
        isc_timer_detach(&cleaner->cleaning_timer);
    if (cleaner->task != NULL)
        isc_task_detach(&cleaner->task);
    if (cleaner->iterator != NULL)
        dns_dbiterator_destroy(&cleaner->iterator);
    DESTROYLOCK(&cleaner->lock);
 fail:
    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, ISC_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, ISC_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(__FILE__, __LINE__,
                     "cache cleaner: "
                     "dns_dbiterator_first() failed: %s",
                     dns_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);

    dns_cache_setcleaninginterval(cleaner->cache,
                      cleaner->cleaning_interval);

    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 run once for every cache-cleaning-interval as defined in named.conf.
 */
static void
cleaning_timer_action(isc_task_t *task, isc_event_t *event) {
    cache_cleaner_t *cleaner = event->ev_arg;

    UNUSED(task);

    INSIST(task == cleaner->task);
    INSIST(event->ev_type == ISC_TIMEREVENT_TICK);

    isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_CACHE,
              ISC_LOG_DEBUG(1), "cache cleaning timer fired, "
              "cleaner state = %d", cleaner->state);

    if (cleaner->state == cleaner_s_idle)
        begin_cleaning(cleaner);

    isc_event_free(&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;
    isc_boolean_t want_cleaning = ISC_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 = ISC_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,
                             ISC_FALSE,
                             &cleaner->iterator);
            cleaner->replaceiterator = ISC_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(__FILE__, __LINE__,
                 "cache cleaner: dns_dbiterator_current() "
                 "failed: %s", dns_result_totext(result));

            adjust_increment(cleaner, n_names, &start);
            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(__FILE__, __LINE__,
                         "cache cleaner: "
                         "dns_dbiterator_next() "
                         "failed: %s",
                         dns_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;
                }
            }

            adjust_increment(cleaner, n_names, &start);
            end_cleaning(cleaner, event);
            return;
        }
    }

    adjust_increment(cleaner, 0U, &start);

    /*
     * 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, ISC_FALSE, &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(__FILE__, __LINE__,
                     "cache cleaner: dns_db_expirenode() "
                     "failed: %s",
                     dns_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;
    isc_boolean_t overmem = ISC_TF(mark == ISC_MEM_HIWATER);

    REQUIRE(VALID_CACHE(cache));

    LOCK(&cache->cleaner.lock);

    dns_db_overmem(cache->db, overmem);
    cache->cleaner.overmem = overmem;

    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, isc_uint32_t size) {
    isc_uint32_t lowater;
    isc_uint32_t hiwater;

    REQUIRE(VALID_CACHE(cache));

    /*
     * Impose a minumum cache size; pathological things happen if there
     * is too little room.
     */
    if (size != 0 && size < DNS_CACHE_MINSIZE)
        size = DNS_CACHE_MINSIZE;

    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 == 0 || hiwater == 0 || lowater == 0)
        /*
         * Disable cache memory limiting.
         */
        isc_mem_setwater(cache->mctx, water, cache, 0, 0);
    else
        /*
         * Establish new cache memory limits (either for the first
         * time, or replacing other limits).
         */
        isc_mem_setwater(cache->mctx, water, cache, hiwater, lowater);
}

/*
 * 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;
    isc_boolean_t should_free = ISC_FALSE;

    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);

    LOCK(&cache->lock);

    cache->live_tasks--;
    INSIST(cache->live_tasks == 0);

    if (cache->references == 0)
        should_free = ISC_TRUE;

    /*
     * By detaching the timer in the context of its task,
     * we are guaranteed that there will be no further timer
     * events.
     */
    if (cache->cleaner.cleaning_timer != NULL)
        isc_timer_detach(&cache->cleaner.cleaning_timer);

    /* Make sure we don't reschedule anymore. */
    (void)isc_task_purge(task, NULL, DNS_EVENT_CACHECLEAN, NULL);

    UNLOCK(&cache->lock);

    if (should_free)
        cache_free(cache);
}

isc_result_t
dns_cache_flush(dns_cache_t *cache) {
    dns_db_t *db = NULL;
    isc_result_t result;

    result = cache_create_db(cache, &db);
    if (result != ISC_R_SUCCESS)
        return (result);

    LOCK(&cache->lock);
    LOCK(&cache->cleaner.lock);
    if (cache->cleaner.state == cleaner_s_idle) {
        if (cache->cleaner.iterator != NULL)
            dns_dbiterator_destroy(&cache->cleaner.iterator);
        (void) dns_db_createiterator(db, ISC_FALSE,
                         &cache->cleaner.iterator);
    } else {
        if (cache->cleaner.state == cleaner_s_busy)
            cache->cleaner.state = cleaner_s_done;
        cache->cleaner.replaceiterator = ISC_TRUE;
    }
    dns_db_detach(&cache->db);
    cache->db = db;
    UNLOCK(&cache->cleaner.lock);
    UNLOCK(&cache->lock);

    return (ISC_R_SUCCESS);
}

isc_result_t
dns_cache_flushname(dns_cache_t *cache, dns_name_t *name) {
    isc_result_t result;
    dns_rdatasetiter_t *iter = NULL;
    dns_dbnode_t *node = NULL;
    dns_db_t *db = NULL;

    LOCK(&cache->lock);
    if (cache->db != NULL)
        dns_db_attach(cache->db, &db);
    UNLOCK(&cache->lock);
    if (db == NULL)
        return (ISC_R_SUCCESS);
    result = dns_db_findnode(cache->db, name, ISC_FALSE, &node);
    if (result == ISC_R_NOTFOUND) {
        result = ISC_R_SUCCESS;
        goto cleanup_db;
    }
    if (result != ISC_R_SUCCESS)
        goto cleanup_db;

    result = dns_db_allrdatasets(cache->db, node, NULL,
                     (isc_stdtime_t)0, &iter);
    if (result != ISC_R_SUCCESS)
        goto cleanup_node;

    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(cache->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);

 cleanup_node:
    dns_db_detachnode(cache->db, &node);

 cleanup_db:
    dns_db_detach(&db);
    return (result);
}