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>
 * Author: Martin Blix Grydeland <martin@varnish-software.com>
 *
 * 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 <sys/mman.h>
#include <sys/stat.h>

#include <fcntl.h>
#include <float.h>
#include <math.h>
#include <stdarg.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "vdef.h"
#include "vas.h"
#include "miniobj.h"

#include "vav.h"
#include "vin.h"
#include "vlu.h"
#include "vsb.h"
#include "vsm_priv.h"
#include "vqueue.h"
#include "vtim.h"

#include "vapi/vsig.h"
#include "vapi/vsm.h"

#ifndef MAP_HASSEMAPHORE
#  define MAP_HASSEMAPHORE 0 /* XXX Linux */
#endif

#ifndef MAP_NOSYNC
#  define MAP_NOSYNC 0 /* XXX Linux */
#endif

const struct vsm_valid VSM_invalid[1] = {{"invalid"}};
const struct vsm_valid VSM_valid[1] = {{"valid"}};

static vlu_f vsm_vlu_func;

#define VSM_PRIV_SHIFT                                                  \
        (sizeof (uint64_t) * 4)
#define VSM_PRIV_MASK                                                   \
        ((1ULL << VSM_PRIV_SHIFT) - 1)
#define VSM_PRIV_LOW(u)                                                 \
        ((uint64_t)(u) & VSM_PRIV_MASK)
#define VSM_PRIV_HIGH(u)                                                \
        (((uint64_t)(u) >> VSM_PRIV_SHIFT) & VSM_PRIV_MASK)
#define VSM_PRIV_MERGE(low, high)                                       \
        (VSM_PRIV_LOW(low) | (VSM_PRIV_LOW(high) << VSM_PRIV_SHIFT))

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

struct vsm_set;

struct vsm_seg {
        unsigned                magic;
#define VSM_SEG_MAGIC           0xeb6c6dfd
        unsigned                flags;
#define VSM_FLAG_MARKSCAN       (1U<<1)
#define VSM_FLAG_STALE          (1U<<2)
#define VSM_FLAG_CLUSTER        (1U<<3)
        VTAILQ_ENTRY(vsm_seg)   list;
        VTAILQ_ENTRY(vsm_seg)   clist;
        struct vsm_set          *set;
        struct vsm_seg          *cluster;
        char                    **av;
        int                     refs;
        void                    *s;
        size_t                  sz;
        void                    *b;
        void                    *e;
        uint64_t                serial;
};

struct vsm_set {
        unsigned                magic;
#define VSM_SET_MAGIC           0xdee401b8
        const char              *dname;
        struct vsm              *vsm;
        VTAILQ_HEAD(,vsm_seg)   segs;
        VTAILQ_HEAD(,vsm_seg)   stale;
        VTAILQ_HEAD(,vsm_seg)   clusters;

        int                     dfd;
        struct stat             dst;

        int                     fd;
        struct stat             fst;

        uintmax_t               id1, id2;

        // _.index reading state
        struct vlu              *vlu;
        unsigned                retval;
        struct vsm_seg          *vg;

        unsigned                flag_running;
        unsigned                flag_changed;
        unsigned                flag_restarted;
};

struct vsm {
        unsigned                magic;
#define VSM_MAGIC               0x6e3bd69b

        struct vsb              *diag;
        uint64_t                serial;

        int                     wdfd;
        struct stat             wdst;
        char                    *wdname;

        struct vsm_set          *mgt;
        struct vsm_set          *child;

        int                     attached;
        double                  patience;
};

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

static int
vsm_diag(struct vsm *vd, const char *fmt, ...)
{
        va_list ap;

        CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
        AN(fmt);

        if (vd->diag == NULL)
                vd->diag = VSB_new_auto();
        AN(vd->diag);
        VSB_clear(vd->diag);
        va_start(ap, fmt);
        VSB_vprintf(vd->diag, fmt, ap);
        va_end(ap);
        AZ(VSB_finish(vd->diag));
        return (-1);
}

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

static int
vsm_mapseg(struct vsm *vd, struct vsm_seg *vg)
{
        size_t of, off, sz, ps, len;
        struct vsb *vsb;
        int fd;

        CHECK_OBJ_NOTNULL(vg, VSM_SEG_MAGIC);

        if (vg->s != NULL)
                return (0);

        ps = getpagesize();

        of = strtoul(vg->av[2], NULL, 10);
        off = RDN2(of, ps);

        if (vg->flags & VSM_FLAG_CLUSTER)
                assert(of == 0);
        assert(vg->cluster == NULL);

        sz = strtoul(vg->av[3], NULL, 10);
        assert(sz > 0);
        assert(of >= off);
        len = RUP2((of - off) + sz, ps);

        vsb = VSB_new_auto();
        AN(vsb);
        VSB_printf(vsb, "%s/%s/%s", vd->wdname, vg->set->dname, vg->av[1]);
        AZ(VSB_finish(vsb));

        fd = open(VSB_data(vsb), O_RDONLY);     // XXX: openat
        if (fd < 0) {
                VSB_destroy(&vsb);
                return (vsm_diag(vd, "Could not open segment"));
        }

        vg->s = (void*)mmap(NULL, len,
            PROT_READ,
            MAP_HASSEMAPHORE | MAP_NOSYNC | MAP_SHARED,
            fd, (off_t)off);

        VSB_destroy(&vsb);

        closefd(&fd);
        if (vg->s == MAP_FAILED)
                return (vsm_diag(vd, "Could not mmap segment"));

        vg->b = (char*)(vg->s) + of - off;
        vg->e = (char *)vg->b + sz;
        vg->sz = len;

        return (0);
}

static void
vsm_unmapseg(struct vsm_seg *vg)
{

        CHECK_OBJ_NOTNULL(vg, VSM_SEG_MAGIC);

        AN(vg->b);
        AN(vg->e);
        AZ(munmap(vg->s, vg->sz));
        vg->s = vg->b = vg->e = NULL;
        vg->sz = 0;
}

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

