lib/isc/timer.c

	timer.c revision 618053b8bec1dea3e9486c3b427b123c4093d56a
/*
 * Copyright (C) 2004, 2005, 2007-2009, 2011-2014  Internet Systems Consortium, Inc. ("ISC")
 * Copyright (C) 1998-2002  Internet Software Consortium.
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
 */

/* $Id$ */

/*! \file */

#include <config.h>

#include <isc/app.h>
#include <isc/condition.h>
#include <isc/heap.h>
#include <isc/log.h>
#include <isc/magic.h>
#include <isc/mem.h>
#include <isc/msgs.h>
#include <isc/once.h>
#include <isc/platform.h>
#include <isc/task.h>
#include <isc/thread.h>
#include <isc/time.h>
#include <isc/timer.h>
#include <isc/util.h>

#ifdef OPENSSL_LEAKS
#include <openssl/err.h>
#endif

/* See task.c about the following definition: */
#ifdef ISC_PLATFORM_USETHREADS
#define USE_TIMER_THREAD
#else
#define USE_SHARED_MANAGER
#endif  /* ISC_PLATFORM_USETHREADS */

#ifndef USE_TIMER_THREAD
#include "timer_p.h"
#endif /* USE_TIMER_THREAD */

#ifdef ISC_TIMER_TRACE
#define XTRACE(s)           fprintf(stderr, "%s\n", (s))
#define XTRACEID(s, t)          fprintf(stderr, "%s %p\n", (s), (t))
#define XTRACETIME(s, d)        fprintf(stderr, "%s %u.%09u\n", (s), \
                           (d).seconds, (d).nanoseconds)
#define XTRACETIME2(s, d, n)        fprintf(stderr, "%s %u.%09u %u.%09u\n", (s), \
                           (d).seconds, (d).nanoseconds, (n).seconds, (n).nanoseconds)
#define XTRACETIMER(s, t, d)        fprintf(stderr, "%s %p %u.%09u\n", (s), (t), \
                           (d).seconds, (d).nanoseconds)
#else
#define XTRACE(s)
#define XTRACEID(s, t)
#define XTRACETIME(s, d)
#define XTRACETIME2(s, d, n)
#define XTRACETIMER(s, t, d)
#endif /* ISC_TIMER_TRACE */

#define TIMER_MAGIC         ISC_MAGIC('T', 'I', 'M', 'R')
#define VALID_TIMER(t)          ISC_MAGIC_VALID(t, TIMER_MAGIC)

typedef struct isc__timer isc__timer_t;
typedef struct isc__timermgr isc__timermgr_t;

struct isc__timer {
    /*! Not locked. */
    isc_timer_t         common;
    isc__timermgr_t *       manager;
    isc_mutex_t         lock;
    /*! Locked by timer lock. */
    unsigned int            references;
    isc_time_t          idle;
    /*! Locked by manager lock. */
    isc_timertype_t         type;
    isc_time_t          expires;
    isc_interval_t          interval;
    isc_task_t *            task;
    isc_taskaction_t        action;
    void *              arg;
    unsigned int            index;
    isc_time_t          due;
    LINK(isc__timer_t)      link;
};

#define TIMER_MANAGER_MAGIC     ISC_MAGIC('T', 'I', 'M', 'M')
#define VALID_MANAGER(m)        ISC_MAGIC_VALID(m, TIMER_MANAGER_MAGIC)

struct isc__timermgr {
    /* Not locked. */
    isc_timermgr_t          common;
    isc_mem_t *         mctx;
    isc_mutex_t         lock;
    /* Locked by manager lock. */
    isc_boolean_t           done;
    LIST(isc__timer_t)      timers;
    unsigned int            nscheduled;
    isc_time_t          due;
#ifdef USE_TIMER_THREAD
    isc_condition_t         wakeup;
    isc_thread_t            thread;
#endif  /* USE_TIMER_THREAD */
#ifdef USE_SHARED_MANAGER
    unsigned int            refs;
#endif /* USE_SHARED_MANAGER */
    isc_heap_t *            heap;
};

/*%
 * The following are intended for internal use (indicated by "isc__"
 * prefix) but are not declared as static, allowing direct access from
 * unit tests etc.
 */

isc_result_t
isc__timer_create(isc_timermgr_t *manager, isc_timertype_t type,
          const isc_time_t *expires, const isc_interval_t *interval,
          isc_task_t *task, isc_taskaction_t action, void *arg,
          isc_timer_t **timerp);
isc_result_t
isc__timer_reset(isc_timer_t *timer, isc_timertype_t type,
         const isc_time_t *expires, const isc_interval_t *interval,
         isc_boolean_t purge);
