GCOV - Varnish Cache


/*-
 * Copyright (c) 2006 Verdens Gang AS
 * Copyright (c) 2006-2015 Varnish Software AS
 * All rights reserved.
 *
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 */

#include "config.h"

#include <stdlib.h>
#include <stdio.h>

#include "cache_int.h"
#include "cache_ban.h"
#include "cache_objhead.h"

#include "vcli_serve.h"
#include "vend.h"
#include "vmb.h"

/* cache_ban_build.c */
void BAN_Build_Init(void);
void BAN_Build_Fini(void);

struct lock ban_mtx;
int ban_shutdown;
struct banhead_s ban_head = VTAILQ_HEAD_INITIALIZER(ban_head);
struct ban * volatile ban_start;

static pthread_t ban_thread;
static int ban_holds;
uint64_t bans_persisted_bytes;
uint64_t bans_persisted_fragmentation;

struct ban_test {
        uint8_t                 oper;
        uint8_t                 arg1;
        uint8_t                 arg2_bool;
        const char              *arg1_spec;
        const char              *arg2;
        double                  arg2_double;
        const void              *arg2_spec;
};

static const char * const arg_name[BAN_ARGARRSZ + 1] = {
#define PVAR(a, b, c) [BAN_ARGIDX(c)] = (a),
#include "tbl/ban_vars.h"
        [BAN_ARGARRSZ] = NULL
};

/*--------------------------------------------------------------------
 * Storage handling of bans
 */

static struct ban *
ban_alloc(void)
{
        struct ban *b;

        ALLOC_OBJ(b, BAN_MAGIC);
        if (b != NULL)
                VTAILQ_INIT(&b->objcore);
        return (b);
}

void
BAN_Free(struct ban *b)
{

        CHECK_OBJ_NOTNULL(b, BAN_MAGIC);
        AZ(b->refcount);
        assert(VTAILQ_EMPTY(&b->objcore));

        if (b->spec != NULL)
                free(b->spec);
        FREE_OBJ(b);
}

/*--------------------------------------------------------------------
 * Get/release holds which prevent the ban_lurker from starting.
 * Holds are held while stevedores load zombie objects.
 */

void
BAN_Hold(void)
{

        Lck_Lock(&ban_mtx);
        /* Once holds are released, we allow no more */
        assert(ban_holds > 0);
        ban_holds++;
        Lck_Unlock(&ban_mtx);
}

void
BAN_Release(void)
{

        Lck_Lock(&ban_mtx);
        assert(ban_holds > 0);
        ban_holds--;
        Lck_Unlock(&ban_mtx);
        if (ban_holds == 0) {
                BANIDX_fini();
                WRK_BgThread(&ban_thread, "ban-lurker", ban_lurker, NULL);
        }
}

/*--------------------------------------------------------------------
 * Extract time and length from ban-spec
 */

vtim_real
ban_time(const uint8_t *banspec)
{
        vtim_real t;
        uint64_t u;

        assert(sizeof t == sizeof u);
        assert(sizeof t == (BANS_LENGTH - BANS_TIMESTAMP));
        u = vbe64dec(banspec + BANS_TIMESTAMP);
        memcpy(&t, &u, sizeof t);
        return (t);
}

unsigned
ban_len(const uint8_t *banspec)
{
        unsigned u;

        u = vbe32dec(banspec + BANS_LENGTH);
        return (u);
}

int
ban_equal(const uint8_t *bs1, const uint8_t *bs2)
{
        unsigned u;

        /*
         * Compare two ban-strings.
         */
        u = ban_len(bs1);
        if (u != ban_len(bs2))
                return (0);
        if (bs1[BANS_FLAGS] & BANS_FLAG_NODEDUP)
                return (0);

        return (!memcmp(bs1 + BANS_LENGTH, bs2 + BANS_LENGTH, u - BANS_LENGTH));
}

void
ban_mark_completed(struct ban *b)
{
        unsigned ln;

        CHECK_OBJ_NOTNULL(b, BAN_MAGIC);
        Lck_AssertHeld(&ban_mtx);

        AN(b->spec);
        if (!(b->flags & BANS_FLAG_COMPLETED)) {
                ln = ban_len(b->spec);
                b->flags |= BANS_FLAG_COMPLETED;
                b->spec[BANS_FLAGS] |= BANS_FLAG_COMPLETED;
                VWMB();
                vbe32enc(b->spec + BANS_LENGTH, BANS_HEAD_LEN);
                VSC_C_main->bans_completed++;
                bans_persisted_fragmentation += ln - ban_len(b->spec);
                VSC_C_main->bans_persisted_fragmentation =
                    bans_persisted_fragmentation;
        }
}

/*--------------------------------------------------------------------
 * Access a lump of bytes in a ban test spec
 */

static const void *
ban_get_lump(const uint8_t **bs)
{
        const void *r;
        unsigned ln;

        while (**bs == 0xff)
                *bs += 1;
        ln = vbe32dec(*bs);
        *bs += PRNDUP(sizeof(uint32_t));
        assert(PAOK(*bs));
        r = (const void*)*bs;
        *bs += ln;
        return (r);
}

/*--------------------------------------------------------------------
 * Pick a test apart from a spec string
 */

static void
ban_iter(const uint8_t **bs, struct ban_test *bt)
{
        const void *lump;
        uint64_t dtmp;

        memset(bt, 0, sizeof *bt);
        bt->arg2_double = nan("");
        bt->arg1 = *(*bs)++;
        if (BANS_HAS_ARG1_SPEC(bt->arg1)) {
                bt->arg1_spec = (const char *)*bs;
                (*bs) += (*bs)[0] + 2;
        }
        lump = ban_get_lump(bs);
        bt->oper = *(*bs)++;
        if (BANS_HAS_ARG2_DOUBLE(bt->arg1)) {
                dtmp = vbe64dec(lump);
                memcpy(&bt->arg2_double, &dtmp, sizeof dtmp);
                return;
        } else if (BANS_HAS_ARG2_BOOL(bt->arg1)) {
                bt->arg2_bool = *(uint8_t const *)lump;
                return;
        }
        bt->arg2 = lump;
        if (BANS_HAS_ARG2_SPEC(bt->oper))
                bt->arg2_spec = ban_get_lump(bs);
}

