GCOV - Varnish Cache


/*-
 * Copyright (c) 2008-2011 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.
 *
 * Persistent storage method
 *
 * XXX: Before we start the client or maybe after it stops, we should give the
 * XXX: stevedores a chance to examine their storage for consistency.
 *
 * XXX: Do we ever free the LRU-lists ?
 */

#include "config.h"

#include "cache/cache_varnishd.h"

#include <sys/mman.h>

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

#include "cache/cache_obj.h"
#include "cache/cache_objhead.h"
#include "storage/storage.h"
#include "storage/storage_simple.h"

#include "vcli_serve.h"
#include "vsha256.h"
#include "vtim.h"

#include "storage/storage_persistent.h"

static struct obj_methods smp_oc_realmethods;

static struct VSC_lck *lck_smp;

static void smp_init(void);

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

/*
 * silos is unlocked, it only changes during startup when we are
 * single-threaded
 */
static VTAILQ_HEAD(,smp_sc)     silos = VTAILQ_HEAD_INITIALIZER(silos);

/*--------------------------------------------------------------------
 * Add bans to silos
 */

static int
smp_appendban(const struct smp_sc *sc, struct smp_signspace *spc,
    uint32_t len, const uint8_t *ban)
{

        (void)sc;
        if (SIGNSPACE_FREE(spc) < len)
                return (-1);

        memcpy(SIGNSPACE_FRONT(spc), ban, len);
        smp_append_signspace(spc, len);

        return (0);
}

/* Trust that cache_ban.c takes care of locking */

static int
smp_baninfo(const struct stevedore *stv, enum baninfo event,
            const uint8_t *ban, unsigned len)
{
        struct smp_sc *sc;
        int r = 0;

        CAST_OBJ_NOTNULL(sc, stv->priv, SMP_SC_MAGIC);

        switch (event) {
        case BI_NEW:
                r |= smp_appendban(sc, &sc->ban1, len, ban);
                r |= smp_appendban(sc, &sc->ban2, len, ban);
                break;
        default:
                /* Ignored */
                break;
        }

        return (r);
}

static void
smp_banexport_spc(struct smp_signspace *spc, const uint8_t *bans, unsigned len)
{
        smp_reset_signspace(spc);
        assert(SIGNSPACE_FREE(spc) >= len);
        memcpy(SIGNSPACE_DATA(spc), bans, len);
        smp_append_signspace(spc, len);
        smp_sync_sign(&spc->ctx);
}

static void
smp_banexport(const struct stevedore *stv, const uint8_t *bans, unsigned len)
{
        struct smp_sc *sc;

        CAST_OBJ_NOTNULL(sc, stv->priv, SMP_SC_MAGIC);
        smp_banexport_spc(&sc->ban1, bans, len);
        smp_banexport_spc(&sc->ban2, bans, len);
}

/*--------------------------------------------------------------------
 * Attempt to open and read in a ban list
 */

static int
smp_open_bans(const struct smp_sc *sc, struct smp_signspace *spc)
{
        uint8_t *ptr, *pe;
        int i;

        ASSERT_CLI();
        (void)sc;
        i = smp_chk_signspace(spc);
        if (i)
                return (i);

        ptr = SIGNSPACE_DATA(spc);
        pe = SIGNSPACE_FRONT(spc);
        BAN_Reload(ptr, pe - ptr);

        return (0);
}

/*--------------------------------------------------------------------
 * Attempt to open and read in a segment list
 */