isc_timertype_t
isc_timer_gettype(isc_timer_t *timer);
isc_result_t
isc__timer_touch(isc_timer_t *timer);
void
isc__timer_attach(isc_timer_t *timer0, isc_timer_t **timerp);
void
isc__timer_detach(isc_timer_t **timerp);
isc_result_t
isc__timermgr_create(isc_mem_t *mctx, isc_timermgr_t **managerp);
void
isc_timermgr_poke(isc_timermgr_t *manager0);
void
isc__timermgr_destroy(isc_timermgr_t **managerp);

static struct isc__timermethods {
    isc_timermethods_t methods;

    /*%
     * The following are defined just for avoiding unused static functions.
     */
    void *gettype;
} timermethods = {
    {
        isc__timer_attach,
        isc__timer_detach,
        isc__timer_reset,
        isc__timer_touch
    },
    (void *)isc_timer_gettype
};

static struct isc__timermgrmethods {
    isc_timermgrmethods_t methods;
    void *poke;     /* see above */
} timermgrmethods = {
    {
        isc__timermgr_destroy,
        isc__timer_create
    },
    (void *)isc_timermgr_poke
};

#ifdef USE_SHARED_MANAGER
/*!
 * If the manager is supposed to be shared, there can be only one.
 */
static isc__timermgr_t *timermgr = NULL;
#endif /* USE_SHARED_MANAGER */

static inline isc_result_t
schedule(isc__timer_t *timer, isc_time_t *now, isc_boolean_t signal_ok) {
    isc_result_t result;
    isc__timermgr_t *manager;
    isc_time_t due;
    int cmp;
#ifdef USE_TIMER_THREAD
    isc_boolean_t timedwait;
#endif

    /*!
     * Note: the caller must ensure locking.
     */

    REQUIRE(timer->type != isc_timertype_inactive);

#ifndef USE_TIMER_THREAD
    UNUSED(signal_ok);
#endif /* USE_TIMER_THREAD */

    manager = timer->manager;

#ifdef USE_TIMER_THREAD
    /*!
     * If the manager was timed wait, we may need to signal the
     * manager to force a wakeup.
     */
    timedwait = ISC_TF(manager->nscheduled > 0 &&
               isc_time_seconds(&manager->due) != 0);
#endif

    /*
     * Compute the new due time.
     */
    if (timer->type != isc_timertype_once) {
        result = isc_time_add(now, &timer->interval, &due);
        if (result != ISC_R_SUCCESS)
            return (result);
        if (timer->type == isc_timertype_limited &&
            isc_time_compare(&timer->expires, &due) < 0)
            due = timer->expires;
    } else {
        if (isc_time_isepoch(&timer->idle))
            due = timer->expires;
        else if (isc_time_isepoch(&timer->expires))
            due = timer->idle;
        else if (isc_time_compare(&timer->idle, &timer->expires) < 0)
            due = timer->idle;
        else
            due = timer->expires;
    }

    /*
     * Schedule the timer.
     */

    if (timer->index > 0) {
        /*
         * Already scheduled.
         */
        cmp = isc_time_compare(&due, &timer->due);
        timer->due = due;
        switch (cmp) {
        case -1:
            isc_heap_increased(manager->heap, timer->index);
            break;
        case 1:
            isc_heap_decreased(manager->heap, timer->index);
            break;
        case 0:
            /* Nothing to do. */
            break;
        }
    } else {
        timer->due = due;
        result = isc_heap_insert(manager->heap, timer);
        if (result != ISC_R_SUCCESS) {
            INSIST(result == ISC_R_NOMEMORY);
            return (ISC_R_NOMEMORY);
        }
        manager->nscheduled++;
    }

    XTRACETIMER(isc_msgcat_get(isc_msgcat, ISC_MSGSET_TIMER,
                   ISC_MSG_SCHEDULE, "schedule"), timer, due);

    /*
     * If this timer is at the head of the queue, we need to ensure
     * that we won't miss it if it has a more recent due time than
     * the current "next" timer.  We do this either by waking up the
     * run thread, or explicitly setting the value in the manager.
     */
#ifdef USE_TIMER_THREAD

    /*
     * This is a temporary (probably) hack to fix a bug on tru64 5.1
     * and 5.1a.  Sometimes, pthread_cond_timedwait() doesn't actually
     * return when the time expires, so here, we check to see if
     * we're 15 seconds or more behind, and if we are, we signal
     * the dispatcher.  This isn't such a bad idea as a general purpose
     * watchdog, so perhaps we should just leave it in here.
     */
    if (signal_ok && timedwait) {
        isc_interval_t fifteen;
        isc_time_t then;

        isc_interval_set(&fifteen, 15, 0);
        result = isc_time_add(&manager->due, &fifteen, &then);

        if (result == ISC_R_SUCCESS &&
            isc_time_compare(&then, now) < 0) {
            SIGNAL(&manager->wakeup);
            signal_ok = ISC_FALSE;
            isc_log_write(isc_lctx, ISC_LOGCATEGORY_GENERAL,
                      ISC_LOGMODULE_TIMER, ISC_LOG_WARNING,
                      "*** POKED TIMER ***");
        }
    }

    if (timer->index == 1 && signal_ok) {
        XTRACE(isc_msgcat_get(isc_msgcat, ISC_MSGSET_TIMER,
                      ISC_MSG_SIGNALSCHED,
                      "signal (schedule)"));
        SIGNAL(&manager->wakeup);
    }
#else /* USE_TIMER_THREAD */
    if (timer->index == 1 &&
        isc_time_compare(&timer->due, &manager->due) < 0)
        manager->due = timer->due;
#endif /* USE_TIMER_THREAD */

    return (ISC_R_SUCCESS);
}

