lib/isc/ratelimiter.c

	ratelimiter.c revision c110d61b173a68420d19858abb80285be0dc1120
/*
 * Copyright (C) 2004, 2005, 2007, 2012, 2014, 2015  Internet Systems Consortium, Inc. ("ISC")
 * Copyright (C) 1999-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: ratelimiter.c,v 1.25 2007/06/19 23:47:17 tbox Exp $ */

/*! \file */

#include <config.h>

#include <isc/mem.h>
#include <isc/ratelimiter.h>
#include <isc/task.h>
#include <isc/time.h>
#include <isc/timer.h>
#include <isc/util.h>

typedef enum {
    isc_ratelimiter_stalled = 0,
    isc_ratelimiter_ratelimited = 1,
    isc_ratelimiter_idle = 2,
    isc_ratelimiter_shuttingdown = 3
} isc_ratelimiter_state_t;

struct isc_ratelimiter {
    isc_mem_t *     mctx;
    isc_mutex_t     lock;
    int         refs;
    isc_task_t *        task;
    isc_timer_t *       timer;
    isc_interval_t      interval;
    isc_uint32_t        pertic;
    isc_ratelimiter_state_t state;
    isc_event_t     shutdownevent;
    ISC_LIST(isc_event_t)   pending;
};

#define ISC_RATELIMITEREVENT_SHUTDOWN (ISC_EVENTCLASS_RATELIMITER + 1)

static void
ratelimiter_tick(isc_task_t *task, isc_event_t *event);

static void
ratelimiter_shutdowncomplete(isc_task_t *task, isc_event_t *event);

isc_result_t
isc_ratelimiter_create(isc_mem_t *mctx, isc_timermgr_t *timermgr,
               isc_task_t *task, isc_ratelimiter_t **ratelimiterp)
{
    isc_result_t result;
    isc_ratelimiter_t *rl;
    INSIST(ratelimiterp != NULL && *ratelimiterp == NULL);

    rl = isc_mem_get(mctx, sizeof(*rl));
    if (rl == NULL)
        return ISC_R_NOMEMORY;
    rl->mctx = mctx;
    rl->refs = 1;
    rl->task = task;
    isc_interval_set(&rl->interval, 0, 0);
    rl->timer = NULL;
    rl->pertic = 1;
    rl->state = isc_ratelimiter_idle;
    ISC_LIST_INIT(rl->pending);

    result = isc_mutex_init(&rl->lock);
    if (result != ISC_R_SUCCESS)
        goto free_mem;

    result = isc_timer_create(timermgr, isc_timertype_inactive,
                  NULL, NULL, rl->task, ratelimiter_tick,
                  rl, &rl->timer);
    if (result != ISC_R_SUCCESS)
        goto free_mutex;

    /*
     * Increment the reference count to indicate that we may
     * (soon) have events outstanding.
     */
    rl->refs++;

    ISC_EVENT_INIT(&rl->shutdownevent,
               sizeof(isc_event_t),
               0, NULL, ISC_RATELIMITEREVENT_SHUTDOWN,
               ratelimiter_shutdowncomplete, rl, rl, NULL, NULL);

    *ratelimiterp = rl;
    return (ISC_R_SUCCESS);

free_mutex:
    DESTROYLOCK(&rl->lock);
free_mem:
    isc_mem_put(mctx, rl, sizeof(*rl));
    return (result);
}

isc_result_t
isc_ratelimiter_setinterval(isc_ratelimiter_t *rl, isc_interval_t *interval) {
    isc_result_t result = ISC_R_SUCCESS;

    REQUIRE(rl != NULL);
    REQUIRE(interval != NULL);

    LOCK(&rl->lock);
    rl->interval = *interval;
    /*
     * If the timer is currently running, change its rate.
     */
    if (rl->state == isc_ratelimiter_ratelimited) {
        result = isc_timer_reset(rl->timer, isc_timertype_ticker, NULL,
                     &rl->interval, ISC_FALSE);
    }
    UNLOCK(&rl->lock);
    return (result);
}