static void
vsm_delseg(struct vsm_seg *vg, int refsok)
{

        CHECK_OBJ_NOTNULL(vg, VSM_SEG_MAGIC);

        if (vg->set->vg == vg) {
                AZ(vg->flags & VSM_FLAG_STALE);
                vg->set->vg = VTAILQ_NEXT(vg, list);
        }

        if (refsok && vg->refs) {
                AZ(vg->flags & VSM_FLAG_STALE);
                vg->flags |= VSM_FLAG_STALE;
                VTAILQ_REMOVE(&vg->set->segs, vg, list);
                VTAILQ_INSERT_TAIL(&vg->set->stale, vg, list);
                return;
        }

        if (vg->s != NULL)
                vsm_unmapseg(vg);

        if (vg->flags & VSM_FLAG_CLUSTER) {
                vg->flags &= ~VSM_FLAG_CLUSTER;
                VTAILQ_REMOVE(&vg->set->clusters, vg, clist);
        }

        if (vg->flags & VSM_FLAG_STALE)
                VTAILQ_REMOVE(&vg->set->stale, vg, list);
        else
                VTAILQ_REMOVE(&vg->set->segs, vg, list);
        VAV_Free(vg->av);
        FREE_OBJ(vg);
}

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

static struct vsm_set *
vsm_newset(const char *dirname)
{
        struct vsm_set *vs;

        ALLOC_OBJ(vs, VSM_SET_MAGIC);
        AN(vs);
        VTAILQ_INIT(&vs->segs);
        VTAILQ_INIT(&vs->stale);
        VTAILQ_INIT(&vs->clusters);
        vs->dname = dirname;
        vs->dfd = vs->fd = -1;
        vs->vlu = VLU_New(vsm_vlu_func, vs, 0);
        AN(vs->vlu);
        return (vs);
}

static void
vsm_delset(struct vsm_set **p)
{
        struct vsm_set *vs;
        struct vsm_seg *vg;

        TAKE_OBJ_NOTNULL(vs, p, VSM_SET_MAGIC);

        if (vs->fd >= 0)
                closefd(&vs->fd);
        if (vs->dfd >= 0)
                closefd(&vs->dfd);
        while ((vg = VTAILQ_FIRST(&vs->stale)) != NULL) {
                AN(vg->flags & VSM_FLAG_STALE);
                vsm_delseg(vg, 0);
        }
        while ((vg = VTAILQ_FIRST(&vs->segs)) != NULL) {
                AZ(vg->flags & VSM_FLAG_STALE);
                vsm_delseg(vg, 0);
        }
        assert(VTAILQ_EMPTY(&vs->clusters));
        VLU_Destroy(&vs->vlu);
        FREE_OBJ(vs);
}

static void
vsm_wash_set(const struct vsm_set *vs, int all)
{
        struct vsm_seg *vg, *vg2;

        VTAILQ_FOREACH_SAFE(vg, &vs->segs, list, vg2) {
                if (all || (vg->flags & VSM_FLAG_MARKSCAN) == 0)
                        vsm_delseg(vg, 1);
        }
}

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

struct vsm *
VSM_New(void)
{
        struct vsm *vd;

        ALLOC_OBJ(vd, VSM_MAGIC);
        AN(vd);

        vd->mgt = vsm_newset(VSM_MGT_DIRNAME);
        vd->mgt->flag_running = VSM_MGT_RUNNING;
        vd->mgt->flag_changed = VSM_MGT_CHANGED;
        vd->mgt->flag_restarted = VSM_MGT_RESTARTED;

        vd->child = vsm_newset(VSM_CHILD_DIRNAME);
        vd->child->flag_running = VSM_WRK_RUNNING;
        vd->child->flag_changed = VSM_WRK_CHANGED;
        vd->child->flag_restarted = VSM_WRK_RESTARTED;

        vd->mgt->vsm = vd;
        vd->child->vsm = vd;
        vd->wdfd = -1;
        vd->patience = 5;
        return (vd);
}

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

int
VSM_Arg(struct vsm *vd, char flag, const char *arg)
{
        char *p = NULL;

        CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);

        if (arg == NULL)
                return (1);
        switch (flag) {
        case 't':
                if (!strcasecmp(arg, "off")) {
                        vd->patience = -1;
                } else {
                        vd->patience = strtod(arg, &p);
                        if ((p != NULL && *p != '\0') ||
                            !isfinite(vd->patience) || vd->patience < 0)
                                return (vsm_diag(vd,
                                    "-t: Invalid argument: %s", arg));
                }
                break;
        case 'n':
                if (vd->wdname != NULL)
                        free(vd->wdname);
                vd->wdname = VIN_n_Arg(arg);
                if (vd->wdname == NULL)
                        return (vsm_diag(vd, "Invalid instance name: %s",
                            strerror(errno)));
                break;
        default:
                return (vsm_diag(vd, "Unknown VSM_Arg('%c')", flag));
        }
        return (1);
}

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

void
VSM_Destroy(struct vsm **vdp)
{
        struct vsm *vd;

        TAKE_OBJ_NOTNULL(vd, vdp, VSM_MAGIC);

        VSM_ResetError(vd);
        REPLACE(vd->wdname, NULL);
        if (vd->diag != NULL)
                VSB_destroy(&vd->diag);
        if (vd->wdfd >= 0)
                closefd(&vd->wdfd);
        vsm_delset(&vd->mgt);
        vsm_delset(&vd->child);
        FREE_OBJ(vd);
}

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

const char *
VSM_Error(const struct vsm *vd)
{

        CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);

        if (vd->diag == NULL)
                return ("No VSM error");
        else
                return (VSB_data(vd->diag));
}

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

void
VSM_ResetError(struct vsm *vd)
{

        CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);

        if (vd->diag == NULL)
                return;
        VSB_destroy(&vd->diag);
}

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