static int
smp_open_segs(struct smp_sc *sc, struct smp_signspace *spc)
{
        uint64_t length, l;
        struct smp_segptr *ss, *se;
        struct smp_seg *sg, *sg1, *sg2;
        int i, n = 0;

        ASSERT_CLI();
        i = smp_chk_signspace(spc);
        if (i)
                return (i);

        ss = SIGNSPACE_DATA(spc);
        length = SIGNSPACE_LEN(spc);

        if (length == 0) {
                /* No segments */
                sc->free_offset = sc->ident->stuff[SMP_SPC_STUFF];
                return (0);
        }
        se = ss + length / sizeof *ss;
        se--;
        assert(ss <= se);

        /*
         * Locate the free reserve, there are only two basic cases,
         * but once we start dropping segments, things gets more complicated.
         */

        sc->free_offset = se->offset + se->length;
        l = sc->mediasize - sc->free_offset;
        if (se->offset > ss->offset && l >= sc->free_reserve) {
                /*
                 * [__xxxxyyyyzzzz___]
                 * Plenty of space at tail, do nothing.
                 */
        } else if (ss->offset > se->offset) {
                /*
                 * [zzzz____xxxxyyyy_]
                 * (make) space between ends
                 * We might nuke the entire tail end without getting
                 * enough space, in which case we fall through to the
                 * last check.
                 */
                while (ss < se && ss->offset > se->offset) {
                        l = ss->offset - (se->offset + se->length);
                        if (l > sc->free_reserve)
                                break;
                        ss++;
                        n++;
                }
        }

        if (l < sc->free_reserve) {
                /*
                 * [__xxxxyyyyzzzz___]
                 * (make) space at front
                 */
                sc->free_offset = sc->ident->stuff[SMP_SPC_STUFF];
                while (ss < se) {
                        l = ss->offset - sc->free_offset;
                        if (l > sc->free_reserve)
                                break;
                        ss++;
                        n++;
                }
        }

        assert(l >= sc->free_reserve);


        sg1 = NULL;
        sg2 = NULL;
        for (; ss <= se; ss++) {
                ALLOC_OBJ(sg, SMP_SEG_MAGIC);
                AN(sg);
                VTAILQ_INIT(&sg->objcores);
                sg->p = *ss;

                sg->flags |= SMP_SEG_MUSTLOAD;

                /*
                 * HACK: prevent save_segs from nuking segment until we have
                 * HACK: loaded it.
                 */
                sg->nobj = 1;
                if (sg1 != NULL) {
                        assert(sg1->p.offset != sg->p.offset);
                        if (sg1->p.offset < sg->p.offset)
                                assert(smp_segend(sg1) <= sg->p.offset);
                        else
                                assert(smp_segend(sg) <= sg1->p.offset);
                }
                if (sg2 != NULL) {
                        assert(sg2->p.offset != sg->p.offset);
                        if (sg2->p.offset < sg->p.offset)
                                assert(smp_segend(sg2) <= sg->p.offset);
                        else
                                assert(smp_segend(sg) <= sg2->p.offset);
                }

                /* XXX: check that they are inside silo */
                /* XXX: check that they don't overlap */
                /* XXX: check that they are serial */
                sg->sc = sc;
                VTAILQ_INSERT_TAIL(&sc->segments, sg, list);
                sg2 = sg;
                if (sg1 == NULL)
                        sg1 = sg;
        }
        printf("Dropped %d segments to make free_reserve\n", n);
        return (0);
}

/*--------------------------------------------------------------------
 * Silo worker thread
 */

static void * v_matchproto_(bgthread_t)
smp_thread(struct worker *wrk, void *priv)
{
        struct smp_sc   *sc;
        struct smp_seg *sg;

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        CAST_OBJ_NOTNULL(sc, priv, SMP_SC_MAGIC);
        sc->thread = pthread_self();

        /* First, load all the objects from all segments */
        VTAILQ_FOREACH(sg, &sc->segments, list)
                if (sg->flags & SMP_SEG_MUSTLOAD)
                        smp_load_seg(wrk, sc, sg);

        sc->flags |= SMP_SC_LOADED;
        BAN_Release();
        printf("Silo completely loaded\n");

        /* Housekeeping loop */
        Lck_Lock(&sc->mtx);
        while (!(sc->flags & SMP_SC_STOP)) {
                sg = VTAILQ_FIRST(&sc->segments);
                if (sg != NULL && sg != sc->cur_seg && sg->nobj == 0)
                        smp_save_segs(sc);

                Lck_Unlock(&sc->mtx);
                VTIM_sleep(3.14159265359 - 2);
                Lck_Lock(&sc->mtx);
        }

        smp_save_segs(sc);

        Lck_Unlock(&sc->mtx);
        pthread_exit(0);

        NEEDLESS(return (NULL));
}

/*--------------------------------------------------------------------
 * Open a silo in the worker process
 */

static void v_matchproto_(storage_open_f)
smp_open(struct stevedore *st)
{
        struct smp_sc   *sc;

        ASSERT_CLI();

        if (VTAILQ_EMPTY(&silos))
                smp_init();

        CAST_OBJ_NOTNULL(sc, st->priv, SMP_SC_MAGIC);

        Lck_New(&sc->mtx, lck_smp);
        Lck_Lock(&sc->mtx);

        sc->stevedore = st;

        /* We trust the parent to give us a valid silo, for good measure: */
        AZ(smp_valid_silo(sc));

        AZ(mprotect((void*)sc->base, 4096, PROT_READ));

        sc->ident = SIGN_DATA(&sc->idn);

        /* Check ban lists */
        if (smp_chk_signspace(&sc->ban1)) {
                /* Ban list 1 is broken, use ban2 */
                AZ(smp_chk_signspace(&sc->ban2));
                smp_copy_signspace(&sc->ban1, &sc->ban2);
                smp_sync_sign(&sc->ban1.ctx);
        } else {
                /* Ban1 is OK, copy to ban2 for consistency */
                smp_copy_signspace(&sc->ban2, &sc->ban1);
                smp_sync_sign(&sc->ban2.ctx);
        }
        AZ(smp_open_bans(sc, &sc->ban1));

        /* We attempt seg1 first, and if that fails, try seg2 */
        if (smp_open_segs(sc, &sc->seg1))
                AZ(smp_open_segs(sc, &sc->seg2));

        /*
         * Grab a reference to the tail of the ban list, until the thread
         * has loaded all objects, so we can be sure that all of our
         * proto-bans survive until then.
         */
        BAN_Hold();

        /* XXX: save segments to ensure consistency between seg1 & seg2 ? */

        /* XXX: abandon early segments to make sure we have free space ? */

        (void)ObjSubscribeEvents(smp_oc_event, st,
            OEV_BANCHG|OEV_TTLCHG|OEV_INSERT);

        /* Open a new segment, so we are ready to write */
        smp_new_seg(sc);

        /* Start the worker silo worker thread, it will load the objects */
        WRK_BgThread(&sc->bgthread, "persistence", smp_thread, sc);

        VTAILQ_INSERT_TAIL(&silos, sc, list);
        Lck_Unlock(&sc->mtx);
}