static inline void
deschedule(isc__timer_t *timer) {
#ifdef USE_TIMER_THREAD
    isc_boolean_t need_wakeup = ISC_FALSE;
#endif
    isc__timermgr_t *manager;

    /*
     * The caller must ensure locking.
     */

    manager = timer->manager;
    if (timer->index > 0) {
#ifdef USE_TIMER_THREAD
        if (timer->index == 1)
            need_wakeup = ISC_TRUE;
#endif
        isc_heap_delete(manager->heap, timer->index);
        timer->index = 0;
        INSIST(manager->nscheduled > 0);
        manager->nscheduled--;
#ifdef USE_TIMER_THREAD
        if (need_wakeup) {
            XTRACE(isc_msgcat_get(isc_msgcat, ISC_MSGSET_TIMER,
                          ISC_MSG_SIGNALDESCHED,
                          "signal (deschedule)"));
            SIGNAL(&manager->wakeup);
        }
#endif /* USE_TIMER_THREAD */
    }
}

static void
destroy(isc__timer_t *timer) {
    isc__timermgr_t *manager = timer->manager;

    /*
     * The caller must ensure it is safe to destroy the timer.
     */

    LOCK(&manager->lock);

    (void)isc_task_purgerange(timer->task,
                  timer,
                  ISC_TIMEREVENT_FIRSTEVENT,
                  ISC_TIMEREVENT_LASTEVENT,
                  NULL);
    deschedule(timer);
    UNLINK(manager->timers, timer, link);

    UNLOCK(&manager->lock);

    isc_task_detach(&timer->task);
    DESTROYLOCK(&timer->lock);
    timer->common.impmagic = 0;
    timer->common.magic = 0;
    isc_mem_put(manager->mctx, timer, sizeof(*timer));
}

