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

#ifndef WITH_PERSISTENT_STORAGE
#error "WITH_PERSISTENT_STORAGE must be defined"
#endif

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

/*
 * 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;
        smp_oc_realmethods.vai_init     = SML_methods.vai_init;
}

/*--------------------------------------------------------------------
 * 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		#ifndef WITH_PERSISTENT_STORAGE
64		#error "WITH_PERSISTENT_STORAGE must be defined"
65		#endif
66
67		/--------------------------------------------------------------------/
68
69		/*
70		* silos is unlocked, it only changes during startup when we are
71		* single-threaded
72		*/
73		static VTAILQ_HEAD(,smp_sc) silos = VTAILQ_HEAD_INITIALIZER(silos);
74
75		/*--------------------------------------------------------------------
76		* Add bans to silos
77		*/
78
79		static int
80	768	smp_appendban(const struct smp_sc sc, struct smp_signspace spc,
81		uint32_t len, const uint8_t *ban)
82		{
83
84	768	(void)sc;
85	768	if (SIGNSPACE_FREE(spc) < len)
86	0	return (-1);
87
88	768	memcpy(SIGNSPACE_FRONT(spc), ban, len);
89	768	smp_append_signspace(spc, len);
90
91	768	return (0);
92	768	}
93
94		/* Trust that cache_ban.c takes care of locking */
95
96		static int
97	552	smp_baninfo(const struct stevedore *stv, enum baninfo event,
98		const uint8_t *ban, unsigned len)
99		{
100		struct smp_sc *sc;
101	552	int r = 0;
102
103	552	CAST_OBJ_NOTNULL(sc, stv->priv, SMP_SC_MAGIC);
104
105	552	switch (event) {
106		case BI_NEW:
107	384	r \|= smp_appendban(sc, &sc->ban1, len, ban);
108	384	r \|= smp_appendban(sc, &sc->ban2, len, ban);
109	384	break;
110		default:
111		/* Ignored */
112	168	break;
113		}
114
115	552	return (r);
116		}
117
118		static void
119	1200	smp_banexport_spc(struct smp_signspace spc, const uint8_t bans, unsigned len)
120		{
121	1200	smp_reset_signspace(spc);
122	1200	assert(SIGNSPACE_FREE(spc) >= len);
123	1200	memcpy(SIGNSPACE_DATA(spc), bans, len);
124	1200	smp_append_signspace(spc, len);
125	1200	smp_sync_sign(&spc->ctx);
126	1200	}
127
128		static void
129	600	smp_banexport(const struct stevedore stv, const uint8_t bans, unsigned len)
130		{
131		struct smp_sc *sc;
132
133	600	CAST_OBJ_NOTNULL(sc, stv->priv, SMP_SC_MAGIC);
134	600	smp_banexport_spc(&sc->ban1, bans, len);
135	600	smp_banexport_spc(&sc->ban2, bans, len);
136	600	}
137
138		/*--------------------------------------------------------------------
139		* Attempt to open and read in a ban list
140		*/
141
142		static int
143	304	smp_open_bans(const struct smp_sc sc, struct smp_signspace spc)
144		{
145		uint8_t ptr, pe;
146		int i;
147
148	304	ASSERT_CLI();
149	304	(void)sc;
150	304	i = smp_chk_signspace(spc);
151	304	if (i)
152	0	return (i);
153
154	304	ptr = SIGNSPACE_DATA(spc);
155	304	pe = SIGNSPACE_FRONT(spc);
156	304	BAN_Reload(ptr, pe - ptr);
157
158	304	return (0);
159	304	}
160
161		/*--------------------------------------------------------------------
162		* Attempt to open and read in a segment list
163		*/
164
165		static int
166	304	smp_open_segs(struct smp_sc sc, struct smp_signspace spc)
167		{
168		uint64_t length, l;
169		struct smp_segptr ss, se;
170		struct smp_seg sg, sg1, *sg2;
171	304	int i, n = 0;
172
173	304	ASSERT_CLI();
174	304	i = smp_chk_signspace(spc);
175	304	if (i)
176	0	return (i);
177
178	304	ss = SIGNSPACE_DATA(spc);
179	304	length = SIGNSPACE_LEN(spc);
180
181	304	if (length == 0) {
182		/* No segments */
183	184	sc->free_offset = sc->ident->stuff[SMP_SPC_STUFF];
184	184	return (0);
185		}
186	120	se = ss + length / sizeof *ss;
187	120	se--;
188	120	assert(ss <= se);
189
190		/*
191		* Locate the free reserve, there are only two basic cases,
192		* but once we start dropping segments, things gets more complicated.
193		*/
194
195	120	sc->free_offset = se->offset + se->length;
196	120	l = sc->mediasize - sc->free_offset;
197	120	if (se->offset > ss->offset && l >= sc->free_reserve) {
198		/*
199		* [__xxxxyyyyzzzz___]
200		* Plenty of space at tail, do nothing.
201		*/
202	120	} else if (ss->offset > se->offset) {
203		/*
204		* [zzzz____xxxxyyyy_]
205		* (make) space between ends
206		* We might nuke the entire tail end without getting
207		* enough space, in which case we fall through to the
208		* last check.
209		*/
210	0	while (ss < se && ss->offset > se->offset) {
211	0	l = ss->offset - (se->offset + se->length);
212	0	if (l > sc->free_reserve)
213	0	break;
214	0	ss++;
215	0	n++;
216		}
217	0	}
218
219	120	if (l < sc->free_reserve) {
220		/*
221		* [__xxxxyyyyzzzz___]
222		* (make) space at front
223		*/
224	0	sc->free_offset = sc->ident->stuff[SMP_SPC_STUFF];
225	0	while (ss < se) {
226	0	l = ss->offset - sc->free_offset;
227	0	if (l > sc->free_reserve)
228	0	break;
229	0	ss++;
230	0	n++;
231		}
232	0	}
233
234	120	assert(l >= sc->free_reserve);
235
236
237	120	sg1 = NULL;
238	120	sg2 = NULL;
239	240	for (; ss <= se; ss++) {
240	120	ALLOC_OBJ(sg, SMP_SEG_MAGIC);
241	120	AN(sg);
242	120	VTAILQ_INIT(&sg->objcores);
243	120	sg->p = *ss;
244
245	120	sg->flags \|= SMP_SEG_MUSTLOAD;
246
247		/*
248		* HACK: prevent save_segs from nuking segment until we have
249		* HACK: loaded it.
250		*/
251	120	sg->nobj = 1;
252	120	if (sg1 != NULL) {
253	0	assert(sg1->p.offset != sg->p.offset);
254	0	if (sg1->p.offset < sg->p.offset)
255	0	assert(smp_segend(sg1) <= sg->p.offset);
256		else
257	0	assert(smp_segend(sg) <= sg1->p.offset);
258	0	}
259	120	if (sg2 != NULL) {
260	0	assert(sg2->p.offset != sg->p.offset);
261	0	if (sg2->p.offset < sg->p.offset)
262	0	assert(smp_segend(sg2) <= sg->p.offset);
263		else
264	0	assert(smp_segend(sg) <= sg2->p.offset);
265	0	}
266
267		/* XXX: check that they are inside silo */
268		/* XXX: check that they don't overlap */
269		/* XXX: check that they are serial */
270	120	sg->sc = sc;
271	120	VTAILQ_INSERT_TAIL(&sc->segments, sg, list);
272	120	sg2 = sg;
273	120	if (sg1 == NULL)
274	120	sg1 = sg;
275	120	}
276	120	printf("Dropped %d segments to make free_reserve\n", n);
277	120	return (0);
278	304	}
279
280		/*--------------------------------------------------------------------
281		* Silo worker thread
282		*/
283
284		static void * v_matchproto_(bgthread_t)
285	304	smp_thread(struct worker wrk, void priv)
286		{
287		struct smp_sc *sc;
288		struct smp_seg *sg;
289
290	304	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
291	304	CAST_OBJ_NOTNULL(sc, priv, SMP_SC_MAGIC);
292	304	sc->thread = pthread_self();
293
294		/* First, load all the objects from all segments */
295	728	VTAILQ_FOREACH(sg, &sc->segments, list)
296	544	if (sg->flags & SMP_SEG_MUSTLOAD)
297	120	smp_load_seg(wrk, sc, sg);
298
299	304	sc->flags \|= SMP_SC_LOADED;
300	304	BAN_Release();
301	304	printf("Silo completely loaded\n");
302
303		/* Housekeeping loop */
304	304	Lck_Lock(&sc->mtx);
305	657	while (!(sc->flags & SMP_SC_STOP)) {
306	353	sg = VTAILQ_FIRST(&sc->segments);
307	353	if (sg != NULL && sg != sc->cur_seg && sg->nobj == 0)
308	14	smp_save_segs(sc);
309
310	353	Lck_Unlock(&sc->mtx);
311	353	VTIM_sleep(3.14159265359 - 2);
312	353	Lck_Lock(&sc->mtx);
313		}
314
315	304	smp_save_segs(sc);
316
317	304	Lck_Unlock(&sc->mtx);
318	304	pthread_exit(0);
319
320		NEEDLESS(return (NULL));
321		}
322
323		/*--------------------------------------------------------------------
324		* Open a silo in the worker process
325		*/
326
327		static void v_matchproto_(storage_open_f)
328	304	smp_open(struct stevedore *st)
329		{
330		struct smp_sc *sc;
331
332	304	ASSERT_CLI();
333
334	304	if (VTAILQ_EMPTY(&silos))
335	232	smp_init();
336
337	304	CAST_OBJ_NOTNULL(sc, st->priv, SMP_SC_MAGIC);
338
339	304	Lck_New(&sc->mtx, lck_smp);
340	304	Lck_Lock(&sc->mtx);
341
342	304	sc->stevedore = st;
343
344		/* We trust the parent to give us a valid silo, for good measure: */
345	304	AZ(smp_valid_silo(sc));
346
347	304	AZ(mprotect((void*)sc->base, 4096, PROT_READ));
348
349	304	sc->ident = SIGN_DATA(&sc->idn);
350
351		/* Check ban lists */
352	304	if (smp_chk_signspace(&sc->ban1)) {
353		/* Ban list 1 is broken, use ban2 */
354	0	AZ(smp_chk_signspace(&sc->ban2));
355	0	smp_copy_signspace(&sc->ban1, &sc->ban2);
356	0	smp_sync_sign(&sc->ban1.ctx);
357	0	} else {
358		/* Ban1 is OK, copy to ban2 for consistency */
359	304	smp_copy_signspace(&sc->ban2, &sc->ban1);
360	304	smp_sync_sign(&sc->ban2.ctx);
361		}
362	304	AZ(smp_open_bans(sc, &sc->ban1));
363
364		/* We attempt seg1 first, and if that fails, try seg2 */
365	304	if (smp_open_segs(sc, &sc->seg1))
366	0	AZ(smp_open_segs(sc, &sc->seg2));
367
368		/*
369		* Grab a reference to the tail of the ban list, until the thread
370		* has loaded all objects, so we can be sure that all of our
371		* proto-bans survive until then.
372		*/
373	304	BAN_Hold();
374
375		/* XXX: save segments to ensure consistency between seg1 & seg2 ? */
376
377		/* XXX: abandon early segments to make sure we have free space ? */
378
379	304	(void)ObjSubscribeEvents(smp_oc_event, st,
380		OEV_BANCHG\|OEV_TTLCHG\|OEV_INSERT);
381
382		/* Open a new segment, so we are ready to write */
383	304	smp_new_seg(sc);
384
385		/* Start the worker silo worker thread, it will load the objects */
386	304	WRK_BgThread(&sc->bgthread, "persistence", smp_thread, sc);
387
388	304	VTAILQ_INSERT_TAIL(&silos, sc, list);
389	304	Lck_Unlock(&sc->mtx);
390	304	}
391
392		/*--------------------------------------------------------------------
393		* Close a silo
394		*/
395
396		static void v_matchproto_(storage_close_f)
397	592	smp_close(const struct stevedore *st, int warn)
398		{
399		struct smp_sc *sc;
400		void *status;
401
402	592	ASSERT_CLI();
403
404	592	CAST_OBJ_NOTNULL(sc, st->priv, SMP_SC_MAGIC);
405	592	if (warn) {
406	296	Lck_Lock(&sc->mtx);
407	296	if (sc->cur_seg != NULL)
408	296	smp_close_seg(sc, sc->cur_seg);
409	296	AZ(sc->cur_seg);
410	296	sc->flags \|= SMP_SC_STOP;
411	296	Lck_Unlock(&sc->mtx);
412	296	} else {
413	296	PTOK(pthread_join(sc->bgthread, &status));
414	296	AZ(status);
415		}
416	592	}
417
418		/*--------------------------------------------------------------------
419		* Allocate a bite.
420		*
421		* Allocate [min_size...max_size] space from the bottom of the segment,
422		* as is convenient.
423		*
424		* If 'so' + 'idx' is given, also allocate a smp_object from the top
425		* of the segment.
426		*
427		* Return the segment in 'ssg' if given.
428		*/
429
430		static struct storage *
431	224	smp_allocx(const struct stevedore *st, size_t min_size, size_t max_size,
432		struct smp_object *so, unsigned idx, struct smp_seg **ssg)
433		{
434		struct smp_sc *sc;
435		struct storage *ss;
436		struct smp_seg *sg;
437		uint64_t left, extra;
438
439	224	CAST_OBJ_NOTNULL(sc, st->priv, SMP_SC_MAGIC);
440	224	assert(min_size <= max_size);
441
442	224	max_size = IRNUP(sc, max_size);
443	224	min_size = IRNUP(sc, min_size);
444
445	224	extra = IRNUP(sc, sizeof(*ss));
446	224	if (so != NULL) {
447	176	extra += sizeof(**so);
448	176	AN(idx);
449	176	}
450
451	224	Lck_Lock(&sc->mtx);
452	224	sg = NULL;
453	224	ss = NULL;
454
455	224	left = 0;
456	224	if (sc->cur_seg != NULL)
457	224	left = smp_spaceleft(sc, sc->cur_seg);
458	224	if (left < extra + min_size) {
459	0	if (sc->cur_seg != NULL)
460	0	smp_close_seg(sc, sc->cur_seg);
461	0	smp_new_seg(sc);
462	0	if (sc->cur_seg != NULL)
463	0	left = smp_spaceleft(sc, sc->cur_seg);
464		else
465	0	left = 0;
466	0	}
467
468	224	if (left >= extra + min_size) {
469	224	AN(sc->cur_seg);
470	224	if (left < extra + max_size)
471	0	max_size = IRNDN(sc, left - extra);
472
473	224	sg = sc->cur_seg;
474	224	ss = (void*)(sc->base + sc->next_bot);
475	224	sc->next_bot += max_size + IRNUP(sc, sizeof(*ss));
476	224	sg->nalloc++;
477	224	if (so != NULL) {
478	176	sc->next_top -= sizeof(**so);
479	176	so = (void)(sc->base + sc->next_top);
480		/* Render this smp_object mostly harmless */
481	176	EXP_ZERO((*so));
482	176	(*so)->ban = 0.;
483	176	(*so)->ptr = 0;
484	176	sg->objs = *so;
485	176	*idx = ++sg->p.lobjlist;
486	176	}
487	224	(void)smp_spaceleft(sc, sg); /* for the assert */
488	224	}
489	224	Lck_Unlock(&sc->mtx);
490
491	224	if (ss == NULL)
492	0	return (ss);
493	224	AN(sg);
494	224	assert(max_size >= min_size);
495
496		/* Fill the storage structure */
497	224	INIT_OBJ(ss, STORAGE_MAGIC);
498	224	ss->ptr = PRNUP(sc, ss + 1);
499	224	ss->space = max_size;