/*--------------------------------------------------------------------
 * A new object is created, grab a reference to the newest ban
 */

void
BAN_NewObjCore(struct objcore *oc)
{

        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
        AZ(oc->ban);
        AN(oc->objhead);
        Lck_Lock(&ban_mtx);
        oc->ban = ban_start;
        ban_start->refcount++;
        VTAILQ_INSERT_TAIL(&ban_start->objcore, oc, ban_list);
        Lck_Unlock(&ban_mtx);
}

/*--------------------------------------------------------------------
 * An object is destroyed, release its ban reference
 */

void
BAN_DestroyObj(struct objcore *oc)
{

        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
        if (oc->ban == NULL)
                return;
        Lck_Lock(&ban_mtx);
        CHECK_OBJ_ORNULL(oc->ban, BAN_MAGIC);
        if (oc->ban != NULL) {
                assert(oc->ban->refcount > 0);
                oc->ban->refcount--;
                VTAILQ_REMOVE(&oc->ban->objcore, oc, ban_list);
                oc->ban = NULL;
        }
        Lck_Unlock(&ban_mtx);
}

/*--------------------------------------------------------------------
 * Find a ban based on a timestamp.
 * Assume we have a BAN_Hold, so list traversal is safe.
 */

struct ban *
BAN_FindBan(vtim_real t0)
{
        struct ban *b;
        vtim_real t1;

        assert(ban_holds > 0);
        b = BANIDX_lookup(t0);
        VTAILQ_FOREACH_FROM(b, &ban_head, list) {
                t1 = ban_time(b->spec);
                if (t1 == t0)
                        return (b);
                if (t1 < t0)
                        break;
        }
        return (NULL);
}

/*--------------------------------------------------------------------
 * Grab a reference to a ban and associate the objcore with that ban.
 * Assume we have a BAN_Hold, so list traversal is safe.
 */

void
BAN_RefBan(struct objcore *oc, struct ban *b)
{

        Lck_Lock(&ban_mtx);
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
        AZ(oc->ban);
        CHECK_OBJ_NOTNULL(b, BAN_MAGIC);
        assert(ban_holds > 0);
        b->refcount++;
        VTAILQ_INSERT_TAIL(&b->objcore, oc, ban_list);
        oc->ban = b;
        Lck_Unlock(&ban_mtx);
}

/*--------------------------------------------------------------------
 * Compile a full ban list and export this area to the stevedores for
 * persistence.
 */

static void
ban_export(void)
{
        struct ban *b;
        struct vsb *vsb;
        unsigned ln;

        Lck_AssertHeld(&ban_mtx);
        ln = bans_persisted_bytes - bans_persisted_fragmentation;
        vsb = VSB_new_auto();
        AN(vsb);
        VTAILQ_FOREACH_REVERSE(b, &ban_head, banhead_s, list)
                AZ(VSB_bcat(vsb, b->spec, ban_len(b->spec)));
        AZ(VSB_finish(vsb));
        assert(VSB_len(vsb) == ln);
        Lck_Unlock(&ban_mtx);
        STV_BanExport((const uint8_t *)VSB_data(vsb), VSB_len(vsb));
        VSB_destroy(&vsb);
        Lck_Lock(&ban_mtx);
        VSC_C_main->bans_persisted_bytes =
            bans_persisted_bytes = ln;
        VSC_C_main->bans_persisted_fragmentation =
            bans_persisted_fragmentation = 0;
}

/*
 * For both of these we do a full export on info failure to remove
 * holes in the exported list.
 * XXX: we should keep track of the size of holes in the last exported list
 * XXX: check if the ban_export should be batched in ban_cleantail
 */
void
ban_info_new(const uint8_t *ban, unsigned len)
{
        Lck_AssertHeld(&ban_mtx);
        if (STV_BanInfoNew(ban, len))
                ban_export();
}

void
ban_info_drop(const uint8_t *ban, unsigned len)
{
        Lck_AssertHeld(&ban_mtx);
        if (STV_BanInfoDrop(ban, len))
                ban_export();
}

/*--------------------------------------------------------------------
 * Put a skeleton ban in the list, unless there is an identical,
 * time & condition, ban already in place.
 *
 * If a newer ban has same condition, mark the inserted ban COMPLETED,
 * also mark any older bans, with the same condition COMPLETED.
 */

static void
ban_reload(const uint8_t *ban, unsigned len)
{
        struct ban *b, *b2;
        int duplicate = 0;
        vtim_real t0, t1, t2 = 9e99;
        ASSERT_CLI();
        Lck_AssertHeld(&ban_mtx);
        assert(ban_holds > 0);

        t0 = ban_time(ban);
        assert(len == ban_len(ban));

        b = BANIDX_lookup(t0);
        VTAILQ_FOREACH_FROM(b, &ban_head, list) {
                t1 = ban_time(b->spec);
                assert(t1 < t2);
                t2 = t1;
                if (t1 == t0)
                        return;
                if (t1 < t0)
                        break;
                if (ban_equal(b->spec, ban))
                        duplicate = 1;
        }

        VSC_C_main->bans++;
        VSC_C_main->bans_added++;

        b2 = ban_alloc();
        AN(b2);
        b2->spec = malloc(len);
        AN(b2->spec);
        memcpy(b2->spec, ban, len);
        if (ban[BANS_FLAGS] & BANS_FLAG_REQ) {
                VSC_C_main->bans_req++;
                b2->flags |= BANS_FLAG_REQ;
        }
        if (duplicate)
                VSC_C_main->bans_dups++;
        if (duplicate || (ban[BANS_FLAGS] & BANS_FLAG_COMPLETED))
                ban_mark_completed(b2);
        if (b == NULL)
                VTAILQ_INSERT_TAIL(&ban_head, b2, list);
        else
                VTAILQ_INSERT_BEFORE(b, b2, list);
        bans_persisted_bytes += len;
        VSC_C_main->bans_persisted_bytes = bans_persisted_bytes;

        /* Hunt down older duplicates */
        for (b = VTAILQ_NEXT(b2, list); b != NULL; b = VTAILQ_NEXT(b, list)) {
                if (b->flags & BANS_FLAG_COMPLETED)
                        continue;
                if (ban_equal(b->spec, ban)) {
                        ban_mark_completed(b);
                        VSC_C_main->bans_dups++;
                }
        }
}