static int
vsm_cmp_av(char * const *a1, char * const *a2)
{

        while (1) {
                if (*a1 == NULL && *a2 == NULL)
                        return (0);
                if (*a1 == NULL || *a2 == NULL)
                        return (1);
                if (strcmp(*a1, *a2))
                        return (1);
                a1++;
                a2++;
        }
}

static struct vsm_seg *
vsm_findcluster(const struct vsm_set *vs, const char *cnam)
{
        struct vsm_seg *vg;
        AN(vs);
        AN(cnam);
        VTAILQ_FOREACH(vg, &vs->clusters, clist) {
                AN(vg->av[1]);
                if (!strcmp(cnam, vg->av[1]))
                        return (vg);
        }
        return (NULL);
}

static int
vsm_vlu_hash(struct vsm *vd, struct vsm_set *vs, const char *line)
{
        int i;
        uintmax_t id1, id2;

        (void)vd;

        i = sscanf(line, "# %ju %ju", &id1, &id2);
        if (i != 2) {
                vs->retval |= VSM_MGT_RESTARTED | VSM_MGT_CHANGED;
                return (0);
        }
        vs->retval |= VSM_MGT_RUNNING;
        if (id1 != vs->id1 || id2 != vs->id2) {
                vs->retval |= VSM_MGT_RESTARTED | VSM_MGT_CHANGED;
                vs->id1 = id1;
                vs->id2 = id2;
        }
        return (0);
}

static int
vsm_vlu_plus(struct vsm *vd, struct vsm_set *vs, const char *line)
{
        char **av;
        int ac;
        struct vsm_seg *vg;

        av = VAV_Parse(line + 1, &ac, 0);

        if (av[0] != NULL || ac < 4 || ac > 6) {
                (void)(vsm_diag(vd, "vsm_vlu_plus: bad index (%d/%s)",
                    ac, av[0]));
                VAV_Free(av);
                return (-1);
        }

        vg = vs->vg;
        CHECK_OBJ_ORNULL(vg, VSM_SEG_MAGIC);
        if (vg != NULL)
                AZ(vg->flags & VSM_FLAG_STALE);
        while (vg != NULL && vsm_cmp_av(&vg->av[1], &av[1]))
                vg = VTAILQ_NEXT(vg, list);
        if (vg != NULL) {
                /* entry compared equal, so it survives */
                CHECK_OBJ_NOTNULL(vg, VSM_SEG_MAGIC);
                VAV_Free(av);
                vg->flags |= VSM_FLAG_MARKSCAN;
                vs->vg = VTAILQ_NEXT(vg, list);
        } else {
                ALLOC_OBJ(vg, VSM_SEG_MAGIC);
                AN(vg);
                vg->av = av;
                vg->set = vs;
                vg->flags = VSM_FLAG_MARKSCAN;
                vg->serial = vd->serial;

                VTAILQ_INSERT_TAIL(&vs->segs, vg, list);
                if (ac == 4) {
                        vg->flags |= VSM_FLAG_CLUSTER;
                        VTAILQ_INSERT_TAIL(&vs->clusters, vg, clist);
                } else if (*vg->av[2] != '0') {
                        vg->cluster = vsm_findcluster(vs, vg->av[1]);
                        CHECK_OBJ_NOTNULL(vg->cluster, VSM_SEG_MAGIC);
                }
        }
        return (0);
}

static int
vsm_vlu_minus(struct vsm *vd, const struct vsm_set *vs, const char *line)
{
        char **av;
        int ac;
        struct vsm_seg *vg;

        av = VAV_Parse(line + 1, &ac, 0);

        if (av[0] != NULL || ac < 4 || ac > 6) {
                (void)(vsm_diag(vd, "vsm_vlu_minus: bad index (%d/%s)",
                    ac, av[0]));
                VAV_Free(av);
                return (-1);
        }

        /* Clustered segments cannot come before their cluster */
        if (*av[2] != '0')
                vg = vsm_findcluster(vs, av[1]);
        else
                vg = VTAILQ_FIRST(&vs->segs);

        for (;vg != NULL; vg = VTAILQ_NEXT(vg, list)) {
                if (!vsm_cmp_av(&vg->av[1], &av[1])) {
                        vsm_delseg(vg, 1);
                        break;
                }
        }
        AN(vg);
        VAV_Free(av);
        return (0);
}

static int v_matchproto_(vlu_f)
vsm_vlu_func(void *priv, const char *line)
{
        struct vsm *vd;
        struct vsm_set *vs;
        int i = 0;

        CAST_OBJ_NOTNULL(vs, priv, VSM_SET_MAGIC);
        vd = vs->vsm;
        CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
        AN(line);

        /* Up the serial counter. This wraps at UINTPTR_MAX/2
         * because thats the highest value we can store in struct
         * vsm_fantom. */
        vd->serial = VSM_PRIV_LOW(vd->serial + 1);

        switch (line[0]) {
        case '#':
                i = vsm_vlu_hash(vd, vs, line);
                VTAILQ_FOREACH(vs->vg, &vs->segs, list)
                        vs->vg->flags &= ~VSM_FLAG_MARKSCAN;
                if (!(vs->retval & vs->flag_restarted))
                        vs->vg = VTAILQ_FIRST(&vs->segs);
                break;
        case '+':
                i = vsm_vlu_plus(vd, vs, line);
                break;
        case '-':
                i = vsm_vlu_minus(vd, vs, line);
                break;
        default:
                break;
        }
        return (i);
}

static void
vsm_readlines(struct vsm_set *vs)
{
        int i;

        do {
                assert(vs->fd >= 0);
                i = VLU_Fd(vs->vlu, vs->fd);
        } while (!i);
        assert(i == -2);
}