isc_result_t
isc__timer_create(isc_timermgr_t *manager0, isc_timertype_t type,
          const isc_time_t *expires, const isc_interval_t *interval,
          isc_task_t *task, isc_taskaction_t action, void *arg,
          isc_timer_t **timerp)
{
    isc__timermgr_t *manager = (isc__timermgr_t *)manager0;
    isc__timer_t *timer;
    isc_result_t result;
    isc_time_t now;

    /*
     * Create a new 'type' timer managed by 'manager'.  The timers
     * parameters are specified by 'expires' and 'interval'.  Events
     * will be posted to 'task' and when dispatched 'action' will be
     * called with 'arg' as the arg value.  The new timer is returned
     * in 'timerp'.
     */

    REQUIRE(VALID_MANAGER(manager));
    REQUIRE(task != NULL);
    REQUIRE(action != NULL);
    if (expires == NULL)
        expires = isc_time_epoch;
    if (interval == NULL)
        interval = isc_interval_zero;
    REQUIRE(type == isc_timertype_inactive ||
        !(isc_time_isepoch(expires) && isc_interval_iszero(interval)));
    REQUIRE(timerp != NULL && *timerp == NULL);
    REQUIRE(type != isc_timertype_limited ||
        !(isc_time_isepoch(expires) || isc_interval_iszero(interval)));

    /*
     * Get current time.
     */
    if (type != isc_timertype_inactive) {
        TIME_NOW(&now);
    } else {
        /*
         * We don't have to do this, but it keeps the compiler from
         * complaining about "now" possibly being used without being
         * set, even though it will never actually happen.
         */
        isc_time_settoepoch(&now);
    }


    timer = isc_mem_get(manager->mctx, sizeof(*timer));
    if (timer == NULL)
        return (ISC_R_NOMEMORY);

    timer->manager = manager;
    timer->references = 1;

    if (type == isc_timertype_once && !isc_interval_iszero(interval)) {
        result = isc_time_add(&now, interval, &timer->idle);
        if (result != ISC_R_SUCCESS) {
            isc_mem_put(manager->mctx, timer, sizeof(*timer));
            return (result);
        }
    } else
        isc_time_settoepoch(&timer->idle);

    timer->type = type;
    timer->expires = *expires;
    timer->interval = *interval;
    timer->task = NULL;
    isc_task_attach(task, &timer->task);
    timer->action = action;
    /*
     * Removing the const attribute from "arg" is the best of two
     * evils here.  If the timer->arg member is made const, then
     * it affects a great many recipients of the timer event
     * which did not pass in an "arg" that was truly const.
     * Changing isc_timer_create() to not have "arg" prototyped as const,
     * though, can cause compilers warnings for calls that *do*
     * have a truly const arg.  The caller will have to carefully
     * keep track of whether arg started as a true const.
     */
    DE_CONST(arg, timer->arg);
    timer->index = 0;
    result = isc_mutex_init(&timer->lock);
    if (result != ISC_R_SUCCESS) {
        isc_task_detach(&timer->task);
        isc_mem_put(manager->mctx, timer, sizeof(*timer));
        return (result);
    }
    ISC_LINK_INIT(timer, link);
    timer->common.impmagic = TIMER_MAGIC;
    timer->common.magic = ISCAPI_TIMER_MAGIC;
    timer->common.methods = (isc_timermethods_t *)&timermethods;

    LOCK(&manager->lock);

    /*
     * Note we don't have to lock the timer like we normally would because
     * there are no external references to it yet.
     */

    if (type != isc_timertype_inactive)
        result = schedule(timer, &now, ISC_TRUE);
    else
        result = ISC_R_SUCCESS;
    if (result == ISC_R_SUCCESS)
        APPEND(manager->timers, timer, link);

    UNLOCK(&manager->lock);

    if (result != ISC_R_SUCCESS) {
        timer->common.impmagic = 0;
        timer->common.magic = 0;
        DESTROYLOCK(&timer->lock);
        isc_task_detach(&timer->task);
        isc_mem_put(manager->mctx, timer, sizeof(*timer));
        return (result);
    }

    *timerp = (isc_timer_t *)timer;

    return (ISC_R_SUCCESS);
}

isc_result_t
isc__timer_reset(isc_timer_t *timer0, isc_timertype_t type,
         const isc_time_t *expires, const isc_interval_t *interval,
         isc_boolean_t purge)
{
    isc__timer_t *timer = (isc__timer_t *)timer0;
    isc_time_t now;
    isc__timermgr_t *manager;
    isc_result_t result;

    /*
     * Change the timer's type, expires, and interval values to the given
     * values.  If 'purge' is ISC_TRUE, any pending events from this timer
     * are purged from its task's event queue.
     */

    REQUIRE(VALID_TIMER(timer));
    manager = timer->manager;
    REQUIRE(VALID_MANAGER(manager));

    if (expires == NULL)
        expires = isc_time_epoch;
    if (interval == NULL)
        interval = isc_interval_zero;
    REQUIRE(type == isc_timertype_inactive ||
        !(isc_time_isepoch(expires) && isc_interval_iszero(interval)));
    REQUIRE(type != isc_timertype_limited ||
        !(isc_time_isepoch(expires) || isc_interval_iszero(interval)));

    /*
     * Get current time.
     */
    if (type != isc_timertype_inactive) {
        TIME_NOW(&now);
    } else {
        /*
         * We don't have to do this, but it keeps the compiler from
         * complaining about "now" possibly being used without being
         * set, even though it will never actually happen.
         */
        isc_time_settoepoch(&now);
    }

    LOCK(&manager->lock);
    LOCK(&timer->lock);

    if (purge)
        (void)isc_task_purgerange(timer->task,
                      timer,
                      ISC_TIMEREVENT_FIRSTEVENT,
                      ISC_TIMEREVENT_LASTEVENT,
                      NULL);
    timer->type = type;
    timer->expires = *expires;
    timer->interval = *interval;
    if (type == isc_timertype_once && !isc_interval_iszero(interval)) {
        result = isc_time_add(&now, interval, &timer->idle);
    } else {
        isc_time_settoepoch(&timer->idle);
        result = ISC_R_SUCCESS;
    }

    if (result == ISC_R_SUCCESS) {
        if (type == isc_timertype_inactive) {
            deschedule(timer);
            result = ISC_R_SUCCESS;
        } else
            result = schedule(timer, &now, ISC_TRUE);
    }

    UNLOCK(&timer->lock);
    UNLOCK(&manager->lock);

    return (result);
}

isc_timertype_t
isc_timer_gettype(isc_timer_t *timer0) {
    isc__timer_t *timer = (isc__timer_t *)timer0;
    isc_timertype_t t;

    REQUIRE(VALID_TIMER(timer));

    LOCK(&timer->lock);
    t = timer->type;
    UNLOCK(&timer->lock);

    return (t);
}