void
isc_ratelimiter_setpertic(isc_ratelimiter_t *rl, isc_uint32_t pertic) {

    REQUIRE(rl != NULL);

    if (pertic == 0)
        pertic = 1;
    rl->pertic = pertic;
}

isc_result_t
isc_ratelimiter_enqueue(isc_ratelimiter_t *rl, isc_task_t *task,
            isc_event_t **eventp)
{
    isc_result_t result = ISC_R_SUCCESS;
    isc_event_t *ev;

    REQUIRE(rl != NULL);
    REQUIRE(task != NULL);
    REQUIRE(eventp != NULL && *eventp != NULL);
    ev = *eventp;
    REQUIRE(ev->ev_sender == NULL);

    LOCK(&rl->lock);
    if (rl->state == isc_ratelimiter_ratelimited ||
        rl->state == isc_ratelimiter_stalled) {
        ev->ev_sender = task;
        ISC_LIST_APPEND(rl->pending, ev, ev_link);
        *eventp = NULL;
    } else if (rl->state == isc_ratelimiter_idle) {
        result = isc_timer_reset(rl->timer, isc_timertype_ticker, NULL,
                     &rl->interval, ISC_FALSE);
        if (result == ISC_R_SUCCESS) {
            ev->ev_sender = task;
            rl->state = isc_ratelimiter_ratelimited;
        }
    } else {
        INSIST(rl->state == isc_ratelimiter_shuttingdown);
        result = ISC_R_SHUTTINGDOWN;
    }
    UNLOCK(&rl->lock);
    if (*eventp != NULL && result == ISC_R_SUCCESS)
        isc_task_send(task, eventp);
    return (result);
}

isc_result_t
isc_ratelimiter_dequeue(isc_ratelimiter_t *rl, isc_event_t *event) {
    isc_result_t result = ISC_R_SUCCESS;

    REQUIRE(rl != NULL);
    REQUIRE(event != NULL);

    LOCK(&rl->lock);
    if (ISC_LINK_LINKED(event, ev_link))
        ISC_LIST_UNLINK(rl->pending, event, ev_link);
    else
        result = ISC_R_NOTFOUND;
    UNLOCK(&rl->lock);
    return (result);
}

static void
ratelimiter_tick(isc_task_t *task, isc_event_t *event) {
    isc_result_t result = ISC_R_SUCCESS;
    isc_ratelimiter_t *rl = (isc_ratelimiter_t *)event->ev_arg;
    isc_event_t *p;
    isc_uint32_t pertic;

    UNUSED(task);

    isc_event_free(&event);

    pertic = rl->pertic;
    while (pertic != 0) {
        pertic--;
        LOCK(&rl->lock);
        p = ISC_LIST_HEAD(rl->pending);
        if (p != NULL) {
            /*
             * There is work to do.  Let's do it after unlocking.
             */
            ISC_LIST_UNLINK(rl->pending, p, ev_link);
        } else {
            /*
             * No work left to do.  Stop the timer so that we don't
             * waste resources by having it fire periodically.
             */
            result = isc_timer_reset(rl->timer,
                         isc_timertype_inactive,
                         NULL, NULL, ISC_FALSE);
            RUNTIME_CHECK(result == ISC_R_SUCCESS);
            rl->state = isc_ratelimiter_idle;
            pertic = 0; /* Force the loop to exit. */
        }
        UNLOCK(&rl->lock);
        if (p != NULL) {
            isc_task_t *evtask = p->ev_sender;
            isc_task_send(evtask, &p);
        }
        INSIST(p == NULL);
    }
}