static unsigned
vsm_refresh_set(struct vsm *vd, struct vsm_set *vs)
{
        struct stat st;

        CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
        CHECK_OBJ_NOTNULL(vs, VSM_SET_MAGIC);
        vs->retval = 0;
        if (vs->dfd >= 0 && (
            fstatat(vd->wdfd, vs->dname, &st, AT_SYMLINK_NOFOLLOW) ||
            st.st_ino != vs->dst.st_ino ||
            st.st_dev != vs->dst.st_dev ||
            st.st_mode != vs->dst.st_mode ||
            st.st_nlink == 0)) {
                closefd(&vs->dfd);
        }

        if (vs->dfd < 0) {
                if (vs->fd >= 0)
                        closefd(&vs->fd);
                vs->dfd = openat(vd->wdfd, vs->dname, O_RDONLY);
        }

        if (vs->dfd < 0) {
                vs->id1 = vs->id2 = 0;
                vsm_wash_set(vs, 1);
                return (vs->retval | vs->flag_restarted);
        }

        AZ(fstat(vs->dfd, &vs->dst));

        if (vs->fd >= 0 && (
            fstatat(vs->dfd, "_.index", &st, AT_SYMLINK_NOFOLLOW) ||
            st.st_ino != vs->fst.st_ino ||
            st.st_dev != vs->fst.st_dev ||
            st.st_mode != vs->fst.st_mode ||
            st.st_size < vs->fst.st_size ||
            st.st_nlink < 1)) {
                closefd(&vs->fd);
        }

        if (vs->fd >= 0) {
                vs->vg = NULL;
                vsm_readlines(vs);
        } else {
                VTAILQ_FOREACH(vs->vg, &vs->segs, list)
                        vs->vg->flags &= ~VSM_FLAG_MARKSCAN;
                vs->vg = VTAILQ_FIRST(&vs->segs);
                vs->fd = openat(vs->dfd, "_.index", O_RDONLY);
                if (vs->fd < 0)
                        return (vs->retval | vs->flag_restarted);
                VLU_Reset(vs->vlu);
                AZ(fstat(vs->fd, &vs->fst));
                vsm_readlines(vs);
                vsm_wash_set(vs, 0);
        }

        vs->fst.st_size = lseek(vs->fd, 0L, SEEK_CUR);

        vs->retval |= vs->flag_running;
        return (vs->retval);
}

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

unsigned
VSM_Status(struct vsm *vd)
{
        unsigned retval = 0;
        struct stat st;

        CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);

        /* See if the -n workdir changed */
        if (vd->wdfd >= 0) {
                AZ(fstat(vd->wdfd, &st));
                if (st.st_ino != vd->wdst.st_ino ||
                    st.st_dev != vd->wdst.st_dev ||
                    st.st_mode != vd->wdst.st_mode ||
                    st.st_nlink == 0) {
                        closefd(&vd->wdfd);
                        vsm_wash_set(vd->mgt, 1);
                        vsm_wash_set(vd->child, 1);
                }
        }

        /* Open workdir */
        if (vd->wdfd < 0) {
                retval |= VSM_MGT_RESTARTED | VSM_MGT_CHANGED;
                retval |= VSM_WRK_RESTARTED | VSM_MGT_CHANGED;
                vd->wdfd = open(vd->wdname, O_RDONLY);
                if (vd->wdfd < 0)
                        (void)vsm_diag(vd,
                            "VSM_Status: Cannot open workdir");
                else
                        AZ(fstat(vd->wdfd, &vd->wdst));
        }

        if (vd->wdfd >= 0) {
                retval |= vsm_refresh_set(vd, vd->mgt);
                if (retval & VSM_MGT_RUNNING)
                        retval |= vsm_refresh_set(vd, vd->child);
        }
        return (retval);
}

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

int
VSM_Attach(struct vsm *vd, int progress)
{
        double t0;
        unsigned u;
        int i, n = 0;

        CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);

        if (vd->patience < 0)
                t0 = DBL_MAX;
        else
                t0 = VTIM_mono() + vd->patience;

        if (vd->wdname == NULL) {
                /* Use default (hostname) */
                i = VSM_Arg(vd, 'n', "");
                if (i < 0)
                        return (i);
                AN(vd->wdname);
        }

        AZ(vd->attached);
        while (!VSIG_int && !VSIG_term) {
                u = VSM_Status(vd);
                VSM_ResetError(vd);
                if (u & VSM_MGT_RUNNING) {
                        if (progress >= 0 && n > 4)
                                (void)write(progress, "\n", 1);
                        vd->attached = 1;
                        return (0);
                }
                if (t0 < VTIM_mono()) {
                        if (progress >= 0 && n > 4)
                                (void)write(progress, "\n", 1);
                        return (vsm_diag(vd,
                            "Could not get hold of varnishd, is it running?"));
                }
                if (progress >= 0 && !(++n % 4))
                        (void)write(progress, ".", 1);
                VTIM_sleep(.25);
        }
        return (vsm_diag(vd, "Attach interrupted"));
}

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

static struct vsm_seg *
vsm_findseg(const struct vsm *vd, const struct vsm_fantom *vf)
{
        struct vsm_set *vs;
        struct vsm_seg *vg;
        uint64_t x;

        x = VSM_PRIV_HIGH(vf->priv);
        if (x == vd->serial) {
                vg = (struct vsm_seg *)vf->priv2;
                if (!VALID_OBJ(vg, VSM_SEG_MAGIC) ||
                    vg->serial != VSM_PRIV_LOW(vf->priv))
                        WRONG("Corrupt fantom");
                return (vg);
        }

        x = VSM_PRIV_LOW(vf->priv);
        vs = vd->mgt;
        VTAILQ_FOREACH(vg, &vs->segs, list)
                if (vg->serial == x)
                        break;
        if (vg == NULL) {
                VTAILQ_FOREACH(vg, &vs->stale, list)
                        if (vg->serial == x)
                                break;
        }
        vs = vd->child;
        if (vg == NULL) {
                VTAILQ_FOREACH(vg, &vs->segs, list)
                        if (vg->serial == x)
                                break;
        }
        if (vg == NULL) {
                VTAILQ_FOREACH(vg, &vs->stale, list)
                        if (vg->serial == x)
                                break;
        }
        if (vg == NULL)
                return (NULL);

        /* Update the fantom with the new priv so that lookups will be
         * fast on the next call. Note that this casts away the const. */
        ((struct vsm_fantom *)TRUST_ME(vf))->priv =
            VSM_PRIV_MERGE(vg->serial, vd->serial);
        return (vg);
}

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