isc_result_t
isc__timer_touch(isc_timer_t *timer0) {
    isc__timer_t *timer = (isc__timer_t *)timer0;
    isc_result_t result;
    isc_time_t now;

    /*
     * Set the last-touched time of 'timer' to the current time.
     */

    REQUIRE(VALID_TIMER(timer));

    LOCK(&timer->lock);

    /*
     * We'd like to
     *
     *  REQUIRE(timer->type == isc_timertype_once);
     *
     * but we cannot without locking the manager lock too, which we
     * don't want to do.
     */

    TIME_NOW(&now);
    result = isc_time_add(&now, &timer->interval, &timer->idle);

    UNLOCK(&timer->lock);

    return (result);
}

void
isc__timer_attach(isc_timer_t *timer0, isc_timer_t **timerp) {
    isc__timer_t *timer = (isc__timer_t *)timer0;

    /*
     * Attach *timerp to timer.
     */

    REQUIRE(VALID_TIMER(timer));
    REQUIRE(timerp != NULL && *timerp == NULL);

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

    *timerp = (isc_timer_t *)timer;
}

void
isc__timer_detach(isc_timer_t **timerp) {
    isc__timer_t *timer;
    isc_boolean_t free_timer = ISC_FALSE;

    /*
     * Detach *timerp from its timer.
     */

    REQUIRE(timerp != NULL);
    timer = (isc__timer_t *)*timerp;
    REQUIRE(VALID_TIMER(timer));

    LOCK(&timer->lock);
    REQUIRE(timer->references > 0);
    timer->references--;
    if (timer->references == 0)
        free_timer = ISC_TRUE;
    UNLOCK(&timer->lock);

    if (free_timer)
        destroy(timer);

    *timerp = NULL;
}

static void
dispatch(isc__timermgr_t *manager, isc_time_t *now) {
    isc_boolean_t done = ISC_FALSE, post_event, need_schedule;
    isc_timerevent_t *event;
    isc_eventtype_t type = 0;
    isc__timer_t *timer;
    isc_result_t result;
    isc_boolean_t idle;

    /*!
     * The caller must be holding the manager lock.
     */

    while (manager->nscheduled > 0 && !done) {
        timer = isc_heap_element(manager->heap, 1);
        INSIST(timer != NULL && timer->type != isc_timertype_inactive);
        if (isc_time_compare(now, &timer->due) >= 0) {
            if (timer->type == isc_timertype_ticker) {
                type = ISC_TIMEREVENT_TICK;
                post_event = ISC_TRUE;
                need_schedule = ISC_TRUE;
            } else if (timer->type == isc_timertype_limited) {
                int cmp;
                cmp = isc_time_compare(now, &timer->expires);
                if (cmp >= 0) {
                    type = ISC_TIMEREVENT_LIFE;
                    post_event = ISC_TRUE;
                    need_schedule = ISC_FALSE;
                } else {
                    type = ISC_TIMEREVENT_TICK;
                    post_event = ISC_TRUE;
                    need_schedule = ISC_TRUE;
                }
            } else if (!isc_time_isepoch(&timer->expires) &&
                   isc_time_compare(now,
                            &timer->expires) >= 0) {
                type = ISC_TIMEREVENT_LIFE;
                post_event = ISC_TRUE;
                need_schedule = ISC_FALSE;
            } else {
                idle = ISC_FALSE;

                LOCK(&timer->lock);
                if (!isc_time_isepoch(&timer->idle) &&
                    isc_time_compare(now,
                             &timer->idle) >= 0) {
                    idle = ISC_TRUE;
                }
                UNLOCK(&timer->lock);
                if (idle) {
                    type = ISC_TIMEREVENT_IDLE;
                    post_event = ISC_TRUE;
                    need_schedule = ISC_FALSE;
                } else {
                    /*
                     * Idle timer has been touched;
                     * reschedule.
                     */
                    XTRACEID(isc_msgcat_get(isc_msgcat,
                                ISC_MSGSET_TIMER,
                                ISC_MSG_IDLERESCHED,
                                "idle reschedule"),
                         timer);
                    post_event = ISC_FALSE;
                    need_schedule = ISC_TRUE;
                }
            }

            if (post_event) {
                XTRACEID(isc_msgcat_get(isc_msgcat,
                            ISC_MSGSET_TIMER,
                            ISC_MSG_POSTING,
                            "posting"), timer);
                /*
                 * XXX We could preallocate this event.
                 */
                event = (isc_timerevent_t *)isc_event_allocate(manager->mctx,
                               timer,
                               type,
                               timer->action,
                               timer->arg,
                               sizeof(*event));

                if (event != NULL) {
                    event->due = timer->due;
                    isc_task_send(timer->task,
                              ISC_EVENT_PTR(&event));
                } else
                    UNEXPECTED_ERROR(__FILE__, __LINE__, "%s",
                         isc_msgcat_get(isc_msgcat,
                             ISC_MSGSET_TIMER,
                             ISC_MSG_EVENTNOTALLOC,
                             "couldn't "
                             "allocate event"));
            }

            timer->index = 0;
            isc_heap_delete(manager->heap, 1);
            manager->nscheduled--;

            if (need_schedule) {
                result = schedule(timer, now, ISC_FALSE);
                if (result != ISC_R_SUCCESS)
                    UNEXPECTED_ERROR(__FILE__, __LINE__,
                             "%s: %u",
                        isc_msgcat_get(isc_msgcat,
                            ISC_MSGSET_TIMER,
                            ISC_MSG_SCHEDFAIL,
                            "couldn't schedule "
                            "timer"),
                             result);
            }
        } else {
            manager->due = timer->due;
            done = ISC_TRUE;
        }
    }
}