/*--------------------------------------------------------------------
 * Reload a series of persisted ban specs
 */

void
BAN_Reload(const uint8_t *ptr, unsigned len)
{
        const uint8_t *pe;
        unsigned l;

        AZ(ban_shutdown);
        pe = ptr + len;
        Lck_Lock(&ban_mtx);
        while (ptr < pe) {
                /* XXX: This can be optimized by traversing the live
                 * ban list together with the reload list (combining
                 * the loops in BAN_Reload and ban_reload). */
                l = ban_len(ptr);
                assert(ptr + l <= pe);
                ban_reload(ptr, l);
                ptr += l;
        }
        Lck_Unlock(&ban_mtx);
}

/*--------------------------------------------------------------------
 * Get a bans timestamp
 */

vtim_real
BAN_Time(const struct ban *b)
{

        if (b == NULL)
                return (0.0);

        CHECK_OBJ(b, BAN_MAGIC);
        return (ban_time(b->spec));
}

/*--------------------------------------------------------------------
 * Evaluate ban-spec
 */

int
ban_evaluate(struct worker *wrk, const uint8_t *bsarg, struct objcore *oc,
    const struct http *reqhttp, unsigned *tests)
{
        struct ban_test bt;
        const uint8_t *bs, *be;
        const char *p;
        const char *arg1;
        double darg1, darg2;
        int barg1, barg2;
        hdr_t hdr;
        int rv;

        /*
         * for ttl, age and last_hit, fix the point in time such that banning
         * refers to the same point in time when the ban is evaluated
         *
         * for grace/keep, we assume that the absolute values are pola and that
         * users will most likely also specify a ttl criterion if they want to
         * fix a point in time (such as "obj.ttl > 5h && obj.keep > 3h")
         */

        bs = bsarg;
        be = bs + ban_len(bs);
        bs += BANS_HEAD_LEN;
        while (bs < be) {
                (*tests)++;
                ban_iter(&bs, &bt);
                arg1 = NULL;
                darg1 = darg2 = nan("");
                barg1 = barg2 = -1;
                switch (bt.arg1) {
                case BANS_ARG_URL:
                        AN(reqhttp);
                        arg1 = reqhttp->hd[HTTP_HDR_URL].b;
                        break;
                case BANS_ARG_REQHTTP:
                        AN(reqhttp);
                        CAST_HDR(hdr, bt.arg1_spec);
                        (void)http_GetHdr(reqhttp, hdr, &p);
                        arg1 = p;
                        break;
                case BANS_ARG_OBJHTTP:
                        CAST_HDR(hdr, bt.arg1_spec);
                        arg1 = HTTP_GetHdrPack(wrk, oc, hdr);
                        break;
                case BANS_ARG_OBJSTATUS:
                        arg1 = HTTP_GetHdrPack(wrk, oc, H__Status);
                        break;
                case BANS_ARG_OBJTTL:
                        darg1 = oc->ttl + oc->t_origin;
                        darg2 = bt.arg2_double + ban_time(bsarg);
                        break;
                case BANS_ARG_OBJAGE:
                        darg1 = 0.0 - oc->t_origin;
                        darg2 = 0.0 - (ban_time(bsarg) - bt.arg2_double);
                        break;
                case BANS_ARG_OBJGRACE:
                        darg1 = oc->grace;
                        darg2 = bt.arg2_double;
                        break;
                case BANS_ARG_OBJKEEP:
                        darg1 = oc->keep;
                        darg2 = bt.arg2_double;
                        break;
                case BANS_ARG_OBJLASTHIT:
                        if (isnan(oc->last_lru))
                                return (0);
                        darg1 = 0.0 - oc->last_lru;
                        darg2 = 0.0 - (ban_time(bsarg) - bt.arg2_double);
                        break;
                case BANS_ARG_OBJHFM:
                        barg1 = oc->flags & OC_F_HFM ? 1 : 0;
                        barg2 = bt.arg2_bool;
                        break;
                case BANS_ARG_OBJHFP:
                        barg1 = oc->flags & OC_F_HFP ? 1 : 0;
                        barg2 = bt.arg2_bool;
                        break;
                case BANS_ARG_OBJUNCACHEABLE:
                        barg1 = (oc->flags & (OC_F_HFM | OC_F_HFP)) ? 1 : 0;
                        barg2 = bt.arg2_bool;
                        break;
                default:
                        WRONG("Wrong BAN_ARG code");
                }

                switch (bt.oper) {
                case BANS_OPER_EQ:
                        if (barg1 != -1) {
                                if (barg1 != barg2)
                                        return (0);
                        } else if (arg1 == NULL) {
                                if (isnan(darg1) || darg1 != darg2)
                                        return (0);
                        } else if (vstrcmp(arg1, bt.arg2)) {
                                return (0);
                        }
                        break;
                case BANS_OPER_NEQ:
                        if (barg1 != -1) {
                                if (barg1 == barg2)
                                        return (0);
                        } else if (arg1 == NULL) {
                                if (! isnan(darg1) && darg1 == darg2)
                                        return (0);
                        } else if (!vstrcmp(arg1, bt.arg2)) {
                                return (0);
                        }
                        break;
                case BANS_OPER_MATCH:
                        if (arg1 == NULL)
                                return (0);
                        rv = VRE_match(bt.arg2_spec, arg1, 0, 0, NULL);
                        xxxassert(rv >= -1);
                        if (rv < 0)
                                return (0);
                        break;
                case BANS_OPER_NMATCH:
                        if (arg1 == NULL)
                                return (0);
                        rv = VRE_match(bt.arg2_spec, arg1, 0, 0, NULL);
                        xxxassert(rv >= -1);
                        if (rv >= 0)
                                return (0);
                        break;
                case BANS_OPER_GT:
                        AZ(arg1);
                        assert(! isnan(darg1));
                        if (!(darg1 > darg2))
                                return (0);
                        break;
                case BANS_OPER_GTE:
                        AZ(arg1);
                        assert(! isnan(darg1));
                        if (!(darg1 >= darg2))
                                return (0);
                        break;
                case BANS_OPER_LT:
                        AZ(arg1);
                        assert(! isnan(darg1));
                        if (!(darg1 < darg2))
                                return (0);
                        break;
                case BANS_OPER_LTE:
                        AZ(arg1);
                        assert(! isnan(darg1));
                        if (!(darg1 <= darg2))
                                return (0);
                        break;
                default:
                        WRONG("Wrong BAN_OPER code");
                }
        }
        return (1);
}