void
VSM__iter0(const struct vsm *vd, struct vsm_fantom *vf)
{

        CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
        AN(vf);

        AN(vd->attached);
        memset(vf, 0, sizeof *vf);
}

int
VSM__itern(struct vsm *vd, struct vsm_fantom *vf)
{
        struct vsm_seg *vg;

        CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
        AN(vd->attached);
        AN(vf);

        if (vf->priv == 0) {
                vg = VTAILQ_FIRST(&vd->mgt->segs);
                if (vg == NULL)
                        return (0);
        } else {
                vg = vsm_findseg(vd, vf);
                if (vg == NULL)
                        return (vsm_diag(vd, "VSM_FOREACH: inconsistency"));
                while (1) {
                        if (vg->set == vd->mgt && VTAILQ_NEXT(vg, list) == NULL)
                                vg = VTAILQ_FIRST(&vd->child->segs);
                        else
                                vg = VTAILQ_NEXT(vg, list);
                        if (vg == NULL)
                                return (0);
                        if (!(vg->flags & VSM_FLAG_CLUSTER))
                                break;
                }
        }
        memset(vf, 0, sizeof *vf);
        vf->priv = VSM_PRIV_MERGE(vg->serial, vd->serial);
        vf->priv2 = (uintptr_t)vg;
        vf->category = vg->av[4];
        vf->ident = vg->av[5];
        AN(vf->category);
        return (1);
}

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

int
VSM_Map(struct vsm *vd, struct vsm_fantom *vf)
{
        struct vsm_seg *vg, *vgc;
        size_t of, sz;
        int r;

        CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
        AN(vd->attached);
        AN(vf);
        vg = vsm_findseg(vd, vf);
        if (vg == NULL)
                return (vsm_diag(vd, "VSM_Map: bad fantom"));

        assert(vg->serial == VSM_PRIV_LOW(vf->priv));
        assert(vg->av[4] == vf->category);
        assert(vg->av[5] == vf->ident);

        if (vg->b != NULL) {
                assert(vg->refs > 0);
                AN(vg->e);
                vf->b = vg->b;
                vf->e = vg->e;
                vg->refs++;
                return (0);
        }

        assert(vg->refs == 0);

        vgc = vg->cluster;

        if (vgc == NULL) {
                r = vsm_mapseg(vd, vg);
                if (r)
                        return (r);
                vf->b = vg->b;
                vf->e = vg->e;

                vg->refs++;

                return (0);
        }

        CHECK_OBJ_NOTNULL(vgc, VSM_SEG_MAGIC);
        assert(vgc->flags & VSM_FLAG_CLUSTER);
        assert(vg->s == NULL);
        assert(vg->sz == 0);

        r = vsm_mapseg(vd, vgc);
        if (r)
                return (r);
        vgc->refs++;

        of = strtoul(vg->av[2], NULL, 10);
        sz = strtoul(vg->av[3], NULL, 10);
        assert(sz > 0);

        assert(vgc->sz >= of + sz);
        assert(vgc->s == vgc->b);
        vg->b = (char *)vgc->b + of;
        vg->e = (char *)vg->b + sz;

        vf->b = vg->b;
        vf->e = vg->e;

        vg->refs++;

        return (0);
}

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

int
VSM_Unmap(struct vsm *vd, struct vsm_fantom *vf)
{
        struct vsm_seg *vg;

        CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
        AN(vd->attached);
        AN(vf);
        AN(vf->b);
        vg = vsm_findseg(vd, vf);
        if (vg == NULL)
                return (vsm_diag(vd, "VSM_Unmap: bad fantom"));
        CHECK_OBJ_NOTNULL(vg, VSM_SEG_MAGIC);
        assert(vg->refs > 0);
        vg->refs--;
        vf->b = NULL;
        vf->e = NULL;
        if (vg->refs > 0)
                return (0);

        if (vg->cluster) {
                CHECK_OBJ_NOTNULL(vg->cluster, VSM_SEG_MAGIC);
                assert(vg->s == NULL);
                assert(vg->sz == 0);
                assert(vg->cluster->refs > 0);
                if (--vg->cluster->refs == 0) {
                        vsm_unmapseg(vg->cluster);
                        if (vg->cluster->flags & VSM_FLAG_STALE) {
                                AN(vg->flags & VSM_FLAG_STALE);
                                vsm_delseg(vg->cluster, 0);
                        }
                }
                vg->b = vg->e = NULL;
        } else {
                vsm_unmapseg(vg);
        }
        if (vg->flags & VSM_FLAG_STALE)
                vsm_delseg(vg, 0);
        return (0);
}

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

const struct vsm_valid *
VSM_StillValid(const struct vsm *vd, const struct vsm_fantom *vf)
{
        struct vsm_seg *vg;

        CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
        AN(vf);
        vg = vsm_findseg(vd, vf);
        if (vg == NULL || vg->flags & VSM_FLAG_STALE)
                return (VSM_invalid);
        return (VSM_valid);
}

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

int
VSM_Get(struct vsm *vd, struct vsm_fantom *vf,
    const char *category, const char *ident)
{

        CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
        AN(vd->attached);
        VSM_FOREACH(vf, vd) {
                if (strcmp(vf->category, category))
                        continue;
                if (ident != NULL && strcmp(vf->ident, ident))
                        continue;
                return (1);
        }
        memset(vf, 0, sizeof *vf);
        return (0);
}

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