#ifdef USE_TIMER_THREAD
static isc_threadresult_t
#ifdef _WIN32           /* XXXDCL */
WINAPI
#endif
run(void *uap) {
    isc__timermgr_t *manager = uap;
    isc_time_t now;
    isc_result_t result;

    LOCK(&manager->lock);
    while (!manager->done) {
        TIME_NOW(&now);

        XTRACETIME(isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
                      ISC_MSG_RUNNING,
                      "running"), now);

        dispatch(manager, &now);

        if (manager->nscheduled > 0) {
            XTRACETIME2(isc_msgcat_get(isc_msgcat,
                           ISC_MSGSET_GENERAL,
                           ISC_MSG_WAITUNTIL,
                           "waituntil"),
                    manager->due, now);
            result = WAITUNTIL(&manager->wakeup, &manager->lock, &manager->due);
            INSIST(result == ISC_R_SUCCESS ||
                   result == ISC_R_TIMEDOUT);
        } else {
            XTRACETIME(isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
                          ISC_MSG_WAIT, "wait"), now);
            WAIT(&manager->wakeup, &manager->lock);
        }
        XTRACE(isc_msgcat_get(isc_msgcat, ISC_MSGSET_TIMER,
                      ISC_MSG_WAKEUP, "wakeup"));
    }
    UNLOCK(&manager->lock);

#ifdef OPENSSL_LEAKS
    ERR_remove_state(0);
#endif

    return ((isc_threadresult_t)0);
}
#endif /* USE_TIMER_THREAD */

static isc_boolean_t
sooner(void *v1, void *v2) {
    isc__timer_t *t1, *t2;

    t1 = v1;
    t2 = v2;
    REQUIRE(VALID_TIMER(t1));
    REQUIRE(VALID_TIMER(t2));

    if (isc_time_compare(&t1->due, &t2->due) < 0)
        return (ISC_TRUE);
    return (ISC_FALSE);
}

static void
set_index(void *what, unsigned int index) {
    isc__timer_t *timer;

    timer = what;
    REQUIRE(VALID_TIMER(timer));

    timer->index = index;
}

isc_result_t
isc__timermgr_create(isc_mem_t *mctx, isc_timermgr_t **managerp) {
    isc__timermgr_t *manager;
    isc_result_t result;

    /*
     * Create a timer manager.
     */

    REQUIRE(managerp != NULL && *managerp == NULL);

#ifdef USE_SHARED_MANAGER
    if (timermgr != NULL) {
        timermgr->refs++;
        *managerp = (isc_timermgr_t *)timermgr;
        return (ISC_R_SUCCESS);
    }
#endif /* USE_SHARED_MANAGER */

    manager = isc_mem_get(mctx, sizeof(*manager));
    if (manager == NULL)
        return (ISC_R_NOMEMORY);

    manager->common.impmagic = TIMER_MANAGER_MAGIC;
    manager->common.magic = ISCAPI_TIMERMGR_MAGIC;
    manager->common.methods = (isc_timermgrmethods_t *)&timermgrmethods;
    manager->mctx = NULL;
    manager->done = ISC_FALSE;
    INIT_LIST(manager->timers);
    manager->nscheduled = 0;
    isc_time_settoepoch(&manager->due);
    manager->heap = NULL;
    result = isc_heap_create(mctx, sooner, set_index, 0, &manager->heap);
    if (result != ISC_R_SUCCESS) {
        INSIST(result == ISC_R_NOMEMORY);
        isc_mem_put(mctx, manager, sizeof(*manager));
        return (ISC_R_NOMEMORY);
    }
    result = isc_mutex_init(&manager->lock);
    if (result != ISC_R_SUCCESS) {
        isc_heap_destroy(&manager->heap);
        isc_mem_put(mctx, manager, sizeof(*manager));
        return (result);
    }
    isc_mem_attach(mctx, &manager->mctx);
#ifdef USE_TIMER_THREAD
    if (isc_condition_init(&manager->wakeup) != ISC_R_SUCCESS) {
        isc_mem_detach(&manager->mctx);
        DESTROYLOCK(&manager->lock);
        isc_heap_destroy(&manager->heap);
        isc_mem_put(mctx, manager, sizeof(*manager));
        UNEXPECTED_ERROR(__FILE__, __LINE__,
                 "isc_condition_init() %s",
                 isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
                        ISC_MSG_FAILED, "failed"));
        return (ISC_R_UNEXPECTED);
    }
    if (isc_thread_create(run, manager, &manager->thread) !=
        ISC_R_SUCCESS) {
        isc_mem_detach(&manager->mctx);
        (void)isc_condition_destroy(&manager->wakeup);
        DESTROYLOCK(&manager->lock);
        isc_heap_destroy(&manager->heap);
        isc_mem_put(mctx, manager, sizeof(*manager));
        UNEXPECTED_ERROR(__FILE__, __LINE__,
                 "isc_thread_create() %s",
                 isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
                        ISC_MSG_FAILED, "failed"));
        return (ISC_R_UNEXPECTED);
    }