/*--------------------------------------------------------------------
 * Check an object against all applicable bans
 *
 * Return:
 *      -1 not all bans checked, but none of the checked matched
 *              Only if !has_req
 *      0 No bans matched, object moved to ban_start.
 *      1 Ban matched, object removed from ban list.
 */

int
BAN_CheckObject(struct worker *wrk, struct objcore *oc, struct req *req)
{
        struct ban *b;
        struct vsl_log *vsl;
        struct ban *b0, *bn;
        unsigned tests;

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
        Lck_AssertHeld(&oc->objhead->mtx);
        assert(oc->refcnt > 0);

        vsl = req->vsl;

        CHECK_OBJ_NOTNULL(oc->ban, BAN_MAGIC);

        /* First do an optimistic unlocked check */
        b0 = ban_start;
        CHECK_OBJ_NOTNULL(b0, BAN_MAGIC);

        if (b0 == oc->ban)
                return (0);

        /* If that fails, make a safe check */
        Lck_Lock(&ban_mtx);
        b0 = ban_start;
        bn = oc->ban;
        if (b0 != bn)
                bn->refcount++;
        Lck_Unlock(&ban_mtx);

        AN(bn);

        if (b0 == bn)
                return (0);

        AN(b0);
        AN(bn);

        /*
         * This loop is safe without locks, because we know we hold
         * a refcount on a ban somewhere in the list and we do not
         * inspect the list past that ban.
         */
        tests = 0;
        for (b = b0; b != bn; b = VTAILQ_NEXT(b, list)) {
                CHECK_OBJ_NOTNULL(b, BAN_MAGIC);
                if (b->flags & BANS_FLAG_COMPLETED)
                        continue;
                if (ban_evaluate(wrk, b->spec, oc, req->http, &tests))
                        break;
        }

        Lck_Lock(&ban_mtx);
        bn->refcount--;
        VSC_C_main->bans_tested++;
        VSC_C_main->bans_tests_tested += tests;

        if (b == bn) {
                /* not banned */
                oc->ban->refcount--;
                VTAILQ_REMOVE(&oc->ban->objcore, oc, ban_list);
                VTAILQ_INSERT_TAIL(&b0->objcore, oc, ban_list);
                b0->refcount++;
                oc->ban = b0;
                b = NULL;
        }
        if (b != NULL)
                VSC_C_main->bans_obj_killed++;

        if (VTAILQ_LAST(&ban_head, banhead_s)->refcount == 0)
                ban_kick_lurker();

        Lck_Unlock(&ban_mtx);

        if (b == NULL) {
                /* not banned */
                ObjSendEvent(wrk, oc, OEV_BANCHG);
                return (0);
        } else {
                VSLb(vsl, SLT_ExpBan,
                    "%ju banned lookup", VXID(ObjGetXID(wrk, oc)));
                return (1);
        }
}

/*--------------------------------------------------------------------
 * CLI functions to add bans
 */

static void v_matchproto_(cli_func_t)
ccf_ban(struct cli *cli, const char * const *av, void *priv)
{
        int narg, i;
        struct ban_proto *bp;
        const char *err = NULL;

        (void)priv;

        /* First do some cheap checks on the arguments */
        for (narg = 0; av[narg + 2] != NULL; narg++)
                continue;
        if ((narg % 4) != 3) {
                VCLI_Out(cli, "Wrong number of arguments");
                VCLI_SetResult(cli, CLIS_PARAM);
                return;
        }
        for (i = 3; i < narg; i += 4) {
                if (vstrcmp(av[i + 2], "&&")) {
                        VCLI_Out(cli, "Found \"%s\" expected &&", av[i + 2]);
                        VCLI_SetResult(cli, CLIS_PARAM);
                        return;
                }
        }

        bp = BAN_Build();
        if (bp == NULL) {
                VCLI_Out(cli, "Out of Memory");
                VCLI_SetResult(cli, CLIS_CANT);
                return;
        }
        for (i = 0; i < narg; i += 4) {
                err = BAN_AddTest(bp, av[i + 2], av[i + 3], av[i + 4]);
                if (err)
                        break;
        }

        if (err == NULL) {
                // XXX racy - grab wstat lock?
                err = BAN_Commit(bp);
        }

        if (err != NULL) {
                VCLI_Out(cli, "%s", err);
                BAN_Abandon(bp);
                VCLI_SetResult(cli, CLIS_PARAM);
        }
}

#define Ms 60
#define Hs (Ms * 60)
#define Ds (Hs * 24)
#define Ws (Ds * 7)
#define Ys (Ds * 365)

#define Xfmt(buf, var, s, unit)                                         \
        ((var) >= s && (var) % s == 0)                                  \
                bprintf((buf), "%ju" unit, (var) / s)

// XXX move to VTIM?
#define vdur_render(buf, dur) do {                                      \
        uintmax_t dec = (uintmax_t)floor(dur);                          \
        uintmax_t frac = (uintmax_t)floor((dur) * 1e3) % UINTMAX_C(1000); \
        if (dec == 0 && frac == 0)                                      \
                (void) strncpy(buf, "0s", sizeof(buf));                 \
        else if (dec == 0)                                              \
                bprintf((buf), "%jums", frac);                          \
        else if (frac != 0)                                             \
                bprintf((buf), "%ju.%03jus", dec, frac);                \
        else if Xfmt(buf, dec, Ys, "y");                                \
        else if Xfmt(buf, dec, Ws, "w");                                \
        else if Xfmt(buf, dec, Ds, "d");                                \
        else if Xfmt(buf, dec, Hs, "h");                                \
        else if Xfmt(buf, dec, Ms, "m");                                \
        else                                                            \
                bprintf((buf), "%jus", dec);                            \
        } while (0)