/*--------------------------------------------------------------------
 * Close a silo
 */

static void v_matchproto_(storage_close_f)
smp_close(const struct stevedore *st, int warn)
{
        struct smp_sc   *sc;
        void *status;

        ASSERT_CLI();

        CAST_OBJ_NOTNULL(sc, st->priv, SMP_SC_MAGIC);
        if (warn) {
                Lck_Lock(&sc->mtx);
                if (sc->cur_seg != NULL)
                        smp_close_seg(sc, sc->cur_seg);
                AZ(sc->cur_seg);
                sc->flags |= SMP_SC_STOP;
                Lck_Unlock(&sc->mtx);
        } else {
                PTOK(pthread_join(sc->bgthread, &status));
                AZ(status);
        }
}

/*--------------------------------------------------------------------
 * Allocate a bite.
 *
 * Allocate [min_size...max_size] space from the bottom of the segment,
 * as is convenient.
 *
 * If 'so' + 'idx' is given, also allocate a smp_object from the top
 * of the segment.
 *
 * Return the segment in 'ssg' if given.
 */

static struct storage *
smp_allocx(const struct stevedore *st, size_t min_size, size_t max_size,
    struct smp_object **so, unsigned *idx, struct smp_seg **ssg)
{
        struct smp_sc *sc;
        struct storage *ss;
        struct smp_seg *sg;
        uint64_t left, extra;

        CAST_OBJ_NOTNULL(sc, st->priv, SMP_SC_MAGIC);
        assert(min_size <= max_size);

        max_size = IRNUP(sc, max_size);
        min_size = IRNUP(sc, min_size);

        extra = IRNUP(sc, sizeof(*ss));
        if (so != NULL) {
                extra += sizeof(**so);
                AN(idx);
        }

        Lck_Lock(&sc->mtx);
        sg = NULL;
        ss = NULL;

        left = 0;
        if (sc->cur_seg != NULL)
                left = smp_spaceleft(sc, sc->cur_seg);
        if (left < extra + min_size) {
                if (sc->cur_seg != NULL)
                        smp_close_seg(sc, sc->cur_seg);
                smp_new_seg(sc);
                if (sc->cur_seg != NULL)
                        left = smp_spaceleft(sc, sc->cur_seg);
                else
                        left = 0;
        }

        if (left >= extra + min_size)  {
                AN(sc->cur_seg);
                if (left < extra + max_size)
                        max_size = IRNDN(sc, left - extra);

                sg = sc->cur_seg;
                ss = (void*)(sc->base + sc->next_bot);
                sc->next_bot += max_size + IRNUP(sc, sizeof(*ss));
                sg->nalloc++;
                if (so != NULL) {
                        sc->next_top -= sizeof(**so);
                        *so = (void*)(sc->base + sc->next_top);
                        /* Render this smp_object mostly harmless */
                        EXP_ZERO((*so));
                        (*so)->ban = 0.;
                        (*so)->ptr = 0;
                        sg->objs = *so;
                        *idx = ++sg->p.lobjlist;
                }
                (void)smp_spaceleft(sc, sg);    /* for the assert */
        }
        Lck_Unlock(&sc->mtx);

        if (ss == NULL)
                return (ss);
        AN(sg);
        assert(max_size >= min_size);

        /* Fill the storage structure */
        INIT_OBJ(ss, STORAGE_MAGIC);
        ss->ptr = PRNUP(sc, ss + 1);
        ss->space = max_size;
        ss->priv = sc->base;
        if (ssg != NULL)
                *ssg = sg;
        return (ss);
}

/*--------------------------------------------------------------------
 * Allocate an object
 */

static int v_matchproto_(storage_allocobj_f)
smp_allocobj(struct worker *wrk, const struct stevedore *stv,
    struct objcore *oc, unsigned wsl)
{
        struct object *o;
        struct storage *st;
        struct smp_sc   *sc;
        struct smp_seg *sg;
        struct smp_object *so;
        unsigned objidx;
        unsigned ltot;

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
        CAST_OBJ_NOTNULL(sc, stv->priv, SMP_SC_MAGIC);