#endif
#ifdef USE_SHARED_MANAGER
    manager->refs = 1;
    timermgr = manager;
#endif /* USE_SHARED_MANAGER */

    *managerp = (isc_timermgr_t *)manager;

    return (ISC_R_SUCCESS);
}

void
isc_timermgr_poke(isc_timermgr_t *manager0) {
#ifdef USE_TIMER_THREAD
    isc__timermgr_t *manager = (isc__timermgr_t *)manager0;

    REQUIRE(VALID_MANAGER(manager));

    SIGNAL(&manager->wakeup);
#else
    UNUSED(manager0);
#endif
}

void
isc__timermgr_destroy(isc_timermgr_t **managerp) {
    isc__timermgr_t *manager;
    isc_mem_t *mctx;

    /*
     * Destroy a timer manager.
     */

    REQUIRE(managerp != NULL);
    manager = (isc__timermgr_t *)*managerp;
    REQUIRE(VALID_MANAGER(manager));

    LOCK(&manager->lock);

#ifdef USE_SHARED_MANAGER
    manager->refs--;
    if (manager->refs > 0) {
        UNLOCK(&manager->lock);
        *managerp = NULL;
        return;
    }
    timermgr = NULL;
#endif /* USE_SHARED_MANAGER */

#ifndef USE_TIMER_THREAD
    isc__timermgr_dispatch((isc_timermgr_t *)manager);
#endif

    REQUIRE(EMPTY(manager->timers));
    manager->done = ISC_TRUE;

#ifdef USE_TIMER_THREAD
    XTRACE(isc_msgcat_get(isc_msgcat, ISC_MSGSET_TIMER,
                  ISC_MSG_SIGNALDESTROY, "signal (destroy)"));
    SIGNAL(&manager->wakeup);
#endif /* USE_TIMER_THREAD */

    UNLOCK(&manager->lock);

#ifdef USE_TIMER_THREAD
    /*
     * Wait for thread to exit.
     */
    if (isc_thread_join(manager->thread, NULL) != ISC_R_SUCCESS)
        UNEXPECTED_ERROR(__FILE__, __LINE__,
                 "isc_thread_join() %s",
                 isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
                        ISC_MSG_FAILED, "failed"));
#endif /* USE_TIMER_THREAD */

    /*
     * Clean up.
     */
#ifdef USE_TIMER_THREAD
    (void)isc_condition_destroy(&manager->wakeup);
#endif /* USE_TIMER_THREAD */
    DESTROYLOCK(&manager->lock);
    isc_heap_destroy(&manager->heap);
    manager->common.impmagic = 0;
    manager->common.magic = 0;
    mctx = manager->mctx;
    isc_mem_put(mctx, manager, sizeof(*manager));
    isc_mem_detach(&mctx);

    *managerp = NULL;

#ifdef USE_SHARED_MANAGER
    timermgr = NULL;
#endif
}

#ifndef USE_TIMER_THREAD
isc_result_t
isc__timermgr_nextevent(isc_timermgr_t *manager0, isc_time_t *when) {
    isc__timermgr_t *manager = (isc__timermgr_t *)manager0;

#ifdef USE_SHARED_MANAGER
    if (manager == NULL)
        manager = timermgr;
#endif
    if (manager == NULL || manager->nscheduled == 0)
        return (ISC_R_NOTFOUND);
    *when = manager->due;
    return (ISC_R_SUCCESS);
}