static void
ban_render(struct cli *cli, const uint8_t *bs, int quote)
{
        struct ban_test bt;
        const uint8_t *be;
        char buf[64];

        be = bs + ban_len(bs);
        bs += BANS_HEAD_LEN;
        while (bs < be) {
                ban_iter(&bs, &bt);
                ASSERT_BAN_ARG(bt.arg1);
                ASSERT_BAN_OPER(bt.oper);

                if (BANS_HAS_ARG1_SPEC(bt.arg1))
                        VCLI_Out(cli, "%s%.*s",
                            arg_name[BAN_ARGIDX(bt.arg1)],
                            bt.arg1_spec[0] - 1, bt.arg1_spec + 1);
                else
                        VCLI_Out(cli, "%s", arg_name[BAN_ARGIDX(bt.arg1)]);

                VCLI_Out(cli, " %s ", ban_oper[BAN_OPERIDX(bt.oper)]);

                if (BANS_HAS_ARG2_DOUBLE(bt.arg1)) {
                        vdur_render(buf, bt.arg2_double);
                        VCLI_Out(cli, "%s", buf);
                } else if (BANS_HAS_ARG2_BOOL(bt.arg1)) {
                        VCLI_Out(cli, "%s", bt.arg2_bool ? "true" : "false");
                } else if (quote) {
                        VCLI_Quote(cli, bt.arg2);
                } else {
                        VCLI_Out(cli, "%s", bt.arg2);
                }

                if (bs < be)
                        VCLI_Out(cli, " && ");
        }
}

static void
ban_list(struct cli *cli, struct ban *bl)
{
        struct ban *b;
        int64_t o;

        VCLI_Out(cli, "Present bans:\n");
        VTAILQ_FOREACH(b, &ban_head, list) {
                o = bl == b ? 1 : 0;
                VCLI_Out(cli, "%10.6f %5ju %s", ban_time(b->spec),
                    (intmax_t)(b->refcount - o),
                    b->flags & BANS_FLAG_COMPLETED ? "C" : "-");
                if (DO_DEBUG(DBG_LURKER)) {
                        VCLI_Out(cli, "%s%s %p ",
                            b->flags & BANS_FLAG_REQ ? "R" : "-",
                            b->flags & BANS_FLAG_OBJ ? "O" : "-",
                            b);
                }
                VCLI_Out(cli, "  ");
                ban_render(cli, b->spec, 0);
                VCLI_Out(cli, "\n");
                if (VCLI_Overflow(cli))
                        break;
                if (DO_DEBUG(DBG_LURKER)) {
                        Lck_Lock(&ban_mtx);
                        struct objcore *oc;
                        VTAILQ_FOREACH(oc, &b->objcore, ban_list)
                                VCLI_Out(cli, "  oc = %p\n", oc);
                        Lck_Unlock(&ban_mtx);
                }
        }
}

static void
ban_list_json(struct cli *cli, const char * const *av, struct ban *bl)
{
        struct ban *b;
        int64_t o;
        int n = 0;
        int ocs;

        VCLI_JSON_begin(cli, 2, av);
        VCLI_Out(cli, ",\n");
        VTAILQ_FOREACH(b, &ban_head, list) {
                o = bl == b ? 1 : 0;
                VCLI_Out(cli, "%s", n ? ",\n" : "");
                n++;
                VCLI_Out(cli, "{\n");
                VSB_indent(cli->sb, 2);
                VCLI_Out(cli, "\"time\": %.6f,\n", ban_time(b->spec));
                VCLI_Out(cli, "\"refs\": %ju,\n", (intmax_t)(b->refcount - o));
                VCLI_Out(cli, "\"completed\": %s,\n",
                         b->flags & BANS_FLAG_COMPLETED ? "true" : "false");
                VCLI_Out(cli, "\"spec\": \"");
                ban_render(cli, b->spec, 1);
                VCLI_Out(cli, "\"");

                if (DO_DEBUG(DBG_LURKER)) {
                        VCLI_Out(cli, ",\n");
                        VCLI_Out(cli, "\"req_tests\": %s,\n",
                                 b->flags & BANS_FLAG_REQ ? "true" : "false");
                        VCLI_Out(cli, "\"obj_tests\": %s,\n",
                                 b->flags & BANS_FLAG_OBJ ? "true" : "false");
                        VCLI_Out(cli, "\"pointer\": \"%p\",\n", b);
                        if (VCLI_Overflow(cli))
                                break;

                        ocs = 0;
                        VCLI_Out(cli, "\"objcores\": [\n");
                        VSB_indent(cli->sb, 2);
                        Lck_Lock(&ban_mtx);
                        struct objcore *oc;
                        VTAILQ_FOREACH(oc, &b->objcore, ban_list) {
                                if (ocs)
                                        VCLI_Out(cli, ",\n");
                                VCLI_Out(cli, "%p", oc);
                                ocs++;
                        }
                        Lck_Unlock(&ban_mtx);
                        VSB_indent(cli->sb, -2);
                        VCLI_Out(cli, "\n]");
                }
                VSB_indent(cli->sb, -2);
                VCLI_Out(cli, "\n}");
        }
        VCLI_JSON_end(cli);
}

static void v_matchproto_(cli_func_t)
ccf_ban_list(struct cli *cli, const char * const *av, void *priv)
{
        struct ban *bl;

        (void)priv;

        /* Get a reference so we are safe to traverse the list */
        Lck_Lock(&ban_mtx);
        bl = VTAILQ_LAST(&ban_head, banhead_s);
        bl->refcount++;
        Lck_Unlock(&ban_mtx);

        if (av[2] != NULL && vstrcmp(av[2], "-j") == 0)
                ban_list_json(cli, av, bl);
        else
                ban_list(cli, bl);

        Lck_Lock(&ban_mtx);
        bl->refcount--;
        ban_kick_lurker();      // XXX: Mostly for testcase b00009.vtc
        Lck_Unlock(&ban_mtx);
}

static struct cli_proto ban_cmds[] = {
        { CLICMD_BAN,                           "", ccf_ban },
        { CLICMD_BAN_LIST,                      "", ccf_ban_list,
          ccf_ban_list },
        { NULL }
};

/*--------------------------------------------------------------------
 */

void
BAN_Compile(void)
{
        struct ban *b;

        /*
         * All bans have been read from all persistent stevedores. Export
         * the compiled list
         */

        ASSERT_CLI();
        AZ(ban_shutdown);

        Lck_Lock(&ban_mtx);

        /* Report the place-holder ban */
        b = VTAILQ_FIRST(&ban_head);
        ban_info_new(b->spec, ban_len(b->spec));

        ban_export();

        Lck_Unlock(&ban_mtx);

        ban_start = VTAILQ_FIRST(&ban_head);
        BAN_Release();
}