char *
VSM_Dup(struct vsm *vd, const char *category, const char *ident)
{
        struct vsm_fantom vf;
        char *p = NULL;

        CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
        AN(vd->attached);
        VSM_FOREACH(&vf, vd) {
                if (strcmp(vf.category, category))
                        continue;
                if (ident != NULL && strcmp(vf.ident, ident))
                        continue;
                AZ(VSM_Map(vd, &vf));
                AN(vf.b);
                AN(vf.e);
                p = malloc((char*)vf.e - (char*)vf.b);
                AN(p);
                memcpy(p, vf.b, (char*)vf.e - (char*)vf.b);
                AZ(VSM_Unmap(vd, &vf));
                break;
        }
        return (p);
}

		varnish-cache/lib/libvarnishapi/vsm.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		* Author: Martin Blix Grydeland <martin@varnish-software.com>
7		*
8		* SPDX-License-Identifier: BSD-2-Clause
9		*
10		* Redistribution and use in source and binary forms, with or without
11		* modification, are permitted provided that the following conditions
12		* are met:
13		* 1. Redistributions of source code must retain the above copyright
14		* notice, this list of conditions and the following disclaimer.
15		* 2. Redistributions in binary form must reproduce the above copyright
16		* notice, this list of conditions and the following disclaimer in the
17		* documentation and/or other materials provided with the distribution.
18		*
19		* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
20		* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22		* ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
23		* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24		* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25		* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26		* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27		* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28		* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29		* SUCH DAMAGE.
30		*/
31
32		#include "config.h"
33
34		#include <sys/mman.h>
35		#include <sys/stat.h>
36
37		#include <fcntl.h>
38		#include <float.h>
39		#include <math.h>
40		#include <stdarg.h>
41		#include <stdint.h>
42		#include <stdio.h>
43		#include <stdlib.h>
44		#include <string.h>
45		#include <unistd.h>
46
47		#include "vdef.h"
48		#include "vas.h"
49		#include "miniobj.h"
50
51		#include "vav.h"
52		#include "vin.h"
53		#include "vlu.h"
54		#include "vsb.h"
55		#include "vsm_priv.h"
56		#include "vqueue.h"
57		#include "vtim.h"
58
59		#include "vapi/vsig.h"
60		#include "vapi/vsm.h"
61
62		#ifndef MAP_HASSEMAPHORE
63		# define MAP_HASSEMAPHORE 0 /* XXX Linux */
64		#endif
65
66		#ifndef MAP_NOSYNC
67		# define MAP_NOSYNC 0 /* XXX Linux */
68		#endif
69
70		const struct vsm_valid VSM_invalid[1] = {{"invalid"}};
71		const struct vsm_valid VSM_valid[1] = {{"valid"}};
72
73		static vlu_f vsm_vlu_func;
74
75		#define VSM_PRIV_SHIFT \
76		(sizeof (uint64_t) * 4)
77		#define VSM_PRIV_MASK \
78		((1ULL << VSM_PRIV_SHIFT) - 1)
79		#define VSM_PRIV_LOW(u) \
80		((uint64_t)(u) & VSM_PRIV_MASK)
81		#define VSM_PRIV_HIGH(u) \
82		(((uint64_t)(u) >> VSM_PRIV_SHIFT) & VSM_PRIV_MASK)
83		#define VSM_PRIV_MERGE(low, high) \
84		(VSM_PRIV_LOW(low) \| (VSM_PRIV_LOW(high) << VSM_PRIV_SHIFT))
85
86		/--------------------------------------------------------------------/
87
88		struct vsm_set;
89
90		struct vsm_seg {
91		unsigned magic;
92		#define VSM_SEG_MAGIC 0xeb6c6dfd
93		unsigned flags;
94		#define VSM_FLAG_MARKSCAN (1U<<1)
95		#define VSM_FLAG_STALE (1U<<2)
96		#define VSM_FLAG_CLUSTER (1U<<3)
97		VTAILQ_ENTRY(vsm_seg) list;
98		VTAILQ_ENTRY(vsm_seg) clist;
99		struct vsm_set *set;
100		struct vsm_seg *cluster;
101		char **av;
102		int refs;
103		void *s;
104		size_t sz;
105		void *b;
106		void *e;
107		uint64_t serial;
108		};
109
110		struct vsm_set {
111		unsigned magic;
112		#define VSM_SET_MAGIC 0xdee401b8
113		const char *dname;
114		struct vsm *vsm;
115		VTAILQ_HEAD(,vsm_seg) segs;
116		VTAILQ_HEAD(,vsm_seg) stale;
117		VTAILQ_HEAD(,vsm_seg) clusters;
118
119		int dfd;
120		struct stat dst;
121
122		int fd;
123		struct stat fst;
124
125		uintmax_t id1, id2;
126
127		// _.index reading state
128		struct vlu *vlu;
129		unsigned retval;
130		struct vsm_seg *vg;
131
132		unsigned flag_running;
133		unsigned flag_changed;
134		unsigned flag_restarted;
135		};
136
137		struct vsm {
138		unsigned magic;
139		#define VSM_MAGIC 0x6e3bd69b
140
141		struct vsb *diag;
142		uint64_t serial;
143
144		int wdfd;
145		struct stat wdst;
146		char *wdname;
147
148		struct vsm_set *mgt;
149		struct vsm_set *child;
150
151		int attached;
152		double patience;
153		};
154
155		/--------------------------------------------------------------------/
156
157		static int
158	1583	vsm_diag(struct vsm vd, const char fmt, ...)
159		{
160		va_list ap;
161
162	1583	CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
163	1583	AN(fmt);
164
165	1583	if (vd->diag == NULL)
166	1583	vd->diag = VSB_new_auto();
167	1583	AN(vd->diag);
168	1583	VSB_clear(vd->diag);
169	1583	va_start(ap, fmt);
170	1583	VSB_vprintf(vd->diag, fmt, ap);
171	1583	va_end(ap);
172	1583	AZ(VSB_finish(vd->diag));
173	1583	return (-1);
174		}
175
176		/--------------------------------------------------------------------/
177
178		static int
179	204542	vsm_mapseg(struct vsm vd, struct vsm_seg vg)
180		{
181		size_t of, off, sz, ps, len;
182		struct vsb *vsb;
183		int fd;
184
185	204542	CHECK_OBJ_NOTNULL(vg, VSM_SEG_MAGIC);
186
187	204542	if (vg->s != NULL)
188	4000	return (0);
189
190	200542	ps = getpagesize();
191
192	200542	of = strtoul(vg->av[2], NULL, 10);
193	200542	off = RDN2(of, ps);
194
195	200542	if (vg->flags & VSM_FLAG_CLUSTER)
196	3001	assert(of == 0);
197	200542	assert(vg->cluster == NULL);
198
199	200542	sz = strtoul(vg->av[3], NULL, 10);
200	200542	assert(sz > 0);
201	200542	assert(of >= off);
202	200542	len = RUP2((of - off) + sz, ps);
203
204	200542	vsb = VSB_new_auto();
205	200542	AN(vsb);
206	200542	VSB_printf(vsb, "%s/%s/%s", vd->wdname, vg->set->dname, vg->av[1]);
207	200542	AZ(VSB_finish(vsb));
208
209	200542	fd = open(VSB_data(vsb), O_RDONLY); // XXX: openat
210	200542	if (fd < 0) {
211	0	VSB_destroy(&vsb);
212	0	return (vsm_diag(vd, "Could not open segment"));
213		}
214
215	401084	vg->s = (void*)mmap(NULL, len,
216		PROT_READ,
217		MAP_HASSEMAPHORE \| MAP_NOSYNC \| MAP_SHARED,
218	200542	fd, (off_t)off);
219
220	200542	VSB_destroy(&vsb);
221
222	200542	closefd(&fd);
223	200542	if (vg->s == MAP_FAILED)
224	0	return (vsm_diag(vd, "Could not mmap segment"));
225
226	200542	vg->b = (char*)(vg->s) + of - off;
227	200542	vg->e = (char *)vg->b + sz;
228	200542	vg->sz = len;
229
230	200542	return (0);
231	204542	}
232
233		static void
234	177742	vsm_unmapseg(struct vsm_seg *vg)
235		{
236
237	177742	CHECK_OBJ_NOTNULL(vg, VSM_SEG_MAGIC);
238
239	177742	AN(vg->b);
240	177742	AN(vg->e);
241	177742	AZ(munmap(vg->s, vg->sz));
242	177742	vg->s = vg->b = vg->e = NULL;
243	177742	vg->sz = 0;
244	177742	}
245
246		/--------------------------------------------------------------------/
247
248		static void
249	2701958	vsm_delseg(struct vsm_seg *vg, int refsok)
250		{
251
252	2701958	CHECK_OBJ_NOTNULL(vg, VSM_SEG_MAGIC);
253
254	2701958	if (vg->set->vg == vg) {
255	285631	AZ(vg->flags & VSM_FLAG_STALE);
256	285631	vg->set->vg = VTAILQ_NEXT(vg, list);
257	285631	}
258
259	2701958	if (refsok && vg->refs) {
260	5912	AZ(vg->flags & VSM_FLAG_STALE);
261	5912	vg->flags \|= VSM_FLAG_STALE;
262	5912	VTAILQ_REMOVE(&vg->set->segs, vg, list);
263	5912	VTAILQ_INSERT_TAIL(&vg->set->stale, vg, list);
264	5912	return;
265		}
266
267	2696046	if (vg->s != NULL)
268	0	vsm_unmapseg(vg);
269
270	2696046	if (vg->flags & VSM_FLAG_CLUSTER) {
271	71240	vg->flags &= ~VSM_FLAG_CLUSTER;
272	71240	VTAILQ_REMOVE(&vg->set->clusters, vg, clist);
273	71240	}
274
275	2696046	if (vg->flags & VSM_FLAG_STALE)
276	5912	VTAILQ_REMOVE(&vg->set->stale, vg, list);
277		else
278	2690134	VTAILQ_REMOVE(&vg->set->segs, vg, list);
279	2696046	VAV_Free(vg->av);
280	2696046	FREE_OBJ(vg);
281	2701958	}
282
283		/--------------------------------------------------------------------/
284
285		static struct vsm_set *
286	170960	vsm_newset(const char *dirname)
287		{
288		struct vsm_set *vs;
289
290	170960	ALLOC_OBJ(vs, VSM_SET_MAGIC);
291	170960	AN(vs);
292	170960	VTAILQ_INIT(&vs->segs);
293	170960	VTAILQ_INIT(&vs->stale);
294	170960	VTAILQ_INIT(&vs->clusters);
295	170960	vs->dname = dirname;
296	170960	vs->dfd = vs->fd = -1;
297	170960	vs->vlu = VLU_New(vsm_vlu_func, vs, 0);
298	170960	AN(vs->vlu);
299	170960	return (vs);
300		}
301
302		static void
303	168880	vsm_delset(struct vsm_set **p)
304		{
305		struct vsm_set *vs;
306		struct vsm_seg *vg;
307
308	168880	TAKE_OBJ_NOTNULL(vs, p, VSM_SET_MAGIC);
309
310	168880	if (vs->fd >= 0)
311	102646	closefd(&vs->fd);
312	168880	if (vs->dfd >= 0)
313	138560	closefd(&vs->dfd);
314	168880	while ((vg = VTAILQ_FIRST(&vs->stale)) != NULL) {
315	0	AN(vg->flags & VSM_FLAG_STALE);
316	0	vsm_delseg(vg, 0);
317		}
318	2723140	while ((vg = VTAILQ_FIRST(&vs->segs)) != NULL) {
319	2554260	AZ(vg->flags & VSM_FLAG_STALE);
320	2554260	vsm_delseg(vg, 0);
321		}
322	168880	assert(VTAILQ_EMPTY(&vs->clusters));
323	168880	VLU_Destroy(&vs->vlu);
324	168880	FREE_OBJ(vs);
325	168880	}
326
327		static void
328	364904	vsm_wash_set(const struct vsm_set *vs, int all)
329		{
330		struct vsm_seg vg, vg2;
331
332	3044660	VTAILQ_FOREACH_SAFE(vg, &vs->segs, list, vg2) {
333	2679756	if (all \|\| (vg->flags & VSM_FLAG_MARKSCAN) == 0)
334	79985	vsm_delseg(vg, 1);
335	2679756	}
336	364904	}
337
338		/--------------------------------------------------------------------/
339
340		struct vsm *
341	85480	VSM_New(void)
342		{
343		struct vsm *vd;
344
345	85480	ALLOC_OBJ(vd, VSM_MAGIC);
346	85480	AN(vd);
347
348	85480	vd->mgt = vsm_newset(VSM_MGT_DIRNAME);
349	85480	vd->mgt->flag_running = VSM_MGT_RUNNING;
350	85480	vd->mgt->flag_changed = VSM_MGT_CHANGED;
351	85480	vd->mgt->flag_restarted = VSM_MGT_RESTARTED;
352
353	85480	vd->child = vsm_newset(VSM_CHILD_DIRNAME);
354	85480	vd->child->flag_running = VSM_WRK_RUNNING;
355	85480	vd->child->flag_changed = VSM_WRK_CHANGED;
356	85480	vd->child->flag_restarted = VSM_WRK_RESTARTED;
357
358	85480	vd->mgt->vsm = vd;
359	85480	vd->child->vsm = vd;
360	85480	vd->wdfd = -1;
361	85480	vd->patience = 5;
362	85480	return (vd);
363		}
364
365		/--------------------------------------------------------------------/
366
367		int
368	87080	VSM_Arg(struct vsm vd, char flag, const char arg)
369		{
370	87080	char *p = NULL;
371
372	87080	CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
373
374	87080	if (arg == NULL)
375	1520	return (1);
376	85560	switch (flag) {
377		case 't':
378	480	if (!strcasecmp(arg, "off")) {
379	0	vd->patience = -1;
380	0	} else {
381	480	vd->patience = strtod(arg, &p);
382	760	if ((p != NULL && *p != '\0') \|\|
383	280	!isfinite(vd->patience) \|\| vd->patience < 0)
384	560	return (vsm_diag(vd,
385	280	"-t: Invalid argument: %s", arg));
386		}
387	200	break;
388		case 'n':
389	85080	if (vd->wdname != NULL)
390	0	free(vd->wdname);
391	85080	vd->wdname = VIN_n_Arg(arg);
392	85080	if (vd->wdname == NULL)
393	0	return (vsm_diag(vd, "Invalid instance name: %s",
394	0	strerror(errno)));
395	85080	break;
396		default:
397	0	return (vsm_diag(vd, "Unknown VSM_Arg('%c')", flag));
398		}
399	85280	return (1);
400	87080	}
401
402		/--------------------------------------------------------------------/
403
404		void
405	84440	VSM_Destroy(struct vsm **vdp)
406		{
407		struct vsm *vd;
408
409	84440	TAKE_OBJ_NOTNULL(vd, vdp, VSM_MAGIC);
410
411	84440	VSM_ResetError(vd);
412	84440	REPLACE(vd->wdname, NULL);
413	84440	if (vd->diag != NULL)
414	0	VSB_destroy(&vd->diag);
415	84440	if (vd->wdfd >= 0)
416	84360	closefd(&vd->wdfd);
417	84440	vsm_delset(&vd->mgt);
418	84440	vsm_delset(&vd->child);
419	84440	FREE_OBJ(vd);
420	84440	}
421
422		/--------------------------------------------------------------------/
423
424		const char *
425	400	VSM_Error(const struct vsm *vd)
426		{
427
428	400	CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
429
430	400	if (vd->diag == NULL)
431	0	return ("No VSM error");
432		else
433	400	return (VSB_data(vd->diag));
434	400	}
435
436		/--------------------------------------------------------------------/
437
438		void
439	170663	VSM_ResetError(struct vsm *vd)
440		{
441
442	170663	CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
443
444	170663	if (vd->diag == NULL)
445	169400	return;
446	1263	VSB_destroy(&vd->diag);
447	170663	}
448
449		/*--------------------------------------------------------------------
450		*/
451
452		static int
453	4826286	vsm_cmp_av(char * const a1, char const *a2)
454		{
455
456	5089346	while (1) {
457	5089346	if (a1 == NULL && a2 == NULL)
458	63631	return (0);
459	5025715	if (a1 == NULL \|\| a2 == NULL)
460	0	return (1);
461	5025715	if (strcmp(a1, a2))
462	4762655	return (1);
463	263060	a1++;
464	263060	a2++;
465		}
466	4826286	}
467
468		static struct vsm_seg *
469	78400	vsm_findcluster(const struct vsm_set vs, const char cnam)
470		{
471		struct vsm_seg *vg;
472	78400	AN(vs);
473	78400	AN(cnam);
474	109219	VTAILQ_FOREACH(vg, &vs->clusters, clist) {
475	109219	AN(vg->av[1]);
476	109219	if (!strcmp(cnam, vg->av[1]))
477	78400	return (vg);
478	30819	}
479	0	return (NULL);
480	78400	}
481
482		static int
483	141863	vsm_vlu_hash(struct vsm vd, struct vsm_set vs, const char *line)
484		{
485		int i;
486		uintmax_t id1, id2;
487
488	141863	(void)vd;
489
490	141863	i = sscanf(line, "# %ju %ju", &id1, &id2);
491	141863	if (i != 2) {
492	0	vs->retval \|= VSM_MGT_RESTARTED \| VSM_MGT_CHANGED;
493	0	return (0);
494		}
495	141863	vs->retval \|= VSM_MGT_RUNNING;
496	141863	if (id1 != vs->id1 \|\| id2 != vs->id2) {
497	141798	vs->retval \|= VSM_MGT_RESTARTED \| VSM_MGT_CHANGED;
498	141798	vs->id1 = id1;
499	141798	vs->id2 = id2;