void
isc_ratelimiter_shutdown(isc_ratelimiter_t *rl) {
    isc_event_t *ev;
    isc_task_t *task;

    REQUIRE(rl != NULL);

    LOCK(&rl->lock);
    rl->state = isc_ratelimiter_shuttingdown;
    (void)isc_timer_reset(rl->timer, isc_timertype_inactive,
                  NULL, NULL, ISC_FALSE);
    while ((ev = ISC_LIST_HEAD(rl->pending)) != NULL) {
        ISC_LIST_UNLINK(rl->pending, ev, ev_link);
        ev->ev_attributes |= ISC_EVENTATTR_CANCELED;
        task = ev->ev_sender;
        isc_task_send(task, &ev);
    }
    isc_timer_detach(&rl->timer);

    /*
     * Send an event to our task.  The delivery of this event
     * indicates that no more timer events will be delivered.
     */
    ev = &rl->shutdownevent;
    isc_task_send(rl->task, &ev);

    UNLOCK(&rl->lock);
}

static void
ratelimiter_shutdowncomplete(isc_task_t *task, isc_event_t *event) {
    isc_ratelimiter_t *rl = (isc_ratelimiter_t *)event->ev_arg;

    UNUSED(task);

    isc_ratelimiter_detach(&rl);
}

static void
ratelimiter_free(isc_ratelimiter_t *rl) {
    DESTROYLOCK(&rl->lock);
    isc_mem_put(rl->mctx, rl, sizeof(*rl));
}

void
isc_ratelimiter_attach(isc_ratelimiter_t *source, isc_ratelimiter_t **target) {

    REQUIRE(source != NULL);
    REQUIRE(target != NULL && *target == NULL);

    LOCK(&source->lock);
    REQUIRE(source->refs > 0);
    source->refs++;
    INSIST(source->refs > 0);
    UNLOCK(&source->lock);
    *target = source;
}

void
isc_ratelimiter_detach(isc_ratelimiter_t **rlp) {
    isc_ratelimiter_t *rl;
    isc_boolean_t free_now = ISC_FALSE;

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

    rl = *rlp;

    LOCK(&rl->lock);
    REQUIRE(rl->refs > 0);
    rl->refs--;
    if (rl->refs == 0)
        free_now = ISC_TRUE;
    UNLOCK(&rl->lock);

    if (free_now)
        ratelimiter_free(rl);

    *rlp = NULL;
}

isc_result_t
isc_ratelimiter_stall(isc_ratelimiter_t *rl) {
    isc_result_t result = ISC_R_SUCCESS;

    REQUIRE(rl != NULL);

    LOCK(&rl->lock);
    switch (rl->state) {
    case isc_ratelimiter_shuttingdown:
        result = ISC_R_SHUTTINGDOWN;
        break;
    case isc_ratelimiter_ratelimited:
        result = isc_timer_reset(rl->timer, isc_timertype_inactive,
                     NULL, NULL, ISC_FALSE);
        RUNTIME_CHECK(result == ISC_R_SUCCESS);
        /* FALLTHROUGH */
    case isc_ratelimiter_idle:
    case isc_ratelimiter_stalled:
        rl->state = isc_ratelimiter_stalled;
        break;
    }
    UNLOCK(&rl->lock);
    return (result);
}

isc_result_t
isc_ratelimiter_release(isc_ratelimiter_t *rl) {
    isc_result_t result = ISC_R_SUCCESS;

    REQUIRE(rl != NULL);

    LOCK(&rl->lock);
    switch (rl->state) {
    case isc_ratelimiter_shuttingdown:
        result = ISC_R_SHUTTINGDOWN;
        break;
    case isc_ratelimiter_stalled:
        if (!ISC_LIST_EMPTY(rl->pending)) {
            result = isc_timer_reset(rl->timer,
                         isc_timertype_ticker, NULL,
                         &rl->interval, ISC_FALSE);
            if (result == ISC_R_SUCCESS)
                rl->state = isc_ratelimiter_ratelimited;
        } else
            rl->state = isc_ratelimiter_idle;
        break;
    case isc_ratelimiter_ratelimited:
    case isc_ratelimiter_idle:
        break;
    }
    UNLOCK(&rl->lock);
    return (result);
}