void
BAN_Init(void)
{
        struct ban_proto *bp;

        BAN_Build_Init();
        Lck_New(&ban_mtx, lck_ban);
        CLI_AddFuncs(ban_cmds);

        ban_holds = 1;

        /* Add a placeholder ban */
        bp = BAN_Build();
        AN(bp);
        PTOK(pthread_cond_init(&ban_lurker_cond, NULL));
        AZ(BAN_Commit(bp));
        Lck_Lock(&ban_mtx);
        ban_mark_completed(VTAILQ_FIRST(&ban_head));
        Lck_Unlock(&ban_mtx);
}

/*--------------------------------------------------------------------
 * Shutdown of the ban system.
 *
 * When this function returns, no new bans will be accepted, and no
 * bans will be dropped (ban lurker thread stopped), so that no
 * STV_BanInfo calls will be executed.
 */

void
BAN_Shutdown(void)
{
        void *status;

        Lck_Lock(&ban_mtx);
        ban_shutdown = 1;
        ban_kick_lurker();
        Lck_Unlock(&ban_mtx);

        PTOK(pthread_join(ban_thread, &status));
        AZ(status);

        Lck_Lock(&ban_mtx);
        /* Export the ban list to compact it */
        ban_export();
        Lck_Unlock(&ban_mtx);

        BAN_Build_Fini();
}

		vinyl-cache/bin/vinyld/cache/cache_ban.c