void
isc__timermgr_dispatch(isc_timermgr_t *manager0) {
    isc__timermgr_t *manager = (isc__timermgr_t *)manager0;
    isc_time_t now;

#ifdef USE_SHARED_MANAGER
    if (manager == NULL)
        manager = timermgr;
#endif
    if (manager == NULL)
        return;
    TIME_NOW(&now);
    dispatch(manager, &now);
}
#endif /* USE_TIMER_THREAD */

isc_result_t
isc__timer_register(void) {
    return (isc_timer_register(isc__timermgr_create));
}

static isc_mutex_t createlock;
static isc_once_t once = ISC_ONCE_INIT;
static isc_timermgrcreatefunc_t timermgr_createfunc = NULL;

static void
initialize(void) {
    RUNTIME_CHECK(isc_mutex_init(&createlock) == ISC_R_SUCCESS);
}

isc_result_t
isc_timer_register(isc_timermgrcreatefunc_t createfunc) {
    isc_result_t result = ISC_R_SUCCESS;

    RUNTIME_CHECK(isc_once_do(&once, initialize) == ISC_R_SUCCESS);

    LOCK(&createlock);
    if (timermgr_createfunc == NULL)
        timermgr_createfunc = createfunc;
    else
        result = ISC_R_EXISTS;
    UNLOCK(&createlock);

    return (result);
}

isc_result_t
isc_timermgr_createinctx(isc_mem_t *mctx, isc_appctx_t *actx,
             isc_timermgr_t **managerp)
{
    isc_result_t result;

    LOCK(&createlock);

    REQUIRE(timermgr_createfunc != NULL);
    result = (*timermgr_createfunc)(mctx, managerp);

    UNLOCK(&createlock);

    if (result == ISC_R_SUCCESS)
        isc_appctx_settimermgr(actx, *managerp);

    return (result);
}

isc_result_t
isc_timermgr_create(isc_mem_t *mctx, isc_timermgr_t **managerp) {
    isc_result_t result;

    if (isc_bind9)
        return (isc__timermgr_create(mctx, managerp));

    LOCK(&createlock);

    REQUIRE(timermgr_createfunc != NULL);
    result = (*timermgr_createfunc)(mctx, managerp);

    UNLOCK(&createlock);

    return (result);
}

void
isc_timermgr_destroy(isc_timermgr_t **managerp) {
    REQUIRE(*managerp != NULL && ISCAPI_TIMERMGR_VALID(*managerp));

    if (isc_bind9)
        isc__timermgr_destroy(managerp);
    else
        (*managerp)->methods->destroy(managerp);

    ENSURE(*managerp == NULL);
}

isc_result_t
isc_timer_create(isc_timermgr_t *manager, isc_timertype_t type,
         const isc_time_t *expires, const isc_interval_t *interval,
         isc_task_t *task, isc_taskaction_t action, const void *arg,
         isc_timer_t **timerp)
{
    REQUIRE(ISCAPI_TIMERMGR_VALID(manager));

    if (isc_bind9)
        return (isc__timer_create(manager, type, expires, interval,
                      task, action, arg, timerp));

    return (manager->methods->timercreate(manager, type, expires,
                          interval, task, action, arg,
                          timerp));
}

void
isc_timer_attach(isc_timer_t *timer, isc_timer_t **timerp) {
    REQUIRE(ISCAPI_TIMER_VALID(timer));
    REQUIRE(timerp != NULL && *timerp == NULL);

    if (isc_bind9)
        isc__timer_attach(timer, timerp);
    else
        timer->methods->attach(timer, timerp);

    ENSURE(*timerp == timer);
}

void
isc_timer_detach(isc_timer_t **timerp) {
    REQUIRE(timerp != NULL && ISCAPI_TIMER_VALID(*timerp));

    if (isc_bind9)
        isc__timer_detach(timerp);
    else
        (*timerp)->methods->detach(timerp);

    ENSURE(*timerp == NULL);
}

isc_result_t
isc_timer_reset(isc_timer_t *timer, isc_timertype_t type,
        const isc_time_t *expires, const isc_interval_t *interval,
        isc_boolean_t purge)
{
    REQUIRE(ISCAPI_TIMER_VALID(timer));

    if (isc_bind9)
        return (isc__timer_reset(timer, type, expires,
                     interval, purge));

    return (timer->methods->reset(timer, type, expires, interval, purge));
}

isc_result_t
isc_timer_touch(isc_timer_t *timer) {
    REQUIRE(ISCAPI_TIMER_VALID(timer));

    if (isc_bind9)
        return (isc__timer_touch(timer));

    return (timer->methods->touch(timer));
}