        /* Don't entertain already dead objects */
        if (oc->flags & OC_F_DYING)
                return (0);
        if (oc->t_origin <= 0.)
                return (0);
        if (oc->ttl + oc->grace + oc->keep <= 0.)
                return (0);

        ltot = sizeof(struct object) + PRNDUP(wsl);
        ltot = IRNUP(sc, ltot);

        st = NULL;
        sg = NULL;
        so = NULL;
        objidx = 0;

        do {
                st = smp_allocx(stv, ltot, ltot, &so, &objidx, &sg);
                if (st != NULL && st->space < ltot) {
                        stv->sml_free(st);              // NOP
                        st = NULL;
                }
        } while (st == NULL && LRU_NukeOne(wrk, stv->lru));
        if (st == NULL)
                return (0);

        AN(st);
        AN(sg);
        AN(so);
        assert(st->space >= ltot);

        o = SML_MkObject(stv, oc, st->ptr);
        AN(oc->stobj->stevedore);
        assert(oc->stobj->stevedore == stv);
        CHECK_OBJ_NOTNULL(o, OBJECT_MAGIC);
        o->objstore = st;
        st->len = sizeof(*o);

        Lck_Lock(&sc->mtx);
        sg->nfixed++;
        sg->nobj++;

        /* We have to do this somewhere, might as well be here... */
        assert(sizeof so->hash == DIGEST_LEN);
        memcpy(so->hash, oc->objhead->digest, DIGEST_LEN);
        EXP_COPY(so, oc);
        so->ptr = (uint8_t*)(o->objstore) - sc->base;
        so->ban = BAN_Time(oc->ban);

        smp_init_oc(oc, sg, objidx);

        VTAILQ_INSERT_TAIL(&sg->objcores, oc, lru_list);
        Lck_Unlock(&sc->mtx);
        return (1);
}

/*--------------------------------------------------------------------
 * Allocate a bite
 */

static struct storage * v_matchproto_(sml_alloc_f)
smp_alloc(const struct stevedore *st, size_t size)
{

        return (smp_allocx(st,
            size > 4096 ? 4096 : size, size, NULL, NULL, NULL));
}

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

const struct stevedore smp_stevedore = {
        .magic          = STEVEDORE_MAGIC,
        .name           = "deprecated_persistent",
        .init           = smp_mgt_init,
        .open           = smp_open,
        .close          = smp_close,
        .allocobj       = smp_allocobj,
        .baninfo        = smp_baninfo,
        .banexport      = smp_banexport,
        .methods        = &smp_oc_realmethods,

        .sml_alloc      = smp_alloc,
        .sml_free       = NULL,
        .sml_getobj     = smp_sml_getobj,
};

/*--------------------------------------------------------------------
 * Persistence is a bear to test unadulterated, so we cheat by adding
 * a cli command we can use to make it do tricks for us.
 */

static void
debug_report_silo(struct cli *cli, const struct smp_sc *sc)
{
        struct smp_seg *sg;

        VCLI_Out(cli, "Silo: %s (%s)\n",
            sc->stevedore->ident, sc->filename);
        VTAILQ_FOREACH(sg, &sc->segments, list) {
                VCLI_Out(cli, "  Seg: [0x%jx ... +0x%jx]\n",
                   (uintmax_t)sg->p.offset, (uintmax_t)sg->p.length);
                if (sg == sc->cur_seg)
                        VCLI_Out(cli,
                           "    Alloc: [0x%jx ... 0x%jx] = 0x%jx free\n",
                           (uintmax_t)(sc->next_bot),
                           (uintmax_t)(sc->next_top),
                           (uintmax_t)(sc->next_top - sc->next_bot));
                VCLI_Out(cli, "    %u nobj, %u alloc, %u lobjlist, %u fixed\n",
                    sg->nobj, sg->nalloc, sg->p.lobjlist, sg->nfixed);
        }
}

static void v_matchproto_(cli_func_t)
debug_persistent(struct cli *cli, const char * const * av, void *priv)
{
        struct smp_sc *sc;

        (void)priv;

        if (av[2] == NULL) {
                VTAILQ_FOREACH(sc, &silos, list)
                        debug_report_silo(cli, sc);
                return;
        }
        VTAILQ_FOREACH(sc, &silos, list)
                if (!strcmp(av[2], sc->stevedore->ident))
                        break;
        if (sc == NULL) {
                VCLI_Out(cli, "Silo <%s> not found\n", av[2]);
                VCLI_SetResult(cli, CLIS_PARAM);
                return;
        }
        if (av[3] == NULL) {
                debug_report_silo(cli, sc);
                return;
        }
        Lck_Lock(&sc->mtx);
        if (!strcmp(av[3], "sync")) {
                if (sc->cur_seg != NULL)
                        smp_close_seg(sc, sc->cur_seg);
                smp_new_seg(sc);
        } else if (!strcmp(av[3], "dump")) {
                debug_report_silo(cli, sc);
        } else {
                VCLI_Out(cli, "Unknown operation\n");
                VCLI_SetResult(cli, CLIS_PARAM);
        }
        Lck_Unlock(&sc->mtx);
}