0		/*-
1		* Copyright (c) 2006 Verdens Gang AS
2		* Copyright (c) 2006-2015 Varnish Software AS
3		* All rights reserved.
4		*
5		* Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
6		*
7		* SPDX-License-Identifier: BSD-2-Clause
8		*
9		* Redistribution and use in source and binary forms, with or without
10		* modification, are permitted provided that the following conditions
11		* are met:
12		* 1. Redistributions of source code must retain the above copyright
13		* notice, this list of conditions and the following disclaimer.
14		* 2. Redistributions in binary form must reproduce the above copyright
15		* notice, this list of conditions and the following disclaimer in the
16		* documentation and/or other materials provided with the distribution.
17		*
18		* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19		* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21		* ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
22		* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23		* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24		* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25		* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26		* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27		* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28		* SUCH DAMAGE.
29		*
30		*/
31
32		#include "config.h"
33
34		#include <stdlib.h>
35		#include <stdio.h>
36
37		#include "cache_int.h"
38		#include "cache_ban.h"
39		#include "cache_objhead.h"
40
41		#include "vcli_serve.h"
42		#include "vend.h"
43		#include "vmb.h"
44
45		/* cache_ban_build.c */
46		void BAN_Build_Init(void);
47		void BAN_Build_Fini(void);
48
49		struct lock ban_mtx;
50		int ban_shutdown;
51		struct banhead_s ban_head = VTAILQ_HEAD_INITIALIZER(ban_head);
52		struct ban * volatile ban_start;
53
54		static pthread_t ban_thread;
55		static int ban_holds;
56		uint64_t bans_persisted_bytes;
57		uint64_t bans_persisted_fragmentation;
58
59		struct ban_test {
60		uint8_t oper;
61		uint8_t arg1;
62		uint8_t arg2_bool;
63		const char *arg1_spec;
64		const char *arg2;
65		double arg2_double;
66		const void *arg2_spec;
67		};
68
69		static const char * const arg_name[BAN_ARGARRSZ + 1] = {
70		#define PVAR(a, b, c) [BAN_ARGIDX(c)] = (a),
71		#include "tbl/ban_vars.h"
72		[BAN_ARGARRSZ] = NULL
73		};
74
75		/*--------------------------------------------------------------------
76		* Storage handling of bans
77		*/
78
79		static struct ban *
80	104	ban_alloc(void)
81		{
82		struct ban *b;
83
84	104	ALLOC_OBJ(b, BAN_MAGIC);
85	104	if (b != NULL)
86	104	VTAILQ_INIT(&b->objcore);
87	104	return (b);
88		}
89
90		void
91	372	BAN_Free(struct ban *b)
92		{
93
94	372	CHECK_OBJ_NOTNULL(b, BAN_MAGIC);
95	372	AZ(b->refcount);
96	372	assert(VTAILQ_EMPTY(&b->objcore));
97
98	372	if (b->spec != NULL)
99	372	free(b->spec);
100	372	FREE_OBJ(b);
101	372	}
102
103		/*--------------------------------------------------------------------
104		* Get/release holds which prevent the ban_lurker from starting.
105		* Holds are held while stevedores load zombie objects.
106		*/
107
108		void
109	152	BAN_Hold(void)
110		{
111
112	152	Lck_Lock(&ban_mtx);
113		/* Once holds are released, we allow no more */
114	152	assert(ban_holds > 0);
115	152	ban_holds++;
116	152	Lck_Unlock(&ban_mtx);
117	152	}
118
119		void
120	4036	BAN_Release(void)
121		{
122
123	4036	Lck_Lock(&ban_mtx);
124	4036	assert(ban_holds > 0);
125	4036	ban_holds--;
126	4036	Lck_Unlock(&ban_mtx);
127	4036	if (ban_holds == 0) {
128	3884	BANIDX_fini();
129	3884	WRK_BgThread(&ban_thread, "ban-lurker", ban_lurker, NULL);
130	3884	}
131	4036	}
132
133		/*--------------------------------------------------------------------
134		* Extract time and length from ban-spec
135		*/
136
137		vtim_real
138	3900	ban_time(const uint8_t *banspec)
139		{
140		vtim_real t;
141		uint64_t u;
142
143	3900	assert(sizeof t == sizeof u);
144	3900	assert(sizeof t == (BANS_LENGTH - BANS_TIMESTAMP));
145	3900	u = vbe64dec(banspec + BANS_TIMESTAMP);
146	3900	memcpy(&t, &u, sizeof t);
147	3900	return (t);
148		}
149
150		unsigned
151	25320	ban_len(const uint8_t *banspec)
152		{
153		unsigned u;
154
155	25320	u = vbe32dec(banspec + BANS_LENGTH);
156	25320	return (u);
157		}
158
159		int
160	1096	ban_equal(const uint8_t bs1, const uint8_t bs2)
161		{
162		unsigned u;
163
164		/*
165		* Compare two ban-strings.
166		*/
167	1096	u = ban_len(bs1);
168	1096	if (u != ban_len(bs2))
169	412	return (0);
170	684	if (bs1[BANS_FLAGS] & BANS_FLAG_NODEDUP)
171	12	return (0);
172
173	672	return (!memcmp(bs1 + BANS_LENGTH, bs2 + BANS_LENGTH, u - BANS_LENGTH));
174	1096	}
175
176		void
177	4184	ban_mark_completed(struct ban *b)
178		{
179		unsigned ln;
180
181	4184	CHECK_OBJ_NOTNULL(b, BAN_MAGIC);
182	4184	Lck_AssertHeld(&ban_mtx);
183
184	4184	AN(b->spec);
185	4184	if (!(b->flags & BANS_FLAG_COMPLETED)) {
186	4184	ln = ban_len(b->spec);
187	4184	b->flags \|= BANS_FLAG_COMPLETED;
188	4184	b->spec[BANS_FLAGS] \|= BANS_FLAG_COMPLETED;
189	4184	VWMB();
190	4184	vbe32enc(b->spec + BANS_LENGTH, BANS_HEAD_LEN);
191	4184	VSC_C_main->bans_completed++;
192	4184	bans_persisted_fragmentation += ln - ban_len(b->spec);
193	4184	VSC_C_main->bans_persisted_fragmentation =
194	4184	bans_persisted_fragmentation;
195	4184	}
196	4184	}
197
198		/*--------------------------------------------------------------------
199		* Access a lump of bytes in a ban test spec
200		*/
201
202		static const void *
203	1792	ban_get_lump(const uint8_t **bs)
204		{
205		const void *r;
206		unsigned ln;
207
208	11200	while (**bs == 0xff)
209	9408	*bs += 1;
210	1792	ln = vbe32dec(*bs);
211	1792	*bs += PRNDUP(sizeof(uint32_t));
212	1792	assert(PAOK(*bs));
213	1792	r = (const void)bs;
214	1792	*bs += ln;
215	1792	return (r);
216		}
217
218		/*--------------------------------------------------------------------
219		* Pick a test apart from a spec string
220		*/
221
222		static void
223	1592	ban_iter(const uint8_t *bs, struct ban_test bt)
224		{
225		const void *lump;
226		uint64_t dtmp;
227
228	1592	memset(bt, 0, sizeof *bt);
229	1592	bt->arg2_double = nan("");
230	1592	bt->arg1 = (bs)++;
231	1592	if (BANS_HAS_ARG1_SPEC(bt->arg1)) {
232	408	bt->arg1_spec = (const char )bs;
233	408	(bs) += (bs)[0] + 2;
234	408	}
235	1592	lump = ban_get_lump(bs);
236	1592	bt->oper = (bs)++;
237	1592	if (BANS_HAS_ARG2_DOUBLE(bt->arg1)) {
238	628	dtmp = vbe64dec(lump);
239	628	memcpy(&bt->arg2_double, &dtmp, sizeof dtmp);
240	628	return;
241	964	} else if (BANS_HAS_ARG2_BOOL(bt->arg1)) {
242	140	bt->arg2_bool = (uint8_t const )lump;
243	140	return;
244		}
245	824	bt->arg2 = lump;
246	824	if (BANS_HAS_ARG2_SPEC(bt->oper))
247	200	bt->arg2_spec = ban_get_lump(bs);
248	1592	}
249
250		/*--------------------------------------------------------------------
251		* A new object is created, grab a reference to the newest ban
252		*/
253
254		void
255	5980	BAN_NewObjCore(struct objcore *oc)
256		{
257
258	5980	CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
259	5980	AZ(oc->ban);
260	5980	AN(oc->objhead);
261	5980	Lck_Lock(&ban_mtx);
262	5980	oc->ban = ban_start;
263	5980	ban_start->refcount++;
264	5980	VTAILQ_INSERT_TAIL(&ban_start->objcore, oc, ban_list);
265	5980	Lck_Unlock(&ban_mtx);
266	5980	}
267
268		/*--------------------------------------------------------------------
269		* An object is destroyed, release its ban reference
270		*/
271
272		void
273	7881	BAN_DestroyObj(struct objcore *oc)
274		{
275
276	7881	CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
277	7881	if (oc->ban == NULL)
278	6220	return;
279	1661	Lck_Lock(&ban_mtx);
280	1661	CHECK_OBJ_ORNULL(oc->ban, BAN_MAGIC);
281	1661	if (oc->ban != NULL) {
282	1661	assert(oc->ban->refcount > 0);
283	1661	oc->ban->refcount--;
284	1661	VTAILQ_REMOVE(&oc->ban->objcore, oc, ban_list);
285	1661	oc->ban = NULL;
286	1661	}
287	1661	Lck_Unlock(&ban_mtx);
288	7881	}
289
290		/*--------------------------------------------------------------------
291		* Find a ban based on a timestamp.
292		* Assume we have a BAN_Hold, so list traversal is safe.
293		*/
294
295		struct ban *
296	68	BAN_FindBan(vtim_real t0)
297		{
298		struct ban *b;
299		vtim_real t1;
300
301	68	assert(ban_holds > 0);
302	68	b = BANIDX_lookup(t0);
303	68	VTAILQ_FOREACH_FROM(b, &ban_head, list) {
304	68	t1 = ban_time(b->spec);
305	68	if (t1 == t0)
306	68	return (b);
307	0	if (t1 < t0)
308	0	break;
309	0	}
310	0	return (NULL);
311	68	}
312
313		/*--------------------------------------------------------------------
314		* Grab a reference to a ban and associate the objcore with that ban.
315		* Assume we have a BAN_Hold, so list traversal is safe.
316		*/
317
318		void
319	68	BAN_RefBan(struct objcore oc, struct ban b)
320		{
321
322	68	Lck_Lock(&ban_mtx);
323	68	CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
324	68	AZ(oc->ban);
325	68	CHECK_OBJ_NOTNULL(b, BAN_MAGIC);
326	68	assert(ban_holds > 0);
327	68	b->refcount++;
328	68	VTAILQ_INSERT_TAIL(&b->objcore, oc, ban_list);
329	68	oc->ban = b;
330	68	Lck_Unlock(&ban_mtx);
331	68	}
332
333		/*--------------------------------------------------------------------
334		* Compile a full ban list and export this area to the stevedores for
335		* persistence.
336		*/
337
338		static void
339	7732	ban_export(void)
340		{
341		struct ban *b;
342		struct vsb *vsb;
343		unsigned ln;
344
345	7732	Lck_AssertHeld(&ban_mtx);
346	7732	ln = bans_persisted_bytes - bans_persisted_fragmentation;
347	7732	vsb = VSB_new_auto();
348	7732	AN(vsb);
349	15796	VTAILQ_FOREACH_REVERSE(b, &ban_head, banhead_s, list)
350	8064	AZ(VSB_bcat(vsb, b->spec, ban_len(b->spec)));
351	7732	AZ(VSB_finish(vsb));
352	7732	assert(VSB_len(vsb) == ln);
353	7732	Lck_Unlock(&ban_mtx);
354	7732	STV_BanExport((const uint8_t *)VSB_data(vsb), VSB_len(vsb));
355	7732	VSB_destroy(&vsb);
356	7732	Lck_Lock(&ban_mtx);
357	7732	VSC_C_main->bans_persisted_bytes =
358	7732	bans_persisted_bytes = ln;
359	7732	VSC_C_main->bans_persisted_fragmentation =
360	7732	bans_persisted_fragmentation = 0;
361	7732	}
362
363		/*
364		* For both of these we do a full export on info failure to remove
365		* holes in the exported list.
366		* XXX: we should keep track of the size of holes in the last exported list
367		* XXX: check if the ban_export should be batched in ban_cleantail
368		*/
369		void
370	3884	ban_info_new(const uint8_t *ban, unsigned len)
371		{
372	3884	Lck_AssertHeld(&ban_mtx);
373	3884	if (STV_BanInfoNew(ban, len))
374	0	ban_export();
375	3884	}
376
377		void
378	372	ban_info_drop(const uint8_t *ban, unsigned len)
379		{
380	372	Lck_AssertHeld(&ban_mtx);
381	372	if (STV_BanInfoDrop(ban, len))
382	0	ban_export();
383	372	}
384
385		/*--------------------------------------------------------------------
386		* Put a skeleton ban in the list, unless there is an identical,
387		* time & condition, ban already in place.
388		*
389		* If a newer ban has same condition, mark the inserted ban COMPLETED,
390		* also mark any older bans, with the same condition COMPLETED.
391		*/
392
393		static void
394	136	ban_reload(const uint8_t *ban, unsigned len)
395		{
396		struct ban b, b2;
397	136	int duplicate = 0;
398	136	vtim_real t0, t1, t2 = 9e99;
399	136	ASSERT_CLI();
400	136	Lck_AssertHeld(&ban_mtx);
401	136	assert(ban_holds > 0);
402
403	136	t0 = ban_time(ban);
404	136	assert(len == ban_len(ban));
405
406	136	b = BANIDX_lookup(t0);
407	240	VTAILQ_FOREACH_FROM(b, &ban_head, list) {
408	176	t1 = ban_time(b->spec);
409	176	assert(t1 < t2);
410	176	t2 = t1;
411	176	if (t1 == t0)
412	32	return;
413	144	if (t1 < t0)
414	40	break;
415	104	if (ban_equal(b->spec, ban))
416	72	duplicate = 1;
417	104	}
418
419	104	VSC_C_main->bans++;
420	104	VSC_C_main->bans_added++;
421
422	104	b2 = ban_alloc();
423	104	AN(b2);
424	104	b2->spec = malloc(len);
425	104	AN(b2->spec);
426	104	memcpy(b2->spec, ban, len);
427	104	if (ban[BANS_FLAGS] & BANS_FLAG_REQ) {
428	20	VSC_C_main->bans_req++;
429	20	b2->flags \|= BANS_FLAG_REQ;
430	20	}
431	104	if (duplicate)
432	72	VSC_C_main->bans_dups++;
433	104	if (duplicate \|\| (ban[BANS_FLAGS] & BANS_FLAG_COMPLETED))
434	76	ban_mark_completed(b2);
435	104	if (b == NULL)
436	64	VTAILQ_INSERT_TAIL(&ban_head, b2, list);
437		else
438	40	VTAILQ_INSERT_BEFORE(b, b2, list);
439	104	bans_persisted_bytes += len;
440	104	VSC_C_main->bans_persisted_bytes = bans_persisted_bytes;
441
442		/* Hunt down older duplicates */
443	164	for (b = VTAILQ_NEXT(b2, list); b != NULL; b = VTAILQ_NEXT(b, list)) {
444	60	if (b->flags & BANS_FLAG_COMPLETED)
445	56	continue;
446	4	if (ban_equal(b->spec, ban)) {
447	0	ban_mark_completed(b);
448	0	VSC_C_main->bans_dups++;
449	0	}
450	4	}
451	136	}
452
453		/*--------------------------------------------------------------------
454		* Reload a series of persisted ban specs
455		*/
456
457		void
458	152	BAN_Reload(const uint8_t *ptr, unsigned len)
459		{
460		const uint8_t *pe;
461		unsigned l;
462
463	152	AZ(ban_shutdown);
464	152	pe = ptr + len;
465	152	Lck_Lock(&ban_mtx);
466	288	while (ptr < pe) {
467		/* XXX: This can be optimized by traversing the live
468		* ban list together with the reload list (combining
469		* the loops in BAN_Reload and ban_reload). */
470	136	l = ban_len(ptr);
471	136	assert(ptr + l <= pe);
472	136	ban_reload(ptr, l);
473	136	ptr += l;
474		}
475	152	Lck_Unlock(&ban_mtx);
476	152	}
477
478		/*--------------------------------------------------------------------
479		* Get a bans timestamp
480		*/
481
482		vtim_real
483	272	BAN_Time(const struct ban *b)
484		{
485
486	272	if (b == NULL)
487	84	return (0.0);
488
489	188	CHECK_OBJ(b, BAN_MAGIC);
490	188	return (ban_time(b->spec));
491	272	}
492
493		/*--------------------------------------------------------------------
494		* Evaluate ban-spec
495		*/
496
497		int
498	500	ban_evaluate(struct worker wrk, const uint8_t bsarg, struct objcore *oc,
499		const struct http reqhttp, unsigned tests)