static struct cli_proto debug_cmds[] = {
        { CLICMD_DEBUG_PERSISTENT,              "d", debug_persistent },
        { NULL }
};

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

static void
smp_init(void)
{
        lck_smp = Lck_CreateClass(NULL, "smp");
        CLI_AddFuncs(debug_cmds);
        smp_oc_realmethods.objfree = SML_methods.objfree;
        smp_oc_realmethods.objiterator = SML_methods.objiterator;
        smp_oc_realmethods.objgetspace = SML_methods.objgetspace;
        smp_oc_realmethods.objextend = SML_methods.objextend;
        smp_oc_realmethods.objbocdone = SML_methods.objbocdone;
        smp_oc_realmethods.objgetattr = SML_methods.objgetattr;
        smp_oc_realmethods.objsetattr = SML_methods.objsetattr;
        smp_oc_realmethods.objtouch = LRU_Touch;
        smp_oc_realmethods.objfree = smp_oc_objfree;
}

/*--------------------------------------------------------------------
 * Pause until all silos have loaded.
 */

void
SMP_Ready(void)
{
        struct smp_sc *sc;

        ASSERT_CLI();
        do {
                VTAILQ_FOREACH(sc, &silos, list)
                        if (!(sc->flags & SMP_SC_LOADED))
                                break;
                if (sc != NULL)
                        (void)sleep(1);
        } while (sc != NULL);
}

		varnish-cache/bin/varnishd/storage/storage_persistent.c
0		/*-
1		* Copyright (c) 2008-2011 Varnish Software AS
2		* All rights reserved.
3		*
4		* Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
5		*
6		* SPDX-License-Identifier: BSD-2-Clause
7		*
8		* Redistribution and use in source and binary forms, with or without
9		* modification, are permitted provided that the following conditions
10		* are met:
11		* 1. Redistributions of source code must retain the above copyright
12		* notice, this list of conditions and the following disclaimer.
13		* 2. Redistributions in binary form must reproduce the above copyright
14		* notice, this list of conditions and the following disclaimer in the
15		* documentation and/or other materials provided with the distribution.
16		*
17		* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18		* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20		* ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
21		* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22		* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23		* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24		* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25		* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26		* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27		* SUCH DAMAGE.
28		*
29		* Persistent storage method
30		*
31		* XXX: Before we start the client or maybe after it stops, we should give the
32		* XXX: stevedores a chance to examine their storage for consistency.
33		*
34		* XXX: Do we ever free the LRU-lists ?
35		*/
36
37		#include "config.h"
38
39		#include "cache/cache_varnishd.h"
40
41		#include <sys/mman.h>
42
43		#include <stdio.h>
44		#include <stdlib.h>
45
46		#include "cache/cache_obj.h"
47		#include "cache/cache_objhead.h"
48		#include "storage/storage.h"
49		#include "storage/storage_simple.h"
50
51		#include "vcli_serve.h"
52		#include "vsha256.h"
53		#include "vtim.h"
54
55		#include "storage/storage_persistent.h"
56
57		static struct obj_methods smp_oc_realmethods;
58
59		static struct VSC_lck *lck_smp;
60
61		static void smp_init(void);
62
63		/--------------------------------------------------------------------/
64
65		/*
66		* silos is unlocked, it only changes during startup when we are
67		* single-threaded
68		*/
69		static VTAILQ_HEAD(,smp_sc) silos = VTAILQ_HEAD_INITIALIZER(silos);
70
71		/*--------------------------------------------------------------------
72		* Add bans to silos
73		*/
74
75		static int
76	3840	smp_appendban(const struct smp_sc sc, struct smp_signspace spc,
77		uint32_t len, const uint8_t *ban)
78		{
79
80	3840	(void)sc;
81	3840	if (SIGNSPACE_FREE(spc) < len)
82	0	return (-1);
83
84	3840	memcpy(SIGNSPACE_FRONT(spc), ban, len);
85	3840	smp_append_signspace(spc, len);
86
87	3840	return (0);
88	3840	}
89
90		/* Trust that cache_ban.c takes care of locking */
91
92		static int
93	2760	smp_baninfo(const struct stevedore *stv, enum baninfo event,
94		const uint8_t *ban, unsigned len)
95		{
96		struct smp_sc *sc;
97	2760	int r = 0;
98
99	2760	CAST_OBJ_NOTNULL(sc, stv->priv, SMP_SC_MAGIC);
100
101	2760	switch (event) {
102		case BI_NEW:
103	1920	r \|= smp_appendban(sc, &sc->ban1, len, ban);
104	1920	r \|= smp_appendban(sc, &sc->ban2, len, ban);
105	1920	break;
106		default:
107		/* Ignored */
108	840	break;
109		}
110
111	2760	return (r);
112		}
113
114		static void
115	6000	smp_banexport_spc(struct smp_signspace spc, const uint8_t bans, unsigned len)
116		{
117	6000	smp_reset_signspace(spc);
118	6000	assert(SIGNSPACE_FREE(spc) >= len);
119	6000	memcpy(SIGNSPACE_DATA(spc), bans, len);
120	6000	smp_append_signspace(spc, len);
121	6000	smp_sync_sign(&spc->ctx);
122	6000	}
123
124		static void
125	3000	smp_banexport(const struct stevedore stv, const uint8_t bans, unsigned len)
126		{
127		struct smp_sc *sc;
128
129	3000	CAST_OBJ_NOTNULL(sc, stv->priv, SMP_SC_MAGIC);
130	3000	smp_banexport_spc(&sc->ban1, bans, len);
131	3000	smp_banexport_spc(&sc->ban2, bans, len);
132	3000	}
133
134		/*--------------------------------------------------------------------
135		* Attempt to open and read in a ban list
136		*/
137
138		static int
139	1520	smp_open_bans(const struct smp_sc sc, struct smp_signspace spc)
140		{
141		uint8_t ptr, pe;
142		int i;
143
144	1520	ASSERT_CLI();
145	1520	(void)sc;
146	1520	i = smp_chk_signspace(spc);
147	1520	if (i)
148	0	return (i);
149
150	1520	ptr = SIGNSPACE_DATA(spc);
151	1520	pe = SIGNSPACE_FRONT(spc);
152	1520	BAN_Reload(ptr, pe - ptr);
153
154	1520	return (0);
155	1520	}
156
157		/*--------------------------------------------------------------------
158		* Attempt to open and read in a segment list
159		*/
160
161		static int
162	1520	smp_open_segs(struct smp_sc sc, struct smp_signspace spc)
163		{
164		uint64_t length, l;
165		struct smp_segptr ss, se;
166		struct smp_seg sg, sg1, *sg2;
167	1520	int i, n = 0;
168
169	1520	ASSERT_CLI();
170	1520	i = smp_chk_signspace(spc);
171	1520	if (i)
172	0	return (i);
173
174	1520	ss = SIGNSPACE_DATA(spc);
175	1520	length = SIGNSPACE_LEN(spc);
176
177	1520	if (length == 0) {
178		/* No segments */
179	920	sc->free_offset = sc->ident->stuff[SMP_SPC_STUFF];
180	920	return (0);
181		}
182	600	se = ss + length / sizeof *ss;
183	600	se--;
184	600	assert(ss <= se);
185
186		/*
187		* Locate the free reserve, there are only two basic cases,
188		* but once we start dropping segments, things gets more complicated.
189		*/
190
191	600	sc->free_offset = se->offset + se->length;
192	600	l = sc->mediasize - sc->free_offset;
193	600	if (se->offset > ss->offset && l >= sc->free_reserve) {
194		/*
195		* [__xxxxyyyyzzzz___]
196		* Plenty of space at tail, do nothing.
197		*/
198	600	} else if (ss->offset > se->offset) {
199		/*
200		* [zzzz____xxxxyyyy_]
201		* (make) space between ends
202		* We might nuke the entire tail end without getting
203		* enough space, in which case we fall through to the
204		* last check.
205		*/
206	0	while (ss < se && ss->offset > se->offset) {
207	0	l = ss->offset - (se->offset + se->length);
208	0	if (l > sc->free_reserve)
209	0	break;
210	0	ss++;
211	0	n++;
212		}
213	0	}
214
215	600	if (l < sc->free_reserve) {
216		/*
217		* [__xxxxyyyyzzzz___]
218		* (make) space at front
219		*/
220	0	sc->free_offset = sc->ident->stuff[SMP_SPC_STUFF];
221	0	while (ss < se) {
222	0	l = ss->offset - sc->free_offset;
223	0	if (l > sc->free_reserve)
224	0	break;
225	0	ss++;
226	0	n++;
227		}
228	0	}
229
230	600	assert(l >= sc->free_reserve);
231
232
233	600	sg1 = NULL;
234	600	sg2 = NULL;
235	1200	for (; ss <= se; ss++) {
236	600	ALLOC_OBJ(sg, SMP_SEG_MAGIC);
237	600	AN(sg);
238	600	VTAILQ_INIT(&sg->objcores);
239	600	sg->p = *ss;
240
241	600	sg->flags \|= SMP_SEG_MUSTLOAD;
242
243		/*
244		* HACK: prevent save_segs from nuking segment until we have
245		* HACK: loaded it.
246		*/
247	600	sg->nobj = 1;
248	600	if (sg1 != NULL) {
249	0	assert(sg1->p.offset != sg->p.offset);
250	0	if (sg1->p.offset < sg->p.offset)
251	0	assert(smp_segend(sg1) <= sg->p.offset);
252		else
253	0	assert(smp_segend(sg) <= sg1->p.offset);
254	0	}
255	600	if (sg2 != NULL) {
256	0	assert(sg2->p.offset != sg->p.offset);
257	0	if (sg2->p.offset < sg->p.offset)
258	0	assert(smp_segend(sg2) <= sg->p.offset);
259		else
260	0	assert(smp_segend(sg) <= sg2->p.offset);
261	0	}
262
263		/* XXX: check that they are inside silo */
264		/* XXX: check that they don't overlap */
265		/* XXX: check that they are serial */
266	600	sg->sc = sc;
267	600	VTAILQ_INSERT_TAIL(&sc->segments, sg, list);
268	600	sg2 = sg;
269	600	if (sg1 == NULL)
270	600	sg1 = sg;
271	600	}
272	600	printf("Dropped %d segments to make free_reserve\n", n);
273	600	return (0);
274	1520	}
275
276		/*--------------------------------------------------------------------
277		* Silo worker thread
278		*/
279
280		static void * v_matchproto_(bgthread_t)
281	1520	smp_thread(struct worker wrk, void priv)
282		{
283		struct smp_sc *sc;
284		struct smp_seg *sg;
285
286	1520	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
287	1520	CAST_OBJ_NOTNULL(sc, priv, SMP_SC_MAGIC);
288	1520	sc->thread = pthread_self();
289
290		/* First, load all the objects from all segments */
291	3640	VTAILQ_FOREACH(sg, &sc->segments, list)
292	2720	if (sg->flags & SMP_SEG_MUSTLOAD)
293	600	smp_load_seg(wrk, sc, sg);
294
295	1520	sc->flags \|= SMP_SC_LOADED;
296	1520	BAN_Release();
297	1520	printf("Silo completely loaded\n");
298
299		/* Housekeeping loop */
300	1520	Lck_Lock(&sc->mtx);
301	3273	while (!(sc->flags & SMP_SC_STOP)) {
302	1753	sg = VTAILQ_FIRST(&sc->segments);
303	1753	if (sg != NULL && sg != sc->cur_seg && sg->nobj == 0)
304	68	smp_save_segs(sc);
305
306	1753	Lck_Unlock(&sc->mtx);
307	1753	VTIM_sleep(3.14159265359 - 2);
308	1753	Lck_Lock(&sc->mtx);
309		}
310
311	1520	smp_save_segs(sc);
312
313	1520	Lck_Unlock(&sc->mtx);
314	1520	pthread_exit(0);
315
316		NEEDLESS(return (NULL));
317		}
318
319		/*--------------------------------------------------------------------
320		* Open a silo in the worker process
321		*/
322
323		static void v_matchproto_(storage_open_f)
324	1520	smp_open(struct stevedore *st)
325		{
326		struct smp_sc *sc;
327
328	1520	ASSERT_CLI();
329
330	1520	if (VTAILQ_EMPTY(&silos))
331	1160	smp_init();
332
333	1520	CAST_OBJ_NOTNULL(sc, st->priv, SMP_SC_MAGIC);
334
335	1520	Lck_New(&sc->mtx, lck_smp);
336	1520	Lck_Lock(&sc->mtx);
337
338	1520	sc->stevedore = st;
339
340		/* We trust the parent to give us a valid silo, for good measure: */
341	1520	AZ(smp_valid_silo(sc));
342
343	1520	AZ(mprotect((void*)sc->base, 4096, PROT_READ));
344
345	1520	sc->ident = SIGN_DATA(&sc->idn);
346
347		/* Check ban lists */
348	1520	if (smp_chk_signspace(&sc->ban1)) {
349		/* Ban list 1 is broken, use ban2 */
350	0	AZ(smp_chk_signspace(&sc->ban2));
351	0	smp_copy_signspace(&sc->ban1, &sc->ban2);
352	0	smp_sync_sign(&sc->ban1.ctx);
353	0	} else {
354		/* Ban1 is OK, copy to ban2 for consistency */
355	1520	smp_copy_signspace(&sc->ban2, &sc->ban1);
356	1520	smp_sync_sign(&sc->ban2.ctx);
357		}
358	1520	AZ(smp_open_bans(sc, &sc->ban1));
359
360		/* We attempt seg1 first, and if that fails, try seg2 */
361	1520	if (smp_open_segs(sc, &sc->seg1))
362	0	AZ(smp_open_segs(sc, &sc->seg2));
363
364		/*
365		* Grab a reference to the tail of the ban list, until the thread
366		* has loaded all objects, so we can be sure that all of our
367		* proto-bans survive until then.
368		*/
369	1520	BAN_Hold();
370
371		/* XXX: save segments to ensure consistency between seg1 & seg2 ? */
372
373		/* XXX: abandon early segments to make sure we have free space ? */
374
375	1520	(void)ObjSubscribeEvents(smp_oc_event, st,
376		OEV_BANCHG\|OEV_TTLCHG\|OEV_INSERT);
377
378		/* Open a new segment, so we are ready to write */
379	1520	smp_new_seg(sc);
380
381		/* Start the worker silo worker thread, it will load the objects */
382	1520	WRK_BgThread(&sc->bgthread, "persistence", smp_thread, sc);
383
384	1520	VTAILQ_INSERT_TAIL(&silos, sc, list);
385	1520	Lck_Unlock(&sc->mtx);
386	1520	}
387
388		/*--------------------------------------------------------------------
389		* Close a silo
390		*/
391
392		static void v_matchproto_(storage_close_f)
393	2960	smp_close(const struct stevedore *st, int warn)
394		{
395		struct smp_sc *sc;
396		void *status;
397
398	2960	ASSERT_CLI();
399
400	2960	CAST_OBJ_NOTNULL(sc, st->priv, SMP_SC_MAGIC);
401	2960	if (warn) {
402	1480	Lck_Lock(&sc->mtx);
403	1480	if (sc->cur_seg != NULL)
404	1480	smp_close_seg(sc, sc->cur_seg);
405	1480	AZ(sc->cur_seg);
406	1480	sc->flags \|= SMP_SC_STOP;
407	1480	Lck_Unlock(&sc->mtx);
408	1480	} else {
409	1480	PTOK(pthread_join(sc->bgthread, &status));
410	1480	AZ(status);
411		}
412	2960	}
413
414		/*--------------------------------------------------------------------
415		* Allocate a bite.
416		*
417		* Allocate [min_size...max_size] space from the bottom of the segment,
418		* as is convenient.
419		*
420		* If 'so' + 'idx' is given, also allocate a smp_object from the top
421		* of the segment.
422		*
423		* Return the segment in 'ssg' if given.
424		*/
425
426		static struct storage *
427	1120	smp_allocx(const struct stevedore *st, size_t min_size, size_t max_size,
428		struct smp_object *so, unsigned idx, struct smp_seg **ssg)
429		{
430		struct smp_sc *sc;
431		struct storage *ss;
432		struct smp_seg *sg;
433		uint64_t left, extra;
434
435	1120	CAST_OBJ_NOTNULL(sc, st->priv, SMP_SC_MAGIC);
436	1120	assert(min_size <= max_size);
437
438	1120	max_size = IRNUP(sc, max_size);
439	1120	min_size = IRNUP(sc, min_size);
440
441	1120	extra = IRNUP(sc, sizeof(*ss));
442	1120	if (so != NULL) {
443	880	extra += sizeof(**so);
444	880	AN(idx);
445	880	}
446
447	1120	Lck_Lock(&sc->mtx);
448	1120	sg = NULL;
449	1120	ss = NULL;
450
451	1120	left = 0;
452	1120	if (sc->cur_seg != NULL)
453	1120	left = smp_spaceleft(sc, sc->cur_seg);
454	1120	if (left < extra + min_size) {
455	0	if (sc->cur_seg != NULL)
456	0	smp_close_seg(sc, sc->cur_seg);
457	0	smp_new_seg(sc);
458	0	if (sc->cur_seg != NULL)
459	0	left = smp_spaceleft(sc, sc->cur_seg);
460		else
461	0	left = 0;
462	0	}
463
464	1120	if (left >= extra + min_size) {
465	1120	AN(sc->cur_seg);
466	1120	if (left < extra + max_size)
467	0	max_size = IRNDN(sc, left - extra);
468
469	1120	sg = sc->cur_seg;
470	1120	ss = (void*)(sc->base + sc->next_bot);
471	1120	sc->next_bot += max_size + IRNUP(sc, sizeof(*ss));
472	1120	sg->nalloc++;
473	1120	if (so != NULL) {
474	880	sc->next_top -= sizeof(**so);
475	880	so = (void)(sc->base + sc->next_top);
476		/* Render this smp_object mostly harmless */
477	880	EXP_ZERO((*so));
478	880	(*so)->ban = 0.;
479	880	(*so)->ptr = 0;
480	880	sg->objs = *so;
481	880	*idx = ++sg->p.lobjlist;
482	880	}
483	1120	(void)smp_spaceleft(sc, sg); /* for the assert */
484	1120	}
485	1120	Lck_Unlock(&sc->mtx);
486
487	1120	if (ss == NULL)
488	0	return (ss);
489	1120	AN(sg);
490	1120	assert(max_size >= min_size);
491
492		/* Fill the storage structure */
493	1120	INIT_OBJ(ss, STORAGE_MAGIC);
494	1120	ss->ptr = PRNUP(sc, ss + 1);
495	1120	ss->space = max_size;
496	1120	ss->priv = sc->base;
497	1120	if (ssg != NULL)
498	880	*ssg = sg;
499	1120	return (ss);